@Override public void addError(final String msg, final ASTNode expr) { sourceUnit.addError(new IncorrectTypeHintException(mn, msg, usage.getLineNumber(), usage.getColumnNumber())); } };
private void throwSuperError(final ASTNode node) { unit.addError(new SyntaxException("Call to super is not allowed in a trait", node.getLineNumber(), node.getColumnNumber())); }
private void checkInnerClasses(final ClassNode cNode) { Iterator<InnerClassNode> it = cNode.getInnerClasses(); while (it.hasNext()) { InnerClassNode origin = it.next(); if ((origin.getModifiers() & ACC_STATIC) == 0) { unit.addError(new SyntaxException("Cannot have non-static inner class inside a trait ("+origin.getName()+")", origin.getLineNumber(), origin.getColumnNumber())); } } }
private static void checkTraitAllowed(final ClassNode bottomTrait, final SourceUnit unit) { ClassNode superClass = bottomTrait.getSuperClass(); if (superClass==null || ClassHelper.OBJECT_TYPE.equals(superClass)) return; if (!Traits.isTrait(superClass)) { unit.addError(new SyntaxException("A trait can only inherit from another trait", superClass.getLineNumber(), superClass.getColumnNumber())); } }
sourceUnit.addError(new IncorrectTypeHintException(mn, e, usage.getLineNumber(), usage.getColumnNumber()));
private Expression transformPostfixExpression(final PostfixExpression exp) { if (isInternalFieldAccess(exp.getExpression())) { Token operation = exp.getOperation(); sourceUnit.addError(new SyntaxException("Postfix expressions on trait fields/properties are not supported in traits.", operation.getStartLine(), operation.getStartColumn())); return exp; } else { return super.transform(exp); } }
private Expression transformPrefixExpression(final PrefixExpression exp) { if (isInternalFieldAccess(exp.getExpression())) { Token operation = exp.getOperation(); sourceUnit.addError(new SyntaxException("Prefix expressions on trait fields/properties are not supported in traits.", operation.getStartLine(), operation.getStartColumn())); return exp; } else { return super.transform(exp); } }
public List<ClassNode[]> getClosureSignatures(final MethodNode node, final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final String[] options, final ASTNode usage) { Options opt; try { opt = Options.parse(node, usage, options); } catch (IncorrectTypeHintException e) { sourceUnit.addError(e); return Collections.emptyList(); } GenericsType[] genericsTypes = node.getParameters()[opt.parameterIndex].getOriginType().getGenericsTypes(); if (genericsTypes==null) { // would happen if you have a raw Map type for example genericsTypes = new GenericsType[] { new GenericsType(ClassHelper.OBJECT_TYPE), new GenericsType(ClassHelper.OBJECT_TYPE) }; } ClassNode[] firstSig; ClassNode[] secondSig; ClassNode mapEntry = MAPENTRY_TYPE.getPlainNodeReference(); mapEntry.setGenericsTypes(genericsTypes); if (opt.generateIndex) { firstSig = new ClassNode[] {genericsTypes[0].getType(), genericsTypes[1].getType(), ClassHelper.int_TYPE}; secondSig = new ClassNode[] {mapEntry, ClassHelper.int_TYPE}; } else { firstSig = new ClassNode[] {genericsTypes[0].getType(), genericsTypes[1].getType()}; secondSig = new ClassNode[] {mapEntry}; } return Arrays.asList(firstSig, secondSig); }
private void checkAndAddCannotCallPrivateMethodError(MethodNode target, Expression receiver, ClassNode classNode, ClassNode declaringClass) { if (declaringClass != classNode) { controller.getSourceUnit().addError(new SyntaxException("Cannot call private method " + (target.isStatic() ? "static " : "") + declaringClass.toString(false) + "#" + target.getName() + " from class " + classNode.toString(false), receiver.getLineNumber(), receiver.getColumnNumber(), receiver.getLastLineNumber(), receiver.getLastColumnNumber())); } }
public void visit(ASTNode[] nodes, SourceUnit source) { AnnotationNode annotationInformation = (AnnotationNode) nodes[0]; Map<String,Expression> members = annotationInformation.getMembers(); Expression extensions = members.get("extensions"); AnnotatedNode node = (AnnotatedNode) nodes[1]; StaticTypeCheckingVisitor visitor = null; if (node instanceof ClassNode) { ClassNode classNode = (ClassNode) node; visitor = newVisitor(source, classNode); visitor.setCompilationUnit(compilationUnit); addTypeCheckingExtensions(visitor, extensions); visitor.initialize(); visitor.visitClass(classNode); } else if (node instanceof MethodNode) { MethodNode methodNode = (MethodNode) node; visitor = newVisitor(source, methodNode.getDeclaringClass()); visitor.setCompilationUnit(compilationUnit); addTypeCheckingExtensions(visitor, extensions); visitor.setMethodsToBeVisited(Collections.singleton(methodNode)); visitor.initialize(); visitor.visitMethod(methodNode); } else { source.addError(new SyntaxException(STATIC_ERROR_PREFIX + "Unimplemented node type", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber())); } if (visitor != null) { visitor.performSecondPass(); } }
if (declared) { if (!methodNode.isSynthetic() && (methodNode.isProtected() || methodNode.getModifiers()==0)) { unit.addError(new SyntaxException("Cannot have protected/package private method in a trait (" + cNode.getName() + "#" + methodNode.getTypeDescriptor() + ")", methodNode.getLineNumber(), methodNode.getColumnNumber())); return null;
if (!forwarder.isStatic() && existingMethod.isStatic()) { unit.addError(createException(trait, targetNode, forwarder, existingMethod)); return;
visitor.visitMethod(methodNode); } else { source.addError(new SyntaxException(STATIC_ERROR_PREFIX + "Unimplemented node type", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()));
ConstructorNode sameHashNode = sortedConstructors.put(hash, constructor); if (sameHashNode!=null) { controller.getSourceUnit().addError( new SyntaxException("Unable to compile class "+controller.getClassNode().getName() + " due to hash collision in constructors", call.getLineNumber(), call.getColumnNumber()));
args = newArgs; } else { controller.getSourceUnit().addError(new SyntaxException("Cannot call private constructor for " + declaringClass.toString(false) + " from class " + classNode.toString(false), call.getLineNumber(), call.getColumnNumber(), mn.getLastLineNumber(), call.getLastColumnNumber()));
final Set<String> knownFields) { if (field.isProtected()) { unit.addError(new SyntaxException("Cannot have protected field in a trait (" + trait.getName() + "#" + field.getName() + ")", field.getLineNumber(), field.getColumnNumber())); return;
controller.getSourceUnit().addError( new SyntaxException("Access to "+ (receiver instanceof ClassExpression ?receiver.getType():receiverType).toString(false)
&& StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(node,target.getDeclaringClass())) { ASTNode src = receiver==null?args:receiver; controller.getSourceUnit().addError( new SyntaxException("Method " + target.getName() + " is protected in " + target.getDeclaringClass().toString(false), src.getLineNumber(), src.getColumnNumber(), src.getLastLineNumber(), src.getLastColumnNumber()));
@Override public void visitListExpression(final ListExpression exp) { if (exp.getExpressions().size() > 250) { sourceUnit.addError(new SyntaxException("List expressions can only contain up to 250 elements", exp.getLineNumber(), exp.getColumnNumber())); } else { makeNode("list", new Runnable() { @Override public void run() { visit(exp.getExpressions()); } }); } }