code
stringlengths 24
2.07M
| docstring
stringlengths 25
85.3k
| func_name
stringlengths 1
92
| language
stringclasses 1
value | repo
stringlengths 5
64
| path
stringlengths 4
172
| url
stringlengths 44
218
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
function parsePrimaryExpression() {
switch (token) {
case 8 /* NumericLiteral */:
case 9 /* StringLiteral */:
case 11 /* NoSubstitutionTemplateLiteral */:
return parseLiteralNode();
case 97 /* ThisKeyword */:
case 95 /* SuperKeyword */:
case 93 /* NullKeyword */:
case 99 /* TrueKeyword */:
case 84 /* FalseKeyword */:
return parseTokenNode();
case 17 /* OpenParenToken */:
return parseParenthesizedExpression();
case 19 /* OpenBracketToken */:
return parseArrayLiteralExpression();
case 15 /* OpenBraceToken */:
return parseObjectLiteralExpression();
case 118 /* AsyncKeyword */:
// Async arrow functions are parsed earlier in parseAssignmentExpressionOrHigher.
// If we encounter `async [no LineTerminator here] function` then this is an async
// function; otherwise, its an identifier.
if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
break;
}
return parseFunctionExpression();
case 73 /* ClassKeyword */:
return parseClassExpression();
case 87 /* FunctionKeyword */:
return parseFunctionExpression();
case 92 /* NewKeyword */:
return parseNewExpression();
case 39 /* SlashToken */:
case 61 /* SlashEqualsToken */:
if (reScanSlashToken() === 10 /* RegularExpressionLiteral */) {
return parseLiteralNode();
}
break;
case 12 /* TemplateHead */:
return parseTemplateExpression();
}
return parseIdentifier(ts.Diagnostics.Expression_expected);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parsePrimaryExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseParenthesizedExpression() {
var node = createNode(172 /* ParenthesizedExpression */);
parseExpected(17 /* OpenParenToken */);
node.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseParenthesizedExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseSpreadElement() {
var node = createNode(185 /* SpreadElementExpression */);
parseExpected(22 /* DotDotDotToken */);
node.expression = parseAssignmentExpressionOrHigher();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseSpreadElement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseArgumentOrArrayLiteralElement() {
return token === 22 /* DotDotDotToken */ ? parseSpreadElement() :
token === 24 /* CommaToken */ ? createNode(187 /* OmittedExpression */) :
parseAssignmentExpressionOrHigher();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseArgumentOrArrayLiteralElement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseArgumentExpression() {
return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseArgumentExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseArrayLiteralExpression() {
var node = createNode(164 /* ArrayLiteralExpression */);
parseExpected(19 /* OpenBracketToken */);
if (scanner.hasPrecedingLineBreak())
node.flags |= 1024 /* MultiLine */;
node.elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
parseExpected(20 /* CloseBracketToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseArrayLiteralExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function tryParseAccessorDeclaration(fullStart, decorators, modifiers) {
if (parseContextualModifier(123 /* GetKeyword */)) {
return parseAccessorDeclaration(145 /* GetAccessor */, fullStart, decorators, modifiers);
}
else if (parseContextualModifier(129 /* SetKeyword */)) {
return parseAccessorDeclaration(146 /* SetAccessor */, fullStart, decorators, modifiers);
}
return undefined;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
tryParseAccessorDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseObjectLiteralElement() {
var fullStart = scanner.getStartPos();
var decorators = parseDecorators();
var modifiers = parseModifiers();
var accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
if (accessor) {
return accessor;
}
var asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
var tokenIsIdentifier = isIdentifier();
var nameToken = token;
var propertyName = parsePropertyName();
// Disallowing of optional property assignments happens in the grammar checker.
var questionToken = parseOptionalToken(53 /* QuestionToken */);
if (asteriskToken || token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken);
}
// check if it is short-hand property assignment or normal property assignment
// NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production
// CoverInitializedName[Yield] :
// IdentifierReference[?Yield] Initializer[In, ?Yield]
// this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern
var isShorthandPropertyAssignment = tokenIsIdentifier && (token === 24 /* CommaToken */ || token === 16 /* CloseBraceToken */ || token === 56 /* EqualsToken */);
if (isShorthandPropertyAssignment) {
var shorthandDeclaration = createNode(246 /* ShorthandPropertyAssignment */, fullStart);
shorthandDeclaration.name = propertyName;
shorthandDeclaration.questionToken = questionToken;
var equalsToken = parseOptionalToken(56 /* EqualsToken */);
if (equalsToken) {
shorthandDeclaration.equalsToken = equalsToken;
shorthandDeclaration.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher);
}
return finishNode(shorthandDeclaration);
}
else {
var propertyAssignment = createNode(245 /* PropertyAssignment */, fullStart);
propertyAssignment.name = propertyName;
propertyAssignment.questionToken = questionToken;
parseExpected(54 /* ColonToken */);
propertyAssignment.initializer = allowInAnd(parseAssignmentExpressionOrHigher);
return finishNode(propertyAssignment);
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseObjectLiteralElement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseObjectLiteralExpression() {
var node = createNode(165 /* ObjectLiteralExpression */);
parseExpected(15 /* OpenBraceToken */);
if (scanner.hasPrecedingLineBreak()) {
node.flags |= 1024 /* MultiLine */;
}
node.properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimeter*/ true);
parseExpected(16 /* CloseBraceToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseObjectLiteralExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseFunctionExpression() {
// GeneratorExpression:
// function* BindingIdentifier [Yield][opt](FormalParameters[Yield]){ GeneratorBody }
//
// FunctionExpression:
// function BindingIdentifier[opt](FormalParameters){ FunctionBody }
var saveDecoratorContext = inDecoratorContext();
if (saveDecoratorContext) {
setDecoratorContext(false);
}
var node = createNode(173 /* FunctionExpression */);
setModifiers(node, parseModifiers());
parseExpected(87 /* FunctionKeyword */);
node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
var isGenerator = !!node.asteriskToken;
var isAsync = !!(node.flags & 256 /* Async */);
node.name =
isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
isGenerator ? doInYieldContext(parseOptionalIdentifier) :
isAsync ? doInAwaitContext(parseOptionalIdentifier) :
parseOptionalIdentifier();
fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
node.body = parseFunctionBlock(/*allowYield*/ isGenerator, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false);
if (saveDecoratorContext) {
setDecoratorContext(true);
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseFunctionExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseOptionalIdentifier() {
return isIdentifier() ? parseIdentifier() : undefined;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseOptionalIdentifier
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseNewExpression() {
var node = createNode(169 /* NewExpression */);
parseExpected(92 /* NewKeyword */);
node.expression = parseMemberExpressionOrHigher();
node.typeArguments = tryParse(parseTypeArgumentsInExpression);
if (node.typeArguments || token === 17 /* OpenParenToken */) {
node.arguments = parseArgumentList();
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseNewExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseFunctionBlock(allowYield, allowAwait, ignoreMissingOpenBrace, diagnosticMessage) {
var savedYieldContext = inYieldContext();
setYieldContext(allowYield);
var savedAwaitContext = inAwaitContext();
setAwaitContext(allowAwait);
// We may be in a [Decorator] context when parsing a function expression or
// arrow function. The body of the function is not in [Decorator] context.
var saveDecoratorContext = inDecoratorContext();
if (saveDecoratorContext) {
setDecoratorContext(false);
}
var block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage);
if (saveDecoratorContext) {
setDecoratorContext(true);
}
setYieldContext(savedYieldContext);
setAwaitContext(savedAwaitContext);
return block;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseFunctionBlock
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseEmptyStatement() {
var node = createNode(194 /* EmptyStatement */);
parseExpected(23 /* SemicolonToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseEmptyStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseIfStatement() {
var node = createNode(196 /* IfStatement */);
parseExpected(88 /* IfKeyword */);
parseExpected(17 /* OpenParenToken */);
node.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
node.thenStatement = parseStatement();
node.elseStatement = parseOptional(80 /* ElseKeyword */) ? parseStatement() : undefined;
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseIfStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseDoStatement() {
var node = createNode(197 /* DoStatement */);
parseExpected(79 /* DoKeyword */);
node.statement = parseStatement();
parseExpected(104 /* WhileKeyword */);
parseExpected(17 /* OpenParenToken */);
node.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
// From: https://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html
// 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in
// spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby
// do;while(0)x will have a semicolon inserted before x.
parseOptional(23 /* SemicolonToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseDoStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseWhileStatement() {
var node = createNode(198 /* WhileStatement */);
parseExpected(104 /* WhileKeyword */);
parseExpected(17 /* OpenParenToken */);
node.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
node.statement = parseStatement();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseWhileStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseForOrForInOrForOfStatement() {
var pos = getNodePos();
parseExpected(86 /* ForKeyword */);
parseExpected(17 /* OpenParenToken */);
var initializer = undefined;
if (token !== 23 /* SemicolonToken */) {
if (token === 102 /* VarKeyword */ || token === 108 /* LetKeyword */ || token === 74 /* ConstKeyword */) {
initializer = parseVariableDeclarationList(/*inForStatementInitializer*/ true);
}
else {
initializer = disallowInAnd(parseExpression);
}
}
var forOrForInOrForOfStatement;
if (parseOptional(90 /* InKeyword */)) {
var forInStatement = createNode(200 /* ForInStatement */, pos);
forInStatement.initializer = initializer;
forInStatement.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
forOrForInOrForOfStatement = forInStatement;
}
else if (parseOptional(134 /* OfKeyword */)) {
var forOfStatement = createNode(201 /* ForOfStatement */, pos);
forOfStatement.initializer = initializer;
forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
parseExpected(18 /* CloseParenToken */);
forOrForInOrForOfStatement = forOfStatement;
}
else {
var forStatement = createNode(199 /* ForStatement */, pos);
forStatement.initializer = initializer;
parseExpected(23 /* SemicolonToken */);
if (token !== 23 /* SemicolonToken */ && token !== 18 /* CloseParenToken */) {
forStatement.condition = allowInAnd(parseExpression);
}
parseExpected(23 /* SemicolonToken */);
if (token !== 18 /* CloseParenToken */) {
forStatement.incrementor = allowInAnd(parseExpression);
}
parseExpected(18 /* CloseParenToken */);
forOrForInOrForOfStatement = forStatement;
}
forOrForInOrForOfStatement.statement = parseStatement();
return finishNode(forOrForInOrForOfStatement);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseForOrForInOrForOfStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseBreakOrContinueStatement(kind) {
var node = createNode(kind);
parseExpected(kind === 203 /* BreakStatement */ ? 70 /* BreakKeyword */ : 75 /* ContinueKeyword */);
if (!canParseSemicolon()) {
node.label = parseIdentifier();
}
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseBreakOrContinueStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseReturnStatement() {
var node = createNode(204 /* ReturnStatement */);
parseExpected(94 /* ReturnKeyword */);
if (!canParseSemicolon()) {
node.expression = allowInAnd(parseExpression);
}
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseReturnStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseWithStatement() {
var node = createNode(205 /* WithStatement */);
parseExpected(105 /* WithKeyword */);
parseExpected(17 /* OpenParenToken */);
node.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
node.statement = parseStatement();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseWithStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseCaseClause() {
var node = createNode(241 /* CaseClause */);
parseExpected(71 /* CaseKeyword */);
node.expression = allowInAnd(parseExpression);
parseExpected(54 /* ColonToken */);
node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseCaseClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseDefaultClause() {
var node = createNode(242 /* DefaultClause */);
parseExpected(77 /* DefaultKeyword */);
parseExpected(54 /* ColonToken */);
node.statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseDefaultClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseCaseOrDefaultClause() {
return token === 71 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseCaseOrDefaultClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseSwitchStatement() {
var node = createNode(206 /* SwitchStatement */);
parseExpected(96 /* SwitchKeyword */);
parseExpected(17 /* OpenParenToken */);
node.expression = allowInAnd(parseExpression);
parseExpected(18 /* CloseParenToken */);
var caseBlock = createNode(220 /* CaseBlock */, scanner.getStartPos());
parseExpected(15 /* OpenBraceToken */);
caseBlock.clauses = parseList(2 /* SwitchClauses */, parseCaseOrDefaultClause);
parseExpected(16 /* CloseBraceToken */);
node.caseBlock = finishNode(caseBlock);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseSwitchStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseThrowStatement() {
// ThrowStatement[Yield] :
// throw [no LineTerminator here]Expression[In, ?Yield];
// Because of automatic semicolon insertion, we need to report error if this
// throw could be terminated with a semicolon. Note: we can't call 'parseExpression'
// directly as that might consume an expression on the following line.
// We just return 'undefined' in that case. The actual error will be reported in the
// grammar walker.
var node = createNode(208 /* ThrowStatement */);
parseExpected(98 /* ThrowKeyword */);
node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression);
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseThrowStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseCatchClause() {
var result = createNode(244 /* CatchClause */);
parseExpected(72 /* CatchKeyword */);
if (parseExpected(17 /* OpenParenToken */)) {
result.variableDeclaration = parseVariableDeclaration();
}
parseExpected(18 /* CloseParenToken */);
result.block = parseBlock(/*ignoreMissingOpenBrace*/ false);
return finishNode(result);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseCatchClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseDebuggerStatement() {
var node = createNode(210 /* DebuggerStatement */);
parseExpected(76 /* DebuggerKeyword */);
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseDebuggerStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseExpressionOrLabeledStatement() {
// Avoiding having to do the lookahead for a labeled statement by just trying to parse
// out an expression, seeing if it is identifier and then seeing if it is followed by
// a colon.
var fullStart = scanner.getStartPos();
var expression = allowInAnd(parseExpression);
if (expression.kind === 69 /* Identifier */ && parseOptional(54 /* ColonToken */)) {
var labeledStatement = createNode(207 /* LabeledStatement */, fullStart);
labeledStatement.label = expression;
labeledStatement.statement = parseStatement();
return finishNode(labeledStatement);
}
else {
var expressionStatement = createNode(195 /* ExpressionStatement */, fullStart);
expressionStatement.expression = expression;
parseSemicolon();
return finishNode(expressionStatement);
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseExpressionOrLabeledStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsIdentifierOrKeywordOnSameLine() {
nextToken();
return ts.tokenIsIdentifierOrKeyword(token) && !scanner.hasPrecedingLineBreak();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsIdentifierOrKeywordOnSameLine
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsFunctionKeywordOnSameLine() {
nextToken();
return token === 87 /* FunctionKeyword */ && !scanner.hasPrecedingLineBreak();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsFunctionKeywordOnSameLine
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() {
nextToken();
return (ts.tokenIsIdentifierOrKeyword(token) || token === 8 /* NumericLiteral */) && !scanner.hasPrecedingLineBreak();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsIdentifierOrKeywordOrNumberOnSameLine
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isDeclaration() {
while (true) {
switch (token) {
case 102 /* VarKeyword */:
case 108 /* LetKeyword */:
case 74 /* ConstKeyword */:
case 87 /* FunctionKeyword */:
case 73 /* ClassKeyword */:
case 81 /* EnumKeyword */:
return true;
// 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers;
// however, an identifier cannot be followed by another identifier on the same line. This is what we
// count on to parse out the respective declarations. For instance, we exploit this to say that
//
// namespace n
//
// can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees
//
// namespace
// n
//
// as the identifier 'namespace' on one line followed by the identifier 'n' on another.
// We need to look one token ahead to see if it permissible to try parsing a declaration.
//
// *Note*: 'interface' is actually a strict mode reserved word. So while
//
// "use strict"
// interface
// I {}
//
// could be legal, it would add complexity for very little gain.
case 107 /* InterfaceKeyword */:
case 132 /* TypeKeyword */:
return nextTokenIsIdentifierOnSameLine();
case 125 /* ModuleKeyword */:
case 126 /* NamespaceKeyword */:
return nextTokenIsIdentifierOrStringLiteralOnSameLine();
case 115 /* AbstractKeyword */:
case 118 /* AsyncKeyword */:
case 122 /* DeclareKeyword */:
case 110 /* PrivateKeyword */:
case 111 /* ProtectedKeyword */:
case 112 /* PublicKeyword */:
nextToken();
// ASI takes effect for this modifier.
if (scanner.hasPrecedingLineBreak()) {
return false;
}
continue;
case 89 /* ImportKeyword */:
nextToken();
return token === 9 /* StringLiteral */ || token === 37 /* AsteriskToken */ ||
token === 15 /* OpenBraceToken */ || ts.tokenIsIdentifierOrKeyword(token);
case 82 /* ExportKeyword */:
nextToken();
if (token === 56 /* EqualsToken */ || token === 37 /* AsteriskToken */ ||
token === 15 /* OpenBraceToken */ || token === 77 /* DefaultKeyword */) {
return true;
}
continue;
case 113 /* StaticKeyword */:
nextToken();
continue;
default:
return false;
}
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isStartOfDeclaration() {
return lookAhead(isDeclaration);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isStartOfDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isStartOfStatement() {
switch (token) {
case 55 /* AtToken */:
case 23 /* SemicolonToken */:
case 15 /* OpenBraceToken */:
case 102 /* VarKeyword */:
case 108 /* LetKeyword */:
case 87 /* FunctionKeyword */:
case 73 /* ClassKeyword */:
case 81 /* EnumKeyword */:
case 88 /* IfKeyword */:
case 79 /* DoKeyword */:
case 104 /* WhileKeyword */:
case 86 /* ForKeyword */:
case 75 /* ContinueKeyword */:
case 70 /* BreakKeyword */:
case 94 /* ReturnKeyword */:
case 105 /* WithKeyword */:
case 96 /* SwitchKeyword */:
case 98 /* ThrowKeyword */:
case 100 /* TryKeyword */:
case 76 /* DebuggerKeyword */:
// 'catch' and 'finally' do not actually indicate that the code is part of a statement,
// however, we say they are here so that we may gracefully parse them and error later.
case 72 /* CatchKeyword */:
case 85 /* FinallyKeyword */:
return true;
case 74 /* ConstKeyword */:
case 82 /* ExportKeyword */:
case 89 /* ImportKeyword */:
return isStartOfDeclaration();
case 118 /* AsyncKeyword */:
case 122 /* DeclareKeyword */:
case 107 /* InterfaceKeyword */:
case 125 /* ModuleKeyword */:
case 126 /* NamespaceKeyword */:
case 132 /* TypeKeyword */:
// When these don't start a declaration, they're an identifier in an expression statement
return true;
case 112 /* PublicKeyword */:
case 110 /* PrivateKeyword */:
case 111 /* ProtectedKeyword */:
case 113 /* StaticKeyword */:
// When these don't start a declaration, they may be the start of a class member if an identifier
// immediately follows. Otherwise they're an identifier in an expression statement.
return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
default:
return isStartOfExpression();
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isStartOfStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsIdentifierOrStartOfDestructuring() {
nextToken();
return isIdentifier() || token === 15 /* OpenBraceToken */ || token === 19 /* OpenBracketToken */;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsIdentifierOrStartOfDestructuring
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isLetDeclaration() {
// In ES6 'let' always starts a lexical declaration if followed by an identifier or {
// or [.
return lookAhead(nextTokenIsIdentifierOrStartOfDestructuring);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isLetDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseStatement() {
switch (token) {
case 23 /* SemicolonToken */:
return parseEmptyStatement();
case 15 /* OpenBraceToken */:
return parseBlock(/*ignoreMissingOpenBrace*/ false);
case 102 /* VarKeyword */:
return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
case 108 /* LetKeyword */:
if (isLetDeclaration()) {
return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
}
break;
case 87 /* FunctionKeyword */:
return parseFunctionDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
case 73 /* ClassKeyword */:
return parseClassDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
case 88 /* IfKeyword */:
return parseIfStatement();
case 79 /* DoKeyword */:
return parseDoStatement();
case 104 /* WhileKeyword */:
return parseWhileStatement();
case 86 /* ForKeyword */:
return parseForOrForInOrForOfStatement();
case 75 /* ContinueKeyword */:
return parseBreakOrContinueStatement(202 /* ContinueStatement */);
case 70 /* BreakKeyword */:
return parseBreakOrContinueStatement(203 /* BreakStatement */);
case 94 /* ReturnKeyword */:
return parseReturnStatement();
case 105 /* WithKeyword */:
return parseWithStatement();
case 96 /* SwitchKeyword */:
return parseSwitchStatement();
case 98 /* ThrowKeyword */:
return parseThrowStatement();
case 100 /* TryKeyword */:
// Include 'catch' and 'finally' for error recovery.
case 72 /* CatchKeyword */:
case 85 /* FinallyKeyword */:
return parseTryStatement();
case 76 /* DebuggerKeyword */:
return parseDebuggerStatement();
case 55 /* AtToken */:
return parseDeclaration();
case 118 /* AsyncKeyword */:
case 107 /* InterfaceKeyword */:
case 132 /* TypeKeyword */:
case 125 /* ModuleKeyword */:
case 126 /* NamespaceKeyword */:
case 122 /* DeclareKeyword */:
case 74 /* ConstKeyword */:
case 81 /* EnumKeyword */:
case 82 /* ExportKeyword */:
case 89 /* ImportKeyword */:
case 110 /* PrivateKeyword */:
case 111 /* ProtectedKeyword */:
case 112 /* PublicKeyword */:
case 115 /* AbstractKeyword */:
case 113 /* StaticKeyword */:
if (isStartOfDeclaration()) {
return parseDeclaration();
}
break;
}
return parseExpressionOrLabeledStatement();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseDeclaration() {
var fullStart = getNodePos();
var decorators = parseDecorators();
var modifiers = parseModifiers();
switch (token) {
case 102 /* VarKeyword */:
case 108 /* LetKeyword */:
case 74 /* ConstKeyword */:
return parseVariableStatement(fullStart, decorators, modifiers);
case 87 /* FunctionKeyword */:
return parseFunctionDeclaration(fullStart, decorators, modifiers);
case 73 /* ClassKeyword */:
return parseClassDeclaration(fullStart, decorators, modifiers);
case 107 /* InterfaceKeyword */:
return parseInterfaceDeclaration(fullStart, decorators, modifiers);
case 132 /* TypeKeyword */:
return parseTypeAliasDeclaration(fullStart, decorators, modifiers);
case 81 /* EnumKeyword */:
return parseEnumDeclaration(fullStart, decorators, modifiers);
case 125 /* ModuleKeyword */:
case 126 /* NamespaceKeyword */:
return parseModuleDeclaration(fullStart, decorators, modifiers);
case 89 /* ImportKeyword */:
return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers);
case 82 /* ExportKeyword */:
nextToken();
return token === 77 /* DefaultKeyword */ || token === 56 /* EqualsToken */ ?
parseExportAssignment(fullStart, decorators, modifiers) :
parseExportDeclaration(fullStart, decorators, modifiers);
default:
if (decorators || modifiers) {
// We reached this point because we encountered decorators and/or modifiers and assumed a declaration
// would follow. For recovery and error reporting purposes, return an incomplete declaration.
var node = createMissingNode(231 /* MissingDeclaration */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Declaration_expected);
node.pos = fullStart;
node.decorators = decorators;
setModifiers(node, modifiers);
return finishNode(node);
}
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
nextToken();
return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === 9 /* StringLiteral */);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsIdentifierOrStringLiteralOnSameLine
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage) {
if (token !== 15 /* OpenBraceToken */ && canParseSemicolon()) {
parseSemicolon();
return;
}
return parseFunctionBlock(isGenerator, isAsync, /*ignoreMissingOpenBrace*/ false, diagnosticMessage);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseFunctionBlockOrSemicolon
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseObjectBindingElement() {
var node = createNode(163 /* BindingElement */);
var tokenIsIdentifier = isIdentifier();
var propertyName = parsePropertyName();
if (tokenIsIdentifier && token !== 54 /* ColonToken */) {
node.name = propertyName;
}
else {
parseExpected(54 /* ColonToken */);
node.propertyName = propertyName;
node.name = parseIdentifierOrPattern();
}
node.initializer = parseBindingElementInitializer(/*inParameter*/ false);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseObjectBindingElement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseObjectBindingPattern() {
var node = createNode(161 /* ObjectBindingPattern */);
parseExpected(15 /* OpenBraceToken */);
node.elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement);
parseExpected(16 /* CloseBraceToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseObjectBindingPattern
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseArrayBindingPattern() {
var node = createNode(162 /* ArrayBindingPattern */);
parseExpected(19 /* OpenBracketToken */);
node.elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement);
parseExpected(20 /* CloseBracketToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseArrayBindingPattern
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isIdentifierOrPattern() {
return token === 15 /* OpenBraceToken */ || token === 19 /* OpenBracketToken */ || isIdentifier();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isIdentifierOrPattern
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseIdentifierOrPattern() {
if (token === 19 /* OpenBracketToken */) {
return parseArrayBindingPattern();
}
if (token === 15 /* OpenBraceToken */) {
return parseObjectBindingPattern();
}
return parseIdentifier();
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseIdentifierOrPattern
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseVariableDeclaration() {
var node = createNode(211 /* VariableDeclaration */);
node.name = parseIdentifierOrPattern();
node.type = parseTypeAnnotation();
if (!isInOrOfKeyword(token)) {
node.initializer = parseInitializer(/*inParameter*/ false);
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseVariableDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseVariableDeclarationList(inForStatementInitializer) {
var node = createNode(212 /* VariableDeclarationList */);
switch (token) {
case 102 /* VarKeyword */:
break;
case 108 /* LetKeyword */:
node.flags |= 8192 /* Let */;
break;
case 74 /* ConstKeyword */:
node.flags |= 16384 /* Const */;
break;
default:
ts.Debug.fail();
}
nextToken();
// The user may have written the following:
//
// for (let of X) { }
//
// In this case, we want to parse an empty declaration list, and then parse 'of'
// as a keyword. The reason this is not automatic is that 'of' is a valid identifier.
// So we need to look ahead to determine if 'of' should be treated as a keyword in
// this context.
// The checker will then give an error that there is an empty declaration list.
if (token === 134 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) {
node.declarations = createMissingList();
}
else {
var savedDisallowIn = inDisallowInContext();
setDisallowInContext(inForStatementInitializer);
node.declarations = parseDelimitedList(8 /* VariableDeclarations */, parseVariableDeclaration);
setDisallowInContext(savedDisallowIn);
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseVariableDeclarationList
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function canFollowContextualOfKeyword() {
return nextTokenIsIdentifier() && nextToken() === 18 /* CloseParenToken */;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
canFollowContextualOfKeyword
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseVariableStatement(fullStart, decorators, modifiers) {
var node = createNode(193 /* VariableStatement */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
node.declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false);
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseVariableStatement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseFunctionDeclaration(fullStart, decorators, modifiers) {
var node = createNode(213 /* FunctionDeclaration */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
parseExpected(87 /* FunctionKeyword */);
node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
node.name = node.flags & 512 /* Default */ ? parseOptionalIdentifier() : parseIdentifier();
var isGenerator = !!node.asteriskToken;
var isAsync = !!(node.flags & 256 /* Async */);
fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseFunctionDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseConstructorDeclaration(pos, decorators, modifiers) {
var node = createNode(144 /* Constructor */, pos);
node.decorators = decorators;
setModifiers(node, modifiers);
parseExpected(121 /* ConstructorKeyword */);
fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node);
node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false, ts.Diagnostics.or_expected);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseConstructorDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, diagnosticMessage) {
var method = createNode(143 /* MethodDeclaration */, fullStart);
method.decorators = decorators;
setModifiers(method, modifiers);
method.asteriskToken = asteriskToken;
method.name = name;
method.questionToken = questionToken;
var isGenerator = !!asteriskToken;
var isAsync = !!(method.flags & 256 /* Async */);
fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method);
method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
return finishNode(method);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseMethodDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken) {
var property = createNode(141 /* PropertyDeclaration */, fullStart);
property.decorators = decorators;
setModifiers(property, modifiers);
property.name = name;
property.questionToken = questionToken;
property.type = parseTypeAnnotation();
// For instance properties specifically, since they are evaluated inside the constructor,
// we do *not * want to parse yield expressions, so we specifically turn the yield context
// off. The grammar would look something like this:
//
// MemberVariableDeclaration[Yield]:
// AccessibilityModifier_opt PropertyName TypeAnnotation_opt Initialiser_opt[In];
// AccessibilityModifier_opt static_opt PropertyName TypeAnnotation_opt Initialiser_opt[In, ?Yield];
//
// The checker may still error in the static case to explicitly disallow the yield expression.
property.initializer = modifiers && modifiers.flags & 64 /* Static */
? allowInAnd(parseNonParameterInitializer)
: doOutsideOfContext(2 /* Yield */ | 1 /* DisallowIn */, parseNonParameterInitializer);
parseSemicolon();
return finishNode(property);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parsePropertyDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers) {
var asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
var name = parsePropertyName();
// Note: this is not legal as per the grammar. But we allow it in the parser and
// report an error in the grammar checker.
var questionToken = parseOptionalToken(53 /* QuestionToken */);
if (asteriskToken || token === 17 /* OpenParenToken */ || token === 25 /* LessThanToken */) {
return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected);
}
else {
return parsePropertyDeclaration(fullStart, decorators, modifiers, name, questionToken);
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parsePropertyOrMethodDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseNonParameterInitializer() {
return parseInitializer(/*inParameter*/ false);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseNonParameterInitializer
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseAccessorDeclaration(kind, fullStart, decorators, modifiers) {
var node = createNode(kind, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
node.name = parsePropertyName();
fillSignature(54 /* ColonToken */, /*yieldContext*/ false, /*awaitContext*/ false, /*requireCompleteParameterList*/ false, node);
node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, /*isAsync*/ false);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseAccessorDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isClassMemberModifier(idToken) {
switch (idToken) {
case 112 /* PublicKeyword */:
case 110 /* PrivateKeyword */:
case 111 /* ProtectedKeyword */:
case 113 /* StaticKeyword */:
return true;
default:
return false;
}
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isClassMemberModifier
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isClassMemberStart() {
var idToken;
if (token === 55 /* AtToken */) {
return true;
}
// Eat up all modifiers, but hold on to the last one in case it is actually an identifier.
while (ts.isModifier(token)) {
idToken = token;
// If the idToken is a class modifier (protected, private, public, and static), it is
// certain that we are starting to parse class member. This allows better error recovery
// Example:
// public foo() ... // true
// public @dec blah ... // true; we will then report an error later
// export public ... // true; we will then report an error later
if (isClassMemberModifier(idToken)) {
return true;
}
nextToken();
}
if (token === 37 /* AsteriskToken */) {
return true;
}
// Try to get the first property-like token following all modifiers.
// This can either be an identifier or the 'get' or 'set' keywords.
if (isLiteralPropertyName()) {
idToken = token;
nextToken();
}
// Index signatures and computed properties are class members; we can parse.
if (token === 19 /* OpenBracketToken */) {
return true;
}
// If we were able to get any potential identifier...
if (idToken !== undefined) {
// If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse.
if (!ts.isKeyword(idToken) || idToken === 129 /* SetKeyword */ || idToken === 123 /* GetKeyword */) {
return true;
}
// If it *is* a keyword, but not an accessor, check a little farther along
// to see if it should actually be parsed as a class member.
switch (token) {
case 17 /* OpenParenToken */: // Method declaration
case 25 /* LessThanToken */: // Generic Method declaration
case 54 /* ColonToken */: // Type Annotation for declaration
case 56 /* EqualsToken */: // Initializer for declaration
case 53 /* QuestionToken */:
return true;
default:
// Covers
// - Semicolons (declaration termination)
// - Closing braces (end-of-class, must be declaration)
// - End-of-files (not valid, but permitted so that it gets caught later on)
// - Line-breaks (enabling *automatic semicolon insertion*)
return canParseSemicolon();
}
}
return false;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isClassMemberStart
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseDecorators() {
var decorators;
while (true) {
var decoratorStart = getNodePos();
if (!parseOptional(55 /* AtToken */)) {
break;
}
if (!decorators) {
decorators = [];
decorators.pos = scanner.getStartPos();
}
var decorator = createNode(139 /* Decorator */, decoratorStart);
decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher);
decorators.push(finishNode(decorator));
}
if (decorators) {
decorators.end = getNodeEnd();
}
return decorators;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseDecorators
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModifiers() {
var flags = 0;
var modifiers;
while (true) {
var modifierStart = scanner.getStartPos();
var modifierKind = token;
if (!parseAnyContextualModifier()) {
break;
}
if (!modifiers) {
modifiers = [];
modifiers.pos = modifierStart;
}
flags |= ts.modifierToFlag(modifierKind);
modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
}
if (modifiers) {
modifiers.flags = flags;
modifiers.end = scanner.getStartPos();
}
return modifiers;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModifiers
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModifiersForArrowFunction() {
var flags = 0;
var modifiers;
if (token === 118 /* AsyncKeyword */) {
var modifierStart = scanner.getStartPos();
var modifierKind = token;
nextToken();
modifiers = [];
modifiers.pos = modifierStart;
flags |= ts.modifierToFlag(modifierKind);
modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
modifiers.flags = flags;
modifiers.end = scanner.getStartPos();
}
return modifiers;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModifiersForArrowFunction
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseClassElement() {
if (token === 23 /* SemicolonToken */) {
var result = createNode(191 /* SemicolonClassElement */);
nextToken();
return finishNode(result);
}
var fullStart = getNodePos();
var decorators = parseDecorators();
var modifiers = parseModifiers();
var accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
if (accessor) {
return accessor;
}
if (token === 121 /* ConstructorKeyword */) {
return parseConstructorDeclaration(fullStart, decorators, modifiers);
}
if (isIndexSignature()) {
return parseIndexSignatureDeclaration(fullStart, decorators, modifiers);
}
// It is very important that we check this *after* checking indexers because
// the [ token can start an index signature or a computed property name
if (ts.tokenIsIdentifierOrKeyword(token) ||
token === 9 /* StringLiteral */ ||
token === 8 /* NumericLiteral */ ||
token === 37 /* AsteriskToken */ ||
token === 19 /* OpenBracketToken */) {
return parsePropertyOrMethodDeclaration(fullStart, decorators, modifiers);
}
if (decorators || modifiers) {
// treat this as a property declaration with a missing name.
var name_7 = createMissingNode(69 /* Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Declaration_expected);
return parsePropertyDeclaration(fullStart, decorators, modifiers, name_7, /*questionToken*/ undefined);
}
// 'isClassMemberStart' should have hinted not to attempt parsing.
ts.Debug.fail("Should not have attempted to parse class member declaration.");
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseClassElement
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseClassExpression() {
return parseClassDeclarationOrExpression(
/*fullStart*/ scanner.getStartPos(),
/*decorators*/ undefined,
/*modifiers*/ undefined, 186 /* ClassExpression */);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseClassExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseClassDeclaration(fullStart, decorators, modifiers) {
return parseClassDeclarationOrExpression(fullStart, decorators, modifiers, 214 /* ClassDeclaration */);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseClassDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseClassDeclarationOrExpression(fullStart, decorators, modifiers, kind) {
var node = createNode(kind, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
parseExpected(73 /* ClassKeyword */);
node.name = parseNameOfClassDeclarationOrExpression();
node.typeParameters = parseTypeParameters();
node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ true);
if (parseExpected(15 /* OpenBraceToken */)) {
// ClassTail[Yield,Await] : (Modified) See 14.5
// ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
node.members = parseClassMembers();
parseExpected(16 /* CloseBraceToken */);
}
else {
node.members = createMissingList();
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseClassDeclarationOrExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseNameOfClassDeclarationOrExpression() {
// implements is a future reserved word so
// 'class implements' might mean either
// - class expression with omitted name, 'implements' starts heritage clause
// - class with name 'implements'
// 'isImplementsClause' helps to disambiguate between these two cases
return isIdentifier() && !isImplementsClause()
? parseIdentifier()
: undefined;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseNameOfClassDeclarationOrExpression
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isImplementsClause() {
return token === 106 /* ImplementsKeyword */ && lookAhead(nextTokenIsIdentifierOrKeyword);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isImplementsClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseHeritageClauses(isClassHeritageClause) {
// ClassTail[Yield,Await] : (Modified) See 14.5
// ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
if (isHeritageClause()) {
return parseList(20 /* HeritageClauses */, parseHeritageClause);
}
return undefined;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseHeritageClauses
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseHeritageClausesWorker() {
return parseList(20 /* HeritageClauses */, parseHeritageClause);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseHeritageClausesWorker
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseHeritageClause() {
if (token === 83 /* ExtendsKeyword */ || token === 106 /* ImplementsKeyword */) {
var node = createNode(243 /* HeritageClause */);
node.token = token;
nextToken();
node.types = parseDelimitedList(7 /* HeritageClauseElement */, parseExpressionWithTypeArguments);
return finishNode(node);
}
return undefined;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseHeritageClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseExpressionWithTypeArguments() {
var node = createNode(188 /* ExpressionWithTypeArguments */);
node.expression = parseLeftHandSideExpressionOrHigher();
if (token === 25 /* LessThanToken */) {
node.typeArguments = parseBracketedList(18 /* TypeArguments */, parseType, 25 /* LessThanToken */, 27 /* GreaterThanToken */);
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseExpressionWithTypeArguments
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isHeritageClause() {
return token === 83 /* ExtendsKeyword */ || token === 106 /* ImplementsKeyword */;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isHeritageClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseClassMembers() {
return parseList(5 /* ClassMembers */, parseClassElement);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseClassMembers
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseInterfaceDeclaration(fullStart, decorators, modifiers) {
var node = createNode(215 /* InterfaceDeclaration */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
parseExpected(107 /* InterfaceKeyword */);
node.name = parseIdentifier();
node.typeParameters = parseTypeParameters();
node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ false);
node.members = parseObjectTypeMembers();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseInterfaceDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseTypeAliasDeclaration(fullStart, decorators, modifiers) {
var node = createNode(216 /* TypeAliasDeclaration */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
parseExpected(132 /* TypeKeyword */);
node.name = parseIdentifier();
node.typeParameters = parseTypeParameters();
parseExpected(56 /* EqualsToken */);
node.type = parseType();
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseTypeAliasDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseEnumMember() {
var node = createNode(247 /* EnumMember */, scanner.getStartPos());
node.name = parsePropertyName();
node.initializer = allowInAnd(parseNonParameterInitializer);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseEnumMember
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseEnumDeclaration(fullStart, decorators, modifiers) {
var node = createNode(217 /* EnumDeclaration */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
parseExpected(81 /* EnumKeyword */);
node.name = parseIdentifier();
if (parseExpected(15 /* OpenBraceToken */)) {
node.members = parseDelimitedList(6 /* EnumMembers */, parseEnumMember);
parseExpected(16 /* CloseBraceToken */);
}
else {
node.members = createMissingList();
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseEnumDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModuleBlock() {
var node = createNode(219 /* ModuleBlock */, scanner.getStartPos());
if (parseExpected(15 /* OpenBraceToken */)) {
node.statements = parseList(1 /* BlockStatements */, parseStatement);
parseExpected(16 /* CloseBraceToken */);
}
else {
node.statements = createMissingList();
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModuleBlock
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) {
var node = createNode(218 /* ModuleDeclaration */, fullStart);
// If we are parsing a dotted namespace name, we want to
// propagate the 'Namespace' flag across the names if set.
var namespaceFlag = flags & 65536 /* Namespace */;
node.decorators = decorators;
setModifiers(node, modifiers);
node.flags |= flags;
node.name = parseIdentifier();
node.body = parseOptional(21 /* DotToken */)
? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, 2 /* Export */ | namespaceFlag)
: parseModuleBlock();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModuleOrNamespaceDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers) {
var node = createNode(218 /* ModuleDeclaration */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
node.name = parseLiteralNode(/*internName*/ true);
node.body = parseModuleBlock();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseAmbientExternalModuleDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModuleDeclaration(fullStart, decorators, modifiers) {
var flags = modifiers ? modifiers.flags : 0;
if (parseOptional(126 /* NamespaceKeyword */)) {
flags |= 65536 /* Namespace */;
}
else {
parseExpected(125 /* ModuleKeyword */);
if (token === 9 /* StringLiteral */) {
return parseAmbientExternalModuleDeclaration(fullStart, decorators, modifiers);
}
}
return parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModuleDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function isExternalModuleReference() {
return token === 127 /* RequireKeyword */ &&
lookAhead(nextTokenIsOpenParen);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
isExternalModuleReference
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsOpenParen() {
return nextToken() === 17 /* OpenParenToken */;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsOpenParen
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsSlash() {
return nextToken() === 39 /* SlashToken */;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsSlash
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function nextTokenIsCommaOrFromKeyword() {
nextToken();
return token === 24 /* CommaToken */ ||
token === 133 /* FromKeyword */;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
nextTokenIsCommaOrFromKeyword
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers) {
parseExpected(89 /* ImportKeyword */);
var afterImportPos = scanner.getStartPos();
var identifier;
if (isIdentifier()) {
identifier = parseIdentifier();
if (token !== 24 /* CommaToken */ && token !== 133 /* FromKeyword */) {
// ImportEquals declaration of type:
// import x = require("mod"); or
// import x = M.x;
var importEqualsDeclaration = createNode(221 /* ImportEqualsDeclaration */, fullStart);
importEqualsDeclaration.decorators = decorators;
setModifiers(importEqualsDeclaration, modifiers);
importEqualsDeclaration.name = identifier;
parseExpected(56 /* EqualsToken */);
importEqualsDeclaration.moduleReference = parseModuleReference();
parseSemicolon();
return finishNode(importEqualsDeclaration);
}
}
// Import statement
var importDeclaration = createNode(222 /* ImportDeclaration */, fullStart);
importDeclaration.decorators = decorators;
setModifiers(importDeclaration, modifiers);
// ImportDeclaration:
// import ImportClause from ModuleSpecifier ;
// import ModuleSpecifier;
if (identifier ||
token === 37 /* AsteriskToken */ ||
token === 15 /* OpenBraceToken */) {
importDeclaration.importClause = parseImportClause(identifier, afterImportPos);
parseExpected(133 /* FromKeyword */);
}
importDeclaration.moduleSpecifier = parseModuleSpecifier();
parseSemicolon();
return finishNode(importDeclaration);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseImportDeclarationOrImportEqualsDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseImportClause(identifier, fullStart) {
// ImportClause:
// ImportedDefaultBinding
// NameSpaceImport
// NamedImports
// ImportedDefaultBinding, NameSpaceImport
// ImportedDefaultBinding, NamedImports
var importClause = createNode(223 /* ImportClause */, fullStart);
if (identifier) {
// ImportedDefaultBinding:
// ImportedBinding
importClause.name = identifier;
}
// If there was no default import or if there is comma token after default import
// parse namespace or named imports
if (!importClause.name ||
parseOptional(24 /* CommaToken */)) {
importClause.namedBindings = token === 37 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(225 /* NamedImports */);
}
return finishNode(importClause);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseImportClause
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModuleReference() {
return isExternalModuleReference()
? parseExternalModuleReference()
: parseEntityName(/*allowReservedWords*/ false);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModuleReference
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseExternalModuleReference() {
var node = createNode(232 /* ExternalModuleReference */);
parseExpected(127 /* RequireKeyword */);
parseExpected(17 /* OpenParenToken */);
node.expression = parseModuleSpecifier();
parseExpected(18 /* CloseParenToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseExternalModuleReference
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseModuleSpecifier() {
// We allow arbitrary expressions here, even though the grammar only allows string
// literals. We check to ensure that it is only a string literal later in the grammar
// walker.
var result = parseExpression();
// Ensure the string being required is in our 'identifier' table. This will ensure
// that features like 'find refs' will look inside this file when search for its name.
if (result.kind === 9 /* StringLiteral */) {
internIdentifier(result.text);
}
return result;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseModuleSpecifier
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseNamespaceImport() {
// NameSpaceImport:
// * as ImportedBinding
var namespaceImport = createNode(224 /* NamespaceImport */);
parseExpected(37 /* AsteriskToken */);
parseExpected(116 /* AsKeyword */);
namespaceImport.name = parseIdentifier();
return finishNode(namespaceImport);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseNamespaceImport
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseNamedImportsOrExports(kind) {
var node = createNode(kind);
// NamedImports:
// { }
// { ImportsList }
// { ImportsList, }
// ImportsList:
// ImportSpecifier
// ImportsList, ImportSpecifier
node.elements = parseBracketedList(21 /* ImportOrExportSpecifiers */, kind === 225 /* NamedImports */ ? parseImportSpecifier : parseExportSpecifier, 15 /* OpenBraceToken */, 16 /* CloseBraceToken */);
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseNamedImportsOrExports
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseExportSpecifier() {
return parseImportOrExportSpecifier(230 /* ExportSpecifier */);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseExportSpecifier
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseImportSpecifier() {
return parseImportOrExportSpecifier(226 /* ImportSpecifier */);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseImportSpecifier
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseImportOrExportSpecifier(kind) {
var node = createNode(kind);
// ImportSpecifier:
// BindingIdentifier
// IdentifierName as BindingIdentifier
// ExportSpecififer:
// IdentifierName
// IdentifierName as IdentifierName
var checkIdentifierIsKeyword = ts.isKeyword(token) && !isIdentifier();
var checkIdentifierStart = scanner.getTokenPos();
var checkIdentifierEnd = scanner.getTextPos();
var identifierName = parseIdentifierName();
if (token === 116 /* AsKeyword */) {
node.propertyName = identifierName;
parseExpected(116 /* AsKeyword */);
checkIdentifierIsKeyword = ts.isKeyword(token) && !isIdentifier();
checkIdentifierStart = scanner.getTokenPos();
checkIdentifierEnd = scanner.getTextPos();
node.name = parseIdentifierName();
}
else {
node.name = identifierName;
}
if (kind === 226 /* ImportSpecifier */ && checkIdentifierIsKeyword) {
// Report error identifier expected
parseErrorAtPosition(checkIdentifierStart, checkIdentifierEnd - checkIdentifierStart, ts.Diagnostics.Identifier_expected);
}
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseImportOrExportSpecifier
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseExportDeclaration(fullStart, decorators, modifiers) {
var node = createNode(228 /* ExportDeclaration */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
if (parseOptional(37 /* AsteriskToken */)) {
parseExpected(133 /* FromKeyword */);
node.moduleSpecifier = parseModuleSpecifier();
}
else {
node.exportClause = parseNamedImportsOrExports(229 /* NamedExports */);
// It is not uncommon to accidentally omit the 'from' keyword. Additionally, in editing scenarios,
// the 'from' keyword can be parsed as a named export when the export clause is unterminated (i.e. `export { from "moduleName";`)
// If we don't have a 'from' keyword, see if we have a string literal such that ASI won't take effect.
if (token === 133 /* FromKeyword */ || (token === 9 /* StringLiteral */ && !scanner.hasPrecedingLineBreak())) {
parseExpected(133 /* FromKeyword */);
node.moduleSpecifier = parseModuleSpecifier();
}
}
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseExportDeclaration
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function parseExportAssignment(fullStart, decorators, modifiers) {
var node = createNode(227 /* ExportAssignment */, fullStart);
node.decorators = decorators;
setModifiers(node, modifiers);
if (parseOptional(56 /* EqualsToken */)) {
node.isExportEquals = true;
}
else {
parseExpected(77 /* DefaultKeyword */);
}
node.expression = parseAssignmentExpressionOrHigher();
parseSemicolon();
return finishNode(node);
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
parseExportAssignment
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function processReferenceComments(sourceFile) {
var triviaScanner = ts.createScanner(sourceFile.languageVersion, /*skipTrivia*/ false, 0 /* Standard */, sourceText);
var referencedFiles = [];
var amdDependencies = [];
var amdModuleName;
// Keep scanning all the leading trivia in the file until we get to something that
// isn't trivia. Any single line comment will be analyzed to see if it is a
// reference comment.
while (true) {
var kind = triviaScanner.scan();
if (kind === 5 /* WhitespaceTrivia */ || kind === 4 /* NewLineTrivia */ || kind === 3 /* MultiLineCommentTrivia */) {
continue;
}
if (kind !== 2 /* SingleLineCommentTrivia */) {
break;
}
var range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() };
var comment = sourceText.substring(range.pos, range.end);
var referencePathMatchResult = ts.getFileReferenceFromReferencePath(comment, range);
if (referencePathMatchResult) {
var fileReference = referencePathMatchResult.fileReference;
sourceFile.hasNoDefaultLib = referencePathMatchResult.isNoDefaultLib;
var diagnosticMessage = referencePathMatchResult.diagnosticMessage;
if (fileReference) {
referencedFiles.push(fileReference);
}
if (diagnosticMessage) {
parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, diagnosticMessage));
}
}
else {
var amdModuleNameRegEx = /^\/\/\/\s*<amd-module\s+name\s*=\s*('|")(.+?)\1/gim;
var amdModuleNameMatchResult = amdModuleNameRegEx.exec(comment);
if (amdModuleNameMatchResult) {
if (amdModuleName) {
parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, ts.Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments));
}
amdModuleName = amdModuleNameMatchResult[2];
}
var amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s/gim;
var pathRegex = /\spath\s*=\s*('|")(.+?)\1/gim;
var nameRegex = /\sname\s*=\s*('|")(.+?)\1/gim;
var amdDependencyMatchResult = amdDependencyRegEx.exec(comment);
if (amdDependencyMatchResult) {
var pathMatchResult = pathRegex.exec(comment);
var nameMatchResult = nameRegex.exec(comment);
if (pathMatchResult) {
var amdDependency = { path: pathMatchResult[2], name: nameMatchResult ? nameMatchResult[2] : undefined };
amdDependencies.push(amdDependency);
}
}
}
}
sourceFile.referencedFiles = referencedFiles;
sourceFile.amdDependencies = amdDependencies;
sourceFile.moduleName = amdModuleName;
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
processReferenceComments
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
function setExternalModuleIndicator(sourceFile) {
sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) {
return node.flags & 2 /* Export */
|| node.kind === 221 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 232 /* ExternalModuleReference */
|| node.kind === 222 /* ImportDeclaration */
|| node.kind === 227 /* ExportAssignment */
|| node.kind === 228 /* ExportDeclaration */
? node
: undefined;
});
}
|
Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
ES7 IncrementExpression[yield]:
1) LeftHandSideExpression[?yield]
2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
4) ++LeftHandSideExpression[?yield]
5) --LeftHandSideExpression[?yield]
In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
|
setExternalModuleIndicator
|
javascript
|
amol-/dukpy
|
dukpy/jsmodules/typescriptServices.js
|
https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js
|
MIT
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.