Package gw.internal.gosu.parser

Class GosuParser

java.lang.Object
gw.internal.gosu.parser.ParserBase
gw.internal.gosu.parser.GosuParser
All Implemented Interfaces:
IGosuParser, IParserPart
public final class GosuParser extends ParserBase implements IGosuParser

  • Field Details

    • PENDING_BOUNDING_TYPE

      public static final IType PENDING_BOUNDING_TYPE

    • notfound

      public static ErrorType notfound

    • _tokenizer

      private SourceCodeTokenizer _tokenizer

    • _symTable

      private ISymbolTable _symTable

    • _bParsed

      private boolean _bParsed

    • _stack

      private Stack<ParsedElement> _stack

    • _stackDFS

      private Stack<DynamicFunctionSymbol> _stackDFS

    • _locations

      private List<ParseTree> _locations

    • _parsingProgram

      private Program _parsingProgram

    • _parsingFunctions

      private ArrayList<FunctionType> _parsingFunctions

    • _parsingNewExpressionTypeLiteral

      private boolean _parsingNewExpressionTypeLiteral

    • _parsingFieldInitializer

      private ArrayList<VarStatement> _parsingFieldInitializer

    • _dfsDeclByName

      private Map<String,List<IFunctionSymbol>> _dfsDeclByName

    • _typeUsesMap

      private ITypeUsesMap _typeUsesMap

    • _strNamespace

      private String _strNamespace

    • _tokenizerInstructor

      private ITokenizerInstructor _tokenizerInstructor

    • _scriptabilityConstraint

      private IScriptabilityModifier _scriptabilityConstraint

    • _iBreakOk

      private int _iBreakOk

    • _iContinueOk

      private int _iContinueOk

    • _iReturnOk

      int _iReturnOk

    • _scriptPartIdStack

      private Stack<IScriptPartId> _scriptPartIdStack

    • _inferenceMapStack

      private Stack<TypeVarToTypeMap> _inferenceMapStack

    • _typeVarsByName

      private HashMap<String,ITypeVariableDefinition> _typeVarsByName

    • _inferredContextStack

      private Stack<ContextType> _inferredContextStack

    • _bThrowForWarnings

      private boolean _bThrowForWarnings

    • _bStudioEditorParser

      private boolean _bStudioEditorParser

    • _bWarnOnCaseIssue

      private boolean _bWarnOnCaseIssue

    • _parsingAbstractConstructor

      private Stack<Boolean> _parsingAbstractConstructor

    • _ctxInferenceMgr

      private ContextInferenceManager _ctxInferenceMgr

    • _blockReturnTypeStack

      private Stack<IType> _blockReturnTypeStack

    • _parsingStaticFeature

      private Stack<Boolean> _parsingStaticFeature

    • _bCaptureSymbolsForEval

      private boolean _bCaptureSymbolsForEval

    • _parsingAnnotation

      private boolean _parsingAnnotation

    • _allowWildcards

      private boolean _allowWildcards

    • _ignoreTypeDeprecation

      private int _ignoreTypeDeprecation

    • _bGenRootExprAccess

      private boolean _bGenRootExprAccess

    • _bProgramCallFunction

      private boolean _bProgramCallFunction

    • _typeCache

      private Map<String,IType> _typeCache

    • _iStmtDepth

      private int _iStmtDepth

    • _savedLocations

      private List<ParseTree> _savedLocations

    • _bAreUsingStatementsAllowedInStatementLists

      private Boolean _bAreUsingStatementsAllowedInStatementLists

    • BINDER_ASSIGNABILITY_CACHE

      private static final Cache<Pair<String,String>,Boolean> BINDER_ASSIGNABILITY_CACHE

    • METHOD_PREFIX_LIST

      private static final String[] METHOD_PREFIX_LIST
      Using some simple pattern matching, get a potential property name from a method name at the end of an access list.

      Patterns:
      get&gtmixed-case-name&lt is&gtmixed-case-name&lt

    • METHOD_PREFIX_LIST_WITH_SETTER

      private static final String[] METHOD_PREFIX_LIST_WITH_SETTER

  • Constructor Details

  • Method Details

    • setValidator

      public void setValidator(IGosuValidator validator)
      Specified by:
      setValidator in interface IParserPart
      Overrides:
      setValidator in class ParserBase

    • getScriptPart

      public IScriptPartId getScriptPart()
      Description copied from interface: IGosuParser
      The context associated with the parser's script. E.g., a file name, a library, a rule, etc.
      Specified by:
      getScriptPart in interface IGosuParser

    • getScriptPartIdStack

      public Stack<IScriptPartId> getScriptPartIdStack()

    • pushScriptPart

      public void pushScriptPart(IScriptPartId partId)

    • popScriptPart

      void popScriptPart(IScriptPartId partId)

    • getInferenceMap

      public TypeVarToTypeMap getInferenceMap()

    • pushInferenceMap

      public void pushInferenceMap(TypeVarToTypeMap inferenceMap)

    • popInferenceMap

      void popInferenceMap(TypeVarToTypeMap inferenceMap)

    • setScript

      public void setScript(CharSequence source)
      Description copied from interface: IGosuParser
      Set the script or expression to parse and execute.
      Specified by:
      setScript in interface IGosuParser
      Parameters:
      source - The rule (Gosu) source to parse/execute.

    • setScript

      public void setScript(ISource src)
      Description copied from interface: IGosuParser
      Set the script or expression to parse and execute.
      Specified by:
      setScript in interface IGosuParser
      Parameters:
      src - A reader for the rule (Gosu) source to parse/execute.

    • setScript

      public void setScript(SourceCodeReader reader)
      Description copied from interface: IGosuParser
      Set the script or expression to parse and execute.
      Specified by:
      setScript in interface IGosuParser
      Parameters:
      reader - A reader for the rule (Gosu) source to parse/execute.

    • resetScript

      public void resetScript()

    • reset

      private void reset()

    • getScript

      protected String getScript()
      Specified by:
      getScript in class ParserBase

    • getSymbolTable

      public ISymbolTable getSymbolTable()
      Description copied from interface: IGosuParser
      Returns the parser's symbol table.
      Specified by:
      getSymbolTable in interface IGosuParser
      Overrides:
      getSymbolTable in class ParserBase

    • setSymbolTable

      public void setSymbolTable(ISymbolTable symTable)
      Description copied from interface: IGosuParser
      Sets the parser's symbol table.
      Specified by:
      setSymbolTable in interface IGosuParser
      Parameters:
      symTable - The symbol table the parser will use when parsing and executing rules.

    • getTypeUsesMap

      public ITypeUsesMap getTypeUsesMap()
      Description copied from interface: IGosuParser
      Get the type uses map.
      Specified by:
      getTypeUsesMap in interface IGosuParser

    • setTypeUsesMap

      public void setTypeUsesMap(ITypeUsesMap typeUsesMap)
      Description copied from interface: IGosuParser
      Set the type uses map.
      Specified by:
      setTypeUsesMap in interface IGosuParser

    • getNamespace

      public String getNamespace()

    • setNamespace

      void setNamespace(String strNamespace)

    • getVisibilityConstraint

      public IScriptabilityModifier getVisibilityConstraint()

    • getTokenizerInstructor

      public ITokenizerInstructor getTokenizerInstructor()
      Description copied from interface: IGosuParser
      The TokenizerInstructor to use for this parser. Optional.
      Specified by:
      getTokenizerInstructor in interface IGosuParser

    • setTokenizerInstructor

      public void setTokenizerInstructor(ITokenizerInstructor tokenizerInstructor)
      Specified by:
      setTokenizerInstructor in interface IGosuParser

    • peekParsingFunction

      public FunctionType peekParsingFunction()

    • iterateParsingFunctions

      public Iterator<FunctionType> iterateParsingFunctions()

    • popParsingFunction

      FunctionType popParsingFunction()

    • pushParsingFunction

      void pushParsingFunction(FunctionType functionType)

    • isParsingFunction

      public boolean isParsingFunction()
      Specified by:
      isParsingFunction in interface IGosuParser

    • isParsingTypeListeralForNewExpression

      private boolean isParsingTypeListeralForNewExpression()

    • setParsingTypeLiteralForNewExpression

      private void setParsingTypeLiteralForNewExpression(boolean value)

    • peekParsingFieldInitializer

      public VarStatement peekParsingFieldInitializer()

    • popParsingFieldInitializer

      VarStatement popParsingFieldInitializer()

    • pushParsingFieldInitializer

      void pushParsingFieldInitializer(VarStatement VarStatement)

    • isParsingFieldInitializer

      public boolean isParsingFieldInitializer()

    • peekParsingProgram

      Program peekParsingProgram()

    • isParsingProgram

      boolean isParsingProgram()

    • parseStatements

      public Statement parseStatements(IScriptPartId partId) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a set of Gosu statements. To execute all of the Statements at once call Statement.execute().
      Specified by:
      parseStatements in interface IGosuParser
      Returns:
      The parsed Statement[s].
      Throws:
      ParseResultsException - if any of the statements do not parse according to the Gosu grammar.

    • parseStatements

      private Statement parseStatements(IScriptPartId partId, boolean verify, boolean isolatedScope) throws ParseResultsException
      Throws:
      ParseResultsException

    • _parseStatements

      void _parseStatements(boolean isolatedScope)

    • parseStatementsAndDetectUnreachable

      void parseStatementsAndDetectUnreachable(List<Statement> statements)

    • popStatementAndDetectUnreachable

      private Statement popStatementAndDetectUnreachable(Statement previousStatement, List<Statement> statements)

    • isUnexpectedToken

      private boolean isUnexpectedToken(Statement statement)

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, IType expectedExpressionType) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime, boolean bDoNotThrowParseResultsException) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, boolean isolatedScope, IType expectedExpressionType) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, boolean isolatedScope, boolean reallyIsolatedScope, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, boolean isolatedScope, boolean reallyIsolatedScope, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime, boolean bDoNotThrowParseResultsException) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • parseProgram

      public IProgram parseProgram(IScriptPartId partId, boolean isolatedScope, boolean reallyIsolatedScope, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime, boolean bDoNotThrowParseResultsException, IType superType) throws ParseResultsException
      Specified by:
      parseProgram in interface IGosuParser
      Throws:
      ParseResultsException

    • setGenerateRootExpressionAccessForProgram

      public void setGenerateRootExpressionAccessForProgram(boolean bGenRootExprAccess)
      Specified by:
      setGenerateRootExpressionAccessForProgram in interface IGosuParser

    • isGenerateRootExpressionAccessForProgram

      public boolean isGenerateRootExpressionAccessForProgram()

    • assignRuntime

      private void assignRuntime(ParsedElement elem, boolean bIsolatedScope, IFileContext context, IType superType, IScriptPartId partId) throws ParseResultsException
      Throws:
      ParseResultsException

    • isForStringLiteralTemplate

      private boolean isForStringLiteralTemplate()

    • parseProgramClasspathStatements

      List<IClasspathStatement> parseProgramClasspathStatements()

    • parseProgramTypeLoaderStatements

      List<ITypeLoaderStatement> parseProgramTypeLoaderStatements()

    • parseExp

      public Expression parseExp(IScriptPartId partId) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a Gosu expression. To evaluate the Expression simply call Expression.evaluate().
      Specified by:
      parseExp in interface IGosuParser
      Returns:
      The parsed Expression.
      Throws:
      ParseResultsException - if the expression does not parse according to the Gosu grammar.

    • parseExp

      public Expression parseExp(IScriptPartId partId, IType expectedExpressionType) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a Gosu expression. To evaluate the Expression simply call Expression.evaluate().
      Specified by:
      parseExp in interface IGosuParser
      Returns:
      The parsed Expression.
      Throws:
      ParseResultsException - if the expression does not parse according to the Gosu grammar.

    • parseExp

      public Expression parseExp(IScriptPartId partId, IType expectedExpressionType, IFileContext context, boolean assignRuntime) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a Gosu expression. To evaluate the Expression simply call Expression.evaluate().
      Specified by:
      parseExp in interface IGosuParser
      Returns:
      The parsed Expression.
      Throws:
      ParseResultsException - if the expression does not parse according to the Gosu grammar.

    • parseExp

      private Expression parseExp(IScriptPartId partId, boolean isolatedScope, IType expectedExpressionType, boolean assignRuntime) throws ParseResultsException
      Throws:
      ParseResultsException

    • parseExp

      private Expression parseExp(IScriptPartId partId, boolean isolatedScope, IType expectedExpressionType, IFileContext context, boolean assignRuntime) throws ParseResultsException
      Throws:
      ParseResultsException

    • parseExpOrProgram

      public IExpression parseExpOrProgram(IScriptPartId partId) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a Gosu expression. If that fails, attempts to parse a Gosu program (which is also an expression, but which has a different grammar.
      Specified by:
      parseExpOrProgram in interface IGosuParser
      Parameters:
      partId - Script part id
      Returns:
      either a pure expression or Program, depending on the source
      Throws:
      ParseResultsException - if neither an expression nor a program parses according to the Gosu grammar. We try to make a best guess as to which IParseResultsException to throw, so that the errors are as close as possible to the true cause of the IParseResultsException

    • parseExpOrProgram

      public IExpression parseExpOrProgram(IScriptPartId partId, boolean isolatedScope, boolean assignRuntime) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a Gosu expression. If that fails, attempts to parse a Gosu program (which is also an expression, but which has a different grammar.
      Specified by:
      parseExpOrProgram in interface IGosuParser
      Parameters:
      partId - Script part id
      isolatedScope - if false, the program will modify the symbol table at the current scope
      Returns:
      either a pure expression or Program, depending on the source
      Throws:
      ParseResultsException - if neither an expression nor a program parses according to the Gosu grammar. We try to make a best guess as to which IParseResultsException to throw, so that the errors are as close as possible to the true cause of the IParseResultsException

    • parseExpOrProgram

      public IExpression parseExpOrProgram(IScriptPartId partId, IType typeExpected, boolean isolatedScope, boolean assignRuntime) throws ParseResultsException
      Throws:
      ParseResultsException

    • parseTypeLiteral

      public TypeLiteral parseTypeLiteral(IScriptPartId partId) throws ParseResultsException
      Description copied from interface: IGosuParser
      Parses a type literal expression. The source must obviously satisfy the type literal syntax.
      Specified by:
      parseTypeLiteral in interface IGosuParser
      Throws:
      ParseResultsException

    • isParsed

      public boolean isParsed()
      Specified by:
      isParsed in interface IGosuParser
      Returns:
      Whether or not the referenced Gosu source has been parsed.

    • setParsed

      protected void setParsed(boolean bParsed)

    • getTokenizer

      public final SourceCodeTokenizer getTokenizer()
      Specified by:
      getTokenizer in interface IGosuParser
      Overrides:
      getTokenizer in class ParserBase

    • getLocationsList

      List<ParseTree> getLocationsList()
      Overrides:
      getLocationsList in class ParserBase

    • getLocations

      public List<IParseTree> getLocations()
      Specified by:
      getLocations in interface IGosuParser
      Returns:
      All the locations corresponding to parsed elements.

    • peekLocation

      public ParseTree peekLocation()

    • hasWarnings

      public boolean hasWarnings()
      Specified by:
      hasWarnings in interface IGosuParser
      Returns:
      Did the most recent parse have warnings

    • isThrowParseResultsExceptionForWarnings

      public boolean isThrowParseResultsExceptionForWarnings()
      Specified by:
      isThrowParseResultsExceptionForWarnings in interface IGosuParser

    • setThrowParseExceptionForWarnings

      public void setThrowParseExceptionForWarnings(boolean bThrowParseExceptionForWarnings)
      Specified by:
      setThrowParseExceptionForWarnings in interface IGosuParser

    • parseExpression

      void parseExpression()

    • parseExpression

      void parseExpression(ContextType contextType)

    • parseExpression

      void parseExpression(ContextType ctxType, boolean bVerify)

    • parseExpressionNoVerify

      void parseExpressionNoVerify(ContextType ctxType)

    • setContextInferenceManager

      public void setContextInferenceManager(ContextInferenceManager ctxInferenceMgr)

    • pushInferredContextTypes

      public void pushInferredContextTypes(ContextType ctxType)

    • popInferredContextTypes

      public void popInferredContextTypes()

    • getContextType

      public ContextType getContextType()

    • convertNullLiterals

      private void convertNullLiterals(IType contextType)

    • convertNumberLiteralsToContextType

      private void convertNumberLiteralsToContextType(IType contextType)

    • getNumberTypeFromContextType

      private IType getNumberTypeFromContextType(IType ctxType)

    • parseConditionalExpression

      void parseConditionalExpression()

    • _parseConditionalExpression

      void _parseConditionalExpression()

    • isPrimitiveOrBoxedOrBigIntegerOrBigDecimal

      private boolean isPrimitiveOrBoxedOrBigIntegerOrBigDecimal(IType type)

    • findLeastUpperBoundWithCoercions

      private IType findLeastUpperBoundWithCoercions(ConditionalTernaryExpression cte, Expression first, Expression second)

    • canCoerceFromString

      private boolean canCoerceFromString(Expression first, Expression second)

    • wrapExpressionIfNeeded

      private Expression wrapExpressionIfNeeded(Expression first, Expression second)

    • parseConditionalOrExpression

      void parseConditionalOrExpression()

    • parseConditionalAndExpression

      void parseConditionalAndExpression()

    • parseBitwiseOrExpression

      void parseBitwiseOrExpression()

    • ensureOperandIntOrLongOrBoolean

      private Expression ensureOperandIntOrLongOrBoolean(Expression op)

    • isPrimitiveOrBoxedIntegerType

      private boolean isPrimitiveOrBoxedIntegerType(IType type)

    • ensureOperandBoolean

      private Expression ensureOperandBoolean(Expression op)

    • ensureOperandIntOrLong

      private Expression ensureOperandIntOrLong(Expression op)

    • parseBitwiseXorExpression

      void parseBitwiseXorExpression()

    • parseBitwiseAndExpression

      void parseBitwiseAndExpression()

    • parseEqualityExpression

      private void parseEqualityExpression()

    • isConditional

      private boolean isConditional(IExpression expression)

    • _parseEqualityExpression

      private void _parseEqualityExpression()

    • warnOnSuspiciousEqualsOperator

      private void warnOnSuspiciousEqualsOperator(EqualityExpression e)

    • isThisPointer

      private boolean isThisPointer(Expression expr)

    • isEqualsArgReference

      private boolean isEqualsArgReference(Expression expr)

    • verifyCoercionSymmetry

      private void verifyCoercionSymmetry(EqualityExpression e, Expression lhs, Expression rhs)

    • verifyRelationalOperandsComparable

      private void verifyRelationalOperandsComparable(BinaryExpression expr)

    • verifyConditionalTypes

      private Expression verifyConditionalTypes(Expression lhs, Expression rhs)

    • areMetaTypes

      private boolean areMetaTypes(IType lhsType, IType rhsType)

    • verifyWithComparableDimension

      private Expression verifyWithComparableDimension(Expression rhs, IType lhsType)

    • parseRelationalExpression

      void parseRelationalExpression()

    • parseIntervalExpression

      void parseIntervalExpression()

    • _parseIntervalExpression

      void _parseIntervalExpression()

    • parseBitshiftExpression

      void parseBitshiftExpression()

    • matchRightShift

      private boolean matchRightShift()

    • parseAdditiveExpression

      void parseAdditiveExpression()

    • parseMultiplicativeExpression

      void parseMultiplicativeExpression()

    • parseTypeAsExpression

      void parseTypeAsExpression()

    • checkComparableAndCastable

      private boolean checkComparableAndCastable(Expression lhs, Expression rhs)

    • parseUnaryExpression

      void parseUnaryExpression()

    • parseUnaryExpressionNotPlusMinus

      void parseUnaryExpressionNotPlusMinus()

    • checkMemberAccessIsReadable

      private void checkMemberAccessIsReadable()

    • _parseUnaryExpressionNotPlusMinus

      void _parseUnaryExpressionNotPlusMinus()

    • parseEvalExpression

      private void parseEvalExpression()

    • isCaptureSymbolsForEval

      public boolean isCaptureSymbolsForEval()
      Specified by:
      isCaptureSymbolsForEval in interface IGosuParser

    • setCaptureSymbolsForEval

      public void setCaptureSymbolsForEval(boolean bCaputreSymbolsForEval)
      Specified by:
      setCaptureSymbolsForEval in interface IGosuParser

    • parsePrimaryExpression

      void parsePrimaryExpression()

    • _parsePrimaryExpression

      boolean _parsePrimaryExpression(Token token)

    • parseBindableExpression

      void parseBindableExpression()

    • parseBindableExpression

      void parseBindableExpression(boolean bPostfix)

    • parseBindableExpression

      private void parseBindableExpression(Token token)

    • parseBindableExpression

      private void parseBindableExpression(Token token, boolean bPostfix)

    • parseBindingExpression

      private void parseBindingExpression(Token token)

    • parseBindingExpression

      private void parseBindingExpression(Token token, boolean bPostfix)

    • hasMethod_Cached

      private static boolean hasMethod_Cached(IType type, String method)

    • parsePrefixUnitBindingExpression

      private boolean parsePrefixUnitBindingExpression(Token priorToken, String connectorString)

    • unitExprType

      private IType unitExprType(Expression unitExpr)

    • backtrackBinderExpr

      private Expression backtrackBinderExpr(int locationsCount, Expression primExpr)

    • parsePostfixUnitBindingExpression

      private boolean parsePostfixUnitBindingExpression(Token priorToken, String connectorString)

    • tryPostfixUnitExpr

      private boolean tryPostfixUnitExpr(int mark, int locationsCount, Expression lhsExpr, Token priorToken, String connectorString, boolean testConnector)

    • isConnectorStringValid

      private boolean isConnectorStringValid(boolean bPostfix, String connectorString, Expression unitExpr, IType unitBinderType)

    • parseUnitExpression

      private boolean parseUnitExpression()

    • parseUnitExpressionFactor

      private boolean parseUnitExpressionFactor(Token token)

    • hasMethod

      private static boolean hasMethod(IType type, String name)

    • parseBooleanLiteral

      private boolean parseBooleanLiteral(Token token)

    • parseNullLiteral

      private boolean parseNullLiteral(Token token)

    • parseStandAloneDataStructureInitialization

      private boolean parseStandAloneDataStructureInitialization(Token token)

    • parseStandAloneDataStructureInitialization

      private boolean parseStandAloneDataStructureInitialization(Token token, boolean bAvoidContextType, boolean bBacktracking)

    • maybeReparseWithoutContextType

      private boolean maybeReparseWithoutContextType(int mark, int iLocationsCount, Expression initializerExpression)

    • shouldThisExpressionAvoidTheContextType

      private boolean shouldThisExpressionAvoidTheContextType()

    • getTypes

      private List<IType> getTypes(List<? extends IExpression> list)

    • getInitializableType

      private ContextType getInitializableType()

    • getCurrentInitializableContextType

      private ContextType getCurrentInitializableContextType()

    • findImpl

      public static IType findImpl(IType typeToInit)

    • supportsInitializer

      private boolean supportsInitializer(IType type)

    • parseBlockExpression

      private void parseBlockExpression()

    • getBlockReturnType

      private IType getBlockReturnType(IParsedElement blockBody, IType ctxType)

    • getContextTypesForBlockArgument

      private List<IType> getContextTypesForBlockArgument(ContextType ctxType)

    • inferReturnTypeForBlockArgument

      private IType inferReturnTypeForBlockArgument(ContextType contextType, IType[] unbound)

    • parseNewExpression

      void parseNewExpression()
      new-expression new <type-expression> ( [<argument-list>] ) { [<initialization-expression>] } new <type-expression> [ <expression> ] new <type-expression> [] { [<array-value-list>] }

    • parseNewExpressionOrAnnotation

      void parseNewExpressionOrAnnotation(boolean bAnnotation)

    • _parseNewExpressionOrAnnotation

      void _parseNewExpressionOrAnnotation(boolean bAnnotation, boolean bBacktracking)

    • maybeInferTypeLiteralFromContextType

      private TypeLiteral maybeInferTypeLiteralFromContextType()

    • parseNewExpressionOrAnnotation

      void parseNewExpressionOrAnnotation(IType declaringClass, boolean bAnnotation, boolean bNoArgNoParenthesis, TypeLiteral typeLiteral, int mark)

    • maybeChangeToInferredType

      private IType maybeChangeToInferredType(IType declaringClass, TypeLiteral typeLiteral, MethodScore bestConst)

    • scrubAnnotationConstructors

      private void scrubAnnotationConstructors(IType declaringClass, List<IConstructorType> listConstructorTypes)

    • isAnnotation

      private boolean isAnnotation(IType type)

    • getPreliminaryConstructorTypes

      private ArrayList<IConstructorType> getPreliminaryConstructorTypes(IType declaringClass, NewExpression e)

    • parseAnonymousInnerClass

      private IType parseAnonymousInnerClass(IType declaringClass, TypeLiteral typeLiteral, NewExpression newExpr, int state, int mark)

    • _parseAnonymousInnerClass

      private void _parseAnonymousInnerClass(IType declaringClass, IGosuClassInternal gsDeclaringClass, ICompilableTypeInternal enclosingType, int iNameOffset, NewExpression newExpr, int mark)

    • isParsingStaticFeature

      public boolean isParsingStaticFeature()

    • pushParsingStaticMember

      public void pushParsingStaticMember(Boolean bParsingStaticFeature)

    • popParsingStaticMember

      public void popParsingStaticMember()

    • isParsingAbstractConstructor

      public boolean isParsingAbstractConstructor()

    • pushParsingAbstractConstructor

      public void pushParsingAbstractConstructor(Boolean bParsingAbstractConstructor)

    • popParsingAbstractConstructor

      public void popParsingAbstractConstructor()

    • getConstructor

      private IConstructorInfo getConstructor(IType instanceClass)

    • verifyConstructorIsAccessible

      private void verifyConstructorIsAccessible(IType instanceClass, NewExpression e, IConstructorType constructorType, boolean bAnonymous)

    • getModifierString

      private String getModifierString(IConstructorType constructorType)

    • parseObjectInitializer

      private boolean parseObjectInitializer(IType objectType)

    • _parseObjectInitializer

      private boolean _parseObjectInitializer(IType objectType)

    • _doParseObjectInitializer

      private void _doParseObjectInitializer(IType objectType)

    • parseInitializerAssignment

      private boolean parseInitializerAssignment(IType objectType)

    • parseInitializerIdentifier

      private void parseInitializerIdentifier(IType objectType)

    • getGsConstructorInfo

      private GosuConstructorInfo getGsConstructorInfo(IConstructorInfo ci, IGosuClassInternal gsInstanceClass)

    • isConcreteInitializableType

      private boolean isConcreteInitializableType(IType type)

    • isInitializableType

      private boolean isInitializableType(IType type)

    • verifyCanConstructInnerClassFromCallSite

      private void verifyCanConstructInnerClassFromCallSite(NewExpression e, IType innerClass)

    • isConstructingNonStaticInnerClassFromNonStaticContext

      private boolean isConstructingNonStaticInnerClassFromNonStaticContext(IType innersEnclosingClass, IGosuClassInternal constructingFromClass)

    • isNonStaticInnerClassConstructableFromCurrentFunction

      private boolean isNonStaticInnerClassConstructableFromCurrentFunction(IType innersEnclosingClass, IGosuClassInternal constructingFromClass)

    • _parseInitializerExpression

      private void _parseInitializerExpression(ContextType type)

    • getImplicitConstructor

      private IConstructorInfo getImplicitConstructor(IType type)

    • parseCollectionInitializerList

      private void parseCollectionInitializerList(IType type)

    • parseMapInitializerList

      private void parseMapInitializerList(ContextType type)

    • parseArrayValueList

      List<Expression> parseArrayValueList(IType componentType)

    • parseIndirectMemberAccess

      private void parseIndirectMemberAccess(int iOffset, int iLineNum, int iColumn)

    • parseIndirectMemberAccess

      private void parseIndirectMemberAccess(int iOffset, int iLineNum, int iColumn, boolean bParsingTypeLiteralOnly)

    • maybeReplacePackageExprWithTypeLiteral

      private void maybeReplacePackageExprWithTypeLiteral(int iOffset, int iLineNum, int iColumn, Expression expr)

    • maybeReplaceErrantPackageExprWithEnumConstEpr

      private boolean maybeReplaceErrantPackageExprWithEnumConstEpr(int iOffset, int iLineNum, int iColumn, Expression expr)

    • _parseIndirectMemberAccess

      boolean _parseIndirectMemberAccess(boolean bParseTypeLiteralOnly)

    • verifySuperTypeIsDeclaredInCompilingClass

      private IType verifySuperTypeIsDeclaredInCompilingClass(TypeLiteral superTypeLiteral)

    • isSuperCall

      private boolean isSuperCall(Expression rootExpression, Expression indexExpression)

    • parseFeatureLiteral

      private boolean parseFeatureLiteral(Token token, Expression root)

    • parseErrantFeatureLiteralParameterization

      private void parseErrantFeatureLiteralParameterization(FeatureLiteral fle)

    • evalTypes

      private List<IType> evalTypes(List<IExpression> arguments)

    • allTypeLiterals

      private boolean allTypeLiterals(List<IExpression> args)

    • setOperatorLineNumber

      private void setOperatorLineNumber(Expression expression, int operatorLineNumber)

    • parseNameOrMethodCall

      boolean parseNameOrMethodCall(Token token)

    • _parseNameOrMethodCall

      boolean _parseNameOrMethodCall(Token token)

    • parseMethodCall

      private void parseMethodCall(String[] t, int iOffset, int iLineNum, int iColumn, LazyLightweightParserState state, MethodCallExpression e, IType[] typeParameters, String strFunction, ISymbol functionSymbol, int markBeforeTypeArgs, int iLocBeforeTypeArgs, int markAfterTypeArgs)

    • hasParseExceptions

      private boolean hasParseExceptions(Expression expr)

    • maybeParseImpliedThisMethod

      private boolean maybeParseImpliedThisMethod(int iOffset, int iLineNum, int iColumn, LazyLightweightParserState state, String strFunction, int markBeforeTypeArgs, int iLocBeforeTypeArgs)

    • maybeParseImpliedStaticMethod

      private void maybeParseImpliedStaticMethod(int iOffset, int iLineNum, int iColumn, LazyLightweightParserState state, String strFunction, int markBeforeTypeArgs, int iLocBeforeTypeArgs)

    • maybeParseIdentifierAssumingOpenParenIsForParenthesizedExpr

      private void maybeParseIdentifierAssumingOpenParenIsForParenthesizedExpr(String[] t, int iOffset, int iLineNum, int iColumn, IParserState state, MethodCallExpression e, IType[] typeParameters, String strFunction, ISymbol functionSymbol, int mark, int iLocationsCount)

    • backtrack

      void backtrack(int mark, int iLocationsCount)

    • backtrack

      void backtrack(int mark, int iLocationsCount, Expression expr)

    • parseMethodCall

      private void parseMethodCall(String[] t, IParserState state, MethodCallExpression e, IType[] typeParameters, String strFunction, ISymbol functionSymbol)

    • verifyReifiedCallHasProperContext

      private void verifyReifiedCallHasProperContext(MethodCallExpression e)

    • supportPropertyAccessAsGetterCall

      private boolean supportPropertyAccessAsGetterCall(String[] t, String strFunction, IFunctionSymbol function)

    • maybeCaptureSymbol

      private ISymbol maybeCaptureSymbol(MethodCallExpression e, ISymbol functionSymbol)

    • isInSeparateStringTemplateExpression

      private boolean isInSeparateStringTemplateExpression()

    • possiblyResolveFunctionSymbol

      private ISymbol possiblyResolveFunctionSymbol(MethodCallExpression e, String strFunction)

    • isBlockSym

      private boolean isBlockSym(ISymbol functionSymbol)

    • staticRefToNonStaticFunc

      private boolean staticRefToNonStaticFunc(String stFunction, Expression[] eArgs)

    • staticRefToNonStaticProp

      private boolean staticRefToNonStaticProp(String name)

    • boundFunctionType

      private IFunctionType boundFunctionType(IFunctionType funcType)

    • getDFSForFunctionType

      private IDynamicFunctionSymbol getDFSForFunctionType(String strFunction, MethodScore bestMethod)

    • verifyNotCallingOverridableFunctionFromCtor

      private void verifyNotCallingOverridableFunctionFromCtor(MethodCallExpression mce)

    • verifyNotCallingOverridableFunctionFromCtor

      private void verifyNotCallingOverridableFunctionFromCtor(BeanMethodCallExpression mce)

    • isParsingConstructor

      private boolean isParsingConstructor()

    • parsePossibleFunctionParameterization

      private IType[] parsePossibleFunctionParameterization(String name, MethodCallExpression e)

    • parseIdentifier

      private void parseIdentifier(String[] T)

    • parseIdentifier

      private void parseIdentifier(Identifier e, String[] T)

    • verifyReifiedCallHasProperContext

      private void verifyReifiedCallHasProperContext(PropertyAccessIdentifier e, DynamicPropertySymbol dps)

    • parseIdentifierOrTypeLiteralOrEnumConstant

      private void parseIdentifierOrTypeLiteralOrEnumConstant(String[] T, int iOffset, int iLineNum, int iColumn)

    • tryToMakeTypeLiteral

      private void tryToMakeTypeLiteral(String[] T, int iOffset, int iLineNum, int iColumn, String name, Expression errantExpression)

    • parseNamespaceStartOrRelativeType

      private void parseNamespaceStartOrRelativeType(String[] T, boolean bInterface)

    • parseUnqualifiedEnumConstant

      private MemberAccess parseUnqualifiedEnumConstant(String strConstValue)

    • verifyArgCount

      private void verifyArgCount(ParsedElement element, int iArgs, IFunctionType funcType)

    • verifyOverrideNotOnMethodThatDoesNotExtend

      private void verifyOverrideNotOnMethodThatDoesNotExtend(ParsedElement element, DynamicFunctionSymbol dfs)

    • verifyArgCount

      private void verifyArgCount(ParsedElement element, int iArgs, IConstructorType ctorType)

    • parsePlainFunction

      private void parsePlainFunction(IFunctionSymbol functionSymbol)

    • parseDynamicFunction

      private void parseDynamicFunction(Symbol dynamcSymbol)

    • parseMemberAccess

      private void parseMemberAccess(Expression rootExpression, MemberAccessKind kind, int iTokenStart, String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly)

    • parseMemberAccess

      private void parseMemberAccess(Expression rootExpression, MemberAccessKind kind, int iTokenStart, String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty)

    • parseMethodMember

      private void parseMethodMember(Expression rootExpression, MemberAccessKind kind, int iTokenStart, String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty, BeanMethodCallExpression e, IType rootType, boolean bExpansion, IType[] typeParameters, int iParenStart, int mark)

    • maybeOpenParenIsForParenthesizedExpr

      private void maybeOpenParenIsForParenthesizedExpr(Expression rootExpression, MemberAccessKind kind, int iTokenStart, String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty, BeanMethodCallExpression e, IType rootType, boolean bExpansion, IType[] typeParameters, int iParenStart, int mark, int iLocationsCount)

    • isOpenParenOnNextLine

      private boolean isOpenParenOnNextLine(int mark)

    • parseMethodMember

      private void parseMethodMember(Expression rootExpression, MemberAccessKind kind, int iTokenStart, String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, BeanMethodCallExpression e, IType rootType, boolean bExpansion, IType[] typeParameters, int iParenStart)

    • findFunction

      private IFunctionType findFunction(List<IFunctionType> listFunctionTypes, boolean bNoArgsProvided)

    • verifyReifiedCallHasProperContext

      private void verifyReifiedCallHasProperContext(BeanMethodCallExpression e)

    • parsePropertyMember

      private void parsePropertyMember(Expression rootExpression, MemberAccessKind kind, int iTokenStart, String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty, IType rootType, boolean bExpansion)

    • verifyReifiedCallHasProperContext

      private void verifyReifiedCallHasProperContext(MemberAccess e)

    • verifySuperAccess

      private void verifySuperAccess(Expression rootExpression, Expression memberExpr, IAttributedFeatureInfo feature, String strMemberName)

    • shouldParseMemberInstead

      private boolean shouldParseMemberInstead(String strMemberName, IType rootType, IType memberType)

    • isEndOfArgExpression

      private boolean isEndOfArgExpression()

    • isParenthesisTerminalExpression

      private boolean isParenthesisTerminalExpression()

    • isParenthesisTerminalExpression

      private boolean isParenthesisTerminalExpression(boolean bMatchOpeningParen)

    • isEndOfExpression

      private boolean isEndOfExpression()

    • getInnerClass

      private IType getInnerClass(String strMemberName, IType memberType, IHasInnerClass typeLiteralType)

    • maybeParameterizeOnCtxType

      private IFunctionType maybeParameterizeOnCtxType(IFunctionType funcType)

    • getPreliminaryFunctionTypes

      private List<IFunctionType> getPreliminaryFunctionTypes(String strMemberName, BeanMethodCallExpression e, IType rootType, IType[] typeParameters)

    • addJavaPropertyMethods

      private void addJavaPropertyMethods(String strMemberName, IType rootType, List<IFunctionType> listFunctionTypes)

    • maybeGetProxiedPropertyInfo

      private IPropertyInfo maybeGetProxiedPropertyInfo(String propName, IPropertyInfo pi)

    • isBlockInvoke

      private boolean isBlockInvoke(Expression rootExpression, String strMemberName, IType rootType)

    • isErrorType

      private boolean isErrorType(IType rootType)

    • parameterizeFunctionTypes

      private ArrayList<IFunctionType> parameterizeFunctionTypes(Expression expression, IType[] typeParameters, List<IFunctionType> listFunctionTypes)

    • handleAbstractCtor

      private void handleAbstractCtor(int iTokenStart, String strMemberName, BeanMethodCallExpression e, IParserState state)

    • verifyCanParameterizeType

      private boolean verifyCanParameterizeType(ParsedElement elem, IType type, IType[] typeParam)

    • isTypeParamHeaderCompiling

      private boolean isTypeParamHeaderCompiling(IType typeParam)

    • parseFunctionParameterization

      private IType[] parseFunctionParameterization(Expression e)

    • parseArgumentList

      private MethodScore parseArgumentList(IType rootType, ParsedElement element, List<? extends IInvocableType> listFunctionTypes, IType[] typeParams, boolean bVerifyArgs, boolean bNoArgsProvided)

    • findLeastParams

      private MethodScore findLeastParams(List<MethodScore> scoredMethods)
      Param count is the tiebreaker when vararg methods are involved. The only way there can be valid method calls differing by param count is when one or more vararg methods match. If a non-vararg method matches with fewer params, this indicates the vararg method matched because the vararg argument was not present in the call.

    • reparseWithCorrectFunctionAndGtfo

      private MethodScore reparseWithCorrectFunctionAndGtfo(MethodScore bestScore, boolean bShouldScoreMethods, List<Expression> argExpressions, ParsedElement element, int mark, int iLocationsCount, IType rootType, IType[] typeParams, boolean bVerifyArgs, boolean bNoArgsProvided)

    • reparseErrorsAreDifferent

      private boolean reparseErrorsAreDifferent(TypeVarToTypeMap inferenceMap, List<Expression> argExpressions)

    • errorsSame

      private boolean errorsSame(List<IParseIssue> newErrors, List<IParseIssue> errors)

    • reparseArguments

      private MethodScore reparseArguments(MethodScore bestScore, List<Expression> argExpressions, ParsedElement element, int mark, int iLocationsCount, IType rootType, IType[] typeParams, boolean bVerifyArgs, boolean bNoArgsProvided)

    • maskCurrentFunctionTypeVarsFromPriorInference

      private TypeVarToTypeMap maskCurrentFunctionTypeVarsFromPriorInference()

    • maybeInferFunctionTypeVarsFromReturnType

      private void maybeInferFunctionTypeVarsFromReturnType(IInvocableType invType, TypeVarToTypeMap inferenceMap)

    • factorInParseErrors

      private List<MethodScore> factorInParseErrors(List<MethodScore> scoredMethods)

    • hasContextSensitiveExpression

      private boolean hasContextSensitiveExpression(List<Expression> argExpressions)

    • isGenericMethodCall

      private boolean isGenericMethodCall(Expression e)

    • maybeAvoidNestedMethodScoring

      private List<? extends IInvocableType> maybeAvoidNestedMethodScoring(List<? extends IInvocableType> listFunctionTypes)

    • backtrackArgParsing

      private void backtrackArgParsing(int mark, int iLocationsCount, List<Expression> argExpressions)

    • maybeRemoveNonGenericMethods

      private List<? extends IInvocableType> maybeRemoveNonGenericMethods(List<? extends IInvocableType> listFunctionTypes, IType[] typeParams)

    • maybeReassignOffsetForArgumentListClause

      private void maybeReassignOffsetForArgumentListClause(int iArgs, List<Expression> argExpressions, int iOffset, int iLineNum, int iColumn)

    • maybeBoundFunctionTypeVars

      private IInvocableType maybeBoundFunctionTypeVars(IInvocableType inferredFunctionType, TypeVarToTypeMap inferenceMap)

    • assignArgExprPosition

      private List<Integer> assignArgExprPosition(List<? extends IInvocableType> listFunctionTypes, int iArgs, List<Integer> namedArgOrder, int iArgPos)

    • addMisingArgsWithDefaultValues

      void addMisingArgsWithDefaultValues(ParsedElement element, IInvocableType funcType, List<Expression> argExpressions, List<LightweightParserState> parserStates, boolean bShouldScoreMethods)

    • parseArgExpression

      private int parseArgExpression(IInvocableType funcType, int iArgs, List<Expression> argExpressions, TypeVarToTypeMap inferenceMap, List<LightweightParserState> parserStates, Set<String> namedArgs, boolean bMethodScoring)

    • useDynamicTypeIfDynamicRoot

      private IType useDynamicTypeIfDynamicRoot(IInvocableType funcType, IType ctxType)

    • getDefaultValueOrPlaceHolderForParam

      private Expression getDefaultValueOrPlaceHolderForParam(int iParam, IInvocableType invType)

    • parseNamedParamExpression

      private int parseNamedParamExpression(IInvocableType invType, boolean bMethodScoring)

    • getParamTypeFromParamName

      private IType getParamTypeFromParamName(IInvocableType invType, String strParam, int[] iPos)

    • parseNamedParamIdentifier

      private void parseNamedParamIdentifier()

    • isDynamicMethod

      private boolean isDynamicMethod(List<? extends IInvocableType> listFunctionTypes)

    • makeDynamicMethodScore

      private MethodScore makeDynamicMethodScore(List<? extends IInvocableType> listFunctionTypes, List<Expression> argExpressions)

    • getParamTypes

      private IType[] getParamTypes(List<Expression> argExpressions)

    • scoreMethod

      private MethodScore scoreMethod(IType callsiteEnclosingType, IType rootType, IInvocableType funcType, List<? extends IInvocableType> listFunctionTypes, List<Expression> argExpressions, boolean bSimple, boolean bLookInCache)

    • boundCtxType

      private IType boundCtxType(IType ctxType)

    • boundCtxType

      private IType boundCtxType(IType ctxType, boolean bKeepTypeVars)

    • inferFunctionTypeVariables

      private void inferFunctionTypeVariables(IType rawContextType, IType boundContextType, Expression expression, TypeVarToTypeMap inferenceMap)

    • inferArgType

      private IType inferArgType(IType contextType, TypeVarToTypeMap inferenceMap)

    • handleImplicitCoercionsInArgs

      private void handleImplicitCoercionsInArgs(ParsedElement element, IType[] argTypes, IType[] rawArgTypes, List<Expression> args)

    • extractContextTypes

      private List<List<IType>> extractContextTypes(List<? extends IInvocableType> funcTypes)

    • verifyArgTypes

      private void verifyArgTypes(IType[] argTypes, List<Expression> argExpressions, List<LightweightParserState> parserStates)

    • parseLiteral

      void parseLiteral(Token token)

    • _parseLiteral

      void _parseLiteral(Token token)

    • parseRelativeFeatureLiteral

      private boolean parseRelativeFeatureLiteral(Token token)

    • parseNumberLiteral

      private boolean parseNumberLiteral(Token token)

    • atNumberLiteralStart

      private boolean atNumberLiteralStart()

    • parseNumberLiteral

      private boolean parseNumberLiteral(Token token, boolean negated)

    • parseNumericValue

      private void parseNumericValue(String strValue)

    • parseIntOrLongOrBigInt

      private NumericLiteral parseIntOrLongOrBigInt(String strValue)

    • stripPrefix

      private String stripPrefix(String strValue)

    • parseDoubleOrBigDec

      private NumericLiteral parseDoubleOrBigDec(String strValue)

    • parseFloat

      private NumericLiteral parseFloat(String strValue)

    • parseDouble

      private NumericLiteral parseDouble(String strValue)

    • parseExplicitlyTypedNumericLiteral

      private void parseExplicitlyTypedNumericLiteral(String strValue, IType numericTypeFrom)

    • isPrefixNumericLiteral

      private boolean isPrefixNumericLiteral(String strValue)

    • parsePrefixNumericLiteral

      private void parsePrefixNumericLiteral(String strValue, IType numericTypeFrom)

    • isHexLiteral

      private boolean isHexLiteral(String num)

    • isBinLiteral

      private boolean isBinLiteral(String num)

    • parsePostfixNumericLiteral

      private void parsePostfixNumericLiteral(String num, IType numericTypeFrom, int radix)

    • maybeStripTypeModifier

      private String maybeStripTypeModifier(String strValue, IType numericTypeFrom)

    • hasTypeModifier

      private boolean hasTypeModifier(String strValue)

    • pushErrorNumberLiteral

      private void pushErrorNumberLiteral(ResourceKey key, Object... args)

    • getNumericTypeFrom

      private IType getNumericTypeFrom(String strValue)

    • parseCharLiteral

      private boolean parseCharLiteral(Token token)

    • parseStringLiteralSeparately

      private boolean parseStringLiteralSeparately()

    • parseStringLiteral

      private boolean parseStringLiteral(Token token)

    • _parseStringLiteral

      private void _parseStringLiteral(boolean bUnterminatedLiteral, Token t)

    • parseTemplatizedStringLiteral

      private TemplateStringLiteral parseTemplatizedStringLiteral(Token t)

    • parseTypeLiteral

      public boolean parseTypeLiteral()
      Description copied from interface: IGosuParser
      Consumes a type literal from the current tokenizer, if one exists.
      Specified by:
      parseTypeLiteral in interface IGosuParser
      Returns:
      true if a type literal was found, false otherwise

    • parseTypeLiteral

      public boolean parseTypeLiteral(Token token)

    • parseTypeLiteral

      boolean parseTypeLiteral(boolean bInterface)

    • parseTypeLiteral

      boolean parseTypeLiteral(Token token, boolean bInterface)

    • parseTypeLiteralForNewExpression

      void parseTypeLiteralForNewExpression()

    • _parseTypeLiteralWithAggregateSyntax

      boolean _parseTypeLiteralWithAggregateSyntax(Token token, boolean bIgnoreArrayBrackets, boolean bInterface)

    • _parseTypeLiteral

      boolean _parseTypeLiteral(Token token, boolean bIgnoreArrayBrackets, boolean bInterface)

    • matchPrimitiveType

      boolean matchPrimitiveType(boolean bSuperThis)

    • parseAggregateTypeLiteral

      private void parseAggregateTypeLiteral(boolean bInterface)

    • addToCompoundType

      private void addToCompoundType(List<IType> types)

    • parseBlockLiteral

      void parseBlockLiteral()

    • _parseBlockLiteral

      void _parseBlockLiteral()

    • parseTypeLiteral

      void parseTypeLiteral(String[] T, boolean bIgnoreArrayBrackets, boolean bInterface, int iOffset, int iLineNum, int iColumn)

    • verifyTypeAccessible

      private void verifyTypeAccessible(TypeLiteral expr, IType type)

    • parseCompoundTypeLiteralExpression

      private void parseCompoundTypeLiteralExpression(String[] T, boolean bInterface, int iOffset, int iLineNum, int iColumn)

    • isTypeParameterErrorMsg

      private boolean isTypeParameterErrorMsg(Expression expr, List<IParseIssue> exceptions)

    • resolveArrayOrParameterizationPartOfTypeLiteral

      private boolean resolveArrayOrParameterizationPartOfTypeLiteral(String[] T, boolean bIgnoreArrayBrackets, TypeLiteral e)
      Returns:
      True if parsed parameterized type.

    • isParsingCompileTimeConstantExpression

      private boolean isParsingCompileTimeConstantExpression()

    • parseArrayType

      private boolean parseArrayType(TypeLiteral tl)

    • parseTypeParameters

      List<TypeLiteral> parseTypeParameters(IType enclosingType)

    • makeTypeParameterListClause

      private void makeTypeParameterListClause(int iOffset, int iLineNum, int iColumn, List<TypeLiteral> paramTypes)

    • parseParameterType

      boolean parseParameterType(IType boundingType)

    • boxTypeLiteralsType

      private void boxTypeLiteralsType(TypeLiteral tl)

    • parseStatement

      boolean parseStatement()

    • parseStatement

      boolean parseStatement(boolean bAsStmtBlock)

    • parseStatement

      boolean parseStatement(boolean forceKeepStmtBlock, boolean bAsStmtBlock)

    • hasSemicolon

      private boolean hasSemicolon(IParsedElement stmt)

    • parseLoopStatement

      boolean parseLoopStatement()

    • _parseStatement

      boolean _parseStatement()

    • parseAssertStatement

      private void parseAssertStatement()

    • areUsingStatementsAllowedInStatementLists

      private boolean areUsingStatementsAllowedInStatementLists()

    • getStatementDepth

      private int getStatementDepth()

    • incStatementDepth

      private void incStatementDepth()

    • decStatementDepth

      private void decStatementDepth()

    • parseLocalVarStatement

      void parseLocalVarStatement(VarStatement varStmt)

    • parseVarStatement

      void parseVarStatement(VarStatement varStmt, Token idToken, boolean bClassMember)

    • isLocalVarTopLevelFunctionBodyStmt

      private boolean isLocalVarTopLevelFunctionBodyStmt()

    • detectLikelyJavaCast

      private void detectLikelyJavaCast(Expression eas)

    • recoverFromJavaStyleCast

      private boolean recoverFromJavaStyleCast(Expression eas)

    • parseVarPropertyClause

      DynamicPropertySymbol parseVarPropertyClause(VarStatement varStmt, ModifierInfo modifiers, String strVarIdentifier, IType varType, boolean parseInitializer)

    • makeProperties

      DynamicPropertySymbol makeProperties(VarStatement varStmt, String strVarIdentifier, String strPropertyName, IType varType, ModifierInfo modifiers, boolean bGetter, boolean bSetter)

    • makeGetter

      private DynamicPropertySymbol makeGetter(VarStatement varStmt, String strVarIdentifier, String strPropertyName, IType varType, ModifierInfo modifiers, ISymbol symbol, ICompilableType gsClass, boolean bOldSyntax)

    • makeSetter

      private DynamicPropertySymbol makeSetter(VarStatement varStmt, String strVarIdentifier, String strPropertyName, IType varType, ModifierInfo modifiers, ISymbol symbol, ICompilableType gsClass, DynamicPropertySymbol dps, boolean bOldSyntax)

    • transferModifierInfo

      private void transferModifierInfo(VarStatement varStmt, ModifierInfo modifiers, AnnotationUseSiteTarget target, DynamicFunctionSymbol dfs)

    • transferModifierInfo

      private void transferModifierInfo(ParsedElement stmt, ModifierInfo modifiers, AnnotationUseSiteTarget target, EnhancementDynamicFunctionSymbol dfs)

    • setFromTargetModifier

      static void setFromTargetModifier(IGosuAnnotation anno, ModifierInfo modifierInfo)

    • appliesToElementType

      private boolean appliesToElementType(IGosuAnnotation anno, ElementType elemType)

    • parseDelegateStatement

      void parseDelegateStatement(DelegateStatement delegateStmt, String strIdentifier)

    • parseSwitchStatement

      private void parseSwitchStatement()

    • parseDoWhileStatement

      private void parseDoWhileStatement()

    • verifyLoopConditionNotAlwaysFalse

      private void verifyLoopConditionNotAlwaysFalse(Expression e)

    • parseWhileStatement

      private void parseWhileStatement()

    • parseForEachStatement

      private void parseForEachStatement()

    • parseIndexVar

      private void parseIndexVar(ForEachStatement forEachStmt)

    • parseIteratorVar

      private void parseIteratorVar(ForEachStatement forEachStmt, IType type)

    • parseReturnStatement

      private void parseReturnStatement()

    • inConstructorCtx

      private boolean inConstructorCtx()

    • setReturnNullExpr

      private void setReturnNullExpr(ReturnStatement returnStmt, boolean bProgramCallFunction)

    • parseThrowStatement

      private void parseThrowStatement()

    • parseTryCatchFinallyStatement

      private void parseTryCatchFinallyStatement()

    • parseIfStatement

      private void parseIfStatement()

    • parseUsingStatement

      private void parseUsingStatement()

    • parseVarStatementsInUsingStatement

      private void parseVarStatementsInUsingStatement(UsingStatement usingStmt)

    • verifyTypeForUsingStatementPredicate

      private void verifyTypeForUsingStatementPredicate(ParsedElement pe, IType type)

    • isAssignableFrom

      private boolean isAssignableFrom(IType type1, IType type2)

    • maybeRemoveIMonitorLockError

      private void maybeRemoveIMonitorLockError(ParsedElement pe)

    • parseStatementBlock

      private void parseStatementBlock()

    • parseStatementBlock

      private void parseStatementBlock(boolean bMatchClosingBrace)

    • parseStatementBlock

      private void parseStatementBlock(boolean forceKeepStmtBlock, boolean bMatchClosingBrace)

    • parseNamespaceStatement

      void parseNamespaceStatement()

    • parseNamespaceStatement_editor

      void parseNamespaceStatement_editor()

    • parseNamespaceStatement_normal

      void parseNamespaceStatement_normal()

    • parseUsesStatementList

      public UsesStatementList parseUsesStatementList(boolean bResolveUsesTypes)
      Specified by:
      parseUsesStatementList in interface IGosuParser

    • parseUsesStatement

      void parseUsesStatement()

    • parseUsesStatement

      void parseUsesStatement(boolean bResolveTypes)

    • processUsesStatementFeatureLiteral

      private void processUsesStatementFeatureLiteral(boolean bResolveTypes, UsesStatement usesStmt, TypeLiteral typeLiteral, FeatureLiteral fl)

    • processUsesStatement

      private void processUsesStatement(UsesStatement usesStmt, TypeLiteral typeLiteral, IFeatureInfo fi, IGosuClass gsType)

    • getAllStaticFeatures

      private List<IAttributedFeatureInfo> getAllStaticFeatures(IGosuClass gsType, String name)

    • processUsesStatementTypeLiteral

      private void processUsesStatementTypeLiteral(boolean bResolveTypes, UsesStatement usesStmt, TypeLiteral typeLiteral)

    • parseCaseClauses

      void parseCaseClauses(SwitchStatement switchStmt)

    • parseCaseClause

      boolean parseCaseClause(SwitchStatement switchStmt, List<CaseClause> cases)

    • verifyCaseIsUnique

      private void verifyCaseIsUnique(Expression e, List<CaseClause> cases)

    • isIsolatedCase

      private boolean isIsolatedCase(List<CaseClause> cases)

    • warnIfCaseNotTerminated

      private void warnIfCaseNotTerminated(List<Statement> statements)

    • parseDefaultClause

      boolean parseDefaultClause(SwitchStatement switchStmt, List<CaseClause> cases)

    • checkInstruction

      void checkInstruction(boolean bProcessDirectives)

    • checkUnexpectedEof

      private void checkUnexpectedEof()

    • clearExpressionInTemplateUnlessParsingEvaluateFunctionBody

      private void clearExpressionInTemplateUnlessParsingEvaluateFunctionBody(Expression e)

    • removeInnerClasses

      private void removeInnerClasses(IParsedElement e)

    • removeLocation

      private void removeLocation(ParseTree location)

    • parseDirective

      private void parseDirective(boolean processDirectives)

    • parseAssignmentOrMethodCall

      boolean parseAssignmentOrMethodCall()

    • parseAssignment

      private void parseAssignment(Expression e, String assignOp)

    • isParsingProgramEvaluateMethod

      private boolean isParsingProgramEvaluateMethod()

    • isSymbolInScopeDirectly

      private boolean isSymbolInScopeDirectly(ISymbol idSym)

    • parseAssignmentRhs

      private Expression parseAssignmentRhs(String operation, IType typeExpected, Expression lhs)

    • buildRhsOfCompoundOperator

      private Expression buildRhsOfCompoundOperator(Expression lhs, String assignOp, Expression rhs)

    • matchAssignmentOperator

      private String matchAssignmentOperator()

    • matchRightShiftAssign

      private String matchRightShiftAssign()

    • parseFunctionOrPropertyDeclaration

      ISymbol parseFunctionOrPropertyDeclaration(ParsedElement element)

    • parsePropertyDefinition

      boolean parsePropertyDefinition()

    • getOrCreateDynamicPropertySymbol

      DynamicPropertySymbol getOrCreateDynamicPropertySymbol(ParsedElement parsedElement, IGosuClassInternal gsClass, DynamicFunctionSymbol dfs, boolean bGetter)

    • parseFunctionDefinition

      boolean parseFunctionDefinition()

    • parseBaseFunctionDefinition

      FunctionStatement parseBaseFunctionDefinition(FunctionStatement functionStmt, boolean bProperty, boolean bGetter, ModifierInfo modifiers)

    • getLastStatement

      private Statement getLastStatement(Statement statement)

    • isValidAnnotationMethodReturnType

      private boolean isValidAnnotationMethodReturnType(IType returnType)

    • putThisAndSuperSymbols

      private void putThisAndSuperSymbols(ModifierInfo modifiers)

    • findProgramPropertyDfs

      private DynamicFunctionSymbol findProgramPropertyDfs(String strFunctionName, ArrayList<ISymbol> args)

    • getTypeVarDefsFromDecl

      private List<TypeVariableDefinitionImpl> getTypeVarDefsFromDecl(IGenericTypeVariable[] typeVars)

    • findCorrespondingDeclDfs

      private DynamicFunctionSymbol findCorrespondingDeclDfs(int iOffsetName, int iModifiers)

    • isDeclarationKeyword

      boolean isDeclarationKeyword(String strKeyword)

    • assignPossibleDuplicateDfs

      static DynamicFunctionSymbol assignPossibleDuplicateDfs(DynamicFunctionSymbol dfsDecl, Iterable symbols)

    • addNameInDeclaration

      void addNameInDeclaration(String strName, int iOffsetName, int iLineNumName, int iColumnName, boolean bHasName)

    • parsingFunctionsEncloseMyClass

      private boolean parsingFunctionsEncloseMyClass()

    • parseProgramEntryPointBody

      FunctionStatement parseProgramEntryPointBody()

    • getProgramEntryPointDfs

      private DynamicFunctionSymbol getProgramEntryPointDfs()

    • handleExpressionStatementList

      private StatementList handleExpressionStatementList(Expression expr)

    • wrapProgramExpressionInReturnStmt

      private ReturnStatement wrapProgramExpressionInReturnStmt(Expression e)

    • addDefaultReturnStmt

      private void addDefaultReturnStmt(DynamicFunctionSymbol dfsDecl, StatementList stmtList)

    • parseProgramFunctionBody

      private boolean parseProgramFunctionBody(FunctionType type)

    • parseProgramExpr

      private void parseProgramExpr()

    • maybeSetExternalSymbols

      private void maybeSetExternalSymbols()

    • removeLocationsFrom

      void removeLocationsFrom(int iLocationsCount)

    • isTerminal

      private boolean isTerminal(Statement statement, IType returnType)

    • parseFunctionBody

      private boolean parseFunctionBody(FunctionStatement functionStmt, FunctionType type)

    • parseFunctionDecl

      DynamicFunctionSymbol parseFunctionDecl(ParsedElement element, ModifierInfo modifiers)

    • parseFunctionDecl

      DynamicFunctionSymbol parseFunctionDecl(ParsedElement element, boolean bProperty, boolean bGetter, ModifierInfo modifiers)

    • parseFunctionDecl

      DynamicFunctionSymbol parseFunctionDecl(ParsedElement element, String T, boolean bProperty, boolean bGetter, ModifierInfo modifiers)

    • matchNonDeclarationKeyword

      private boolean matchNonDeclarationKeyword()

    • maybeEatNonDeclKeyword

      boolean maybeEatNonDeclKeyword(boolean bHasName, String strFunctionName)

    • verifyFunction

      private void verifyFunction(DynamicFunctionSymbol dfs, ParsedElement element)

    • verifyReified

      private void verifyReified(boolean bValidOverrideFound, ParsedElement element, DynamicFunctionSymbol dfs)

    • areParametersEquivalent_Enhancement

      private boolean areParametersEquivalent_Enhancement(DynamicFunctionSymbol dfs1, DynamicFunctionSymbol dfs2)

    • maybeAddPrivateFunctionsIfSuperInSamePackage

      private List<IFunctionSymbol> maybeAddPrivateFunctionsIfSuperInSamePackage(String name, List<IFunctionSymbol> functions)

    • addAllNonstaticPrivateMethods

      private void addAllNonstaticPrivateMethods(String name, IGosuClassInternal superClass, List<IFunctionSymbol> functions)

    • propertyTypeDiffers

      private boolean propertyTypeDiffers(DynamicFunctionSymbol dfs, DynamicFunctionSymbol dfsExisting)

    • verifySameNumberOfFunctionTypeVars

      private void verifySameNumberOfFunctionTypeVars(ParsedElement element, DynamicFunctionSymbol dfs, DynamicFunctionSymbol dfsExisting)

    • areDFSsInSameNameSpace

      private boolean areDFSsInSameNameSpace(IDynamicSymbol newDfs, IDynamicSymbol existingDfs)

    • verifyNoImplicitPropertyMethodConflicts

      private void verifyNoImplicitPropertyMethodConflicts(ParsedElement element, DynamicFunctionSymbol dfs)

    • verifyFunctionConflictsWithPropoertySetter

      void verifyFunctionConflictsWithPropoertySetter(ParsedElement element, DynamicFunctionSymbol dfs, DynamicPropertySymbol dps)

    • verifyPropertySetterConflictsWithFunction

      void verifyPropertySetterConflictsWithFunction(ParsedElement element, DynamicFunctionSymbol dfs, String propName, DynamicFunctionSymbol existingDfs)

    • returnTypesCompatible

      private boolean returnTypesCompatible(DynamicFunctionSymbol dfsExisting, DynamicFunctionSymbol dfs)

    • areParametersEquivalent

      private boolean areParametersEquivalent(IDynamicFunctionSymbol dfs, IDynamicFunctionSymbol dfsExisting, IType... extraParams)

    • _areParametersEquivalent

      private boolean _areParametersEquivalent(IDynamicFunctionSymbol dfs1, IDynamicFunctionSymbol dfs2, IType[] args, IType[] toArgs)

    • maybeResolveFunctionTypeVars

      private IType maybeResolveFunctionTypeVars(IDynamicFunctionSymbol dfs, IType type)

    • doParametersReifyToSameBytecodeType

      public boolean doParametersReifyToSameBytecodeType(IDynamicFunctionSymbol dfs, IDynamicFunctionSymbol dfsExisting)

    • doTypesReifyToTheSameBytecodeType

      boolean doTypesReifyToTheSameBytecodeType(IType toArg, IType arg)

    • getOwningTypeForDfs

      private IGosuClass getOwningTypeForDfs(IDynamicSymbol dfs)

    • verifyNotWeakerAccess

      private void verifyNotWeakerAccess(ParsedElement element, DynamicFunctionSymbol dfs, DynamicFunctionSymbol dfsExisting)

    • parseParameterDeclarationList

      public ArrayList<ISymbol> parseParameterDeclarationList(IParsedElement element, boolean bStatic, List<IType> inferredArgumentTypes)
      Specified by:
      parseParameterDeclarationList in interface IGosuParser

    • parseParameterDeclarationList

      public ArrayList<ISymbol> parseParameterDeclarationList(IParsedElement element, boolean bStatic, List<IType> inferredArgumentTypes, boolean bProperty, boolean bGetter, boolean bEmpty, boolean bVarDynamicArg)

    • parseLocalAnnotations

      private List<IGosuAnnotation> parseLocalAnnotations(List<IGosuAnnotation> annotations)

    • parseTypeVariableDefs

      List<ITypeVariableDefinitionExpression> parseTypeVariableDefs(ParsedElement parsedElem, boolean bFunction, List<TypeVariableDefinitionImpl> typeVarDefListFromDecl)

    • parseTypeVariableDefList

      List<ITypeVariableDefinitionExpression> parseTypeVariableDefList(ParsedElement parsedElem, boolean bForFunction, List<TypeVariableDefinitionImpl> typeVarDefListFromDecl)

    • typeVarExists

      public boolean typeVarExists(Map<String,ITypeVariableDefinition> typeVarMap, TypeVariableDefinition typeVarDef)

    • parseTypeVariableDefinition

      void parseTypeVariableDefinition(ParsedElement parsedElem, TypeVariableDefinition typeVarDef, boolean bFirstPass)

    • _parseTypeVariableDefinition

      boolean _parseTypeVariableDefinition(ParsedElement parsedElem, TypeVariableDefinition typeVarDef, boolean bFirstPass)

    • parseVariance

      private void parseVariance(ParsedElement parsedElem, TypeVariableDefinition typeVarDef)

    • getEnclosingType

      private IType getEnclosingType()

    • isCompilingOrReparsingHeader

      private boolean isCompilingOrReparsingHeader()

    • pushExpression

      protected void pushExpression(Expression e)
      Overrides:
      pushExpression in class ParserBase

    • maybeVerifyDoubleLiterals

      private void maybeVerifyDoubleLiterals(Expression e)

    • maybeVerifyDoubleLiteral

      private void maybeVerifyDoubleLiteral(IExpression oneSide, IExpression otherSide)

    • popExpression

      public Expression popExpression()
      Specified by:
      popExpression in interface IGosuParser
      Overrides:
      popExpression in class ParserBase

    • setTokenizer

      public void setTokenizer(ISourceCodeTokenizer tokenizer)
      Specified by:
      setTokenizer in interface IGosuParser

    • peekExpression

      protected Expression peekExpression()
      Overrides:
      peekExpression in class ParserBase

    • peekParsedElement

      protected ParsedElement peekParsedElement()

    • pushStatement

      protected void pushStatement(Statement stmt)
      Overrides:
      pushStatement in class ParserBase

    • popStatement

      protected Statement popStatement()
      Overrides:
      popStatement in class ParserBase

    • peekStatement

      protected Statement peekStatement()
      Overrides:
      peekStatement in class ParserBase

    • pushDynamicFunctionSymbol

      protected void pushDynamicFunctionSymbol(DynamicFunctionSymbol stmt)

    • popDynamicFunctionSymbol

      protected DynamicFunctionSymbol popDynamicFunctionSymbol()

    • peekDynamicFunctionSymbol

      protected DynamicFunctionSymbol peekDynamicFunctionSymbol()

    • clearDfsStack

      protected void clearDfsStack()

    • putDfsDeclsInTable

      public void putDfsDeclsInTable(ISymbolTable table)
      Specified by:
      putDfsDeclsInTable in interface IGosuParser

    • putDfsDeclInSetByName

      public void putDfsDeclInSetByName(IDynamicFunctionSymbol dfs)
      Specified by:
      putDfsDeclInSetByName in interface IGosuParser

    • nextIndexOfErrantDuplicateDynamicSymbol

      public int nextIndexOfErrantDuplicateDynamicSymbol(IDynamicSymbol ds, Collection<? extends ISymbol> symbols, boolean bCheckContains)

    • symbolIn

      private boolean symbolIn(IDynamicSymbol ds, Collection<? extends ISymbol> symbols)

    • setDfsDeclInSetByName

      public void setDfsDeclInSetByName(Map<String,List<IFunctionSymbol>> dfsDecl)
      Specified by:
      setDfsDeclInSetByName in interface IGosuParser

    • newDfsDeclInSetByName

      protected void newDfsDeclInSetByName()

    • getDfsDecls

      public Map<String,List<IFunctionSymbol>> getDfsDecls()
      Specified by:
      getDfsDecls in interface IGosuParser

    • getFunctionTypesForName

      protected List<IFunctionType> getFunctionTypesForName(String strFunctionName)

    • resolveTypeLiteral

      protected TypeLiteral resolveTypeLiteral(String[] T)

    • resolveTypeLiteral

      protected TypeLiteral resolveTypeLiteral(String[] T, boolean bRelative, boolean bInterface)

    • getDfsDeclsForFunction

      protected List<IFunctionSymbol> getDfsDeclsForFunction(String strFunctionName)

    • resolveTypeLiteral

      public TypeLiteral resolveTypeLiteral(String strTypeName)
      Resolves the type literal given by strTypeName. If parentType is non null then strTypeName is assumed relative to the given parent.
      Specified by:
      resolveTypeLiteral in interface IGosuParser
      Parameters:
      strTypeName -

    • resolveTypeLiteral

      public TypeLiteral resolveTypeLiteral(String strTypeName, boolean bRelative, boolean bInterface)

    • resolveTypeName

      private IType resolveTypeName(String strTypeName, boolean bRelative)

    • getTypeVarDef

      private ITypeVariableDefinition getTypeVarDef(String strTypeName)

    • getEnclosingTypeVars

      private Map<String,TypeVariableDefinition> getEnclosingTypeVars()

    • resolveTypeByRelativeName

      private IType resolveTypeByRelativeName(String strTypeName)

    • getTypeVariables

      public HashMap<String,ITypeVariableDefinition> getTypeVariables()
      Specified by:
      getTypeVariables in interface IGosuParser

    • setTypeVariables

      protected void setTypeVariables(HashMap<String,ITypeVariableDefinition> map)

    • parseClass

      public IGosuClassInternal parseClass(String strQualifiedClassName, ISourceFileHandle sourceFile, boolean bThrowOnWarnings, boolean bFullyCompile) throws ParseResultsException
      Description copied from interface: IGosuParser
      For use by code editors etc.
      Specified by:
      parseClass in interface IGosuParser
      Throws:
      ParseResultsException

    • getFunctionType

      public IFunctionType getFunctionType(IType classBean, String functionName, Expression[] eArgs, List<IFunctionType> listAllMatchingMethods, GosuParser parser, boolean bMatchParamTypes) throws ParseException
      Throws:
      ParseException

    • checkForStaticMethod

      private void checkForStaticMethod(IType classBean, Expression[] eArgs, String strMethod, GosuParser parserState) throws ParseException
      Throws:
      ParseException

    • inferFunctionType

      private IInvocableType inferFunctionType(IInvocableType funcType, List<? extends IExpression> eArgs, boolean bUseCtx, TypeVarToTypeMap inferenceMap)

    • inferConstructor

      private IInvocableType inferConstructor(ConstructorType ctorType, TypeVarToTypeMap inferenceMap)

    • inferFunction

      private IInvocableType inferFunction(IInvocableType funcType, List<? extends IExpression> eArgs, boolean bUseCtx, TypeVarToTypeMap inferenceMap)

    • getPropertyNameFromMethodName

      private String getPropertyNameFromMethodName(String strMethod)

    • getPropertyNameFromMethodNameIncludingSetter

      private String getPropertyNameFromMethodNameIncludingSetter(String strMethod)

    • getPropertyNameFromMethodName

      private String getPropertyNameFromMethodName(String strPrefix, String strMethod)

    • verifyPropertyWritable

      private void verifyPropertyWritable(IType classRoot, String strProperty, boolean bFromObjInitializer) throws ParseException
      Throws:
      ParseException

    • getConstructorType

      public IConstructorType getConstructorType(IType classBean, Expression[] eArgs, List<IConstructorType> listAllMatchingMethods, ParserBase parserState) throws ParseException
      Get the type of the method specified in the member path.
      Parameters:
      classBean - The declaring class of the constructor.
      parserState - The parserState that may be involved in the process of parsing a constructor. Can be null.
      Returns:
      A Gosu type for the constructor.
      Throws:
      ParseException

    • verifyCase

      private void verifyCase(ParsedElement element, String foundName, String actualName, ResourceKey errorKey, boolean isEndsWithMatchOK)

    • verifyCase

      private void verifyCase(ParsedElement element, String foundName, String actualName, IParserState state, ResourceKey errorKey, boolean isEndsWithMatchOK)

    • setWarnOnCaseIssue

      public void setWarnOnCaseIssue(boolean warnOnCaseIssue)
      Specified by:
      setWarnOnCaseIssue in interface IGosuParser

    • setEditorParser

      public void setEditorParser(boolean bStudioEditorParser)
      Specified by:
      setEditorParser in interface IGosuParser

    • isEditorParser

      public boolean isEditorParser()
      Specified by:
      isEditorParser in interface IGosuParser

    • getState

      public IParserState getState()
      Specified by:
      getState in interface IGosuParser

    • isParsingAnnotation

      public boolean isParsingAnnotation()

    • setParsingAnnotation

      public void setParsingAnnotation(boolean parsingAnnotation)

    • isAllowingWildcards

      public boolean isAllowingWildcards()

    • setAllowWildcards

      public void setAllowWildcards(boolean allowWildcards)

    • isIgnoreTypeDeprecation

      public boolean isIgnoreTypeDeprecation()

    • pushIgnoreTypeDeprecation

      public void pushIgnoreTypeDeprecation()

    • popIgnoreTypeDeprecation

      public void popIgnoreTypeDeprecation()

    • setLocationsFromProgramClassParser

      public void setLocationsFromProgramClassParser(List<ParseTree> savedLocations)

    • maybeAdvanceTokenizerToEndOfSavedLocation

      boolean maybeAdvanceTokenizerToEndOfSavedLocation()

    • pushTypeVariableTypesToInfer

      protected void pushTypeVariableTypesToInfer(IInvocableType functionType)

    • addTypeVarsToList

      private void addTypeVarsToList(List<IType> typeVariableTypes, IGenericTypeVariable[] typeVariables)

    • toString

      public String toString()
      Overrides:
      toString in class Object