private void checkClassForOverwritingFinal(ClassNode cn) {
   ClassNode superCN = cn.getSuperClass();
   if (superCN == null) return;
   if (!isFinal(superCN.getModifiers())) return;
   StringBuilder msg = new StringBuilder();
   msg.append("You are not allowed to overwrite the final ");
   msg.append(getDescription(superCN));
   msg.append(".");
   addError(msg.toString(), cn);
 }
        public void call(SourceUnit source) throws CompilationFailedException {
          List<ClassNode> classes = source.ast.getClasses();
          for (ClassNode node : classes) {
            CompileUnit cu = node.getCompileUnit();
            for (Iterator iter = cu.iterateClassNodeToCompile(); iter.hasNext(); ) {
              String name = (String) iter.next();
              SourceUnit su = ast.getScriptSourceLocation(name);
              List<ClassNode> classesInSourceUnit = su.ast.getClasses();
              StringBuilder message = new StringBuilder();
              message
                  .append("Compilation incomplete: expected to find the class ")
                  .append(name)
                  .append(" in ")
                  .append(su.getName());
              if (classesInSourceUnit.isEmpty()) {
                message.append(", but the file seems not to contain any classes");
              } else {
                message.append(", but the file contains the classes: ");
                boolean first = true;
                for (ClassNode cn : classesInSourceUnit) {
                  if (!first) {
                    message.append(", ");
                  } else {
                    first = false;
                  }
                  message.append(cn.getName());
                }
              }

              getErrorCollector()
                  .addErrorAndContinue(new SimpleMessage(message.toString(), CompilationUnit.this));
              iter.remove();
            }
          }
        }
 private String getAnnotationValue(Object memberValue) {
   String val = "null";
   if (memberValue instanceof ListExpression) {
     StringBuilder sb = new StringBuilder("{");
     boolean first = true;
     ListExpression le = (ListExpression) memberValue;
     for (Expression e : le.getExpressions()) {
       if (first) first = false;
       else sb.append(",");
       sb.append(getAnnotationValue(e));
     }
     sb.append("}");
     val = sb.toString();
   } else if (memberValue instanceof ConstantExpression) {
     ConstantExpression ce = (ConstantExpression) memberValue;
     Object constValue = ce.getValue();
     if (constValue instanceof AnnotationNode) {
       StringWriter writer = new StringWriter();
       PrintWriter out = new PrintWriter(writer);
       printAnnotation(out, (AnnotationNode) constValue);
       val = writer.toString();
     } else if (constValue instanceof Number || constValue instanceof Boolean)
       val = constValue.toString();
     else val = "\"" + escapeSpecialChars(constValue.toString()) + "\"";
   } else if (memberValue instanceof PropertyExpression
       || memberValue instanceof VariableExpression) {
     // assume must be static class field or enum value or class that Java can resolve
     val = ((Expression) memberValue).getText();
   } else if (memberValue instanceof ClosureExpression) {
     // annotation closure; replaced with this specific class literal to cover the
     // case where annotation type uses Class<? extends Closure> for the closure's type
     val = "groovy.lang.Closure.class";
   } else if (memberValue instanceof ClassExpression) {
     val = ((Expression) memberValue).getText() + ".class";
   }
   return val;
 }
 private void addInvalidUseOfFinalError(
     MethodNode method, Parameter[] parameters, ClassNode superCN) {
   StringBuilder msg = new StringBuilder();
   msg.append("You are not allowed to override the final method ").append(method.getName());
   msg.append("(");
   boolean needsComma = false;
   for (Parameter parameter : parameters) {
     if (needsComma) {
       msg.append(",");
     } else {
       needsComma = true;
     }
     msg.append(parameter.getType());
   }
   msg.append(") from ").append(getDescription(superCN));
   msg.append(".");
   addError(msg.toString(), method);
 }
  private void declare(Variable var, ASTNode expr) {
    String scopeType = "scope";
    String variableType = "variable";

    if (expr.getClass() == FieldNode.class) {
      scopeType = "class";
      variableType = "field";
    } else if (expr.getClass() == PropertyNode.class) {
      scopeType = "class";
      variableType = "property";
    }

    StringBuilder msg = new StringBuilder();
    msg.append("The current ").append(scopeType);
    msg.append(" already contains a ").append(variableType);
    msg.append(" of the name ").append(var.getName());

    if (currentScope.getDeclaredVariable(var.getName()) != null) {
      addError(msg.toString(), expr);
      return;
    }

    for (VariableScope scope = currentScope.getParent(); scope != null; scope = scope.getParent()) {
      // if we are in a class and no variable is declared until
      // now, then we can break the loop, because we are allowed
      // to declare a variable of the same name as a class member
      if (scope.getClassScope() != null) break;

      if (scope.getDeclaredVariable(var.getName()) != null) {
        // variable already declared
        addError(msg.toString(), expr);
        break;
      }
    }
    // declare the variable even if there was an error to allow more checks
    currentScope.putDeclaredVariable(var);
  }
 private void addWeakerAccessError(
     ClassNode cn, MethodNode method, Parameter[] parameters, MethodNode superMethod) {
   StringBuilder msg = new StringBuilder();
   msg.append(method.getName());
   msg.append("(");
   boolean needsComma = false;
   for (Parameter parameter : parameters) {
     if (needsComma) {
       msg.append(",");
     } else {
       needsComma = true;
     }
     msg.append(parameter.getType());
   }
   msg.append(") in ");
   msg.append(cn.getName());
   msg.append(" cannot override ");
   msg.append(superMethod.getName());
   msg.append(" in ");
   msg.append(superMethod.getDeclaringClass().getName());
   msg.append("; attempting to assign weaker access privileges; was ");
   msg.append(superMethod.isPublic() ? "public" : "protected");
   addError(msg.toString(), method);
 }
 private void throwExceptionForNoStackElement(int size, ClassNode targetType, boolean coerce) {
   if (size > 0) return;
   StringBuilder sb = new StringBuilder();
   sb.append("Internal compiler error while compiling ")
       .append(controller.getSourceUnit().getName())
       .append("\n");
   MethodNode methodNode = controller.getMethodNode();
   if (methodNode != null) {
     sb.append("Method: ");
     sb.append(methodNode);
     sb.append("\n");
   }
   ConstructorNode constructorNode = controller.getConstructorNode();
   if (constructorNode != null) {
     sb.append("Constructor: ");
     sb.append(methodNode);
     sb.append("\n");
   }
   sb.append("Line ").append(controller.getLineNumber()).append(",");
   sb.append(" expecting ")
       .append(coerce ? "coercion" : "casting")
       .append(" to ")
       .append(targetType.toString(false));
   sb.append(" but operand stack is empty");
   throw new ArrayIndexOutOfBoundsException(sb.toString());
 }