Package org.codehaus.groovy.transform.stc

# Class StaticTypeCheckingVisitor

java.lang.Object
org.codehaus.groovy.ast.CodeVisitorSupport
org.codehaus.groovy.ast.ClassCodeVisitorSupport
org.codehaus.groovy.transform.stc.StaticTypeCheckingVisitor

All Implemented Interfaces:
  `GroovyClassVisitor`, `GroovyCodeVisitor`, `ErrorCollecting`

Direct Known Subclasses:
  `StaticCompilationVisitor`

public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport
The main class code visitor responsible for static type checking. It will perform various inspections like checking assignment types, type inference, ... Eventually, class nodes may be annotated with inferred type information.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static class`
  `StaticTypeCheckingVisitor.SignatureCodecFactory`
  Creates signature codecs for serialized type checking metadata.
  `protected class`
  `StaticTypeCheckingVisitor.VariableExpressionTypeMemoizer`
  Memoizes inferred variable types so they can be restored after temporary rewrites.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected static final ClassNode`
  `CHAR_SEQUENCE_TYPE`
  Cached `CharSequence` type (GROOVY-9848: membership operator dispatch).
  `static final MethodNode`
  `CLOSURE_CALL_NO_ARG`
  Cached zero-argument `Closure#call()` method.
  `static final MethodNode`
  `CLOSURE_CALL_ONE_ARG`
  Cached single-argument `Closure#call(Object)` method.
  `static final MethodNode`
  `CLOSURE_CALL_VARGS`
  Cached varargs `Closure#call(Object[])` method.
  `protected static final ClassNode`
  `CLOSUREPARAMS_CLASSNODE`
  Cached `ClosureParams` annotation type.
  `protected static final Expression`
  `CURRENT_SIGNATURE_PROTOCOL`
  Constant expression for the current signature protocol version.
  `protected static final int`
  `CURRENT_SIGNATURE_PROTOCOL_VERSION`
  Current encoding protocol for stored type-checking signatures.
  `protected FieldNode`
  `currentField`
  Field currently being visited.
  `protected PropertyNode`
  `currentProperty`
  Property currently being visited.
  `protected static final ClassNode`
  `DELEGATES_TO`
  Cached `DelegatesTo` annotation type.
  `protected static final ClassNode`
  `DELEGATES_TO_TARGET`
  Cached `DelegatesTo.Target` annotation type.
  `protected static final ClassNode`
  `DGM_CLASSNODE`
  Cached `DefaultGroovyMethods` type.
  `protected static final List<MethodNode>`
  `EMPTY_METHODNODE_LIST`
  Shared empty method list.
  `protected static final ClassNode`
  `ENUMERATION_TYPE`
  Cached `Enumeration` type.
  `protected static final Object`
  `ERROR_COLLECTOR`
  Metadata key used to store per-method error collectors.
  `protected DefaultTypeCheckingExtension`
  `extension`
  Composite extension chain consulted during type checking.
  `static final Statement`
  `GENERATED_EMPTY_STATEMENT`
  Empty statement reused for synthetic AST nodes.
  `protected static final MethodNode`
  `GET_DELEGATE`
  Cached `Closure#getDelegate()` method.
  `protected static final MethodNode`
  `GET_OWNER`
  Cached `Closure#getOwner()` method.
  `protected static final MethodNode`
  `GET_THISOBJECT`
  Cached `Closure#getThisObject()` method.
  `protected static final ClassNode`
  `ITERABLE_TYPE`
  Cached `Iterable` type.
  `protected static final ClassNode`
  `LINKEDHASHMAP_CLASSNODE`
  Deprecated, for removal: This API element is subject to removal in a future version.
  `protected static final ClassNode`
  `MAP_ENTRY_TYPE`
  Cached `Map.Entry` type.
  `protected static final ClassNode`
  `NAMED_PARAM_CLASSNODE`
  Cached `NamedParam` annotation type.
  `protected static final ClassNode`
  `NAMED_PARAMS_CLASSNODE`
  Cached `NamedParams` annotation type.
  `protected final ReturnAdder`
  `returnAdder`
  Return adder used to normalize implicit and explicit returns.
  `protected final ReturnAdder.ReturnStatementListener`
  `returnListener`
  `protected static final ClassNode`
  `TYPECHECKED_CLASSNODE`
  Cached `TypeChecked` annotation type.
  `protected static final ClassNode[]`
  `TYPECHECKING_ANNOTATIONS`
  Type-checking annotations recognized by this visitor.
  `protected static final ClassNode`
  `TYPECHECKING_INFO_NODE`
  Cached `TypeChecked.TypeCheckingInfo` annotation type.
  `protected TypeCheckingContext`
  `typeCheckingContext`
  Mutable state for the current type-checking run.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `StaticTypeCheckingVisitor(SourceUnit source, ClassNode classNode)`
  Creates a static type-checking visitor for the supplied source and class.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected void`
  `addAmbiguousErrorMessage(List<MethodNode> foundMethods, String name, ClassNode[] args, Expression expr)`
  Reports that method resolution remained ambiguous after filtering.
  `protected void`
  `addAssignmentError(ClassNode leftType, ClassNode rightType, Expression expression)`
  Reports an incompatible assignment between the supplied types.
  `protected void`
  `addCategoryMethodCallError(Expression call)`
  Reports that categories cannot be used under static type checking.
  `protected void`
  `addClosureReturnType(ClassNode returnType)`
  Records a non-void return type for the current enclosing closure.
  `void`
  `addError(String msg, ASTNode node)`
  Adds an error message associated with an AST node to the source unit.
  `protected void`
  `addNoMatchingMethodError(ClassNode receiver, String name, ClassNode[] args, ASTNode origin)`
  Reports that no matching method or constructor could be found for the call.
  `protected void`
  `addNoMatchingMethodError(ClassNode receiver, String name, ClassNode[] args, Expression exp)`
  Reports that no matching method or constructor could be found for the call.
  `protected void`
  `addReceivers(List<Receiver<String>> receivers, Collection<Receiver<String>> owners, boolean implicitThis)`
  Adds candidate receivers derived from owner chains.
  `protected void`
  `addStaticTypeError(String msg, ASTNode node)`
  Reports a static type checking error for the supplied node.
  `void`
  `addTypeCheckingExtension(TypeCheckingExtension extension)`
  Adds a type-checking extension to the active extension chain.
  `protected void`
  `addTypeCheckingInfoAnnotation(MethodNode node)`
  Adds `TypeChecked.TypeCheckingInfo` metadata for an inferred method return type.
  `protected void`
  `addUnsupportedPreOrPostfixExpressionError(Expression expression)`
  Reports an unsupported prefix or postfix operation.
  `protected void`
  `afterSwitchCaseStatementsVisited(SwitchExpression expression)`
  Hook method called after all case arms are visited, but before the default arm (GROOVY-12255).
  `protected void`
  `afterSwitchCaseStatementsVisited(SwitchStatement statement)`
  Hook method called after all case statements are visited, but before the default statement.
  `protected void`
  `afterSwitchConditionExpressionVisited(SwitchExpression expression)`
  Hook method called after the switch-expression selector is visited, but before case arms (GROOVY-12255).
  `protected void`
  `afterSwitchConditionExpressionVisited(SwitchStatement statement)`
  Hook method called after the switch condition expression is visited, but before case statements.
  `protected boolean`
  `areCategoryMethodCalls(List<MethodNode> foundMethods, String name, ClassNode[] args)`
  Indicates whether all candidates are category-style extension methods.
  `protected boolean`
  `checkCast(ClassNode targetType, Expression source)`
  Checks whether the source expression can be cast to the supplied target type.
  `protected void`
  `checkClosureParameters(Expression callArguments, ClassNode receiver)`
  Deprecated, for removal: This API element is subject to removal in a future version.
  this method is unused, replaced with `DelegatesTo` inference.
  `protected void`
  `checkForbiddenSpreadArgument(ArgumentListExpression arguments)`
  Rejects spread arguments where no target signature is available.
  `protected void`
  `checkGroovyConstructorMap(Expression receiver, ClassNode receiverType, MapExpression mapExpression)`
  Validates map-style constructor arguments against writable properties.
  `protected MethodNode`
  `checkGroovyStyleConstructor(ClassNode node, ClassNode[] arguments, ASTNode origin)`
  Checks that a constructor style expression is valid regarding the number of arguments and the argument types.
  `protected ClassNode`
  `checkReturnType(ReturnStatement statement)`
  Validates the current return statement against the enclosing closure or method.
  `protected boolean`
  `existsProperty(PropertyExpression pexp, boolean checkForReadOnly)`
  Checks whether the property exists for the current access mode.
  `protected boolean`
  `existsProperty(PropertyExpression pexp, boolean readMode, ClassCodeVisitorSupport visitor)`
  Checks whether a property exists on the receiver, or on any of the possible receiver classes (found in the temporary type information table)
  `static String`
  `extractPropertyNameFromMethodName(String prefix, String methodName)`
  Given a method name and a prefix, returns the name of the property that should be looked up, following the java beans rules.
  `protected Object`
  `extractTemporaryTypeInfoKey(Expression expression)`
  Computes the key to use for `TypeCheckingContext.temporaryIfBranchTypeInformation`.
  `protected static ClassNode[]`
  `extractTypesFromParameters(Parameter[] parameters)`
  Extracts the declared types of the supplied parameters.
  `protected ClassNode`
  `findCurrentInstanceOfClass(Expression expression, ClassNode type)`
  A helper method which determines which receiver class should be used in error messages when a field or attribute is not found.
  `protected List<MethodNode>`
  `findMethod(ClassNode receiver, String name, ClassNode... args)`
  Finds candidate methods matching the supplied receiver, name, and argument types.
  `protected MethodNode`
  `findMethodOrFail(Expression expr, ClassNode receiver, String name, ClassNode... args)`
  Finds a matching method or reports a static type error when none is available.
  `protected List<MethodNode>`
  `findMethodsWithGenerated(ClassNode receiver, String name)`
  Returns methods defined for the specified receiver and adds "non-existing" methods that will be generated afterwards by the compiler; for example if a method is using default values and the class node is not compiled yet.
  `protected static String`
  `formatArgumentList(ClassNode[] nodes)`
  Formats an argument-type list for diagnostics.
  `protected ClassNode[]`
  `getArgumentTypes(ArgumentListExpression argumentList)`
  Returns the inferred argument types for the supplied argument list.
  `protected org.codehaus.groovy.transform.stc.DelegationMetadata`
  `getDelegationMetadata(ClosureExpression expression)`
  Returns delegation metadata attached to the supplied closure expression.
  `protected static ClassNode`
  `getGroupOperationResultType(ClassNode a, ClassNode b)`
  Returns the result type for grouped numeric operations such as addition.
  `protected ClassNode`
  `getInferredReturnType(ASTNode node)`
  Returns the inferred return type of a closure or method, if stored on the AST node.
  `protected ClassNode`
  `getInferredReturnTypeFromWithClosureArgument(Expression callArguments)`
  In the case of a Object.with { ...
  `protected ClassNode`
  `getOriginalDeclarationType(Expression lhs)`
  Returns the declared type of the left-hand side before any flow-based refinement.
  `protected ClassNode`
  `getResultType(ClassNode left, int op, ClassNode right, BinaryExpression expr)`
  Computes the result type of a binary operation.
  `protected SourceUnit`
  `getSourceUnit()`
  Provides access to the `SourceUnit` for error reporting during visitation.
  `protected List<ClassNode>`
  `getTemporaryTypesForExpression(Expression expression)`
  Returns temporary narrowed types recorded for the supplied expression.
  `protected ClassNode`
  `getType(ASTNode node)`
  Returns the inferred type for the supplied AST node.
  `protected ClassNode[]`
  `getTypeCheckingAnnotations()`
  Returns array of type checking annotations.
  `TypeCheckingContext`
  `getTypeCheckingContext()`
  Returns the current type checking context.
  `protected static boolean`
  `hasRHSIncompleteGenericTypeInfo(ClassNode inferredRightExpressionType)`
  Deprecated, for removal: This API element is subject to removal in a future version.
  `protected void`
  `inferClosureParameterTypes(ClassNode receiver, Expression arguments, ClosureExpression expression, Parameter target, MethodNode method)`
  Performs type inference on closure argument types whenever code like this is found: `foo.collect { it.toUpperCase() }`.
  `protected ClassNode`
  `inferComponentType(ClassNode receiverType, ClassNode subscriptType)`
  Infers the component type addressed by subscript or iterator access.
  `protected void`
  `inferDiamondType(ConstructorCallExpression cce, ClassNode lType)`
  Infers generic arguments for constructor calls that use the diamond operator.
  `protected ClassNode`
  `inferListExpressionType(ListExpression list)`
  Infers the static type of a list literal.
  `static ClassNode`
  `inferLoopElementType(ClassNode collectionType)`
  Returns the inferred loop element type given a loop collection type.
  `protected ClassNode`
  `inferMapExpressionType(MapExpression map)`
  Infers the static type of a map literal.
  `protected ClassNode`
  `inferRangeSliceType(ClassNode receiverType)`
  GEP-20: probe the static return type of `rhs.getAt(IntRange)` on `receiverType`, so the rest binder can be typed against the actual slice type rather than a hard-coded `List<T>`.
  `protected ClassNode`
  `inferReturnTypeGenerics(ClassNode receiver, MethodNode method, Expression arguments)`
  If a method call returns a parameterized type, then perform additional inference on the return type, so that the type gets actual type arguments.
  `protected ClassNode`
  `inferReturnTypeGenerics(ClassNode receiver, MethodNode method, Expression arguments, GenericsType[] explicitTypeHints)`
  If a method call returns a parameterized type, then perform additional inference on the return type, so that the type gets actual type arguments.
  `void`
  `initialize()`
  Initializes the registered type-checking extensions.
  `protected static boolean`
  `isClassInnerClassOrEqualTo(ClassNode toBeChecked, ClassNode start)`
  Indicates whether `start` is `toBeChecked` or nested within it.
  `protected static boolean`
  `isNullConstant(Expression expression)`
  Indicates whether the expression is the `null` constant.
  `protected boolean`
  `isSecondPassNeededForControlStructure(Map<VariableExpression,ClassNode> startTypes, Map<VariableExpression,List<ClassNode>> oldTracker)`
  Indicates whether a second pass is needed after visiting a control structure.
  `boolean`
  `isSkipMode(AnnotatedNode node)`
  Indicates whether the annotated node is configured for `TypeCheckingMode.SKIP`.
  `protected boolean`
  `isSkippedInnerClass(AnnotatedNode node)`
  Tests if a node is an inner class node, and if it is, then checks if the enclosing method is skipped.
  `protected static boolean`
  `isSuperExpression(Expression expression)`
  Indicates whether the expression represents `super`.
  `protected static boolean`
  `isThisExpression(Expression expression)`
  Indicates whether the expression represents `this`.
  `protected List<Receiver<String>>`
  `makeOwnerList(Expression objectExpression)`
  Given an object expression (a message receiver expression), generate list of possible types.
  `void`
  `performSecondPass()`
  Replays deferred checks that require information collected during the first pass.
  `protected Map<VariableExpression,ClassNode>`
  `popAssignmentTracking(Map<VariableExpression,List<ClassNode>> oldTracker)`
  Pops the current assignment tracker and applies any merged types.
  `protected static String`
  `prettyPrintMethodList(List<MethodNode> nodes)`
  Formats a method list for diagnostics.
  `protected Map<VariableExpression,List<ClassNode>>`
  `pushAssignmentTracking()`
  Pushes a fresh assignment tracker and returns the previous tracker.
  `protected void`
  `pushInstanceOfTypeInfo(Expression objectExpression, Expression typeExpression)`
  Stores information about types when [objectExpression instanceof typeExpression] is visited.
  `protected void`
  `restoreVariableExpressionMetadata(Map<VariableExpression,Map<StaticTypesMarker,Object>> typesBeforeVisit)`
  Restores variable-expression metadata saved before a closure visit.
  `protected void`
  `saveVariableExpressionMetadata(Set<VariableExpression> closureSharedExpressions, Map<VariableExpression,Map<StaticTypesMarker,Object>> typesBeforeVisit)`
  Saves variable-expression metadata that must survive closure re-visits.
  `void`
  `setCompilationUnit(CompilationUnit compilationUnit)`
  Associates the visitor with a compilation unit.
  `void`
  `setMethodsToBeVisited(Set<MethodNode> methodsToBeVisited)`
  Restricts type checking to the supplied method set.
  `protected boolean`
  `shouldSkipClassNode(ClassNode node)`
  Indicates whether the class should be skipped by this visitor.
  `protected boolean`
  `shouldSkipMethodNode(MethodNode node)`
  Indicates whether the method should be skipped by this visitor.
  `protected void`
  `silentlyVisitMethodNode(MethodNode directMethodCallCandidate)`
  Visits a method call target, to infer the type.
  `protected void`
  `startMethodInference(MethodNode node, ErrorCollector collector)`
  Starts type inference for the supplied method using the supplied error collector.
  `protected ClassNode`
  `storeInferredReturnType(ASTNode node, ClassNode type)`
  Stores the inferred return type of a closure or method.
  `protected void`
  `storeTargetMethod(Expression call, MethodNode target)`
  Stores the selected target method on the call expression.
  `protected void`
  `storeType(Expression exp, ClassNode cn)`
  Stores the inferred type for the supplied expression.
  `protected void`
  `typeCheckAssignment(BinaryExpression assignmentExpression, Expression leftExpression, ClassNode leftExpressionType, Expression rightExpression, ClassNode rightExpressionType)`
  Checks assignment compatibility and reports any associated type errors.
  `protected void`
  `typeCheckClosureCall(Expression arguments, ClassNode[] argumentTypes, Parameter[] parameters)`
  Validates closure calls against the signatures implied by the closure parameters.
  `protected MethodNode`
  `typeCheckMapConstructor(ConstructorCallExpression call, ClassNode receiver, Expression arguments)`
  Selects and validates a synthetic map-style constructor target.
  `protected boolean`
  `typeCheckMethodsWithGenericsOrFail(ClassNode receiver, ClassNode[] arguments, MethodNode candidateMethod, Expression location)`
  Validates a chosen method against its generic constraints and reports failures.
  `void`
  `visitArrayExpression(ArrayExpression expression)`
  Visits an `ArrayExpression`, traversing element expressions and size expressions.
  `void`
  `visitAttributeExpression(AttributeExpression expression)`
  Visits an `AttributeExpression`, traversing the object and attribute name expressions.
  `void`
  `visitBinaryExpression(BinaryExpression expression)`
  Visits a `BinaryExpression`, traversing left and right operand expressions.
  `void`
  `visitBitwiseNegationExpression(BitwiseNegationExpression expression)`
  Visits a `BitwiseNegationExpression`, traversing the operand expression.
  `void`
  `visitCaseStatement(CaseStatement statement)`
  Visits a `CaseStatement`, invoking the statement hook before parent traversal.
  `void`
  `visitCastExpression(CastExpression expression)`
  Visits a `CastExpression`, traversing the operand expression.
  `void`
  `visitClass(ClassNode node)`
  Visits a `ClassNode`, processing its annotations, package, imports, contents, and object initializers.
  `void`
  `visitClassExpression(ClassExpression expression)`
  Visits a `ClassExpression`.
  `void`
  `visitClosureExpression(ClosureExpression expression)`
  Visits a `ClosureExpression` with annotation processing, traversing parameter annotations before delegating to parent traversal.
  `void`
  `visitConstructor(ConstructorNode node)`
  Visits a `ConstructorNode`, processing its annotations, parameter annotations, and code block.
  `void`
  `visitConstructorCallExpression(ConstructorCallExpression call)`
  Visits a `ConstructorCallExpression`, traversing its argument list.
  `protected void`
  `visitConstructorOrMethod(MethodNode node, boolean isConstructor)`
  Visits a constructor or method node (implementation detail for both visit methods).
  `void`
  `visitExpressionStatement(ExpressionStatement statement)`
  Visits an `ExpressionStatement`, invoking the statement hook before parent traversal.
  `void`
  `visitField(FieldNode node)`
  Visits a `FieldNode`, processing its annotations and initial value expression if present.
  `void`
  `visitForLoop(ForStatement forLoop)`
  Visits a `ForStatement`, invoking statement hooks and processing loop variable annotations.
  `void`
  `visitIfElse(IfStatement ifElse)`
  Visits an `IfStatement`, invoking the statement hook before parent traversal.
  `void`
  `visitMethod(MethodNode node)`
  Visits a `MethodNode`, processing its annotations, parameter annotations, and code block.
  `protected void`
  `visitMethodCallArguments(ClassNode receiver, ArgumentListExpression arguments, boolean visitFunctors, MethodNode selectedMethod)`
  Visits method-call arguments and defers functional arguments until a target is known.
  `void`
  `visitMethodCallExpression(MethodCallExpression call)`
  Visits a `MethodCallExpression`, traversing the object expression, method expression, and argument list.
  `void`
  `visitMethodPointerExpression(MethodPointerExpression expression)`
  Visits a `MethodPointerExpression`, traversing the object and method name expressions.
  `void`
  `visitNotExpression(NotExpression expression)`
  Visits a `NotExpression`, traversing the operand expression.
  `protected void`
  `visitObjectInitializerStatements(ClassNode node)`
  Visits all object initializer statements in a class, typically static or instance initialization blocks.
  `void`
  `visitPostfixExpression(PostfixExpression expression)`
  Visits a `PostfixExpression`, traversing the operand expression.
  `void`
  `visitPrefixExpression(PrefixExpression expression)`
  Visits a `PrefixExpression`, traversing the operand expression.
  `void`
  `visitProperty(PropertyNode node)`
  Visits a `PropertyNode`, processing its annotations, initial value expression, and getter/setter blocks if present.
  `void`
  `visitPropertyExpression(PropertyExpression expression)`
  Visits a `PropertyExpression`, traversing the object and property name expressions.
  `void`
  `visitRangeExpression(RangeExpression expression)`
  Visits a `RangeExpression`, traversing from and to boundary expressions.
  `void`
  `visitReturnStatement(ReturnStatement statement)`
  Visits a `ReturnStatement`, invoking the statement hook before parent traversal.
  `void`
  `visitStaticMethodCallExpression(StaticMethodCallExpression call)`
  Visits a `StaticMethodCallExpression`, traversing its argument list.
  `void`
  `visitSwitch(SwitchStatement statement)`
  Visits a `SwitchStatement`, invoking the statement hook before parent traversal.
  `void`
  `visitSwitchExpression(SwitchExpression expression)`
  Type-checks a switch expression: visits the selector and each arm, selects an `isCase` target for non-intrinsic arms, unifies the yielded types (JEP 361 poly expression), and reports a non-exhaustive switch when the selector type is statically known.
  `void`
  `visitTernaryExpression(TernaryExpression expression)`
  Visits a `TernaryExpression`, traversing the condition, true-branch, and false-branch expressions.
  `void`
  `visitTryCatchFinally(TryCatchStatement statement)`
  Visits a `TryCatchStatement`, invoking the statement hook before parent traversal.
  `void`
  `visitUnaryMinusExpression(UnaryMinusExpression expression)`
  Visits a `UnaryMinusExpression`, traversing the operand expression.
  `void`
  `visitUnaryPlusExpression(UnaryPlusExpression expression)`
  Visits a `UnaryPlusExpression`, traversing the operand expression.
  `void`
  `visitVariableExpression(VariableExpression vexp)`
  Visits a `VariableExpression`.
  `void`
  `visitWhileLoop(WhileStatement loop)`
  Visits a `WhileStatement`, invoking statement hooks before parent traversal.
  `void`
  `visitYieldStatement(YieldStatement statement)`
  Visits a `YieldStatement`, invoking the statement hook before parent traversal (GROOVY-12255).
  `protected static ClassNode`
  `wrapTypeIfNecessary(ClassNode type)`
  Returns a wrapped type if, and only if, the provided class node is a primitive type.

  ### Methods inherited from class org.codehaus.groovy.ast.ClassCodeVisitorSupport

  `visitAnnotation, visitAnnotations, visitAnnotations, visitAssertStatement, visitBlockStatement, visitBreakStatement, visitCatchStatement, visitClassCodeContainer, visitContinueStatement, visitDeclarationExpression, visitDoWhileLoop, visitImports, visitPackage, visitStatement, visitStatementAnnotations, visitSynchronizedStatement, visitThrowStatement`

  ### Methods inherited from class org.codehaus.groovy.ast.CodeVisitorSupport

  `visitArgumentlistExpression, visitBooleanExpression, visitBytecodeExpression, visitClosureListExpression, visitConstantExpression, visitEmptyStatement, visitFieldExpression, visitGStringExpression, visitLambdaExpression, visitListExpression, visitMapEntryExpression, visitMapExpression, visitMethodReferenceExpression, visitShortTernaryExpression, visitSpreadExpression, visitSpreadMapExpression, visitTupleExpression`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface org.codehaus.groovy.ast.GroovyCodeVisitor

  `visit, visit, visitEmptyExpression, visitListOfExpressions`

- ## Field Details

  - ### ERROR_COLLECTOR

    protected static final Object ERROR_COLLECTOR
    Metadata key used to store per-method error collectors.

  - ### EMPTY_METHODNODE_LIST

    protected static final List<MethodNode> EMPTY_METHODNODE_LIST
    Shared empty method list.

  - ### TYPECHECKED_CLASSNODE

    protected static final ClassNode TYPECHECKED_CLASSNODE
    Cached `TypeChecked` annotation type.

  - ### TYPECHECKING_ANNOTATIONS

    protected static final ClassNode[] TYPECHECKING_ANNOTATIONS
    Type-checking annotations recognized by this visitor.

  - ### TYPECHECKING_INFO_NODE

    protected static final ClassNode TYPECHECKING_INFO_NODE
    Cached `TypeChecked.TypeCheckingInfo` annotation type.

  - ### DGM_CLASSNODE

    protected static final ClassNode DGM_CLASSNODE
    Cached `DefaultGroovyMethods` type.

  - ### CURRENT_SIGNATURE_PROTOCOL_VERSION

    protected static final int CURRENT_SIGNATURE_PROTOCOL_VERSION
    Current encoding protocol for stored type-checking signatures.
    See Also:
      - Constant Field Values

  - ### CURRENT_SIGNATURE_PROTOCOL

    protected static final Expression CURRENT_SIGNATURE_PROTOCOL
    Constant expression for the current signature protocol version.

  - ### GET_DELEGATE

    protected static final MethodNode GET_DELEGATE
    Cached `Closure#getDelegate()` method.

  - ### GET_OWNER

    protected static final MethodNode GET_OWNER
    Cached `Closure#getOwner()` method.

  - ### GET_THISOBJECT

    protected static final MethodNode GET_THISOBJECT
    Cached `Closure#getThisObject()` method.

  - ### DELEGATES_TO

    protected static final ClassNode DELEGATES_TO
    Cached `DelegatesTo` annotation type.

  - ### DELEGATES_TO_TARGET

    protected static final ClassNode DELEGATES_TO_TARGET
    Cached `DelegatesTo.Target` annotation type.

  - ### CLOSUREPARAMS_CLASSNODE

    protected static final ClassNode CLOSUREPARAMS_CLASSNODE
    Cached `ClosureParams` annotation type.

  - ### NAMED_PARAMS_CLASSNODE

    protected static final ClassNode NAMED_PARAMS_CLASSNODE
    Cached `NamedParams` annotation type.

  - ### NAMED_PARAM_CLASSNODE

    protected static final ClassNode NAMED_PARAM_CLASSNODE
    Cached `NamedParam` annotation type.

  - ### LINKEDHASHMAP_CLASSNODE

    @Deprecated(forRemoval=true, since="4.0.0") protected static final ClassNode LINKEDHASHMAP_CLASSNODE
    Deprecated, for removal: This API element is subject to removal in a future version.

  - ### ENUMERATION_TYPE

    protected static final ClassNode ENUMERATION_TYPE
    Cached `Enumeration` type.

  - ### CHAR_SEQUENCE_TYPE

    protected static final ClassNode CHAR_SEQUENCE_TYPE
    Cached `CharSequence` type (GROOVY-9848: membership operator dispatch).

  - ### MAP_ENTRY_TYPE

    protected static final ClassNode MAP_ENTRY_TYPE
    Cached `Map.Entry` type.

  - ### ITERABLE_TYPE

    protected static final ClassNode ITERABLE_TYPE
    Cached `Iterable` type.

  - ### CLOSURE_CALL_NO_ARG

    public static final MethodNode CLOSURE_CALL_NO_ARG
    Cached zero-argument `Closure#call()` method.

  - ### CLOSURE_CALL_ONE_ARG

    public static final MethodNode CLOSURE_CALL_ONE_ARG
    Cached single-argument `Closure#call(Object)` method.

  - ### CLOSURE_CALL_VARGS

    public static final MethodNode CLOSURE_CALL_VARGS
    Cached varargs `Closure#call(Object[])` method.

  - ### GENERATED_EMPTY_STATEMENT

    public static final Statement GENERATED_EMPTY_STATEMENT
    Empty statement reused for synthetic AST nodes.

  - ### returnListener

    protected final ReturnAdder.ReturnStatementListener returnListener

  - ### returnAdder

    protected final ReturnAdder returnAdder
    Return adder used to normalize implicit and explicit returns.

  - ### currentField

    protected FieldNode currentField
    Field currently being visited.

  - ### currentProperty

    protected PropertyNode currentProperty
    Property currently being visited.

  - ### extension

    protected DefaultTypeCheckingExtension extension
    Composite extension chain consulted during type checking.

  - ### typeCheckingContext

    protected TypeCheckingContext typeCheckingContext
    Mutable state for the current type-checking run.

- ## Constructor Details

  - ### StaticTypeCheckingVisitor

    public StaticTypeCheckingVisitor(SourceUnit source, ClassNode classNode)
    Creates a static type-checking visitor for the supplied source and class.

- ## Method Details

  - ### setCompilationUnit

    public void setCompilationUnit(CompilationUnit compilationUnit)
    Associates the visitor with a compilation unit.

  - ### getSourceUnit

    protected SourceUnit getSourceUnit()
    Provides access to the `SourceUnit` for error reporting during visitation. Implementations must override this method.
    Specified by:
      `getSourceUnit` in class `ClassCodeVisitorSupport`
    Returns:
      the source unit for this visitor

  - ### initialize

    public void initialize()
    Initializes the registered type-checking extensions.

  - ### getTypeCheckingAnnotations

    protected ClassNode[] getTypeCheckingAnnotations()
    Returns array of type checking annotations. Subclasses may override this method in order to provide additional types which must be looked up when checking if a method or a class node should be skipped.

    The default implementation returns `TypeChecked`.

  - ### getTypeCheckingContext

    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

  - ### addTypeCheckingExtension

    public void addTypeCheckingExtension(TypeCheckingExtension extension)
    Adds a type-checking extension to the active extension chain.

  - ### visitClass

    public void visitClass(ClassNode node)
    Visits a `ClassNode`, processing its annotations, package, imports, contents, and object initializers.
    Specified by:
      `visitClass` in interface `GroovyClassVisitor`
    Overrides:
      `visitClass` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the class node to visit

  - ### shouldSkipClassNode

    protected boolean shouldSkipClassNode(ClassNode node)
    Indicates whether the class should be skipped by this visitor.

  - ### shouldSkipMethodNode

    protected boolean shouldSkipMethodNode(MethodNode node)
    Indicates whether the method should be skipped by this visitor.

  - ### isSkipMode

    public boolean isSkipMode(AnnotatedNode node)
    Indicates whether the annotated node is configured for `TypeCheckingMode.SKIP`.

    The most specific annotation wins: a node whose own type-checking annotation has a non-SKIP mode is never skipped, whatever an enclosing class or method declares. Without an annotation of its own, a node inherits skip mode from its enclosing scope.

  - ### isSkippedInnerClass

    protected boolean isSkippedInnerClass(AnnotatedNode node)
    Tests if a node is an inner class node, and if it is, then checks if the enclosing method is skipped.
    Returns:
      true if the inner class node should be skipped

  - ### visitClassExpression

    public void visitClassExpression(ClassExpression expression)
    Visits a `ClassExpression`. No traversal is performed as class expressions contain no child expressions.
    Specified by:
      `visitClassExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitClassExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the class expression

  - ### visitVariableExpression

    public void visitVariableExpression(VariableExpression vexp)
    Visits a `VariableExpression`. No traversal is performed as variable expressions contain no child expressions.
    Specified by:
      `visitVariableExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitVariableExpression` in class `CodeVisitorSupport`
    Parameters:
      `vexp` - the variable expression

  - ### visitPropertyExpression

    public void visitPropertyExpression(PropertyExpression expression)
    Visits a `PropertyExpression`, traversing the object and property name expressions.
    Specified by:
      `visitPropertyExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitPropertyExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the property expression

  - ### visitAttributeExpression

    public void visitAttributeExpression(AttributeExpression expression)
    Visits an `AttributeExpression`, traversing the object and attribute name expressions.
    Specified by:
      `visitAttributeExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitAttributeExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the attribute expression

  - ### visitRangeExpression

    public void visitRangeExpression(RangeExpression expression)
    Visits a `RangeExpression`, traversing from and to boundary expressions.
    Specified by:
      `visitRangeExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitRangeExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the range expression

  - ### visitNotExpression

    public void visitNotExpression(NotExpression expression)
    Visits a `NotExpression`, traversing the operand expression.
    Specified by:
      `visitNotExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitNotExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the not expression

  - ### visitBinaryExpression

    public void visitBinaryExpression(BinaryExpression expression)
    Visits a `BinaryExpression`, traversing left and right operand expressions.
    Specified by:
      `visitBinaryExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitBinaryExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the binary expression

  - ### getOriginalDeclarationType

    protected ClassNode getOriginalDeclarationType(Expression lhs)
    Returns the declared type of the left-hand side before any flow-based refinement.

  - ### inferDiamondType

    protected void inferDiamondType(ConstructorCallExpression cce, ClassNode lType)
    Infers generic arguments for constructor calls that use the diamond operator.

  - ### typeCheckAssignment

    protected void typeCheckAssignment(BinaryExpression assignmentExpression, Expression leftExpression, ClassNode leftExpressionType, Expression rightExpression, ClassNode rightExpressionType)
    Checks assignment compatibility and reports any associated type errors.

  - ### checkGroovyConstructorMap

    protected void checkGroovyConstructorMap(Expression receiver, ClassNode receiverType, MapExpression mapExpression)
    Validates map-style constructor arguments against writable properties.

  - ### hasRHSIncompleteGenericTypeInfo

    @Deprecated(forRemoval=true, since="4.0.0") protected static boolean hasRHSIncompleteGenericTypeInfo(ClassNode inferredRightExpressionType)
    Deprecated, for removal: This API element is subject to removal in a future version.
    Indicates whether the inferred type still contains unresolved placeholder generics.

  - ### checkGroovyStyleConstructor

    protected MethodNode checkGroovyStyleConstructor(ClassNode node, ClassNode[] arguments, ASTNode origin)
    Checks that a constructor style expression is valid regarding the number of arguments and the argument types.
    Parameters:
      `node` - the class node for which we will try to find a matching constructor
      `arguments` - the constructor arguments

  - ### existsProperty

    protected boolean existsProperty(PropertyExpression pexp, boolean checkForReadOnly)
    Checks whether the property exists for the current access mode.

  - ### existsProperty

    protected boolean existsProperty(PropertyExpression pexp, boolean readMode, ClassCodeVisitorSupport visitor)
    Checks whether a property exists on the receiver, or on any of the possible receiver classes (found in the temporary type information table)
    Parameters:
      `pexp` - a property expression
      `readMode` - if true, look for property read, else for property set
      `visitor` - if not null, when the property node is found, visit it with the provided visitor
    Returns:
      true if the property is defined in any of the possible receiver classes

  - ### visitProperty

    public void visitProperty(PropertyNode node)
    Visits a `PropertyNode`, processing its annotations, initial value expression, and getter/setter blocks if present.
    Specified by:
      `visitProperty` in interface `GroovyClassVisitor`
    Overrides:
      `visitProperty` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the property node to visit

  - ### visitField

    public void visitField(FieldNode node)
    Visits a `FieldNode`, processing its annotations and initial value expression if present.
    Specified by:
      `visitField` in interface `GroovyClassVisitor`
    Overrides:
      `visitField` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the field node to visit

  - ### visitForLoop

    public void visitForLoop(ForStatement forLoop)
    Visits a `ForStatement`, invoking statement hooks and processing loop variable annotations.
    Specified by:
      `visitForLoop` in interface `GroovyCodeVisitor`
    Overrides:
      `visitForLoop` in class `ClassCodeVisitorSupport`
    Parameters:
      `forLoop` - the for statement to visit

  - ### inferLoopElementType

    public static ClassNode inferLoopElementType(ClassNode collectionType)
    Returns the inferred loop element type given a loop collection type. 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
    See Also:
      - `inferComponentType(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.ast.ClassNode)`

  - ### isSecondPassNeededForControlStructure

    protected boolean isSecondPassNeededForControlStructure(Map<VariableExpression,ClassNode> startTypes, Map<VariableExpression,List<ClassNode>> oldTracker)
    Indicates whether a second pass is needed after visiting a control structure.

  - ### visitWhileLoop

    public void visitWhileLoop(WhileStatement loop)
    Visits a `WhileStatement`, invoking statement hooks before parent traversal.
    Specified by:
      `visitWhileLoop` in interface `GroovyCodeVisitor`
    Overrides:
      `visitWhileLoop` in class `ClassCodeVisitorSupport`
    Parameters:
      `loop` - the while statement to visit

  - ### visitBitwiseNegationExpression

    public void visitBitwiseNegationExpression(BitwiseNegationExpression expression)
    Visits a `BitwiseNegationExpression`, traversing the operand expression.
    Specified by:
      `visitBitwiseNegationExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitBitwiseNegationExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the bitwise negation expression

  - ### visitUnaryPlusExpression

    public void visitUnaryPlusExpression(UnaryPlusExpression expression)
    Visits a `UnaryPlusExpression`, traversing the operand expression.
    Specified by:
      `visitUnaryPlusExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitUnaryPlusExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the unary plus expression

  - ### visitUnaryMinusExpression

    public void visitUnaryMinusExpression(UnaryMinusExpression expression)
    Visits a `UnaryMinusExpression`, traversing the operand expression.
    Specified by:
      `visitUnaryMinusExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitUnaryMinusExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the unary minus expression

  - ### visitPostfixExpression

    public void visitPostfixExpression(PostfixExpression expression)
    Visits a `PostfixExpression`, traversing the operand expression.
    Specified by:
      `visitPostfixExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitPostfixExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the postfix expression

  - ### visitPrefixExpression

    public void visitPrefixExpression(PrefixExpression expression)
    Visits a `PrefixExpression`, traversing the operand expression.
    Specified by:
      `visitPrefixExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitPrefixExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the prefix expression

  - ### visitExpressionStatement

    public void visitExpressionStatement(ExpressionStatement statement)
    Visits an `ExpressionStatement`, invoking the statement hook before parent traversal.
    Specified by:
      `visitExpressionStatement` in interface `GroovyCodeVisitor`
    Overrides:
      `visitExpressionStatement` in class `ClassCodeVisitorSupport`
    Parameters:
      `statement` - the expression statement to visit

  - ### visitReturnStatement

    public void visitReturnStatement(ReturnStatement statement)
    Visits a `ReturnStatement`, invoking the statement hook before parent traversal.
    Specified by:
      `visitReturnStatement` in interface `GroovyCodeVisitor`
    Overrides:
      `visitReturnStatement` in class `ClassCodeVisitorSupport`
    Parameters:
      `statement` - the return statement to visit

  - ### checkReturnType

    protected ClassNode checkReturnType(ReturnStatement statement)
    Validates the current return statement against the enclosing closure or method.

  - ### addClosureReturnType

    protected void addClosureReturnType(ClassNode returnType)
    Records a non-void return type for the current enclosing closure.

  - ### visitConstructorCallExpression

    public void visitConstructorCallExpression(ConstructorCallExpression call)
    Description copied from class: `CodeVisitorSupport`
    Visits a `ConstructorCallExpression`, traversing its argument list.
    Specified by:
      `visitConstructorCallExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitConstructorCallExpression` in class `CodeVisitorSupport`
    Parameters:
      `call` - the constructor call expression

  - ### typeCheckMapConstructor

    protected MethodNode typeCheckMapConstructor(ConstructorCallExpression call, ClassNode receiver, Expression arguments)
    Selects and validates a synthetic map-style constructor target.

  - ### getArgumentTypes

    protected ClassNode[] getArgumentTypes(ArgumentListExpression argumentList)
    Returns the inferred argument types for the supplied argument list.

  - ### visitClosureExpression

    public void visitClosureExpression(ClosureExpression expression)
    Visits a `ClosureExpression` with annotation processing, traversing parameter annotations before delegating to parent traversal.
    Specified by:
      `visitClosureExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitClosureExpression` in class `ClassCodeVisitorSupport`
    Parameters:
      `expression` - the closure expression to visit

  - ### visitMethodPointerExpression

    public void visitMethodPointerExpression(MethodPointerExpression expression)
    Visits a `MethodPointerExpression`, traversing the object and method name expressions.
    Specified by:
      `visitMethodPointerExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitMethodPointerExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the method pointer expression

  - ### getDelegationMetadata

    protected org.codehaus.groovy.transform.stc.DelegationMetadata getDelegationMetadata(ClosureExpression expression)
    Returns delegation metadata attached to the supplied closure expression.

  - ### restoreVariableExpressionMetadata

    protected void restoreVariableExpressionMetadata(Map<VariableExpression,Map<StaticTypesMarker,Object>> typesBeforeVisit)
    Restores variable-expression metadata saved before a closure visit.

  - ### saveVariableExpressionMetadata

    protected void saveVariableExpressionMetadata(Set<VariableExpression> closureSharedExpressions, Map<VariableExpression,Map<StaticTypesMarker,Object>> typesBeforeVisit)
    Saves variable-expression metadata that must survive closure re-visits.

  - ### visitConstructor

    public void visitConstructor(ConstructorNode node)
    Visits a `ConstructorNode`, processing its annotations, parameter annotations, and code block.
    Specified by:
      `visitConstructor` in interface `GroovyClassVisitor`
    Overrides:
      `visitConstructor` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the constructor node to visit

  - ### visitMethod

    public void visitMethod(MethodNode node)
    Visits a `MethodNode`, processing its annotations, parameter annotations, and code block.
    Specified by:
      `visitMethod` in interface `GroovyClassVisitor`
    Overrides:
      `visitMethod` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the method node to visit

  - ### startMethodInference

    protected void startMethodInference(MethodNode node, ErrorCollector collector)
    Starts type inference for the supplied method using the supplied error collector.

  - ### visitConstructorOrMethod

    protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor)
    Visits a constructor or method node (implementation detail for both visit methods). Processes the node's annotations, all parameter annotations, and code block.
    Overrides:
      `visitConstructorOrMethod` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the method or constructor node
      `isConstructor` - true if node is a constructor, false if it is a method

  - ### visitObjectInitializerStatements

    protected void visitObjectInitializerStatements(ClassNode node)
    Visits all object initializer statements in a class, typically static or instance initialization blocks.
    Overrides:
      `visitObjectInitializerStatements` in class `ClassCodeVisitorSupport`
    Parameters:
      `node` - the class node containing initializer statements

  - ### addTypeCheckingInfoAnnotation

    protected void addTypeCheckingInfoAnnotation(MethodNode node)
    Adds `TypeChecked.TypeCheckingInfo` metadata for an inferred method return type.

  - ### visitStaticMethodCallExpression

    public void visitStaticMethodCallExpression(StaticMethodCallExpression call)
    Visits a `StaticMethodCallExpression`, traversing its argument list.
    Specified by:
      `visitStaticMethodCallExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitStaticMethodCallExpression` in class `CodeVisitorSupport`
    Parameters:
      `call` - the static method call expression

  - ### checkClosureParameters

    @Deprecated(forRemoval=true, since="2.5.0") protected void checkClosureParameters(Expression callArguments, ClassNode receiver)
    Deprecated, for removal: This API element is subject to removal in a future version.
    this method is unused, replaced with `DelegatesTo` inference.

  - ### silentlyVisitMethodNode

    protected void silentlyVisitMethodNode(MethodNode directMethodCallCandidate)
    Visits a method call target, to infer the type. Don't report errors right away, that will be done by a later visitMethod call.

  - ### visitMethodCallArguments

    protected void visitMethodCallArguments(ClassNode receiver, ArgumentListExpression arguments, boolean visitFunctors, MethodNode selectedMethod)
    Visits method-call arguments and defers functional arguments until a target is known.

  - ### inferClosureParameterTypes

    protected void inferClosureParameterTypes(ClassNode receiver, Expression arguments, ClosureExpression expression, Parameter target, MethodNode method)
    Performs type inference on closure argument types whenever code like this is found: `foo.collect { it.toUpperCase() }`.

    In this case the type checker tries to find if the `collect` method has its `Closure` argument annotated with `ClosureParams`. If so, then additional type inference can be performed and the type of `it` may be inferred.

    Parameters:
      `receiver` -
      `arguments` -
      `expression` - closure or lambda expression for which the argument types should be inferred
      `target` - parameter which may provide `ClosureParams` annotation or SAM type
      `method` - method that declares `target`

  - ### addReceivers

    protected void addReceivers(List<Receiver<String>> receivers, Collection<Receiver<String>> owners, boolean implicitThis)
    Adds candidate receivers derived from owner chains.

  - ### visitMethodCallExpression

    public void visitMethodCallExpression(MethodCallExpression call)
    Visits a `MethodCallExpression`, traversing the object expression, method expression, and argument list.
    Specified by:
      `visitMethodCallExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitMethodCallExpression` in class `CodeVisitorSupport`
    Parameters:
      `call` - the method call expression

  - ### getInferredReturnTypeFromWithClosureArgument

    protected ClassNode getInferredReturnTypeFromWithClosureArgument(Expression callArguments)
    In the case of a Object.with { ... } call, this method is supposed to retrieve the inferred closure return type.
    Parameters:
      `callArguments` - the argument list from the Object#with(Closure) call, i.e. a single closure expression
    Returns:
      the inferred closure return type or null

  - ### makeOwnerList

    protected List<Receiver<String>> makeOwnerList(Expression objectExpression)
    Given an object expression (a message receiver expression), generate list of possible types.
    Parameters:
      `objectExpression` - the message receiver
    Returns:
      types and qualifiers of the receiver

  - ### checkForbiddenSpreadArgument

    protected void checkForbiddenSpreadArgument(ArgumentListExpression arguments)
    Rejects spread arguments where no target signature is available.

  - ### storeTargetMethod

    protected void storeTargetMethod(Expression call, MethodNode target)
    Stores the selected target method on the call expression.

  - ### typeCheckClosureCall

    protected void typeCheckClosureCall(Expression arguments, ClassNode[] argumentTypes, Parameter[] parameters)
    Validates closure calls against the signatures implied by the closure parameters.

  - ### visitIfElse

    public void visitIfElse(IfStatement ifElse)
    Visits an `IfStatement`, invoking the statement hook before parent traversal.
    Specified by:
      `visitIfElse` in interface `GroovyCodeVisitor`
    Overrides:
      `visitIfElse` in class `ClassCodeVisitorSupport`
    Parameters:
      `ifElse` - the if statement to visit

  - ### visitSwitch

    public void visitSwitch(SwitchStatement statement)
    Visits a `SwitchStatement`, invoking the statement hook before parent traversal.
    Specified by:
      `visitSwitch` in interface `GroovyCodeVisitor`
    Overrides:
      `visitSwitch` in class `ClassCodeVisitorSupport`
    Parameters:
      `statement` - the switch statement to visit

  - ### visitSwitchExpression

    public void visitSwitchExpression(SwitchExpression expression)
    Type-checks a switch expression: visits the selector and each arm, selects an `isCase` target for non-intrinsic arms, unifies the yielded types (JEP 361 poly expression), and reports a non-exhaustive switch when the selector type is statically known.
    Specified by:
      `visitSwitchExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitSwitchExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the switch expression
    Since:
      6.0.0

  - ### afterSwitchConditionExpressionVisited

    protected void afterSwitchConditionExpressionVisited(SwitchExpression expression)
    Hook method called after the switch-expression selector is visited, but before case arms (GROOVY-12255).
    Overrides:
      `afterSwitchConditionExpressionVisited` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the switch expression being visited

  - ### afterSwitchCaseStatementsVisited

    protected void afterSwitchCaseStatementsVisited(SwitchExpression expression)
    Hook method called after all case arms are visited, but before the default arm (GROOVY-12255).
    Overrides:
      `afterSwitchCaseStatementsVisited` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the switch expression being visited

  - ### visitYieldStatement

    public void visitYieldStatement(YieldStatement statement)
    Visits a `YieldStatement`, invoking the statement hook before parent traversal (GROOVY-12255).
    Specified by:
      `visitYieldStatement` in interface `GroovyCodeVisitor`
    Overrides:
      `visitYieldStatement` in class `ClassCodeVisitorSupport`
    Parameters:
      `statement` - the yield statement to visit

  - ### afterSwitchConditionExpressionVisited

    protected void afterSwitchConditionExpressionVisited(SwitchStatement statement)
    Hook method called after the switch condition expression is visited, but before case statements. Subclasses may override to perform processing between condition and cases.
    Overrides:
      `afterSwitchConditionExpressionVisited` in class `CodeVisitorSupport`
    Parameters:
      `statement` - the switch statement being visited

  - ### afterSwitchCaseStatementsVisited

    protected void afterSwitchCaseStatementsVisited(SwitchStatement statement)
    Hook method called after all case statements are visited, but before the default statement. Subclasses may override to perform processing between cases and default.
    Overrides:
      `afterSwitchCaseStatementsVisited` in class `CodeVisitorSupport`
    Parameters:
      `statement` - the switch statement being visited

  - ### visitCaseStatement

    public void visitCaseStatement(CaseStatement statement)
    Visits a `CaseStatement`, invoking the statement hook before parent traversal.
    Specified by:
      `visitCaseStatement` in interface `GroovyCodeVisitor`
    Overrides:
      `visitCaseStatement` in class `ClassCodeVisitorSupport`
    Parameters:
      `statement` - the case statement to visit

  - ### pushAssignmentTracking

    protected Map<VariableExpression,List<ClassNode>> pushAssignmentTracking()
    Pushes a fresh assignment tracker and returns the previous tracker.

  - ### popAssignmentTracking

    protected Map<VariableExpression,ClassNode> popAssignmentTracking(Map<VariableExpression,List<ClassNode>> oldTracker)
    Pops the current assignment tracker and applies any merged types.

  - ### visitArrayExpression

    public void visitArrayExpression(ArrayExpression expression)
    Visits an `ArrayExpression`, traversing element expressions and size expressions.
    Specified by:
      `visitArrayExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitArrayExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the array expression

  - ### visitCastExpression

    public void visitCastExpression(CastExpression expression)
    Visits a `CastExpression`, traversing the operand expression.
    Specified by:
      `visitCastExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitCastExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the cast expression

  - ### checkCast

    protected boolean checkCast(ClassNode targetType, Expression source)
    Checks whether the source expression can be cast to the supplied target type.

  - ### visitTernaryExpression

    public void visitTernaryExpression(TernaryExpression expression)
    Visits a `TernaryExpression`, traversing the condition, true-branch, and false-branch expressions.
    Specified by:
      `visitTernaryExpression` in interface `GroovyCodeVisitor`
    Overrides:
      `visitTernaryExpression` in class `CodeVisitorSupport`
    Parameters:
      `expression` - the ternary expression

  - ### visitTryCatchFinally

    public void visitTryCatchFinally(TryCatchStatement statement)
    Visits a `TryCatchStatement`, invoking the statement hook before parent traversal.
    Specified by:
      `visitTryCatchFinally` in interface `GroovyCodeVisitor`
    Overrides:
      `visitTryCatchFinally` in class `ClassCodeVisitorSupport`
    Parameters:
      `statement` - the try-catch statement to visit

  - ### storeType

    protected void storeType(Expression exp, ClassNode cn)
    Stores the inferred type for the supplied expression.

  - ### getResultType

    protected ClassNode getResultType(ClassNode left, int op, ClassNode right, BinaryExpression expr)
    Computes the result type of a binary operation.

  - ### getGroupOperationResultType

    protected static ClassNode getGroupOperationResultType(ClassNode a, ClassNode b)
    Returns the result type for grouped numeric operations such as addition.

  - ### inferRangeSliceType

    protected ClassNode inferRangeSliceType(ClassNode receiverType)
    GEP-20: probe the static return type of `rhs.getAt(IntRange)` on `receiverType`, so the rest binder can be typed against the actual slice type rather than a hard-coded `List<T>`. Returns the resolved slice type (e.g. `String` for a String receiver, `BitSet` for a BitSet receiver, the user-declared return type for custom classes), or `null` if the receiver has no resolvable `getAt(IntRange)`.

    Mirrors `inferComponentType(org.codehaus.groovy.ast.ClassNode, org.codehaus.groovy.ast.ClassNode)` but for the IntRange overload. Method resolution runs under a swallowed error collector so a missing overload doesn't surface as a static-type error.

  - ### inferComponentType

    protected ClassNode inferComponentType(ClassNode receiverType, ClassNode subscriptType)
    Infers the component type addressed by subscript or iterator access.

  - ### findMethodOrFail

    protected MethodNode findMethodOrFail(Expression expr, ClassNode receiver, String name, ClassNode... args)
    Finds a matching method or reports a static type error when none is available.

  - ### prettyPrintMethodList

    protected static String prettyPrintMethodList(List<MethodNode> nodes)
    Formats a method list for diagnostics.

  - ### areCategoryMethodCalls

    protected boolean areCategoryMethodCalls(List<MethodNode> foundMethods, String name, ClassNode[] args)
    Indicates whether all candidates are category-style extension methods.

  - ### findMethodsWithGenerated

    protected List<MethodNode> findMethodsWithGenerated(ClassNode receiver, String name)
    Returns methods defined for the specified receiver and adds "non-existing" methods that will be generated afterwards by the compiler; for example if a method is using default values and the class node is not compiled yet.
    Parameters:
      `receiver` - the type to search for methods
      `name` - the name of the methods to return
    Returns:
      the methods that are defined on the receiver completed with stubs for future methods

  - ### findMethod

    protected List<MethodNode> findMethod(ClassNode receiver, String name, ClassNode... args)
    Finds candidate methods matching the supplied receiver, name, and argument types.

  - ### extractPropertyNameFromMethodName

    public static String extractPropertyNameFromMethodName(String prefix, String methodName)
    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

  - ### getType

    protected ClassNode getType(ASTNode node)
    Returns the inferred type for the supplied AST node.

  - ### storeInferredReturnType

    protected ClassNode storeInferredReturnType(ASTNode node, ClassNode type)
    Stores the inferred return type of a closure or 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 `MethodNode`
      `type` - the inferred return type of the code
    Returns:
      The old value of the inferred type.

  - ### getInferredReturnType

    protected ClassNode getInferredReturnType(ASTNode node)
    Returns the inferred return type of a closure or method, if stored on the AST node. This method doesn't perform any type inference by itself.
    Parameters:
      `node` - a `ClosureExpression` or `MethodNode`
    Returns:
      The expected return type.

  - ### isNullConstant

    protected static boolean isNullConstant(Expression expression)
    Indicates whether the expression is the `null` constant.

  - ### isThisExpression

    protected static boolean isThisExpression(Expression expression)
    Indicates whether the expression represents `this`.

  - ### isSuperExpression

    protected static boolean isSuperExpression(Expression expression)
    Indicates whether the expression represents `super`.

  - ### inferListExpressionType

    protected ClassNode inferListExpressionType(ListExpression list)
    Infers the static type of a list literal.

  - ### inferMapExpressionType

    protected ClassNode inferMapExpressionType(MapExpression map)
    Infers the static type of a map literal.

  - ### inferReturnTypeGenerics

    protected ClassNode inferReturnTypeGenerics(ClassNode receiver, MethodNode method, Expression arguments)
    If a method call returns a parameterized type, then perform additional inference on the return type, so that the type gets actual type arguments. For example, the method `Arrays.asList(T...)` is parameterized with `T`, which can be deduced type arguments or call arguments.
    Parameters:
      `method` - the method node
      `arguments` - the method call arguments
      `receiver` - the object expression type

  - ### inferReturnTypeGenerics

    protected ClassNode inferReturnTypeGenerics(ClassNode receiver, MethodNode method, Expression arguments, GenericsType[] explicitTypeHints)
    If a method call returns a parameterized type, then perform additional inference on the return type, so that the type gets actual type arguments. For example, the method `Arrays.asList(T...)` is parameterized with `T`, which can be deduced type arguments or call arguments.
    Parameters:
      `method` - the method node
      `arguments` - the method call arguments
      `receiver` - the object expression type
      `explicitTypeHints` - type arguments (optional), for example `Collections.<String>emptyList()`

  - ### typeCheckMethodsWithGenericsOrFail

    protected boolean typeCheckMethodsWithGenericsOrFail(ClassNode receiver, ClassNode[] arguments, MethodNode candidateMethod, Expression location)
    Validates a chosen method against its generic constraints and reports failures.

  - ### formatArgumentList

    protected static String formatArgumentList(ClassNode[] nodes)
    Formats an argument-type list for diagnostics.

  - ### addError

    public void addError(String msg, ASTNode node)
    Adds an error message associated with an AST node to the source unit. Errors are accumulated and reported after visitation completes.

    The error counts towards the configured `error tolerance`, so visitation may be cut short once that many errors have been collected (GROOVY-12306). Use `ErrorCollector.addErrorAndContinue(Message)` directly to report an error which must never bail out.

    Specified by:
      `addError` in interface `ErrorCollecting`
    Overrides:
      `addError` in class `ClassCodeVisitorSupport`
    Parameters:
      `msg` - the error message to report
      `node` - the AST node associated with the error location
    See Also:
      - `ErrorCollecting`

  - ### addStaticTypeError

    protected void addStaticTypeError(String msg, ASTNode node)
    Reports a static type checking error for the supplied node.

  - ### addNoMatchingMethodError

    protected void addNoMatchingMethodError(ClassNode receiver, String name, ClassNode[] args, Expression exp)
    Reports that no matching method or constructor could be found for the call.

  - ### addNoMatchingMethodError

    protected void addNoMatchingMethodError(ClassNode receiver, String name, ClassNode[] args, ASTNode origin)
    Reports that no matching method or constructor could be found for the call.

  - ### addAmbiguousErrorMessage

    protected void addAmbiguousErrorMessage(List<MethodNode> foundMethods, String name, ClassNode[] args, Expression expr)
    Reports that method resolution remained ambiguous after filtering.

  - ### addCategoryMethodCallError

    protected void addCategoryMethodCallError(Expression call)
    Reports that categories cannot be used under static type checking.

  - ### addAssignmentError

    protected void addAssignmentError(ClassNode leftType, ClassNode rightType, Expression expression)
    Reports an incompatible assignment between the supplied types.

  - ### addUnsupportedPreOrPostfixExpressionError

    protected void addUnsupportedPreOrPostfixExpressionError(Expression expression)
    Reports an unsupported prefix or postfix operation.

  - ### setMethodsToBeVisited

    public void setMethodsToBeVisited(Set<MethodNode> methodsToBeVisited)
    Restricts type checking to the supplied method set.

  - ### performSecondPass

    public void performSecondPass()
    Replays deferred checks that require information collected during the first pass.

  - ### extractTypesFromParameters

    protected static ClassNode[] extractTypesFromParameters(Parameter[] parameters)
    Extracts the declared types of the supplied parameters.

  - ### wrapTypeIfNecessary

    protected static ClassNode wrapTypeIfNecessary(ClassNode type)
    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.
    Returns:
      the wrapped type

  - ### isClassInnerClassOrEqualTo

    protected static boolean isClassInnerClassOrEqualTo(ClassNode toBeChecked, ClassNode start)
    Indicates whether `start` is `toBeChecked` or nested within it.

  - ### pushInstanceOfTypeInfo

    protected void pushInstanceOfTypeInfo(Expression objectExpression, Expression typeExpression)
    Stores information about types when [objectExpression instanceof typeExpression] is visited.
    Parameters:
      `objectExpression` - the expression to be checked against instanceof
      `typeExpression` - the expression which represents the target type

  - ### extractTemporaryTypeInfoKey

    protected Object extractTemporaryTypeInfoKey(Expression expression)
    Computes the key to use for `TypeCheckingContext.temporaryIfBranchTypeInformation`.

  - ### findCurrentInstanceOfClass

    protected ClassNode findCurrentInstanceOfClass(Expression expression, ClassNode type)
    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 available (due to instanceof checks) and whether there is a single candidate in that case.
    Parameters:
      `expression` - 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.

  - ### getTemporaryTypesForExpression

    protected List<ClassNode> getTemporaryTypesForExpression(Expression expression)
    Returns temporary narrowed types recorded for the supplied expression.