tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/file-loader.js

@@ -2,15 +2,17 @@
  * Finds every file of a program: root files, libraries, references, imports and type directives, in tsgo's order.
  */
 import { ImportDeclaration, ParseOptions, StringLiteral, getText, } from './ast.js';
+import { messageWithArgs } from './diagnostics.js';
 import { FileIncludeReason, IncludeProcessor, ProcessingDiagnostic } from './file-include.js';
 import { ModuleResolutionHost, Resolver, getAutomaticTypeDirectiveNames } from './module-resolution.js';
 import { getResolutionDiagnostic, inferredTypesContainingFile, } from './module-resolution-types.js';
 import { getAllowJS, getIsolatedModules, getModuleResolutionKind, ModuleKind, ModuleResolutionKind, } from './options.js';
 import { isPrepared, preparedLoad, preparedPackageJsonLookups, takePreparedFile, } from './parallel-parse.js';
-import { parseSourceFile } from './parser.js';
+import { parseSourceFile, getScriptKindFromFileName } from './parser.js';
 import { mark } from './timeline.js';
-import { combinePaths, fileExtensionIsOneOf, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getRootLength, hasJSFileExtension, isRootedDiskPath, normalizePath, normalizeSlashes, removeTrailingDirectorySeparator, supportedTSExtensionsWithJsonFlat, toFileNameLowerCase, toPath, } from './path.js';
+import { combinePaths, fileExtensionIsOneOf, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getRootLength, hasJSFileExtension, isRootedDiskPath, normalizePath, normalizeSlashes, removeTrailingDirectorySeparator, supportedTSExtensionsWithJsonFlat, toFileNameLowerCase, toPath, isNetworkPath, } from './path.js';
 import { getDefaultLibFileName, getDefaultResolutionModeForFile, getExternalModuleIndicatorOptions, getImpliedNodeFormatForFile, getJSXImplicitImportBase, getJSXRuntimeImport, getLibFileName, getModeForUsageLocation, isExternalModule, isSourceFileJS, libFileMetadata, libNames, SourceFileMetadata, } from './program-utilities.js';
+import { isSourcePhaseImport } from './ast-utilities.js';
 import { hasExtension } from './vfs-match.js';
 import { ConfigParser, flattenExtensions, getSupportedExtensions, getSupportedExtensionsWithJsonIfResolveJsonModule, } from './tsconfig.js';
 /** Files and services the compiler reads through. */
@@ -58,7 +60,10 @@ export class CompilerHost extends ModuleResolutionHost {
         const text = this.fs.readFile(fileName);
         if (text === undefined)
             return undefined;
-        return parseSourceFile(fileName, text, new ParseOptions(path, 0 /* ScriptKind.Unknown */, externalModuleIndicatorOptions));
+        // A file without a known extension (with allowNonTsExtensions) parses as TypeScript.
+        const kind = getScriptKindFromFileName(fileName);
+        const scriptKind = kind === 0 /* ScriptKind.Unknown */ ? 3 /* ScriptKind.TS */ : kind;
+        return parseSourceFile(fileName, text, new ParseOptions(path, scriptKind, externalModuleIndicatorOptions));
     }
     /** The config of a referenced project, or `undefined` if it can't be read. */
     getResolvedProjectReference(fileName) {
@@ -187,6 +192,8 @@ class ParseTask {
     subTasks = undefined;
     loaded = false;
     startedSubTasks = false;
+    /** A root file name that resolved to no supported file: the task only carries its processing diagnostic. */
+    failedLookup = false;
     metadata = libFileMetadata;
     resolutionsInFile = undefined;
     resolutionsTrace = undefined;
@@ -197,6 +204,8 @@ class ParseTask {
     jsxRuntimeImport = undefined;
     /** The task of the same file name that was loaded instead of this one. */
     loadedTask = undefined;
+    /** The index in `FileLoader.taskData` of the tasks of this task's path, once known; -1 before. */
+    dataIndex = -1;
     /** Whether an import or a type reference directive adds the file (`ProcessedFiles.addedFiles`). */
     byImport;
     constructor(normalizedFilePath, libFile, includeReason, isForAutomaticTypeDirective, increaseDepth, 
@@ -228,9 +237,29 @@ class ParseTask {
     }
 }
 const noData = [];
+/** The resolution of a module the importing file declares itself: none. */
+const locallyDeclaredModule = {
+    resolvedFileName: '',
+    originalPath: '',
+    extension: '',
+    resolvedUsingTsExtension: false,
+    packageId: undefined,
+    isExternalLibraryImport: false,
+    alternateResult: '',
+    resolutionDiagnostics: [],
+};
 /** The tasks of one path, by file name casing. */
 class ParseTaskData {
     tasks = new Map();
+    /** Whether a task of the path is queued (`start`). */
+    queued = false;
+    /** The path's first queued task, the first of `tasks`. */
+    first = undefined;
+    /**
+     * Whether every task of `tasks` is loaded (`run`): then more work of the path does nothing unless it
+     * reaches the path at a lower depth.
+     */
+    settled = false;
     lowestDepth = Number.MAX_SAFE_INTEGER;
     startedSubTasks = false;
     packageId = undefined;
@@ -240,9 +269,10 @@ class ParseTaskData {
     keptCopy = undefined;
     /** The paths the file's imports and type reference directives add, once collected. */
     added = noData;
-    constructor(task) {
-        this.tasks.set(task.normalizedFilePath, task);
-    }
+    /** The file name `collect` reached the path by first, once it did. */
+    collectedName = undefined;
+    /** The path's include reasons, once `collect` found one: the list in `IncludeProcessor.fileIncludeReasons`. */
+    reasons = undefined;
 }
 /** Pending processing of `tasks[index]`. */
 class ParseWork {
@@ -407,7 +437,7 @@ export function needsImportHelpersImportSpecifier(file, options) {
 }
 /** The module `file` imports the JSX runtime from under `options`, or '' if it imports none. */
 export function jsxRuntimeImportOf(file, options) {
-    if (file.scriptKind !== 2 /* ScriptKind.JSX */ && file.scriptKind !== 4 /* ScriptKind.TSX */)
+    if (!isSourceFileJS(file) && file.scriptKind !== 4 /* ScriptKind.TSX */)
         return '';
     return getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
 }
@@ -481,6 +511,9 @@ export class FileLoader {
     supportedExtensionsWithJson;
     maxNodeModuleJsDepth;
     rootTasks = [];
+    /** The tasks of each path, created when a task of the path is first queued or built ahead. */
+    taskData = [];
+    /** The index in `taskData` of each path's tasks. */
     taskDataByPath = new Map();
     /** Work queued by `start`, run last-in first-out like tsgo's single-threaded work group. */
     work = [];
@@ -548,8 +581,11 @@ export class FileLoader {
             if (loaded === undefined)
                 continue;
             const subTasks = this.subTasksOf(loaded);
-            for (const task of subTasks)
+            // Their paths and tasks, found here while threads parse rather than when the walk reaches them.
+            for (const task of subTasks) {
                 task.path = this.toPath(task.normalizedFilePath);
+                task.dataIndex = this.dataIndexOf(task.path);
+            }
             this.subTasksAhead.set(prepared.fileName, new SubTasksAhead(loaded, subTasks));
         }
     }
@@ -616,7 +652,7 @@ export class FileLoader {
     }
     walk() {
         for (let work = this.work.pop(); work !== undefined; work = this.work.pop()) {
-            if (this.walkingAhead && this.parsesUnprepared(work.tasks[work.index], work.data)) {
+            if (this.walkingAhead && !this.elides(work) && this.parsesUnprepared(work.tasks[work.index], work.data)) {
                 this.work.push(work);
                 return;
             }
@@ -631,6 +667,7 @@ export class FileLoader {
      */
     release() {
         this.rootTasks.length = 0;
+        this.taskData.length = 0;
         this.taskDataByPath.clear();
         this.work.length = 0;
         this.subTasksAhead.clear();
@@ -776,6 +813,7 @@ export class FileLoader {
             return;
         }
         const task = new ParseTask(absolute, undefined, reason, false, false, false, undefined);
+        task.failedLookup = true;
         task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
         this.rootTasks.push(task);
     }
@@ -793,17 +831,19 @@ export class FileLoader {
     getSourceFileFromReference(fileName, referenceText, containingFile, reason) {
         const allowNonTsExtensions = this.options.allowNonTsExtensions === true;
         const diagnosticFileName = normalizeSlashes(referenceText);
+        if (isNetworkPath(fileName))
+            return new ReferenceDiagnostic(1195 /* Diagnostics.Network_path_0_is_not_supported */, [diagnosticFileName]);
         const fs = this.host.fs;
         if (hasExtension(fileName)) {
             const canonicalFileName = getCanonicalFileName(fileName, fs.useCaseSensitiveFileNames);
             if (!allowNonTsExtensions && !this.isSupportedExtension(canonicalFileName)) {
                 if (hasJSFileExtension(canonicalFileName)) {
-                    return new ReferenceDiagnostic(1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [diagnosticFileName]);
+                    return new ReferenceDiagnostic(1530 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [diagnosticFileName]);
                 }
-                return new ReferenceDiagnostic(1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [diagnosticFileName, this.supportedExtensionsList()]);
+                return new ReferenceDiagnostic(1241 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [diagnosticFileName, this.supportedExtensionsList()]);
             }
             if (!fs.fileExists(fileName))
-                return new ReferenceDiagnostic(1229 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
+                return new ReferenceDiagnostic(1240 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
             if (reason.isReferencedFile() &&
                 getCanonicalFileName(containingFile, fs.useCaseSensitiveFileNames) === canonicalFileName) {
                 return new ReferenceDiagnostic(3 /* Diagnostics.A_file_cannot_have_a_reference_to_itself */, []);
@@ -813,14 +853,14 @@ export class FileLoader {
         if (allowNonTsExtensions) {
             return fs.fileExists(fileName)
                 ? fileName
-                : new ReferenceDiagnostic(1229 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
+                : new ReferenceDiagnostic(1240 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
         }
         for (const extension of this.supportedExtensions[0]) {
             const candidate = fileName + extension;
             if (fs.fileExists(candidate))
                 return candidate;
         }
-        return new ReferenceDiagnostic(1383 /* Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1 */, [
+        return new ReferenceDiagnostic(1394 /* Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1 */, [
             diagnosticFileName,
             this.supportedExtensionsList(),
         ]);
@@ -876,31 +916,51 @@ export class FileLoader {
     }
     // ---- Loading
     start(tasks, depth) {
+        const taskData = this.taskData;
         for (let i = 0; i < tasks.length; i++) {
             const task = tasks[i];
-            // Sub-tasks built ahead have their paths.
-            if (task.path === '')
-                task.path = this.toPath(task.normalizedFilePath);
-            let data = this.taskDataByPath.get(task.path);
-            const loaded = data !== undefined;
-            if (data === undefined) {
-                data = new ParseTaskData(task);
-                this.taskDataByPath.set(task.path, data);
+            // Sub-tasks built ahead have their paths and tasks.
+            let k = task.dataIndex;
+            if (k < 0) {
+                if (task.path === '')
+                    task.path = this.toPath(task.normalizedFilePath);
+                k = this.dataIndexOf(task.path);
+                task.dataIndex = k;
+            }
+            const data = taskData[k];
+            const loaded = data.queued;
+            if (!loaded) {
+                data.queued = true;
+                data.first = task;
+                data.tasks.set(task.normalizedFilePath, task);
             }
             this.work.push(new ParseWork(tasks, i, data, loaded, depth));
         }
     }
+    /** The index in `taskData` of the tasks of `path`, created if needed. */
+    dataIndexOf(path) {
+        let k = this.taskDataByPath.get(path);
+        if (k === undefined) {
+            k = this.taskData.length;
+            this.taskData.push(new ParseTaskData());
+            this.taskDataByPath.set(path, k);
+        }
+        return k;
+    }
     run(work) {
         const task = work.tasks[work.index];
         const data = work.data;
         let startSubTasks = false;
         if (work.loaded) {
-            const existing = data.tasks.get(task.normalizedFilePath);
+            const name = task.normalizedFilePath;
+            const first = data.first;
+            const existing = first !== undefined && first.normalizedFilePath === name ? first : data.tasks.get(name);
             if (existing !== undefined) {
                 task.loadedTask = existing;
             }
             else {
-                data.tasks.set(task.normalizedFilePath, task);
+                data.tasks.set(name, task);
+                data.settled = false;
                 // A new casing of a file: load its references if another casing's were.
                 startSubTasks = data.startedSubTasks;
             }
@@ -908,7 +968,8 @@ export class FileLoader {
         if (data.packageId === undefined && task.packageId !== undefined)
             data.packageId = task.packageId;
         const depth = task.increaseDepth ? work.depth + 1 : work.depth;
-        if (depth < data.lowestDepth) {
+        const lowered = depth < data.lowestDepth;
+        if (lowered) {
             // Reached at a lower depth than before: load references again.
             data.lowestDepth = depth;
             startSubTasks = true;
@@ -916,6 +977,9 @@ export class FileLoader {
         }
         if (task.elideOnDepth && depth > this.maxNodeModuleJsDepth)
             return;
+        // Most work reaches a path already loaded, at no lower depth.
+        if (data.settled && !startSubTasks)
+            return;
         for (const taskByFileName of data.tasks.values()) {
             let loadSubTasks = startSubTasks;
             if (!taskByFileName.loaded) {
@@ -925,12 +989,23 @@ export class FileLoader {
                     data.startedSubTasks = true;
                 }
             }
-            if (!taskByFileName.startedSubTasks && loadSubTasks) {
+            // A lower depth restarts references already started, which may now be loaded past `maxNodeModuleJsDepth`.
+            // Every file reached from them is at least as deep, so a depth past it changes nothing they load.
+            if (loadSubTasks && ((lowered && depth <= this.maxNodeModuleJsDepth) || !taskByFileName.startedSubTasks)) {
                 taskByFileName.startedSubTasks = true;
                 if (taskByFileName.subTasks !== undefined)
                     this.start(taskByFileName.subTasks, data.lowestDepth);
             }
         }
+        data.settled = true;
+    }
+    /**
+     * Whether `run` drops `work` without loading its file: a JavaScript file past `maxNodeModuleJsDepth`,
+     * which no parse thread prepares, so the walk ahead does not wait for it.
+     */
+    elides(work) {
+        const task = work.tasks[work.index];
+        return task.elideOnDepth && (task.increaseDepth ? work.depth + 1 : work.depth) > this.maxNodeModuleJsDepth;
     }
     /**
      * Whether running the work of `task` (of `data`'s path) may parse a file that parse threads have not
@@ -950,6 +1025,8 @@ export class FileLoader {
             this.loadAutomaticTypeDirectives(task);
             return;
         }
+        if (task.failedLookup)
+            return;
         const redirect = this.mapper.getParseFileRedirect(task.path);
         if (redirect !== '') {
             const redirected = new ParseTask(normalizePath(redirect), task.libFile, task.includeReason, false, false, false, undefined);
@@ -962,8 +1039,8 @@ export class FileLoader {
             const canonicalFileName = getCanonicalFileName(task.normalizedFilePath, fs.useCaseSensitiveFileNames);
             if (!this.isSupportedExtension(canonicalFileName)) {
                 task.addProcessingDiagnostic(hasJSFileExtension(canonicalFileName)
-                    ? ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [task.normalizedFilePath])
-                    : ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [task.normalizedFilePath, this.supportedExtensionsList()]));
+                    ? ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1530 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [task.normalizedFilePath])
+                    : ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1241 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [task.normalizedFilePath, this.supportedExtensionsList()]));
                 return;
             }
         }
@@ -1085,7 +1162,7 @@ export class FileLoader {
                 task.addSubTask(resolved.resolvedFileName, undefined, FileIncludeReason.automaticTypeDirective(name, resolved.packageId), resolved.isExternalLibraryImport, false, resolved.packageId);
             }
             else {
-                task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
+                task.addProcessingDiagnostic(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 828 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
             }
         }
         task.typeResolutionsInFile = resolutions;
@@ -1120,9 +1197,19 @@ export class FileLoader {
         for (let index = 0; index < moduleNames.length; index++) {
             const entry = moduleNames[index];
             const moduleName = getText(entry);
-            if (moduleName === '')
+            // A source phase import loads no module declarations.
+            if (moduleName === '' || isSourcePhaseImport(entry.parent))
                 continue;
             const mode = getModeForUsageLocation(file.fileName, task.metadata, entry, options);
+            // A module the file declares itself (`declare module "m"`) isn't resolved.
+            if (file.ambientModuleNames.includes(moduleName)) {
+                if (options.traceResolution === true)
+                    task
+                        .moduleTraces(true)
+                        .push(messageWithArgs(1319 /* Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1 */, moduleName, file.fileName));
+                resolutions.set(modeAwareKey(moduleName, mode), locallyDeclaredModule);
+                continue;
+            }
             const resolved = this.resolver.resolveModuleName(moduleName, containingFile, mode, redirect?.resolved, task.moduleTraces(this.options.traceResolution === true));
             resolutions.set(modeAwareKey(moduleName, mode), resolved);
             const resolvedFileName = resolved.resolvedFileName;
@@ -1173,7 +1260,7 @@ export class FileLoader {
         const redirectFilesByPath = new Map();
         const packageIdToSourceFile = new Map();
         const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
-        const seen = new Map();
+        const taskData = this.taskData;
         // The paths each file's imports and type reference directives add (the tasks of each path), for
         // `ProcessedFiles.addedFiles`: recorded while collecting visits them, as their files are only known
         // once every file is collected.
@@ -1189,14 +1276,14 @@ export class FileLoader {
                     if (task.loadedTask !== undefined)
                         task = task.loadedTask;
                     if (includeReason !== undefined)
-                        addIncludeReason(includeProcessor, task, includeReason);
+                        addIncludeReason(includeProcessor, taskData, task, includeReason);
                 }
-                const data = this.taskDataByPath.get(task.path);
+                const data = task.dataIndex >= 0 ? taskData[task.dataIndex] : undefined;
                 if (added !== undefined && data !== undefined && byImport)
                     added.push(data);
                 if (!task.loaded || data === undefined)
                     continue;
-                const checkedName = seen.get(data);
+                const checkedName = data.collectedName;
                 if (checkedName !== undefined) {
                     // The same name normalizes the same: only another spelling needs comparing.
                     if (checkCasing &&
@@ -1207,7 +1294,7 @@ export class FileLoader {
                     }
                     continue;
                 }
-                seen.set(data, task.normalizedFilePath);
+                data.collectedName = task.normalizedFilePath;
                 if (tasksSeenByNameIgnoreCase !== undefined) {
                     const lowerCasePath = toFileNameLowerCase(task.path);
                     const existing = tasksSeenByNameIgnoreCase.get(lowerCasePath);
@@ -1259,13 +1346,15 @@ export class FileLoader {
                         includeProcessor.addProcessingDiagnostic(diagnostic);
                     continue;
                 }
-                const path = task.path;
                 for (const diagnostic of task.processingDiagnostics ?? noProcessingDiagnostics)
                     includeProcessor.addProcessingDiagnostic(diagnostic);
                 if (file === undefined) {
                     missingFiles.push(task.normalizedFilePath);
                     continue;
                 }
+                // The program's maps of the file are keyed by the file's own path: lookups by `file.path` then find
+                // the same string, also for a file a parse thread created, whose path is another string than the task's.
+                const path = file.path === task.path ? file.path : task.path;
                 if (task.libFile !== undefined) {
                     libFiles.push(file);
                     libData.set(file, data);
@@ -1336,12 +1425,20 @@ const noPackageJsonLookups = [];
 export function releaseLater(loader) {
     setImmediate(() => loader.release());
 }
-function addIncludeReason(processor, task, reason) {
+function addIncludeReason(processor, taskData, task, reason) {
     const redirected = task.redirectedParseTask;
     if (redirected !== undefined)
-        addIncludeReason(processor, redirected, reason);
-    else if (task.loaded)
-        processor.addReason(task.path, reason);
+        addIncludeReason(processor, taskData, redirected, reason);
+    else if (task.loaded) {
+        // The path's list, without looking the path up for each reference to the file.
+        const data = task.dataIndex >= 0 ? taskData[task.dataIndex] : undefined;
+        if (data === undefined)
+            processor.addReason(task.path, reason);
+        else if (data.reasons !== undefined)
+            data.reasons.push(reason);
+        else
+            data.reasons = processor.addReason(task.path, reason);
+    }
 }
 function createProjectReferenceTasks(paths) {
     const tasks = [];
@@ -1358,7 +1455,7 @@ function withoutRoot(path) {
 /** A specifier of an import the compiler adds, such as `tslib` for `importHelpers`. */
 function createSyntheticImport(text, file) {
     const specifier = new StringLiteral(text, 0 /* TokenFlags.None */);
-    const declaration = new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
+    const declaration = new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
     specifier.parent = declaration;
     declaration.parent = file;
     return specifier;

package/dist/api/compiler/identifier-name.d.ts

@@ -0,0 +1,9 @@
+import type { ProgramLifetime } from '@scriptc/types';
+/**
+ * The text of an identifier. The identifiers a parser's scanner interns with the same text share one
+ * (scanner.ts `IdentifierTable`), and natively an identifier refers to it in 4 bytes.
+ */
+export declare class IdentifierName implements ProgramLifetime {
+    readonly text: string;
+    constructor(text: string);
+}

package/dist/api/compiler/identifier-name.js

@@ -0,0 +1,10 @@
+/**
+ * The text of an identifier. The identifiers a parser's scanner interns with the same text share one
+ * (scanner.ts `IdentifierTable`), and natively an identifier refers to it in 4 bytes.
+ */
+export class IdentifierName {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+}

package/dist/api/compiler/instantiation.d.ts

@@ -38,6 +38,8 @@ export declare class UniqueLiteralMapper extends TypeMapper {
 export declare function combineTypeMappers(c: Checker, m1: TypeMapper | undefined, m2: TypeMapper): TypeMapper;
 export declare function instantiateType(c: Checker, type: Type, mapper: TypeMapper | undefined): Type;
 export declare function instantiateTypeWithAlias(c: Checker, type: Type, mapper: TypeMapper | undefined, alias: TypeAlias | undefined): Type;
+/** `'a', 'b', 'c'`. */
+export declare function quotedAndCommaSeparated(items: readonly string[]): string;
 /** Whether `type` could reference a type parameter we infer for. Cached on the type. */
 export declare function couldContainTypeVariables(c: Checker, type: Type): boolean;
 /** Whether `node` has a reference to `tp` (or one that may be to it, such as a type query). */
@@ -65,6 +67,11 @@ export declare function instantiateSymbol(c: Checker, symbol: Symbol, mapper: Ty
  * is resolved yet, so lazily instantiated members record it when tsgo would instantiate them.
  */
 export declare function keepsSymbolUnderInstantiation(c: Checker, symbol: Symbol, mapper: TypeMapper): boolean;
+/**
+ * Whether the resolved type of `symbol` (and its write type) can't change under instantiation, so that
+ * `instantiateSymbol` keeps it whatever the mapper. Once true, it stays true: types are resolved once.
+ */
+export declare function keepsSymbolTypeUnderInstantiation(c: Checker, symbol: Symbol): boolean;
 /** The instantiated copy of `symbol` that `instantiateSymbol` creates when it doesn't keep it. */
 export declare function newInstantiatedSymbol(c: Checker, symbol: Symbol, mapper: TypeMapper): Symbol;
 /** Conservatively, whether a parameter or member's type can't reference `this`. */