jmlparser-core/com.github.javaparser.resolution/Context

Context

interface Context(source)

Context is very similar to scope. In the context we look for solving symbols.

Author

Federico Tomassetti

Functions

fieldDeclarationInScope

open fun fieldDeclarationInScope(name: String): Optional<ResolvedFieldDeclaration>

fieldsExposedToChild

open fun fieldsExposedToChild(child: Node): List<ResolvedFieldDeclaration>

The fields that are declared and in this immediate context made visible to a given child.

getParent

abstract fun getParent(): Optional<Context>

getWrappedNode

abstract fun <N : Node?> getWrappedNode(): N

Returns the node wrapped in the context

localVariableDeclarationInScope

open fun localVariableDeclarationInScope(name: String): Optional<VariableDeclarator>

Aim to resolve the given name by looking for a variable matching it.

localVariablesExposedToChild

open fun localVariablesExposedToChild(child: Node): List<VariableDeclarator>

The local variables that are declared in this immediate context and made visible to a given child.

negatedTypePatternExprsExposedFromChildren

open fun negatedTypePatternExprsExposedFromChildren(): List<TypePatternExpr>

parameterDeclarationInScope

open fun parameterDeclarationInScope(name: String): Optional<Parameter>

parametersExposedToChild

open fun parametersExposedToChild(child: Node): List<Parameter>

The parameters that are declared in this immediate context and made visible to a given child.

solveConstructor

open fun solveConstructor(argumentsTypes: List<ResolvedType>): SymbolReference<ResolvedConstructorDeclaration>

We find the method declaration which is the best match for the given name and list of typeParametersValues.

solveGenericType

open fun solveGenericType(name: String): Optional<ResolvedType>

Default to no generics available in this context, delegating solving to the parent context.

solveGenericTypeInParentContext

open fun solveGenericTypeInParentContext(name: String): Optional<ResolvedType>

solveMethod

open fun solveMethod(name: String, argumentsTypes: List<ResolvedType>, staticOnly: Boolean, invocationContext: ResolvedReferenceTypeDeclaration): SymbolReference<ResolvedMethodDeclaration>

We find the method declaration which is the best match for the given name and list of typeParametersValues.

solveMethodAsUsage

abstract fun solveMethodAsUsage(name: String, argumentsTypes: List<ResolvedType>, invocationContext: ResolvedReferenceTypeDeclaration): Optional<MethodUsage>

Similar to solveMethod but we return a MethodUsage.

solveMethodInParentContext

open fun solveMethodInParentContext(name: String, argumentsTypes: List<ResolvedType>, staticOnly: Boolean, invocationContext: ResolvedReferenceTypeDeclaration): SymbolReference<ResolvedMethodDeclaration>

solveSymbol

open fun solveSymbol(name: String): SymbolReference<out ResolvedValueDeclaration>

Used where a symbol is being used (e.g.

solveSymbolAsValue

open fun solveSymbolAsValue(name: String): Optional<Value>

Used where a symbol is being used (e.g.

solveSymbolAsValueInParentContext

open fun solveSymbolAsValueInParentContext(name: String): Optional<Value>

solveSymbolInParentContext

open fun solveSymbolInParentContext(name: String): SymbolReference<out ResolvedValueDeclaration>

solveType

open fun ~~solveType~~(name: String): SymbolReference<ResolvedTypeDeclaration>

Default to being unable to solve any reference in this context, delegating solving to the parent context.

open fun solveType(name: String, @Nullable typeArguments: List<ResolvedType>): SymbolReference<ResolvedTypeDeclaration>

Method used to solve a name with an expected list of type arguments.

solveTypeInParentContext

open fun ~~solveTypeInParentContext~~(name: String): SymbolReference<ResolvedTypeDeclaration>

Solve a name in the parent context.

open fun solveTypeInParentContext(name: String, @Nullable typeArguments: List<ResolvedType>): SymbolReference<ResolvedTypeDeclaration>

Solve a name with type arguments in the parent context.

typePatternExprInScope

open fun typePatternExprInScope(name: String): Optional<TypePatternExpr>

With respect to solving, the AST "parent" of a block statement is not necessarily the same as the scope parent.

typePatternExprsExposedFromChildren

open fun typePatternExprsExposedFromChildren(): List<TypePatternExpr>

typePatternExprsExposedToChild

open fun typePatternExprsExposedToChild(child: Node): List<TypePatternExpr>

The pattern expressions that are declared in this immediate context and made visible to a given child.