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

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private static class`	`GosuParser.FunctionDeclTransparentActivationContext`
`private static class`	`GosuParser.GosuParserTransparentActivationContext`

Nested classes/interfaces inherited from interface gw.lang.parser.IGosuParser
IGosuParser.ParseType, IGosuParser.Settings

Field Summary

Fields
Modifier and Type	Field	Description
`private boolean`	`_allowWildcards`
`private java.lang.Boolean`	`_bAreUsingStatementsAllowedInStatementLists`
`private boolean`	`_bCaptureSymbolsForEval`
`private boolean`	`_bGenRootExprAccess`
`private Stack<IType>`	`_blockReturnTypeStack`
`private boolean`	`_bParsed`
`private boolean`	`_bProgramCallFunction`
`private boolean`	`_bStudioEditorParser`
`private boolean`	`_bThrowForWarnings`
`private boolean`	`_bWarnOnCaseIssue`
`private ContextInferenceManager`	`_ctxInferenceMgr`
`private java.util.Map<java.lang.String,java.util.List<IFunctionSymbol>>`	`_dfsDeclByName`
`private int`	`_iBreakOk`
`private int`	`_iContinueOk`
`private int`	`_ignoreTypeDeprecation`
`private Stack<TypeVarToTypeMap>`	`_inferenceMapStack`
`private Stack<ContextType>`	`_inferredContextStack`
`(package private) int`	`_iReturnOk`
`private int`	`_iStmtDepth`
`private java.util.List<ParseTree>`	`_locations`
`private Stack<java.lang.Boolean>`	`_parsingAbstractConstructor`
`private boolean`	`_parsingAnnotation`
`private java.util.ArrayList<VarStatement>`	`_parsingFieldInitializer`
`private java.util.ArrayList<FunctionType>`	`_parsingFunctions`
`private boolean`	`_parsingNewExpressionTypeLiteral`
`private Program`	`_parsingProgram`
`private Stack<java.lang.Boolean>`	`_parsingStaticFeature`
`private java.util.List<ParseTree>`	`_savedLocations`
`private IScriptabilityModifier`	`_scriptabilityConstraint`
`private Stack<IScriptPartId>`	`_scriptPartIdStack`
`private Stack<ParsedElement>`	`_stack`
`private Stack<DynamicFunctionSymbol>`	`_stackDFS`
`private java.lang.String`	`_strNamespace`
`private ISymbolTable`	`_symTable`
`private SourceCodeTokenizer`	`_tokenizer`
`private ITokenizerInstructor`	`_tokenizerInstructor`
`private java.util.Map<java.lang.String,IType>`	`_typeCache`
`private ITypeUsesMap`	`_typeUsesMap`
`private java.util.HashMap<java.lang.String,ITypeVariableDefinition>`	`_typeVarsByName`
`private static Cache<Pair<java.lang.String,java.lang.String>,java.lang.Boolean>`	`BINDER_ASSIGNABILITY_CACHE`
`private static java.lang.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.
`private static java.lang.String[]`	`METHOD_PREFIX_LIST_WITH_SETTER`
`static ErrorType`	`notfound`
`static IType`	`PENDING_BOUNDING_TYPE`

Fields inherited from class gw.internal.gosu.parser.ParserBase
_bDontOptimizeStatementLists, _blocks, _offsetShift

Fields inherited from interface gw.lang.parser.IGosuParser
BIGD_ZERO, DOUBLE_DIGITS, NaN, ONE, ZERO

Constructor Summary

Constructors
Constructor	Description
`GosuParser(ISymbolTable symTable, IScriptabilityModifier scriptabilityConstraint)`
`GosuParser(ISymbolTable symTable, IScriptabilityModifier scriptabilityConstraint, ITypeUsesMap tuMap)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private boolean`	`_areParametersEquivalent(IDynamicFunctionSymbol dfs1, IDynamicFunctionSymbol dfs2, IType[] args, IType[] toArgs)`
`private void`	`_doParseObjectInitializer(IType objectType)`
`private void`	`_parseAnonymousInnerClass(IType declaringClass, IGosuClassInternal gsDeclaringClass, ICompilableTypeInternal enclosingType, int iNameOffset, NewExpression newExpr, int mark)`
`(package private) void`	`_parseBlockLiteral()`
`(package private) void`	`_parseConditionalExpression()`
`private void`	`_parseEqualityExpression()`
`(package private) boolean`	`_parseIndirectMemberAccess(boolean bParseTypeLiteralOnly)`
`private void`	`_parseInitializerExpression(ContextType type)`
`(package private) void`	`_parseIntervalExpression()`
`(package private) void`	`_parseLiteral(Token token)`
`(package private) boolean`	`_parseNameOrMethodCall(Token token)`
`(package private) void`	`_parseNewExpressionOrAnnotation(boolean bAnnotation, boolean bBacktracking)`
`private boolean`	`_parseObjectInitializer(IType objectType)`
`(package private) boolean`	`_parsePrimaryExpression(Token token)`
`(package private) boolean`	`_parseStatement()`
`(package private) void`	`_parseStatements(boolean isolatedScope)`
`private void`	`_parseStringLiteral(boolean bUnterminatedLiteral, Token t)`
`(package private) boolean`	`_parseTypeLiteral(Token token, boolean bIgnoreArrayBrackets, boolean bInterface)`
`(package private) boolean`	`_parseTypeLiteralWithAggregateSyntax(Token token, boolean bIgnoreArrayBrackets, boolean bInterface)`
`(package private) boolean`	`_parseTypeVariableDefinition(ParsedElement parsedElem, TypeVariableDefinition typeVarDef, boolean bFirstPass)`
`(package private) void`	`_parseUnaryExpressionNotPlusMinus()`
`private void`	`addAllNonstaticPrivateMethods(java.lang.String name, IGosuClassInternal superClass, java.util.List<IFunctionSymbol> functions)`
`private void`	`addDefaultReturnStmt(DynamicFunctionSymbol dfsDecl, StatementList stmtList)`
`private void`	`addJavaPropertyMethods(java.lang.String strMemberName, IType rootType, java.util.List<IFunctionType> listFunctionTypes)`
`(package private) void`	`addMisingArgsWithDefaultValues(ParsedElement element, IInvocableType funcType, java.util.List<Expression> argExpressions, java.util.List<LightweightParserState> parserStates, boolean bShouldScoreMethods)`
`(package private) void`	`addNameInDeclaration(java.lang.String strName, int iOffsetName, int iLineNumName, int iColumnName, boolean bHasName)`
`private void`	`addToCompoundType(java.util.List<IType> types)`
`private void`	`addTypeVarsToList(java.util.List<IType> typeVariableTypes, IGenericTypeVariable[] typeVariables)`
`private boolean`	`allTypeLiterals(java.util.List<IExpression> args)`
`private boolean`	`appliesToElementType(IGosuAnnotation anno, java.lang.annotation.ElementType elemType)`
`private boolean`	`areDFSsInSameNameSpace(IDynamicSymbol newDfs, IDynamicSymbol existingDfs)`
`private boolean`	`areMetaTypes(IType lhsType, IType rhsType)`
`private boolean`	`areParametersEquivalent(IDynamicFunctionSymbol dfs, IDynamicFunctionSymbol dfsExisting, IType... extraParams)`
`private boolean`	`areParametersEquivalent_Enhancement(DynamicFunctionSymbol dfs1, DynamicFunctionSymbol dfs2)`
`private boolean`	`areUsingStatementsAllowedInStatementLists()`
`private java.util.List<java.lang.Integer>`	`assignArgExprPosition(java.util.List<? extends IInvocableType> listFunctionTypes, int iArgs, java.util.List<java.lang.Integer> namedArgOrder, int iArgPos)`
`(package private) static DynamicFunctionSymbol`	`assignPossibleDuplicateDfs(DynamicFunctionSymbol dfsDecl, java.lang.Iterable symbols)`
`private void`	`assignRuntime(ParsedElement elem, boolean bIsolatedScope, IFileContext context, IType superType, IScriptPartId partId)`
`private boolean`	`atNumberLiteralStart()`
`(package private) void`	`backtrack(int mark, int iLocationsCount)`
`(package private) void`	`backtrack(int mark, int iLocationsCount, Expression expr)`
`private void`	`backtrackArgParsing(int mark, int iLocationsCount, java.util.List<Expression> argExpressions)`
`private Expression`	`backtrackBinderExpr(int locationsCount, Expression primExpr)`
`private IType`	`boundCtxType(IType ctxType)`
`private IType`	`boundCtxType(IType ctxType, boolean bKeepTypeVars)`
`private IFunctionType`	`boundFunctionType(IFunctionType funcType)`
`private void`	`boxTypeLiteralsType(TypeLiteral tl)`
`private Expression`	`buildRhsOfCompoundOperator(Expression lhs, java.lang.String assignOp, Expression rhs)`
`private boolean`	`canCoerceFromString(Expression first, Expression second)`
`private boolean`	`checkComparableAndCastable(Expression lhs, Expression rhs)`
`private void`	`checkForStaticMethod(IType classBean, Expression[] eArgs, java.lang.String strMethod, GosuParser parserState)`
`(package private) void`	`checkInstruction(boolean bProcessDirectives)`
`private void`	`checkMemberAccessIsReadable()`
`private void`	`checkUnexpectedEof()`
`protected void`	`clearDfsStack()`
`private void`	`clearExpressionInTemplateUnlessParsingEvaluateFunctionBody(Expression e)`
`private void`	`convertNullLiterals(IType contextType)`
`private void`	`convertNumberLiteralsToContextType(IType contextType)`
`private void`	`decStatementDepth()`
`private void`	`detectLikelyJavaCast(Expression eas)`
`boolean`	`doParametersReifyToSameBytecodeType(IDynamicFunctionSymbol dfs, IDynamicFunctionSymbol dfsExisting)`
`(package private) boolean`	`doTypesReifyToTheSameBytecodeType(IType toArg, IType arg)`
`private Expression`	`ensureOperandBoolean(Expression op)`
`private Expression`	`ensureOperandIntOrLong(Expression op)`
`private Expression`	`ensureOperandIntOrLongOrBoolean(Expression op)`
`private boolean`	`errorsSame(java.util.List<IParseIssue> newErrors, java.util.List<IParseIssue> errors)`
`private java.util.List<IType>`	`evalTypes(java.util.List<IExpression> arguments)`
`private java.util.List<java.util.List<IType>>`	`extractContextTypes(java.util.List<? extends IInvocableType> funcTypes)`
`private java.util.List<MethodScore>`	`factorInParseErrors(java.util.List<MethodScore> scoredMethods)`
`private DynamicFunctionSymbol`	`findCorrespondingDeclDfs(int iOffsetName, int iModifiers)`
`private IFunctionType`	`findFunction(java.util.List<IFunctionType> listFunctionTypes, boolean bNoArgsProvided)`
`static IType`	`findImpl(IType typeToInit)`
`private MethodScore`	`findLeastParams(java.util.List<MethodScore> scoredMethods)`	Param count is the tiebreaker when vararg methods are involved.
`private IType`	`findLeastUpperBoundWithCoercions(ConditionalTernaryExpression cte, Expression first, Expression second)`
`private DynamicFunctionSymbol`	`findProgramPropertyDfs(java.lang.String strFunctionName, java.util.ArrayList<ISymbol> args)`
`private java.util.List<IAttributedFeatureInfo>`	`getAllStaticFeatures(IGosuClass gsType, java.lang.String name)`
`private IType`	`getBlockReturnType(IParsedElement blockBody, IType ctxType)`
`private IConstructorInfo`	`getConstructor(IType instanceClass)`
`IConstructorType`	`getConstructorType(IType classBean, Expression[] eArgs, java.util.List<IConstructorType> listAllMatchingMethods, ParserBase parserState)`	Get the type of the method specified in the member path.
`ContextType`	`getContextType()`
`private java.util.List<IType>`	`getContextTypesForBlockArgument(ContextType ctxType)`
`private ContextType`	`getCurrentInitializableContextType()`
`private Expression`	`getDefaultValueOrPlaceHolderForParam(int iParam, IInvocableType invType)`
`java.util.Map<java.lang.String,java.util.List<IFunctionSymbol>>`	`getDfsDecls()`
`protected java.util.List<IFunctionSymbol>`	`getDfsDeclsForFunction(java.lang.String strFunctionName)`
`private IDynamicFunctionSymbol`	`getDFSForFunctionType(java.lang.String strFunction, MethodScore bestMethod)`
`private IType`	`getEnclosingType()`
`private java.util.Map<java.lang.String,TypeVariableDefinition>`	`getEnclosingTypeVars()`
`IFunctionType`	`getFunctionType(IType classBean, java.lang.String functionName, Expression[] eArgs, java.util.List<IFunctionType> listAllMatchingMethods, GosuParser parser, boolean bMatchParamTypes)`
`protected java.util.List<IFunctionType>`	`getFunctionTypesForName(java.lang.String strFunctionName)`
`private GosuConstructorInfo`	`getGsConstructorInfo(IConstructorInfo ci, IGosuClassInternal gsInstanceClass)`
`private IConstructorInfo`	`getImplicitConstructor(IType type)`
`TypeVarToTypeMap`	`getInferenceMap()`
`private ContextType`	`getInitializableType()`
`private IType`	`getInnerClass(java.lang.String strMemberName, IType memberType, IHasInnerClass typeLiteralType)`
`private Statement`	`getLastStatement(Statement statement)`
`java.util.List<IParseTree>`	`getLocations()`
`(package private) java.util.List<ParseTree>`	`getLocationsList()`
`private java.lang.String`	`getModifierString(IConstructorType constructorType)`
`java.lang.String`	`getNamespace()`
`private IType`	`getNumberTypeFromContextType(IType ctxType)`
`private IType`	`getNumericTypeFrom(java.lang.String strValue)`
`(package private) DynamicPropertySymbol`	`getOrCreateDynamicPropertySymbol(ParsedElement parsedElement, IGosuClassInternal gsClass, DynamicFunctionSymbol dfs, boolean bGetter)`
`private IGosuClass`	`getOwningTypeForDfs(IDynamicSymbol dfs)`
`private IType`	`getParamTypeFromParamName(IInvocableType invType, java.lang.String strParam, int[] iPos)`
`private IType[]`	`getParamTypes(java.util.List<Expression> argExpressions)`
`private java.util.ArrayList<IConstructorType>`	`getPreliminaryConstructorTypes(IType declaringClass, NewExpression e)`
`private java.util.List<IFunctionType>`	`getPreliminaryFunctionTypes(java.lang.String strMemberName, BeanMethodCallExpression e, IType rootType, IType[] typeParameters)`
`private DynamicFunctionSymbol`	`getProgramEntryPointDfs()`
`private java.lang.String`	`getPropertyNameFromMethodName(java.lang.String strMethod)`
`private java.lang.String`	`getPropertyNameFromMethodName(java.lang.String strPrefix, java.lang.String strMethod)`
`private java.lang.String`	`getPropertyNameFromMethodNameIncludingSetter(java.lang.String strMethod)`
`protected java.lang.String`	`getScript()`
`IScriptPartId`	`getScriptPart()`	The context associated with the parser's script.
`Stack<IScriptPartId>`	`getScriptPartIdStack()`
`IParserState`	`getState()`
`private int`	`getStatementDepth()`
`ISymbolTable`	`getSymbolTable()`	Returns the parser's symbol table.
`SourceCodeTokenizer`	`getTokenizer()`
`ITokenizerInstructor`	`getTokenizerInstructor()`	The TokenizerInstructor to use for this parser.
`private java.util.List<IType>`	`getTypes(java.util.List<? extends IExpression> list)`
`ITypeUsesMap`	`getTypeUsesMap()`	Get the type uses map.
`private ITypeVariableDefinition`	`getTypeVarDef(java.lang.String strTypeName)`
`private java.util.List<TypeVariableDefinitionImpl>`	`getTypeVarDefsFromDecl(IGenericTypeVariable[] typeVars)`
`java.util.HashMap<java.lang.String,ITypeVariableDefinition>`	`getTypeVariables()`
`IScriptabilityModifier`	`getVisibilityConstraint()`
`private void`	`handleAbstractCtor(int iTokenStart, java.lang.String strMemberName, BeanMethodCallExpression e, IParserState state)`
`private StatementList`	`handleExpressionStatementList(Expression expr)`
`private void`	`handleImplicitCoercionsInArgs(ParsedElement element, IType[] argTypes, IType[] rawArgTypes, java.util.List<Expression> args)`
`private boolean`	`hasContextSensitiveExpression(java.util.List<Expression> argExpressions)`
`private static boolean`	`hasMethod(IType type, java.lang.String name)`
`private static boolean`	`hasMethod_Cached(IType type, java.lang.String method)`
`private boolean`	`hasParseExceptions(Expression expr)`
`private boolean`	`hasSemicolon(IParsedElement stmt)`
`private boolean`	`hasTypeModifier(java.lang.String strValue)`
`boolean`	`hasWarnings()`
`private boolean`	`inConstructorCtx()`
`private void`	`incStatementDepth()`
`private IType`	`inferArgType(IType contextType, TypeVarToTypeMap inferenceMap)`
`private IInvocableType`	`inferConstructor(ConstructorType ctorType, TypeVarToTypeMap inferenceMap)`
`private IInvocableType`	`inferFunction(IInvocableType funcType, java.util.List<? extends IExpression> eArgs, boolean bUseCtx, TypeVarToTypeMap inferenceMap)`
`private IInvocableType`	`inferFunctionType(IInvocableType funcType, java.util.List<? extends IExpression> eArgs, boolean bUseCtx, TypeVarToTypeMap inferenceMap)`
`private void`	`inferFunctionTypeVariables(IType rawContextType, IType boundContextType, Expression expression, TypeVarToTypeMap inferenceMap)`
`private IType`	`inferReturnTypeForBlockArgument(ContextType contextType, IType[] unbound)`
`boolean`	`isAllowingWildcards()`
`private boolean`	`isAnnotation(IType type)`
`private boolean`	`isAssignableFrom(IType type1, IType type2)`
`private boolean`	`isBinLiteral(java.lang.String num)`
`private boolean`	`isBlockInvoke(Expression rootExpression, java.lang.String strMemberName, IType rootType)`
`private boolean`	`isBlockSym(ISymbol functionSymbol)`
`boolean`	`isCaptureSymbolsForEval()`
`private boolean`	`isCompilingOrReparsingHeader()`
`private boolean`	`isConcreteInitializableType(IType type)`
`private boolean`	`isConditional(IExpression expression)`
`private boolean`	`isConnectorStringValid(boolean bPostfix, java.lang.String connectorString, Expression unitExpr, IType unitBinderType)`
`private boolean`	`isConstructingNonStaticInnerClassFromNonStaticContext(IType innersEnclosingClass, IGosuClassInternal constructingFromClass)`
`(package private) boolean`	`isDeclarationKeyword(java.lang.String strKeyword)`
`private boolean`	`isDynamicMethod(java.util.List<? extends IInvocableType> listFunctionTypes)`
`boolean`	`isEditorParser()`
`private boolean`	`isEndOfArgExpression()`
`private boolean`	`isEndOfExpression()`
`private boolean`	`isEqualsArgReference(Expression expr)`
`private boolean`	`isErrorType(IType rootType)`
`private boolean`	`isForStringLiteralTemplate()`
`boolean`	`isGenerateRootExpressionAccessForProgram()`
`private boolean`	`isGenericMethodCall(Expression e)`
`private boolean`	`isHexLiteral(java.lang.String num)`
`boolean`	`isIgnoreTypeDeprecation()`
`private boolean`	`isInitializableType(IType type)`
`private boolean`	`isInSeparateStringTemplateExpression()`
`private boolean`	`isIsolatedCase(java.util.List<CaseClause> cases)`
`private boolean`	`isLocalVarTopLevelFunctionBodyStmt()`
`private boolean`	`isNonStaticInnerClassConstructableFromCurrentFunction(IType innersEnclosingClass, IGosuClassInternal constructingFromClass)`
`private boolean`	`isOpenParenOnNextLine(int mark)`
`private boolean`	`isParenthesisTerminalExpression()`
`private boolean`	`isParenthesisTerminalExpression(boolean bMatchOpeningParen)`
`boolean`	`isParsed()`
`boolean`	`isParsingAbstractConstructor()`
`boolean`	`isParsingAnnotation()`
`private boolean`	`isParsingCompileTimeConstantExpression()`
`private boolean`	`isParsingConstructor()`
`boolean`	`isParsingFieldInitializer()`
`boolean`	`isParsingFunction()`
`(package private) boolean`	`isParsingProgram()`
`private boolean`	`isParsingProgramEvaluateMethod()`
`boolean`	`isParsingStaticFeature()`
`private boolean`	`isParsingTypeListeralForNewExpression()`
`private boolean`	`isPrefixNumericLiteral(java.lang.String strValue)`
`private boolean`	`isPrimitiveOrBoxedIntegerType(IType type)`
`private boolean`	`isPrimitiveOrBoxedOrBigIntegerOrBigDecimal(IType type)`
`private boolean`	`isSuperCall(Expression rootExpression, Expression indexExpression)`
`private boolean`	`isSymbolInScopeDirectly(ISymbol idSym)`
`private boolean`	`isTerminal(Statement statement, IType returnType)`
`private boolean`	`isThisPointer(Expression expr)`
`boolean`	`isThrowParseResultsExceptionForWarnings()`
`private boolean`	`isTypeParameterErrorMsg(Expression expr, java.util.List<IParseIssue> exceptions)`
`private boolean`	`isTypeParamHeaderCompiling(IType typeParam)`
`private boolean`	`isUnexpectedToken(Statement statement)`
`private boolean`	`isValidAnnotationMethodReturnType(IType returnType)`
`java.util.Iterator<FunctionType>`	`iterateParsingFunctions()`
`private MethodScore`	`makeDynamicMethodScore(java.util.List<? extends IInvocableType> listFunctionTypes, java.util.List<Expression> argExpressions)`
`private DynamicPropertySymbol`	`makeGetter(VarStatement varStmt, java.lang.String strVarIdentifier, java.lang.String strPropertyName, IType varType, ModifierInfo modifiers, ISymbol symbol, ICompilableType gsClass, boolean bOldSyntax)`
`(package private) DynamicPropertySymbol`	`makeProperties(VarStatement varStmt, java.lang.String strVarIdentifier, java.lang.String strPropertyName, IType varType, ModifierInfo modifiers, boolean bGetter, boolean bSetter)`
`private DynamicPropertySymbol`	`makeSetter(VarStatement varStmt, java.lang.String strVarIdentifier, java.lang.String strPropertyName, IType varType, ModifierInfo modifiers, ISymbol symbol, ICompilableType gsClass, DynamicPropertySymbol dps, boolean bOldSyntax)`
`private void`	`makeTypeParameterListClause(int iOffset, int iLineNum, int iColumn, java.util.List<TypeLiteral> paramTypes)`
`private TypeVarToTypeMap`	`maskCurrentFunctionTypeVarsFromPriorInference()`
`private java.lang.String`	`matchAssignmentOperator()`
`private boolean`	`matchNonDeclarationKeyword()`
`(package private) boolean`	`matchPrimitiveType(boolean bSuperThis)`
`private boolean`	`matchRightShift()`
`private java.lang.String`	`matchRightShiftAssign()`
`private java.util.List<IFunctionSymbol>`	`maybeAddPrivateFunctionsIfSuperInSamePackage(java.lang.String name, java.util.List<IFunctionSymbol> functions)`
`(package private) boolean`	`maybeAdvanceTokenizerToEndOfSavedLocation()`
`private java.util.List<? extends IInvocableType>`	`maybeAvoidNestedMethodScoring(java.util.List<? extends IInvocableType> listFunctionTypes)`
`private IInvocableType`	`maybeBoundFunctionTypeVars(IInvocableType inferredFunctionType, TypeVarToTypeMap inferenceMap)`
`private ISymbol`	`maybeCaptureSymbol(MethodCallExpression e, ISymbol functionSymbol)`
`private IType`	`maybeChangeToInferredType(IType declaringClass, TypeLiteral typeLiteral, MethodScore bestConst)`
`(package private) boolean`	`maybeEatNonDeclKeyword(boolean bHasName, java.lang.String strFunctionName)`
`private IPropertyInfo`	`maybeGetProxiedPropertyInfo(java.lang.String propName, IPropertyInfo pi)`
`private void`	`maybeInferFunctionTypeVarsFromReturnType(IInvocableType invType, TypeVarToTypeMap inferenceMap)`
`private TypeLiteral`	`maybeInferTypeLiteralFromContextType()`
`private void`	`maybeOpenParenIsForParenthesizedExpr(Expression rootExpression, MemberAccessKind kind, int iTokenStart, java.lang.String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty, BeanMethodCallExpression e, IType rootType, boolean bExpansion, IType[] typeParameters, int iParenStart, int mark, int iLocationsCount)`
`private IFunctionType`	`maybeParameterizeOnCtxType(IFunctionType funcType)`
`private void`	`maybeParseIdentifierAssumingOpenParenIsForParenthesizedExpr(java.lang.String[] t, int iOffset, int iLineNum, int iColumn, IParserState state, MethodCallExpression e, IType[] typeParameters, java.lang.String strFunction, ISymbol functionSymbol, int mark, int iLocationsCount)`
`private void`	`maybeParseImpliedStaticMethod(int iOffset, int iLineNum, int iColumn, LazyLightweightParserState state, java.lang.String strFunction, int markBeforeTypeArgs, int iLocBeforeTypeArgs)`
`private boolean`	`maybeParseImpliedThisMethod(int iOffset, int iLineNum, int iColumn, LazyLightweightParserState state, java.lang.String strFunction, int markBeforeTypeArgs, int iLocBeforeTypeArgs)`
`private void`	`maybeReassignOffsetForArgumentListClause(int iArgs, java.util.List<Expression> argExpressions, int iOffset, int iLineNum, int iColumn)`
`private void`	`maybeRemoveIMonitorLockError(ParsedElement pe)`
`private java.util.List<? extends IInvocableType>`	`maybeRemoveNonGenericMethods(java.util.List<? extends IInvocableType> listFunctionTypes, IType[] typeParams)`
`private boolean`	`maybeReparseWithoutContextType(int mark, int iLocationsCount, Expression initializerExpression)`
`private boolean`	`maybeReplaceErrantPackageExprWithEnumConstEpr(int iOffset, int iLineNum, int iColumn, Expression expr)`
`private void`	`maybeReplacePackageExprWithTypeLiteral(int iOffset, int iLineNum, int iColumn, Expression expr)`
`private IType`	`maybeResolveFunctionTypeVars(IDynamicFunctionSymbol dfs, IType type)`
`private void`	`maybeSetExternalSymbols()`
`private java.lang.String`	`maybeStripTypeModifier(java.lang.String strValue, IType numericTypeFrom)`
`private void`	`maybeVerifyDoubleLiteral(IExpression oneSide, IExpression otherSide)`
`private void`	`maybeVerifyDoubleLiterals(Expression e)`
`protected void`	`newDfsDeclInSetByName()`
`int`	`nextIndexOfErrantDuplicateDynamicSymbol(IDynamicSymbol ds, java.util.Collection<? extends ISymbol> symbols, boolean bCheckContains)`
`private java.util.ArrayList<IFunctionType>`	`parameterizeFunctionTypes(Expression expression, IType[] typeParameters, java.util.List<IFunctionType> listFunctionTypes)`
`(package private) void`	`parseAdditiveExpression()`
`private void`	`parseAggregateTypeLiteral(boolean bInterface)`
`private IType`	`parseAnonymousInnerClass(IType declaringClass, TypeLiteral typeLiteral, NewExpression newExpr, int state, int mark)`
`private int`	`parseArgExpression(IInvocableType funcType, int iArgs, java.util.List<Expression> argExpressions, TypeVarToTypeMap inferenceMap, java.util.List<LightweightParserState> parserStates, java.util.Set<java.lang.String> namedArgs, boolean bMethodScoring)`
`private MethodScore`	`parseArgumentList(IType rootType, ParsedElement element, java.util.List<? extends IInvocableType> listFunctionTypes, IType[] typeParams, boolean bVerifyArgs, boolean bNoArgsProvided)`
`private boolean`	`parseArrayType(TypeLiteral tl)`
`(package private) java.util.List<Expression>`	`parseArrayValueList(IType componentType)`
`private void`	`parseAssertStatement()`
`private void`	`parseAssignment(Expression e, java.lang.String assignOp)`
`(package private) boolean`	`parseAssignmentOrMethodCall()`
`private Expression`	`parseAssignmentRhs(java.lang.String operation, IType typeExpected, Expression lhs)`
`(package private) FunctionStatement`	`parseBaseFunctionDefinition(FunctionStatement functionStmt, boolean bProperty, boolean bGetter, ModifierInfo modifiers)`
`(package private) void`	`parseBindableExpression()`
`(package private) void`	`parseBindableExpression(boolean bPostfix)`
`private void`	`parseBindableExpression(Token token)`
`private void`	`parseBindableExpression(Token token, boolean bPostfix)`
`private void`	`parseBindingExpression(Token token)`
`private void`	`parseBindingExpression(Token token, boolean bPostfix)`
`(package private) void`	`parseBitshiftExpression()`
`(package private) void`	`parseBitwiseAndExpression()`
`(package private) void`	`parseBitwiseOrExpression()`
`(package private) void`	`parseBitwiseXorExpression()`
`private void`	`parseBlockExpression()`
`(package private) void`	`parseBlockLiteral()`
`private boolean`	`parseBooleanLiteral(Token token)`
`(package private) boolean`	`parseCaseClause(SwitchStatement switchStmt, java.util.List<CaseClause> cases)`
`(package private) void`	`parseCaseClauses(SwitchStatement switchStmt)`
`private boolean`	`parseCharLiteral(Token token)`
`IGosuClassInternal`	`parseClass(java.lang.String strQualifiedClassName, ISourceFileHandle sourceFile, boolean bThrowOnWarnings, boolean bFullyCompile)`	For use by code editors etc.
`private void`	`parseCollectionInitializerList(IType type)`
`private void`	`parseCompoundTypeLiteralExpression(java.lang.String[] T, boolean bInterface, int iOffset, int iLineNum, int iColumn)`
`(package private) void`	`parseConditionalAndExpression()`
`(package private) void`	`parseConditionalExpression()`
`(package private) void`	`parseConditionalOrExpression()`
`(package private) boolean`	`parseDefaultClause(SwitchStatement switchStmt, java.util.List<CaseClause> cases)`
`(package private) void`	`parseDelegateStatement(DelegateStatement delegateStmt, java.lang.String strIdentifier)`
`private void`	`parseDirective(boolean processDirectives)`
`private NumericLiteral`	`parseDouble(java.lang.String strValue)`
`private NumericLiteral`	`parseDoubleOrBigDec(java.lang.String strValue)`
`private void`	`parseDoWhileStatement()`
`private void`	`parseDynamicFunction(Symbol dynamcSymbol)`
`private void`	`parseEqualityExpression()`
`private void`	`parseErrantFeatureLiteralParameterization(FeatureLiteral fle)`
`private void`	`parseEvalExpression()`
`Expression`	`parseExp(IScriptPartId partId)`	Parses a Gosu expression.
`private Expression`	`parseExp(IScriptPartId partId, boolean isolatedScope, IType expectedExpressionType, boolean assignRuntime)`
`private Expression`	`parseExp(IScriptPartId partId, boolean isolatedScope, IType expectedExpressionType, IFileContext context, boolean assignRuntime)`
`Expression`	`parseExp(IScriptPartId partId, IType expectedExpressionType)`	Parses a Gosu expression.
`Expression`	`parseExp(IScriptPartId partId, IType expectedExpressionType, IFileContext context, boolean assignRuntime)`	Parses a Gosu expression.
`private void`	`parseExplicitlyTypedNumericLiteral(java.lang.String strValue, IType numericTypeFrom)`
`IExpression`	`parseExpOrProgram(IScriptPartId partId)`	Parses a Gosu expression.
`IExpression`	`parseExpOrProgram(IScriptPartId partId, boolean isolatedScope, boolean assignRuntime)`	Parses a Gosu expression.
`IExpression`	`parseExpOrProgram(IScriptPartId partId, IType typeExpected, boolean isolatedScope, boolean assignRuntime)`
`(package private) void`	`parseExpression()`
`(package private) void`	`parseExpression(ContextType contextType)`
`(package private) void`	`parseExpression(ContextType ctxType, boolean bVerify)`
`(package private) void`	`parseExpressionNoVerify(ContextType ctxType)`
`private boolean`	`parseFeatureLiteral(Token token, Expression root)`
`private NumericLiteral`	`parseFloat(java.lang.String strValue)`
`private void`	`parseForEachStatement()`
`private boolean`	`parseFunctionBody(FunctionStatement functionStmt, FunctionType type)`
`(package private) DynamicFunctionSymbol`	`parseFunctionDecl(ParsedElement element, boolean bProperty, boolean bGetter, ModifierInfo modifiers)`
`(package private) DynamicFunctionSymbol`	`parseFunctionDecl(ParsedElement element, ModifierInfo modifiers)`
`(package private) DynamicFunctionSymbol`	`parseFunctionDecl(ParsedElement element, java.lang.String T, boolean bProperty, boolean bGetter, ModifierInfo modifiers)`
`(package private) boolean`	`parseFunctionDefinition()`
`(package private) ISymbol`	`parseFunctionOrPropertyDeclaration(ParsedElement element)`
`private IType[]`	`parseFunctionParameterization(Expression e)`
`private void`	`parseIdentifier(Identifier e, java.lang.String[] T)`
`private void`	`parseIdentifier(java.lang.String[] T)`
`private void`	`parseIdentifierOrTypeLiteralOrEnumConstant(java.lang.String[] T, int iOffset, int iLineNum, int iColumn)`
`private void`	`parseIfStatement()`
`private void`	`parseIndexVar(ForEachStatement forEachStmt)`
`private void`	`parseIndirectMemberAccess(int iOffset, int iLineNum, int iColumn)`
`private void`	`parseIndirectMemberAccess(int iOffset, int iLineNum, int iColumn, boolean bParsingTypeLiteralOnly)`
`private boolean`	`parseInitializerAssignment(IType objectType)`
`private void`	`parseInitializerIdentifier(IType objectType)`
`(package private) void`	`parseIntervalExpression()`
`private NumericLiteral`	`parseIntOrLongOrBigInt(java.lang.String strValue)`
`private void`	`parseIteratorVar(ForEachStatement forEachStmt, IType type)`
`(package private) void`	`parseLiteral(Token token)`
`private java.util.List<IGosuAnnotation>`	`parseLocalAnnotations(java.util.List<IGosuAnnotation> annotations)`
`(package private) void`	`parseLocalVarStatement(VarStatement varStmt)`
`(package private) boolean`	`parseLoopStatement()`
`private void`	`parseMapInitializerList(ContextType type)`
`private void`	`parseMemberAccess(Expression rootExpression, MemberAccessKind kind, int iTokenStart, java.lang.String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly)`
`private void`	`parseMemberAccess(Expression rootExpression, MemberAccessKind kind, int iTokenStart, java.lang.String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty)`
`private void`	`parseMethodCall(java.lang.String[] t, int iOffset, int iLineNum, int iColumn, LazyLightweightParserState state, MethodCallExpression e, IType[] typeParameters, java.lang.String strFunction, ISymbol functionSymbol, int markBeforeTypeArgs, int iLocBeforeTypeArgs, int markAfterTypeArgs)`
`private void`	`parseMethodCall(java.lang.String[] t, IParserState state, MethodCallExpression e, IType[] typeParameters, java.lang.String strFunction, ISymbol functionSymbol)`
`private void`	`parseMethodMember(Expression rootExpression, MemberAccessKind kind, int iTokenStart, java.lang.String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty, BeanMethodCallExpression e, IType rootType, boolean bExpansion, IType[] typeParameters, int iParenStart, int mark)`
`private void`	`parseMethodMember(Expression rootExpression, MemberAccessKind kind, int iTokenStart, java.lang.String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, BeanMethodCallExpression e, IType rootType, boolean bExpansion, IType[] typeParameters, int iParenStart)`
`(package private) void`	`parseMultiplicativeExpression()`
`private int`	`parseNamedParamExpression(IInvocableType invType, boolean bMethodScoring)`
`private void`	`parseNamedParamIdentifier()`
`(package private) boolean`	`parseNameOrMethodCall(Token token)`
`private void`	`parseNamespaceStartOrRelativeType(java.lang.String[] T, boolean bInterface)`
`(package private) void`	`parseNamespaceStatement()`
`(package private) void`	`parseNamespaceStatement_editor()`
`(package private) void`	`parseNamespaceStatement_normal()`
`(package private) void`	`parseNewExpression()`	new-expression new <type-expression> ( [<argument-list>] ) { [<initialization-expression>] } new <type-expression> [ <expression> ] new <type-expression> [] { [<array-value-list>] }
`(package private) void`	`parseNewExpressionOrAnnotation(boolean bAnnotation)`
`(package private) void`	`parseNewExpressionOrAnnotation(IType declaringClass, boolean bAnnotation, boolean bNoArgNoParenthesis, TypeLiteral typeLiteral, int mark)`
`private boolean`	`parseNullLiteral(Token token)`
`private boolean`	`parseNumberLiteral(Token token)`
`private boolean`	`parseNumberLiteral(Token token, boolean negated)`
`private void`	`parseNumericValue(java.lang.String strValue)`
`private boolean`	`parseObjectInitializer(IType objectType)`
`java.util.ArrayList<ISymbol>`	`parseParameterDeclarationList(IParsedElement element, boolean bStatic, java.util.List<IType> inferredArgumentTypes)`
`java.util.ArrayList<ISymbol>`	`parseParameterDeclarationList(IParsedElement element, boolean bStatic, java.util.List<IType> inferredArgumentTypes, boolean bProperty, boolean bGetter, boolean bEmpty, boolean bVarDynamicArg)`
`(package private) boolean`	`parseParameterType(IType boundingType)`
`private void`	`parsePlainFunction(IFunctionSymbol functionSymbol)`
`private IType[]`	`parsePossibleFunctionParameterization(java.lang.String name, MethodCallExpression e)`
`private void`	`parsePostfixNumericLiteral(java.lang.String num, IType numericTypeFrom, int radix)`
`private boolean`	`parsePostfixUnitBindingExpression(Token priorToken, java.lang.String connectorString)`
`private void`	`parsePrefixNumericLiteral(java.lang.String strValue, IType numericTypeFrom)`
`private boolean`	`parsePrefixUnitBindingExpression(Token priorToken, java.lang.String connectorString)`
`(package private) void`	`parsePrimaryExpression()`
`IProgram`	`parseProgram(IScriptPartId partId)`
`IProgram`	`parseProgram(IScriptPartId partId, boolean isolatedScope, boolean reallyIsolatedScope, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime)`
`IProgram`	`parseProgram(IScriptPartId partId, boolean isolatedScope, boolean reallyIsolatedScope, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime, boolean bDoNotThrowParseResultsException)`
`IProgram`	`parseProgram(IScriptPartId partId, boolean isolatedScope, boolean reallyIsolatedScope, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime, boolean bDoNotThrowParseResultsException, IType superType)`
`IProgram`	`parseProgram(IScriptPartId partId, boolean isolatedScope, IType expectedExpressionType)`
`IProgram`	`parseProgram(IScriptPartId partId, IType expectedExpressionType)`
`IProgram`	`parseProgram(IScriptPartId partId, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime)`
`IProgram`	`parseProgram(IScriptPartId partId, IType expectedExpressionType, IFileContext ctx, boolean assignRuntime, boolean bDoNotThrowParseResultsException)`
`(package private) java.util.List<IClasspathStatement>`	`parseProgramClasspathStatements()`
`(package private) FunctionStatement`	`parseProgramEntryPointBody()`
`private void`	`parseProgramExpr()`
`private boolean`	`parseProgramFunctionBody(FunctionType type)`
`(package private) java.util.List<ITypeLoaderStatement>`	`parseProgramTypeLoaderStatements()`
`(package private) boolean`	`parsePropertyDefinition()`
`private void`	`parsePropertyMember(Expression rootExpression, MemberAccessKind kind, int iTokenStart, java.lang.String strMemberName, LazyLightweightParserState state, boolean bParseTypeLiteralOnly, boolean createSynthesizedProperty, IType rootType, boolean bExpansion)`
`(package private) void`	`parseRelationalExpression()`
`private boolean`	`parseRelativeFeatureLiteral(Token token)`
`private void`	`parseReturnStatement()`
`private boolean`	`parseStandAloneDataStructureInitialization(Token token)`
`private boolean`	`parseStandAloneDataStructureInitialization(Token token, boolean bAvoidContextType, boolean bBacktracking)`
`(package private) boolean`	`parseStatement()`
`(package private) boolean`	`parseStatement(boolean bAsStmtBlock)`
`(package private) boolean`	`parseStatement(boolean forceKeepStmtBlock, boolean bAsStmtBlock)`
`private void`	`parseStatementBlock()`
`private void`	`parseStatementBlock(boolean bMatchClosingBrace)`
`private void`	`parseStatementBlock(boolean forceKeepStmtBlock, boolean bMatchClosingBrace)`
`Statement`	`parseStatements(IScriptPartId partId)`	Parses a set of Gosu statements.
`private Statement`	`parseStatements(IScriptPartId partId, boolean verify, boolean isolatedScope)`
`(package private) void`	`parseStatementsAndDetectUnreachable(java.util.List<Statement> statements)`
`private boolean`	`parseStringLiteral(Token token)`
`private boolean`	`parseStringLiteralSeparately()`
`private void`	`parseSwitchStatement()`
`private TemplateStringLiteral`	`parseTemplatizedStringLiteral(Token t)`
`private void`	`parseThrowStatement()`
`private void`	`parseTryCatchFinallyStatement()`
`(package private) void`	`parseTypeAsExpression()`
`boolean`	`parseTypeLiteral()`	Consumes a type literal from the current tokenizer, if one exists.
`(package private) boolean`	`parseTypeLiteral(boolean bInterface)`
`boolean`	`parseTypeLiteral(Token token)`
`(package private) boolean`	`parseTypeLiteral(Token token, boolean bInterface)`
`TypeLiteral`	`parseTypeLiteral(IScriptPartId partId)`	Parses a type literal expression.
`(package private) void`	`parseTypeLiteral(java.lang.String[] T, boolean bIgnoreArrayBrackets, boolean bInterface, int iOffset, int iLineNum, int iColumn)`
`(package private) void`	`parseTypeLiteralForNewExpression()`
`(package private) java.util.List<TypeLiteral>`	`parseTypeParameters(IType enclosingType)`
`(package private) void`	`parseTypeVariableDefinition(ParsedElement parsedElem, TypeVariableDefinition typeVarDef, boolean bFirstPass)`
`(package private) java.util.List<ITypeVariableDefinitionExpression>`	`parseTypeVariableDefList(ParsedElement parsedElem, boolean bForFunction, java.util.List<TypeVariableDefinitionImpl> typeVarDefListFromDecl)`
`(package private) java.util.List<ITypeVariableDefinitionExpression>`	`parseTypeVariableDefs(ParsedElement parsedElem, boolean bFunction, java.util.List<TypeVariableDefinitionImpl> typeVarDefListFromDecl)`
`(package private) void`	`parseUnaryExpression()`
`(package private) void`	`parseUnaryExpressionNotPlusMinus()`
`private boolean`	`parseUnitExpression()`
`private boolean`	`parseUnitExpressionFactor(Token token)`
`private MemberAccess`	`parseUnqualifiedEnumConstant(java.lang.String strConstValue)`
`(package private) void`	`parseUsesStatement()`
`(package private) void`	`parseUsesStatement(boolean bResolveTypes)`
`UsesStatementList`	`parseUsesStatementList(boolean bResolveUsesTypes)`
`private void`	`parseUsingStatement()`
`private void`	`parseVariance(ParsedElement parsedElem, TypeVariableDefinition typeVarDef)`
`(package private) DynamicPropertySymbol`	`parseVarPropertyClause(VarStatement varStmt, ModifierInfo modifiers, java.lang.String strVarIdentifier, IType varType, boolean parseInitializer)`
`(package private) void`	`parseVarStatement(VarStatement varStmt, Token idToken, boolean bClassMember)`
`private void`	`parseVarStatementsInUsingStatement(UsingStatement usingStmt)`
`private void`	`parseWhileStatement()`
`private boolean`	`parsingFunctionsEncloseMyClass()`
`protected DynamicFunctionSymbol`	`peekDynamicFunctionSymbol()`
`protected Expression`	`peekExpression()`
`ParseTree`	`peekLocation()`
`protected ParsedElement`	`peekParsedElement()`
`VarStatement`	`peekParsingFieldInitializer()`
`FunctionType`	`peekParsingFunction()`
`(package private) Program`	`peekParsingProgram()`
`protected Statement`	`peekStatement()`
`protected DynamicFunctionSymbol`	`popDynamicFunctionSymbol()`
`Expression`	`popExpression()`
`void`	`popIgnoreTypeDeprecation()`
`(package private) void`	`popInferenceMap(TypeVarToTypeMap inferenceMap)`
`void`	`popInferredContextTypes()`
`void`	`popParsingAbstractConstructor()`
`(package private) VarStatement`	`popParsingFieldInitializer()`
`(package private) FunctionType`	`popParsingFunction()`
`void`	`popParsingStaticMember()`
`(package private) void`	`popScriptPart(IScriptPartId partId)`
`protected Statement`	`popStatement()`
`private Statement`	`popStatementAndDetectUnreachable(Statement previousStatement, java.util.List<Statement> statements)`
`private ISymbol`	`possiblyResolveFunctionSymbol(MethodCallExpression e, java.lang.String strFunction)`
`private void`	`processUsesStatement(UsesStatement usesStmt, TypeLiteral typeLiteral, IFeatureInfo fi, IGosuClass gsType)`
`private void`	`processUsesStatementFeatureLiteral(boolean bResolveTypes, UsesStatement usesStmt, TypeLiteral typeLiteral, FeatureLiteral fl)`
`private void`	`processUsesStatementTypeLiteral(boolean bResolveTypes, UsesStatement usesStmt, TypeLiteral typeLiteral)`
`private boolean`	`propertyTypeDiffers(DynamicFunctionSymbol dfs, DynamicFunctionSymbol dfsExisting)`
`protected void`	`pushDynamicFunctionSymbol(DynamicFunctionSymbol stmt)`
`private void`	`pushErrorNumberLiteral(ResourceKey key, java.lang.Object... args)`
`protected void`	`pushExpression(Expression e)`
`void`	`pushIgnoreTypeDeprecation()`
`void`	`pushInferenceMap(TypeVarToTypeMap inferenceMap)`
`void`	`pushInferredContextTypes(ContextType ctxType)`
`void`	`pushParsingAbstractConstructor(java.lang.Boolean bParsingAbstractConstructor)`
`(package private) void`	`pushParsingFieldInitializer(VarStatement VarStatement)`
`(package private) void`	`pushParsingFunction(FunctionType functionType)`
`void`	`pushParsingStaticMember(java.lang.Boolean bParsingStaticFeature)`
`void`	`pushScriptPart(IScriptPartId partId)`
`protected void`	`pushStatement(Statement stmt)`
`protected void`	`pushTypeVariableTypesToInfer(IInvocableType functionType)`
`void`	`putDfsDeclInSetByName(IDynamicFunctionSymbol dfs)`
`void`	`putDfsDeclsInTable(ISymbolTable table)`
`private void`	`putThisAndSuperSymbols(ModifierInfo modifiers)`
`private boolean`	`recoverFromJavaStyleCast(Expression eas)`
`private void`	`removeInnerClasses(IParsedElement e)`
`private void`	`removeLocation(ParseTree location)`
`(package private) void`	`removeLocationsFrom(int iLocationsCount)`
`private MethodScore`	`reparseArguments(MethodScore bestScore, java.util.List<Expression> argExpressions, ParsedElement element, int mark, int iLocationsCount, IType rootType, IType[] typeParams, boolean bVerifyArgs, boolean bNoArgsProvided)`
`private boolean`	`reparseErrorsAreDifferent(TypeVarToTypeMap inferenceMap, java.util.List<Expression> argExpressions)`
`private MethodScore`	`reparseWithCorrectFunctionAndGtfo(MethodScore bestScore, boolean bShouldScoreMethods, java.util.List<Expression> argExpressions, ParsedElement element, int mark, int iLocationsCount, IType rootType, IType[] typeParams, boolean bVerifyArgs, boolean bNoArgsProvided)`
`private void`	`reset()`
`void`	`resetScript()`
`private boolean`	`resolveArrayOrParameterizationPartOfTypeLiteral(java.lang.String[] T, boolean bIgnoreArrayBrackets, TypeLiteral e)`
`private IType`	`resolveTypeByRelativeName(java.lang.String strTypeName)`
`TypeLiteral`	`resolveTypeLiteral(java.lang.String strTypeName)`	Resolves the type literal given by strTypeName.
`protected TypeLiteral`	`resolveTypeLiteral(java.lang.String[] T)`
`protected TypeLiteral`	`resolveTypeLiteral(java.lang.String[] T, boolean bRelative, boolean bInterface)`
`TypeLiteral`	`resolveTypeLiteral(java.lang.String strTypeName, boolean bRelative, boolean bInterface)`
`private IType`	`resolveTypeName(java.lang.String strTypeName, boolean bRelative)`
`private boolean`	`returnTypesCompatible(DynamicFunctionSymbol dfsExisting, DynamicFunctionSymbol dfs)`
`private MethodScore`	`scoreMethod(IType callsiteEnclosingType, IType rootType, IInvocableType funcType, java.util.List<? extends IInvocableType> listFunctionTypes, java.util.List<Expression> argExpressions, boolean bSimple, boolean bLookInCache)`
`private void`	`scrubAnnotationConstructors(IType declaringClass, java.util.List<IConstructorType> listConstructorTypes)`
`void`	`setAllowWildcards(boolean allowWildcards)`
`void`	`setCaptureSymbolsForEval(boolean bCaputreSymbolsForEval)`
`void`	`setContextInferenceManager(ContextInferenceManager ctxInferenceMgr)`
`void`	`setDfsDeclInSetByName(java.util.Map<java.lang.String,java.util.List<IFunctionSymbol>> dfsDecl)`
`void`	`setEditorParser(boolean bStudioEditorParser)`
`(package private) static void`	`setFromTargetModifier(IGosuAnnotation anno, ModifierInfo modifierInfo)`
`void`	`setGenerateRootExpressionAccessForProgram(boolean bGenRootExprAccess)`
`void`	`setLocationsFromProgramClassParser(java.util.List<ParseTree> savedLocations)`
`(package private) void`	`setNamespace(java.lang.String strNamespace)`
`private void`	`setOperatorLineNumber(Expression expression, int operatorLineNumber)`
`protected void`	`setParsed(boolean bParsed)`
`void`	`setParsingAnnotation(boolean parsingAnnotation)`
`private void`	`setParsingTypeLiteralForNewExpression(boolean value)`
`private void`	`setReturnNullExpr(ReturnStatement returnStmt, boolean bProgramCallFunction)`
`void`	`setScript(ISource src)`	Set the script or expression to parse and execute.
`void`	`setScript(SourceCodeReader reader)`	Set the script or expression to parse and execute.
`void`	`setScript(java.lang.CharSequence source)`	Set the script or expression to parse and execute.
`void`	`setSymbolTable(ISymbolTable symTable)`	Sets the parser's symbol table.
`void`	`setThrowParseExceptionForWarnings(boolean bThrowParseExceptionForWarnings)`
`void`	`setTokenizer(ISourceCodeTokenizer tokenizer)`
`void`	`setTokenizerInstructor(ITokenizerInstructor tokenizerInstructor)`
`void`	`setTypeUsesMap(ITypeUsesMap typeUsesMap)`	Set the type uses map.
`protected void`	`setTypeVariables(java.util.HashMap<java.lang.String,ITypeVariableDefinition> map)`
`void`	`setValidator(IGosuValidator validator)`
`void`	`setWarnOnCaseIssue(boolean warnOnCaseIssue)`
`private boolean`	`shouldParseMemberInstead(java.lang.String strMemberName, IType rootType, IType memberType)`
`private boolean`	`shouldThisExpressionAvoidTheContextType()`
`private boolean`	`staticRefToNonStaticFunc(java.lang.String stFunction, Expression[] eArgs)`
`private boolean`	`staticRefToNonStaticProp(java.lang.String name)`
`private java.lang.String`	`stripPrefix(java.lang.String strValue)`
`private boolean`	`supportPropertyAccessAsGetterCall(java.lang.String[] t, java.lang.String strFunction, IFunctionSymbol function)`
`private boolean`	`supportsInitializer(IType type)`
`private boolean`	`symbolIn(IDynamicSymbol ds, java.util.Collection<? extends ISymbol> symbols)`
`java.lang.String`	`toString()`
`private void`	`transferModifierInfo(ParsedElement stmt, ModifierInfo modifiers, AnnotationUseSiteTarget target, EnhancementDynamicFunctionSymbol dfs)`
`private void`	`transferModifierInfo(VarStatement varStmt, ModifierInfo modifiers, AnnotationUseSiteTarget target, DynamicFunctionSymbol dfs)`
`private boolean`	`tryPostfixUnitExpr(int mark, int locationsCount, Expression lhsExpr, Token priorToken, java.lang.String connectorString, boolean testConnector)`
`private void`	`tryToMakeTypeLiteral(java.lang.String[] T, int iOffset, int iLineNum, int iColumn, java.lang.String name, Expression errantExpression)`
`boolean`	`typeVarExists(java.util.Map<java.lang.String,ITypeVariableDefinition> typeVarMap, TypeVariableDefinition typeVarDef)`
`private IType`	`unitExprType(Expression unitExpr)`
`private IType`	`useDynamicTypeIfDynamicRoot(IInvocableType funcType, IType ctxType)`
`private void`	`verifyArgCount(ParsedElement element, int iArgs, IConstructorType ctorType)`
`private void`	`verifyArgCount(ParsedElement element, int iArgs, IFunctionType funcType)`
`private void`	`verifyArgTypes(IType[] argTypes, java.util.List<Expression> argExpressions, java.util.List<LightweightParserState> parserStates)`
`private void`	`verifyCanConstructInnerClassFromCallSite(NewExpression e, IType innerClass)`
`private boolean`	`verifyCanParameterizeType(ParsedElement elem, IType type, IType[] typeParam)`
`private void`	`verifyCase(ParsedElement element, java.lang.String foundName, java.lang.String actualName, IParserState state, ResourceKey errorKey, boolean isEndsWithMatchOK)`
`private void`	`verifyCase(ParsedElement element, java.lang.String foundName, java.lang.String actualName, ResourceKey errorKey, boolean isEndsWithMatchOK)`
`private void`	`verifyCaseIsUnique(Expression e, java.util.List<CaseClause> cases)`
`private void`	`verifyCoercionSymmetry(EqualityExpression e, Expression lhs, Expression rhs)`
`private Expression`	`verifyConditionalTypes(Expression lhs, Expression rhs)`
`private void`	`verifyConstructorIsAccessible(IType instanceClass, NewExpression e, IConstructorType constructorType, boolean bAnonymous)`
`private void`	`verifyFunction(DynamicFunctionSymbol dfs, ParsedElement element)`
`(package private) void`	`verifyFunctionConflictsWithPropoertySetter(ParsedElement element, DynamicFunctionSymbol dfs, DynamicPropertySymbol dps)`
`private void`	`verifyLoopConditionNotAlwaysFalse(Expression e)`
`private void`	`verifyNoImplicitPropertyMethodConflicts(ParsedElement element, DynamicFunctionSymbol dfs)`
`private void`	`verifyNotCallingOverridableFunctionFromCtor(BeanMethodCallExpression mce)`
`private void`	`verifyNotCallingOverridableFunctionFromCtor(MethodCallExpression mce)`
`private void`	`verifyNotWeakerAccess(ParsedElement element, DynamicFunctionSymbol dfs, DynamicFunctionSymbol dfsExisting)`
`private void`	`verifyOverrideNotOnMethodThatDoesNotExtend(ParsedElement element, DynamicFunctionSymbol dfs)`
`(package private) void`	`verifyPropertySetterConflictsWithFunction(ParsedElement element, DynamicFunctionSymbol dfs, java.lang.String propName, DynamicFunctionSymbol existingDfs)`
`private void`	`verifyPropertyWritable(IType classRoot, java.lang.String strProperty, boolean bFromObjInitializer)`
`private void`	`verifyReified(boolean bValidOverrideFound, ParsedElement element, DynamicFunctionSymbol dfs)`
`private void`	`verifyReifiedCallHasProperContext(BeanMethodCallExpression e)`
`private void`	`verifyReifiedCallHasProperContext(MemberAccess e)`
`private void`	`verifyReifiedCallHasProperContext(MethodCallExpression e)`
`private void`	`verifyReifiedCallHasProperContext(PropertyAccessIdentifier e, DynamicPropertySymbol dps)`
`private void`	`verifyRelationalOperandsComparable(BinaryExpression expr)`
`private void`	`verifySameNumberOfFunctionTypeVars(ParsedElement element, DynamicFunctionSymbol dfs, DynamicFunctionSymbol dfsExisting)`
`private void`	`verifySuperAccess(Expression rootExpression, Expression memberExpr, IAttributedFeatureInfo feature, java.lang.String strMemberName)`
`private IType`	`verifySuperTypeIsDeclaredInCompilingClass(TypeLiteral superTypeLiteral)`
`private void`	`verifyTypeAccessible(TypeLiteral expr, IType type)`
`private void`	`verifyTypeForUsingStatementPredicate(ParsedElement pe, IType type)`
`private Expression`	`verifyWithComparableDimension(Expression rhs, IType lhsType)`
`private void`	`warnIfCaseNotTerminated(java.util.List<Statement> statements)`
`private void`	`warnOnSuspiciousEqualsOperator(EqualityExpression e)`
`private Expression`	`wrapExpressionIfNeeded(Expression first, Expression second)`
`private ReturnStatement`	`wrapProgramExpressionInReturnStmt(Expression e)`

Methods inherited from class gw.internal.gosu.parser.ParserBase
addBlockToBlockStack, addError, addError, advanceToNextTokenSilently, captureAllSymbols, captureSymbol, copyBlockStackTo, eatBlock, eatBlock, eatOptionalSemiColon, eatParenthesized, eatPossibleArrayBrackets, eatPossibleArrayBrackets, eatPossibleEnclosedVarInStmt, eatPossibleParametarization, eatPossibleParametarization, eatPossibleStatementBlock, eatStatementBlock, eatTypeLiteral, findAndWrapLocation, findMathOpMethod, getClassStatement, getCurrentEnclosingGosuClass, getCurrentlyInferringFunctionTypeVars, getGosuClass, getLineNumShift, getOffsetShift, getOwner, getParsingAnonymousClass, getUncapturedSymbol, getValidator, isDontOptimizeStatementLists, isEvalClass, isFinalDimension, isOrIsEnclosedByAnonymousClass, isParsingBlock, isTypeVarInReifiedContext, isWordOrValueKeyword, makeFullParserState, makeFullParserStateWithSymbols, makeLazyLightweightParserState, makeLightweightParserState, match, match, match, match, match, match, matchDeclarationKeyword, parseAnnotation, parseDotPathWord, parseModifiers, parseModifiers, peekInferringFunctionTypeVariableTypes, popCurrentBlock, popInferringFunctionTypeVariableTypes, possiblyWrapWithCoercion, possiblyWrapWithImplicitCoercion, pushCurrentBlock, pushInferringFunctionTypeVars, pushModifierList, resolveNamespace, resolveNamespaceSymbol, resolveRuntimeType, resolveSymbol, resolveType, resolveType, resolveTypeForArithmeticExpression, setBlocks, setDontOptimizeStatementLists, setIgnoreWarnings, setLineNumShift, setLocation, setLocation, setLocation, setLocationForImplicitTypeAs, setOffsetShift, setOwner, setSnapshotSymbols, setSubTree, shouldSnapshotSymbols, verify, verify, verify, verify, verify, verify, verifyAnnotations, verifyComparable, verifyComparable, verifyComparable, verifyModifiers, verifyModifiersForFeature, verifyNoAbstractHideOverrideModifierDefined, verifyNoAbstractHideOverrideStaticModifierDefined, verifyNoAbstractHideOverrideStaticModifierDefined, verifyNoAbstractHideStaticModifierDefined, verifyNoAccessibilityModifierDefined, verifyNoCombinedFinalPrivateModifierDefined, verifyNoCombinedFinalStaticModifierDefined, verifyNoCombinedPrivateAbstract, verifyNoHideOverrideModifierDefined, verifyNoHideOverrideStaticModifierDefined, verifyNonVoidExpression, verifyOrWarn, verifyParsedElement, verifyParsedElement, verifyTypesComparable, verifyTypesComparable, verifyTypeVarAreReified, warn, warn

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface gw.lang.parser.IGosuParser
isParsingBlock, setIgnoreWarnings, setSnapshotSymbols

Methods inherited from interface gw.lang.parser.IParserPart
getLineNumShift, getOffsetShift, getOwner, isDontOptimizeStatementLists, setDontOptimizeStatementLists, setLineNumShift

Field Detail

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 java.util.List<ParseTree> _locations

_parsingProgram
```
private Program _parsingProgram
```

_parsingFunctions

private java.util.ArrayList<FunctionType> _parsingFunctions

_parsingNewExpressionTypeLiteral

private boolean _parsingNewExpressionTypeLiteral

_parsingFieldInitializer

private java.util.ArrayList<VarStatement> _parsingFieldInitializer

_dfsDeclByName

private java.util.Map<java.lang.String,java.util.List<IFunctionSymbol>> _dfsDeclByName

_typeUsesMap
```
private ITypeUsesMap _typeUsesMap
```

_strNamespace
```
private java.lang.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 java.util.HashMap<java.lang.String,ITypeVariableDefinition> _typeVarsByName

_inferredContextStack

private Stack<ContextType> _inferredContextStack

_bThrowForWarnings
```
private boolean _bThrowForWarnings
```

_bStudioEditorParser
```
private boolean _bStudioEditorParser
```

_bWarnOnCaseIssue
```
private boolean _bWarnOnCaseIssue
```

_parsingAbstractConstructor

private Stack<java.lang.Boolean> _parsingAbstractConstructor

_ctxInferenceMgr

private ContextInferenceManager _ctxInferenceMgr

_blockReturnTypeStack

private Stack<IType> _blockReturnTypeStack

_parsingStaticFeature

private Stack<java.lang.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 java.util.Map<java.lang.String,IType> _typeCache

_iStmtDepth
```
private int _iStmtDepth
```

_savedLocations

private java.util.List<ParseTree> _savedLocations

_bAreUsingStatementsAllowedInStatementLists

private java.lang.Boolean _bAreUsingStatementsAllowedInStatementLists

BINDER_ASSIGNABILITY_CACHE

private static final Cache<Pair<java.lang.String,java.lang.String>,java.lang.Boolean> BINDER_ASSIGNABILITY_CACHE

METHOD_PREFIX_LIST
```
private static final java.lang.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>mixed-case-name< is>mixed-case-name<

METHOD_PREFIX_LIST_WITH_SETTER

private static final java.lang.String[] METHOD_PREFIX_LIST_WITH_SETTER

Constructor Detail

GosuParser

GosuParser(ISymbolTable symTable,
           IScriptabilityModifier scriptabilityConstraint)

GosuParser

GosuParser(ISymbolTable symTable,
           IScriptabilityModifier scriptabilityConstraint,
           ITypeUsesMap tuMap)

Method Detail

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(java.lang.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 java.lang.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 java.lang.String getNamespace()

setNamespace

void setNamespace(java.lang.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 java.util.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(java.util.List<Statement> statements)

popStatementAndDetectUnreachable

private Statement popStatementAndDetectUnreachable(Statement previousStatement,
                                                   java.util.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

java.util.List<IClasspathStatement> parseProgramClasspathStatements()

parseProgramTypeLoaderStatements

java.util.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
```
java.util.List<ParseTree> getLocationsList()
```
Overrides:

getLocationsList in class ParserBase

getLocations
```
public java.util.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,
                                        java.lang.String method)

parsePrefixUnitBindingExpression

private boolean parsePrefixUnitBindingExpression(Token priorToken,
                                                 java.lang.String connectorString)

unitExprType

private IType unitExprType(Expression unitExpr)

backtrackBinderExpr

private Expression backtrackBinderExpr(int locationsCount,
                                       Expression primExpr)

parsePostfixUnitBindingExpression

private boolean parsePostfixUnitBindingExpression(Token priorToken,
                                                  java.lang.String connectorString)

tryPostfixUnitExpr

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

isConnectorStringValid

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

parseUnitExpression
```
private boolean parseUnitExpression()
```

parseUnitExpressionFactor

private boolean parseUnitExpressionFactor(Token token)

hasMethod

private static boolean hasMethod(IType type,
                                 java.lang.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 java.util.List<IType> getTypes(java.util.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 java.util.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,
                                         java.util.List<IConstructorType> listConstructorTypes)

isAnnotation

private boolean isAnnotation(IType type)

getPreliminaryConstructorTypes

private java.util.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(java.lang.Boolean bParsingStaticFeature)

popParsingStaticMember
```
public void popParsingStaticMember()
```

isParsingAbstractConstructor

public boolean isParsingAbstractConstructor()

pushParsingAbstractConstructor

public void pushParsingAbstractConstructor(java.lang.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 java.lang.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

java.util.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 java.util.List<IType> evalTypes(java.util.List<IExpression> arguments)

allTypeLiterals

private boolean allTypeLiterals(java.util.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(java.lang.String[] t,
                             int iOffset,
                             int iLineNum,
                             int iColumn,
                             LazyLightweightParserState state,
                             MethodCallExpression e,
                             IType[] typeParameters,
                             java.lang.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,
                                            java.lang.String strFunction,
                                            int markBeforeTypeArgs,
                                            int iLocBeforeTypeArgs)

maybeParseImpliedStaticMethod

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

maybeParseIdentifierAssumingOpenParenIsForParenthesizedExpr

private void maybeParseIdentifierAssumingOpenParenIsForParenthesizedExpr(java.lang.String[] t,
                                                                         int iOffset,
                                                                         int iLineNum,
                                                                         int iColumn,
                                                                         IParserState state,
                                                                         MethodCallExpression e,
                                                                         IType[] typeParameters,
                                                                         java.lang.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(java.lang.String[] t,
                             IParserState state,
                             MethodCallExpression e,
                             IType[] typeParameters,
                             java.lang.String strFunction,
                             ISymbol functionSymbol)

verifyReifiedCallHasProperContext

private void verifyReifiedCallHasProperContext(MethodCallExpression e)

supportPropertyAccessAsGetterCall

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

maybeCaptureSymbol

private ISymbol maybeCaptureSymbol(MethodCallExpression e,
                                   ISymbol functionSymbol)

isInSeparateStringTemplateExpression

private boolean isInSeparateStringTemplateExpression()

possiblyResolveFunctionSymbol

private ISymbol possiblyResolveFunctionSymbol(MethodCallExpression e,
                                              java.lang.String strFunction)

isBlockSym

private boolean isBlockSym(ISymbol functionSymbol)

staticRefToNonStaticFunc

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

staticRefToNonStaticProp

private boolean staticRefToNonStaticProp(java.lang.String name)

boundFunctionType

private IFunctionType boundFunctionType(IFunctionType funcType)

getDFSForFunctionType

private IDynamicFunctionSymbol getDFSForFunctionType(java.lang.String strFunction,
                                                     MethodScore bestMethod)

verifyNotCallingOverridableFunctionFromCtor

private void verifyNotCallingOverridableFunctionFromCtor(MethodCallExpression mce)

verifyNotCallingOverridableFunctionFromCtor

private void verifyNotCallingOverridableFunctionFromCtor(BeanMethodCallExpression mce)

isParsingConstructor

private boolean isParsingConstructor()

parsePossibleFunctionParameterization

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

parseIdentifier

private void parseIdentifier(java.lang.String[] T)

parseIdentifier

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

verifyReifiedCallHasProperContext

private void verifyReifiedCallHasProperContext(PropertyAccessIdentifier e,
                                               DynamicPropertySymbol dps)

parseIdentifierOrTypeLiteralOrEnumConstant

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

tryToMakeTypeLiteral

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

parseNamespaceStartOrRelativeType

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

parseUnqualifiedEnumConstant

private MemberAccess parseUnqualifiedEnumConstant(java.lang.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,
                               java.lang.String strMemberName,
                               LazyLightweightParserState state,
                               boolean bParseTypeLiteralOnly)

parseMemberAccess

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

parseMethodMember

private void parseMethodMember(Expression rootExpression,
                               MemberAccessKind kind,
                               int iTokenStart,
                               java.lang.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,
                                                  java.lang.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,
                               java.lang.String strMemberName,
                               LazyLightweightParserState state,
                               boolean bParseTypeLiteralOnly,
                               BeanMethodCallExpression e,
                               IType rootType,
                               boolean bExpansion,
                               IType[] typeParameters,
                               int iParenStart)

findFunction

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

verifyReifiedCallHasProperContext

private void verifyReifiedCallHasProperContext(BeanMethodCallExpression e)

parsePropertyMember

private void parsePropertyMember(Expression rootExpression,
                                 MemberAccessKind kind,
                                 int iTokenStart,
                                 java.lang.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,
                               java.lang.String strMemberName)

shouldParseMemberInstead

private boolean shouldParseMemberInstead(java.lang.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(java.lang.String strMemberName,
                            IType memberType,
                            IHasInnerClass typeLiteralType)

maybeParameterizeOnCtxType

private IFunctionType maybeParameterizeOnCtxType(IFunctionType funcType)

getPreliminaryFunctionTypes

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

addJavaPropertyMethods

private void addJavaPropertyMethods(java.lang.String strMemberName,
                                    IType rootType,
                                    java.util.List<IFunctionType> listFunctionTypes)

maybeGetProxiedPropertyInfo

private IPropertyInfo maybeGetProxiedPropertyInfo(java.lang.String propName,
                                                  IPropertyInfo pi)

isBlockInvoke

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

isErrorType

private boolean isErrorType(IType rootType)

parameterizeFunctionTypes

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

handleAbstractCtor

private void handleAbstractCtor(int iTokenStart,
                                java.lang.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,
                                      java.util.List<? extends IInvocableType> listFunctionTypes,
                                      IType[] typeParams,
                                      boolean bVerifyArgs,
                                      boolean bNoArgsProvided)

findLeastParams
```
private MethodScore findLeastParams(java.util.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,
                                                      java.util.List<Expression> argExpressions,
                                                      ParsedElement element,
                                                      int mark,
                                                      int iLocationsCount,
                                                      IType rootType,
                                                      IType[] typeParams,
                                                      boolean bVerifyArgs,
                                                      boolean bNoArgsProvided)

reparseErrorsAreDifferent

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

errorsSame

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

reparseArguments

private MethodScore reparseArguments(MethodScore bestScore,
                                     java.util.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 java.util.List<MethodScore> factorInParseErrors(java.util.List<MethodScore> scoredMethods)

hasContextSensitiveExpression

private boolean hasContextSensitiveExpression(java.util.List<Expression> argExpressions)

isGenericMethodCall

private boolean isGenericMethodCall(Expression e)

maybeAvoidNestedMethodScoring

private java.util.List<? extends IInvocableType> maybeAvoidNestedMethodScoring(java.util.List<? extends IInvocableType> listFunctionTypes)

backtrackArgParsing

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

maybeRemoveNonGenericMethods

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

maybeReassignOffsetForArgumentListClause

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

maybeBoundFunctionTypeVars

private IInvocableType maybeBoundFunctionTypeVars(IInvocableType inferredFunctionType,
                                                  TypeVarToTypeMap inferenceMap)

assignArgExprPosition

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

addMisingArgsWithDefaultValues

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

parseArgExpression

private int parseArgExpression(IInvocableType funcType,
                               int iArgs,
                               java.util.List<Expression> argExpressions,
                               TypeVarToTypeMap inferenceMap,
                               java.util.List<LightweightParserState> parserStates,
                               java.util.Set<java.lang.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,
                                        java.lang.String strParam,
                                        int[] iPos)

parseNamedParamIdentifier

private void parseNamedParamIdentifier()

isDynamicMethod

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

makeDynamicMethodScore

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

getParamTypes

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

scoreMethod

private MethodScore scoreMethod(IType callsiteEnclosingType,
                                IType rootType,
                                IInvocableType funcType,
                                java.util.List<? extends IInvocableType> listFunctionTypes,
                                java.util.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,
                                           java.util.List<Expression> args)

extractContextTypes

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

verifyArgTypes

private void verifyArgTypes(IType[] argTypes,
                            java.util.List<Expression> argExpressions,
                            java.util.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(java.lang.String strValue)

parseIntOrLongOrBigInt

private NumericLiteral parseIntOrLongOrBigInt(java.lang.String strValue)

stripPrefix

private java.lang.String stripPrefix(java.lang.String strValue)

parseDoubleOrBigDec

private NumericLiteral parseDoubleOrBigDec(java.lang.String strValue)

parseFloat

private NumericLiteral parseFloat(java.lang.String strValue)

parseDouble

private NumericLiteral parseDouble(java.lang.String strValue)

parseExplicitlyTypedNumericLiteral

private void parseExplicitlyTypedNumericLiteral(java.lang.String strValue,
                                                IType numericTypeFrom)

isPrefixNumericLiteral

private boolean isPrefixNumericLiteral(java.lang.String strValue)

parsePrefixNumericLiteral

private void parsePrefixNumericLiteral(java.lang.String strValue,
                                       IType numericTypeFrom)

isHexLiteral

private boolean isHexLiteral(java.lang.String num)

isBinLiteral

private boolean isBinLiteral(java.lang.String num)

parsePostfixNumericLiteral

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

maybeStripTypeModifier

private java.lang.String maybeStripTypeModifier(java.lang.String strValue,
                                                IType numericTypeFrom)

hasTypeModifier

private boolean hasTypeModifier(java.lang.String strValue)

pushErrorNumberLiteral

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

getNumericTypeFrom

private IType getNumericTypeFrom(java.lang.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(java.util.List<IType> types)

parseBlockLiteral
```
void parseBlockLiteral()
```

_parseBlockLiteral
```
void _parseBlockLiteral()
```

parseTypeLiteral

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

verifyTypeAccessible

private void verifyTypeAccessible(TypeLiteral expr,
                                  IType type)

parseCompoundTypeLiteralExpression

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

isTypeParameterErrorMsg

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

resolveArrayOrParameterizationPartOfTypeLiteral

private boolean resolveArrayOrParameterizationPartOfTypeLiteral(java.lang.String[] T,
                                                                boolean bIgnoreArrayBrackets,
                                                                TypeLiteral e)

Returns:: True if parsed parameterized type.

isParsingCompileTimeConstantExpression

private boolean isParsingCompileTimeConstantExpression()

parseArrayType

private boolean parseArrayType(TypeLiteral tl)

parseTypeParameters

java.util.List<TypeLiteral> parseTypeParameters(IType enclosingType)

makeTypeParameterListClause

private void makeTypeParameterListClause(int iOffset,
                                         int iLineNum,
                                         int iColumn,
                                         java.util.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,
                                             java.lang.String strVarIdentifier,
                                             IType varType,
                                             boolean parseInitializer)

makeProperties

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

makeGetter

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

makeSetter

private DynamicPropertySymbol makeSetter(VarStatement varStmt,
                                         java.lang.String strVarIdentifier,
                                         java.lang.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,
                                     java.lang.annotation.ElementType elemType)

parseDelegateStatement

void parseDelegateStatement(DelegateStatement delegateStmt,
                            java.lang.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 java.util.List<IAttributedFeatureInfo> getAllStaticFeatures(IGosuClass gsType,
                                                                    java.lang.String name)

processUsesStatementTypeLiteral

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

parseCaseClauses

void parseCaseClauses(SwitchStatement switchStmt)

parseCaseClause

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

verifyCaseIsUnique

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

isIsolatedCase

private boolean isIsolatedCase(java.util.List<CaseClause> cases)

warnIfCaseNotTerminated

private void warnIfCaseNotTerminated(java.util.List<Statement> statements)

parseDefaultClause

boolean parseDefaultClause(SwitchStatement switchStmt,
                           java.util.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,
                             java.lang.String assignOp)

isParsingProgramEvaluateMethod

private boolean isParsingProgramEvaluateMethod()

isSymbolInScopeDirectly

private boolean isSymbolInScopeDirectly(ISymbol idSym)

parseAssignmentRhs

private Expression parseAssignmentRhs(java.lang.String operation,
                                      IType typeExpected,
                                      Expression lhs)

buildRhsOfCompoundOperator

private Expression buildRhsOfCompoundOperator(Expression lhs,
                                              java.lang.String assignOp,
                                              Expression rhs)

matchAssignmentOperator

private java.lang.String matchAssignmentOperator()

matchRightShiftAssign

private java.lang.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(java.lang.String strFunctionName,
                                                     java.util.ArrayList<ISymbol> args)

getTypeVarDefsFromDecl

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

findCorrespondingDeclDfs

private DynamicFunctionSymbol findCorrespondingDeclDfs(int iOffsetName,
                                                       int iModifiers)

isDeclarationKeyword

boolean isDeclarationKeyword(java.lang.String strKeyword)

assignPossibleDuplicateDfs

static DynamicFunctionSymbol assignPossibleDuplicateDfs(DynamicFunctionSymbol dfsDecl,
                                                        java.lang.Iterable symbols)

addNameInDeclaration

void addNameInDeclaration(java.lang.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,
                                        java.lang.String T,
                                        boolean bProperty,
                                        boolean bGetter,
                                        ModifierInfo modifiers)

matchNonDeclarationKeyword

private boolean matchNonDeclarationKeyword()

maybeEatNonDeclKeyword

boolean maybeEatNonDeclKeyword(boolean bHasName,
                               java.lang.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 java.util.List<IFunctionSymbol> maybeAddPrivateFunctionsIfSuperInSamePackage(java.lang.String name,
                                                                                     java.util.List<IFunctionSymbol> functions)

addAllNonstaticPrivateMethods

private void addAllNonstaticPrivateMethods(java.lang.String name,
                                           IGosuClassInternal superClass,
                                           java.util.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,
                                               java.lang.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 java.util.ArrayList<ISymbol> parseParameterDeclarationList(IParsedElement element,
                                                                  boolean bStatic,
                                                                  java.util.List<IType> inferredArgumentTypes)

Specified by:: parseParameterDeclarationList in interface IGosuParser

parseParameterDeclarationList

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

parseLocalAnnotations

private java.util.List<IGosuAnnotation> parseLocalAnnotations(java.util.List<IGosuAnnotation> annotations)

parseTypeVariableDefs

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

parseTypeVariableDefList

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

typeVarExists

public boolean typeVarExists(java.util.Map<java.lang.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,
                                                   java.util.Collection<? extends ISymbol> symbols,
                                                   boolean bCheckContains)

symbolIn

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

setDfsDeclInSetByName

public void setDfsDeclInSetByName(java.util.Map<java.lang.String,java.util.List<IFunctionSymbol>> dfsDecl)

Specified by:: setDfsDeclInSetByName in interface IGosuParser

newDfsDeclInSetByName

protected void newDfsDeclInSetByName()

getDfsDecls

public java.util.Map<java.lang.String,java.util.List<IFunctionSymbol>> getDfsDecls()

Specified by:: getDfsDecls in interface IGosuParser

getFunctionTypesForName

protected java.util.List<IFunctionType> getFunctionTypesForName(java.lang.String strFunctionName)

resolveTypeLiteral

protected TypeLiteral resolveTypeLiteral(java.lang.String[] T)

resolveTypeLiteral

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

getDfsDeclsForFunction

protected java.util.List<IFunctionSymbol> getDfsDeclsForFunction(java.lang.String strFunctionName)

resolveTypeLiteral
```
public TypeLiteral resolveTypeLiteral(java.lang.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(java.lang.String strTypeName,
                                      boolean bRelative,
                                      boolean bInterface)

resolveTypeName

private IType resolveTypeName(java.lang.String strTypeName,
                              boolean bRelative)

getTypeVarDef

private ITypeVariableDefinition getTypeVarDef(java.lang.String strTypeName)

getEnclosingTypeVars

private java.util.Map<java.lang.String,TypeVariableDefinition> getEnclosingTypeVars()

resolveTypeByRelativeName

private IType resolveTypeByRelativeName(java.lang.String strTypeName)

getTypeVariables

public java.util.HashMap<java.lang.String,ITypeVariableDefinition> getTypeVariables()

Specified by:: getTypeVariables in interface IGosuParser

setTypeVariables

protected void setTypeVariables(java.util.HashMap<java.lang.String,ITypeVariableDefinition> map)

parseClass

public IGosuClassInternal parseClass(java.lang.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,
                                     java.lang.String functionName,
                                     Expression[] eArgs,
                                     java.util.List<IFunctionType> listAllMatchingMethods,
                                     GosuParser parser,
                                     boolean bMatchParamTypes)
                              throws ParseException

Throws:: ParseException

checkForStaticMethod

private void checkForStaticMethod(IType classBean,
                                  Expression[] eArgs,
                                  java.lang.String strMethod,
                                  GosuParser parserState)
                           throws ParseException

Throws:: ParseException

inferFunctionType

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

inferConstructor

private IInvocableType inferConstructor(ConstructorType ctorType,
                                        TypeVarToTypeMap inferenceMap)

inferFunction

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

getPropertyNameFromMethodName

private java.lang.String getPropertyNameFromMethodName(java.lang.String strMethod)

getPropertyNameFromMethodNameIncludingSetter

private java.lang.String getPropertyNameFromMethodNameIncludingSetter(java.lang.String strMethod)

getPropertyNameFromMethodName

private java.lang.String getPropertyNameFromMethodName(java.lang.String strPrefix,
                                                       java.lang.String strMethod)

verifyPropertyWritable

private void verifyPropertyWritable(IType classRoot,
                                    java.lang.String strProperty,
                                    boolean bFromObjInitializer)
                             throws ParseException

Throws:: ParseException

getConstructorType

public IConstructorType getConstructorType(IType classBean,
                                           Expression[] eArgs,
                                           java.util.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,
                        java.lang.String foundName,
                        java.lang.String actualName,
                        ResourceKey errorKey,
                        boolean isEndsWithMatchOK)

verifyCase

private void verifyCase(ParsedElement element,
                        java.lang.String foundName,
                        java.lang.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(java.util.List<ParseTree> savedLocations)

maybeAdvanceTokenizerToEndOfSavedLocation

boolean maybeAdvanceTokenizerToEndOfSavedLocation()

pushTypeVariableTypesToInfer

protected void pushTypeVariableTypesToInfer(IInvocableType functionType)

addTypeVarsToList

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

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

Class GosuParser

Nested Class Summary

Nested classes/interfaces inherited from interface gw.lang.parser.IGosuParser

Field Summary

Fields inherited from class gw.internal.gosu.parser.ParserBase

Fields inherited from interface gw.lang.parser.IGosuParser

Constructor Summary

Method Summary

Methods inherited from class gw.internal.gosu.parser.ParserBase

Methods inherited from class java.lang.Object

Methods inherited from interface gw.lang.parser.IGosuParser

Methods inherited from interface gw.lang.parser.IParserPart

Field Detail

PENDING_BOUNDING_TYPE

notfound

_tokenizer

_symTable

_bParsed

_stack

_stackDFS

_locations

_parsingProgram

_parsingFunctions

_parsingNewExpressionTypeLiteral

_parsingFieldInitializer

_dfsDeclByName

_typeUsesMap

_strNamespace

_tokenizerInstructor

_scriptabilityConstraint

_iBreakOk

_iContinueOk

_iReturnOk

_scriptPartIdStack

_inferenceMapStack

_typeVarsByName

_inferredContextStack

_bThrowForWarnings

_bStudioEditorParser

_bWarnOnCaseIssue

_parsingAbstractConstructor

_ctxInferenceMgr

_blockReturnTypeStack

_parsingStaticFeature

_bCaptureSymbolsForEval

_parsingAnnotation

_allowWildcards

_ignoreTypeDeprecation

_bGenRootExprAccess

_bProgramCallFunction

_typeCache

_iStmtDepth

_savedLocations

_bAreUsingStatementsAllowedInStatementLists

BINDER_ASSIGNABILITY_CACHE

METHOD_PREFIX_LIST

METHOD_PREFIX_LIST_WITH_SETTER

Constructor Detail

GosuParser

GosuParser

Method Detail

setValidator

getScriptPart

getScriptPartIdStack

pushScriptPart

popScriptPart

getInferenceMap

pushInferenceMap

popInferenceMap

setScript

setScript

setScript

resetScript

reset

getScript

getSymbolTable

setSymbolTable

getTypeUsesMap

setTypeUsesMap

getNamespace