/** @return whether the next token is an identifier. */ private boolean peekId(int index) { TokenType type = peekType(index); // There are two special cases to handle here: // * outside of strict-mode code strict-mode keywords can be used as identifiers // * when configured to parse TypeScript code the scanner will return TypeScript // keyword token but these contextual keywords can always be used as idenifiers. return TokenType.IDENTIFIER == type || (config.parseTypeSyntax && Keywords.isTypeScriptSpecificKeyword(type)) || (!inStrictContext() && Keywords.isStrictKeyword(type)); }
private TokenType maybeParseAccessibilityModifier() { if (peekAccessibilityModifier()) { features = features.require(FeatureSet.TYPESCRIPT); if (!config.is6Typed) { reportError("Accessibility modifier is only supported in ES6 typed mode"); } return nextToken().type; } else { return null; } }
private ParseTree parseClassElement(PartialClassElement partialElement) { if (peekGetAccessor()) { return parseGetAccessor(partialElement); } else if (peekSetAccessor()) { return parseSetAccessor(partialElement); } else if (peekAsyncMethod()) { return parseAsyncMethod(partialElement); } else { return parseClassMemberDeclaration(partialElement); } }
public TemplateLiteralToken nextTemplateLiteralToken() { Token token = nextToken(); if (isAtEnd() || token.type != TokenType.CLOSE_CURLY) { reportError(getPosition(index), "Expected '}' after expression in template literal"); } return nextTemplateLiteralTokenShared(TokenType.TEMPLATE_TAIL, TokenType.TEMPLATE_MIDDLE); }
private boolean skipRegularExpressionChar() { switch (peekChar()) { case '\\': return skipRegularExpressionBackslashSequence(); case '[': return skipRegularExpressionClass(); default: nextChar(); return true; } }
private ParseTree parseTypeReference() { SourcePosition start = getTreeStartLocation(); TypeNameTree typeName = parseTypeName(); if (!peek(TokenType.OPEN_ANGLE)) { return typeName; } return parseTypeArgumentList(start, typeName); }
private ParseTree parsePattern(PatternKind kind) { features = features.require(Feature.DESTRUCTURING); switch (peekType()) { case OPEN_SQUARE: return parseArrayPattern(kind); case OPEN_CURLY: default: return parseObjectPattern(kind); } }
private void skipOctalDigits() { while (peekOctalDigit()) { nextChar(); } }
private boolean peekVariableDeclarationList() { switch (peekType()) { case VAR: case CONST: case LET: return true; default: return false; } }
private static boolean isRegularExpressionChar(char ch) { switch (ch) { case '/': return false; case '\\': case '[': return true; default: return !isLineTerminator(ch); } }
private boolean peekAmbientNamespaceElement() { return peek(TokenType.VAR) || peek(TokenType.LET) || peek(TokenType.CONST) || peek(TokenType.FUNCTION) || peek(TokenType.CLASS) || peek(TokenType.INTERFACE) || peek(TokenType.ENUM) || peek(TokenType.MODULE) || peek(TokenType.NAMESPACE) || peek(TokenType.EXPORT); }
/** * In V8 all source elements may appear where statements appear in the grammar. */ private boolean peekStatement() { return peekSourceElement(); }
/** * Consumes a regular expression literal token and returns it. */ private LiteralToken nextRegularExpressionLiteralToken() { LiteralToken token = scanner.nextRegularExpressionLiteralToken(); lastSourcePosition = token.location.end; return token; }
/** Consumes a template literal token and returns it. */ private TemplateLiteralToken nextTemplateLiteralToken() { TemplateLiteralToken token = scanner.nextTemplateLiteralToken(); lastSourcePosition = token.location.end; return token; }
/** * Returns true if the index-th next token is of the expected type. Does not consume * any tokens. */ private boolean peek(int index, TokenType expectedType) { return peekType(index) == expectedType; }