private NamespaceNameTree parseNamespaceName() { SourcePosition start = getTreeStartLocation(); IdentifierToken token = eatId(); return new NamespaceNameTree(getTreeLocation(start), buildIdentifierPath(token)); }
private boolean peekFunctionTypeExpression() { if ((config.parseTypeSyntax && peek(TokenType.OPEN_PAREN)) || peek(TokenType.OPEN_ANGLE)) { // TODO(blickly): determine if we can parse this without the // overhead of forking the parser. Parser p = createLookaheadParser(); try { p.maybeParseGenericTypes(); p.parseFormalParameterList(ParamContext.TYPE_EXPRESSION); if (p.peek(TokenType.COLON)) { p.parseTypeAnnotation(); } return p.peek(TokenType.ARROW); } catch (ParseException e) { return false; } } return false; }
private ParseTree parseBreakStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.BREAK); IdentifierToken name = null; if (!peekImplicitSemiColon()) { name = eatIdOpt(); } eatPossibleImplicitSemiColon(); return new BreakStatementTree(getTreeLocation(start), name); }
private ParseTree parseParenTypeExpression() { ParseTree typeExpression; if (peek(TokenType.OPEN_PAREN)) { eat(TokenType.OPEN_PAREN); typeExpression = parseType(); eat(TokenType.CLOSE_PAREN); } else { typeExpression = parseRecordTypeExpression(); } return typeExpression; }
private ParseTree parseAmbientFunctionDeclaration() { SourcePosition start = getTreeStartLocation(); eat(Keywords.FUNCTION.type); boolean isGenerator = eatOpt(TokenType.STAR) != null; IdentifierToken name = eatId(); return parseAmbientFunctionDeclaration(start, name, isGenerator); }
private Token eatObjectLiteralPropertyName() { Token token = peekToken(); switch (token.type) { case STRING: case NUMBER: return nextToken(); case IDENTIFIER: default: return eatIdOrKeywordAsId(); } }
private ParseTree parseForStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.FOR); eat(TokenType.OPEN_PAREN); if (peekVariableDeclarationList()) { VariableDeclarationListTree variables = parseVariableDeclarationListNoIn(); if (peek(TokenType.IN)) { reportError("for-in statement may not have more than one variable declaration"); reportError("for-in statement may not have initializer"); } else { errorReporter.reportWarning(declaration.location.start, return parseForInStatement(start, variables); } else if (peekPredefinedString(PredefinedName.OF)) { reportError("for-of statement may not have more than one variable declaration"); reportError("for-of statement may not have initializer"); return parseForOfStatement(start, variables); } else { checkVanillaForInitializers(variables); return parseForStatement(start, variables); if (peek(TokenType.SEMI_COLON)) { return parseForStatement(start, null);
private ParseTree parseClassMemberDeclaration( boolean allowStatic, boolean isAmbient, TokenType access) { SourcePosition start = getTreeStartLocation(); boolean isStatic = false; if (allowStatic && peek(TokenType.STATIC) && peekType(1) != TokenType.OPEN_PAREN) { eat(TokenType.STATIC); isStatic = true; boolean isGenerator = eatOpt(TokenType.STAR) != null; if (peekIdOrKeyword()) { nameExpr = null; name = eatIdOrKeywordAsId(); } else { if (peekIndexSignature()) { ParseTree indexSignature = parseIndexSignature(); eatPossibleImplicitSemiColon(); return indexSignature; nameExpr = parseComputedPropertyName(); name = null; if (peek(TokenType.OPEN_PAREN) || peek(TokenType.OPEN_ANGLE)) { function = parseMethodSignature( start, name, isStatic, isGenerator, false, accessOnFunction); eatPossibleImplicitSemiColon(); } else { function = parseFunctionTail( start, name, isStatic, isGenerator, accessOnFunction, kind);
private ParseTree parseClassMemberDeclaration(PartialClassElement partial) { boolean isGenerator = eatOpt(TokenType.STAR) != null; if (peekPropertyName(0)) { if (peekIdOrKeyword()) { nameExpr = null; name = eatIdOrKeywordAsId(); if (Keywords.isKeyword(name.value, /* includeTypeScriptKeywords= */ false)) { recordFeatureUsed(Feature.KEYWORDS_AS_PROPERTIES); nameExpr = parseLiteralExpression(); if (config.parseTypeSyntax && peekIndexSignature()) { ParseTree indexSignature = parseIndexSignature(); eatPossibleImplicitSemiColon(); return indexSignature; nameExpr = parseComputedPropertyName(); name = null; if (!config.parseTypeSyntax || peek(TokenType.OPEN_PAREN) || peek(TokenType.OPEN_ANGLE)) { function = parseMethodSignature(partial, name, isGenerator, /* isOptional */ false); eatPossibleImplicitSemiColon(); } else { FunctionDeclarationTree.Builder builder = .setStatic(partial.isStatic) .setAccess(accessOnFunction); parseFunctionTail(builder, isGenerator ? FunctionFlavor.GENERATOR : FunctionFlavor.NORMAL);
private ParseTree parseAsyncMethod(PartialClassElement partial) { eatPredefinedString(ASYNC); boolean generator = peek(TokenType.STAR); if (generator) { eat(TokenType.STAR); if (peekPropertyName(0)) { if (peekIdOrKeyword()) { IdentifierToken name = eatIdOrKeywordAsId(); FunctionDeclarationTree.Builder builder = FunctionDeclarationTree.builder(FunctionDeclarationTree.Kind.MEMBER) if (partial.isAmbient) { builder .setGenerics(maybeParseGenericTypes()) .setFormalParameterList(parseFormalParameterList(ParamContext.SIGNATURE)) .setReturnType(maybeParseColonType()) .setFunctionBody(new EmptyStatementTree(getTreeLocation(partial.start))); eatPossibleImplicitSemiColon(); } else { parseFunctionTail( builder, generator ? FunctionFlavor.ASYNCHRONOUS_GENERATOR : FunctionFlavor.ASYNCHRONOUS); return builder.build(getTreeLocation(name.getStart())); } else { ParseTree nameExpr = parseLiteralExpression(); FunctionDeclarationTree.Builder builder = FunctionDeclarationTree.builder(FunctionDeclarationTree.Kind.EXPRESSION)
private ParseTree parseGetAccessor(TokenType access) { SourcePosition start = getTreeStartLocation(); boolean isStatic = eatOpt(TokenType.STATIC) != null; eatPredefinedString(PredefinedName.GET); if (peekPropertyName(0)) { Token propertyName = eatObjectLiteralPropertyName(); eat(TokenType.OPEN_PAREN); eat(TokenType.CLOSE_PAREN); ParseTree returnType = maybeParseColonType(); BlockTree body = parseFunctionBody(); return new GetAccessorTree(getTreeLocation(start), propertyName, isStatic, returnType, body); } else { ParseTree property = parseComputedPropertyName(); eat(TokenType.OPEN_PAREN); eat(TokenType.CLOSE_PAREN); ParseTree returnType = maybeParseColonType(); BlockTree body = parseFunctionBody(); return new ComputedPropertyGetterTree( getTreeLocation(start), property, isStatic, access, returnType, body); } }
private ParseTree parseObjectPatternField(PatternKind kind) { SourcePosition start = getTreeStartLocation(); if (peekType() == TokenType.OPEN_SQUARE) { ParseTree key = parseComputedPropertyName(); eat(TokenType.COLON); ParseTree value = parsePatternAssignmentTarget(kind); return new ComputedPropertyDefinitionTree(getTreeLocation(start), key, value); if (peekIdOrKeyword()) { name = eatIdOrKeywordAsId(); if (!peek(TokenType.COLON)) { IdentifierToken idToken = (IdentifierToken) name; if (Keywords.isKeyword(idToken.value, /* includeTypeScriptKeywords = */ false)) { reportError("cannot use keyword '%s' here.", name); if (peek(TokenType.EQUAL)) { IdentifierExpressionTree idTree = new IdentifierExpressionTree( getTreeLocation(start), idToken); eat(TokenType.EQUAL); ParseTree defaultValue = parseAssignmentExpression(); return new DefaultParameterTree(getTreeLocation(start), idTree, defaultValue); return new PropertyNameAssignmentTree(getTreeLocation(start), name, null); name = parseLiteralExpression().literalToken; eat(TokenType.COLON); ParseTree value = parsePatternAssignmentTarget(kind); return new PropertyNameAssignmentTree(getTreeLocation(start), name, value);
private ParseTree parseMemberExpressionNoNew() { SourcePosition start = getTreeStartLocation(); ParseTree operand; if (peekAsyncFunctionStart()) { operand = parseAsyncFunctionExpression(); } else if (peekFunction()) { operand = parseFunctionExpression(); } else { operand = parsePrimaryExpression(); while (peekMemberExpressionSuffix()) { switch (peekType()) { case OPEN_SQUARE: eat(TokenType.OPEN_SQUARE); ParseTree member = parseExpression(); eat(TokenType.CLOSE_SQUARE); operand = new MemberLookupExpressionTree( getTreeLocation(start), operand, member); break; case PERIOD: eat(TokenType.PERIOD); IdentifierToken id = eatIdOrKeywordAsId(); operand = new MemberExpressionTree(getTreeLocation(start), operand, id); break; case NO_SUBSTITUTION_TEMPLATE: case TEMPLATE_HEAD: operand = parseTemplateLiteral(operand); break; default:
private ParseTree parseInterfaceElement() { SourcePosition start = getTreeStartLocation(); boolean isGenerator = eatOpt(TokenType.STAR) != null; TokenType type = peekType(); return parseCallSignature(true); // ConstructSignature } else if (type == TokenType.IDENTIFIER || Keywords.isKeyword(type)) { name = eatIdOrKeywordAsId(); } else if (type == TokenType.OPEN_SQUARE) { // IndexSignature return parseIndexSignature(); } else if (type == TokenType.OPEN_ANGLE || type == TokenType.OPEN_PAREN) { // CallSignature return parseCallSignature(false); if (peek(TokenType.QUESTION)) { eat(TokenType.QUESTION); isOptional = true; if (peek(TokenType.OPEN_PAREN) || peek(TokenType.OPEN_ANGLE)) { ParseTree function = parseMethodSignature( start, name, false, isGenerator, isOptional, null); return function; } else { ParseTree declaredType = maybeParseColonType(); return new MemberVariableTree( getTreeLocation(start), name, false, isOptional, null, declaredType);
private ParseTree parsePropertyNameAssignment() { SourcePosition start = getTreeStartLocation(); Token name = eatObjectLiteralPropertyName(); Token colon = eatOpt(TokenType.COLON); if (colon == null) { if (name.type != TokenType.IDENTIFIER) { reportExpectedError(peekToken(), TokenType.COLON); } else if (Keywords.isKeyword( name.asIdentifier().value, /* includeTypeScriptKeywords= */ false)) { reportError(name, "Cannot use keyword in short object literal"); } else if (peek(TokenType.EQUAL)) { IdentifierExpressionTree idTree = new IdentifierExpressionTree( getTreeLocation(start), (IdentifierToken) name); eat(TokenType.EQUAL); ParseTree defaultValue = parseAssignmentExpression(); return new DefaultParameterTree(getTreeLocation(start), idTree, defaultValue); } } ParseTree value = colon == null ? null : parseAssignmentExpression(); return new PropertyNameAssignmentTree(getTreeLocation(start), name, value); }
@SuppressWarnings("incomplete-switch") private ParseTree parseLeftHandSideExpression() { SourcePosition start = getTreeStartLocation(); ParseTree operand = parseNewExpression(); while (peekCallSuffix()) { switch (peekType()) { case OPEN_PAREN: ArgumentListTree arguments = parseArguments(); operand = new CallExpressionTree(getTreeLocation(start), operand, arguments); break; case OPEN_SQUARE: eat(TokenType.OPEN_SQUARE); ParseTree member = parseExpression(); eat(TokenType.CLOSE_SQUARE); operand = new MemberLookupExpressionTree(getTreeLocation(start), operand, member); break; case PERIOD: eat(TokenType.PERIOD); IdentifierToken id = eatIdOrKeywordAsId(); operand = new MemberExpressionTree(getTreeLocation(start), operand, id); break; case NO_SUBSTITUTION_TEMPLATE: case TEMPLATE_HEAD: operand = parseTemplateLiteral(operand); break; default: throw new AssertionError("unexpected case: " + peekType());
private ParseTree parseObjectLiteral() { SourcePosition start = getTreeStartLocation(); ImmutableList.Builder<ParseTree> result = ImmutableList.builder(); eat(TokenType.OPEN_CURLY); Token commaToken = null; while (peekPropertyNameOrComputedProp(0) || peek(TokenType.STAR) || peekAccessibilityModifier()) { commaToken = null; result.add(parsePropertyAssignment()); commaToken = eatOpt(TokenType.COMMA); if (commaToken == null) { break; } } eat(TokenType.CLOSE_CURLY); maybeReportTrailingComma(commaToken); return new ObjectLiteralExpressionTree(getTreeLocation(start), result.build()); }
private ParseTree parseClass(boolean isExpression, boolean isAmbient) { SourcePosition start = getTreeStartLocation(); eat(TokenType.CLASS); IdentifierToken name = null; if (!isExpression || peekId()) { name = eatId(); GenericTypeListTree generics = maybeParseGenericTypes(); ParseTree superClass = null; if (peek(TokenType.EXTENDS)) { eat(TokenType.EXTENDS); superClass = parseExpression(); if (config.parseTypeSyntax && peek(TokenType.IMPLEMENTS)) { eat(TokenType.IMPLEMENTS); ParseTree type = parseType(); interfaces.add(type); while (peek(TokenType.COMMA)) { eat(TokenType.COMMA); type = parseType(); if (type != null) { interfaces.add(type); eat(TokenType.OPEN_CURLY); ImmutableList<ParseTree> elements = parseClassElements(isAmbient); eat(TokenType.CLOSE_CURLY); return new ClassDeclarationTree(getTreeLocation(start), name, generics, superClass, interfaces.build(), elements);
private ParseTree parseYield(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); eat(TokenType.YIELD); boolean isYieldFor = false; ParseTree expression = null; if (!peekImplicitSemiColon()) { isYieldFor = eatOpt(TokenType.STAR) != null; if (peekAssignmentExpression()) { expression = parseAssignment(expressionIn); } } return new YieldExpressionTree( getTreeLocation(start), isYieldFor, expression); }
private ParseTree parseInterfaceDeclaration() { SourcePosition start = getTreeStartLocation(); eat(TokenType.INTERFACE); IdentifierToken name = eatId(); GenericTypeListTree generics = maybeParseGenericTypes(); ImmutableList.Builder<ParseTree> superTypes = ImmutableList.builder(); if (peek(TokenType.EXTENDS)) { eat(TokenType.EXTENDS); ParseTree type = parseType(); superTypes.add(type); while (peek(TokenType.COMMA)) { eat(TokenType.COMMA); type = parseType(); if (type != null) { superTypes.add(type); } } } eat(TokenType.OPEN_CURLY); ImmutableList<ParseTree> elements = parseInterfaceElements(); eat(TokenType.CLOSE_CURLY); return new InterfaceDeclarationTree(getTreeLocation(start), name, generics, superTypes.build(), elements); }