From 99368d96db1396ca0e4cfffdb815e9b1cfa5e91e Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Sat, 18 Feb 2023 01:24:19 +0000 Subject: [PATCH 1/2] Swap shared pre-initialized closure state in checker to `var` to avoid TDZ checks. --- src/compiler/checker.ts | 552 ++++++++++++++++++++-------------------- 1 file changed, 277 insertions(+), 275 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 307dcc7aee13b..79f6111f1dc37 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1378,12 +1378,13 @@ export function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums /** @internal */ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { - const getPackagesMap = memoize(() => { + /* eslint-disable no-var */ + var getPackagesMap = memoize(() => { // A package name maps to true when we detect it has .d.ts files. // This is useful as an approximation of whether a package bundles its own types. // Note: we only look at files already found by module resolution, // so there may be files we did not consider. - const map = new Map(); + var map = new Map(); host.getSourceFiles().forEach(sf => { if (!sf.resolvedModules) return; @@ -1394,9 +1395,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return map; }); - let deferredDiagnosticsCallbacks: (() => void)[] = []; + var deferredDiagnosticsCallbacks: (() => void)[] = []; - let addLazyDiagnostic = (arg: () => void) => { + var addLazyDiagnostic = (arg: () => void) => { deferredDiagnosticsCallbacks.push(arg); }; @@ -1409,65 +1410,65 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // Currently we only support setting the cancellation token when getting diagnostics. This // is because diagnostics can be quite expensive, and we want to allow hosts to bail out if // they no longer need the information (for example, if the user started editing again). - let cancellationToken: CancellationToken | undefined; - - const requestedExternalEmitHelperNames = new Set(); - let requestedExternalEmitHelpers: ExternalEmitHelpers; - let externalHelpersModule: Symbol; - - const Symbol = objectAllocator.getSymbolConstructor(); - const Type = objectAllocator.getTypeConstructor(); - const Signature = objectAllocator.getSignatureConstructor(); - - let typeCount = 0; - let symbolCount = 0; - let totalInstantiationCount = 0; - let instantiationCount = 0; - let instantiationDepth = 0; - let inlineLevel = 0; - let currentNode: Node | undefined; - let varianceTypeParameter: TypeParameter | undefined; - let isInferencePartiallyBlocked = false; - - const emptySymbols = createSymbolTable(); - const arrayVariances = [VarianceFlags.Covariant]; - - const compilerOptions = host.getCompilerOptions(); - const languageVersion = getEmitScriptTarget(compilerOptions); - const moduleKind = getEmitModuleKind(compilerOptions); - const legacyDecorators = !!compilerOptions.experimentalDecorators; - const useDefineForClassFields = getUseDefineForClassFields(compilerOptions); - const allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions); - const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks"); - const strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes"); - const strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply"); - const strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization"); - const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny"); - const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis"); - const useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); - const keyofStringsOnly = !!compilerOptions.keyofStringsOnly; - const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : ObjectFlags.FreshLiteral; - const exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes; - - const checkBinaryExpression = createCheckBinaryExpression(); - const emitResolver = createResolver(); - const nodeBuilder = createNodeBuilder(); - - const globals = createSymbolTable(); - const undefinedSymbol = createSymbol(SymbolFlags.Property, "undefined" as __String); + var cancellationToken: CancellationToken | undefined; + + var requestedExternalEmitHelperNames = new Set(); + var requestedExternalEmitHelpers: ExternalEmitHelpers; + var externalHelpersModule: Symbol; + + var Symbol = objectAllocator.getSymbolConstructor(); + var Type = objectAllocator.getTypeConstructor(); + var Signature = objectAllocator.getSignatureConstructor(); + + var typeCount = 0; + var symbolCount = 0; + var totalInstantiationCount = 0; + var instantiationCount = 0; + var instantiationDepth = 0; + var inlineLevel = 0; + var currentNode: Node | undefined; + var varianceTypeParameter: TypeParameter | undefined; + var isInferencePartiallyBlocked = false; + + var emptySymbols = createSymbolTable(); + var arrayVariances = [VarianceFlags.Covariant]; + + var compilerOptions = host.getCompilerOptions(); + var languageVersion = getEmitScriptTarget(compilerOptions); + var moduleKind = getEmitModuleKind(compilerOptions); + var legacyDecorators = !!compilerOptions.experimentalDecorators; + var useDefineForClassFields = getUseDefineForClassFields(compilerOptions); + var allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions); + var strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks"); + var strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes"); + var strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply"); + var strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization"); + var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny"); + var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis"); + var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); + var keyofStringsOnly = !!compilerOptions.keyofStringsOnly; + var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : ObjectFlags.FreshLiteral; + var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes; + + var checkBinaryExpression = createCheckBinaryExpression(); + var emitResolver = createResolver(); + var nodeBuilder = createNodeBuilder(); + + var globals = createSymbolTable(); + var undefinedSymbol = createSymbol(SymbolFlags.Property, "undefined" as __String); undefinedSymbol.declarations = []; - const globalThisSymbol = createSymbol(SymbolFlags.Module, "globalThis" as __String, CheckFlags.Readonly); + var globalThisSymbol = createSymbol(SymbolFlags.Module, "globalThis" as __String, CheckFlags.Readonly); globalThisSymbol.exports = globals; globalThisSymbol.declarations = []; globals.set(globalThisSymbol.escapedName, globalThisSymbol); - const argumentsSymbol = createSymbol(SymbolFlags.Property, "arguments" as __String); - const requireSymbol = createSymbol(SymbolFlags.Property, "require" as __String); - const isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules"; + var argumentsSymbol = createSymbol(SymbolFlags.Property, "arguments" as __String); + var requireSymbol = createSymbol(SymbolFlags.Property, "require" as __String); + var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules"; /** This will be set during calls to `getResolvedSignature` where services determines an apparent number of arguments greater than what is actually provided. */ - let apparentArgumentCount: number | undefined; + var apparentArgumentCount: number | undefined; // for public members that accept a Node or one of its subtypes, we must guard against // synthetic nodes created during transformations by calling `getParseTreeNode`. @@ -1863,56 +1864,56 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return res; } - const tupleTypes = new Map(); - const unionTypes = new Map(); - const intersectionTypes = new Map(); - const stringLiteralTypes = new Map(); - const numberLiteralTypes = new Map(); - const bigIntLiteralTypes = new Map(); - const enumLiteralTypes = new Map(); - const indexedAccessTypes = new Map(); - const templateLiteralTypes = new Map(); - const stringMappingTypes = new Map(); - const substitutionTypes = new Map(); - const subtypeReductionCache = new Map(); - const decoratorContextOverrideTypeCache = new Map(); - const cachedTypes = new Map(); - const evolvingArrayTypes: EvolvingArrayType[] = []; - const undefinedProperties: SymbolTable = new Map(); - const markerTypes = new Set(); - - const unknownSymbol = createSymbol(SymbolFlags.Property, "unknown" as __String); - const resolvingSymbol = createSymbol(0, InternalSymbolName.Resolving); - const unresolvedSymbols = new Map(); - const errorTypes = new Map(); + var tupleTypes = new Map(); + var unionTypes = new Map(); + var intersectionTypes = new Map(); + var stringLiteralTypes = new Map(); + var numberLiteralTypes = new Map(); + var bigIntLiteralTypes = new Map(); + var enumLiteralTypes = new Map(); + var indexedAccessTypes = new Map(); + var templateLiteralTypes = new Map(); + var stringMappingTypes = new Map(); + var substitutionTypes = new Map(); + var subtypeReductionCache = new Map(); + var decoratorContextOverrideTypeCache = new Map(); + var cachedTypes = new Map(); + var evolvingArrayTypes: EvolvingArrayType[] = []; + var undefinedProperties: SymbolTable = new Map(); + var markerTypes = new Set(); + + var unknownSymbol = createSymbol(SymbolFlags.Property, "unknown" as __String); + var resolvingSymbol = createSymbol(0, InternalSymbolName.Resolving); + var unresolvedSymbols = new Map(); + var errorTypes = new Map(); // We specifically create the `undefined` and `null` types before any other types that can occur in // unions such that they are given low type IDs and occur first in the sorted list of union constituents. // We can then just examine the first constituent(s) of a union to check for their presence. - const anyType = createIntrinsicType(TypeFlags.Any, "any"); - const autoType = createIntrinsicType(TypeFlags.Any, "any", ObjectFlags.NonInferrableType); - const wildcardType = createIntrinsicType(TypeFlags.Any, "any"); - const errorType = createIntrinsicType(TypeFlags.Any, "error"); - const unresolvedType = createIntrinsicType(TypeFlags.Any, "unresolved"); - const nonInferrableAnyType = createIntrinsicType(TypeFlags.Any, "any", ObjectFlags.ContainsWideningType); - const intrinsicMarkerType = createIntrinsicType(TypeFlags.Any, "intrinsic"); - const unknownType = createIntrinsicType(TypeFlags.Unknown, "unknown"); - const nonNullUnknownType = createIntrinsicType(TypeFlags.Unknown, "unknown"); - const undefinedType = createIntrinsicType(TypeFlags.Undefined, "undefined"); - const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(TypeFlags.Undefined, "undefined", ObjectFlags.ContainsWideningType); - const missingType = createIntrinsicType(TypeFlags.Undefined, "undefined"); - const undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType; - const optionalType = createIntrinsicType(TypeFlags.Undefined, "undefined"); - const nullType = createIntrinsicType(TypeFlags.Null, "null"); - const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(TypeFlags.Null, "null", ObjectFlags.ContainsWideningType); - const stringType = createIntrinsicType(TypeFlags.String, "string"); - const numberType = createIntrinsicType(TypeFlags.Number, "number"); - const bigintType = createIntrinsicType(TypeFlags.BigInt, "bigint"); - const falseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false") as FreshableIntrinsicType; - const regularFalseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false") as FreshableIntrinsicType; - const trueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true") as FreshableIntrinsicType; - const regularTrueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true") as FreshableIntrinsicType; + var anyType = createIntrinsicType(TypeFlags.Any, "any"); + var autoType = createIntrinsicType(TypeFlags.Any, "any", ObjectFlags.NonInferrableType); + var wildcardType = createIntrinsicType(TypeFlags.Any, "any"); + var errorType = createIntrinsicType(TypeFlags.Any, "error"); + var unresolvedType = createIntrinsicType(TypeFlags.Any, "unresolved"); + var nonInferrableAnyType = createIntrinsicType(TypeFlags.Any, "any", ObjectFlags.ContainsWideningType); + var intrinsicMarkerType = createIntrinsicType(TypeFlags.Any, "intrinsic"); + var unknownType = createIntrinsicType(TypeFlags.Unknown, "unknown"); + var nonNullUnknownType = createIntrinsicType(TypeFlags.Unknown, "unknown"); + var undefinedType = createIntrinsicType(TypeFlags.Undefined, "undefined"); + var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(TypeFlags.Undefined, "undefined", ObjectFlags.ContainsWideningType); + var missingType = createIntrinsicType(TypeFlags.Undefined, "undefined"); + var undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType; + var optionalType = createIntrinsicType(TypeFlags.Undefined, "undefined"); + var nullType = createIntrinsicType(TypeFlags.Null, "null"); + var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(TypeFlags.Null, "null", ObjectFlags.ContainsWideningType); + var stringType = createIntrinsicType(TypeFlags.String, "string"); + var numberType = createIntrinsicType(TypeFlags.Number, "number"); + var bigintType = createIntrinsicType(TypeFlags.BigInt, "bigint"); + var falseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false") as FreshableIntrinsicType; + var regularFalseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false") as FreshableIntrinsicType; + var trueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true") as FreshableIntrinsicType; + var regularTrueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true") as FreshableIntrinsicType; trueType.regularType = regularTrueType; trueType.freshType = trueType; regularTrueType.regularType = regularTrueType; @@ -1921,92 +1922,92 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { falseType.freshType = falseType; regularFalseType.regularType = regularFalseType; regularFalseType.freshType = falseType; - const booleanType = getUnionType([regularFalseType, regularTrueType]); - const esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol"); - const voidType = createIntrinsicType(TypeFlags.Void, "void"); - const neverType = createIntrinsicType(TypeFlags.Never, "never"); - const silentNeverType = createIntrinsicType(TypeFlags.Never, "never", ObjectFlags.NonInferrableType); - const implicitNeverType = createIntrinsicType(TypeFlags.Never, "never"); - const unreachableNeverType = createIntrinsicType(TypeFlags.Never, "never"); - const nonPrimitiveType = createIntrinsicType(TypeFlags.NonPrimitive, "object"); - const stringOrNumberType = getUnionType([stringType, numberType]); - const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]); - const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType; - const numberOrBigIntType = getUnionType([numberType, bigintType]); - const templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]) as UnionType; - const numericStringType = getTemplateLiteralType(["", ""], [numberType]); // The `${number}` type - - const restrictiveMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? getRestrictiveTypeParameter(t as TypeParameter) : t, () => "(restrictive mapper)"); - const permissiveMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? wildcardType : t, () => "(permissive mapper)"); - const uniqueLiteralType = createIntrinsicType(TypeFlags.Never, "never"); // `uniqueLiteralType` is a special `never` flagged by union reduction to behave as a literal - const uniqueLiteralMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? uniqueLiteralType : t, () => "(unique literal mapper)"); // replace all type parameters with the unique literal type (disregarding constraints) - let outofbandVarianceMarkerHandler: ((onlyUnreliable: boolean) => void) | undefined; - const reportUnreliableMapper = makeFunctionTypeMapper(t => { + var booleanType = getUnionType([regularFalseType, regularTrueType]); + var esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol"); + var voidType = createIntrinsicType(TypeFlags.Void, "void"); + var neverType = createIntrinsicType(TypeFlags.Never, "never"); + var silentNeverType = createIntrinsicType(TypeFlags.Never, "never", ObjectFlags.NonInferrableType); + var implicitNeverType = createIntrinsicType(TypeFlags.Never, "never"); + var unreachableNeverType = createIntrinsicType(TypeFlags.Never, "never"); + var nonPrimitiveType = createIntrinsicType(TypeFlags.NonPrimitive, "object"); + var stringOrNumberType = getUnionType([stringType, numberType]); + var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]); + var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType; + var numberOrBigIntType = getUnionType([numberType, bigintType]); + var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]) as UnionType; + var numericStringType = getTemplateLiteralType(["", ""], [numberType]); // The `${number}` type + + var restrictiveMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? getRestrictiveTypeParameter(t as TypeParameter) : t, () => "(restrictive mapper)"); + var permissiveMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? wildcardType : t, () => "(permissive mapper)"); + var uniqueLiteralType = createIntrinsicType(TypeFlags.Never, "never"); // `uniqueLiteralType` is a special `never` flagged by union reduction to behave as a literal + var uniqueLiteralMapper: TypeMapper = makeFunctionTypeMapper(t => t.flags & TypeFlags.TypeParameter ? uniqueLiteralType : t, () => "(unique literal mapper)"); // replace all type parameters with the unique literal type (disregarding constraints) + var outofbandVarianceMarkerHandler: ((onlyUnreliable: boolean) => void) | undefined; + var reportUnreliableMapper = makeFunctionTypeMapper(t => { if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) { outofbandVarianceMarkerHandler(/*onlyUnreliable*/ true); } return t; }, () => "(unmeasurable reporter)"); - const reportUnmeasurableMapper = makeFunctionTypeMapper(t => { + var reportUnmeasurableMapper = makeFunctionTypeMapper(t => { if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) { outofbandVarianceMarkerHandler(/*onlyUnreliable*/ false); } return t; }, () => "(unreliable reporter)"); - const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); - const emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); emptyJsxObjectType.objectFlags |= ObjectFlags.JsxAttributes; - const emptyTypeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, InternalSymbolName.Type); + var emptyTypeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, InternalSymbolName.Type); emptyTypeLiteralSymbol.members = createSymbolTable(); - const emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray); + var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray); - const unknownEmptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); - const unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType; + var unknownEmptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType; - const emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray) as ObjectType as GenericType; + var emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray) as ObjectType as GenericType; emptyGenericType.instantiations = new Map(); - const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes. anyFunctionType.objectFlags |= ObjectFlags.NonInferrableType; - const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); - const circularConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); - const resolvingDefaultType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var circularConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); + var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray); - const markerSuperType = createTypeParameter(); - const markerSubType = createTypeParameter(); + var markerSuperType = createTypeParameter(); + var markerSubType = createTypeParameter(); markerSubType.constraint = markerSuperType; - const markerOtherType = createTypeParameter(); + var markerOtherType = createTypeParameter(); - const markerSuperTypeForCheck = createTypeParameter(); - const markerSubTypeForCheck = createTypeParameter(); + var markerSuperTypeForCheck = createTypeParameter(); + var markerSubTypeForCheck = createTypeParameter(); markerSubTypeForCheck.constraint = markerSuperTypeForCheck; - const noTypePredicate = createTypePredicate(TypePredicateKind.Identifier, "<>", 0, anyType); + var noTypePredicate = createTypePredicate(TypePredicateKind.Identifier, "<>", 0, anyType); - const anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); - const unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, errorType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); - const resolvingSignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); - const silentNeverSignature = createSignature(undefined, undefined, undefined, emptyArray, silentNeverType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); + var anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); + var unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, errorType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); + var resolvingSignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); + var silentNeverSignature = createSignature(undefined, undefined, undefined, emptyArray, silentNeverType, /*resolvedTypePredicate*/ undefined, 0, SignatureFlags.None); - const enumNumberIndexInfo = createIndexInfo(numberType, stringType, /*isReadonly*/ true); + var enumNumberIndexInfo = createIndexInfo(numberType, stringType, /*isReadonly*/ true); - const iterationTypesCache = new Map(); // cache for common IterationTypes instances - const noIterationTypes: IterationTypes = { + var iterationTypesCache = new Map(); // cache for common IterationTypes instances + var noIterationTypes: IterationTypes = { get yieldType(): Type { return Debug.fail("Not supported"); }, get returnType(): Type { return Debug.fail("Not supported"); }, get nextType(): Type { return Debug.fail("Not supported"); }, }; - const anyIterationTypes = createIterationTypes(anyType, anyType, anyType); - const anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType); - const defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType); // default iteration types for `Iterator`. + var anyIterationTypes = createIterationTypes(anyType, anyType, anyType); + var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType); + var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType); // default iteration types for `Iterator`. - const asyncIterationTypesResolver: IterationTypesResolver = { + var asyncIterationTypesResolver: IterationTypesResolver = { iterableCacheKey: "iterationTypesOfAsyncIterable", iteratorCacheKey: "iterationTypesOfAsyncIterator", iteratorSymbolName: "asyncIterator", @@ -2020,7 +2021,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property, }; - const syncIterationTypesResolver: IterationTypesResolver = { + var syncIterationTypesResolver: IterationTypesResolver = { iterableCacheKey: "iterationTypesOfIterable", iteratorCacheKey: "iterationTypesOfIterator", iteratorSymbolName: "iterator", @@ -2046,145 +2047,145 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { readonly conflictingSymbols: Map; } /** Key is "/path/to/a.ts|/path/to/b.ts". */ - let amalgamatedDuplicates: Map | undefined; - const reverseMappedCache = new Map(); - let inInferTypeForHomomorphicMappedType = false; - let ambientModulesCache: Symbol[] | undefined; + var amalgamatedDuplicates: Map | undefined; + var reverseMappedCache = new Map(); + var inInferTypeForHomomorphicMappedType = false; + var ambientModulesCache: Symbol[] | undefined; /** * List of every ambient module with a "*" wildcard. * Unlike other ambient modules, these can't be stored in `globals` because symbol tables only deal with exact matches. * This is only used if there is no exact match. */ - let patternAmbientModules: PatternAmbientModule[]; - let patternAmbientModuleAugmentations: Map | undefined; - - let globalObjectType: ObjectType; - let globalFunctionType: ObjectType; - let globalCallableFunctionType: ObjectType; - let globalNewableFunctionType: ObjectType; - let globalArrayType: GenericType; - let globalReadonlyArrayType: GenericType; - let globalStringType: ObjectType; - let globalNumberType: ObjectType; - let globalBooleanType: ObjectType; - let globalRegExpType: ObjectType; - let globalThisType: GenericType; - let anyArrayType: Type; - let autoArrayType: Type; - let anyReadonlyArrayType: Type; - let deferredGlobalNonNullableTypeAlias: Symbol; + var patternAmbientModules: PatternAmbientModule[]; + var patternAmbientModuleAugmentations: Map | undefined; + + var globalObjectType: ObjectType; + var globalFunctionType: ObjectType; + var globalCallableFunctionType: ObjectType; + var globalNewableFunctionType: ObjectType; + var globalArrayType: GenericType; + var globalReadonlyArrayType: GenericType; + var globalStringType: ObjectType; + var globalNumberType: ObjectType; + var globalBooleanType: ObjectType; + var globalRegExpType: ObjectType; + var globalThisType: GenericType; + var anyArrayType: Type; + var autoArrayType: Type; + var anyReadonlyArrayType: Type; + var deferredGlobalNonNullableTypeAlias: Symbol; // The library files are only loaded when the feature is used. // This allows users to just specify library files they want to used through --lib // and they will not get an error from not having unrelated library files - let deferredGlobalESSymbolConstructorSymbol: Symbol | undefined; - let deferredGlobalESSymbolConstructorTypeSymbol: Symbol | undefined; - let deferredGlobalESSymbolType: ObjectType | undefined; - let deferredGlobalTypedPropertyDescriptorType: GenericType; - let deferredGlobalPromiseType: GenericType | undefined; - let deferredGlobalPromiseLikeType: GenericType | undefined; - let deferredGlobalPromiseConstructorSymbol: Symbol | undefined; - let deferredGlobalPromiseConstructorLikeType: ObjectType | undefined; - let deferredGlobalIterableType: GenericType | undefined; - let deferredGlobalIteratorType: GenericType | undefined; - let deferredGlobalIterableIteratorType: GenericType | undefined; - let deferredGlobalGeneratorType: GenericType | undefined; - let deferredGlobalIteratorYieldResultType: GenericType | undefined; - let deferredGlobalIteratorReturnResultType: GenericType | undefined; - let deferredGlobalAsyncIterableType: GenericType | undefined; - let deferredGlobalAsyncIteratorType: GenericType | undefined; - let deferredGlobalAsyncIterableIteratorType: GenericType | undefined; - let deferredGlobalAsyncGeneratorType: GenericType | undefined; - let deferredGlobalTemplateStringsArrayType: ObjectType | undefined; - let deferredGlobalImportMetaType: ObjectType; - let deferredGlobalImportMetaExpressionType: ObjectType; - let deferredGlobalImportCallOptionsType: ObjectType | undefined; - let deferredGlobalExtractSymbol: Symbol | undefined; - let deferredGlobalOmitSymbol: Symbol | undefined; - let deferredGlobalAwaitedSymbol: Symbol | undefined; - let deferredGlobalBigIntType: ObjectType | undefined; - let deferredGlobalNaNSymbol: Symbol | undefined; - let deferredGlobalRecordSymbol: Symbol | undefined; - let deferredGlobalClassDecoratorContextType: GenericType | undefined; - let deferredGlobalClassMethodDecoratorContextType: GenericType | undefined; - let deferredGlobalClassGetterDecoratorContextType: GenericType | undefined; - let deferredGlobalClassSetterDecoratorContextType: GenericType | undefined; - let deferredGlobalClassAccessorDecoratorContextType: GenericType | undefined; - let deferredGlobalClassAccessorDecoratorTargetType: GenericType | undefined; - let deferredGlobalClassAccessorDecoratorResultType: GenericType | undefined; - let deferredGlobalClassFieldDecoratorContextType: GenericType | undefined; - - const allPotentiallyUnusedIdentifiers = new Map(); // key is file name - - let flowLoopStart = 0; - let flowLoopCount = 0; - let sharedFlowCount = 0; - let flowAnalysisDisabled = false; - let flowInvocationCount = 0; - let lastFlowNode: FlowNode | undefined; - let lastFlowNodeReachable: boolean; - let flowTypeCache: Type[] | undefined; - - const contextualTypeNodes: Node[] = []; - const contextualTypes: (Type | undefined)[] = []; - const contextualIsCache: boolean[] = []; - let contextualTypeCount = 0; - - const inferenceContextNodes: Node[] = []; - const inferenceContexts: (InferenceContext | undefined)[] = []; - let inferenceContextCount = 0; - - const emptyStringType = getStringLiteralType(""); - const zeroType = getNumberLiteralType(0); - const zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" }); - - const resolutionTargets: TypeSystemEntity[] = []; - const resolutionResults: boolean[] = []; - const resolutionPropertyNames: TypeSystemPropertyName[] = []; - - let suggestionCount = 0; - const maximumSuggestionCount = 10; - const mergedSymbols: Symbol[] = []; - const symbolLinks: SymbolLinks[] = []; - const nodeLinks: NodeLinks[] = []; - const flowLoopCaches: Map[] = []; - const flowLoopNodes: FlowNode[] = []; - const flowLoopKeys: string[] = []; - const flowLoopTypes: Type[][] = []; - const sharedFlowNodes: FlowNode[] = []; - const sharedFlowTypes: FlowType[] = []; - const flowNodeReachable: (boolean | undefined)[] = []; - const flowNodePostSuper: (boolean | undefined)[] = []; - const potentialThisCollisions: Node[] = []; - const potentialNewTargetCollisions: Node[] = []; - const potentialWeakMapSetCollisions: Node[] = []; - const potentialReflectCollisions: Node[] = []; - const potentialUnusedRenamedBindingElementsInTypes: BindingElement[] = []; - const awaitedTypeStack: number[] = []; - - const diagnostics = createDiagnosticCollection(); - const suggestionDiagnostics = createDiagnosticCollection(); - - const typeofType = createTypeofType(); - - let _jsxNamespace: __String; - let _jsxFactoryEntity: EntityName | undefined; - - const subtypeRelation = new Map(); - const strictSubtypeRelation = new Map(); - const assignableRelation = new Map(); - const comparableRelation = new Map(); - const identityRelation = new Map(); - const enumRelation = new Map(); - - const builtinGlobals = createSymbolTable(); + var deferredGlobalESSymbolConstructorSymbol: Symbol | undefined; + var deferredGlobalESSymbolConstructorTypeSymbol: Symbol | undefined; + var deferredGlobalESSymbolType: ObjectType | undefined; + var deferredGlobalTypedPropertyDescriptorType: GenericType; + var deferredGlobalPromiseType: GenericType | undefined; + var deferredGlobalPromiseLikeType: GenericType | undefined; + var deferredGlobalPromiseConstructorSymbol: Symbol | undefined; + var deferredGlobalPromiseConstructorLikeType: ObjectType | undefined; + var deferredGlobalIterableType: GenericType | undefined; + var deferredGlobalIteratorType: GenericType | undefined; + var deferredGlobalIterableIteratorType: GenericType | undefined; + var deferredGlobalGeneratorType: GenericType | undefined; + var deferredGlobalIteratorYieldResultType: GenericType | undefined; + var deferredGlobalIteratorReturnResultType: GenericType | undefined; + var deferredGlobalAsyncIterableType: GenericType | undefined; + var deferredGlobalAsyncIteratorType: GenericType | undefined; + var deferredGlobalAsyncIterableIteratorType: GenericType | undefined; + var deferredGlobalAsyncGeneratorType: GenericType | undefined; + var deferredGlobalTemplateStringsArrayType: ObjectType | undefined; + var deferredGlobalImportMetaType: ObjectType; + var deferredGlobalImportMetaExpressionType: ObjectType; + var deferredGlobalImportCallOptionsType: ObjectType | undefined; + var deferredGlobalExtractSymbol: Symbol | undefined; + var deferredGlobalOmitSymbol: Symbol | undefined; + var deferredGlobalAwaitedSymbol: Symbol | undefined; + var deferredGlobalBigIntType: ObjectType | undefined; + var deferredGlobalNaNSymbol: Symbol | undefined; + var deferredGlobalRecordSymbol: Symbol | undefined; + var deferredGlobalClassDecoratorContextType: GenericType | undefined; + var deferredGlobalClassMethodDecoratorContextType: GenericType | undefined; + var deferredGlobalClassGetterDecoratorContextType: GenericType | undefined; + var deferredGlobalClassSetterDecoratorContextType: GenericType | undefined; + var deferredGlobalClassAccessorDecoratorContextType: GenericType | undefined; + var deferredGlobalClassAccessorDecoratorTargetType: GenericType | undefined; + var deferredGlobalClassAccessorDecoratorResultType: GenericType | undefined; + var deferredGlobalClassFieldDecoratorContextType: GenericType | undefined; + + var allPotentiallyUnusedIdentifiers = new Map(); // key is file name + + var flowLoopStart = 0; + var flowLoopCount = 0; + var sharedFlowCount = 0; + var flowAnalysisDisabled = false; + var flowInvocationCount = 0; + var lastFlowNode: FlowNode | undefined; + var lastFlowNodeReachable: boolean; + var flowTypeCache: Type[] | undefined; + + var contextualTypeNodes: Node[] = []; + var contextualTypes: (Type | undefined)[] = []; + var contextualIsCache: boolean[] = []; + var contextualTypeCount = 0; + + var inferenceContextNodes: Node[] = []; + var inferenceContexts: (InferenceContext | undefined)[] = []; + var inferenceContextCount = 0; + + var emptyStringType = getStringLiteralType(""); + var zeroType = getNumberLiteralType(0); + var zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" }); + + var resolutionTargets: TypeSystemEntity[] = []; + var resolutionResults: boolean[] = []; + var resolutionPropertyNames: TypeSystemPropertyName[] = []; + + var suggestionCount = 0; + var maximumSuggestionCount = 10; + var mergedSymbols: Symbol[] = []; + var symbolLinks: SymbolLinks[] = []; + var nodeLinks: NodeLinks[] = []; + var flowLoopCaches: Map[] = []; + var flowLoopNodes: FlowNode[] = []; + var flowLoopKeys: string[] = []; + var flowLoopTypes: Type[][] = []; + var sharedFlowNodes: FlowNode[] = []; + var sharedFlowTypes: FlowType[] = []; + var flowNodeReachable: (boolean | undefined)[] = []; + var flowNodePostSuper: (boolean | undefined)[] = []; + var potentialThisCollisions: Node[] = []; + var potentialNewTargetCollisions: Node[] = []; + var potentialWeakMapSetCollisions: Node[] = []; + var potentialReflectCollisions: Node[] = []; + var potentialUnusedRenamedBindingElementsInTypes: BindingElement[] = []; + var awaitedTypeStack: number[] = []; + + var diagnostics = createDiagnosticCollection(); + var suggestionDiagnostics = createDiagnosticCollection(); + + var typeofType = createTypeofType(); + + var _jsxNamespace: __String; + var _jsxFactoryEntity: EntityName | undefined; + + var subtypeRelation = new Map(); + var strictSubtypeRelation = new Map(); + var assignableRelation = new Map(); + var comparableRelation = new Map(); + var identityRelation = new Map(); + var enumRelation = new Map(); + + var builtinGlobals = createSymbolTable(); builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol); // Extensions suggested for path imports when module resolution is node16 or higher. // The first element of each tuple is the extension a file has. // The second element of each tuple is the extension that should be used in a path import. // e.g. if we want to import file `foo.mts`, we should write `import {} from "./foo.mjs". - const suggestedExtensions: [string, string][] = [ + var suggestedExtensions: [string, string][] = [ [".mts", ".mjs"], [".ts", ".js"], [".cts", ".cjs"], @@ -2195,6 +2196,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { [".jsx", ".jsx"], [".json", ".json"], ]; + /* eslint-enable no-var */ initializeTypeChecker(); From 0d549c83a360fc7bb9fe9556824fa4a88c4baa13 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 21 Feb 2023 11:02:04 -0800 Subject: [PATCH 2/2] Re-enable `no-var` at the end of the scanner's state. --- src/compiler/scanner.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index b36f16a7a6563..554800e28b9bb 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -1031,8 +1031,7 @@ export function createScanner(languageVersion: ScriptTarget, lookAhead, scanRange, }; - - /* eslint-disable no-var */ + /* eslint-enable no-var */ if (Debug.isDebugging) { Object.defineProperty(scanner, "__debugShowCurrentPositionInText", {