diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 5c571d8e0e3..7015c7deb21 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1,28 +1,28 @@
///
module ts {
- var nextSymbolId = 1;
- var nextNodeId = 1;
- var nextMergeId = 1;
+ let nextSymbolId = 1;
+ let nextNodeId = 1;
+ let nextMergeId = 1;
- /* @internal */ export var checkTime = 0;
+ /* @internal */ export let checkTime = 0;
export function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker {
- var Symbol = objectAllocator.getSymbolConstructor();
- var Type = objectAllocator.getTypeConstructor();
- var Signature = objectAllocator.getSignatureConstructor();
+ let Symbol = objectAllocator.getSymbolConstructor();
+ let Type = objectAllocator.getTypeConstructor();
+ let Signature = objectAllocator.getSignatureConstructor();
- var typeCount = 0;
+ let typeCount = 0;
- var emptyArray: any[] = [];
- var emptySymbols: SymbolTable = {};
+ let emptyArray: any[] = [];
+ let emptySymbols: SymbolTable = {};
- var compilerOptions = host.getCompilerOptions();
- var languageVersion = compilerOptions.target || ScriptTarget.ES3;
+ let compilerOptions = host.getCompilerOptions();
+ let languageVersion = compilerOptions.target || ScriptTarget.ES3;
- var emitResolver = createResolver();
+ let emitResolver = createResolver();
- var checker: TypeChecker = {
+ let checker: TypeChecker = {
getNodeCount: () => sum(host.getSourceFiles(), "nodeCount"),
getIdentifierCount: () => sum(host.getSourceFiles(), "identifierCount"),
getSymbolCount: () => sum(host.getSourceFiles(), "symbolCount"),
@@ -61,59 +61,59 @@ module ts {
var undefinedSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "undefined");
var argumentsSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "arguments");
- var unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
- var resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__");
+ let unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
+ let resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__");
- var anyType = createIntrinsicType(TypeFlags.Any, "any");
- var stringType = createIntrinsicType(TypeFlags.String, "string");
- var numberType = createIntrinsicType(TypeFlags.Number, "number");
- var booleanType = createIntrinsicType(TypeFlags.Boolean, "boolean");
- var esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol");
- var voidType = createIntrinsicType(TypeFlags.Void, "void");
- var undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsUndefinedOrNull, "undefined");
- var nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null");
- var unknownType = createIntrinsicType(TypeFlags.Any, "unknown");
- var resolvingType = createIntrinsicType(TypeFlags.Any, "__resolving__");
+ let anyType = createIntrinsicType(TypeFlags.Any, "any");
+ let stringType = createIntrinsicType(TypeFlags.String, "string");
+ let numberType = createIntrinsicType(TypeFlags.Number, "number");
+ let booleanType = createIntrinsicType(TypeFlags.Boolean, "boolean");
+ let esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol");
+ let voidType = createIntrinsicType(TypeFlags.Void, "void");
+ let undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsUndefinedOrNull, "undefined");
+ let nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null");
+ let unknownType = createIntrinsicType(TypeFlags.Any, "unknown");
+ let resolvingType = createIntrinsicType(TypeFlags.Any, "__resolving__");
- var emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
- var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
- var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
- var inferenceFailureType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+ let emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+ let anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+ let noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+ let inferenceFailureType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
- var anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false);
- var unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false);
+ let anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false);
+ let unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false);
- var globals: SymbolTable = {};
+ let globals: SymbolTable = {};
- var globalArraySymbol: Symbol;
- var globalESSymbolConstructorSymbol: Symbol;
+ let globalArraySymbol: Symbol;
+ let globalESSymbolConstructorSymbol: Symbol;
- var globalObjectType: ObjectType;
- var globalFunctionType: ObjectType;
- var globalArrayType: ObjectType;
- var globalStringType: ObjectType;
- var globalNumberType: ObjectType;
- var globalBooleanType: ObjectType;
- var globalRegExpType: ObjectType;
- var globalTemplateStringsArrayType: ObjectType;
- var globalESSymbolType: ObjectType;
- var globalIterableType: ObjectType;
+ let globalObjectType: ObjectType;
+ let globalFunctionType: ObjectType;
+ let globalArrayType: ObjectType;
+ let globalStringType: ObjectType;
+ let globalNumberType: ObjectType;
+ let globalBooleanType: ObjectType;
+ let globalRegExpType: ObjectType;
+ let globalTemplateStringsArrayType: ObjectType;
+ let globalESSymbolType: ObjectType;
+ let globalIterableType: ObjectType;
- var anyArrayType: Type;
+ let anyArrayType: Type;
- var tupleTypes: Map = {};
- var unionTypes: Map = {};
- var stringLiteralTypes: Map = {};
- var emitExtends = false;
+ let tupleTypes: Map = {};
+ let unionTypes: Map = {};
+ let stringLiteralTypes: Map = {};
+ let emitExtends = false;
- var mergedSymbols: Symbol[] = [];
- var symbolLinks: SymbolLinks[] = [];
- var nodeLinks: NodeLinks[] = [];
- var potentialThisCollisions: Node[] = [];
+ let mergedSymbols: Symbol[] = [];
+ let symbolLinks: SymbolLinks[] = [];
+ let nodeLinks: NodeLinks[] = [];
+ let potentialThisCollisions: Node[] = [];
- var diagnostics = createDiagnosticCollection();
+ let diagnostics = createDiagnosticCollection();
- var primitiveTypeInfo: Map<{ type: Type; flags: TypeFlags }> = {
+ let primitiveTypeInfo: Map<{ type: Type; flags: TypeFlags }> = {
"string": {
type: stringType,
flags: TypeFlags.StringLike
@@ -140,7 +140,7 @@ module ts {
}
function error(location: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): void {
- var diagnostic = location
+ let diagnostic = location
? createDiagnosticForNode(location, message, arg0, arg1, arg2)
: createCompilerDiagnostic(message, arg0, arg1, arg2);
diagnostics.add(diagnostic);
@@ -151,7 +151,7 @@ module ts {
}
function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags {
- var result: SymbolFlags = 0;
+ let result: SymbolFlags = 0;
if (flags & SymbolFlags.BlockScopedVariable) result |= SymbolFlags.BlockScopedVariableExcludes;
if (flags & SymbolFlags.FunctionScopedVariable) result |= SymbolFlags.FunctionScopedVariableExcludes;
if (flags & SymbolFlags.Property) result |= SymbolFlags.PropertyExcludes;
@@ -177,7 +177,7 @@ module ts {
}
function cloneSymbol(symbol: Symbol): Symbol {
- var result = createSymbol(symbol.flags | SymbolFlags.Merged, symbol.name);
+ let result = createSymbol(symbol.flags | SymbolFlags.Merged, symbol.name);
result.declarations = symbol.declarations.slice(0);
result.parent = symbol.parent;
if (symbol.valueDeclaration) result.valueDeclaration = symbol.valueDeclaration;
@@ -210,7 +210,7 @@ module ts {
recordMergedSymbol(target, source);
}
else {
- var message = target.flags & SymbolFlags.BlockScopedVariable || source.flags & SymbolFlags.BlockScopedVariable
+ let message = target.flags & SymbolFlags.BlockScopedVariable || source.flags & SymbolFlags.BlockScopedVariable
? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
forEach(source.declarations, node => {
error(node.name ? node.name : node, message, symbolToString(source));
@@ -222,8 +222,8 @@ module ts {
}
function cloneSymbolTable(symbolTable: SymbolTable): SymbolTable {
- var result: SymbolTable = {};
- for (var id in symbolTable) {
+ let result: SymbolTable = {};
+ for (let id in symbolTable) {
if (hasProperty(symbolTable, id)) {
result[id] = symbolTable[id];
}
@@ -232,13 +232,13 @@ module ts {
}
function mergeSymbolTable(target: SymbolTable, source: SymbolTable) {
- for (var id in source) {
+ for (let id in source) {
if (hasProperty(source, id)) {
if (!hasProperty(target, id)) {
target[id] = source[id];
}
else {
- var symbol = target[id];
+ let symbol = target[id];
if (!(symbol.flags & SymbolFlags.Merged)) {
target[id] = symbol = cloneSymbol(symbol);
}
@@ -269,14 +269,14 @@ module ts {
function getSymbol(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol {
if (meaning && hasProperty(symbols, name)) {
- var symbol = symbols[name];
+ let symbol = symbols[name];
Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
if (symbol.flags & meaning) {
return symbol;
}
if (symbol.flags & SymbolFlags.Alias) {
- var target = resolveAlias(symbol);
+ let target = resolveAlias(symbol);
// Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors
if (target === unknownSymbol || target.flags & meaning) {
return symbol;
@@ -289,8 +289,8 @@ module ts {
/** Returns true if node1 is defined before node 2**/
function isDefinedBefore(node1: Node, node2: Node): boolean {
- var file1 = getSourceFileOfNode(node1);
- var file2 = getSourceFileOfNode(node2);
+ let file1 = getSourceFileOfNode(node1);
+ let file2 = getSourceFileOfNode(node2);
if (file1 === file2) {
return node1.pos <= node2.pos;
}
@@ -299,7 +299,7 @@ module ts {
return true;
}
- var sourceFiles = host.getSourceFiles();
+ let sourceFiles = host.getSourceFiles();
return sourceFiles.indexOf(file1) <= sourceFiles.indexOf(file2);
}
@@ -307,10 +307,10 @@ module ts {
// the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
// the given name can be found.
function resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
- var result: Symbol;
- var lastLocation: Node;
- var propertyWithInvalidInitializer: Node;
- var errorLocation = location;
+ let result: Symbol;
+ let lastLocation: Node;
+ let propertyWithInvalidInitializer: Node;
+ let errorLocation = location;
loop: while (location) {
// Locals of a source file are not in scope (because they get merged into the global symbol table)
@@ -344,7 +344,7 @@ module ts {
// by the same name as a constructor parameter or local variable are inaccessible
// in initializer expressions for instance member variables.
if (location.parent.kind === SyntaxKind.ClassDeclaration && !(location.flags & NodeFlags.Static)) {
- var ctor = findConstructorDeclaration(location.parent);
+ let ctor = findConstructorDeclaration(location.parent);
if (ctor && ctor.locals) {
if (getSymbol(ctor.locals, name, meaning & SymbolFlags.Value)) {
// Remember the property node, it will be used later to report appropriate error
@@ -376,7 +376,7 @@ module ts {
// }
//
case SyntaxKind.ComputedPropertyName:
- var grandparent = location.parent.parent;
+ let grandparent = location.parent.parent;
if (grandparent.kind === SyntaxKind.ClassDeclaration || grandparent.kind === SyntaxKind.InterfaceDeclaration) {
// A reference to this grandparent's type parameters would be an error
if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & SymbolFlags.Type)) {
@@ -402,7 +402,7 @@ module ts {
result = argumentsSymbol;
break loop;
}
- var id = (location).name;
+ let id = (location).name;
if (id && name === id.text) {
result = location.symbol;
break loop;
@@ -429,7 +429,7 @@ module ts {
if (propertyWithInvalidInitializer) {
// We have a match, but the reference occurred within a property initializer and the identifier also binds
// to a local variable in the constructor where the code will be emitted.
- var propertyName = (propertyWithInvalidInitializer).name;
+ let propertyName = (propertyWithInvalidInitializer).name;
error(errorLocation, Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor,
declarationNameToString(propertyName), typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
return undefined;
@@ -444,12 +444,12 @@ module ts {
function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
Debug.assert((result.flags & SymbolFlags.BlockScopedVariable) !== 0)
// Block-scoped variables cannot be used before their definition
- var declaration = forEach(result.declarations, d => isBlockOrCatchScoped(d) ? d : undefined);
+ let declaration = forEach(result.declarations, d => isBlockOrCatchScoped(d) ? d : undefined);
Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined");
// first check if usage is lexically located after the declaration
- var isUsedBeforeDeclaration = !isDefinedBefore(declaration, errorLocation);
+ let isUsedBeforeDeclaration = !isDefinedBefore(declaration, errorLocation);
if (!isUsedBeforeDeclaration) {
// lexical check succeeded however code still can be illegal.
// - block scoped variables cannot be used in its initializers
@@ -459,8 +459,8 @@ module ts {
// for (let x of x)
// climb up to the variable declaration skipping binding patterns
- var variableDeclaration = getAncestor(declaration, SyntaxKind.VariableDeclaration);
- var container = getEnclosingBlockScopeContainer(variableDeclaration);
+ let variableDeclaration = getAncestor(declaration, SyntaxKind.VariableDeclaration);
+ let container = getEnclosingBlockScopeContainer(variableDeclaration);
if (variableDeclaration.parent.parent.kind === SyntaxKind.VariableStatement ||
variableDeclaration.parent.parent.kind === SyntaxKind.ForStatement) {
@@ -471,7 +471,7 @@ module ts {
else if (variableDeclaration.parent.parent.kind === SyntaxKind.ForOfStatement ||
variableDeclaration.parent.parent.kind === SyntaxKind.ForInStatement) {
// ForIn/ForOf case - use site should not be used in expression part
- var expression = (variableDeclaration.parent.parent).expression;
+ let expression = (variableDeclaration.parent.parent).expression;
isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container);
}
}
@@ -488,7 +488,7 @@ module ts {
if (!parent) {
return false;
}
- for (var current = initial; current && current !== stopAt && !isFunctionLike(current); current = current.parent) {
+ for (let current = initial; current && current !== stopAt && !isFunctionLike(current); current = current.parent) {
if (current === parent) {
return true;
}
@@ -518,17 +518,17 @@ module ts {
function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
if (node.moduleReference.kind === SyntaxKind.ExternalModuleReference) {
- var moduleSymbol = resolveExternalModuleName(node, getExternalModuleImportEqualsDeclarationExpression(node));
- var exportAssignmentSymbol = moduleSymbol && getResolvedExportAssignmentSymbol(moduleSymbol);
+ let moduleSymbol = resolveExternalModuleName(node, getExternalModuleImportEqualsDeclarationExpression(node));
+ let exportAssignmentSymbol = moduleSymbol && getResolvedExportAssignmentSymbol(moduleSymbol);
return exportAssignmentSymbol || moduleSymbol;
}
return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node);
}
function getTargetOfImportClause(node: ImportClause): Symbol {
- var moduleSymbol = resolveExternalModuleName(node, (node.parent).moduleSpecifier);
+ let moduleSymbol = resolveExternalModuleName(node, (node.parent).moduleSpecifier);
if (moduleSymbol) {
- var exportAssignmentSymbol = getResolvedExportAssignmentSymbol(moduleSymbol);
+ let exportAssignmentSymbol = getResolvedExportAssignmentSymbol(moduleSymbol);
if (!exportAssignmentSymbol) {
error(node.name, Diagnostics.External_module_0_has_no_default_export_or_export_assignment, symbolToString(moduleSymbol));
}
@@ -541,11 +541,11 @@ module ts {
}
function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration, specifier: ImportOrExportSpecifier): Symbol {
- var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
+ let moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
if (moduleSymbol) {
- var name = specifier.propertyName || specifier.name;
+ let name = specifier.propertyName || specifier.name;
if (name.text) {
- var symbol = getSymbol(getExportsOfSymbol(moduleSymbol), name.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+ let symbol = getSymbol(getExportsOfSymbol(moduleSymbol), name.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
if (!symbol) {
error(name, Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(moduleSymbol), declarationNameToString(name));
return;
@@ -588,11 +588,11 @@ module ts {
function resolveAlias(symbol: Symbol): Symbol {
Debug.assert((symbol.flags & SymbolFlags.Alias) !== 0, "Should only get Alias here.");
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.target) {
links.target = resolvingSymbol;
- var node = getDeclarationOfAliasSymbol(symbol);
- var target = getTargetOfImportDeclaration(node);
+ let node = getDeclarationOfAliasSymbol(symbol);
+ let target = getTargetOfImportDeclaration(node);
if (links.target === resolvingSymbol) {
links.target = target || unknownSymbol;
}
@@ -607,8 +607,8 @@ module ts {
}
function markExportAsReferenced(node: ImportEqualsDeclaration | ExportAssignment | ExportSpecifier) {
- var symbol = getSymbolOfNode(node);
- var target = resolveAlias(symbol);
+ let symbol = getSymbolOfNode(node);
+ let target = resolveAlias(symbol);
if (target && target !== unknownSymbol && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target)) {
markAliasSymbolAsReferenced(symbol);
}
@@ -618,10 +618,10 @@ module ts {
// we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of
// the alias as an expression (which recursively takes us back here if the target references another alias).
function markAliasSymbolAsReferenced(symbol: Symbol) {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.referenced) {
links.referenced = true;
- var node = getDeclarationOfAliasSymbol(symbol);
+ let node = getDeclarationOfAliasSymbol(symbol);
if (node.kind === SyntaxKind.ExportAssignment) {
// export default
checkExpressionCached((node).expression);
@@ -680,11 +680,11 @@ module ts {
}
}
else if (name.kind === SyntaxKind.QualifiedName) {
- var namespace = resolveEntityName((name).left, SymbolFlags.Namespace);
+ let namespace = resolveEntityName((name).left, SymbolFlags.Namespace);
if (!namespace || namespace === unknownSymbol || getFullWidth((name).right) === 0) {
return undefined;
}
- var right = (name).right;
+ let right = (name).right;
var symbol = getSymbol(getExportsOfSymbol(namespace), right.text, meaning);
if (!symbol) {
error(right, Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), declarationNameToString(right));
@@ -706,26 +706,26 @@ module ts {
return;
}
- var moduleReferenceLiteral = moduleReferenceExpression;
- var searchPath = getDirectoryPath(getSourceFile(location).fileName);
+ let moduleReferenceLiteral = moduleReferenceExpression;
+ let searchPath = getDirectoryPath(getSourceFile(location).fileName);
// Module names are escaped in our symbol table. However, string literal values aren't.
// Escape the name in the "require(...)" clause to ensure we find the right symbol.
- var moduleName = escapeIdentifier(moduleReferenceLiteral.text);
+ let moduleName = escapeIdentifier(moduleReferenceLiteral.text);
if (!moduleName) return;
- var isRelative = isExternalModuleNameRelative(moduleName);
+ let isRelative = isExternalModuleNameRelative(moduleName);
if (!isRelative) {
- var symbol = getSymbol(globals, '"' + moduleName + '"', SymbolFlags.ValueModule);
+ let symbol = getSymbol(globals, '"' + moduleName + '"', SymbolFlags.ValueModule);
if (symbol) {
return symbol;
}
}
while (true) {
- var fileName = normalizePath(combinePaths(searchPath, moduleName));
+ let fileName = normalizePath(combinePaths(searchPath, moduleName));
var sourceFile = host.getSourceFile(fileName + ".ts") || host.getSourceFile(fileName + ".d.ts");
if (sourceFile || isRelative) break;
- var parentPath = getDirectoryPath(searchPath);
+ let parentPath = getDirectoryPath(searchPath);
if (parentPath === searchPath) break;
searchPath = parentPath;
}
@@ -744,7 +744,7 @@ module ts {
}
function getResolvedExportAssignmentSymbol(moduleSymbol: Symbol): Symbol {
- var symbol = getExportAssignmentSymbol(moduleSymbol);
+ let symbol = getExportAssignmentSymbol(moduleSymbol);
if (symbol) {
if (symbol.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)) {
return symbol;
@@ -760,12 +760,12 @@ module ts {
}
function getExportsOfModule(moduleSymbol: Symbol): SymbolTable {
- var links = getSymbolLinks(moduleSymbol);
+ let links = getSymbolLinks(moduleSymbol);
return links.resolvedExports || (links.resolvedExports = getExportsForModule(moduleSymbol));
}
function extendExportSymbols(target: SymbolTable, source: SymbolTable) {
- for (var id in source) {
+ for (let id in source) {
if (id !== "default" && !hasProperty(target, id)) {
target[id] = source[id];
}
@@ -775,15 +775,15 @@ module ts {
function getExportsForModule(moduleSymbol: Symbol): SymbolTable {
if (compilerOptions.target < ScriptTarget.ES6) {
// A default export hides all other exports in CommonJS and AMD modules
- var defaultSymbol = getExportAssignmentSymbol(moduleSymbol);
+ let defaultSymbol = getExportAssignmentSymbol(moduleSymbol);
if (defaultSymbol) {
return {
"default": defaultSymbol
};
}
}
- var result: SymbolTable;
- var visitedSymbols: Symbol[] = [];
+ let result: SymbolTable;
+ let visitedSymbols: Symbol[] = [];
visit(moduleSymbol);
return result || moduleSymbol.exports;
@@ -799,7 +799,7 @@ module ts {
extendExportSymbols(result, symbol.exports);
}
// All export * declarations are collected in an __export symbol by the binder
- var exportStars = symbol.exports["__export"];
+ let exportStars = symbol.exports["__export"];
if (exportStars) {
forEach(exportStars.declarations, node => {
visit(resolveExternalModuleName(node, (node).moduleSpecifier));
@@ -810,7 +810,7 @@ module ts {
}
function getMergedSymbol(symbol: Symbol): Symbol {
- var merged: Symbol;
+ let merged: Symbol;
return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol;
}
@@ -849,7 +849,7 @@ module ts {
}
function findConstructorDeclaration(node: ClassDeclaration): ConstructorDeclaration {
- var members = node.members;
+ let members = node.members;
for (let member of members) {
if (member.kind === SyntaxKind.Constructor && nodeIsPresent((member).body)) {
return member;
@@ -858,19 +858,19 @@ module ts {
}
function createType(flags: TypeFlags): Type {
- var result = new Type(checker, flags);
+ let result = new Type(checker, flags);
result.id = typeCount++;
return result;
}
function createIntrinsicType(kind: TypeFlags, intrinsicName: string): IntrinsicType {
- var type = createType(kind);
+ let type = createType(kind);
type.intrinsicName = intrinsicName;
return type;
}
function createObjectType(kind: TypeFlags, symbol?: Symbol): ObjectType {
- var type = createType(kind);
+ let type = createType(kind);
type.symbol = symbol;
return type;
}
@@ -887,12 +887,12 @@ module ts {
}
function getNamedMembers(members: SymbolTable): Symbol[] {
- var result: Symbol[];
- for (var id in members) {
+ let result: Symbol[];
+ for (let id in members) {
if (hasProperty(members, id)) {
if (!isReservedMemberName(id)) {
if (!result) result = [];
- var symbol = members[id];
+ let symbol = members[id];
if (symbolIsValue(symbol)) {
result.push(symbol);
}
@@ -918,8 +918,8 @@ module ts {
}
function forEachSymbolTableInScope(enclosingDeclaration: Node, callback: (symbolTable: SymbolTable) => T): T {
- var result: T;
- for (var location = enclosingDeclaration; location; location = location.parent) {
+ let result: T;
+ for (let location = enclosingDeclaration; location; location = location.parent) {
// Locals of a source file are not in scope (because they get merged into the global symbol table)
if (location.locals && !isGlobalSourceFile(location)) {
if (result = callback(location.locals)) {
@@ -962,7 +962,7 @@ module ts {
}
// If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too
- var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing);
+ let accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing);
return !!accessibleParent;
}
@@ -988,14 +988,14 @@ module ts {
// Is this external alias, then use it to name
ts.forEach(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) {
- var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
+ let resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
if (isAccessible(symbolFromSymbolTable, resolveAlias(symbolFromSymbolTable))) {
return [symbolFromSymbolTable];
}
// Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
// but only if the symbolFromSymbolTable can be qualified
- var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
+ let accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
}
@@ -1010,7 +1010,7 @@ module ts {
}
function needsQualification(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) {
- var qualify = false;
+ let qualify = false;
forEachSymbolTableInScope(enclosingDeclaration, symbolTable => {
// If symbol of this name is not available in the symbol table we are ok
if (!hasProperty(symbolTable, symbol.name)) {
@@ -1018,7 +1018,7 @@ module ts {
return false;
}
// If the symbol with this name is present it should refer to the symbol
- var symbolFromSymbolTable = symbolTable[symbol.name];
+ let symbolFromSymbolTable = symbolTable[symbol.name];
if (symbolFromSymbolTable === symbol) {
// No need to qualify
return true;
@@ -1040,13 +1040,13 @@ module ts {
function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult {
if (symbol && enclosingDeclaration && !(symbol.flags & SymbolFlags.TypeParameter)) {
- var initialSymbol = symbol;
- var meaningToLook = meaning;
+ let initialSymbol = symbol;
+ let meaningToLook = meaning;
while (symbol) {
// Symbol is accessible if it by itself is accessible
- var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
+ let accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
if (accessibleSymbolChain) {
- var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
+ let hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
if (!hasAccessibleDeclarations) {
return {
accessibility: SymbolAccessibility.NotAccessible,
@@ -1064,7 +1064,7 @@ module ts {
// export class c {
// }
// }
- // var x: typeof m.c
+ // let x: typeof m.c
// In the above example when we start with checking if typeof m.c symbol is accessible,
// we are going to see if c can be accessed in scope directly.
// But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible
@@ -1075,9 +1075,9 @@ module ts {
// This could be a symbol that is not exported in the external module
// or it could be a symbol from different external module that is not aliased and hence cannot be named
- var symbolExternalModule = forEach(initialSymbol.declarations, getExternalModuleContainer);
+ let symbolExternalModule = forEach(initialSymbol.declarations, getExternalModuleContainer);
if (symbolExternalModule) {
- var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
+ let enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
if (symbolExternalModule !== enclosingExternalModule) {
// name from different external module that is not visible
return {
@@ -1112,7 +1112,7 @@ module ts {
}
function hasVisibleDeclarations(symbol: Symbol): SymbolVisibilityResult {
- var aliasesToMakeVisible: ImportEqualsDeclaration[];
+ let aliasesToMakeVisible: ImportEqualsDeclaration[];
if (forEach(symbol.declarations, declaration => !getIsDeclarationVisible(declaration))) {
return undefined;
}
@@ -1147,7 +1147,7 @@ module ts {
function isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult {
// get symbol of the first identifier of the entityName
- var meaning: SymbolFlags;
+ let meaning: SymbolFlags;
if (entityName.parent.kind === SyntaxKind.TypeQuery) {
// Typeof value
meaning = SymbolFlags.Value | SymbolFlags.ExportValue;
@@ -1163,8 +1163,8 @@ module ts {
meaning = SymbolFlags.Type;
}
- var firstIdentifier = getFirstIdentifier(entityName);
- var symbol = resolveName(enclosingDeclaration, (firstIdentifier).text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
+ let firstIdentifier = getFirstIdentifier(entityName);
+ let symbol = resolveName(enclosingDeclaration, (firstIdentifier).text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
// Verify if the symbol is accessible
return (symbol && hasVisibleDeclarations(symbol)) || {
@@ -1187,23 +1187,23 @@ module ts {
}
function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string {
- var writer = getSingleLineStringWriter();
+ let writer = getSingleLineStringWriter();
getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning);
- var result = writer.string();
+ let result = writer.string();
releaseStringWriter(writer);
return result;
}
function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
- var writer = getSingleLineStringWriter();
+ let writer = getSingleLineStringWriter();
getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
- var result = writer.string();
+ let result = writer.string();
releaseStringWriter(writer);
- var maxLength = compilerOptions.noErrorTruncation || flags & TypeFormatFlags.NoTruncation ? undefined : 100;
+ let maxLength = compilerOptions.noErrorTruncation || flags & TypeFormatFlags.NoTruncation ? undefined : 100;
if (maxLength && result.length >= maxLength) {
result = result.substr(0, maxLength - "...".length) + "...";
}
@@ -1213,7 +1213,7 @@ module ts {
function getTypeAliasForTypeLiteral(type: Type): Symbol {
if (type.symbol && type.symbol.flags & SymbolFlags.TypeLiteral) {
- var node = type.symbol.declarations[0].parent;
+ let node = type.symbol.declarations[0].parent;
while (node.kind === SyntaxKind.ParenthesizedType) {
node = node.parent;
}
@@ -1225,7 +1225,7 @@ module ts {
}
// This is for caching the result of getSymbolDisplayBuilder. Do not access directly.
- var _displayBuilder: SymbolDisplayBuilder;
+ let _displayBuilder: SymbolDisplayBuilder;
function getSymbolDisplayBuilder(): SymbolDisplayBuilder {
/**
* Writes only the name of the symbol out to the writer. Uses the original source text
@@ -1233,7 +1233,7 @@ module ts {
*/
function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter): void {
if (symbol.declarations && symbol.declarations.length > 0) {
- var declaration = symbol.declarations[0];
+ let declaration = symbol.declarations[0];
if (declaration.name) {
writer.writeSymbol(declarationNameToString(declaration.name), symbol);
return;
@@ -1248,7 +1248,7 @@ module ts {
* Meaning needs to be specified if the enclosing declaration is given
*/
function buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags, typeFlags?: TypeFormatFlags): void {
- var parentSymbol: Symbol;
+ let parentSymbol: Symbol;
function appendParentTypeArgumentsAndSymbolName(symbol: Symbol): void {
if (parentSymbol) {
// Write type arguments of instantiated class/interface here
@@ -1277,7 +1277,7 @@ module ts {
writer.trackSymbol(symbol, enclosingDeclaration, meaning);
function walkSymbol(symbol: Symbol, meaning: SymbolFlags): void {
if (symbol) {
- var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
+ let accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
if (!accessibleSymbolChain ||
needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
@@ -1312,8 +1312,8 @@ module ts {
// Get qualified name if the symbol is not a type parameter
// and there is an enclosing declaration or we specifically
// asked for it
- var isTypeParameter = symbol.flags & SymbolFlags.TypeParameter;
- var typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags;
+ let isTypeParameter = symbol.flags & SymbolFlags.TypeParameter;
+ let typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags;
if (!isTypeParameter && (enclosingDeclaration || typeFormatFlag)) {
walkSymbol(symbol, meaning);
return;
@@ -1323,7 +1323,7 @@ module ts {
}
function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, typeStack?: Type[]) {
- var globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
+ let globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
return writeType(type, globalFlags);
function writeType(type: Type, flags: TypeFormatFlags) {
@@ -1364,7 +1364,7 @@ module ts {
}
function writeTypeList(types: Type[], union: boolean) {
- for (var i = 0; i < types.length; i++) {
+ for (let i = 0; i < types.length; i++) {
if (i > 0) {
if (union) {
writeSpace(writer);
@@ -1417,7 +1417,7 @@ module ts {
}
else if (typeStack && contains(typeStack, type)) {
// If type is an anonymous type literal in a type alias declaration, use type alias name
- var typeAlias = getTypeAliasForTypeLiteral(type);
+ let typeAlias = getTypeAliasForTypeLiteral(type);
if (typeAlias) {
// The specified symbol flags need to be reinterpreted as type flags
buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
@@ -1438,9 +1438,9 @@ module ts {
function shouldWriteTypeOfFunctionSymbol() {
if (type.symbol) {
- var isStaticMethodSymbol = !!(type.symbol.flags & SymbolFlags.Method && // typeof static method
+ let isStaticMethodSymbol = !!(type.symbol.flags & SymbolFlags.Method && // typeof static method
ts.forEach(type.symbol.declarations, declaration => declaration.flags & NodeFlags.Static));
- var isNonLocalFunctionSymbol = !!(type.symbol.flags & SymbolFlags.Function) &&
+ let isNonLocalFunctionSymbol = !!(type.symbol.flags & SymbolFlags.Function) &&
(type.symbol.parent || // is exported function symbol
ts.forEach(type.symbol.declarations, declaration =>
declaration.parent.kind === SyntaxKind.SourceFile || declaration.parent.kind === SyntaxKind.ModuleBlock));
@@ -1461,7 +1461,7 @@ module ts {
}
function getIndexerParameterName(type: ObjectType, indexKind: IndexKind, fallbackName: string): string {
- var declaration = getIndexDeclarationOfSymbol(type.symbol, indexKind);
+ let declaration = getIndexDeclarationOfSymbol(type.symbol, indexKind);
if (!declaration) {
// declaration might not be found if indexer was added from the contextual type.
// in this case use fallback name
@@ -1472,7 +1472,7 @@ module ts {
}
function writeLiteralType(type: ObjectType, flags: TypeFormatFlags) {
- var resolved = resolveObjectOrUnionTypeMembers(type);
+ let resolved = resolveObjectOrUnionTypeMembers(type);
if (!resolved.properties.length && !resolved.stringIndexType && !resolved.numberIndexType) {
if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
writePunctuation(writer, SyntaxKind.OpenBraceToken);
@@ -1549,9 +1549,9 @@ module ts {
writer.writeLine();
}
for (let p of resolved.properties) {
- var t = getTypeOfSymbol(p);
+ let t = getTypeOfSymbol(p);
if (p.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfObjectType(t).length) {
- var signatures = getSignaturesOfType(t, SignatureKind.Call);
+ let signatures = getSignaturesOfType(t, SignatureKind.Call);
for (let signature of signatures) {
buildSymbolDisplay(p, writer);
if (p.flags & SymbolFlags.Optional) {
@@ -1580,7 +1580,7 @@ module ts {
}
function buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) {
- var targetSymbol = getTargetSymbol(symbol);
+ let targetSymbol = getTargetSymbol(symbol);
if (targetSymbol.flags & SymbolFlags.Class || targetSymbol.flags & SymbolFlags.Interface) {
buildDisplayForTypeParametersAndDelimiters(getTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags);
}
@@ -1588,7 +1588,7 @@ module ts {
function buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
appendSymbolNameOnly(tp.symbol, writer);
- var constraint = getConstraintOfTypeParameter(tp);
+ let constraint = getConstraintOfTypeParameter(tp);
if (constraint) {
writeSpace(writer);
writeKeyword(writer, SyntaxKind.ExtendsKeyword);
@@ -1614,7 +1614,7 @@ module ts {
function buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
if (typeParameters && typeParameters.length) {
writePunctuation(writer, SyntaxKind.LessThanToken);
- for (var i = 0; i < typeParameters.length; i++) {
+ for (let i = 0; i < typeParameters.length; i++) {
if (i > 0) {
writePunctuation(writer, SyntaxKind.CommaToken);
writeSpace(writer);
@@ -1628,7 +1628,7 @@ module ts {
function buildDisplayForTypeArgumentsAndDelimiters(typeParameters: TypeParameter[], mapper: TypeMapper, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
if (typeParameters && typeParameters.length) {
writePunctuation(writer, SyntaxKind.LessThanToken);
- for (var i = 0; i < typeParameters.length; i++) {
+ for (let i = 0; i < typeParameters.length; i++) {
if (i > 0) {
writePunctuation(writer, SyntaxKind.CommaToken);
writeSpace(writer);
@@ -1641,7 +1641,7 @@ module ts {
function buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
writePunctuation(writer, SyntaxKind.OpenParenToken);
- for (var i = 0; i < parameters.length; i++) {
+ for (let i = 0; i < parameters.length; i++) {
if (i > 0) {
writePunctuation(writer, SyntaxKind.CommaToken);
writeSpace(writer);
@@ -1710,13 +1710,13 @@ module ts {
function isUsedInExportAssignment(node: Node) {
// Get source File and see if it is external module and has export assigned symbol
- var externalModule = getContainingExternalModule(node);
+ let externalModule = getContainingExternalModule(node);
if (externalModule) {
// This is export assigned symbol node
- var externalModuleSymbol = getSymbolOfNode(externalModule);
+ let externalModuleSymbol = getSymbolOfNode(externalModule);
var exportAssignmentSymbol = getExportAssignmentSymbol(externalModuleSymbol);
var resolvedExportSymbol: Symbol;
- var symbolOfNode = getSymbolOfNode(node);
+ let symbolOfNode = getSymbolOfNode(node);
if (isSymbolUsedInExportAssignment(symbolOfNode)) {
return true;
}
@@ -1764,7 +1764,7 @@ module ts {
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.EnumDeclaration:
case SyntaxKind.ImportEqualsDeclaration:
- var parent = getDeclarationContainer(node);
+ let parent = getDeclarationContainer(node);
// If the node is not exported or it is not ambient module element (except import declaration)
if (!(getCombinedNodeFlags(node) & NodeFlags.Export) &&
!(node.kind !== SyntaxKind.ImportEqualsDeclaration && parent.kind !== SyntaxKind.SourceFile && isInAmbientContext(parent))) {
@@ -1813,7 +1813,7 @@ module ts {
}
if (node) {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (links.isVisible === undefined) {
links.isVisible = !!determineIfDeclarationIsVisible();
}
@@ -1841,20 +1841,20 @@ module ts {
// Every class automatically contains a static property member named 'prototype',
// the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter.
// It is an error to explicitly declare a static property member with the name 'prototype'.
- var classType = getDeclaredTypeOfSymbol(prototype.parent);
+ let classType = getDeclaredTypeOfSymbol(prototype.parent);
return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, _ => anyType)) : classType;
}
// Return the type of the given property in the given type, or undefined if no such property exists
function getTypeOfPropertyOfType(type: Type, name: string): Type {
- var prop = getPropertyOfType(type, name);
+ let prop = getPropertyOfType(type, name);
return prop ? getTypeOfSymbol(prop) : undefined;
}
// Return the inferred type for a binding element
function getTypeForBindingElement(declaration: BindingElement): Type {
- var pattern = declaration.parent;
- var parentType = getTypeForVariableLikeDeclaration(pattern.parent);
+ let pattern = declaration.parent;
+ let parentType = getTypeForVariableLikeDeclaration(pattern.parent);
// If parent has the unknown (error) type, then so does this binding element
if (parentType === unknownType) {
return unknownType;
@@ -1870,7 +1870,7 @@ module ts {
}
if (pattern.kind === SyntaxKind.ObjectBindingPattern) {
// Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form)
- var name = declaration.propertyName || declaration.name;
+ let name = declaration.propertyName || declaration.name;
// Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature,
// or otherwise the type of the string index signature.
var type = getTypeOfPropertyOfType(parentType, name.text) ||
@@ -1889,7 +1889,7 @@ module ts {
}
if (!declaration.dotDotDotToken) {
// Use specific property type when parent is a tuple or numeric index type when parent is an array
- var propName = "" + indexOf(pattern.elements, declaration);
+ let propName = "" + indexOf(pattern.elements, declaration);
var type = isTupleLikeType(parentType) ? getTypeOfPropertyOfType(parentType, propName) : getIndexTypeOfType(parentType, IndexKind.Number);
if (!type) {
if (isTupleType(parentType)) {
@@ -1930,16 +1930,16 @@ module ts {
return getTypeFromTypeNode(declaration.type);
}
if (declaration.kind === SyntaxKind.Parameter) {
- var func = declaration.parent;
+ let func = declaration.parent;
// For a parameter of a set accessor, use the type of the get accessor if one is present
if (func.kind === SyntaxKind.SetAccessor && !hasDynamicName(func)) {
- var getter = getDeclarationOfKind(declaration.parent.symbol, SyntaxKind.GetAccessor);
+ let getter = getDeclarationOfKind(declaration.parent.symbol, SyntaxKind.GetAccessor);
if (getter) {
return getReturnTypeOfSignature(getSignatureFromDeclaration(getter));
}
}
// Use contextual parameter type if one is available
- var type = getContextuallyTypedParameterType(declaration);
+ let type = getContextuallyTypedParameterType(declaration);
if (type) {
return type;
}
@@ -1971,11 +1971,11 @@ module ts {
// Return the type implied by an object binding pattern
function getTypeFromObjectBindingPattern(pattern: BindingPattern): Type {
- var members: SymbolTable = {};
+ let members: SymbolTable = {};
forEach(pattern.elements, e => {
- var flags = SymbolFlags.Property | SymbolFlags.Transient | (e.initializer ? SymbolFlags.Optional : 0);
- var name = e.propertyName || e.name;
- var symbol = createSymbol(flags, name.text);
+ let flags = SymbolFlags.Property | SymbolFlags.Transient | (e.initializer ? SymbolFlags.Optional : 0);
+ let name = e.propertyName || e.name;
+ let symbol = createSymbol(flags, name.text);
symbol.type = getTypeFromBindingElement(e);
members[symbol.name] = symbol;
});
@@ -1984,8 +1984,8 @@ module ts {
// Return the type implied by an array binding pattern
function getTypeFromArrayBindingPattern(pattern: BindingPattern): Type {
- var hasSpreadElement: boolean = false;
- var elementTypes: Type[] = [];
+ let hasSpreadElement: boolean = false;
+ let elementTypes: Type[] = [];
forEach(pattern.elements, e => {
elementTypes.push(e.kind === SyntaxKind.OmittedExpression || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e));
if (e.dotDotDotToken) {
@@ -2018,7 +2018,7 @@ module ts {
// binding pattern [x, s = ""]. Because the contextual type is a tuple type, the resulting type of [1, "one"] is the
// tuple type [number, string]. Thus, the type inferred for 'x' is number and the type inferred for 's' is string.
function getWidenedTypeForVariableLikeDeclaration(declaration: VariableLikeDeclaration, reportErrors?: boolean): Type {
- var type = getTypeForVariableLikeDeclaration(declaration);
+ let type = getTypeForVariableLikeDeclaration(declaration);
if (type) {
if (reportErrors) {
reportErrorsFromWidening(declaration, type);
@@ -2037,7 +2037,7 @@ module ts {
type = declaration.dotDotDotToken ? anyArrayType : anyType;
// Report implicit any errors unless this is a private property within an ambient declaration
if (reportErrors && compilerOptions.noImplicitAny) {
- var root = getRootDeclaration(declaration);
+ let root = getRootDeclaration(declaration);
if (!isPrivateWithinAmbient(root) && !(root.kind === SyntaxKind.Parameter && isPrivateWithinAmbient(root.parent))) {
reportImplicitAnyError(declaration, type);
}
@@ -2046,14 +2046,14 @@ module ts {
}
function getTypeOfVariableOrParameterOrProperty(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.type) {
// Handle prototype property
if (symbol.flags & SymbolFlags.Prototype) {
return links.type = getTypeOfPrototypeProperty(symbol);
}
// Handle catch clause variables
- var declaration = symbol.valueDeclaration;
+ let declaration = symbol.valueDeclaration;
if (declaration.parent.kind === SyntaxKind.CatchClause) {
return links.type = anyType;
}
@@ -2063,7 +2063,7 @@ module ts {
}
// Handle variable, parameter or property
links.type = resolvingType;
- var type = getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true);
+ let type = getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true);
if (links.type === resolvingType) {
links.type = type;
}
@@ -2071,7 +2071,7 @@ module ts {
else if (links.type === resolvingType) {
links.type = anyType;
if (compilerOptions.noImplicitAny) {
- var diagnostic = (symbol.valueDeclaration).type ?
+ let diagnostic = (symbol.valueDeclaration).type ?
Diagnostics._0_implicitly_has_type_any_because_it_is_referenced_directly_or_indirectly_in_its_own_type_annotation :
Diagnostics._0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer;
error(symbol.valueDeclaration, diagnostic, symbolToString(symbol));
@@ -2090,7 +2090,7 @@ module ts {
return accessor.type && getTypeFromTypeNode(accessor.type);
}
else {
- var setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor);
+ let setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor);
return setterTypeAnnotation && getTypeFromTypeNode(setterTypeAnnotation);
}
}
@@ -2098,7 +2098,7 @@ module ts {
}
function getTypeOfAccessors(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
checkAndStoreTypeOfAccessors(symbol, links);
return links.type;
}
@@ -2107,19 +2107,19 @@ module ts {
links = links || getSymbolLinks(symbol);
if (!links.type) {
links.type = resolvingType;
- var getter = getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
- var setter = getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
+ let getter = getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
+ let setter = getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
- var type: Type;
+ let type: Type;
// First try to see if the user specified a return type on the get-accessor.
- var getterReturnType = getAnnotatedAccessorType(getter);
+ let getterReturnType = getAnnotatedAccessorType(getter);
if (getterReturnType) {
type = getterReturnType;
}
else {
// If the user didn't specify a return type, try to use the set-accessor's parameter type.
- var setterParameterType = getAnnotatedAccessorType(setter);
+ let setterParameterType = getAnnotatedAccessorType(setter);
if (setterParameterType) {
type = setterParameterType;
}
@@ -2146,14 +2146,14 @@ module ts {
else if (links.type === resolvingType) {
links.type = anyType;
if (compilerOptions.noImplicitAny) {
- var getter = getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
+ let getter = getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
}
}
}
function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.type) {
links.type = createObjectType(TypeFlags.Anonymous, symbol);
}
@@ -2161,7 +2161,7 @@ module ts {
}
function getTypeOfEnumMember(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.type) {
links.type = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
}
@@ -2169,7 +2169,7 @@ module ts {
}
function getTypeOfAlias(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.type) {
links.type = getTypeOfSymbol(resolveAlias(symbol));
}
@@ -2177,7 +2177,7 @@ module ts {
}
function getTypeOfInstantiatedSymbol(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.type) {
links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
}
@@ -2213,7 +2213,7 @@ module ts {
function hasBaseType(type: InterfaceType, checkBase: InterfaceType) {
return check(type);
function check(type: InterfaceType): boolean {
- var target = getTargetType(type);
+ let target = getTargetType(type);
return target === checkBase || forEach(target.baseTypes, check);
}
}
@@ -2222,13 +2222,13 @@ module ts {
// the same, but even if they're not we still need the complete list to ensure instantiations supply type arguments
// for all type parameters.
function getTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] {
- var result: TypeParameter[];
+ let result: TypeParameter[];
forEach(symbol.declarations, node => {
if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration) {
- var declaration = node;
+ let declaration = node;
if (declaration.typeParameters && declaration.typeParameters.length) {
forEach(declaration.typeParameters, node => {
- var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
+ let tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
if (!result) {
result = [tp];
}
@@ -2243,10 +2243,10 @@ module ts {
}
function getDeclaredTypeOfClass(symbol: Symbol): InterfaceType {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.declaredType) {
- var type = links.declaredType = createObjectType(TypeFlags.Class, symbol);
- var typeParameters = getTypeParametersOfClassOrInterface(symbol);
+ let type = links.declaredType = createObjectType(TypeFlags.Class, symbol);
+ let typeParameters = getTypeParametersOfClassOrInterface(symbol);
if (typeParameters) {
type.flags |= TypeFlags.Reference;
type.typeParameters = typeParameters;
@@ -2256,10 +2256,10 @@ module ts {
(type).typeArguments = type.typeParameters;
}
type.baseTypes = [];
- var declaration = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);
- var baseTypeNode = getClassBaseTypeNode(declaration);
+ let declaration = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);
+ let baseTypeNode = getClassBaseTypeNode(declaration);
if (baseTypeNode) {
- var baseType = getTypeFromTypeReferenceNode(baseTypeNode);
+ let baseType = getTypeFromTypeReferenceNode(baseTypeNode);
if (baseType !== unknownType) {
if (getTargetType(baseType).flags & TypeFlags.Class) {
if (type !== baseType && !hasBaseType(baseType, type)) {
@@ -2284,10 +2284,10 @@ module ts {
}
function getDeclaredTypeOfInterface(symbol: Symbol): InterfaceType {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.declaredType) {
- var type = links.declaredType = createObjectType(TypeFlags.Interface, symbol);
- var typeParameters = getTypeParametersOfClassOrInterface(symbol);
+ let type = links.declaredType = createObjectType(TypeFlags.Interface, symbol);
+ let typeParameters = getTypeParametersOfClassOrInterface(symbol);
if (typeParameters) {
type.flags |= TypeFlags.Reference;
type.typeParameters = typeParameters;
@@ -2300,7 +2300,7 @@ module ts {
forEach(symbol.declarations, declaration => {
if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(declaration)) {
forEach(getInterfaceBaseTypeNodes(declaration), node => {
- var baseType = getTypeFromTypeReferenceNode(node);
+ let baseType = getTypeFromTypeReferenceNode(node);
if (baseType !== unknownType) {
if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
if (type !== baseType && !hasBaseType(baseType, type)) {
@@ -2327,27 +2327,27 @@ module ts {
}
function getDeclaredTypeOfTypeAlias(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.declaredType) {
links.declaredType = resolvingType;
- var declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
- var type = getTypeFromTypeNode(declaration.type);
+ let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
+ let type = getTypeFromTypeNode(declaration.type);
if (links.declaredType === resolvingType) {
links.declaredType = type;
}
}
else if (links.declaredType === resolvingType) {
links.declaredType = unknownType;
- var declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
+ let declaration = getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
error(declaration.name, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
}
return links.declaredType;
}
function getDeclaredTypeOfEnum(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.declaredType) {
- var type = createType(TypeFlags.Enum);
+ let type = createType(TypeFlags.Enum);
type.symbol = symbol;
links.declaredType = type;
}
@@ -2355,9 +2355,9 @@ module ts {
}
function getDeclaredTypeOfTypeParameter(symbol: Symbol): TypeParameter {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.declaredType) {
- var type = createType(TypeFlags.TypeParameter);
+ let type = createType(TypeFlags.TypeParameter);
type.symbol = symbol;
if (!(getDeclarationOfKind(symbol, SyntaxKind.TypeParameter)).constraint) {
type.constraint = noConstraintType;
@@ -2368,7 +2368,7 @@ module ts {
}
function getDeclaredTypeOfAlias(symbol: Symbol): Type {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
if (!links.declaredType) {
links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol));
}
@@ -2399,7 +2399,7 @@ module ts {
}
function createSymbolTable(symbols: Symbol[]): SymbolTable {
- var result: SymbolTable = {};
+ let result: SymbolTable = {};
for (let symbol of symbols) {
result[symbol.name] = symbol;
}
@@ -2407,7 +2407,7 @@ module ts {
}
function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper): SymbolTable {
- var result: SymbolTable = {};
+ let result: SymbolTable = {};
for (let symbol of symbols) {
result[symbol.name] = instantiateSymbol(symbol, mapper);
}
@@ -2431,11 +2431,11 @@ module ts {
}
function resolveClassOrInterfaceMembers(type: InterfaceType): void {
- var members = type.symbol.members;
- var callSignatures = type.declaredCallSignatures;
- var constructSignatures = type.declaredConstructSignatures;
- var stringIndexType = type.declaredStringIndexType;
- var numberIndexType = type.declaredNumberIndexType;
+ let members = type.symbol.members;
+ let callSignatures = type.declaredCallSignatures;
+ let constructSignatures = type.declaredConstructSignatures;
+ let stringIndexType = type.declaredStringIndexType;
+ let numberIndexType = type.declaredNumberIndexType;
if (type.baseTypes.length) {
members = createSymbolTable(type.declaredProperties);
forEach(type.baseTypes, baseType => {
@@ -2450,15 +2450,15 @@ module ts {
}
function resolveTypeReferenceMembers(type: TypeReference): void {
- var target = type.target;
- var mapper = createTypeMapper(target.typeParameters, type.typeArguments);
- var members = createInstantiatedSymbolTable(target.declaredProperties, mapper);
- var callSignatures = instantiateList(target.declaredCallSignatures, mapper, instantiateSignature);
- var constructSignatures = instantiateList(target.declaredConstructSignatures, mapper, instantiateSignature);
- var stringIndexType = target.declaredStringIndexType ? instantiateType(target.declaredStringIndexType, mapper) : undefined;
- var numberIndexType = target.declaredNumberIndexType ? instantiateType(target.declaredNumberIndexType, mapper) : undefined;
+ let target = type.target;
+ let mapper = createTypeMapper(target.typeParameters, type.typeArguments);
+ let members = createInstantiatedSymbolTable(target.declaredProperties, mapper);
+ let callSignatures = instantiateList(target.declaredCallSignatures, mapper, instantiateSignature);
+ let constructSignatures = instantiateList(target.declaredConstructSignatures, mapper, instantiateSignature);
+ let stringIndexType = target.declaredStringIndexType ? instantiateType(target.declaredStringIndexType, mapper) : undefined;
+ let numberIndexType = target.declaredNumberIndexType ? instantiateType(target.declaredNumberIndexType, mapper) : undefined;
forEach(target.baseTypes, baseType => {
- var instantiatedBaseType = instantiateType(baseType, mapper);
+ let instantiatedBaseType = instantiateType(baseType, mapper);
addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Call));
constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Construct));
@@ -2470,7 +2470,7 @@ module ts {
function createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[], parameters: Symbol[],
resolvedReturnType: Type, minArgumentCount: number, hasRestParameter: boolean, hasStringLiterals: boolean): Signature {
- var sig = new Signature(checker);
+ let sig = new Signature(checker);
sig.declaration = declaration;
sig.typeParameters = typeParameters;
sig.parameters = parameters;
@@ -2488,10 +2488,10 @@ module ts {
function getDefaultConstructSignatures(classType: InterfaceType): Signature[] {
if (classType.baseTypes.length) {
- var baseType = classType.baseTypes[0];
- var baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), SignatureKind.Construct);
+ let baseType = classType.baseTypes[0];
+ let baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), SignatureKind.Construct);
return map(baseSignatures, baseSignature => {
- var signature = baseType.flags & TypeFlags.Reference ?
+ let signature = baseType.flags & TypeFlags.Reference ?
getSignatureInstantiation(baseSignature, (baseType).typeArguments) : cloneSignature(baseSignature);
signature.typeParameters = classType.typeParameters;
signature.resolvedReturnType = classType;
@@ -2502,9 +2502,9 @@ module ts {
}
function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
- var members: SymbolTable = {};
- for (var i = 0; i < memberTypes.length; i++) {
- var symbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
+ let members: SymbolTable = {};
+ for (let i = 0; i < memberTypes.length; i++) {
+ let symbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
symbol.type = memberTypes[i];
members[i] = symbol;
}
@@ -2512,8 +2512,8 @@ module ts {
}
function resolveTupleTypeMembers(type: TupleType) {
- var arrayType = resolveObjectOrUnionTypeMembers(createArrayType(getUnionType(type.elementTypes)));
- var members = createTupleTypeMemberSymbols(type.elementTypes);
+ let arrayType = resolveObjectOrUnionTypeMembers(createArrayType(getUnionType(type.elementTypes)));
+ let members = createTupleTypeMemberSymbols(type.elementTypes);
addInheritedMembers(members, arrayType.properties);
setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
}
@@ -2522,7 +2522,7 @@ module ts {
if (s.length !== t.length) {
return false;
}
- for (var i = 0; i < s.length; i++) {
+ for (let i = 0; i < s.length; i++) {
if (!compareSignatures(s[i], t[i], /*compareReturnTypes*/ false, compareTypes)) {
return false;
}
@@ -2534,21 +2534,21 @@ module ts {
// and if none of the signatures are generic, return a list of signatures that has substitutes a union of the
// return types of the corresponding signatures in each resulting signature.
function getUnionSignatures(types: Type[], kind: SignatureKind): Signature[] {
- var signatureLists = map(types, t => getSignaturesOfType(t, kind));
- var signatures = signatureLists[0];
+ let signatureLists = map(types, t => getSignaturesOfType(t, kind));
+ let signatures = signatureLists[0];
for (let signature of signatures) {
if (signature.typeParameters) {
return emptyArray;
}
}
- for (var i = 1; i < signatureLists.length; i++) {
+ for (let i = 1; i < signatureLists.length; i++) {
if (!signatureListsIdentical(signatures, signatureLists[i])) {
return emptyArray;
}
}
- var result = map(signatures, cloneSignature);
+ let result = map(signatures, cloneSignature);
for (var i = 0; i < result.length; i++) {
- var s = result[i];
+ let s = result[i];
// Clear resolved return type we possibly got from cloneSignature
s.resolvedReturnType = undefined;
s.unionSignatures = map(signatureLists, signatures => signatures[i]);
@@ -2557,9 +2557,9 @@ module ts {
}
function getUnionIndexType(types: Type[], kind: IndexKind): Type {
- var indexTypes: Type[] = [];
+ let indexTypes: Type[] = [];
for (let type of types) {
- var indexType = getIndexTypeOfType(type, kind);
+ let indexType = getIndexTypeOfType(type, kind);
if (!indexType) {
return undefined;
}
@@ -2571,15 +2571,15 @@ module ts {
function resolveUnionTypeMembers(type: UnionType) {
// The members and properties collections are empty for union types. To get all properties of a union
// type use getPropertiesOfType (only the language service uses this).
- var callSignatures = getUnionSignatures(type.types, SignatureKind.Call);
- var constructSignatures = getUnionSignatures(type.types, SignatureKind.Construct);
- var stringIndexType = getUnionIndexType(type.types, IndexKind.String);
- var numberIndexType = getUnionIndexType(type.types, IndexKind.Number);
+ let callSignatures = getUnionSignatures(type.types, SignatureKind.Call);
+ let constructSignatures = getUnionSignatures(type.types, SignatureKind.Construct);
+ let stringIndexType = getUnionIndexType(type.types, IndexKind.String);
+ let numberIndexType = getUnionIndexType(type.types, IndexKind.Number);
setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType);
}
function resolveAnonymousTypeMembers(type: ObjectType) {
- var symbol = type.symbol;
+ let symbol = type.symbol;
if (symbol.flags & SymbolFlags.TypeLiteral) {
var members = symbol.members;
var callSignatures = getSignaturesOfSymbol(members["__call"]);
@@ -2599,7 +2599,7 @@ module ts {
callSignatures = getSignaturesOfSymbol(symbol);
}
if (symbol.flags & SymbolFlags.Class) {
- var classType = getDeclaredTypeOfClass(symbol);
+ let classType = getDeclaredTypeOfClass(symbol);
constructSignatures = getSignaturesOfSymbol(symbol.members["__constructor"]);
if (!constructSignatures.length) {
constructSignatures = getDefaultConstructSignatures(classType);
@@ -2648,9 +2648,9 @@ module ts {
// the symbol for that property. Otherwise return undefined.
function getPropertyOfObjectType(type: Type, name: string): Symbol {
if (type.flags & TypeFlags.ObjectType) {
- var resolved = resolveObjectOrUnionTypeMembers(type);
+ let resolved = resolveObjectOrUnionTypeMembers(type);
if (hasProperty(resolved.members, name)) {
- var symbol = resolved.members[name];
+ let symbol = resolved.members[name];
if (symbolIsValue(symbol)) {
return symbol;
}
@@ -2659,9 +2659,9 @@ module ts {
}
function getPropertiesOfUnionType(type: UnionType): Symbol[] {
- var result: Symbol[] = [];
+ let result: Symbol[] = [];
forEach(getPropertiesOfType(type.types[0]), prop => {
- var unionProp = getPropertyOfUnionType(type, prop.name);
+ let unionProp = getPropertyOfUnionType(type, prop.name);
if (unionProp) {
result.push(unionProp);
}
@@ -2704,12 +2704,12 @@ module ts {
}
function createUnionProperty(unionType: UnionType, name: string): Symbol {
- var types = unionType.types;
- var props: Symbol[];
+ let types = unionType.types;
+ let props: Symbol[];
for (let current of types) {
- var type = getApparentType(current);
+ let type = getApparentType(current);
if (type !== unknownType) {
- var prop = getPropertyOfType(type, name);
+ let prop = getPropertyOfType(type, name);
if (!prop) {
return undefined;
}
@@ -2721,15 +2721,15 @@ module ts {
}
}
}
- var propTypes: Type[] = [];
- var declarations: Declaration[] = [];
+ let propTypes: Type[] = [];
+ let declarations: Declaration[] = [];
for (let prop of props) {
if (prop.declarations) {
declarations.push.apply(declarations, prop.declarations);
}
propTypes.push(getTypeOfSymbol(prop));
}
- var result = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.UnionProperty, name);
+ let result = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.UnionProperty, name);
result.unionType = unionType;
result.declarations = declarations;
result.type = getUnionType(propTypes);
@@ -2737,11 +2737,11 @@ module ts {
}
function getPropertyOfUnionType(type: UnionType, name: string): Symbol {
- var properties = type.resolvedProperties || (type.resolvedProperties = {});
+ let properties = type.resolvedProperties || (type.resolvedProperties = {});
if (hasProperty(properties, name)) {
return properties[name];
}
- var property = createUnionProperty(type, name);
+ let property = createUnionProperty(type, name);
if (property) {
properties[name] = property;
}
@@ -2761,15 +2761,15 @@ module ts {
return undefined;
}
}
- var resolved = resolveObjectOrUnionTypeMembers(type);
+ let resolved = resolveObjectOrUnionTypeMembers(type);
if (hasProperty(resolved.members, name)) {
- var symbol = resolved.members[name];
+ let symbol = resolved.members[name];
if (symbolIsValue(symbol)) {
return symbol;
}
}
if (resolved === anyFunctionType || resolved.callSignatures.length || resolved.constructSignatures.length) {
- var symbol = getPropertyOfObjectType(globalFunctionType, name);
+ let symbol = getPropertyOfObjectType(globalFunctionType, name);
if (symbol) return symbol;
}
return getPropertyOfObjectType(globalObjectType, name);
@@ -2777,7 +2777,7 @@ module ts {
function getSignaturesOfObjectOrUnionType(type: Type, kind: SignatureKind): Signature[] {
if (type.flags & (TypeFlags.ObjectType | TypeFlags.Union)) {
- var resolved = resolveObjectOrUnionTypeMembers(type);
+ let resolved = resolveObjectOrUnionTypeMembers(type);
return kind === SignatureKind.Call ? resolved.callSignatures : resolved.constructSignatures;
}
return emptyArray;
@@ -2791,7 +2791,7 @@ module ts {
function getIndexTypeOfObjectOrUnionType(type: Type, kind: IndexKind): Type {
if (type.flags & (TypeFlags.ObjectType | TypeFlags.Union)) {
- var resolved = resolveObjectOrUnionTypeMembers(type);
+ let resolved = resolveObjectOrUnionTypeMembers(type);
return kind === IndexKind.String ? resolved.stringIndexType : resolved.numberIndexType;
}
}
@@ -2805,9 +2805,9 @@ module ts {
// Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual
// type checking functions).
function getTypeParametersFromDeclaration(typeParameterDeclarations: TypeParameterDeclaration[]): TypeParameter[] {
- var result: TypeParameter[] = [];
+ let result: TypeParameter[] = [];
forEach(typeParameterDeclarations, node => {
- var tp = getDeclaredTypeOfTypeParameter(node.symbol);
+ let tp = getDeclaredTypeOfTypeParameter(node.symbol);
if (!contains(result, tp)) {
result.push(tp);
}
@@ -2820,7 +2820,7 @@ module ts {
return emptyArray;
}
- var module = resolveExternalModuleName(node, node.moduleSpecifier);
+ let module = resolveExternalModuleName(node, node.moduleSpecifier);
if (!module || !module.exports) {
return emptyArray;
}
@@ -2829,16 +2829,16 @@ module ts {
}
function getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature {
- var links = getNodeLinks(declaration);
+ let links = getNodeLinks(declaration);
if (!links.resolvedSignature) {
- var classType = declaration.kind === SyntaxKind.Constructor ? getDeclaredTypeOfClass((declaration.parent).symbol) : undefined;
- var typeParameters = classType ? classType.typeParameters :
+ let classType = declaration.kind === SyntaxKind.Constructor ? getDeclaredTypeOfClass((declaration.parent).symbol) : undefined;
+ let typeParameters = classType ? classType.typeParameters :
declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined;
- var parameters: Symbol[] = [];
- var hasStringLiterals = false;
- var minArgumentCount = -1;
- for (var i = 0, n = declaration.parameters.length; i < n; i++) {
- var param = declaration.parameters[i];
+ let parameters: Symbol[] = [];
+ let hasStringLiterals = false;
+ let minArgumentCount = -1;
+ for (let i = 0, n = declaration.parameters.length; i < n; i++) {
+ let param = declaration.parameters[i];
parameters.push(param.symbol);
if (param.type && param.type.kind === SyntaxKind.StringLiteral) {
hasStringLiterals = true;
@@ -2854,7 +2854,7 @@ module ts {
minArgumentCount = declaration.parameters.length;
}
- var returnType: Type;
+ let returnType: Type;
if (classType) {
returnType = classType;
}
@@ -2865,7 +2865,7 @@ module ts {
// TypeScript 1.0 spec (April 2014):
// If only one accessor includes a type annotation, the other behaves as if it had the same type annotation.
if (declaration.kind === SyntaxKind.GetAccessor && !hasDynamicName(declaration)) {
- var setter = getDeclarationOfKind(declaration.symbol, SyntaxKind.SetAccessor);
+ let setter = getDeclarationOfKind(declaration.symbol, SyntaxKind.SetAccessor);
returnType = getAnnotatedAccessorType(setter);
}
@@ -2882,9 +2882,9 @@ module ts {
function getSignaturesOfSymbol(symbol: Symbol): Signature[] {
if (!symbol) return emptyArray;
- var result: Signature[] = [];
- for (var i = 0, len = symbol.declarations.length; i < len; i++) {
- var node = symbol.declarations[i];
+ let result: Signature[] = [];
+ for (let i = 0, len = symbol.declarations.length; i < len; i++) {
+ let node = symbol.declarations[i];
switch (node.kind) {
case SyntaxKind.FunctionType:
case SyntaxKind.ConstructorType:
@@ -2903,7 +2903,7 @@ module ts {
// an implementation node if it has a body and the previous node is of the same kind and immediately
// precedes the implementation node (i.e. has the same parent and ends where the implementation starts).
if (i > 0 && (node).body) {
- var previous = symbol.declarations[i - 1];
+ let previous = symbol.declarations[i - 1];
if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) {
break;
}
@@ -2933,7 +2933,7 @@ module ts {
else if (signature.resolvedReturnType === resolvingType) {
signature.resolvedReturnType = anyType;
if (compilerOptions.noImplicitAny) {
- var declaration = signature.declaration;
+ let declaration = signature.declaration;
if (declaration.name) {
error(declaration.name, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, declarationNameToString(declaration.name));
}
@@ -2947,7 +2947,7 @@ module ts {
function getRestTypeOfSignature(signature: Signature): Type {
if (signature.hasRestParameter) {
- var type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
+ let type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
if (type.flags & TypeFlags.Reference && (type).target === globalArrayType) {
return (type).typeArguments[0];
}
@@ -2978,8 +2978,8 @@ module ts {
// object type literal or interface (using the new keyword). Each way of declaring a constructor
// will result in a different declaration kind.
if (!signature.isolatedSignatureType) {
- var isConstructor = signature.declaration.kind === SyntaxKind.Constructor || signature.declaration.kind === SyntaxKind.ConstructSignature;
- var type = createObjectType(TypeFlags.Anonymous | TypeFlags.FromSignature);
+ let isConstructor = signature.declaration.kind === SyntaxKind.Constructor || signature.declaration.kind === SyntaxKind.ConstructSignature;
+ let type = createObjectType(TypeFlags.Anonymous | TypeFlags.FromSignature);
type.members = emptySymbols;
type.properties = emptyArray;
type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -2995,14 +2995,14 @@ module ts {
}
function getIndexDeclarationOfSymbol(symbol: Symbol, kind: IndexKind): SignatureDeclaration {
- var syntaxKind = kind === IndexKind.Number ? SyntaxKind.NumberKeyword : SyntaxKind.StringKeyword;
- var indexSymbol = getIndexSymbol(symbol);
+ let syntaxKind = kind === IndexKind.Number ? SyntaxKind.NumberKeyword : SyntaxKind.StringKeyword;
+ let indexSymbol = getIndexSymbol(symbol);
if (indexSymbol) {
- var len = indexSymbol.declarations.length;
+ let len = indexSymbol.declarations.length;
for (let decl of indexSymbol.declarations) {
- var node = decl;
+ let node = decl;
if (node.parameters.length === 1) {
- var parameter = node.parameters[0];
+ let parameter = node.parameters[0];
if (parameter && parameter.type && parameter.type.kind === syntaxKind) {
return node;
}
@@ -3014,7 +3014,7 @@ module ts {
}
function getIndexTypeOfSymbol(symbol: Symbol, kind: IndexKind): Type {
- var declaration = getIndexDeclarationOfSymbol(symbol, kind);
+ let declaration = getIndexDeclarationOfSymbol(symbol, kind);
return declaration
? declaration.type ? getTypeFromTypeNode(declaration.type) : anyType
: undefined;
@@ -3023,7 +3023,7 @@ module ts {
function getConstraintOfTypeParameter(type: TypeParameter): Type {
if (!type.constraint) {
if (type.target) {
- var targetConstraint = getConstraintOfTypeParameter(type.target);
+ let targetConstraint = getConstraintOfTypeParameter(type.target);
type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType;
}
else {
@@ -3040,8 +3040,8 @@ module ts {
case 2:
return types[0].id + "," + types[1].id;
default:
- var result = "";
- for (var i = 0; i < types.length; i++) {
+ let result = "";
+ for (let i = 0; i < types.length; i++) {
if (i > 0) {
result += ",";
}
@@ -3056,7 +3056,7 @@ module ts {
// It is only necessary to do so if a constituent type might be the undefined type, the null type, or the type
// of an object literal (since those types have widening related information we need to track).
function getWideningFlagsOfTypes(types: Type[]): TypeFlags {
- var result: TypeFlags = 0;
+ let result: TypeFlags = 0;
for (let type of types) {
result |= type.flags;
}
@@ -3064,10 +3064,10 @@ module ts {
}
function createTypeReference(target: GenericType, typeArguments: Type[]): TypeReference {
- var id = getTypeListId(typeArguments);
- var type = target.instantiations[id];
+ let id = getTypeListId(typeArguments);
+ let type = target.instantiations[id];
if (!type) {
- var flags = TypeFlags.Reference | getWideningFlagsOfTypes(typeArguments);
+ let flags = TypeFlags.Reference | getWideningFlagsOfTypes(typeArguments);
type = target.instantiations[id] = createObjectType(flags, target.symbol);
type.target = target;
type.typeArguments = typeArguments;
@@ -3076,13 +3076,13 @@ module ts {
}
function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode, typeParameterSymbol: Symbol): boolean {
- var links = getNodeLinks(typeReferenceNode);
+ let links = getNodeLinks(typeReferenceNode);
if (links.isIllegalTypeReferenceInConstraint !== undefined) {
return links.isIllegalTypeReferenceInConstraint;
}
// bubble up to the declaration
- var currentNode: Node = typeReferenceNode;
+ let currentNode: Node = typeReferenceNode;
// forEach === exists
while (!forEach(typeParameterSymbol.declarations, d => d.parent === currentNode.parent)) {
currentNode = currentNode.parent;
@@ -3093,12 +3093,12 @@ module ts {
}
function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter: TypeParameterDeclaration): void {
- var typeParameterSymbol: Symbol;
+ let typeParameterSymbol: Symbol;
function check(n: Node): void {
if (n.kind === SyntaxKind.TypeReference && (n).typeName.kind === SyntaxKind.Identifier) {
- var links = getNodeLinks(n);
+ let links = getNodeLinks(n);
if (links.isIllegalTypeReferenceInConstraint === undefined) {
- var symbol = resolveName(typeParameter, ((n).typeName).text, SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+ let symbol = resolveName(typeParameter, ((n).typeName).text, SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
if (symbol && (symbol.flags & SymbolFlags.TypeParameter)) {
// TypeScript 1.0 spec (April 2014): 3.4.1
// Type parameters declared in a particular type parameter list
@@ -3125,9 +3125,9 @@ module ts {
}
function getTypeFromTypeReferenceNode(node: TypeReferenceNode): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
- var symbol = resolveEntityName(node.typeName, SymbolFlags.Type);
+ let symbol = resolveEntityName(node.typeName, SymbolFlags.Type);
if (symbol) {
var type: Type;
if ((symbol.flags & SymbolFlags.TypeParameter) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) {
@@ -3140,7 +3140,7 @@ module ts {
else {
type = getDeclaredTypeOfSymbol(symbol);
if (type.flags & (TypeFlags.Class | TypeFlags.Interface) && type.flags & TypeFlags.Reference) {
- var typeParameters = (type).typeParameters;
+ let typeParameters = (type).typeParameters;
if (node.typeArguments && node.typeArguments.length === typeParameters.length) {
type = createTypeReference(type, map(node.typeArguments, getTypeFromTypeNode));
}
@@ -3163,7 +3163,7 @@ module ts {
}
function getTypeFromTypeQueryNode(node: TypeQueryNode): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
// TypeScript 1.0 spec (April 2014): 3.6.3
// The expression is processed as an identifier expression (section 4.3)
@@ -3177,7 +3177,7 @@ module ts {
function getTypeOfGlobalSymbol(symbol: Symbol, arity: number): ObjectType {
function getTypeDeclaration(symbol: Symbol): Declaration {
- var declarations = symbol.declarations;
+ let declarations = symbol.declarations;
for (let declaration of declarations) {
switch (declaration.kind) {
case SyntaxKind.ClassDeclaration:
@@ -3191,7 +3191,7 @@ module ts {
if (!symbol) {
return emptyObjectType;
}
- var type = getDeclaredTypeOfSymbol(symbol);
+ let type = getDeclaredTypeOfSymbol(symbol);
if (!(type.flags & TypeFlags.ObjectType)) {
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name);
return emptyObjectType;
@@ -3227,12 +3227,12 @@ module ts {
// globalArrayType will be undefined if we get here during creation of the Array type. This for example happens if
// user code augments the Array type with call or construct signatures that have an array type as the return type.
// We instead use globalArraySymbol to obtain the (not yet fully constructed) Array type.
- var arrayType = globalArrayType || getDeclaredTypeOfSymbol(globalArraySymbol);
+ let arrayType = globalArrayType || getDeclaredTypeOfSymbol(globalArraySymbol);
return arrayType !== emptyObjectType ? createTypeReference(arrayType, [elementType]) : emptyObjectType;
}
function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
}
@@ -3240,8 +3240,8 @@ module ts {
}
function createTupleType(elementTypes: Type[]) {
- var id = getTypeListId(elementTypes);
- var type = tupleTypes[id];
+ let id = getTypeListId(elementTypes);
+ let type = tupleTypes[id];
if (!type) {
type = tupleTypes[id] = createObjectType(TypeFlags.Tuple);
type.elementTypes = elementTypes;
@@ -3250,7 +3250,7 @@ module ts {
}
function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
links.resolvedType = createTupleType(map(node.elementTypes, getTypeFromTypeNode));
}
@@ -3262,8 +3262,8 @@ module ts {
addTypesToSortedSet(sortedSet, (type).types);
}
else {
- var i = 0;
- var id = type.id;
+ let i = 0;
+ let id = type.id;
while (i < sortedSet.length && sortedSet[i].id < id) {
i++;
}
@@ -3289,7 +3289,7 @@ module ts {
}
function removeSubtypes(types: Type[]) {
- var i = types.length;
+ let i = types.length;
while (i > 0) {
i--;
if (isSubtypeOfAny(types[i], types)) {
@@ -3308,7 +3308,7 @@ module ts {
}
function removeAllButLast(types: Type[], typeToRemove: Type) {
- var i = types.length;
+ let i = types.length;
while (i > 0 && types.length > 1) {
i--;
if (types[i] === typeToRemove) {
@@ -3321,7 +3321,7 @@ module ts {
if (types.length === 0) {
return emptyObjectType;
}
- var sortedTypes: Type[] = [];
+ let sortedTypes: Type[] = [];
addTypesToSortedSet(sortedTypes, types);
if (noSubtypeReduction) {
if (containsAnyType(sortedTypes)) {
@@ -3336,8 +3336,8 @@ module ts {
if (sortedTypes.length === 1) {
return sortedTypes[0];
}
- var id = getTypeListId(sortedTypes);
- var type = unionTypes[id];
+ let id = getTypeListId(sortedTypes);
+ let type = unionTypes[id];
if (!type) {
type = unionTypes[id] = createObjectType(TypeFlags.Union | getWideningFlagsOfTypes(sortedTypes));
type.types = sortedTypes;
@@ -3346,7 +3346,7 @@ module ts {
}
function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
}
@@ -3354,7 +3354,7 @@ module ts {
}
function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node: Node): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
// Deferred resolution of members is handled by resolveObjectTypeMembers
links.resolvedType = createObjectType(TypeFlags.Anonymous, node.symbol);
@@ -3367,13 +3367,13 @@ module ts {
return stringLiteralTypes[node.text];
}
- var type = stringLiteralTypes[node.text] = createType(TypeFlags.StringLiteral);
+ let type = stringLiteralTypes[node.text] = createType(TypeFlags.StringLiteral);
type.text = getTextOfNode(node);
return type;
}
function getTypeFromStringLiteral(node: LiteralExpression): Type {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedType) {
links.resolvedType = getStringLiteralType(node);
}
@@ -3416,7 +3416,7 @@ module ts {
// Callers should first ensure this by calling isTypeNode
case SyntaxKind.Identifier:
case SyntaxKind.QualifiedName:
- var symbol = getSymbolInfo(node);
+ let symbol = getSymbolInfo(node);
return symbol && getDeclaredTypeOfSymbol(symbol);
default:
return unknownType;
@@ -3425,7 +3425,7 @@ module ts {
function instantiateList(items: T[], mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): T[] {
if (items && items.length) {
- var result: T[] = [];
+ let result: T[] = [];
for (let v of items) {
result.push(instantiator(v, mapper));
}
@@ -3448,7 +3448,7 @@ module ts {
case 2: return createBinaryTypeMapper(sources[0], targets[0], sources[1], targets[1]);
}
return t => {
- for (var i = 0; i < sources.length; i++) {
+ for (let i = 0; i < sources.length; i++) {
if (t === sources[i]) {
return targets[i];
}
@@ -3482,7 +3482,7 @@ module ts {
function createInferenceMapper(context: InferenceContext): TypeMapper {
return t => {
- for (var i = 0; i < context.typeParameters.length; i++) {
+ for (let i = 0; i < context.typeParameters.length; i++) {
if (t === context.typeParameters[i]) {
return getInferredType(context, i);
}
@@ -3500,7 +3500,7 @@ module ts {
}
function instantiateTypeParameter(typeParameter: TypeParameter, mapper: TypeMapper): TypeParameter {
- var result = createType(TypeFlags.TypeParameter);
+ let result = createType(TypeFlags.TypeParameter);
result.symbol = typeParameter.symbol;
if (typeParameter.constraint) {
result.constraint = instantiateType(typeParameter.constraint, mapper);
@@ -3517,7 +3517,7 @@ module ts {
var freshTypeParameters = instantiateList(signature.typeParameters, mapper, instantiateTypeParameter);
mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper);
}
- var result = createSignature(signature.declaration, freshTypeParameters,
+ let result = createSignature(signature.declaration, freshTypeParameters,
instantiateList(signature.parameters, mapper, instantiateSymbol),
signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined,
signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals);
@@ -3528,7 +3528,7 @@ module ts {
function instantiateSymbol(symbol: Symbol, mapper: TypeMapper): Symbol {
if (symbol.flags & SymbolFlags.Instantiated) {
- var links = getSymbolLinks(symbol);
+ let links = getSymbolLinks(symbol);
// If symbol being instantiated is itself a instantiation, fetch the original target and combine the
// type mappers. This ensures that original type identities are properly preserved and that aliases
// always reference a non-aliases.
@@ -3538,7 +3538,7 @@ module ts {
// Keep the flags from the symbol we're instantiating. Mark that is instantiated, and
// also transient so that we can just store data on it directly.
- var result = createSymbol(SymbolFlags.Instantiated | SymbolFlags.Transient | symbol.flags, symbol.name);
+ let result = createSymbol(SymbolFlags.Instantiated | SymbolFlags.Transient | symbol.flags, symbol.name);
result.declarations = symbol.declarations;
result.parent = symbol.parent;
result.target = symbol;
@@ -3551,13 +3551,13 @@ module ts {
}
function instantiateAnonymousType(type: ObjectType, mapper: TypeMapper): ObjectType {
- var result = createObjectType(TypeFlags.Anonymous, type.symbol);
+ let result = createObjectType(TypeFlags.Anonymous, type.symbol);
result.properties = instantiateList(getPropertiesOfObjectType(type), mapper, instantiateSymbol);
result.members = createSymbolTable(result.properties);
result.callSignatures = instantiateList(getSignaturesOfType(type, SignatureKind.Call), mapper, instantiateSignature);
result.constructSignatures = instantiateList(getSignaturesOfType(type, SignatureKind.Construct), mapper, instantiateSignature);
- var stringIndexType = getIndexTypeOfType(type, IndexKind.String);
- var numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
+ let stringIndexType = getIndexTypeOfType(type, IndexKind.String);
+ let numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
if (stringIndexType) result.stringIndexType = instantiateType(stringIndexType, mapper);
if (numberIndexType) result.numberIndexType = instantiateType(numberIndexType, mapper);
return result;
@@ -3621,9 +3621,9 @@ module ts {
function getTypeWithoutConstructors(type: Type): Type {
if (type.flags & TypeFlags.ObjectType) {
- var resolved = resolveObjectOrUnionTypeMembers(type);
+ let resolved = resolveObjectOrUnionTypeMembers(type);
if (resolved.constructSignatures.length) {
- var result = createObjectType(TypeFlags.Anonymous, type.symbol);
+ let result = createObjectType(TypeFlags.Anonymous, type.symbol);
result.members = resolved.members;
result.properties = resolved.properties;
result.callSignatures = resolved.callSignatures;
@@ -3636,9 +3636,9 @@ module ts {
// TYPE CHECKING
- var subtypeRelation: Map = {};
- var assignableRelation: Map = {};
- var identityRelation: Map = {};
+ let subtypeRelation: Map = {};
+ let assignableRelation: Map = {};
+ let identityRelation: Map = {};
function isTypeIdenticalTo(source: Type, target: Type): boolean {
return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined);
@@ -3665,8 +3665,8 @@ module ts {
}
function isSignatureAssignableTo(source: Signature, target: Signature): boolean {
- var sourceType = getOrCreateTypeFromSignature(source);
- var targetType = getOrCreateTypeFromSignature(target);
+ let sourceType = getOrCreateTypeFromSignature(source);
+ let targetType = getOrCreateTypeFromSignature(target);
return checkTypeRelatedTo(sourceType, targetType, assignableRelation, /*errorNode*/ undefined);
}
@@ -3678,17 +3678,17 @@ module ts {
headMessage?: DiagnosticMessage,
containingMessageChain?: DiagnosticMessageChain): boolean {
- var errorInfo: DiagnosticMessageChain;
- var sourceStack: ObjectType[];
- var targetStack: ObjectType[];
- var maybeStack: Map[];
- var expandingFlags: number;
- var depth = 0;
- var overflow = false;
+ let errorInfo: DiagnosticMessageChain;
+ let sourceStack: ObjectType[];
+ let targetStack: ObjectType[];
+ let maybeStack: Map[];
+ let expandingFlags: number;
+ let depth = 0;
+ let overflow = false;
Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
- var result = isRelatedTo(source, target, errorNode !== undefined, headMessage);
+ let result = isRelatedTo(source, target, errorNode !== undefined, headMessage);
if (overflow) {
error(errorNode, Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
}
@@ -3718,7 +3718,7 @@ module ts {
// Ternary.Maybe if they are related with assumptions of other relationships, or
// Ternary.False if they are not related.
function isRelatedTo(source: Type, target: Type, reportErrors?: boolean, headMessage?: DiagnosticMessage, elaborateErrors = false): Ternary {
- var result: Ternary;
+ let result: Ternary;
// both types are the same - covers 'they are the same primitive type or both are Any' or the same type parameter cases
if (source === target) return Ternary.True;
if (relation !== identityRelation) {
@@ -3771,7 +3771,7 @@ module ts {
}
}
else {
- var saveErrorInfo = errorInfo;
+ let saveErrorInfo = errorInfo;
if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) {
// We have type references to same target type, see if relationship holds for all type arguments
if (result = typesRelatedTo((source).typeArguments, (target).typeArguments, reportErrors)) {
@@ -3780,9 +3780,9 @@ module ts {
}
// Even if relationship doesn't hold for type arguments, it may hold in a structural comparison
// Report structural errors only if we haven't reported any errors yet
- var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo;
+ let reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo;
// identity relation does not use apparent type
- var sourceOrApparentType = relation === identityRelation ? source : getApparentType(source);
+ let sourceOrApparentType = relation === identityRelation ? source : getApparentType(source);
if (sourceOrApparentType.flags & TypeFlags.ObjectType && target.flags & TypeFlags.ObjectType &&
(result = objectTypeRelatedTo(sourceOrApparentType, target, reportStructuralErrors, elaborateErrors))) {
errorInfo = saveErrorInfo;
@@ -3791,8 +3791,8 @@ module ts {
}
if (reportErrors) {
headMessage = headMessage || Diagnostics.Type_0_is_not_assignable_to_type_1;
- var sourceType = typeToString(source);
- var targetType = typeToString(target);
+ let sourceType = typeToString(source);
+ let targetType = typeToString(target);
if (sourceType === targetType) {
sourceType = typeToString(source, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
targetType = typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
@@ -3803,10 +3803,10 @@ module ts {
}
function unionTypeRelatedToUnionType(source: UnionType, target: UnionType): Ternary {
- var result = Ternary.True;
- var sourceTypes = source.types;
+ let result = Ternary.True;
+ let sourceTypes = source.types;
for (let sourceType of sourceTypes) {
- var related = typeRelatedToUnionType(sourceType, target, false);
+ let related = typeRelatedToUnionType(sourceType, target, false);
if (!related) {
return Ternary.False;
}
@@ -3816,9 +3816,9 @@ module ts {
}
function typeRelatedToUnionType(source: Type, target: UnionType, reportErrors: boolean): Ternary {
- var targetTypes = target.types;
- for (var i = 0, len = targetTypes.length; i < len; i++) {
- var related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1);
+ let targetTypes = target.types;
+ for (let i = 0, len = targetTypes.length; i < len; i++) {
+ let related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1);
if (related) {
return related;
}
@@ -3827,10 +3827,10 @@ module ts {
}
function unionTypeRelatedToType(source: UnionType, target: Type, reportErrors: boolean): Ternary {
- var result = Ternary.True;
- var sourceTypes = source.types;
+ let result = Ternary.True;
+ let sourceTypes = source.types;
for (let sourceType of sourceTypes) {
- var related = isRelatedTo(sourceType, target, reportErrors);
+ let related = isRelatedTo(sourceType, target, reportErrors);
if (!related) {
return Ternary.False;
}
@@ -3840,9 +3840,9 @@ module ts {
}
function typesRelatedTo(sources: Type[], targets: Type[], reportErrors: boolean): Ternary {
- var result = Ternary.True;
- for (var i = 0, len = sources.length; i < len; i++) {
- var related = isRelatedTo(sources[i], targets[i], reportErrors);
+ let result = Ternary.True;
+ for (let i = 0, len = sources.length; i < len; i++) {
+ let related = isRelatedTo(sources[i], targets[i], reportErrors);
if (!related) {
return Ternary.False;
}
@@ -3867,7 +3867,7 @@ module ts {
}
else {
while (true) {
- var constraint = getConstraintOfTypeParameter(source);
+ let constraint = getConstraintOfTypeParameter(source);
if (constraint === target) return Ternary.True;
if (!(constraint && constraint.flags & TypeFlags.TypeParameter)) break;
source = constraint;
@@ -3885,9 +3885,9 @@ module ts {
if (overflow) {
return Ternary.False;
}
- var id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
- var related = relation[id];
- //var related: RelationComparisonResult = undefined; // relation[id];
+ let id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
+ let related = relation[id];
+ //let related: RelationComparisonResult = undefined; // relation[id];
if (related !== undefined) {
// If we computed this relation already and it was failed and reported, or if we're not being asked to elaborate
// errors, we can use the cached value. Otherwise, recompute the relation
@@ -3896,7 +3896,7 @@ module ts {
}
}
if (depth > 0) {
- for (var i = 0; i < depth; i++) {
+ for (let i = 0; i < depth; i++) {
// If source and target are already being compared, consider them related with assumptions
if (maybeStack[i][id]) {
return Ternary.Maybe;
@@ -3918,14 +3918,15 @@ module ts {
maybeStack[depth] = {};
maybeStack[depth][id] = RelationComparisonResult.Succeeded;
depth++;
- var saveExpandingFlags = expandingFlags;
+ let saveExpandingFlags = expandingFlags;
if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) expandingFlags |= 1;
if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) expandingFlags |= 2;
+ let result: Ternary;
if (expandingFlags === 3) {
- var result = Ternary.Maybe;
+ result = Ternary.Maybe;
}
else {
- var result = propertiesRelatedTo(source, target, reportErrors);
+ result = propertiesRelatedTo(source, target, reportErrors);
if (result) {
result &= signaturesRelatedTo(source, target, SignatureKind.Call, reportErrors);
if (result) {
@@ -3942,9 +3943,9 @@ module ts {
expandingFlags = saveExpandingFlags;
depth--;
if (result) {
- var maybeCache = maybeStack[depth];
+ let maybeCache = maybeStack[depth];
// If result is definitely true, copy assumptions to global cache, else copy to next level up
- var destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
+ let destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
copyMap(maybeCache, destinationCache);
}
else {
@@ -3962,10 +3963,10 @@ module ts {
// some level beyond that.
function isDeeplyNestedGeneric(type: ObjectType, stack: ObjectType[]): boolean {
if (type.flags & TypeFlags.Reference && depth >= 10) {
- var target = (type).target;
- var count = 0;
- for (var i = 0; i < depth; i++) {
- var t = stack[i];
+ let target = (type).target;
+ let count = 0;
+ for (let i = 0; i < depth; i++) {
+ let t = stack[i];
if (t.flags & TypeFlags.Reference && (t).target === target) {
count++;
if (count >= 10) return true;
@@ -3979,11 +3980,11 @@ module ts {
if (relation === identityRelation) {
return propertiesIdenticalTo(source, target);
}
- var result = Ternary.True;
- var properties = getPropertiesOfObjectType(target);
- var requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral);
+ let result = Ternary.True;
+ let properties = getPropertiesOfObjectType(target);
+ let requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral);
for (let targetProp of properties) {
- var sourceProp = getPropertyOfType(source, targetProp.name);
+ let sourceProp = getPropertyOfType(source, targetProp.name);
if (sourceProp !== targetProp) {
if (!sourceProp) {
if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) {
@@ -3994,8 +3995,8 @@ module ts {
}
}
else if (!(targetProp.flags & SymbolFlags.Prototype)) {
- var sourceFlags = getDeclarationFlagsFromSymbol(sourceProp);
- var targetFlags = getDeclarationFlagsFromSymbol(targetProp);
+ let sourceFlags = getDeclarationFlagsFromSymbol(sourceProp);
+ let targetFlags = getDeclarationFlagsFromSymbol(targetProp);
if (sourceFlags & NodeFlags.Private || targetFlags & NodeFlags.Private) {
if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
if (reportErrors) {
@@ -4012,9 +4013,9 @@ module ts {
}
}
else if (targetFlags & NodeFlags.Protected) {
- var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & SymbolFlags.Class;
- var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
- var targetClass = getDeclaredTypeOfSymbol(targetProp.parent);
+ let sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & SymbolFlags.Class;
+ let sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
+ let targetClass = getDeclaredTypeOfSymbol(targetProp.parent);
if (!sourceClass || !hasBaseType(sourceClass, targetClass)) {
if (reportErrors) {
reportError(Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2,
@@ -4030,7 +4031,7 @@ module ts {
}
return Ternary.False;
}
- var related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
+ let related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
if (!related) {
if (reportErrors) {
reportError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
@@ -4059,18 +4060,18 @@ module ts {
}
function propertiesIdenticalTo(source: ObjectType, target: ObjectType): Ternary {
- var sourceProperties = getPropertiesOfObjectType(source);
- var targetProperties = getPropertiesOfObjectType(target);
+ let sourceProperties = getPropertiesOfObjectType(source);
+ let targetProperties = getPropertiesOfObjectType(target);
if (sourceProperties.length !== targetProperties.length) {
return Ternary.False;
}
- var result = Ternary.True;
+ let result = Ternary.True;
for (let sourceProp of sourceProperties) {
- var targetProp = getPropertyOfObjectType(target, sourceProp.name);
+ let targetProp = getPropertyOfObjectType(target, sourceProp.name);
if (!targetProp) {
return Ternary.False;
}
- var related = compareProperties(sourceProp, targetProp, isRelatedTo);
+ let related = compareProperties(sourceProp, targetProp, isRelatedTo);
if (!related) {
return Ternary.False;
}
@@ -4086,16 +4087,16 @@ module ts {
if (target === anyFunctionType || source === anyFunctionType) {
return Ternary.True;
}
- var sourceSignatures = getSignaturesOfType(source, kind);
- var targetSignatures = getSignaturesOfType(target, kind);
- var result = Ternary.True;
- var saveErrorInfo = errorInfo;
+ let sourceSignatures = getSignaturesOfType(source, kind);
+ let targetSignatures = getSignaturesOfType(target, kind);
+ let result = Ternary.True;
+ let saveErrorInfo = errorInfo;
outer: for (let t of targetSignatures) {
if (!t.hasStringLiterals || target.flags & TypeFlags.FromSignature) {
- var localErrors = reportErrors;
+ let localErrors = reportErrors;
for (let s of sourceSignatures) {
if (!s.hasStringLiterals || source.flags & TypeFlags.FromSignature) {
- var related = signatureRelatedTo(s, t, localErrors);
+ let related = signatureRelatedTo(s, t, localErrors);
if (related) {
result &= related;
errorInfo = saveErrorInfo;
@@ -4118,9 +4119,9 @@ module ts {
if (!target.hasRestParameter && source.minArgumentCount > target.parameters.length) {
return Ternary.False;
}
- var sourceMax = source.parameters.length;
- var targetMax = target.parameters.length;
- var checkCount: number;
+ let sourceMax = source.parameters.length;
+ let targetMax = target.parameters.length;
+ let checkCount: number;
if (source.hasRestParameter && target.hasRestParameter) {
checkCount = sourceMax > targetMax ? sourceMax : targetMax;
sourceMax--;
@@ -4141,12 +4142,12 @@ module ts {
// M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
source = getErasedSignature(source);
target = getErasedSignature(target);
- var result = Ternary.True;
- for (var i = 0; i < checkCount; i++) {
- var s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
- var t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
- var saveErrorInfo = errorInfo;
- var related = isRelatedTo(s, t, reportErrors);
+ let result = Ternary.True;
+ for (let i = 0; i < checkCount; i++) {
+ let s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
+ let t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
+ let saveErrorInfo = errorInfo;
+ let related = isRelatedTo(s, t, reportErrors);
if (!related) {
related = isRelatedTo(t, s, false);
if (!related) {
@@ -4161,21 +4162,21 @@ module ts {
}
result &= related;
}
- var t = getReturnTypeOfSignature(target);
+ let t = getReturnTypeOfSignature(target);
if (t === voidType) return result;
- var s = getReturnTypeOfSignature(source);
+ let s = getReturnTypeOfSignature(source);
return result & isRelatedTo(s, t, reportErrors);
}
function signaturesIdenticalTo(source: ObjectType, target: ObjectType, kind: SignatureKind): Ternary {
- var sourceSignatures = getSignaturesOfType(source, kind);
- var targetSignatures = getSignaturesOfType(target, kind);
+ let sourceSignatures = getSignaturesOfType(source, kind);
+ let targetSignatures = getSignaturesOfType(target, kind);
if (sourceSignatures.length !== targetSignatures.length) {
return Ternary.False;
}
- var result = Ternary.True;
- for (var i = 0, len = sourceSignatures.length; i < len; ++i) {
- var related = compareSignatures(sourceSignatures[i], targetSignatures[i], /*compareReturnTypes*/ true, isRelatedTo);
+ let result = Ternary.True;
+ for (let i = 0, len = sourceSignatures.length; i < len; ++i) {
+ let related = compareSignatures(sourceSignatures[i], targetSignatures[i], /*compareReturnTypes*/ true, isRelatedTo);
if (!related) {
return Ternary.False;
}
@@ -4188,16 +4189,16 @@ module ts {
if (relation === identityRelation) {
return indexTypesIdenticalTo(IndexKind.String, source, target);
}
- var targetType = getIndexTypeOfType(target, IndexKind.String);
+ let targetType = getIndexTypeOfType(target, IndexKind.String);
if (targetType) {
- var sourceType = getIndexTypeOfType(source, IndexKind.String);
+ let sourceType = getIndexTypeOfType(source, IndexKind.String);
if (!sourceType) {
if (reportErrors) {
reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
}
return Ternary.False;
}
- var related = isRelatedTo(sourceType, targetType, reportErrors);
+ let related = isRelatedTo(sourceType, targetType, reportErrors);
if (!related) {
if (reportErrors) {
reportError(Diagnostics.Index_signatures_are_incompatible);
@@ -4213,10 +4214,10 @@ module ts {
if (relation === identityRelation) {
return indexTypesIdenticalTo(IndexKind.Number, source, target);
}
- var targetType = getIndexTypeOfType(target, IndexKind.Number);
+ let targetType = getIndexTypeOfType(target, IndexKind.Number);
if (targetType) {
- var sourceStringType = getIndexTypeOfType(source, IndexKind.String);
- var sourceNumberType = getIndexTypeOfType(source, IndexKind.Number);
+ let sourceStringType = getIndexTypeOfType(source, IndexKind.String);
+ let sourceNumberType = getIndexTypeOfType(source, IndexKind.Number);
if (!(sourceStringType || sourceNumberType)) {
if (reportErrors) {
reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
@@ -4242,8 +4243,8 @@ module ts {
}
function indexTypesIdenticalTo(indexKind: IndexKind, source: ObjectType, target: ObjectType): Ternary {
- var targetType = getIndexTypeOfType(target, indexKind);
- var sourceType = getIndexTypeOfType(source, indexKind);
+ let targetType = getIndexTypeOfType(target, indexKind);
+ let sourceType = getIndexTypeOfType(source, indexKind);
if (!sourceType && !targetType) {
return Ternary.True;
}
@@ -4265,8 +4266,8 @@ module ts {
if (sourceProp === targetProp) {
return Ternary.True;
}
- var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (NodeFlags.Private | NodeFlags.Protected);
- var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (NodeFlags.Private | NodeFlags.Protected);
+ let sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (NodeFlags.Private | NodeFlags.Protected);
+ let targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (NodeFlags.Private | NodeFlags.Protected);
if (sourcePropAccessibility !== targetPropAccessibility) {
return Ternary.False;
}
@@ -4292,13 +4293,13 @@ module ts {
source.hasRestParameter !== target.hasRestParameter) {
return Ternary.False;
}
- var result = Ternary.True;
+ let result = Ternary.True;
if (source.typeParameters && target.typeParameters) {
if (source.typeParameters.length !== target.typeParameters.length) {
return Ternary.False;
}
- for (var i = 0, len = source.typeParameters.length; i < len; ++i) {
- var related = compareTypes(source.typeParameters[i], target.typeParameters[i]);
+ for (let i = 0, len = source.typeParameters.length; i < len; ++i) {
+ let related = compareTypes(source.typeParameters[i], target.typeParameters[i]);
if (!related) {
return Ternary.False;
}
@@ -4312,10 +4313,10 @@ module ts {
// M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
source = getErasedSignature(source);
target = getErasedSignature(target);
- for (var i = 0, len = source.parameters.length; i < len; i++) {
- var s = source.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
- var t = target.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
- var related = compareTypes(s, t);
+ for (let i = 0, len = source.parameters.length; i < len; i++) {
+ let s = source.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
+ let t = target.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
+ let related = compareTypes(s, t);
if (!related) {
return Ternary.False;
}
@@ -4339,14 +4340,14 @@ module ts {
}
function reportNoCommonSupertypeError(types: Type[], errorLocation: Node, errorMessageChainHead: DiagnosticMessageChain): void {
- var bestSupertype: Type;
- var bestSupertypeDownfallType: Type; // The type that caused bestSupertype not to be the common supertype
- var bestSupertypeScore = 0;
+ let bestSupertype: Type;
+ let bestSupertypeDownfallType: Type; // The type that caused bestSupertype not to be the common supertype
+ let bestSupertypeScore = 0;
- for (var i = 0; i < types.length; i++) {
- var score = 0;
- var downfallType: Type = undefined;
- for (var j = 0; j < types.length; j++) {
+ for (let i = 0; i < types.length; i++) {
+ let score = 0;
+ let downfallType: Type = undefined;
+ for (let j = 0; j < types.length; j++) {
if (isTypeSubtypeOf(types[j], types[i])) {
score++;
}
@@ -4396,13 +4397,13 @@ module ts {
}
function getWidenedTypeOfObjectLiteral(type: Type): Type {
- var properties = getPropertiesOfObjectType(type);
- var members: SymbolTable = {};
+ let properties = getPropertiesOfObjectType(type);
+ let members: SymbolTable = {};
forEach(properties, p => {
- var propType = getTypeOfSymbol(p);
- var widenedType = getWidenedType(propType);
+ let propType = getTypeOfSymbol(p);
+ let widenedType = getWidenedType(propType);
if (propType !== widenedType) {
- var symbol = createSymbol(p.flags | SymbolFlags.Transient, p.name);
+ let symbol = createSymbol(p.flags | SymbolFlags.Transient, p.name);
symbol.declarations = p.declarations;
symbol.parent = p.parent;
symbol.type = widenedType;
@@ -4412,8 +4413,8 @@ module ts {
}
members[p.name] = p;
});
- var stringIndexType = getIndexTypeOfType(type, IndexKind.String);
- var numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
+ let stringIndexType = getIndexTypeOfType(type, IndexKind.String);
+ let numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
if (stringIndexType) stringIndexType = getWidenedType(stringIndexType);
if (numberIndexType) numberIndexType = getWidenedType(numberIndexType);
return createAnonymousType(type.symbol, members, emptyArray, emptyArray, stringIndexType, numberIndexType);
@@ -4439,7 +4440,7 @@ module ts {
function reportWideningErrorsInType(type: Type): boolean {
if (type.flags & TypeFlags.Union) {
- var errorReported = false;
+ let errorReported = false;
forEach((type).types, t => {
if (reportWideningErrorsInType(t)) {
errorReported = true;
@@ -4451,9 +4452,9 @@ module ts {
return reportWideningErrorsInType((type).typeArguments[0]);
}
if (type.flags & TypeFlags.ObjectLiteral) {
- var errorReported = false;
+ let errorReported = false;
forEach(getPropertiesOfObjectType(type), p => {
- var t = getTypeOfSymbol(p);
+ let t = getTypeOfSymbol(p);
if (t.flags & TypeFlags.ContainsUndefinedOrNull) {
if (!reportWideningErrorsInType(t)) {
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t)));
@@ -4467,7 +4468,7 @@ module ts {
}
function reportImplicitAnyError(declaration: Declaration, type: Type) {
- var typeAsString = typeToString(getWidenedType(type));
+ let typeAsString = typeToString(getWidenedType(type));
switch (declaration.kind) {
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
@@ -4507,9 +4508,9 @@ module ts {
}
function forEachMatchingParameterType(source: Signature, target: Signature, callback: (s: Type, t: Type) => void) {
- var sourceMax = source.parameters.length;
- var targetMax = target.parameters.length;
- var count: number;
+ let sourceMax = source.parameters.length;
+ let targetMax = target.parameters.length;
+ let count: number;
if (source.hasRestParameter && target.hasRestParameter) {
count = sourceMax > targetMax ? sourceMax : targetMax;
sourceMax--;
@@ -4526,15 +4527,15 @@ module ts {
else {
count = sourceMax < targetMax ? sourceMax : targetMax;
}
- for (var i = 0; i < count; i++) {
- var s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
- var t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
+ for (let i = 0; i < count; i++) {
+ let s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
+ let t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
callback(s, t);
}
}
function createInferenceContext(typeParameters: TypeParameter[], inferUnionTypes: boolean): InferenceContext {
- var inferences: TypeInferences[] = [];
+ let inferences: TypeInferences[] = [];
for (let unused of typeParameters) {
inferences.push({ primary: undefined, secondary: undefined });
}
@@ -4548,14 +4549,14 @@ module ts {
}
function inferTypes(context: InferenceContext, source: Type, target: Type) {
- var sourceStack: Type[];
- var targetStack: Type[];
- var depth = 0;
- var inferiority = 0;
+ let sourceStack: Type[];
+ let targetStack: Type[];
+ let depth = 0;
+ let inferiority = 0;
inferFromTypes(source, target);
function isInProcess(source: Type, target: Type) {
- for (var i = 0; i < depth; i++) {
+ for (let i = 0; i < depth; i++) {
if (source === sourceStack[i] && target === targetStack[i]) {
return true;
}
@@ -4565,10 +4566,10 @@ module ts {
function isWithinDepthLimit(type: Type, stack: Type[]) {
if (depth >= 5) {
- var target = (type).target;
- var count = 0;
- for (var i = 0; i < depth; i++) {
- var t = stack[i];
+ let target = (type).target;
+ let count = 0;
+ for (let i = 0; i < depth; i++) {
+ let t = stack[i];
if (t.flags & TypeFlags.Reference && (t).target === target) {
count++;
}
@@ -4584,11 +4585,11 @@ module ts {
}
if (target.flags & TypeFlags.TypeParameter) {
// If target is a type parameter, make an inference
- var typeParameters = context.typeParameters;
- for (var i = 0; i < typeParameters.length; i++) {
+ let typeParameters = context.typeParameters;
+ for (let i = 0; i < typeParameters.length; i++) {
if (target === typeParameters[i]) {
- var inferences = context.inferences[i];
- var candidates = inferiority ?
+ let inferences = context.inferences[i];
+ let candidates = inferiority ?
inferences.secondary || (inferences.secondary = []) :
inferences.primary || (inferences.primary = []);
if (!contains(candidates, source)) candidates.push(source);
@@ -4598,16 +4599,16 @@ module ts {
}
else if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) {
// If source and target are references to the same generic type, infer from type arguments
- var sourceTypes = (source).typeArguments;
- var targetTypes = (target).typeArguments;
- for (var i = 0; i < sourceTypes.length; i++) {
+ let sourceTypes = (source).typeArguments;
+ let targetTypes = (target).typeArguments;
+ for (let i = 0; i < sourceTypes.length; i++) {
inferFromTypes(sourceTypes[i], targetTypes[i]);
}
}
else if (target.flags & TypeFlags.Union) {
- var targetTypes = (target).types;
- var typeParameterCount = 0;
- var typeParameter: TypeParameter;
+ let targetTypes = (target).types;
+ let typeParameterCount = 0;
+ let typeParameter: TypeParameter;
// First infer to each type in union that isn't a type parameter
for (let t of targetTypes) {
if (t.flags & TypeFlags.TypeParameter && contains(context.typeParameters, t)) {
@@ -4627,7 +4628,7 @@ module ts {
}
else if (source.flags & TypeFlags.Union) {
// Source is a union type, infer from each consituent type
- var sourceTypes = (source).types;
+ let sourceTypes = (source).types;
for (let sourceType of sourceTypes) {
inferFromTypes(sourceType, target);
}
@@ -4655,9 +4656,9 @@ module ts {
}
function inferFromProperties(source: Type, target: Type) {
- var properties = getPropertiesOfObjectType(target);
+ let properties = getPropertiesOfObjectType(target);
for (let targetProp of properties) {
- var sourceProp = getPropertyOfObjectType(source, targetProp.name);
+ let sourceProp = getPropertyOfObjectType(source, targetProp.name);
if (sourceProp) {
inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
}
@@ -4665,12 +4666,12 @@ module ts {
}
function inferFromSignatures(source: Type, target: Type, kind: SignatureKind) {
- var sourceSignatures = getSignaturesOfType(source, kind);
- var targetSignatures = getSignaturesOfType(target, kind);
- var sourceLen = sourceSignatures.length;
- var targetLen = targetSignatures.length;
- var len = sourceLen < targetLen ? sourceLen : targetLen;
- for (var i = 0; i < len; i++) {
+ let sourceSignatures = getSignaturesOfType(source, kind);
+ let targetSignatures = getSignaturesOfType(target, kind);
+ let sourceLen = sourceSignatures.length;
+ let targetLen = targetSignatures.length;
+ let len = sourceLen < targetLen ? sourceLen : targetLen;
+ for (let i = 0; i < len; i++) {
inferFromSignature(getErasedSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
}
}
@@ -4681,9 +4682,9 @@ module ts {
}
function inferFromIndexTypes(source: Type, target: Type, sourceKind: IndexKind, targetKind: IndexKind) {
- var targetIndexType = getIndexTypeOfType(target, targetKind);
+ let targetIndexType = getIndexTypeOfType(target, targetKind);
if (targetIndexType) {
- var sourceIndexType = getIndexTypeOfType(source, sourceKind);
+ let sourceIndexType = getIndexTypeOfType(source, sourceKind);
if (sourceIndexType) {
inferFromTypes(sourceIndexType, targetIndexType);
}
@@ -4692,17 +4693,17 @@ module ts {
}
function getInferenceCandidates(context: InferenceContext, index: number): Type[] {
- var inferences = context.inferences[index];
+ let inferences = context.inferences[index];
return inferences.primary || inferences.secondary || emptyArray;
}
function getInferredType(context: InferenceContext, index: number): Type {
- var inferredType = context.inferredTypes[index];
+ let inferredType = context.inferredTypes[index];
if (!inferredType) {
- var inferences = getInferenceCandidates(context, index);
+ let inferences = getInferenceCandidates(context, index);
if (inferences.length) {
// Infer widened union or supertype, or the undefined type for no common supertype
- var unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
+ let unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : inferenceFailureType;
}
else {
@@ -4710,7 +4711,7 @@ module ts {
inferredType = emptyObjectType;
}
if (inferredType !== inferenceFailureType) {
- var constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
+ let constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
inferredType = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType;
}
context.inferredTypes[index] = inferredType;
@@ -4719,7 +4720,7 @@ module ts {
}
function getInferredTypes(context: InferenceContext): Type[] {
- for (var i = 0; i < context.inferredTypes.length; i++) {
+ for (let i = 0; i < context.inferredTypes.length; i++) {
getInferredType(context, i);
}
@@ -4733,7 +4734,7 @@ module ts {
// EXPRESSION TYPE CHECKING
function getResolvedSymbol(node: Identifier): Symbol {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (!links.resolvedSymbol) {
links.resolvedSymbol = (getFullWidth(node) > 0 && resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, node)) || unknownSymbol;
}
@@ -4763,10 +4764,10 @@ module ts {
// or not of the given type kind (when isOfTypeKind is false)
function removeTypesFromUnionType(type: Type, typeKind: TypeFlags, isOfTypeKind: boolean, allowEmptyUnionResult: boolean): Type {
if (type.flags & TypeFlags.Union) {
- var types = (type).types;
+ let types = (type).types;
if (forEach(types, t => !!(t.flags & typeKind) === isOfTypeKind)) {
// Above we checked if we have anything to remove, now use the opposite test to do the removal
- var narrowedType = getUnionType(filter(types, t => !(t.flags & typeKind) === isOfTypeKind));
+ let narrowedType = getUnionType(filter(types, t => !(t.flags & typeKind) === isOfTypeKind));
if (allowEmptyUnionResult || narrowedType !== emptyObjectType) {
return narrowedType;
}
@@ -4786,9 +4787,9 @@ module ts {
// Check if a given variable is assigned within a given syntax node
function isVariableAssignedWithin(symbol: Symbol, node: Node): boolean {
- var links = getNodeLinks(node);
+ let links = getNodeLinks(node);
if (links.assignmentChecks) {
- var cachedResult = links.assignmentChecks[symbol.id];
+ let cachedResult = links.assignmentChecks[symbol.id];
if (cachedResult !== undefined) {
return cachedResult;
}
@@ -4800,7 +4801,7 @@ module ts {
function isAssignedInBinaryExpression(node: BinaryExpression) {
if (node.operatorToken.kind >= SyntaxKind.FirstAssignment && node.operatorToken.kind <= SyntaxKind.LastAssignment) {
- var n = node.left;
+ let n = node.left;
while (n.kind === SyntaxKind.ParenthesizedExpression) {
n = (n).expression;
}
@@ -4869,8 +4870,8 @@ module ts {
function resolveLocation(node: Node) {
// Resolve location from top down towards node if it is a context sensitive expression
// That helps in making sure not assigning types as any when resolved out of order
- var containerNodes: Node[] = [];
- for (var parent = node.parent; parent; parent = parent.parent) {
+ let containerNodes: Node[] = [];
+ for (let parent = node.parent; parent; parent = parent.parent) {
if ((isExpression(parent) || isObjectLiteralMethod(node)) &&
isContextSensitive(parent)) {
containerNodes.unshift(parent);
@@ -4909,13 +4910,13 @@ module ts {
// Get the narrowed type of a given symbol at a given location
function getNarrowedTypeOfSymbol(symbol: Symbol, node: Node) {
- var type = getTypeOfSymbol(symbol);
+ let type = getTypeOfSymbol(symbol);
// Only narrow when symbol is variable of type any or an object, union, or type parameter type
if (node && symbol.flags & SymbolFlags.Variable && type.flags & (TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) {
loop: while (node.parent) {
- var child = node;
+ let child = node;
node = node.parent;
- var narrowedType = type;
+ let narrowedType = type;
switch (node.kind) {
case SyntaxKind.IfStatement:
// In a branch of an if statement, narrow based on controlling expression
@@ -4967,12 +4968,12 @@ module ts {
if (expr.left.kind !== SyntaxKind.TypeOfExpression || expr.right.kind !== SyntaxKind.StringLiteral) {
return type;
}
- var left = expr.left;
- var right = expr.right;
+ let left = expr.left;
+ let right = expr.right;
if (left.expression.kind !== SyntaxKind.Identifier || getResolvedSymbol(left.expression) !== symbol) {
return type;
}
- var typeInfo = primitiveTypeInfo[right.text];
+ let typeInfo = primitiveTypeInfo[right.text];
if (expr.operatorToken.kind === SyntaxKind.ExclamationEqualsEqualsToken) {
assumeTrue = !assumeTrue;
}
@@ -5036,16 +5037,16 @@ module ts {
return type;
}
// Check that right operand is a function type with a prototype property
- var rightType = checkExpression(expr.right);
+ let rightType = checkExpression(expr.right);
if (!isTypeSubtypeOf(rightType, globalFunctionType)) {
return type;
}
// Target type is type of prototype property
- var prototypeProperty = getPropertyOfType(rightType, "prototype");
+ let prototypeProperty = getPropertyOfType(rightType, "prototype");
if (!prototypeProperty) {
return type;
}
- var targetType = getTypeOfSymbol(prototypeProperty);
+ let targetType = getTypeOfSymbol(prototypeProperty);
// Narrow to target type if it is a subtype of current type
if (isTypeSubtypeOf(targetType, type)) {
return targetType;
@@ -5064,7 +5065,7 @@ module ts {
case SyntaxKind.ParenthesizedExpression:
return narrowType(type, (expr).expression, assumeTrue);
case SyntaxKind.BinaryExpression:
- var operator = (expr).operatorToken.kind;
+ let operator = (expr).operatorToken.kind;
if (operator === SyntaxKind.EqualsEqualsEqualsToken || operator === SyntaxKind.ExclamationEqualsEqualsToken) {
return narrowTypeByEquality(type, expr, assumeTrue);
}
@@ -5089,7 +5090,7 @@ module ts {
}
function checkIdentifier(node: Identifier): Type {
- var symbol = getResolvedSymbol(node);
+ let symbol = getResolvedSymbol(node);
// As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects.
// Although in down-level emit of arrow function, we emit it using function expression which means that
@@ -5113,7 +5114,7 @@ module ts {
}
function isInsideFunction(node: Node, threshold: Node): boolean {
- var current = node;
+ let current = node;
while (current && current !== threshold) {
if (isFunctionLike(current)) {
return true;
@@ -5137,7 +5138,7 @@ module ts {
// nesting structure:
// (variable declaration or binding element) -> variable declaration list -> container
- var container: Node = symbol.valueDeclaration;
+ let container: Node = symbol.valueDeclaration;
while (container.kind !== SyntaxKind.VariableDeclarationList) {
container = container.parent;
}
@@ -5148,9 +5149,9 @@ module ts {
container = container.parent;
}
- var inFunction = isInsideFunction(node.parent, container);
+ let inFunction = isInsideFunction(node.parent, container);
- var current = container;
+ let current = container;
while (current && !nodeStartsNewLexicalEnvironment(current)) {
if (isIterationStatement(current, /*lookInLabeledStatements*/ false)) {
if (inFunction) {
@@ -5165,7 +5166,7 @@ module ts {
}
function captureLexicalThis(node: Node, container: Node): void {
- var classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined;
+ let classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined;
getNodeLinks(node).flags |= NodeCheckFlags.LexicalThis;
if (container.kind === SyntaxKind.PropertyDeclaration || container.kind === SyntaxKind.Constructor) {
getNodeLinks(classNode).flags |= NodeCheckFlags.CaptureThis;
@@ -5178,8 +5179,8 @@ module ts {
function checkThisExpression(node: Node): Type {
// Stop at the first arrow function so that we can
// tell whether 'this' needs to be captured.
- var container = getThisContainer(node, /* includeArrowFunctions */ true);
- var needToCaptureLexicalThis = false;
+ let container = getThisContainer(node, /* includeArrowFunctions */ true);
+ let needToCaptureLexicalThis = false;
// Now skip arrow functions to get the "real" owner of 'this'.
if (container.kind === SyntaxKind.ArrowFunction) {
@@ -5220,16 +5221,16 @@ module ts {
captureLexicalThis(node, container);
}
- var classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined;
+ let classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined;
if (classNode) {
- var symbol = getSymbolOfNode(classNode);
+ let symbol = getSymbolOfNode(classNode);
return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol);
}
return anyType;
}
function isInConstructorArgumentInitializer(node: Node, constructorDecl: Node): boolean {
- for (var n = node; n && n !== constructorDecl; n = n.parent) {
+ for (let n = node; n && n !== constructorDecl; n = n.parent) {
if (n.kind === SyntaxKind.Parameter) {
return true;
}
@@ -5238,11 +5239,11 @@ module ts {
}
function checkSuperExpression(node: Node): Type {
- var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (node.parent).expression === node;
- var enclosingClass = getAncestor(node, SyntaxKind.ClassDeclaration);
- var baseClass: Type;
+ let isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (node.parent).expression === node;
+ let enclosingClass = getAncestor(node, SyntaxKind.ClassDeclaration);
+ let baseClass: Type;
if (enclosingClass && getClassBaseTypeNode(enclosingClass)) {
- var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass));
+ let classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass));
baseClass = classType.baseTypes.length && classType.baseTypes[0];
}
@@ -5251,10 +5252,10 @@ module ts {
return unknownType;
}
- var container = getSuperContainer(node, /*includeFunctions*/ true);
+ let container = getSuperContainer(node, /*includeFunctions*/ true);
if (container) {
- var canUseSuperExpression = false;
+ let canUseSuperExpression = false;
if (isCallExpression) {
// TS 1.0 SPEC (April 2014): 4.8.1
// Super calls are only permitted in constructors of derived classes
@@ -5296,7 +5297,7 @@ module ts {
}
if (canUseSuperExpression) {
- var returnType: Type;
+ let returnType: Type;
if ((container.flags & NodeFlags.Static) || isCallExpression) {
getNodeLinks(node).flags |= NodeCheckFlags.SuperStatic;
@@ -5340,14 +5341,14 @@ module ts {
// Return contextual type of parameter or undefined if no contextual type is available
function getContextuallyTypedParameterType(parameter: ParameterDeclaration): Type {
if (isFunctionExpressionOrArrowFunction(parameter.parent)) {
- var func = parameter.parent;
+ let func = parameter.parent;
if (isContextSensitive(func)) {
- var contextualSignature = getContextualSignature(func);
+ let contextualSignature = getContextualSignature(func);
if (contextualSignature) {
- var funcHasRestParameters = hasRestParameters(func);
- var len = func.parameters.length - (funcHasRestParameters ? 1 : 0);
- var indexOfParameter = indexOf(func.parameters, parameter);
+ let funcHasRestParameters = hasRestParameters(func);
+ let len = func.parameters.length - (funcHasRestParameters ? 1 : 0);
+ let indexOfParameter = indexOf(func.parameters, parameter);
if (indexOfParameter < len) {
return getTypeAtPosition(contextualSignature, indexOfParameter);
}
@@ -5369,13 +5370,13 @@ module ts {
// of the parameter. Otherwise, in a variable or parameter declaration with a binding pattern name, the contextual
// type of an initializer expression is the type implied by the binding pattern.
function getContextualTypeForInitializerExpression(node: Expression): Type {
- var declaration = node.parent;
+ let declaration = node.parent;
if (node === declaration.initializer) {
if (declaration.type) {
return getTypeFromTypeNode(declaration.type);
}
if (declaration.kind === SyntaxKind.Parameter) {
- var type = getContextuallyTypedParameterType(declaration);
+ let type = getContextuallyTypedParameterType(declaration);
if (type) {
return type;
}
@@ -5388,7 +5389,7 @@ module ts {
}
function getContextualTypeForReturnExpression(node: Expression): Type {
- var func = getContainingFunction(node);
+ let func = getContainingFunction(node);
if (func) {
// If the containing function has a return type annotation, is a constructor, or is a get accessor whose
// corresponding set accessor has a type annotation, return statements in the function are contextually typed
@@ -5397,7 +5398,7 @@ module ts {
}
// Otherwise, if the containing function is contextually typed by a function type with exactly one call signature
// and that call signature is non-generic, return statements are contextually typed by the return type of the signature
- var signature = getContextualSignatureForFunctionLikeDeclaration(func);
+ let signature = getContextualSignatureForFunctionLikeDeclaration(func);
if (signature) {
return getReturnTypeOfSignature(signature);
}
@@ -5407,10 +5408,10 @@ module ts {
// In a typed function call, an argument or substitution expression is contextually typed by the type of the corresponding parameter.
function getContextualTypeForArgument(callTarget: CallLikeExpression, arg: Expression): Type {
- var args = getEffectiveCallArguments(callTarget);
- var argIndex = indexOf(args, arg);
+ let args = getEffectiveCallArguments(callTarget);
+ let argIndex = indexOf(args, arg);
if (argIndex >= 0) {
- var signature = getResolvedSignature(callTarget);
+ let signature = getResolvedSignature(callTarget);
return getTypeAtPosition(signature, argIndex);
}
return undefined;
@@ -5425,8 +5426,8 @@ module ts {
}
function getContextualTypeForBinaryOperand(node: Expression): Type {
- var binaryExpression = node.parent;
- var operator = binaryExpression.operatorToken.kind;
+ let binaryExpression = node.parent;
+ let operator = binaryExpression.operatorToken.kind;
if (operator >= SyntaxKind.FirstAssignment && operator <= SyntaxKind.LastAssignment) {
// In an assignment expression, the right operand is contextually typed by the type of the left operand.
if (node === binaryExpression.right) {
@@ -5436,7 +5437,7 @@ module ts {
else if (operator === SyntaxKind.BarBarToken) {
// When an || expression has a contextual type, the operands are contextually typed by that type. When an ||
// expression has no contextual type, the right operand is contextually typed by the type of the left operand.
- var type = getContextualType(binaryExpression);
+ let type = getContextualType(binaryExpression);
if (!type && node === binaryExpression.right) {
type = checkExpression(binaryExpression.left);
}
@@ -5452,11 +5453,11 @@ module ts {
if (!(type.flags & TypeFlags.Union)) {
return mapper(type);
}
- var types = (type).types;
- var mappedType: Type;
- var mappedTypes: Type[];
+ let types = (type).types;
+ let mappedType: Type;
+ let mappedTypes: Type[];
for (let current of types) {
- var t = mapper(current);
+ let t = mapper(current);
if (t) {
if (!mappedType) {
mappedType = t;
@@ -5474,7 +5475,7 @@ module ts {
function getTypeOfPropertyOfContextualType(type: Type, name: string) {
return applyToContextualType(type, t => {
- var prop = getPropertyOfObjectType(t, name);
+ let prop = getPropertyOfObjectType(t, name);
return prop ? getTypeOfSymbol(prop) : undefined;
});
}
@@ -5507,15 +5508,15 @@ module ts {
}
function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElement) {
- var objectLiteral = element.parent;
- var type = getContextualType(objectLiteral);
+ let objectLiteral = element.parent;
+ let type = getContextualType(objectLiteral);
if (type) {
if (!hasDynamicName(element)) {
// For a (non-symbol) computed property, there is no reason to look up the name
// in the type. It will just be "__computed", which does not appear in any
// SymbolTable.
- var symbolName = getSymbolOfNode(element).name;
- var propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
+ let symbolName = getSymbolOfNode(element).name;
+ let propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
if (propertyType) {
return propertyType;
}
@@ -5533,10 +5534,10 @@ module ts {
// it is the type of the numeric index signature in T. Otherwise, in ES6 and higher, the contextual type is the iterated
// type of T.
function getContextualTypeForElementExpression(node: Expression): Type {
- var arrayLiteral = node.parent;
- var type = getContextualType(arrayLiteral);
+ let arrayLiteral = node.parent;
+ let type = getContextualType(arrayLiteral);
if (type) {
- var index = indexOf(arrayLiteral.elements, node);
+ let index = indexOf(arrayLiteral.elements, node);
return getTypeOfPropertyOfContextualType(type, "" + index)
|| getIndexTypeOfContextualType(type, IndexKind.Number)
|| (languageVersion >= ScriptTarget.ES6 ? checkIteratedType(type, /*expressionForError*/ undefined) : undefined);
@@ -5546,7 +5547,7 @@ module ts {
// In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type.
function getContextualTypeForConditionalOperand(node: Expression): Type {
- var conditional = node.parent;
+ let conditional = node.parent;
return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined;
}
@@ -5560,7 +5561,7 @@ module ts {
if (node.contextualType) {
return node.contextualType;
}
- var parent = node.parent;
+ let parent = node.parent;
switch (parent.kind) {
case SyntaxKind.VariableDeclaration:
case SyntaxKind.Parameter:
@@ -5596,9 +5597,9 @@ module ts {
// If the given type is an object or union type, if that type has a single signature, and if
// that signature is non-generic, return the signature. Otherwise return undefined.
function getNonGenericSignature(type: Type): Signature {
- var signatures = getSignaturesOfObjectOrUnionType(type, SignatureKind.Call);
+ let signatures = getSignaturesOfObjectOrUnionType(type, SignatureKind.Call);
if (signatures.length === 1) {
- var signature = signatures[0];
+ let signature = signatures[0];
if (!signature.typeParameters) {
return signature;
}
@@ -5621,7 +5622,7 @@ module ts {
// union type of return types from these signatures
function getContextualSignature(node: FunctionExpression | MethodDeclaration): Signature {
Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
- var type = isObjectLiteralMethod(node)
+ let type = isObjectLiteralMethod(node)
? getContextualTypeForObjectLiteralMethod(node)
: getContextualType(node);
if (!type) {
@@ -5630,8 +5631,8 @@ module ts {
if (!(type.flags & TypeFlags.Union)) {
return getNonGenericSignature(type);
}
- var signatureList: Signature[];
- var types = (type).types;
+ let signatureList: Signature[];
+ let types = (type).types;
for (let current of types) {
// The signature set of all constituent type with call signatures should match
// So number of signatures allowed is either 0 or 1
@@ -5640,7 +5641,7 @@ module ts {
return undefined;
}
- var signature = getNonGenericSignature(current);
+ let signature = getNonGenericSignature(current);
if (signature) {
if (!signatureList) {
// This signature will contribute to contextual union signature
@@ -5658,7 +5659,7 @@ module ts {
}
// Result is union of signatures collected (return type is union of return types of this signature set)
- var result: Signature;
+ let result: Signature;
if (signatureList) {
result = cloneSignature(signatureList[0]);
// Clear resolved return type we possibly got from cloneSignature
@@ -5678,7 +5679,7 @@ module ts {
// assignment in an object literal that is an assignment target, or if it is parented by an array literal that is
// an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'.
function isAssignmentTarget(node: Node): boolean {
- var parent = node.parent;
+ let parent = node.parent;
if (parent.kind === SyntaxKind.BinaryExpression && (parent).operatorToken.kind === SyntaxKind.EqualsToken && (parent).left === node) {
return true;
}
@@ -5692,7 +5693,7 @@ module ts {
}
function checkSpreadElementExpression(node: SpreadElementExpression, contextualMapper?: TypeMapper): Type {
- var type = checkExpressionCached(node.expression, contextualMapper);
+ let type = checkExpressionCached(node.expression, contextualMapper);
if (!isArrayLikeType(type)) {
error(node.expression, Diagnostics.Type_0_is_not_an_array_type, typeToString(type));
return unknownType;
@@ -5701,14 +5702,14 @@ module ts {
}
function checkArrayLiteral(node: ArrayLiteralExpression, contextualMapper?: TypeMapper): Type {
- var elements = node.elements;
+ let elements = node.elements;
if (!elements.length) {
return createArrayType(undefinedType);
}
- var hasSpreadElement: boolean = false;
- var elementTypes: Type[] = [];
+ let hasSpreadElement: boolean = false;
+ let elementTypes: Type[] = [];
forEach(elements, e => {
- var type = checkExpression(e, contextualMapper);
+ let type = checkExpression(e, contextualMapper);
if (e.kind === SyntaxKind.SpreadElementExpression) {
elementTypes.push(getIndexTypeOfType(type, IndexKind.Number) || anyType);
hasSpreadElement = true;
@@ -5718,7 +5719,7 @@ module ts {
}
});
if (!hasSpreadElement) {
- var contextualType = getContextualType(node);
+ let contextualType = getContextualType(node);
if (contextualType && contextualTypeIsTupleLikeType(contextualType) || isAssignmentTarget(node)) {
return createTupleType(elementTypes);
}
@@ -5762,7 +5763,7 @@ module ts {
}
function checkComputedPropertyName(node: ComputedPropertyName): Type {
- var links = getNodeLinks(node.expression);
+ let links = getNodeLinks(node.expression);
if (!links.resolvedType) {
links.resolvedType = checkExpression(node.expression);
@@ -5783,13 +5784,13 @@ module ts {
// Grammar checking
checkGrammarObjectLiteralExpression(node);
- var propertiesTable: SymbolTable = {};
- var propertiesArray: Symbol[] = [];
- var contextualType = getContextualType(node);
- var typeFlags: TypeFlags;
+ let propertiesTable: SymbolTable = {};
+ let propertiesArray: Symbol[] = [];
+ let contextualType = getContextualType(node);
+ let typeFlags: TypeFlags;
for (let memberDecl of node.properties) {
- var member = memberDecl.symbol;
+ let member = memberDecl.symbol;
if (memberDecl.kind === SyntaxKind.PropertyAssignment ||
memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment ||
isObjectLiteralMethod(memberDecl)) {
@@ -5806,7 +5807,7 @@ module ts {
: checkExpression(memberDecl.name, contextualMapper);
}
typeFlags |= type.flags;
- var prop = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
+ let prop = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
prop.declarations = member.declarations;
prop.parent = member.parent;
if (member.valueDeclaration) {
@@ -5833,29 +5834,29 @@ module ts {
propertiesArray.push(member);
}
- var stringIndexType = getIndexType(IndexKind.String);
- var numberIndexType = getIndexType(IndexKind.Number);
- var result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
+ let stringIndexType = getIndexType(IndexKind.String);
+ let numberIndexType = getIndexType(IndexKind.Number);
+ let result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
return result;
function getIndexType(kind: IndexKind) {
if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) {
- var propTypes: Type[] = [];
- for (var i = 0; i < propertiesArray.length; i++) {
- var propertyDecl = node.properties[i];
+ let propTypes: Type[] = [];
+ for (let i = 0; i < propertiesArray.length; i++) {
+ let propertyDecl = node.properties[i];
if (kind === IndexKind.String || isNumericName(propertyDecl.name)) {
// Do not call getSymbolOfNode(propertyDecl), as that will get the
// original symbol for the node. We actually want to get the symbol
// created by checkObjectLiteral, since that will be appropriately
// contextually typed and resolved.
- var type = getTypeOfSymbol(propertiesArray[i]);
+ let type = getTypeOfSymbol(propertiesArray[i]);
if (!contains(propTypes, type)) {
propTypes.push(type);
}
}
}
- var result = propTypes.length ? getUnionType(propTypes) : undefinedType;
+ let result = propTypes.length ? getUnionType(propTypes) : undefinedType;
typeFlags |= result.flags;
return result;
}
@@ -5874,16 +5875,16 @@ module ts {
}
function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol) {
- var flags = getDeclarationFlagsFromSymbol(prop);
+ let flags = getDeclarationFlagsFromSymbol(prop);
// Public properties are always accessible
if (!(flags & (NodeFlags.Private | NodeFlags.Protected))) {
return;
}
// Property is known to be private or protected at this point
// Get the declaring and enclosing class instance types
- var enclosingClassDeclaration = getAncestor(node, SyntaxKind.ClassDeclaration);
- var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
- var declaringClass = getDeclaredTypeOfSymbol(prop.parent);
+ let enclosingClassDeclaration = getAncestor(node, SyntaxKind.ClassDeclaration);
+ let enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
+ let declaringClass = getDeclaredTypeOfSymbol(prop.parent);
// Private property is accessible if declaring and enclosing class are the same
if (flags & NodeFlags.Private) {
if (declaringClass !== enclosingClass) {
@@ -5920,15 +5921,15 @@ module ts {
}
function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier) {
- var type = checkExpressionOrQualifiedName(left);
+ let type = checkExpressionOrQualifiedName(left);
if (type === unknownType) return type;
if (type !== anyType) {
- var apparentType = getApparentType(getWidenedType(type));
+ let apparentType = getApparentType(getWidenedType(type));
if (apparentType === unknownType) {
// handle cases when type is Type parameter with invalid constraint
return unknownType;
}
- var prop = getPropertyOfType(apparentType, right.text);
+ let prop = getPropertyOfType(apparentType, right.text);
if (!prop) {
if (right.text) {
error(right, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(right), typeToString(type));
@@ -5957,19 +5958,19 @@ module ts {
}
function isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean {
- var left = node.kind === SyntaxKind.PropertyAccessExpression
+ let left = node.kind === SyntaxKind.PropertyAccessExpression
? (node).expression
: (node).left;
- var type = checkExpressionOrQualifiedName(left);
+ let type = checkExpressionOrQualifiedName(left);
if (type !== unknownType && type !== anyType) {
- var prop = getPropertyOfType(getWidenedType(type), propertyName);
+ let prop = getPropertyOfType(getWidenedType(type), propertyName);
if (prop && prop.parent && prop.parent.flags & SymbolFlags.Class) {
if (left.kind === SyntaxKind.SuperKeyword && getDeclarationKindFromSymbol(prop) !== SyntaxKind.MethodDeclaration) {
return false;
}
else {
- var modificationCount = diagnostics.getModificationCount();
+ let modificationCount = diagnostics.getModificationCount();
checkClassPropertyAccess(node, left, type, prop);
return diagnostics.getModificationCount() === modificationCount;
}
@@ -5981,28 +5982,28 @@ module ts {
function checkIndexedAccess(node: ElementAccessExpression): Type {
// Grammar checking
if (!node.argumentExpression) {
- var sourceFile = getSourceFile(node);
+ let sourceFile = getSourceFile(node);
if (node.parent.kind === SyntaxKind.NewExpression && (node.parent).expression === node) {
- var start = skipTrivia(sourceFile.text, node.expression.end);
- var end = node.end;
+ let start = skipTrivia(sourceFile.text, node.expression.end);
+ let end = node.end;
grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
}
else {
- var start = node.end - "]".length;
- var end = node.end;
+ let start = node.end - "]".length;
+ let end = node.end;
grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Expression_expected);
}
}
// Obtain base constraint such that we can bail out if the constraint is an unknown type
- var objectType = getApparentType(checkExpression(node.expression));
- var indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType;
+ let objectType = getApparentType(checkExpression(node.expression));
+ let indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType;
if (objectType === unknownType) {
return unknownType;
}
- var isConstEnum = isConstEnumObjectType(objectType);
+ let isConstEnum = isConstEnumObjectType(objectType);
if (isConstEnum &&
(!node.argumentExpression || node.argumentExpression.kind !== SyntaxKind.StringLiteral)) {
error(node.argumentExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
@@ -6020,9 +6021,9 @@ module ts {
// See if we can index as a property.
if (node.argumentExpression) {
- var name = getPropertyNameForIndexedAccess(node.argumentExpression, indexType);
+ let name = getPropertyNameForIndexedAccess(node.argumentExpression, indexType);
if (name !== undefined) {
- var prop = getPropertyOfType(objectType, name);
+ let prop = getPropertyOfType(objectType, name);
if (prop) {
getNodeLinks(node).resolvedSymbol = prop;
return getTypeOfSymbol(prop);
@@ -6039,14 +6040,14 @@ module ts {
// Try to use a number indexer.
if (allConstituentTypesHaveKind(indexType, TypeFlags.Any | TypeFlags.NumberLike)) {
- var numberIndexType = getIndexTypeOfType(objectType, IndexKind.Number);
+ let numberIndexType = getIndexTypeOfType(objectType, IndexKind.Number);
if (numberIndexType) {
return numberIndexType;
}
}
// Try to use string indexing.
- var stringIndexType = getIndexTypeOfType(objectType, IndexKind.String);
+ let stringIndexType = getIndexTypeOfType(objectType, IndexKind.String);
if (stringIndexType) {
return stringIndexType;
}
@@ -6076,7 +6077,7 @@ module ts {
return (indexArgumentExpression).text;
}
if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, /*reportError*/ false)) {
- var rightHandSideName = ((indexArgumentExpression).name).text;
+ let rightHandSideName = ((indexArgumentExpression).name).text;
return getPropertyNameForKnownSymbolName(rightHandSideName);
}
@@ -6110,13 +6111,13 @@ module ts {
// The name is Symbol., so make sure Symbol actually resolves to the
// global Symbol object
- var leftHandSide = (expression).expression;
- var leftHandSideSymbol = getResolvedSymbol(leftHandSide);
+ let leftHandSide = (expression).expression;
+ let leftHandSideSymbol = getResolvedSymbol(leftHandSide);
if (!leftHandSideSymbol) {
return false;
}
- var globalESSymbol = getGlobalESSymbolConstructorSymbol();
+ let globalESSymbol = getGlobalESSymbolConstructorSymbol();
if (!globalESSymbol) {
// Already errored when we tried to look up the symbol
return false;
@@ -6155,19 +6156,19 @@ module ts {
// so order how inherited signatures are processed is still preserved.
// interface A { (x: string): void }
// interface B extends A { (x: 'foo'): string }
- // var b: B;
+ // let b: B;
// b('foo') // <- here overloads should be processed as [(x:'foo'): string, (x: string): void]
function reorderCandidates(signatures: Signature[], result: Signature[]): void {
- var lastParent: Node;
- var lastSymbol: Symbol;
- var cutoffIndex: number = 0;
- var index: number;
- var specializedIndex: number = -1;
- var spliceIndex: number;
+ let lastParent: Node;
+ let lastSymbol: Symbol;
+ let cutoffIndex: number = 0;
+ let index: number;
+ let specializedIndex: number = -1;
+ let spliceIndex: number;
Debug.assert(!result.length);
for (let signature of signatures) {
- var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
- var parent = signature.declaration && signature.declaration.parent;
+ let symbol = signature.declaration && getSymbolOfNode(signature.declaration);
+ let parent = signature.declaration && signature.declaration.parent;
if (!lastSymbol || symbol === lastSymbol) {
if (lastParent && parent === lastParent) {
index++;
@@ -6204,7 +6205,7 @@ module ts {
}
function getSpreadArgumentIndex(args: Expression[]): number {
- for (var i = 0; i < args.length; i++) {
+ for (let i = 0; i < args.length; i++) {
if (args[i].kind === SyntaxKind.SpreadElementExpression) {
return i;
}
@@ -6213,12 +6214,12 @@ module ts {
}
function hasCorrectArity(node: CallLikeExpression, args: Expression[], signature: Signature) {
- var adjustedArgCount: number; // Apparent number of arguments we will have in this call
- var typeArguments: NodeArray; // Type arguments (undefined if none)
- var callIsIncomplete: boolean; // In incomplete call we want to be lenient when we have too few arguments
+ let adjustedArgCount: number; // Apparent number of arguments we will have in this call
+ let typeArguments: NodeArray; // Type arguments (undefined if none)
+ let callIsIncomplete: boolean; // In incomplete call we want to be lenient when we have too few arguments
if (node.kind === SyntaxKind.TaggedTemplateExpression) {
- var tagExpression = node;
+ let tagExpression = node;
// Even if the call is incomplete, we'll have a missing expression as our last argument,
// so we can say the count is just the arg list length
@@ -6228,8 +6229,8 @@ module ts {
if (tagExpression.template.kind === SyntaxKind.TemplateExpression) {
// If a tagged template expression lacks a tail literal, the call is incomplete.
// Specifically, a template only can end in a TemplateTail or a Missing literal.
- var templateExpression = tagExpression.template;
- var lastSpan = lastOrUndefined(templateExpression.templateSpans);
+ let templateExpression = tagExpression.template;
+ let lastSpan = lastOrUndefined(templateExpression.templateSpans);
Debug.assert(lastSpan !== undefined); // we should always have at least one span.
callIsIncomplete = getFullWidth(lastSpan.literal) === 0 || !!lastSpan.literal.isUnterminated;
}
@@ -6237,13 +6238,13 @@ module ts {
// If the template didn't end in a backtick, or its beginning occurred right prior to EOF,
// then this might actually turn out to be a TemplateHead in the future;
// so we consider the call to be incomplete.
- var templateLiteral = tagExpression.template;
+ let templateLiteral = tagExpression.template;
Debug.assert(templateLiteral.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
callIsIncomplete = !!templateLiteral.isUnterminated;
}
}
else {
- var callExpression = node;
+ let callExpression =