tsc-ts 0.0.6 → 0.0.8

package/dist/api/compiler/checker-modules.js

@@ -57,7 +57,78 @@ export function resolveExternalModuleNameWorker(c, location, moduleReference, mo
         return undefined;
     return resolveExternalModule(c, location, getText(moduleReference), moduleNotFoundError, ignoreErrors ? undefined : moduleReference, isForAugmentation);
 }
+/** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
+export class ModuleResolution {
+    moduleReference;
+    moduleNotFoundError;
+    isForAugmentation;
+    symbol;
+    constructor(moduleReference, moduleNotFoundError, isForAugmentation, symbol) {
+        this.moduleReference = moduleReference;
+        this.moduleNotFoundError = moduleNotFoundError;
+        this.isForAugmentation = isForAugmentation;
+        this.symbol = symbol;
+    }
+}
+/**
+ * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
+ * `errorNode`. Each name an import or export declaration lists resolves its module specifier again,
+ * with the same result and the same diagnostics: a result that reported nothing is kept for the
+ * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
+ */
 export function resolveExternalModule(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+    // An augmentation merged later can give the resolved module a new merged symbol, so results are
+    // kept only once every augmentation is merged.
+    const shared = c.modulesMerged && errorNode !== undefined && sharesSpecifierContext(location, errorNode);
+    if (shared) {
+        const known = c.moduleResolutions.get(errorNode);
+        if (known !== undefined &&
+            known.moduleReference === moduleReference &&
+            known.moduleNotFoundError === moduleNotFoundError &&
+            known.isForAugmentation === isForAugmentation)
+            return known.symbol;
+    }
+    const reports = c.reports;
+    const symbol = resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation);
+    if (shared && c.reports === reports)
+        c.moduleResolutions.set(errorNode, new ModuleResolution(moduleReference, moduleNotFoundError, isForAugmentation, symbol));
+    return symbol;
+}
+/**
+ * Whether a resolution from `location` with errors at `errorNode` depends on `location` only through
+ * the declaration that `errorNode` is the module specifier of: `location` is that declaration, a
+ * clause or specifier inside it, or the specifier itself. The resolution mode, the emittability of
+ * the import and its resolution-mode attributes then all come from that declaration.
+ */
+function sharesSpecifierContext(location, errorNode) {
+    const declaration = errorNode.parent;
+    if (declaration === undefined ||
+        (declaration.kind !== 273 /* SyntaxKind.ImportDeclaration */ &&
+            declaration.kind !== 346 /* SyntaxKind.JSImportDeclaration */ &&
+            declaration.kind !== 279 /* SyntaxKind.ExportDeclaration */) ||
+        getModuleSpecifier(declaration) !== errorNode)
+        return false;
+    for (let current = location; current !== undefined; current = current.parent)
+        switch (current.kind) {
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                return current === declaration;
+            case 274 /* SyntaxKind.ImportClause */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 280 /* SyntaxKind.NamedExports */:
+            case 281 /* SyntaxKind.NamespaceExport */:
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                break;
+            default:
+                if (current !== errorNode)
+                    return false;
+        }
+    return false;
+}
+function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
     if (errorNode !== undefined && moduleReference.startsWith('@types/'))
         c.error(errorNode, 1302 /* Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1 */, moduleReference.substring(7), moduleReference);
     const ambient = tryFindAmbientModule(c, moduleReference, true);
@@ -490,7 +561,8 @@ function isOnlyImportableAsDefault(c, usage, resolvedModule) {
     const moduleSymbol = resolvedModule ?? resolveExternalModuleName(c, usage, usage, true);
     const targetFile = moduleSymbol !== undefined ? getSourceFileOfModuleSymbol(moduleSymbol) : undefined;
     return (targetFile !== undefined &&
-        (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts'));
+        (isJsonSourceFile(targetFile) ||
+            (targetFile.fileName.endsWith('.d.json.ts') && getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts')));
 }
 /** The source file that declares a module: its value declaration, or its first declaration that is not an augmentation. */
 function getSourceFileOfModuleSymbol(symbol) {

package/dist/api/compiler/checker-symbol-types.js

@@ -26,7 +26,7 @@ import { getTypeForBindingElement, getTypeFromBindingPattern } from './checker-d
 import { checkRightHandSideOfForOf } from './checker-statements.js';
 import { getTypeWithFacts, hasTypeFacts, getNonNullableType } from './checker-flow.js';
 import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
-import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
+import { copyDeclarations, declarationAt, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 export function getTypeOfSymbol(c, symbol) {
     const checkFlags = symbol.checkFlags;
     if ((checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
@@ -748,11 +748,11 @@ export function isReadonlySymbol(c, symbol) {
             (getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* NodeFlags.Constant */) !== 0) ||
         ((symbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0 && (symbol.flags & 65536 /* SymbolFlags.SetAccessor */) === 0) ||
         (symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0 ||
-        someReadonlyAssignmentDeclaration(c, getDeclarations(symbol)));
+        someReadonlyAssignmentDeclaration(c, symbol));
 }
-function someReadonlyAssignmentDeclaration(c, declarations) {
-    for (const d of declarations)
-        if (isReadonlyAssignmentDeclaration(c, d))
+function someReadonlyAssignmentDeclaration(c, symbol) {
+    for (let i = 0; i < declarationCount(symbol); i++)
+        if (isReadonlyAssignmentDeclaration(c, declarationAt(symbol, i)))
             return true;
     return false;
 }

package/dist/api/compiler/checker-symbols.js

@@ -1459,9 +1459,11 @@ export function symbolIsValue(c, symbol) {
 function isDeclarationContainedBy(symbol, container) {
     const declaration = symbol.valueDeclaration;
     if (declaration !== undefined)
-        for (const d of getDeclarations(container))
+        for (let i = 0; i < declarationCount(container); i++) {
+            const d = declarationAt(container, i);
             if (declaration.pos >= d.pos && declaration.end <= d.end)
                 return true;
+        }
     return false;
 }
 /** Value members other than signatures and index signatures, declared ones first, each part ordered by declaration. */

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

@@ -6,6 +6,7 @@ import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.j
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { IndexInfo, IntrinsicType, LiteralType, MemberNames, NodeLinks, ObjectFlags, ObjectType, Signature, SignatureFlags, SymbolLinks, type Type, TypeFlags, TypeMapper, TypeParameter, TypePredicate, VarianceFlags, TypeListCache, TypeListTable, type ConditionalType, type InterfaceType, type TypeChecking } from './checker-types.js';
+import type { ModuleResolution } from './checker-modules.js';
 import { CheckerNameResolver, type LibGlobals, type MergedGlobals, TableChanges, SuggestionNameResolver } from './checker-symbols.js';
 import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer } from './relations.js';
 import { TypeNodeVisitor } from './checker-source-file.js';
@@ -19,6 +20,7 @@ import { SourceFileMetadata } from './program-utilities.js';
 import type { GrammarChecker } from './checker-grammar.js';
 import type { ResolvedModule } from './module-resolution-types.js';
 import type { ModuleSpecifierHost } from './module-specifiers.js';
+import type { PropertyListIndex } from './checker-members.js';
 /** What the checker needs from a program. */
 export declare abstract class CheckerHost {
     abstract getCompilerOptions(): CompilerOptions;
@@ -151,6 +153,15 @@ export declare class Checker implements TypeChecking {
     currentNode: Node | undefined;
     readonly diagnostics: DiagnosticCollection;
     readonly suggestionDiagnostics: DiagnosticCollection;
+    /** Diagnostics and suggestions reported so far, whether kept or not (`resolveExternalModule`'s cache). */
+    reports: number;
+    /** `resolveExternalModule` results that reported nothing, by module specifier (checker-modules.ts). */
+    readonly moduleResolutions: Map<Node, ModuleResolution>;
+    /**
+     * Whether ambient modules and module augmentations are merged. Merging can give a module a new
+     * merged symbol, so `resolveExternalModule` keeps results only from then on.
+     */
+    modulesMerged: boolean;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
     readonly moduleSpecifiers: Map<string, string>;
     /** Specifier generation for hosts without a program. */
@@ -161,6 +172,11 @@ export declare class Checker implements TypeChecking {
     readonly sideHolders: LinkTable<Type>;
     /** The same for signatures with side state (`signatureSideOf`), by signature id. */
     readonly signatureSideHolders: LinkTable<Signature>;
+    /**
+     * The indexes of long property lists that `propertiesRelatedTo` walks; before a list is indexed, its uses
+     * so far; null where a list repeats a name.
+     */
+    readonly propertyListIndexes: Map<Symbol[], number | PropertyListIndex | null>;
     /** The type of a value symbol. */
     readonly symbolTypes: LinkTable<Type>;
     /** For instantiated and synthetic symbols, the symbol they come from. */

package/dist/api/compiler/checker.js

@@ -230,6 +230,15 @@ export class Checker {
     currentNode = undefined;
     diagnostics = new DiagnosticCollection();
     suggestionDiagnostics = new DiagnosticCollection();
+    /** Diagnostics and suggestions reported so far, whether kept or not (`resolveExternalModule`'s cache). */
+    reports = 0;
+    /** `resolveExternalModule` results that reported nothing, by module specifier (checker-modules.ts). */
+    moduleResolutions = new Map();
+    /**
+     * Whether ambient modules and module augmentations are merged. Merging can give a module a new
+     * merged symbol, so `resolveExternalModule` keeps results only from then on.
+     */
+    modulesMerged = false;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
     moduleSpecifiers = new Map();
     /** Specifier generation for hosts without a program. */
@@ -243,6 +252,11 @@ export class Checker {
     sideHolders = new LinkTable();
     /** The same for signatures with side state (`signatureSideOf`), by signature id. */
     signatureSideHolders = new LinkTable();
+    /**
+     * The indexes of long property lists that `propertiesRelatedTo` walks; before a list is indexed, its uses
+     * so far; null where a list repeats a name.
+     */
+    propertyListIndexes = new Map();
     /** The type of a value symbol. */
     symbolTypes = new LinkTable();
     /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -740,6 +754,7 @@ export class Checker {
         this.diagnostics.startLog();
         this.suggestionDiagnostics.startLog();
         mergeAmbientModulesAndAugmentations(this);
+        this.modulesMerged = true;
         this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
     }
     // ---- Public API
@@ -830,11 +845,13 @@ export class Checker {
         return diagnostic;
     }
     addDiagnostic(diagnostic) {
+        this.reports++;
         // Discard diagnostics created while at the maximum number of nested typeToString calls.
         if (this.serializationLevel < maxSerializationLevel)
             this.diagnostics.add(diagnostic);
     }
     addSuggestion(diagnostic) {
+        this.reports++;
         this.suggestionDiagnostics.add(diagnostic);
     }
     /** Reports an error, or a suggestion when `isError` is false. */

package/dist/api/compiler/diagnostics.js

@@ -152,12 +152,14 @@ function threadCopyOf(file) {
     }
     return copy;
 }
+/** The empty value of a file's position tables until they are computed. */
+const noNumbers = [];
 /** The text of a file diagnostics point into. */
 export class DiagnosticFile {
     fileName;
     text;
     // Computed on first use; never empty once computed.
-    lineStarts = [];
+    lineStarts = noNumbers;
     /** Whether this is a thread's copy of a possibly shared file (`threadCopyOf`). */
     isThreadCopy = false;
     constructor(fileName, text) {
@@ -186,8 +188,8 @@ export class DiagnosticFile {
     // The non-ASCII characters, in order: their UTF-16 offsets, UTF-8 lengths, and the UTF-8 bytes
     // beyond one per UTF-16 code unit of the text up to and including each. Unset until first used.
     nonASCIIStarts = undefined;
-    nonASCIILengths = [];
-    extraBytes = [];
+    nonASCIILengths = noNumbers;
+    extraBytes = noNumbers;
     getNonASCIIStarts() {
         let starts = this.nonASCIIStarts;
         if (starts === undefined) {
@@ -196,8 +198,8 @@ export class DiagnosticFile {
             if (Buffer.byteLength(text, 'utf8') !== text.length) {
                 // Scanning the UTF-8 encoding is faster than reading each code unit.
                 const bytes = Buffer.from(text, 'utf8');
-                const lengths = this.nonASCIILengths;
-                const extraBytes = this.extraBytes;
+                const lengths = [];
+                const extraBytes = [];
                 let extra = 0;
                 for (let i = 0; i < bytes.length; i++) {
                     const b = bytes[i];
@@ -211,6 +213,8 @@ export class DiagnosticFile {
                     extraBytes.push(extra);
                     i += length - 1;
                 }
+                this.nonASCIILengths = lengths;
+                this.extraBytes = extraBytes;
             }
             this.nonASCIIStarts = starts;
         }

package/dist/api/compiler/parallel-parse.js

@@ -445,7 +445,9 @@ export class ParseSession {
             this.onIdle(batch);
     }
     post(i, chunk) {
-        this.workers[i].postMessage(chunk);
+        // Published, the chunk reaches the thread by pointer: copying its names into the message took the
+        // main thread 25-45 us per chunk, which during config read delays the matching of root files.
+        this.workers[i].postMessage(publish(chunk));
         this.outstanding[i] = this.outstanding[i] + 1;
         if (chunk.kinds[0] === 2 /* LoadKind.Library */ && largeLibraries.has(chunk.names[0]))
             this.blocked[i] = true;

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

@@ -135,6 +135,8 @@ export declare class Parser extends ScannerErrorReporter {
     reparseList: Node[];
     private readonly reparseLists;
     private reparseDepth;
+    private readonly listScratch;
+    private listDepth;
     reparsedClones: Node[];
     /** Nodes with eagerly parsed JSDoc, for rewinding. */
     jsDocInfos: Node[];
@@ -209,6 +211,11 @@ export declare class Parser extends ScannerErrorReporter {
     parseList(kind: ParsingContext, element: ListElement): NodeList;
     /** The list, or undefined if an element parser returned undefined. */
     parseDelimitedList(kind: ParsingContext, element: ListElement): NodeList | undefined;
+    /** The scratch array for a list at the next nesting depth, empty. */
+    private openList;
+    /** The elements collected in `list` (the scratch array from `openList`) as an array of their exact
+     * length, or the shared empty array; empties the scratch array for the next list at its depth. */
+    private closeList;
     /** The list; a missing list if `opening` is absent; undefined if an element parser returned undefined. */
     parseBracketedList(kind: ParsingContext, element: ListElement, opening: SyntaxKind, closing: SyntaxKind): NodeList | undefined;
     parseEmptyNodeList(): NodeList;

package/dist/api/compiler/parser.js

@@ -5,7 +5,7 @@
 // const file = parseSourceFile('/src/main.ts', text);
 // for (const statement of file.statements.nodes) console.log(statement.kind);
 // ```
-import { ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, CheckJsDirective, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleIndicatorOptions, ExternalModuleReference, FileReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocAllType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, KeywordExpression, KeywordTypeNode, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, MissingNodeList, ModifierList, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NoSubstitutionTemplateLiteral, NodeList, NodeVisitor, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, Pragma, PragmaArgument, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReferenceIdentifier, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisTypeNode, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, getBody, getIsTypeOnly, getModifiers, getName, getPostfixToken, getQuestionToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, } from './ast.js';
+import { appendToList, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, CheckJsDirective, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, emptyCommentDirectives, emptyDiagnostics, emptyFileReferences, emptyNodes, emptyPragmas, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleIndicatorOptions, ExternalModuleReference, FileReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocAllType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, KeywordExpression, KeywordTypeNode, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, MissingNodeList, ModifierList, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NoSubstitutionTemplateLiteral, NodeList, NodeVisitor, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, Pragma, PragmaArgument, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReferenceIdentifier, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisTypeNode, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, getBody, getIsTypeOnly, getModifiers, getName, getPostfixToken, getQuestionToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, newCallExpression, newPropertyAssignment, } from './ast.js';
 import { canHaveDecorators, canHaveIllegalDecorators, compareNodePositions, getBinaryOperatorPrecedence, getExternalModuleName, getImportTypeNodeLiteral, getTextOfNodeFromSourceText, isAmbientModule, isAnyImportOrReExport, isAssignmentOperator, isClassMemberModifier, isFunctionLike, isImportCall, isImportMeta, isInJSFile, isKeyword, isKeywordOrPunctuation, isLeftHandSideExpression, isModifierKind, isRequireCall, isReservedWord, isStringLiteralLike, modifierToFlag, modifiersToFlags, nodeIsMissing, nodeIsPresent, tagNamesAreEquivalent, tokenIsIdentifierOrKeyword, tokenIsIdentifierOrKeywordOrGreaterThan, } from './ast-utilities.js';
 import { isLineBreak } from './character-codes.js';
 import { Diagnostic, messageCode } from './diagnostics.js';
@@ -52,6 +52,10 @@ function appendRange(to, from, start, end) {
     for (let i = start; i < end; i += 1)
         to.push(from[i]);
 }
+// The nodes of every empty parsed list. A list's nodes are pushed into a new `[]`, which natively
+// reserves room for its first elements (112 bytes); a parsed list never changes, so an empty one
+// keeps this shared array instead and its builder is freed.
+const emptyListNodes = [];
 /** Parses `text` as the file `fileName`. The script kind defaults to the one implied by the extension. */
 export function parseSourceFile(fileName, text, options) {
     const path = options === undefined ? fileName : options.path;
@@ -143,6 +147,10 @@ export class Parser extends ScannerErrorReporter {
     // receives reparsed nodes, and a fresh array per parsed list would be one more allocation each.
     reparseLists;
     reparseDepth;
+    // One scratch array per nesting depth of the lists being parsed. A list collects its elements in
+    // its depth's array and is copied out at its exact length, so the tree keeps no spare capacity.
+    listScratch;
+    listDepth;
     reparsedClones;
     /** Nodes with eagerly parsed JSDoc, for rewinding. */
     jsDocInfos;
@@ -196,6 +204,8 @@ export class Parser extends ScannerErrorReporter {
         this.reparseList = [];
         this.reparseLists = [this.reparseList];
         this.reparseDepth = 0;
+        this.listScratch = [];
+        this.listDepth = -1;
         this.reparsedClones = [];
         this.jsDocInfos = [];
         this.jsDocTable = undefined;
@@ -368,10 +378,10 @@ export class Parser extends ScannerErrorReporter {
     }
     // Nodes
     newNodeList(pos, end, nodes) {
-        return new NodeList(pos, end, nodes);
+        return new NodeList(pos, end, nodes.length === 0 ? emptyListNodes : nodes);
     }
     newModifierList(pos, end, nodes) {
-        return new ModifierList(pos, end, nodes, modifiersToFlags(nodes));
+        return new ModifierList(pos, end, nodes.length === 0 ? emptyListNodes : nodes, modifiersToFlags(nodes));
     }
     finishNode(node, pos) {
         return this.finishNodeWithEnd(node, pos, this.nodePos());
@@ -434,7 +444,8 @@ export class Parser extends ScannerErrorReporter {
         return new SourceFile(this.fileName, this.path, this.sourceText, this.externalModuleIndicatorOptions, statements, eof);
     }
     finishSourceFile(result, isDeclarationFile) {
-        result.commentDirectives = this.scanner.getCommentDirectives();
+        const commentDirectives = this.scanner.getCommentDirectives();
+        result.commentDirectives = commentDirectives.length === 0 ? emptyCommentDirectives : commentDirectives;
         result.pragmas = getCommentPragmas(this.sourceText);
         this.processPragmasIntoFields(result);
         result.diagnostics = attachFileToDiagnostics(this.diagnostics, result);
@@ -452,9 +463,13 @@ export class Parser extends ScannerErrorReporter {
         // The table stays with the parser: when top-level await reparsing produces a second source
         // file, it finishes with the same table, which still holds the JSDoc of retained statements.
         result.jsDocs = this.jsDocTable;
-        const clones = this.reparsedClones.slice();
-        clones.sort(compareNodePositions);
-        result.reparsedClones = clones;
+        if (this.reparsedClones.length === 0)
+            result.reparsedClones = emptyNodes;
+        else {
+            const clones = this.reparsedClones.slice();
+            clones.sort(compareNodePositions);
+            result.reparsedClones = clones;
+        }
         setExternalModuleIndicator(result);
     }
     parseToplevelStatement(index) {
@@ -601,7 +616,7 @@ export class Parser extends ScannerErrorReporter {
             this.reparseLists.push([]);
         const reparseList = this.reparseLists[depth];
         this.reparseList = reparseList;
-        const list = [];
+        const list = this.openList();
         while (!this.isListTerminator(kind)) {
             if (this.isListElement(kind, false)) {
                 const elt = this.parseListElement(element, list.length);
@@ -627,7 +642,7 @@ export class Parser extends ScannerErrorReporter {
         this.reparseDepth = depth - 1;
         this.reparseList = outerReparseList;
         this.parsingContexts = saveParsingContexts;
-        return list;
+        return this.closeList(list);
     }
     parseList(kind, element) {
         const pos = this.nodePos();
@@ -639,12 +654,13 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         const saveParsingContexts = this.parsingContexts;
         this.parsingContexts |= 1 << kind;
-        const list = [];
+        const list = this.openList();
         for (;;) {
             if (this.isListElement(kind, false)) {
                 const startPos = this.nodePos();
                 const result = this.parseListElement(element, list.length);
                 if (result === this.noElement) {
+                    this.closeList(list);
                     this.parsingContexts = saveParsingContexts;
                     return undefined;
                 }
@@ -674,7 +690,24 @@ export class Parser extends ScannerErrorReporter {
                 break;
         }
         this.parsingContexts = saveParsingContexts;
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
+    }
+    /** The scratch array for a list at the next nesting depth, empty. */
+    openList() {
+        const depth = ++this.listDepth;
+        if (depth === this.listScratch.length)
+            this.listScratch.push([]);
+        return this.listScratch[depth];
+    }
+    /** The elements collected in `list` (the scratch array from `openList`) as an array of their exact
+     * length, or the shared empty array; empties the scratch array for the next list at its depth. */
+    closeList(list) {
+        this.listDepth--;
+        if (list.length === 0)
+            return emptyListNodes;
+        const nodes = list.slice();
+        list.length = 0;
+        return nodes;
     }
     /** The list; a missing list if `opening` is absent; undefined if an element parser returned undefined. */
     parseBracketedList(kind, element, opening, closing) {
@@ -2364,10 +2397,11 @@ export class Parser extends ScannerErrorReporter {
             ? this.parseFunctionOrConstructorTypeToError(isUnionType)
             : this.parseConstituentType(isUnionType);
         if (this.token() === operator || hasLeadingOperator) {
-            const types = [type];
+            const types = this.openList();
+            types.push(type);
             while (this.parseOptional(operator))
                 types.push(this.parseFunctionOrConstructorTypeToError(isUnionType));
-            const list = this.newNodeList(pos, this.nodePos(), types);
+            const list = this.newNodeList(pos, this.nodePos(), this.closeList(types));
             type = isUnionType ? new UnionTypeNode(list) : new IntersectionTypeNode(list);
             this.finishNode(type, pos);
         }
@@ -3166,14 +3200,14 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTemplateTypeSpans() {
         const pos = this.nodePos();
-        const list = [];
+        const list = this.openList();
         for (;;) {
             const span = this.parseTemplateTypeSpan();
             list.push(span);
             if (span.literal.kind !== 16 /* SyntaxKind.TemplateMiddle */)
                 break;
         }
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
     }
     parseTemplateTypeSpan() {
         const pos = this.nodePos();
@@ -3273,12 +3307,10 @@ export class Parser extends ScannerErrorReporter {
         let hasTrailingModifier = false;
         let hasStaticModifier = false;
         const pos = this.nodePos();
-        let list;
+        const list = this.openList();
         for (;;) {
             if (allowDecorators && this.token() === 59 /* SyntaxKind.AtToken */ && !hasTrailingModifier) {
                 const decorator = this.parseDecorator();
-                if (list === undefined)
-                    list = [];
                 list.push(decorator);
                 if (hasLeadingModifier)
                     hasTrailingDecorator = true;
@@ -3289,8 +3321,6 @@ export class Parser extends ScannerErrorReporter {
                     break;
                 if (modifier.kind === 125 /* SyntaxKind.StaticKeyword */)
                     hasStaticModifier = true;
-                if (list === undefined)
-                    list = [];
                 list.push(modifier);
                 if (hasTrailingDecorator)
                     hasTrailingModifier = true;
@@ -3298,7 +3328,8 @@ export class Parser extends ScannerErrorReporter {
                     hasLeadingModifier = true;
             }
         }
-        return list === undefined ? undefined : this.newModifierList(pos, this.nodePos(), list);
+        const nodes = this.closeList(list);
+        return nodes.length === 0 ? undefined : this.newModifierList(pos, this.nodePos(), nodes);
     }
     parseDecorator() {
         const pos = this.nodePos();
@@ -3932,7 +3963,7 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         const saveParsingContexts = this.parsingContexts;
         this.parsingContexts |= 1 << 14 /* ParsingContext.JsxChildren */;
-        const list = [];
+        const list = this.openList();
         for (;;) {
             // Like tsgo, this leaves the parser's current token unchanged.
             const currentToken = this.scanner.reScanJsxToken(true);
@@ -3948,7 +3979,7 @@ export class Parser extends ScannerErrorReporter {
                 break;
         }
         this.parsingContexts = saveParsingContexts;
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
     }
     parseJsxChild(openingTag, token) {
         switch (token) {
@@ -4449,7 +4480,7 @@ export class Parser extends ScannerErrorReporter {
                 const inner = expression;
                 const argumentList = this.parseArgumentList();
                 const isOptionalChain = questionDotToken !== undefined || this.tryReparseOptionalChain(expression);
-                expression = this.checkJSSyntax(this.finishNode(new CallExpression(expression, questionDotToken, typeArguments, argumentList, isOptionalChain ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */), pos));
+                expression = this.checkJSSyntax(this.finishNode(newCallExpression(expression, questionDotToken, typeArguments, argumentList, isOptionalChain ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */, (this.contextFlags & 65536 /* NodeFlags.JavaScriptFile */) !== 0), pos));
                 this.unparseExpressionWithTypeArguments(inner, typeArguments, expression);
                 continue;
             }
@@ -4510,14 +4541,14 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTemplateSpans(isTaggedTemplate) {
         const pos = this.nodePos();
-        const list = [];
+        const list = this.openList();
         for (;;) {
             const span = this.parseTemplateSpan(isTaggedTemplate);
             list.push(span);
             if (span.literal.kind !== 16 /* SyntaxKind.TemplateMiddle */)
                 break;
         }
-        return this.newNodeList(pos, this.nodePos(), list);
+        return this.newNodeList(pos, this.nodePos(), this.closeList(list));
     }
     parseTemplateSpan(isTaggedTemplate) {
         const pos = this.nodePos();
@@ -4636,7 +4667,7 @@ export class Parser extends ScannerErrorReporter {
         else {
             this.parseExpected(58 /* SyntaxKind.ColonToken */);
             const initializer = this.parseAssignmentExpressionOrHigherAllowIn();
-            node = new PropertyAssignment(modifiers, name, postfixToken, undefined, initializer);
+            node = newPropertyAssignment(modifiers, name, postfixToken, undefined, initializer, (this.contextFlags & 65536 /* NodeFlags.JavaScriptFile */) !== 0);
         }
         return this.finishWithJSDoc(node, pos, jsdoc);
     }
@@ -5540,9 +5571,9 @@ export class Parser extends ScannerErrorReporter {
     // Pragmas
     processPragmasIntoFields(file) {
         file.checkJsDirective = undefined;
-        file.referencedFiles = [];
-        file.typeReferenceDirectives = [];
-        file.libReferenceDirectives = [];
+        file.referencedFiles = emptyFileReferences;
+        file.typeReferenceDirectives = emptyFileReferences;
+        file.libReferenceDirectives = emptyFileReferences;
         for (const pragma of file.pragmas) {
             switch (pragma.name) {
                 case 'reference': {
@@ -5561,13 +5592,13 @@ export class Parser extends ScannerErrorReporter {
                         const parsed = resolutionMode !== undefined
                             ? this.parseResolutionMode(resolutionMode.value, resolutionMode.pos, resolutionMode.end)
                             : ModuleKind.None;
-                        file.typeReferenceDirectives.push(new FileReference(types.pos, types.end, types.value, parsed, isPreserved));
+                        file.typeReferenceDirectives = appendToList(file.typeReferenceDirectives, new FileReference(types.pos, types.end, types.value, parsed, isPreserved));
                     }
                     else if (lib !== undefined) {
-                        file.libReferenceDirectives.push(new FileReference(lib.pos, lib.end, lib.value, ModuleKind.None, isPreserved));
+                        file.libReferenceDirectives = appendToList(file.libReferenceDirectives, new FileReference(lib.pos, lib.end, lib.value, ModuleKind.None, isPreserved));
                     }
                     else if (path !== undefined) {
-                        file.referencedFiles.push(new FileReference(path.pos, path.end, path.value, ModuleKind.None, isPreserved));
+                        file.referencedFiles = appendToList(file.referencedFiles, new FileReference(path.pos, path.end, path.value, ModuleKind.None, isPreserved));
                     }
                     else {
                         this.parseErrorAt(pragma.range.pos, pragma.range.end, 57 /* Diagnostics.Invalid_reference_directive_syntax */);
@@ -5776,7 +5807,7 @@ function typeHasBlockingError(node) {
 }
 function attachFileToDiagnostics(diagnostics, file) {
     if (diagnostics.length === 0)
-        return diagnostics;
+        return emptyDiagnostics;
     const diagnosticFile = file.diagnosticFile();
     for (const d of diagnostics) {
         d.file = diagnosticFile;
@@ -6034,12 +6065,13 @@ function nextTokenIsNotColon(p) {
 }
 // Pragmas
 function getCommentPragmas(sourceText) {
-    const pragmas = [];
     const ranges = getLeadingCommentRanges(sourceText, 0);
-    if (ranges !== undefined)
-        for (const range of ranges)
-            extractPragmas(range, sourceText.substring(range.pos, range.end), pragmas);
-    return pragmas;
+    if (ranges === undefined)
+        return emptyPragmas;
+    const pragmas = [];
+    for (const range of ranges)
+        extractPragmas(range, sourceText.substring(range.pos, range.end), pragmas);
+    return pragmas.length === 0 ? emptyPragmas : pragmas;
 }
 function extractPragmas(range, text, pragmas) {
     if (range.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) {
@@ -6200,10 +6232,10 @@ function collectModuleReferences(file, node, inAmbientModule) {
         (inAmbientModule || hasModifierFlag(node, 128 /* ModifierFlags.Ambient */) || file.isDeclarationFile)) {
         const nameText = getText(node.name);
         if (file.externalModuleIndicator !== undefined || (inAmbientModule && !isExternalModuleNameRelative(nameText))) {
-            file.moduleAugmentations.push(node.name);
+            file.moduleAugmentations = appendToList(file.moduleAugmentations, node.name);
         }
         else if (!inAmbientModule) {
-            file.ambientModuleNames.push(nameText);
+            file.ambientModuleNames = appendToList(file.ambientModuleNames, nameText);
             const body = node.body;
             if (body !== undefined) {
                 const statements = getStatements(body);