diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 3fcd5fd9fda..474203702ed 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2,8 +2,8 @@ /// module ts { - var nodeConstructors = new Array Node>(SyntaxKind.Count); - /* @internal */ export var parseTime = 0; + let nodeConstructors = new Array Node>(SyntaxKind.Count); + /* @internal */ export let parseTime = 0; export function getNodeConstructor(kind: SyntaxKind): new () => Node { return nodeConstructors[kind] || (nodeConstructors[kind] = objectAllocator.getNodeConstructor(kind)); @@ -28,7 +28,7 @@ module ts { function visitEachNode(cbNode: (node: Node) => T, nodes: Node[]) { if (nodes) { for (let node of nodes) { - var result = cbNode(node); + let result = cbNode(node); if (result) { return result; } @@ -47,8 +47,8 @@ module ts { // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray // callback parameters, but that causes a closure allocation for each invocation with noticeable effects // on performance. - var visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode; - var cbNodes = cbNodeArray || cbNode; + let visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode; + let cbNodes = cbNodeArray || cbNode; switch (node.kind) { case SyntaxKind.QualifiedName: return visitNode(cbNode, (node).left) || @@ -373,7 +373,7 @@ module ts { // overhead. This functions allows us to set all the parents, without all the expense of // binding. - var parent: Node = sourceFile; + let parent: Node = sourceFile; forEachChild(sourceFile, visitNode); return; @@ -384,7 +384,7 @@ module ts { if (n.parent !== parent) { n.parent = parent; - var saveParent = parent; + let saveParent = parent; parent = n; forEachChild(n, visitNode); parent = saveParent; @@ -519,7 +519,7 @@ module ts { function checkNodePositions(node: Node, aggressiveChecks: boolean) { if (aggressiveChecks) { - var pos = node.pos; + let pos = node.pos; forEachChild(node, child => { Debug.assert(child.pos >= pos); pos = child.end; @@ -553,7 +553,7 @@ module ts { // Check if the element intersects the change range. If it does, then it is not // reusable. Also, we'll need to recurse to see what constituent portions we may // be able to use. - var fullEnd = child.end; + let fullEnd = child.end; if (fullEnd >= changeStart) { child.intersectsChange = true; child._children = undefined; @@ -582,7 +582,7 @@ module ts { // Check if the element intersects the change range. If it does, then it is not // reusable. Also, we'll need to recurse to see what constituent portions we may // be able to use. - var fullEnd = array.end; + let fullEnd = array.end; if (fullEnd >= changeStart) { array.intersectsChange = true; array._children = undefined; @@ -611,35 +611,35 @@ module ts { // (as it does not intersect the actual original change range). Because an edit may // change the token touching it, we actually need to look back *at least* one token so // that the prior token sees that change. - var maxLookahead = 1; + let maxLookahead = 1; - var start = changeRange.span.start; + let start = changeRange.span.start; // the first iteration aligns us with the change start. subsequent iteration move us to // the left by maxLookahead tokens. We only need to do this as long as we're not at the // start of the tree. - for (var i = 0; start > 0 && i <= maxLookahead; i++) { - var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start); + for (let i = 0; start > 0 && i <= maxLookahead; i++) { + let nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start); Debug.assert(nearestNode.pos <= start); - var position = nearestNode.pos; + let position = nearestNode.pos; start = Math.max(0, position - 1); } - var finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span)); - var finalLength = changeRange.newLength + (changeRange.span.start - start); + let finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span)); + let finalLength = changeRange.newLength + (changeRange.span.start - start); return createTextChangeRange(finalSpan, finalLength); } function findNearestNodeStartingBeforeOrAtPosition(sourceFile: SourceFile, position: number): Node { - var bestResult: Node = sourceFile; - var lastNodeEntirelyBeforePosition: Node; + let bestResult: Node = sourceFile; + let lastNodeEntirelyBeforePosition: Node; forEachChild(sourceFile, visit); if (lastNodeEntirelyBeforePosition) { - var lastChildOfLastEntireNodeBeforePosition = getLastChild(lastNodeEntirelyBeforePosition); + let lastChildOfLastEntireNodeBeforePosition = getLastChild(lastNodeEntirelyBeforePosition); if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) { bestResult = lastChildOfLastEntireNodeBeforePosition; } @@ -649,7 +649,7 @@ module ts { function getLastChild(node: Node): Node { while (true) { - var lastChild = getLastChildWorker(node); + let lastChild = getLastChildWorker(node); if (lastChild) { node = lastChild; } @@ -660,7 +660,7 @@ module ts { } function getLastChildWorker(node: Node): Node { - var last: Node = undefined; + let last: Node = undefined; forEachChild(node, child => { if (nodeIsPresent(child)) { last = child; @@ -728,17 +728,17 @@ module ts { } function checkChangeRange(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks: boolean) { - var oldText = sourceFile.text; + let oldText = sourceFile.text; if (textChangeRange) { Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length); if (aggressiveChecks || Debug.shouldAssert(AssertionLevel.VeryAggressive)) { - var oldTextPrefix = oldText.substr(0, textChangeRange.span.start); - var newTextPrefix = newText.substr(0, textChangeRange.span.start); + let oldTextPrefix = oldText.substr(0, textChangeRange.span.start); + let newTextPrefix = newText.substr(0, textChangeRange.span.start); Debug.assert(oldTextPrefix === newTextPrefix); - var oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length); - var newTextSuffix = newText.substring(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.length); + let oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length); + let newTextSuffix = newText.substring(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.length); Debug.assert(oldTextSuffix === newTextSuffix); } } @@ -774,16 +774,16 @@ module ts { // This is because we do incremental parsing in-place. i.e. we take nodes from the old // tree and give them new positions and parents. From that point on, trusting the old // tree at all is not possible as far too much of it may violate invariants. - var incrementalSourceFile = sourceFile; + let incrementalSourceFile = sourceFile; Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed); incrementalSourceFile.hasBeenIncrementallyParsed = true; - var oldText = sourceFile.text; - var syntaxCursor = createSyntaxCursor(sourceFile); + let oldText = sourceFile.text; + let syntaxCursor = createSyntaxCursor(sourceFile); // Make the actual change larger so that we know to reparse anything whose lookahead // might have intersected the change. - var changeRange = extendToAffectedRange(sourceFile, textChangeRange); + let changeRange = extendToAffectedRange(sourceFile, textChangeRange); checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks); // Ensure that extending the affected range only moved the start of the change range @@ -795,7 +795,7 @@ module ts { // The is the amount the nodes after the edit range need to be adjusted. It can be // positive (if the edit added characters), negative (if the edit deleted characters) // or zero (if this was a pure overwrite with nothing added/removed). - var delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length; + let delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length; // If we added or removed characters during the edit, then we need to go and adjust all // the nodes after the edit. Those nodes may move forward (if we inserted chars) or they @@ -829,7 +829,7 @@ module ts { // inconsistent tree. Setting the parents on the new tree should be very fast. We // will immediately bail out of walking any subtrees when we can see that their parents // are already correct. - var result = parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true) + let result = parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true) return result; } @@ -842,7 +842,7 @@ module ts { /// Should be called only on prologue directives (isPrologueDirective(node) should be true) function isUseStrictPrologueDirective(sourceFile: SourceFile, node: Node): boolean { Debug.assert(isPrologueDirective(node)); - var nodeText = getSourceTextOfNodeFromSourceFile(sourceFile,(node).expression); + let nodeText = getSourceTextOfNodeFromSourceFile(sourceFile,(node).expression); // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the // string to contain unicode escapes (as per ES5). @@ -876,12 +876,12 @@ module ts { } function createSyntaxCursor(sourceFile: SourceFile): SyntaxCursor { - var currentArray: NodeArray = sourceFile.statements; - var currentArrayIndex = 0; + let currentArray: NodeArray = sourceFile.statements; + let currentArrayIndex = 0; Debug.assert(currentArrayIndex < currentArray.length); - var current = currentArray[currentArrayIndex]; - var lastQueriedPosition = InvalidPosition.Value; + let current = currentArray[currentArrayIndex]; + let lastQueriedPosition = InvalidPosition.Value; return { currentNode(position: number) { @@ -949,7 +949,7 @@ module ts { // position was in this array. Search through this array to see if we find a // viable element. for (let i = 0, n = array.length; i < n; i++) { - var child = array[i]; + let child = array[i]; if (child) { if (child.pos === position) { // Found the right node. We're done. @@ -977,21 +977,21 @@ module ts { } export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false): SourceFile { - var start = new Date().getTime(); - var result = parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes); + let start = new Date().getTime(); + let result = parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes); parseTime += new Date().getTime() - start; return result; } function parseSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, syntaxCursor: SyntaxCursor, setParentNodes = false): SourceFile { - var parsingContext: ParsingContext = 0; - var identifiers: Map = {}; - var identifierCount = 0; - var nodeCount = 0; - var token: SyntaxKind; + let parsingContext: ParsingContext = 0; + let identifiers: Map = {}; + let identifierCount = 0; + let nodeCount = 0; + let token: SyntaxKind; - var sourceFile = createNode(SyntaxKind.SourceFile, /*pos*/ 0); + let sourceFile = createNode(SyntaxKind.SourceFile, /*pos*/ 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; @@ -1049,7 +1049,7 @@ module ts { // Note: it should not be necessary to save/restore these flags during speculative/lookahead // parsing. These context flags are naturally stored and restored through normal recursive // descent parsing and unwinding. - var contextFlags: ParserContextFlags = 0; + let contextFlags: ParserContextFlags = 0; // Whether or not we've had a parse error since creating the last AST node. If we have // encountered an error, it will be stored on the next AST node we create. Parse errors @@ -1078,10 +1078,10 @@ module ts { // // Note: any errors at the end of the file that do not precede a regular node, should get // attached to the EOF token. - var parseErrorBeforeNextFinishedNode: boolean = false; + let parseErrorBeforeNextFinishedNode: boolean = false; // Create and prime the scanner before parsing the source elements. - var scanner = createScanner(languageVersion, /*skipTrivia*/ true, sourceText, scanError); + let scanner = createScanner(languageVersion, /*skipTrivia*/ true, sourceText, scanError); token = nextToken(); processReferenceComments(sourceFile); @@ -1131,7 +1131,7 @@ module ts { function allowInAnd(func: () => T): T { if (contextFlags & ParserContextFlags.DisallowIn) { setDisallowInContext(false); - var result = func(); + let result = func(); setDisallowInContext(true); return result; } @@ -1147,7 +1147,7 @@ module ts { } setDisallowInContext(true); - var result = func(); + let result = func(); setDisallowInContext(false); return result; } @@ -1159,7 +1159,7 @@ module ts { } setYieldContext(true); - var result = func(); + let result = func(); setYieldContext(false); return result; } @@ -1167,7 +1167,7 @@ module ts { function doOutsideOfYieldContext(func: () => T): T { if (contextFlags & ParserContextFlags.Yield) { setYieldContext(false); - var result = func(); + let result = func(); setYieldContext(true); return result; } @@ -1193,15 +1193,15 @@ module ts { } function parseErrorAtCurrentToken(message: DiagnosticMessage, arg0?: any): void { - var start = scanner.getTokenPos(); - var length = scanner.getTextPos() - start; + let start = scanner.getTokenPos(); + let length = scanner.getTextPos() - start; parseErrorAtPosition(start, length, message, arg0); } function parseErrorAtPosition(start: number, length: number, message: DiagnosticMessage, arg0?: any): void { // Don't report another error if it would just be at the same position as the last error. - var lastError = lastOrUndefined(sourceFile.parseDiagnostics); + let lastError = lastOrUndefined(sourceFile.parseDiagnostics); if (!lastError || start !== lastError.start) { sourceFile.parseDiagnostics.push(createFileDiagnostic(sourceFile, start, length, message, arg0)); } @@ -1212,7 +1212,7 @@ module ts { } function scanError(message: DiagnosticMessage, length?: number) { - var pos = scanner.getTextPos(); + let pos = scanner.getTextPos(); parseErrorAtPosition(pos, length || 0, message); } @@ -1247,20 +1247,20 @@ module ts { function speculationHelper(callback: () => T, isLookAhead: boolean): T { // Keep track of the state we'll need to rollback to if lookahead fails (or if the // caller asked us to always reset our state). - var saveToken = token; - var saveParseDiagnosticsLength = sourceFile.parseDiagnostics.length; - var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; + let saveToken = token; + let saveParseDiagnosticsLength = sourceFile.parseDiagnostics.length; + let saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; // Note: it is not actually necessary to save/restore the context flags here. That's // because the saving/restorating of these flags happens naturally through the recursive // descent nature of our parser. However, we still store this here just so we can // assert that that invariant holds. - var saveContextFlags = contextFlags; + let saveContextFlags = contextFlags; // If we're only looking ahead, then tell the scanner to only lookahead as well. // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the // same. - var result = isLookAhead + let result = isLookAhead ? scanner.lookAhead(callback) : scanner.tryScan(callback); @@ -1343,7 +1343,7 @@ module ts { } function parseTokenNode(): T { - var node = createNode(token); + let node = createNode(token); nextToken(); return finishNode(node); } @@ -1374,7 +1374,7 @@ module ts { function createNode(kind: SyntaxKind, pos?: number): Node { nodeCount++; - var node = new (nodeConstructors[kind] || (nodeConstructors[kind] = objectAllocator.getNodeConstructor(kind)))(); + let node = new (nodeConstructors[kind] || (nodeConstructors[kind] = objectAllocator.getNodeConstructor(kind)))(); if (!(pos >= 0)) { pos = scanner.getStartPos(); } @@ -1410,7 +1410,7 @@ module ts { parseErrorAtCurrentToken(diagnosticMessage, arg0); } - var result = createNode(kind, scanner.getStartPos()); + let result = createNode(kind, scanner.getStartPos()); (result).text = ""; return finishNode(result); } @@ -1426,7 +1426,7 @@ module ts { function createIdentifier(isIdentifier: boolean, diagnosticMessage?: DiagnosticMessage): Identifier { identifierCount++; if (isIdentifier) { - var node = createNode(SyntaxKind.Identifier); + let node = createNode(SyntaxKind.Identifier); node.text = internIdentifier(scanner.getTokenValue()); nextToken(); return finishNode(node); @@ -1468,13 +1468,13 @@ module ts { // ComputedPropertyName[Yield] : // [ AssignmentExpression[In, ?Yield] ] // - var node = createNode(SyntaxKind.ComputedPropertyName); + let node = createNode(SyntaxKind.ComputedPropertyName); parseExpected(SyntaxKind.OpenBracketToken); // We parse any expression (including a comma expression). But the grammar // says that only an assignment expression is allowed, so the grammar checker // will error if it sees a comma expression. - var yieldContext = inYieldContext(); + let yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { setYieldContext(false); } @@ -1534,7 +1534,7 @@ module ts { // True if positioned at the start of a list element function isListElement(parsingContext: ParsingContext, inErrorRecovery: boolean): boolean { - var node = currentNode(parsingContext); + let node = currentNode(parsingContext); if (node) { return true; } @@ -1674,7 +1674,7 @@ module ts { // True if positioned at element or terminator of the current list or any enclosing list function isInSomeParsingContext(): boolean { - for (var kind = 0; kind < ParsingContext.Count; kind++) { + for (let kind = 0; kind < ParsingContext.Count; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, /* inErrorRecovery */ true) || isListTerminator(kind)) { return true; @@ -1687,15 +1687,15 @@ module ts { // Parses a list of elements function parseList(kind: ParsingContext, checkForStrictMode: boolean, parseElement: () => T): NodeArray { - var saveParsingContext = parsingContext; + let saveParsingContext = parsingContext; parsingContext |= 1 << kind; - var result = >[]; + let result = >[]; result.pos = getNodePos(); - var savedStrictModeContext = inStrictModeContext(); + let savedStrictModeContext = inStrictModeContext(); while (!isListTerminator(kind)) { if (isListElement(kind, /* inErrorRecovery */ false)) { - var element = parseListElement(kind, parseElement); + let element = parseListElement(kind, parseElement); result.push(element); // test elements only if we are not already in strict mode @@ -1726,7 +1726,7 @@ module ts { } function parseListElement(parsingContext: ParsingContext, parseElement: () => T): T { - var node = currentNode(parsingContext); + let node = currentNode(parsingContext); if (node) { return consumeNode(node); } @@ -1751,7 +1751,7 @@ module ts { return undefined; } - var node = syntaxCursor.currentNode(scanner.getStartPos()); + let node = syntaxCursor.currentNode(scanner.getStartPos()); // Can't reuse a missing node. if (nodeIsMissing(node)) { @@ -1780,7 +1780,7 @@ module ts { // differently depending on what mode it is in. // // This also applies to all our other context flags as well. - var nodeContextFlags = node.parserContextFlags & ParserContextFlags.ParserGeneratedFlags; + let nodeContextFlags = node.parserContextFlags & ParserContextFlags.ParserGeneratedFlags; if (nodeContextFlags !== contextFlags) { return undefined; } @@ -1978,19 +1978,19 @@ module ts { // Very subtle incremental parsing bug. Consider the following code: // - // var v = new List < A, B + // let v = new List < A, B // // This is actually legal code. It's a list of variable declarators "v = new List() + // let v = new List < A, B >() // // then we have a problem. "v = new Listnode; + let variableDeclarator = node; return variableDeclarator.initializer === undefined; } @@ -2000,7 +2000,7 @@ module ts { } // See the comment in isReusableVariableDeclaration for why we do this. - var parameter = node; + let parameter = node; return parameter.initializer === undefined; } @@ -2017,12 +2017,12 @@ module ts { // Parses a comma-delimited list of elements function parseDelimitedList(kind: ParsingContext, parseElement: () => T, considerSemicolonAsDelimeter?: boolean): NodeArray { - var saveParsingContext = parsingContext; + let saveParsingContext = parsingContext; parsingContext |= 1 << kind; - var result = >[]; + let result = >[]; result.pos = getNodePos(); - var commaStart = -1; // Meaning the previous token was not a comma + let commaStart = -1; // Meaning the previous token was not a comma while (true) { if (isListElement(kind, /* inErrorRecovery */ false)) { result.push(parseListElement(kind, parseElement)); @@ -2076,8 +2076,8 @@ module ts { } function createMissingList(): NodeArray { - var pos = getNodePos(); - var result = >[]; + let pos = getNodePos(); + let result = >[]; result.pos = pos; result.end = pos; return result; @@ -2085,7 +2085,7 @@ module ts { function parseBracketedList(kind: ParsingContext, parseElement: () => T, open: SyntaxKind, close: SyntaxKind): NodeArray { if (parseExpected(open)) { - var result = parseDelimitedList(kind, parseElement); + let result = parseDelimitedList(kind, parseElement); parseExpected(close); return result; } @@ -2095,9 +2095,9 @@ module ts { // The allowReservedWords parameter controls whether reserved words are permitted after the first dot function parseEntityName(allowReservedWords: boolean, diagnosticMessage?: DiagnosticMessage): EntityName { - var entity: EntityName = parseIdentifier(diagnosticMessage); + let entity: EntityName = parseIdentifier(diagnosticMessage); while (parseOptional(SyntaxKind.DotToken)) { - var node = createNode(SyntaxKind.QualifiedName, entity.pos); + let node = createNode(SyntaxKind.QualifiedName, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -2126,7 +2126,7 @@ module ts { // In the first case though, ASI will not take effect because there is not a // line terminator after the keyword. if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { - var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); + let matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); if (matchesPattern) { // Report that we need an identifier. However, report it right after the dot, @@ -2140,12 +2140,12 @@ module ts { } function parseTemplateExpression(): TemplateExpression { - var template = createNode(SyntaxKind.TemplateExpression); + let template = createNode(SyntaxKind.TemplateExpression); template.head = parseLiteralNode(); Debug.assert(template.head.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind"); - var templateSpans = >[]; + let templateSpans = >[]; templateSpans.pos = getNodePos(); do { @@ -2160,10 +2160,10 @@ module ts { } function parseTemplateSpan(): TemplateSpan { - var span = createNode(SyntaxKind.TemplateSpan); + let span = createNode(SyntaxKind.TemplateSpan); span.expression = allowInAnd(parseExpression); - var literal: LiteralExpression; + let literal: LiteralExpression; if (token === SyntaxKind.CloseBraceToken) { reScanTemplateToken() @@ -2178,8 +2178,8 @@ module ts { } function parseLiteralNode(internName?: boolean): LiteralExpression { - var node = createNode(token); - var text = scanner.getTokenValue(); + let node = createNode(token); + let text = scanner.getTokenValue(); node.text = internName ? internIdentifier(text) : text; if (scanner.hasExtendedUnicodeEscape()) { @@ -2190,7 +2190,7 @@ module ts { node.isUnterminated = true; } - var tokenPos = scanner.getTokenPos(); + let tokenPos = scanner.getTokenPos(); nextToken(); finishNode(node); @@ -2213,7 +2213,7 @@ module ts { // TYPES function parseTypeReference(): TypeReferenceNode { - var node = createNode(SyntaxKind.TypeReference); + let node = createNode(SyntaxKind.TypeReference); node.typeName = parseEntityName(/*allowReservedWords*/ false, Diagnostics.Type_expected); if (!scanner.hasPrecedingLineBreak() && token === SyntaxKind.LessThanToken) { node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken); @@ -2222,14 +2222,14 @@ module ts { } function parseTypeQuery(): TypeQueryNode { - var node = createNode(SyntaxKind.TypeQuery); + let node = createNode(SyntaxKind.TypeQuery); parseExpected(SyntaxKind.TypeOfKeyword); node.exprName = parseEntityName(/*allowReservedWords*/ true); return finishNode(node); } function parseTypeParameter(): TypeParameterDeclaration { - var node = createNode(SyntaxKind.TypeParameter); + let node = createNode(SyntaxKind.TypeParameter); node.name = parseIdentifier(); if (parseOptional(SyntaxKind.ExtendsKeyword)) { // It's not uncommon for people to write improper constraints to a generic. If the @@ -2282,7 +2282,7 @@ module ts { } function parseParameter(): ParameterDeclaration { - var node = createNode(SyntaxKind.Parameter); + let node = createNode(SyntaxKind.Parameter); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); @@ -2328,7 +2328,7 @@ module ts { yieldAndGeneratorParameterContext: boolean, requireCompleteParameterList: boolean, signature: SignatureDeclaration): void { - var returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken; + let returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken; signature.typeParameters = parseTypeParameters(); signature.parameters = parseParameterList(yieldAndGeneratorParameterContext, requireCompleteParameterList); @@ -2361,13 +2361,13 @@ module ts { // [+GeneratorParameter]BindingIdentifier[Yield]Initializer[In]opt // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt if (parseExpected(SyntaxKind.OpenParenToken)) { - var savedYieldContext = inYieldContext(); - var savedGeneratorParameterContext = inGeneratorParameterContext(); + let savedYieldContext = inYieldContext(); + let savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(yieldAndGeneratorParameterContext); setGeneratorParameterContext(yieldAndGeneratorParameterContext); - var result = parseDelimitedList(ParsingContext.Parameters, parseParameter); + let result = parseDelimitedList(ParsingContext.Parameters, parseParameter); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); @@ -2399,7 +2399,7 @@ module ts { } function parseSignatureMember(kind: SyntaxKind): SignatureDeclaration { - var node = createNode(kind); + let node = createNode(kind); if (kind === SyntaxKind.ConstructSignature) { parseExpected(SyntaxKind.NewKeyword); } @@ -2472,8 +2472,8 @@ module ts { } function parseIndexSignatureDeclaration(modifiers: ModifiersArray): IndexSignatureDeclaration { - var fullStart = modifiers ? modifiers.pos : scanner.getStartPos(); - var node = createNode(SyntaxKind.IndexSignature, fullStart); + let fullStart = modifiers ? modifiers.pos : scanner.getStartPos(); + let node = createNode(SyntaxKind.IndexSignature, fullStart); setModifiers(node, modifiers); node.parameters = parseBracketedList(ParsingContext.Parameters, parseParameter, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken); node.type = parseTypeAnnotation(); @@ -2482,12 +2482,12 @@ module ts { } function parsePropertyOrMethodSignature(): Declaration { - var fullStart = scanner.getStartPos(); - var name = parsePropertyName(); - var questionToken = parseOptionalToken(SyntaxKind.QuestionToken); + let fullStart = scanner.getStartPos(); + let name = parsePropertyName(); + let questionToken = parseOptionalToken(SyntaxKind.QuestionToken); if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) { - var method = createNode(SyntaxKind.MethodSignature, fullStart); + let method = createNode(SyntaxKind.MethodSignature, fullStart); method.name = name; method.questionToken = questionToken; @@ -2498,7 +2498,7 @@ module ts { return finishNode(method); } else { - var property = createNode(SyntaxKind.PropertySignature, fullStart); + let property = createNode(SyntaxKind.PropertySignature, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -2515,7 +2515,7 @@ module ts { return true; default: if (isModifier(token)) { - var result = lookAhead(isStartOfIndexSignatureDeclaration); + let result = lookAhead(isStartOfIndexSignatureDeclaration); if (result) { return result; } @@ -2568,7 +2568,7 @@ module ts { // if it has the same text regardless of whether it is inside a class or an // object type. if (isModifier(token)) { - var result = tryParse(parseIndexSignatureWithModifiers); + let result = tryParse(parseIndexSignatureWithModifiers); if (result) { return result; } @@ -2581,7 +2581,7 @@ module ts { } function parseIndexSignatureWithModifiers() { - var modifiers = parseModifiers(); + let modifiers = parseModifiers(); return isIndexSignature() ? parseIndexSignatureDeclaration(modifiers) : undefined; @@ -2593,13 +2593,13 @@ module ts { } function parseTypeLiteral(): TypeLiteralNode { - var node = createNode(SyntaxKind.TypeLiteral); + let node = createNode(SyntaxKind.TypeLiteral); node.members = parseObjectTypeMembers(); return finishNode(node); } function parseObjectTypeMembers(): NodeArray { - var members: NodeArray; + let members: NodeArray; if (parseExpected(SyntaxKind.OpenBraceToken)) { members = parseList(ParsingContext.TypeMembers, /*checkForStrictMode*/ false, parseTypeMember); parseExpected(SyntaxKind.CloseBraceToken); @@ -2612,13 +2612,13 @@ module ts { } function parseTupleType(): TupleTypeNode { - var node = createNode(SyntaxKind.TupleType); + let node = createNode(SyntaxKind.TupleType); node.elementTypes = parseBracketedList(ParsingContext.TupleElementTypes, parseType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken); return finishNode(node); } function parseParenthesizedType(): ParenthesizedTypeNode { - var node = createNode(SyntaxKind.ParenthesizedType); + let node = createNode(SyntaxKind.ParenthesizedType); parseExpected(SyntaxKind.OpenParenToken); node.type = parseType(); parseExpected(SyntaxKind.CloseParenToken); @@ -2626,7 +2626,7 @@ module ts { } function parseFunctionOrConstructorType(kind: SyntaxKind): FunctionOrConstructorTypeNode { - var node = createNode(kind); + let node = createNode(kind); if (kind === SyntaxKind.ConstructorType) { parseExpected(SyntaxKind.NewKeyword); } @@ -2635,7 +2635,7 @@ module ts { } function parseKeywordAndNoDot(): TypeNode { - var node = parseTokenNode(); + let node = parseTokenNode(); return token === SyntaxKind.DotToken ? undefined : node; } @@ -2647,7 +2647,7 @@ module ts { case SyntaxKind.BooleanKeyword: case SyntaxKind.SymbolKeyword: // If these are followed by a dot, then parse these out as a dotted type reference instead. - var node = tryParse(parseKeywordAndNoDot); + let node = tryParse(parseKeywordAndNoDot); return node || parseTypeReference(); case SyntaxKind.VoidKeyword: return parseTokenNode(); @@ -2693,10 +2693,10 @@ module ts { } function parseArrayTypeOrHigher(): TypeNode { - var type = parseNonArrayType(); + let type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) { parseExpected(SyntaxKind.CloseBracketToken); - var node = createNode(SyntaxKind.ArrayType, type.pos); + let node = createNode(SyntaxKind.ArrayType, type.pos); node.elementType = type; type = finishNode(node); } @@ -2704,15 +2704,15 @@ module ts { } function parseUnionTypeOrHigher(): TypeNode { - var type = parseArrayTypeOrHigher(); + let type = parseArrayTypeOrHigher(); if (token === SyntaxKind.BarToken) { - var types = >[type]; + let types = >[type]; types.pos = type.pos; while (parseOptional(SyntaxKind.BarToken)) { types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(SyntaxKind.UnionType, type.pos); + let node = createNode(SyntaxKind.UnionType, type.pos); node.types = types; type = finishNode(node); } @@ -2760,13 +2760,13 @@ module ts { function parseType(): TypeNode { // The rules about 'yield' only apply to actual code/expression contexts. They don't // apply to 'type' contexts. So we disable these parameters here before moving on. - var savedYieldContext = inYieldContext(); - var savedGeneratorParameterContext = inGeneratorParameterContext(); + let savedYieldContext = inYieldContext(); + let savedGeneratorParameterContext = inGeneratorParameterContext(); setYieldContext(false); setGeneratorParameterContext(false); - var result = parseTypeWorker(); + let result = parseTypeWorker(); setYieldContext(savedYieldContext); setGeneratorParameterContext(savedGeneratorParameterContext); @@ -2847,8 +2847,8 @@ module ts { // AssignmentExpression[in] // Expression[in] , AssignmentExpression[in] - var expr = parseAssignmentExpressionOrHigher(); - var operatorToken: Node; + let expr = parseAssignmentExpressionOrHigher(); + let operatorToken: Node; while ((operatorToken = parseOptionalToken(SyntaxKind.CommaToken))) { expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher()); } @@ -2899,7 +2899,7 @@ module ts { // parameter list. If we do, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is // not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done // with AssignmentExpression if we see one. - var arrowExpression = tryParseParenthesizedArrowFunctionExpression(); + let arrowExpression = tryParseParenthesizedArrowFunctionExpression(); if (arrowExpression) { return arrowExpression; } @@ -2913,7 +2913,7 @@ module ts { // Otherwise, we try to parse out the conditional expression bit. We want to allow any // binary expression here, so we pass in the 'lowest' precedence here so that it matches // and consumes anything. - var expr = parseBinaryExpressionOrHigher(/*precedence:*/ 0); + let expr = parseBinaryExpressionOrHigher(/*precedence:*/ 0); // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single @@ -2976,7 +2976,7 @@ module ts { } function parseYieldExpression(): YieldExpression { - var node = createNode(SyntaxKind.YieldExpression); + let node = createNode(SyntaxKind.YieldExpression); // YieldExpression[In] : // yield @@ -3000,9 +3000,9 @@ module ts { function parseSimpleArrowFunctionExpression(identifier: Identifier): Expression { Debug.assert(token === SyntaxKind.EqualsGreaterThanToken, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(SyntaxKind.ArrowFunction, identifier.pos); + let node = createNode(SyntaxKind.ArrowFunction, identifier.pos); - var parameter = createNode(SyntaxKind.Parameter, identifier.pos); + let parameter = createNode(SyntaxKind.Parameter, identifier.pos); parameter.name = identifier; finishNode(parameter); @@ -3017,7 +3017,7 @@ module ts { } function tryParseParenthesizedArrowFunctionExpression(): Expression { - var triState = isParenthesizedArrowFunctionExpression(); + let triState = isParenthesizedArrowFunctionExpression(); if (triState === Tristate.False) { // It's definitely not a parenthesized arrow function expression. @@ -3028,7 +3028,7 @@ module ts { // following => or { token. Otherwise, we *might* have an arrow function. Try to parse // it out, but don't allow any ambiguity, and return 'undefined' if this could be an // expression instead. - var arrowFunction = triState === Tristate.True + let arrowFunction = triState === Tristate.True ? parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity:*/ true) : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead); @@ -3070,8 +3070,8 @@ module ts { } function isParenthesizedArrowFunctionExpressionWorker() { - var first = token; - var second = nextToken(); + let first = token; + let second = nextToken(); if (first === SyntaxKind.OpenParenToken) { if (second === SyntaxKind.CloseParenToken) { @@ -3079,7 +3079,7 @@ module ts { // This is an arrow function with no parameters. // The last one is not actually an arrow function, // but this is probably what the user intended. - var third = nextToken(); + let third = nextToken(); switch (third) { case SyntaxKind.EqualsGreaterThanToken: case SyntaxKind.ColonToken: @@ -3134,7 +3134,7 @@ module ts { } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): FunctionExpression { - var node = createNode(SyntaxKind.ArrowFunction); + let node = createNode(SyntaxKind.ArrowFunction); // Arrow functions are never generators. // // If we're speculatively parsing a signature for a parenthesized arrow function, then @@ -3177,7 +3177,7 @@ module ts { // user meant to supply a block. For example, if the user wrote: // // a => - // var v = 0; + // let v = 0; // } // // they may be missing an open brace. Check to see if that's the case so we can @@ -3193,14 +3193,14 @@ module ts { function parseConditionalExpressionRest(leftOperand: Expression): Expression { // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher. - var questionToken = parseOptionalToken(SyntaxKind.QuestionToken); + let questionToken = parseOptionalToken(SyntaxKind.QuestionToken); if (!questionToken) { return leftOperand; } // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and // we do not that for the 'whenFalse' part. - var node = createNode(SyntaxKind.ConditionalExpression, leftOperand.pos); + let node = createNode(SyntaxKind.ConditionalExpression, leftOperand.pos); node.condition = leftOperand; node.questionToken = questionToken; node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher); @@ -3211,7 +3211,7 @@ module ts { } function parseBinaryExpressionOrHigher(precedence: number): Expression { - var leftOperand = parseUnaryExpressionOrHigher(); + let leftOperand = parseUnaryExpressionOrHigher(); return parseBinaryExpressionRest(precedence, leftOperand); } @@ -3225,7 +3225,7 @@ module ts { // reScanGreaterToken so that we merge token sequences like > and = into >= reScanGreaterToken(); - var newPrecedence = getBinaryOperatorPrecedence(); + let newPrecedence = getBinaryOperatorPrecedence(); // Check the precedence to see if we should "take" this operator if (newPrecedence <= precedence) { @@ -3293,7 +3293,7 @@ module ts { } function makeBinaryExpression(left: Expression, operatorToken: Node, right: Expression): BinaryExpression { - var node = createNode(SyntaxKind.BinaryExpression, left.pos); + let node = createNode(SyntaxKind.BinaryExpression, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; @@ -3301,7 +3301,7 @@ module ts { } function parsePrefixUnaryExpression() { - var node = createNode(SyntaxKind.PrefixUnaryExpression); + let node = createNode(SyntaxKind.PrefixUnaryExpression); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); @@ -3309,21 +3309,21 @@ module ts { } function parseDeleteExpression() { - var node = createNode(SyntaxKind.DeleteExpression); + let node = createNode(SyntaxKind.DeleteExpression); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(SyntaxKind.TypeOfExpression); + let node = createNode(SyntaxKind.TypeOfExpression); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(SyntaxKind.VoidExpression); + let node = createNode(SyntaxKind.VoidExpression); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -3352,11 +3352,11 @@ module ts { } function parsePostfixExpressionOrHigher(): PostfixExpression { - var expression = parseLeftHandSideExpressionOrHigher(); + let expression = parseLeftHandSideExpressionOrHigher(); Debug.assert(isLeftHandSideExpression(expression)); if ((token === SyntaxKind.PlusPlusToken || token === SyntaxKind.MinusMinusToken) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(SyntaxKind.PostfixUnaryExpression, expression.pos); + let node = createNode(SyntaxKind.PostfixUnaryExpression, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -3397,7 +3397,7 @@ module ts { // the last two CallExpression productions. Or we have a MemberExpression which either // completes the LeftHandSideExpression, or starts the beginning of the first four // CallExpression productions. - var expression = token === SyntaxKind.SuperKeyword + let expression = token === SyntaxKind.SuperKeyword ? parseSuperExpression() : parseMemberExpressionOrHigher(); @@ -3454,19 +3454,19 @@ module ts { // // Because CallExpression and MemberExpression are left recursive, we need to bottom out // of the recursion immediately. So we parse out a primary expression to start with. - var expression = parsePrimaryExpression(); + let expression = parsePrimaryExpression(); return parseMemberExpressionRest(expression); } function parseSuperExpression(): MemberExpression { - var expression = parseTokenNode(); + let expression = parseTokenNode(); if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.DotToken) { return expression; } // If we have seen "super" it must be followed by '(' or '.'. // If it wasn't then just try to parse out a '.' and report an error. - var node = createNode(SyntaxKind.PropertyAccessExpression, expression.pos); + let node = createNode(SyntaxKind.PropertyAccessExpression, expression.pos); node.expression = expression; node.dotToken = parseExpectedToken(SyntaxKind.DotToken, /*reportAtCurrentPosition:*/ false, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); node.name = parseRightSideOfDot(/*allowIdentifierNames:*/ true); @@ -3474,7 +3474,7 @@ module ts { } function parseTypeAssertion(): TypeAssertion { - var node = createNode(SyntaxKind.TypeAssertionExpression); + let node = createNode(SyntaxKind.TypeAssertionExpression); parseExpected(SyntaxKind.LessThanToken); node.type = parseType(); parseExpected(SyntaxKind.GreaterThanToken); @@ -3484,9 +3484,9 @@ module ts { function parseMemberExpressionRest(expression: LeftHandSideExpression): MemberExpression { while (true) { - var dotToken = parseOptionalToken(SyntaxKind.DotToken); + let dotToken = parseOptionalToken(SyntaxKind.DotToken); if (dotToken) { - var propertyAccess = createNode(SyntaxKind.PropertyAccessExpression, expression.pos); + let propertyAccess = createNode(SyntaxKind.PropertyAccessExpression, expression.pos); propertyAccess.expression = expression; propertyAccess.dotToken = dotToken; propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames:*/ true); @@ -3495,7 +3495,7 @@ module ts { } if (parseOptional(SyntaxKind.OpenBracketToken)) { - var indexedAccess = createNode(SyntaxKind.ElementAccessExpression, expression.pos); + let indexedAccess = createNode(SyntaxKind.ElementAccessExpression, expression.pos); indexedAccess.expression = expression; // It's not uncommon for a user to write: "new Type[]". @@ -3503,7 +3503,7 @@ module ts { if (token !== SyntaxKind.CloseBracketToken) { indexedAccess.argumentExpression = allowInAnd(parseExpression); if (indexedAccess.argumentExpression.kind === SyntaxKind.StringLiteral || indexedAccess.argumentExpression.kind === SyntaxKind.NumericLiteral) { - var literal = indexedAccess.argumentExpression; + let literal = indexedAccess.argumentExpression; literal.text = internIdentifier(literal.text); } } @@ -3514,7 +3514,7 @@ module ts { } if (token === SyntaxKind.NoSubstitutionTemplateLiteral || token === SyntaxKind.TemplateHead) { - var tagExpression = createNode(SyntaxKind.TaggedTemplateExpression, expression.pos); + let tagExpression = createNode(SyntaxKind.TaggedTemplateExpression, expression.pos); tagExpression.tag = expression; tagExpression.template = token === SyntaxKind.NoSubstitutionTemplateLiteral ? parseLiteralNode() @@ -3536,12 +3536,12 @@ module ts { // keep checking for postfix expressions. Otherwise, it's just a '<' that's // part of an arithmetic expression. Break out so we consume it higher in the // stack. - var typeArguments = tryParse(parseTypeArgumentsInExpression); + let typeArguments = tryParse(parseTypeArgumentsInExpression); if (!typeArguments) { return expression; } - var callExpr = createNode(SyntaxKind.CallExpression, expression.pos); + let callExpr = createNode(SyntaxKind.CallExpression, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -3549,7 +3549,7 @@ module ts { continue; } else if (token === SyntaxKind.OpenParenToken) { - var callExpr = createNode(SyntaxKind.CallExpression, expression.pos); + let callExpr = createNode(SyntaxKind.CallExpression, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -3562,7 +3562,7 @@ module ts { function parseArgumentList() { parseExpected(SyntaxKind.OpenParenToken); - var result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression); + let result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression); parseExpected(SyntaxKind.CloseParenToken); return result; } @@ -3572,7 +3572,7 @@ module ts { return undefined; } - var typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType); + let typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType); if (!parseExpected(SyntaxKind.GreaterThanToken)) { // If it doesn't have the closing > then it's definitely not an type argument list. return undefined; @@ -3656,7 +3656,7 @@ module ts { } function parseParenthesizedExpression(): ParenthesizedExpression { - var node = createNode(SyntaxKind.ParenthesizedExpression); + let node = createNode(SyntaxKind.ParenthesizedExpression); parseExpected(SyntaxKind.OpenParenToken); node.expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); @@ -3664,7 +3664,7 @@ module ts { } function parseSpreadElement(): Expression { - var node = createNode(SyntaxKind.SpreadElementExpression); + let node = createNode(SyntaxKind.SpreadElementExpression); parseExpected(SyntaxKind.DotDotDotToken); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); @@ -3681,7 +3681,7 @@ module ts { } function parseArrayLiteralExpression(): ArrayLiteralExpression { - var node = createNode(SyntaxKind.ArrayLiteralExpression); + let node = createNode(SyntaxKind.ArrayLiteralExpression); parseExpected(SyntaxKind.OpenBracketToken); if (scanner.hasPrecedingLineBreak()) node.flags |= NodeFlags.MultiLine; node.elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement); @@ -3701,34 +3701,34 @@ module ts { } function parseObjectLiteralElement(): ObjectLiteralElement { - var fullStart = scanner.getStartPos(); - var modifiers = parseModifiers(); + let fullStart = scanner.getStartPos(); + let modifiers = parseModifiers(); - var accessor = tryParseAccessorDeclaration(fullStart, modifiers); + let accessor = tryParseAccessorDeclaration(fullStart, modifiers); if (accessor) { return accessor; } - var asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); - var tokenIsIdentifier = isIdentifier(); - var nameToken = token; - var propertyName = parsePropertyName(); + let asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); + let tokenIsIdentifier = isIdentifier(); + let nameToken = token; + let propertyName = parsePropertyName(); // Disallowing of optional property assignments happens in the grammar checker. - var questionToken = parseOptionalToken(SyntaxKind.QuestionToken); + let questionToken = parseOptionalToken(SyntaxKind.QuestionToken); if (asteriskToken || token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) { return parseMethodDeclaration(fullStart, modifiers, asteriskToken, propertyName, questionToken); } // Parse to check if it is short-hand property assignment or normal property assignment if ((token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart); + let shorthandDeclaration = createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(SyntaxKind.PropertyAssignment, fullStart); + let propertyAssignment = createNode(SyntaxKind.PropertyAssignment, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(SyntaxKind.ColonToken); @@ -3738,7 +3738,7 @@ module ts { } function parseObjectLiteralExpression(): ObjectLiteralExpression { - var node = createNode(SyntaxKind.ObjectLiteralExpression); + let node = createNode(SyntaxKind.ObjectLiteralExpression); parseExpected(SyntaxKind.OpenBraceToken); if (scanner.hasPrecedingLineBreak()) { node.flags |= NodeFlags.MultiLine; @@ -3754,7 +3754,7 @@ module ts { // function * BindingIdentifier[Yield]opt (FormalParameters[Yield, GeneratorParameter]) { GeneratorBody[Yield] } // FunctionExpression: // function BindingIdentifieropt(FormalParameters) { FunctionBody } - var node = createNode(SyntaxKind.FunctionExpression); + let node = createNode(SyntaxKind.FunctionExpression); parseExpected(SyntaxKind.FunctionKeyword); node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -3768,7 +3768,7 @@ module ts { } function parseNewExpression(): NewExpression { - var node = createNode(SyntaxKind.NewExpression); + let node = createNode(SyntaxKind.NewExpression); parseExpected(SyntaxKind.NewKeyword); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -3781,7 +3781,7 @@ module ts { // STATEMENTS function parseBlock(ignoreMissingOpenBrace: boolean, checkForStrictMode: boolean, diagnosticMessage?: DiagnosticMessage): Block { - var node = createNode(SyntaxKind.Block); + let node = createNode(SyntaxKind.Block); if (parseExpected(SyntaxKind.OpenBraceToken, diagnosticMessage) || ignoreMissingOpenBrace) { node.statements = parseList(ParsingContext.BlockStatements, checkForStrictMode, parseStatement); parseExpected(SyntaxKind.CloseBraceToken); @@ -3793,10 +3793,10 @@ module ts { } function parseFunctionBlock(allowYield: boolean, ignoreMissingOpenBrace: boolean, diagnosticMessage?: DiagnosticMessage): Block { - var savedYieldContext = inYieldContext(); + let savedYieldContext = inYieldContext(); setYieldContext(allowYield); - var block = parseBlock(ignoreMissingOpenBrace, /*checkForStrictMode*/ true, diagnosticMessage); + let block = parseBlock(ignoreMissingOpenBrace, /*checkForStrictMode*/ true, diagnosticMessage); setYieldContext(savedYieldContext); @@ -3804,13 +3804,13 @@ module ts { } function parseEmptyStatement(): Statement { - var node = createNode(SyntaxKind.EmptyStatement); + let node = createNode(SyntaxKind.EmptyStatement); parseExpected(SyntaxKind.SemicolonToken); return finishNode(node); } function parseIfStatement(): IfStatement { - var node = createNode(SyntaxKind.IfStatement); + let node = createNode(SyntaxKind.IfStatement); parseExpected(SyntaxKind.IfKeyword); parseExpected(SyntaxKind.OpenParenToken); node.expression = allowInAnd(parseExpression); @@ -3821,7 +3821,7 @@ module ts { } function parseDoStatement(): DoStatement { - var node = createNode(SyntaxKind.DoStatement); + let node = createNode(SyntaxKind.DoStatement); parseExpected(SyntaxKind.DoKeyword); node.statement = parseStatement(); parseExpected(SyntaxKind.WhileKeyword); @@ -3838,7 +3838,7 @@ module ts { } function parseWhileStatement(): WhileStatement { - var node = createNode(SyntaxKind.WhileStatement); + let node = createNode(SyntaxKind.WhileStatement); parseExpected(SyntaxKind.WhileKeyword); parseExpected(SyntaxKind.OpenParenToken); node.expression = allowInAnd(parseExpression); @@ -3848,11 +3848,11 @@ module ts { } function parseForOrForInOrForOfStatement(): Statement { - var pos = getNodePos(); + let pos = getNodePos(); parseExpected(SyntaxKind.ForKeyword); parseExpected(SyntaxKind.OpenParenToken); - var initializer: VariableDeclarationList | Expression = undefined; + let initializer: VariableDeclarationList | Expression = undefined; if (token !== SyntaxKind.SemicolonToken) { if (token === SyntaxKind.VarKeyword || token === SyntaxKind.LetKeyword || token === SyntaxKind.ConstKeyword) { initializer = parseVariableDeclarationList(/*inForStatementInitializer:*/ true); @@ -3861,22 +3861,22 @@ module ts { initializer = disallowInAnd(parseExpression); } } - var forOrForInOrForOfStatement: IterationStatement; + let forOrForInOrForOfStatement: IterationStatement; if (parseOptional(SyntaxKind.InKeyword)) { - var forInStatement = createNode(SyntaxKind.ForInStatement, pos); + let forInStatement = createNode(SyntaxKind.ForInStatement, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); forOrForInOrForOfStatement = forInStatement; } else if (parseOptional(SyntaxKind.OfKeyword)) { - var forOfStatement = createNode(SyntaxKind.ForOfStatement, pos); + let forOfStatement = createNode(SyntaxKind.ForOfStatement, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(SyntaxKind.CloseParenToken); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(SyntaxKind.ForStatement, pos); + let forStatement = createNode(SyntaxKind.ForStatement, pos); forStatement.initializer = initializer; parseExpected(SyntaxKind.SemicolonToken); if (token !== SyntaxKind.SemicolonToken && token !== SyntaxKind.CloseParenToken) { @@ -3896,7 +3896,7 @@ module ts { } function parseBreakOrContinueStatement(kind: SyntaxKind): BreakOrContinueStatement { - var node = createNode(kind); + let node = createNode(kind); parseExpected(kind === SyntaxKind.BreakStatement ? SyntaxKind.BreakKeyword : SyntaxKind.ContinueKeyword); if (!canParseSemicolon()) { @@ -3908,7 +3908,7 @@ module ts { } function parseReturnStatement(): ReturnStatement { - var node = createNode(SyntaxKind.ReturnStatement); + let node = createNode(SyntaxKind.ReturnStatement); parseExpected(SyntaxKind.ReturnKeyword); if (!canParseSemicolon()) { @@ -3920,7 +3920,7 @@ module ts { } function parseWithStatement(): WithStatement { - var node = createNode(SyntaxKind.WithStatement); + let node = createNode(SyntaxKind.WithStatement); parseExpected(SyntaxKind.WithKeyword); parseExpected(SyntaxKind.OpenParenToken); node.expression = allowInAnd(parseExpression); @@ -3930,7 +3930,7 @@ module ts { } function parseCaseClause(): CaseClause { - var node = createNode(SyntaxKind.CaseClause); + let node = createNode(SyntaxKind.CaseClause); parseExpected(SyntaxKind.CaseKeyword); node.expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.ColonToken); @@ -3939,7 +3939,7 @@ module ts { } function parseDefaultClause(): DefaultClause { - var node = createNode(SyntaxKind.DefaultClause); + let node = createNode(SyntaxKind.DefaultClause); parseExpected(SyntaxKind.DefaultKeyword); parseExpected(SyntaxKind.ColonToken); node.statements = parseList(ParsingContext.SwitchClauseStatements, /*checkForStrictMode*/ false, parseStatement); @@ -3951,12 +3951,12 @@ module ts { } function parseSwitchStatement(): SwitchStatement { - var node = createNode(SyntaxKind.SwitchStatement); + let node = createNode(SyntaxKind.SwitchStatement); parseExpected(SyntaxKind.SwitchKeyword); parseExpected(SyntaxKind.OpenParenToken); node.expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); - var caseBlock = createNode(SyntaxKind.CaseBlock, scanner.getStartPos()); + let caseBlock = createNode(SyntaxKind.CaseBlock, scanner.getStartPos()); parseExpected(SyntaxKind.OpenBraceToken); caseBlock.clauses = parseList(ParsingContext.SwitchClauses, /*checkForStrictMode*/ false, parseCaseOrDefaultClause); parseExpected(SyntaxKind.CloseBraceToken); @@ -3973,7 +3973,7 @@ module ts { // 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(SyntaxKind.ThrowStatement); + let node = createNode(SyntaxKind.ThrowStatement); parseExpected(SyntaxKind.ThrowKeyword); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); @@ -3982,7 +3982,7 @@ module ts { // TODO: Review for error recovery function parseTryStatement(): TryStatement { - var node = createNode(SyntaxKind.TryStatement); + let node = createNode(SyntaxKind.TryStatement); parseExpected(SyntaxKind.TryKeyword); node.tryBlock = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode*/ false); @@ -3999,7 +3999,7 @@ module ts { } function parseCatchClause(): CatchClause { - var result = createNode(SyntaxKind.CatchClause); + let result = createNode(SyntaxKind.CatchClause); parseExpected(SyntaxKind.CatchKeyword); if (parseExpected(SyntaxKind.OpenParenToken)) { result.variableDeclaration = parseVariableDeclaration(); @@ -4011,7 +4011,7 @@ module ts { } function parseDebuggerStatement(): Statement { - var node = createNode(SyntaxKind.DebuggerStatement); + let node = createNode(SyntaxKind.DebuggerStatement); parseExpected(SyntaxKind.DebuggerKeyword); parseSemicolon(); return finishNode(node); @@ -4021,17 +4021,17 @@ module ts { // 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); + let fullStart = scanner.getStartPos(); + let expression = allowInAnd(parseExpression); if (expression.kind === SyntaxKind.Identifier && parseOptional(SyntaxKind.ColonToken)) { - var labeledStatement = createNode(SyntaxKind.LabeledStatement, fullStart); + let labeledStatement = createNode(SyntaxKind.LabeledStatement, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(SyntaxKind.ExpressionStatement, fullStart); + let expressionStatement = createNode(SyntaxKind.ExpressionStatement, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -4045,7 +4045,7 @@ module ts { // as the parser will produce the same FunctionDeclaraiton or VariableStatement if it has // the same text regardless of whether it is inside a block or not. if (isModifier(token)) { - var result = lookAhead(parseVariableStatementOrFunctionDeclarationWithModifiers); + let result = lookAhead(parseVariableStatementOrFunctionDeclarationWithModifiers); if (result) { return true; } @@ -4085,7 +4085,7 @@ module ts { // const keyword can precede enum keyword when defining constant enums // 'const enum' do not start statement. // In ES 6 'enum' is a future reserved keyword, so it should not be used as identifier - var isConstEnum = lookAhead(nextTokenIsEnumKeyword); + let isConstEnum = lookAhead(nextTokenIsEnumKeyword); return !isConstEnum; case SyntaxKind.InterfaceKeyword: case SyntaxKind.ClassKeyword: @@ -4175,7 +4175,7 @@ module ts { // same FunctionDeclaraiton or VariableStatement if it has the same text // regardless of whether it is inside a block or not. if (isModifier(token)) { - var result = tryParse(parseVariableStatementOrFunctionDeclarationWithModifiers); + let result = tryParse(parseVariableStatementOrFunctionDeclarationWithModifiers); if (result) { return result; } @@ -4186,11 +4186,11 @@ module ts { } function parseVariableStatementOrFunctionDeclarationWithModifiers(): FunctionDeclaration | VariableStatement { - var start = scanner.getStartPos(); - var modifiers = parseModifiers(); + let start = scanner.getStartPos(); + let modifiers = parseModifiers(); switch (token) { case SyntaxKind.ConstKeyword: - var nextTokenIsEnum = lookAhead(nextTokenIsEnumKeyword) + let nextTokenIsEnum = lookAhead(nextTokenIsEnumKeyword) if (nextTokenIsEnum) { return undefined; } @@ -4226,7 +4226,7 @@ module ts { if (token === SyntaxKind.CommaToken) { return createNode(SyntaxKind.OmittedExpression); } - var node = createNode(SyntaxKind.BindingElement); + let node = createNode(SyntaxKind.BindingElement); node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(/*inParameter*/ false); @@ -4234,9 +4234,9 @@ module ts { } function parseObjectBindingElement(): BindingElement { - var node = createNode(SyntaxKind.BindingElement); + let node = createNode(SyntaxKind.BindingElement); // TODO(andersh): Handle computed properties - var id = parsePropertyName(); + let id = parsePropertyName(); if (id.kind === SyntaxKind.Identifier && token !== SyntaxKind.ColonToken) { node.name = id; } @@ -4250,7 +4250,7 @@ module ts { } function parseObjectBindingPattern(): BindingPattern { - var node = createNode(SyntaxKind.ObjectBindingPattern); + let node = createNode(SyntaxKind.ObjectBindingPattern); parseExpected(SyntaxKind.OpenBraceToken); node.elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement); parseExpected(SyntaxKind.CloseBraceToken); @@ -4258,7 +4258,7 @@ module ts { } function parseArrayBindingPattern(): BindingPattern { - var node = createNode(SyntaxKind.ArrayBindingPattern); + let node = createNode(SyntaxKind.ArrayBindingPattern); parseExpected(SyntaxKind.OpenBracketToken); node.elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement); parseExpected(SyntaxKind.CloseBracketToken); @@ -4280,7 +4280,7 @@ module ts { } function parseVariableDeclaration(): VariableDeclaration { - var node = createNode(SyntaxKind.VariableDeclaration); + let node = createNode(SyntaxKind.VariableDeclaration); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -4290,7 +4290,7 @@ module ts { } function parseVariableDeclarationList(inForStatementInitializer: boolean): VariableDeclarationList { - var node = createNode(SyntaxKind.VariableDeclarationList); + let node = createNode(SyntaxKind.VariableDeclarationList); switch (token) { case SyntaxKind.VarKeyword: @@ -4309,7 +4309,7 @@ module ts { // The user may have written the following: // - // for (var of X) { } + // 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. @@ -4320,7 +4320,7 @@ module ts { node.declarations = createMissingList(); } else { - var savedDisallowIn = inDisallowInContext(); + let savedDisallowIn = inDisallowInContext(); setDisallowInContext(inForStatementInitializer); node.declarations = parseDelimitedList(ParsingContext.VariableDeclarations, parseVariableDeclaration); @@ -4336,7 +4336,7 @@ module ts { } function parseVariableStatement(fullStart: number, modifiers: ModifiersArray): VariableStatement { - var node = createNode(SyntaxKind.VariableStatement, fullStart); + let node = createNode(SyntaxKind.VariableStatement, fullStart); setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(/*inForStatementInitializer:*/ false); parseSemicolon(); @@ -4344,7 +4344,7 @@ module ts { } function parseFunctionDeclaration(fullStart: number, modifiers: ModifiersArray): FunctionDeclaration { - var node = createNode(SyntaxKind.FunctionDeclaration, fullStart); + let node = createNode(SyntaxKind.FunctionDeclaration, fullStart); setModifiers(node, modifiers); parseExpected(SyntaxKind.FunctionKeyword); node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); @@ -4355,7 +4355,7 @@ module ts { } function parseConstructorDeclaration(pos: number, modifiers: ModifiersArray): ConstructorDeclaration { - var node = createNode(SyntaxKind.Constructor, pos); + let node = createNode(SyntaxKind.Constructor, pos); setModifiers(node, modifiers); parseExpected(SyntaxKind.ConstructorKeyword); fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node); @@ -4364,7 +4364,7 @@ module ts { } function parseMethodDeclaration(fullStart: number, modifiers: ModifiersArray, asteriskToken: Node, name: DeclarationName, questionToken: Node, diagnosticMessage?: DiagnosticMessage): MethodDeclaration { - var method = createNode(SyntaxKind.MethodDeclaration, fullStart); + let method = createNode(SyntaxKind.MethodDeclaration, fullStart); setModifiers(method, modifiers); method.asteriskToken = asteriskToken; method.name = name; @@ -4375,17 +4375,17 @@ module ts { } function parsePropertyOrMethodDeclaration(fullStart: number, modifiers: ModifiersArray): ClassElement { - var asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); - var name = parsePropertyName(); + let asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken); + let 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(SyntaxKind.QuestionToken); + let questionToken = parseOptionalToken(SyntaxKind.QuestionToken); if (asteriskToken || token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) { return parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, Diagnostics.or_expected); } else { - var property = createNode(SyntaxKind.PropertyDeclaration, fullStart); + let property = createNode(SyntaxKind.PropertyDeclaration, fullStart); setModifiers(property, modifiers); property.name = name; property.questionToken = questionToken; @@ -4401,7 +4401,7 @@ module ts { } function parseAccessorDeclaration(kind: SyntaxKind, fullStart: number, modifiers: ModifiersArray): AccessorDeclaration { - var node = createNode(kind, fullStart); + let node = createNode(kind, fullStart); setModifiers(node, modifiers); node.name = parsePropertyName(); fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node); @@ -4410,7 +4410,7 @@ module ts { } function isClassMemberStart(): boolean { - var idToken: SyntaxKind; + let idToken: SyntaxKind; // Eat up all modifiers, but hold on to the last one in case it is actually an identifier. while (isModifier(token)) { @@ -4464,11 +4464,11 @@ module ts { } function parseModifiers(): ModifiersArray { - var flags = 0; - var modifiers: ModifiersArray; + let flags = 0; + let modifiers: ModifiersArray; while (true) { - var modifierStart = scanner.getStartPos(); - var modifierKind = token; + let modifierStart = scanner.getStartPos(); + let modifierKind = token; if (!parseAnyContextualModifier()) { break; @@ -4489,10 +4489,10 @@ module ts { } function parseClassElement(): ClassElement { - var fullStart = getNodePos(); - var modifiers = parseModifiers(); + let fullStart = getNodePos(); + let modifiers = parseModifiers(); - var accessor = tryParseAccessorDeclaration(fullStart, modifiers); + let accessor = tryParseAccessorDeclaration(fullStart, modifiers); if (accessor) { return accessor; } @@ -4521,7 +4521,7 @@ module ts { } function parseClassDeclaration(fullStart: number, modifiers: ModifiersArray): ClassDeclaration { - var node = createNode(SyntaxKind.ClassDeclaration, fullStart); + let node = createNode(SyntaxKind.ClassDeclaration, fullStart); setModifiers(node, modifiers); parseExpected(SyntaxKind.ClassKeyword); node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier(); @@ -4564,7 +4564,7 @@ module ts { function parseHeritageClause() { if (token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword) { - var node = createNode(SyntaxKind.HeritageClause); + let node = createNode(SyntaxKind.HeritageClause); node.token = token; nextToken(); node.types = parseDelimitedList(ParsingContext.TypeReferences, parseTypeReference); @@ -4583,7 +4583,7 @@ module ts { } function parseInterfaceDeclaration(fullStart: number, modifiers: ModifiersArray): InterfaceDeclaration { - var node = createNode(SyntaxKind.InterfaceDeclaration, fullStart); + let node = createNode(SyntaxKind.InterfaceDeclaration, fullStart); setModifiers(node, modifiers); parseExpected(SyntaxKind.InterfaceKeyword); node.name = parseIdentifier(); @@ -4594,7 +4594,7 @@ module ts { } function parseTypeAliasDeclaration(fullStart: number, modifiers: ModifiersArray): TypeAliasDeclaration { - var node = createNode(SyntaxKind.TypeAliasDeclaration, fullStart); + let node = createNode(SyntaxKind.TypeAliasDeclaration, fullStart); setModifiers(node, modifiers); parseExpected(SyntaxKind.TypeKeyword); node.name = parseIdentifier(); @@ -4609,14 +4609,14 @@ module ts { // ConstantEnumMemberSection, which starts at the beginning of an enum declaration // or any time an integer literal initializer is encountered. function parseEnumMember(): EnumMember { - var node = createNode(SyntaxKind.EnumMember, scanner.getStartPos()); + let node = createNode(SyntaxKind.EnumMember, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart: number, modifiers: ModifiersArray): EnumDeclaration { - var node = createNode(SyntaxKind.EnumDeclaration, fullStart); + let node = createNode(SyntaxKind.EnumDeclaration, fullStart); setModifiers(node, modifiers); parseExpected(SyntaxKind.EnumKeyword); node.name = parseIdentifier(); @@ -4631,7 +4631,7 @@ module ts { } function parseModuleBlock(): ModuleBlock { - var node = createNode(SyntaxKind.ModuleBlock, scanner.getStartPos()); + let node = createNode(SyntaxKind.ModuleBlock, scanner.getStartPos()); if (parseExpected(SyntaxKind.OpenBraceToken)) { node.statements = parseList(ParsingContext.ModuleElements, /*checkForStrictMode*/false, parseModuleElement); parseExpected(SyntaxKind.CloseBraceToken); @@ -4643,7 +4643,7 @@ module ts { } function parseInternalModuleTail(fullStart: number, modifiers: ModifiersArray, flags: NodeFlags): ModuleDeclaration { - var node = createNode(SyntaxKind.ModuleDeclaration, fullStart); + let node = createNode(SyntaxKind.ModuleDeclaration, fullStart); setModifiers(node, modifiers); node.flags |= flags; node.name = parseIdentifier(); @@ -4654,7 +4654,7 @@ module ts { } function parseAmbientExternalModuleDeclaration(fullStart: number, modifiers: ModifiersArray): ModuleDeclaration { - var node = createNode(SyntaxKind.ModuleDeclaration, fullStart); + let node = createNode(SyntaxKind.ModuleDeclaration, fullStart); setModifiers(node, modifiers); node.name = parseLiteralNode(/*internName:*/ true); node.body = parseModuleBlock(); @@ -4685,16 +4685,16 @@ module ts { function parseImportDeclarationOrImportEqualsDeclaration(fullStart: number, modifiers: ModifiersArray): ImportEqualsDeclaration | ImportDeclaration { parseExpected(SyntaxKind.ImportKeyword); - var afterImportPos = scanner.getStartPos(); + let afterImportPos = scanner.getStartPos(); - var identifier: Identifier; + let identifier: Identifier; if (isIdentifier()) { identifier = parseIdentifier(); if (token !== SyntaxKind.CommaToken && token !== SyntaxKind.FromKeyword) { // ImportEquals declaration of type: // import x = require("mod"); or // import x = M.x; - var importEqualsDeclaration = createNode(SyntaxKind.ImportEqualsDeclaration, fullStart); + let importEqualsDeclaration = createNode(SyntaxKind.ImportEqualsDeclaration, fullStart); setModifiers(importEqualsDeclaration, modifiers); importEqualsDeclaration.name = identifier; parseExpected(SyntaxKind.EqualsToken); @@ -4705,7 +4705,7 @@ module ts { } // Import statement - var importDeclaration = createNode(SyntaxKind.ImportDeclaration, fullStart); + let importDeclaration = createNode(SyntaxKind.ImportDeclaration, fullStart); setModifiers(importDeclaration, modifiers); // ImportDeclaration: @@ -4731,7 +4731,7 @@ module ts { // ImportedDefaultBinding, NameSpaceImport // ImportedDefaultBinding, NamedImports - var importClause = createNode(SyntaxKind.ImportClause, fullStart); + let importClause = createNode(SyntaxKind.ImportClause, fullStart); if (identifier) { // ImportedDefaultBinding: // ImportedBinding @@ -4755,7 +4755,7 @@ module ts { } function parseExternalModuleReference() { - var node = createNode(SyntaxKind.ExternalModuleReference); + let node = createNode(SyntaxKind.ExternalModuleReference); parseExpected(SyntaxKind.RequireKeyword); parseExpected(SyntaxKind.OpenParenToken); node.expression = parseModuleSpecifier(); @@ -4767,7 +4767,7 @@ module ts { // 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(); + let 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 === SyntaxKind.StringLiteral) { @@ -4779,7 +4779,7 @@ module ts { function parseNamespaceImport(): NamespaceImport { // NameSpaceImport: // * as ImportedBinding - var namespaceImport = createNode(SyntaxKind.NamespaceImport); + let namespaceImport = createNode(SyntaxKind.NamespaceImport); parseExpected(SyntaxKind.AsteriskToken); parseExpected(SyntaxKind.AsKeyword); namespaceImport.name = parseIdentifier(); @@ -4787,7 +4787,7 @@ module ts { } function parseNamedImportsOrExports(kind: SyntaxKind): NamedImportsOrExports { - var node = createNode(kind); + let node = createNode(kind); // NamedImports: // { } @@ -4812,13 +4812,13 @@ module ts { } function parseImportOrExportSpecifier(kind: SyntaxKind): ImportOrExportSpecifier { - var node = createNode(kind); + let node = createNode(kind); // ImportSpecifier: // ImportedBinding // IdentifierName as ImportedBinding - var isFirstIdentifierNameNotAnIdentifier = isKeyword(token) && !isIdentifier(); - var start = scanner.getTokenPos(); - var identifierName = parseIdentifierName(); + let isFirstIdentifierNameNotAnIdentifier = isKeyword(token) && !isIdentifier(); + let start = scanner.getTokenPos(); + let identifierName = parseIdentifierName(); if (token === SyntaxKind.AsKeyword) { node.propertyName = identifierName; parseExpected(SyntaxKind.AsKeyword); @@ -4841,7 +4841,7 @@ module ts { } function parseExportDeclaration(fullStart: number, modifiers: ModifiersArray): ExportDeclaration { - var node = createNode(SyntaxKind.ExportDeclaration, fullStart); + let node = createNode(SyntaxKind.ExportDeclaration, fullStart); setModifiers(node, modifiers); if (parseOptional(SyntaxKind.AsteriskToken)) { parseExpected(SyntaxKind.FromKeyword); @@ -4858,7 +4858,7 @@ module ts { } function parseExportAssignment(fullStart: number, modifiers: ModifiersArray): ExportAssignment { - var node = createNode(SyntaxKind.ExportAssignment, fullStart); + let node = createNode(SyntaxKind.ExportAssignment, fullStart); setModifiers(node, modifiers); if (parseOptional(SyntaxKind.EqualsToken)) { node.isExportEquals = true; @@ -4947,8 +4947,8 @@ module ts { } function parseDeclaration(): ModuleElement { - var fullStart = getNodePos(); - var modifiers = parseModifiers(); + let fullStart = getNodePos(); + let modifiers = parseModifiers(); if (token === SyntaxKind.ExportKeyword) { nextToken(); if (token === SyntaxKind.DefaultKeyword || token === SyntaxKind.EqualsToken) { @@ -5002,16 +5002,16 @@ module ts { } function processReferenceComments(sourceFile: SourceFile): void { - var triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, sourceText); - var referencedFiles: FileReference[] = []; - var amdDependencies: {path: string; name: string}[] = []; - var amdModuleName: string; + let triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, sourceText); + let referencedFiles: FileReference[] = []; + let amdDependencies: {path: string; name: string}[] = []; + let amdModuleName: string; // 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(); + let kind = triviaScanner.scan(); if (kind === SyntaxKind.WhitespaceTrivia || kind === SyntaxKind.NewLineTrivia || kind === SyntaxKind.MultiLineCommentTrivia) { continue; } @@ -5019,14 +5019,14 @@ module ts { break; } - var range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos() }; + let range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos() }; - var comment = sourceText.substring(range.pos, range.end); - var referencePathMatchResult = getFileReferenceFromReferencePath(comment, range); + let comment = sourceText.substring(range.pos, range.end); + let referencePathMatchResult = getFileReferenceFromReferencePath(comment, range); if (referencePathMatchResult) { - var fileReference = referencePathMatchResult.fileReference; + let fileReference = referencePathMatchResult.fileReference; sourceFile.hasNoDefaultLib = referencePathMatchResult.isNoDefaultLib; - var diagnosticMessage = referencePathMatchResult.diagnosticMessage; + let diagnosticMessage = referencePathMatchResult.diagnosticMessage; if (fileReference) { referencedFiles.push(fileReference); } @@ -5035,8 +5035,8 @@ module ts { } } else { - var amdModuleNameRegEx = /^\/\/\/\s*