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)

• protected static String formatArgumentList(ClassNode[] nodes)

• protected ClassNode[] getArgumentTypes(ArgumentListExpression args)

• protected DelegationMetadata getDelegationMetadata(ClosureExpression expression)

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

• 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)

• @Override public void visitAttributeExpression(AttributeExpression expression)

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

• @Override} public void visitBitwiseNegationExpression(BitwiseNegationExpression expression)

• @Overrideif (temporaryTypesForExpression != null && !temporaryTypesForExpression.isEmpty()) { public void visitCaseStatement(CaseStatement statement)

• @Overrideif (STRING_TYPE.equals(initialType) 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)

• @Overrideprotected void storeType(Expression exp, ClassNode cn) { 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)

• @Override// a nice error message to the user 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)

• @Overrideif (var.isClosureSharedVariable() && cn!=null) { public void visitSwitch(SwitchStatement statement)

• @Override} public void visitTernaryExpression(TernaryExpression expression)

• @Override} 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)