Class RecordDeclarationContext

    • Method Detail

      • solveSymbol

        public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol​(java.lang.String name)
        Description copied from interface: Context
        Used where a symbol is being used (e.g. solving x when used as an argument doubleThis(x), or calculation return x * 2;).
        Parameters:
        name - the variable / reference / identifier used.
        Returns:
        // FIXME: Better documentation on how this is different to solveSymbolAsValue()
      • solveSymbolAsValue

        public java.util.Optional<Value> solveSymbolAsValue​(java.lang.String name)
        Description copied from interface: Context
        Used where a symbol is being used (e.g. solving x when used as an argument doubleThis(x), or calculation return x * 2;).
        Parameters:
        name - the variable / reference / identifier used.
        Returns:
        // FIXME: Better documentation on how this is different to solveSymbol()
      • solveGenericType

        public java.util.Optional<ResolvedType> solveGenericType​(java.lang.String name)
        Description copied from interface: Context
        Default to no generics available in this context, delegating solving to the parent context. Contexts which have generics available to it will override this method. For example class and method declarations, and method calls.
        Parameters:
        name - For example, solving T within class Foo<T> {} or
        Returns:
        The resolved generic type, if found.
      • solveType

        public SymbolReference<ResolvedTypeDeclaration> solveType​(java.lang.String name,
                                                                  java.util.List<ResolvedType> typeArguments)
        Description copied from interface: Context
        Method used to solve a name with an expected list of type arguments.
        This method differs from Context.solveType(String) by taking the type arguments in consideration. For example, lets imagine that we have a project containing the following classes:
        • com/example/Alpha.java
        • com/example/Beta.java
        Where Alpha creates a inner interface called CustomInterface and Beta implements Alpha.CustomInterface and also declares a inner interface called CustomInterface with type arguments. Using this method we can specify which type arguments we are expecting and will be resolved with the type matching that declaration.
        Parameters:
        name - The name to be solved.
        typeArguments - The list of expected type arguments.
        Returns:
        The declaration associated with the given type name.
      • solveMethod

        public SymbolReference<ResolvedMethodDeclaration> solveMethod​(java.lang.String name,
                                                                      java.util.List<ResolvedType> argumentsTypes,
                                                                      boolean staticOnly)
        Description copied from interface: Context
        We find the method declaration which is the best match for the given name and list of typeParametersValues.
      • fieldsExposedToChild

        public java.util.List<ResolvedFieldDeclaration> fieldsExposedToChild​(Node child)
        Description copied from interface: Context
        The fields that are declared and in this immediate context made visible to a given child. This list could include values which are shadowed.