Field Detail

• protected static final ClassNode CLOSUREPARAMS_CLASSNODE

• public static final MethodNode CLOSURE_CALL_NO_ARG

• public static final MethodNode CLOSURE_CALL_ONE_ARG

• public static final MethodNode CLOSURE_CALL_VARGS

• protected static final Expression CURRENT_SIGNATURE_PROTOCOL

• protected static final int CURRENT_SIGNATURE_PROTOCOL_VERSION

• protected static final ClassNode DELEGATES_TO

• protected static final ClassNode DELEGATES_TO_TARGET

• protected static final ClassNode DGM_CLASSNODE

• protected static final List EMPTY_METHODNODE_LIST

• protected static final Object ERROR_COLLECTOR

• public static final Statement GENERATED_EMPTY_STATEMENT

• protected static final MethodNode GET_DELEGATE

• protected static final MethodNode GET_OWNER

• protected static final MethodNode GET_THISOBJECT

• protected static final ClassNode ITERABLE_TYPE

• protected static final ClassNode LINKEDHASHMAP_CLASSNODE

• protected static final ClassNode TYPECHECKED_CLASSNODE

• protected static final ClassNode[] TYPECHECKING_ANNOTATIONS

• protected static final ClassNode TYPECHECKING_INFO_NODE

• protected DefaultTypeCheckingExtension extension

• protected final ReturnAdder returnAdder

• protected final ReturnStatementListener returnListener

• protected TypeCheckingContext typeCheckingContext

Constructor Detail

• public StaticTypeCheckingVisitor(SourceUnit source, ClassNode cn)

Method Detail

• protected void addAmbiguousErrorMessage(List foundMethods, String name, ClassNode[] args, Expression expr)

• protected void addAssignmentError(ClassNode leftType, ClassNode rightType, Expression assignmentExpression)

• protected void addCategoryMethodCallError(Expression call)

• protected void addClosureReturnType(ClassNode returnType)

• @Override protected void addError(String msg, ASTNode expr)

• protected void addNoMatchingMethodError(ClassNode receiver, String name, ClassNode[] args, Expression call)

• protected void addReceivers(List receivers, Collection owners, boolean implicitThis)

• protected void addStaticTypeError(String msg, ASTNode expr)

• public void addTypeCheckingExtension(TypeCheckingExtension extension)

• protected void addTypeCheckingInfoAnnotation(MethodNode node)

• protected void addUnsupportedPreOrPostfixExpressionError(Expression expression)

• protected boolean areCategoryMethodCalls(List foundMethods, String name, ClassNode[] args)

• protected boolean checkCast(ClassNode targetType, Expression source)

• protected void checkClosureParameters(Expression callArguments, ClassNode receiver)

  visit a method call target, to infer the type. Don't report errors right away, that will be done by a later visitMethod call

• protected void checkForbiddenSpreadArgument(ArgumentListExpression argumentList)

• protected void checkGroovyConstructorMap(Expression receiver, ClassNode receiverType, MapExpression mapExpression)

  Checks that a constructor style expression is valid regarding the number of arguments and the argument types.

  deprecated:

  use checkGroovyStyleConstructor(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.ast.ClassNode[], org.codehaus.groovy.ast.ASTNode) )}

  Parameters:

  node - the class node for which we will try to find a matching constructor

  arguments - the constructor arguments

• @Deprecated} protected void checkGroovyStyleConstructor(ClassNode node, ClassNode[] arguments)

  A helper method which determines which receiver class should be used in error messages when a field or attribute is not found. The returned type class depends on whether we have temporary type information availble (due to instanceof checks) and whether there is a single candidate in that case.

  Parameters:

  expr - the expression for which an unknown field has been found

  type - the type of the expression (used as fallback type)

  Returns:

  if temporary information is available and there's only one type, returns the temporary type class otherwise falls back to the provided type class.

• protected MethodNode checkGroovyStyleConstructor(ClassNode node, ClassNode[] arguments, ASTNode source)

• protected ClassNode checkReturnType(ReturnStatement statement)

• protected void collectAllInterfaceMethodsByName(ClassNode receiver, String name, List methods)

• protected boolean existsProperty(PropertyExpression pexp, boolean checkForReadOnly)

• protected boolean existsProperty(PropertyExpression pexp, boolean readMode, ClassCodeVisitorSupport visitor)

• public static String extractPropertyNameFromMethodName(String prefix, String methodName)

  Stores the inferred return type of a closure or a method. We are using a separate key to store inferred return type because the inferred type of a closure is Closure, which is different from the inferred type of the code of the closure.

  Parameters:

  node - a ClosureExpression or a MethodNode

  type - the inferred return type of the code

  Returns:

  the old value of the inferred type

• protected Object extractTemporaryTypeInfoKey(Expression expression)

• protected static ClassNode[] extractTypesFromParameters(Parameter[] parameters)

• protected ClassNode findCurrentInstanceOfClass(Expression expr, ClassNode type)

• protected List findMethod(ClassNode receiver, String name, ClassNode... args)

• protected MethodNode findMethodOrFail(Expression expr, ClassNode receiver, String name, ClassNode... args)

• protected List findMethodsWithGenerated(ClassNode receiver, String name)

  Given a method name and a prefix, returns the name of the property that should be looked up, following the java beans rules. For example, "getName" would return "name", while "getFullName" would return "fullName". If the prefix is not found, returns null.

  Parameters:

  prefix - the method name prefix ("get", "is", "set", ...)

  methodName - the method name

  Returns:

  a property name if the prefix is found and the method matches the java beans rules, null otherwise

• protected static String formatArgumentList(ClassNode[] nodes)

• protected ClassNode[] getArgumentTypes(ArgumentListExpression args)

• protected DelegationMetadata getDelegationMetadata(ClosureExpression expression)

• protected static ClassNode getGroupOperationResultType(ClassNode a, ClassNode b)

  This method returns the list of methods named against the supplied parameter that are defined on the specified receiver, but it will also add "non existing" methods that will be generated afterwards by the compiler, for example if a method is using default values and that the specified class node isn't compiled yet.

  Parameters:

  receiver - the receiver where to find methods

  name - the name of the methods to return

  Returns:

  the methods that are defined on the receiver completed with stubs for future methods

• protected ClassNode getInferredReturnType(ASTNode exp)

• protected ClassNode getInferredReturnTypeFromWithClosureArgument(Expression callArguments)

• protected ClassNode getOriginalDeclarationType(Expression lhs)

• protected ClassNode getResultType(ClassNode left, int op, ClassNode right, BinaryExpression expr)

• protected SourceUnit getSourceUnit()

• protected List getTemporaryTypesForExpression(Expression objectExpression)

• protected ClassNode getType(ASTNode exp)

• protected ClassNode[] getTypeCheckingAnnotations()

• public TypeCheckingContext getTypeCheckingContext()

  Returns the current type checking context. The context is used internally by the type checker during type checking to store various state data.

  Returns:

  the type checking context

• protected static boolean hasRHSIncompleteGenericTypeInfo(ClassNode inferredRightExpressionType)

• @Deprecated} else { protected StaticTypeCheckingVisitor.SetterInfo hasSetter(PropertyExpression pexp)

• protected void inferClosureParameterTypes(ClassNode receiver, Expression arguments, ClosureExpression expression, Parameter param, MethodNode selectedMethod)

• protected ClassNode inferComponentType(ClassNode containerType, ClassNode indexType)

• protected void inferDiamondType(ConstructorCallExpression cce, ClassNode lType)

• protected ClassNode inferListExpressionType(ListExpression list)

• public static ClassNode inferLoopElementType(ClassNode collectionType)

• protected ClassNode inferMapExpressionType(MapExpression map)

• protected ClassNode inferReturnTypeGenerics(ClassNode receiver, MethodNode method, Expression arguments)

• public void initialize()

• protected static boolean isClassInnerClassOrEqualTo(ClassNode toBeChecked, ClassNode start)

• protected boolean isClosureCall(String name, Expression objectExpression, Expression arguments)

• protected static boolean isNullConstant(Expression expression)

• protected boolean isSecondPassNeededForControlStructure(Map varOrigType, Map oldTracker)

• public boolean isSkipMode(AnnotatedNode node)

• protected boolean isSkippedInnerClass(AnnotatedNode node)

  Test if a node is an inner class node, and if it is, then checks if the enclosing method is skipped.

  Parameters:

  node

  Returns:

  true if the inner class node should be skipped

• protected List makeOwnerList(Expression objectExpression)

• public void performSecondPass()

• protected Map popAssignmentTracking(Map oldTracker)

• protected static String prettyPrintMethodList(List nodes)

• protected Map pushAssignmentTracking()

• protected void pushInstanceOfTypeInfo(Expression objectOfInstanceOf, Expression typeExpression)

  Stores information about types when [objectOfInstanceof instanceof typeExpression] is visited

  Parameters:

  objectOfInstanceOf - the expression which must be checked against instanceof

  typeExpression - the expression which represents the target type

• protected void restoreVariableExpressionMetadata(Map typesBeforeVisit)

• protected void saveVariableExpressionMetadata(Set closureSharedExpressions, Map typesBeforeVisit)

• public void setCompilationUnit(CompilationUnit cu)

• public void setMethodsToBeVisited(Set methodsToBeVisited)

• protected boolean shouldSkipClassNode(ClassNode node)

• protected boolean shouldSkipMethodNode(MethodNode node)

• protected void silentlyVisitMethodNode(MethodNode directMethodCallCandidate)

• protected void startMethodInference(MethodNode node, ErrorCollector collector)

• protected ClassNode storeInferredReturnType(ASTNode node, ClassNode type)

  This method will convert a closure type to the appropriate SAM type, which will be used to infer return type generics.

  Parameters:

  closureType - the inferred type of a closure (Closure<ClosureReturnType>)

  samType - the type into which the closure is coerced into

  Returns:

  same SAM type, but completed with information from the closure node

• protected void storeInferredTypeForPropertyExpression(PropertyExpression pexp, ClassNode flatInferredType)

• protected void storeTargetMethod(Expression call, MethodNode directMethodCallCandidate)

• protected void storeType(Expression exp, ClassNode cn)

• protected void typeCheckAssignment(BinaryExpression assignmentExpression, Expression leftExpression, ClassNode leftExpressionType, Expression rightExpression, ClassNode inferredRightExpressionType)

• protected void typeCheckClosureCall(Expression callArguments, ClassNode[] args, Parameter[] parameters)

• protected MethodNode typeCheckMapConstructor(ConstructorCallExpression call, ClassNode receiver, Expression arguments)

• protected boolean typeCheckMethodsWithGenericsOrFail(ClassNode receiver, ClassNode[] arguments, MethodNode candidateMethod, Expression location)

  Returns a wrapped type if, and only if, the provided class node is a primitive type. This method differs from ClassHelper#getWrapper(org.codehaus.groovy.ast.ClassNode) as it will return the same instance if the provided type is not a generic type.

  Parameters:

  type

  Returns:

  the wrapped type

• @Override public void visitAttributeExpression(AttributeExpression expression)

• @OverrideleftExpression.visit(this); public void visitBinaryExpression(BinaryExpression expression)

• @Override} public void visitBitwiseNegationExpression(BitwiseNegationExpression expression)

• @Override// in that case, the INFERRED_TYPE corresponds to the current inferred type, while public void visitCaseStatement(CaseStatement statement)

• @Overrideif (expr.getRightExpression() instanceof ListExpression) { public void visitCastExpression(CastExpression expression)

• @Overrideif (shouldSkipClassNode(node)) return; public void visitClass(ClassNode node)

• @Override} public void visitClassExpression(ClassExpression expression)

• @Override} public void visitClosureExpression(ClosureExpression expression)

• @Overridepublic void visitClosureExpression(final ClosureExpression expression) { public void visitConstructorCallExpression(ConstructorCallExpression call)

• @Override// bean-style constructor protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor)

• @OverrideClassNode intf = GenericsUtils.parameterizeType(collectionType, ITERABLE_TYPE); public void visitField(FieldNode node)

  Given a loop collection type, returns the inferred type of the loop element. Used, for example, to infer the element type of a (for e in list) loop.

  Parameters:

  collectionType - the type of the collection

  Returns:

  the inferred component type

• @Override} public void visitForLoop(ForStatement forLoop)

• @Overridefinal ClassNode typeOfTrue = getType(trueExpression); public void visitIfElse(IfStatement ifElse)

• @Overrideif (extension.beforeMethodCall(call)) { public void visitMethod(MethodNode node)

• protected void visitMethodCallArguments(ClassNode receiver, ArgumentListExpression arguments, boolean visitClosures, MethodNode selectedMethod)

• @OverridenbOfArgs = 0; public void visitMethodCallExpression(MethodCallExpression call)

• @Override} else { public void visitPostfixExpression(PostfixExpression expression)

• @Overrideprotected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { public void visitPrefixExpression(PrefixExpression expression)

• @Override} public void visitPropertyExpression(PropertyExpression pexp)

• @OverriderangeType.setGenericsTypes(new GenericsType[] { new GenericsType(WideningCategories.lowestUpperBound(fromType, toType))}); public void visitRangeExpression(RangeExpression expression)

• @Override} public void visitReturnStatement(ReturnStatement statement)

• @OverrideaddStaticTypeError("Unexpected number of parameters for a with call", argList); public void visitStaticMethodCallExpression(StaticMethodCallExpression call)

• @OverridestoreType(exp, getOriginalDeclarationType(exp)); public void visitSwitch(SwitchStatement statement)

• @Overrideif (isOperationInGroup(op)) { public void visitTernaryExpression(TernaryExpression expression)

• @Overridereturn getGroupOperationResultType(leftRedirect, rightRedirect); public void visitTryCatchFinally(TryCatchStatement statement)

• @Override} else if (typeRe == ArrayList_TYPE) { public void visitUnaryMinusExpression(UnaryMinusExpression expression)

• @Overrideprivate void negativeOrPositiveUnary(Expression expression, String name) { public void visitUnaryPlusExpression(UnaryPlusExpression expression)

• @Override public void visitVariableExpression(VariableExpression vexp)

• @OverrideMethodNode node = findMethodOrFail(new VariableExpression("_dummy_", exprType), exprType, name); public void visitWhileLoop(WhileStatement loop)

• protected static ClassNode wrapTypeIfNecessary(ClassNode type)