tsc-ts 0.0.6 → 0.0.7

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;
@@ -368,10 +372,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 +438,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 +457,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) {
@@ -4449,7 +4458,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;
             }
@@ -4636,7 +4645,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 +5549,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 +5570,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 +5785,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 +6043,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 +6210,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);

package/dist/api/compiler/printer/factory-base.js

@@ -1,5 +1,5 @@
 // Generated by scripts/generate-visitor.mjs; do not edit.
-import { ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocDeprecatedTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocNameReference, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocOverloadTag, JSDocOverrideTag, JSDocParameterOrPropertyTag, JSDocPrivateTag, JSDocProtectedTag, JSDocPublicTag, JSDocReadonlyTag, JSDocReturnTag, JSDocSatisfiesTag, JSDocSeeTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocThrowsTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypeTag, JSDocTypedefTag, JSDocUnknownTag, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, SwitchStatement, SyntaxList, SyntheticReferenceExpression, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, } from '../ast.js';
+import { ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocDeprecatedTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocNameReference, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocOverloadTag, JSDocOverrideTag, JSDocParameterOrPropertyTag, JSDocPrivateTag, JSDocProtectedTag, JSDocPublicTag, JSDocReadonlyTag, JSDocReturnTag, JSDocSatisfiesTag, JSDocSeeTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocThrowsTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypeTag, JSDocTypedefTag, JSDocUnknownTag, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, SwitchStatement, SyntaxList, SyntheticReferenceExpression, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, propertyAssignmentPostfixToken, propertyAssignmentType, callQuestionDotToken, propertyAssignmentModifiers, callTypeArguments, newCallExpression, newPropertyAssignment, } from '../ast.js';
 /** `update*` functions: return the node if no child changed, else a copy with the node's flags, range and original. */
 export class NodeFactoryBase {
     updateArrayLiteralExpression(node, elements, multiLine) {
@@ -97,11 +97,11 @@ export class NodeFactoryBase {
     }
     updateCallExpression(node, expression, questionDotToken, typeArguments, args, flags) {
         if (expression !== node.expression ||
-            questionDotToken !== node.questionDotToken ||
-            typeArguments !== node.typeArguments ||
+            questionDotToken !== callQuestionDotToken(node) ||
+            typeArguments !== callTypeArguments(node) ||
             args !== node.arguments ||
             flags !== node.flags) {
-            const updated = new CallExpression(expression, questionDotToken, typeArguments, args, flags);
+            const updated = newCallExpression(expression, questionDotToken, typeArguments, args, flags, false);
             this.finishUpdate(updated, node);
             return updated;
         }
@@ -1154,12 +1154,12 @@ export class NodeFactoryBase {
         return node;
     }
     updatePropertyAssignment(node, modifiers, name, postfixToken, typeNode, initializer) {
-        if (modifiers !== node.modifiers ||
+        if (modifiers !== propertyAssignmentModifiers(node) ||
             name !== node.name ||
-            postfixToken !== node.postfixToken ||
-            typeNode !== node.type ||
+            postfixToken !== propertyAssignmentPostfixToken(node) ||
+            typeNode !== propertyAssignmentType(node) ||
             initializer !== node.initializer) {
-            const updated = new PropertyAssignment(modifiers, name, postfixToken, typeNode, initializer);
+            const updated = newPropertyAssignment(modifiers, name, postfixToken, typeNode, initializer, false);
             this.finishUpdate(updated, node);
             return updated;
         }

package/dist/api/compiler/printer/factory.js

@@ -1,6 +1,6 @@
 // Creates synthesized nodes for transforms and the printer. Created nodes are flagged
 // `Synthesized` and have no range; updated nodes keep the original's flags, range and emit data.
-import { ArrowFunction, AsExpression, DeleteExpression, ExpressionWithTypeArguments, NonNullExpression, PartiallyEmittedExpression, SatisfiesExpression, SyntheticReferenceExpression, TypeAssertion, BinaryExpression, ElementAccessExpression, FunctionExpression, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, QualifiedName, Block, CallExpression, ConditionalExpression, ExpressionStatement, Identifier, IfStatement, KeywordExpression, ModifierList, NodeList, NumericLiteral, ParenthesizedExpression, PrivateIdentifier, PropertyAccessExpression, ReturnStatement, SetAccessorDeclaration, SourceFile, StringLiteral, SyntaxList, Token, TypeOfExpression, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, } from '../ast.js';
+import { ArrowFunction, AsExpression, DeleteExpression, ExpressionWithTypeArguments, NonNullExpression, PartiallyEmittedExpression, SatisfiesExpression, SyntheticReferenceExpression, TypeAssertion, BinaryExpression, ElementAccessExpression, FunctionExpression, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, QualifiedName, Block, CallExpression, ConditionalExpression, ExpressionStatement, Identifier, IfStatement, KeywordExpression, ModifierList, NodeList, NumericLiteral, ParenthesizedExpression, PrivateIdentifier, PropertyAccessExpression, ReturnStatement, SetAccessorDeclaration, SourceFile, StringLiteral, SyntaxList, Token, TypeOfExpression, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, newCallExpression, newPropertyAssignment, } from '../ast.js';
 import { modifierToFlag } from '../ast-utilities.js';
 import { getNameOfDeclaration, getNonAssignedNameOfDeclaration, hasSyntacticModifier } from '../binder-utilities.js';
 import { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
@@ -83,7 +83,7 @@ export class NodeFactory extends NodeFactoryBase {
         return this.created(new PropertyAccessExpression(expression, undefined, name, 0 /* NodeFlags.None */));
     }
     createCallExpression(expression, args) {
-        return this.created(new CallExpression(expression, undefined, undefined, this.createNodeList(args), 0 /* NodeFlags.None */));
+        return this.created(newCallExpression(expression, undefined, undefined, this.createNodeList(args), 0 /* NodeFlags.None */, false));
     }
     createBinaryExpression(left, operator, right) {
         return this.created(new BinaryExpression(undefined, left, undefined, this.createToken(operator), right));
@@ -146,7 +146,7 @@ export class NodeFactory extends NodeFactoryBase {
         return this.created(new ObjectLiteralExpression(this.createNodeList(properties), multiLine));
     }
     createPropertyAssignment(name, initializer) {
-        return this.created(new PropertyAssignment(undefined, name, undefined, undefined, initializer));
+        return this.created(newPropertyAssignment(undefined, name, undefined, undefined, initializer, false));
     }
     createParameter(name) {
         return this.created(new ParameterDeclaration(undefined, undefined, name, undefined, undefined, undefined));
@@ -362,7 +362,7 @@ export class NodeFactory extends NodeFactoryBase {
     createMethodCall(object, method, args) {
         const callee = this.createPropertyAccessExpression(object, this.createIdentifier(method));
         const flags = object instanceof CallExpression ? object.flags & 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */;
-        return this.created(new CallExpression(callee, undefined, undefined, this.createNodeList(args), flags));
+        return this.created(newCallExpression(callee, undefined, undefined, this.createNodeList(args), flags, false));
     }
     /** `Global.method(...args)`, such as `Math.pow(a, b)`. */
     createGlobalMethodCall(global, method, args) {

package/dist/api/compiler/printer/printer.js

@@ -1,6 +1,6 @@
 // Prints syntax trees as source text the way tsgo's printer does: formatting, comments,
 // source maps, generated names and emit helpers.
-import { ArrayLiteralExpression, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, ArrayTypeNode, getName, getParameters, getTypeParameters, getTypeArguments, getArguments, getElements, getProperties, getStatements, getModifiers, } from '../ast.js';
+import { ArrayLiteralExpression, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, ArrayTypeNode, getName, getParameters, getTypeParameters, getTypeArguments, getArguments, getElements, getProperties, getStatements, getModifiers, callQuestionDotToken, callTypeArguments, } from '../ast.js';
 import { computeLineOfPosition, computeLineStarts, getLeadingCommentRanges, getShebang, getTrailingCommentRanges, skipTrivia, tokenToString, } from '../scanner.js';
 import { ScriptTarget } from '../options.js';
 import { fileExtensionIs } from '../path.js';
@@ -1728,8 +1728,8 @@ export class Printer extends NameGeneratorHost {
     emitCallExpression(node) {
         const state = this.enterNode(node);
         this.emitCallee(node.expression, node);
-        this.emitOptionalToken(node.questionDotToken);
-        this.emitTypeArguments(node, node.typeArguments);
+        this.emitOptionalToken(callQuestionDotToken(node));
+        this.emitTypeArguments(node, callTypeArguments(node));
         this.emitList(13 /* ListItem.Argument */, node, node.arguments, 2576 /* ListFormat.CallExpressionArguments */);
         this.exitNode(node, state);
         return true;
@@ -2094,7 +2094,7 @@ export class Printer extends NameGeneratorHost {
         if (node instanceof ElementAccessExpression)
             return factory.updateElementAccessExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.argumentExpression, node.flags);
         if (node instanceof CallExpression)
-            return factory.updateCallExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.typeArguments, node.arguments, node.flags);
+            return factory.updateCallExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), callQuestionDotToken(node), callTypeArguments(node), node.arguments, node.flags);
         if (node instanceof TaggedTemplateExpression)
             return factory.updateTaggedTemplateExpression(node, this.parenthesizeExpressionForNoAsi(node.tag), node.questionDotToken, node.typeArguments, node.template, node.flags);
         if (node instanceof PostfixUnaryExpression)
@@ -2339,8 +2339,8 @@ export class Printer extends NameGeneratorHost {
                 this.write1('(');
                 this.emitExpression(call.expression, 0 /* OperatorPrecedence.Lowest */);
                 this.write1(')');
-                this.emitOptionalToken(call.questionDotToken);
-                this.emitTypeArguments(call, call.typeArguments);
+                this.emitOptionalToken(callQuestionDotToken(call));
+                this.emitTypeArguments(call, callTypeArguments(call));
                 this.emitList(13 /* ListItem.Argument */, call, call.arguments, 2576 /* ListFormat.CallExpressionArguments */);
                 this.exitNode(call, callState);
             }

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

@@ -24,6 +24,11 @@ import { type SourceFileMetadata } from './program-utilities.js';
 export declare class ProgramCheckerHost extends CheckerHost {
     readonly program: Program;
     private specifierHost;
+    /**
+     * `getSourceFileForResolvedModule` by resolved file name (null when there is none): every import of
+     * a module asks again, and the program finds a file by its path, which it computes from the name.
+     */
+    private readonly resolvedSourceFiles;
     constructor(program: Program);
     getCompilerOptions(): CompilerOptions;
     getSourceFiles(): readonly SourceFile[];

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

@@ -9,6 +9,11 @@ import { computeLineOfPosition } from './scanner.js';
 export class ProgramCheckerHost extends CheckerHost {
     program;
     specifierHost = undefined;
+    /**
+     * `getSourceFileForResolvedModule` by resolved file name (null when there is none): every import of
+     * a module asks again, and the program finds a file by its path, which it computes from the name.
+     */
+    resolvedSourceFiles = new Map();
     constructor(program) {
         super();
         this.program = program;
@@ -26,7 +31,12 @@ export class ProgramCheckerHost extends CheckerHost {
         return this.program.getResolvedModule(file, moduleName, mode);
     }
     getSourceFileForResolvedModule(fileName) {
-        return this.program.getSourceFileForResolvedModule(fileName);
+        const known = this.resolvedSourceFiles.get(fileName);
+        if (known !== undefined)
+            return known ?? undefined;
+        const file = this.program.getSourceFileForResolvedModule(fileName);
+        this.resolvedSourceFiles.set(fileName, file ?? null);
+        return file;
     }
     getModeForUsageLocation(file, location) {
         return this.program.getModeForUsageLocation(file, location);

package/dist/api/compiler/relations.js

@@ -10,7 +10,7 @@ import { createDiagnosticForNode } from './checker.js';
 import { cachedTypeKey, emptyTypes, newTypeMapper, SimpleTypeMapper, } from './checker-types.js';
 import { createInferenceContext, inferTypes } from './checker-inference.js';
 import { unionContainsSortedTypes, unionContainsType, createArrayTypeEx, compareTypes, containsMissingType, createTypeReference, everyType, filterType, getBaseTypeOfLiteralType, getBaseTypeOfEnumLikeType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getTargetType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, isArrayOrTupleType, isArrayType, isEmptyAnonymousObjectType, isEmptyObjectType, isErrorType, isFreshLiteralType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, isUnitType, someType, tupleTargetOf, typesOf, countTypes, getStartElementCount, getEndElementCount, createNormalizedTypeReference, typeListKey, getRegularTypeOfLiteralType, } from './checker-type-factory.js';
-import { findApplicableIndexInfo, getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfObjectType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedType, getSignaturesOfStructuredType, getSignaturesOfType, getTargetSymbol, getTypeOfPropertyOfType, getTypeWithThisArgument, getUnionOrIntersectionProperty, isApplicableIndexType, isArrayLikeType, isObjectLiteralType, isDiscriminantWithNeverType, isConflictingPrivateProperty, resolveStructuredTypeMembers, getResolvedMember, hasResolvedProperties, resolvedPropertiesAreOptional, } from './checker-members.js';
+import { findApplicableIndexInfo, getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfObjectType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedType, getSignaturesOfStructuredType, getSignaturesOfType, getTargetSymbol, getTypeOfPropertyOfType, getTypeWithThisArgument, getUnionOrIntersectionProperty, isApplicableIndexType, isArrayLikeType, isObjectLiteralType, isDiscriminantWithNeverType, isConflictingPrivateProperty, resolveStructuredTypeMembers, getResolvedMember, hasResolvedProperties, resolvedPropertiesAreOptional, positionsOfNamesFoundInSource, firstUnmatchedProperty, } from './checker-members.js';
 import { getParentOfSymbol, getMergedSymbol, getMembersOfSymbol, getSpellingSuggestionForName, } from './checker-symbols.js';
 import { CodePoints, distanceToCandidate, utf8Length } from './spelling.js';
 import { getConstraintFromTypeParameter, getDeclaredTypeOfSymbol, getDefaultOrUnknownFromTypeParameter, fillMissingTypeArguments, getMinTypeArgumentCount, hasBaseType, hasNonCircularBaseConstraint, computeEnumMemberValues, getBaseTypes, getExtendsHeritageClauseElement, } from './checker-declared-types.js';
@@ -2058,7 +2058,12 @@ export class Relater extends TypeComparer {
             !isObjectLiteralType(source) &&
             !isEmptyArrayLiteralType(c, source) &&
             !isTupleType(source);
-        const unmatchedProperty = getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
+        const targetProperties = getPropertiesOfType(c, target);
+        // Where it is known which target names the source has, nothing else is looked up by name.
+        const found = positionsOfNamesFoundInSource(c, source, target, targetProperties);
+        const unmatchedProperty = found !== undefined
+            ? firstUnmatchedProperty(c, targetProperties, found, requireOptionalProperties)
+            : getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
         if (unmatchedProperty !== undefined) {
             if (reportErrors && shouldReportUnmatchedPropertyError(c, source, target))
                 this.reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
@@ -2079,7 +2084,7 @@ export class Relater extends TypeComparer {
             }
         }
         const numericNamesOnly = isTupleType(source) && isTupleType(target);
-        for (const targetProp of getPropertiesOfType(c, target)) {
+        for (const targetProp of found !== undefined ? found.map((i) => targetProperties[i]) : targetProperties) {
             if (excludedProperties !== undefined && excludedProperties.has(targetProp.name))
                 continue;
             const name = targetProp.name;

package/dist/api/compiler/reparser.js

@@ -6,7 +6,7 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { ArrayTypeNode, ArrowFunction, AsExpression, BinaryExpression, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ElementAccessExpression, ExportAssignment, ExpressionStatement, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, ImportDeclaration, IndexSignatureDeclaration, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocImplementsTag, JSDocImportTag, JSDocOverloadTag, JSDocParameterOrPropertyTag, JSDocSatisfiesTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypedefTag, JSDocVariadicType, JSDocOptionalType, KeywordTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModifierList, ModuleBlock, ModuleDeclaration, NodeList, NodeVisitor, NumericLiteral, ParameterDeclaration, ParenthesizedExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, StringLiteral, Token, TypeAliasDeclaration, TypeLiteralNode, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getComment, getModifiers, getName, getParameters, getText, getType, getTypeExpression, getTypeParameters, } from './ast.js';
+import { ArrayTypeNode, ArrowFunction, AsExpression, BinaryExpression, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ElementAccessExpression, ExportAssignment, ExpressionStatement, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, ImportDeclaration, IndexSignatureDeclaration, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocImplementsTag, JSDocImportTag, JSDocOverloadTag, JSDocParameterOrPropertyTag, JSDocSatisfiesTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypedefTag, JSDocVariadicType, JSDocOptionalType, KeywordTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModifierList, ModuleBlock, ModuleDeclaration, NodeList, NodeVisitor, NumericLiteral, ParameterDeclaration, ParenthesizedExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, StringLiteral, Token, TypeAliasDeclaration, TypeLiteralNode, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getComment, getModifiers, getName, getParameters, getText, getType, getTypeExpression, getTypeParameters, FullPropertyAssignment, } from './ast.js';
 import { isAssignmentOperator, isFunctionLike, isInJSFile, isLeftHandSideExpression, isStringLiteralLike, } from './ast-utilities.js';
 import { isIdentifierPart, isIdentifierStart } from './character-codes.js';
 /** Sets the parent of every node in a subtree. */
@@ -652,10 +652,14 @@ export class Reparser {
             return false;
         const className = tag.className;
         const heritageClauses = getHeritageClauses(parent);
+        // Parsed lists may share their nodes array (empty ones do), so a longer list is a new list.
         if (heritageClauses !== undefined) {
             for (const clause of heritageClauses.nodes)
                 if (clause instanceof HeritageClause && clause.token === 118 /* SyntaxKind.ImplementsKeyword */) {
-                    clause.types.nodes.push(this.addDeepCloneReparse(className));
+                    const types = clause.types;
+                    const nodes = types.nodes.slice();
+                    nodes.push(this.addDeepCloneReparse(className));
+                    clause.types = this.p.newNodeList(types.pos, types.end, nodes);
                     this.finishMutatedNode(clause);
                     return true;
                 }
@@ -665,8 +669,11 @@ export class Reparser {
         this.finishReparsedNode(heritageClause, className);
         if (heritageClauses === undefined)
             setHeritageClauses(parent, this.p.newNodeList(className.pos, className.end, [heritageClause]));
-        else
-            heritageClauses.nodes.push(heritageClause);
+        else {
+            const nodes = heritageClauses.nodes.slice();
+            nodes.push(heritageClause);
+            setHeritageClauses(parent, this.p.newNodeList(heritageClauses.pos, heritageClauses.end, nodes));
+        }
         this.finishMutatedNode(parent);
         return true;
     }
@@ -1178,7 +1185,8 @@ function setType(node, value) {
         node.type = value;
         return true;
     }
-    if (node instanceof PropertyAssignment) {
+    // Property assignments in JavaScript files, which are the ones reparsed, are full ones.
+    if (node instanceof FullPropertyAssignment) {
         node.type = value;
         return true;
     }

package/dist/api/compiler/transformers/class-fields.js

@@ -1,7 +1,7 @@
 // Lowers class fields, private names, static blocks and `accessor` fields: initializers move to
 // the constructor (useDefineForClassFields: false, or targets before ES2022), private members
 // become WeakMaps, WeakSets and hoisted functions, and static `this` and `super` refer to the class.
-import { ArrayLiteralExpression, BinaryExpression, Block, CallExpression, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConstructorDeclaration, ElementAccessExpression, ExportAssignment, ExpressionWithTypeArguments, GetAccessorDeclaration, HeritageClause, Identifier, NodeList, ObjectLiteralExpression, ParameterDeclaration, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, StringLiteral, TryStatement, NewExpression, ArrowFunction, CatchClause, FunctionExpression, MethodDeclaration, NodeVisitor, VoidExpression, getBody, getParameters, getInitializer, getMembers, getModifiers, getName, } from '../ast.js';
+import { ArrayLiteralExpression, BinaryExpression, Block, CallExpression, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConstructorDeclaration, ElementAccessExpression, ExportAssignment, ExpressionWithTypeArguments, GetAccessorDeclaration, HeritageClause, Identifier, NodeList, ObjectLiteralExpression, ParameterDeclaration, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, StringLiteral, TryStatement, NewExpression, ArrowFunction, CatchClause, FunctionExpression, MethodDeclaration, NodeVisitor, VoidExpression, getBody, getParameters, getInitializer, getMembers, getModifiers, getName, callQuestionDotToken, callTypeArguments, newCallExpression, } from '../ast.js';
 import { isLeftHandSideExpression } from '../ast-utilities.js';
 import { getNameOfDeclaration, hasStaticModifier, isAssignmentExpression, isAutoAccessorPropertyDeclaration, isClassLike, isDestructuringAssignment, isMethodOrAccessor, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from '../binder-utilities.js';
 import { isIdentifierText } from '../scanner.js';
@@ -963,7 +963,7 @@ export class ClassFieldsTransformer extends Transformer {
         if (node instanceof ParenthesizedExpression)
             return factory.cloneNode(node, new ParenthesizedExpression(node.expression));
         if (node instanceof CallExpression)
-            return factory.cloneNode(node, new CallExpression(node.expression, node.questionDotToken, node.typeArguments, node.arguments, node.flags));
+            return factory.cloneNode(node, newCallExpression(node.expression, callQuestionDotToken(node), callTypeArguments(node), node.arguments, node.flags, false));
         return factory.cloneNode(node, node.deepClone());
     }
     visitCallExpression(node) {
@@ -980,7 +980,7 @@ export class ClassFieldsTransformer extends Transformer {
             for (let i = 0; i < visitedArgs.length; i++)
                 args.push(visitedArgs[i]);
             const optional = (node.flags & 32 /* NodeFlags.OptionalChain */) !== 0;
-            const call = factory.created(new PropertyAccessExpression(target, optional ? node.questionDotToken : undefined, factory.createIdentifier('call'), optional ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */));
+            const call = factory.created(new PropertyAccessExpression(target, optional ? callQuestionDotToken(node) : undefined, factory.createIdentifier('call'), optional ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */));
             return factory.updateCallExpression(node, call, undefined, undefined, factory.createNodeList(args), node.flags);
         }
         const data = this.staticSuperData(callee);

package/dist/api/compiler/transformers/commonjs-module.js

@@ -1,5 +1,5 @@
 // CommonJS module output: imports become `require` calls, exports assignments to `exports`.
-import { ArrowFunction, BinaryExpression, BindingPattern, Block, CallExpression, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, DoStatement, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, LabeledStatement, NamedExports, NamespaceExport, NodeList, NodeVisitor, ObjectLiteralExpression, ArrayLiteralExpression, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateSpan, TemplateTail, TryStatement, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, EmptyStatement, getElements, getName, } from '../ast.js';
+import { ArrowFunction, BinaryExpression, BindingPattern, Block, CallExpression, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, DoStatement, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, LabeledStatement, NamedExports, NamespaceExport, NodeList, NodeVisitor, ObjectLiteralExpression, ArrayLiteralExpression, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateSpan, TemplateTail, TryStatement, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, EmptyStatement, getElements, getName, callQuestionDotToken, } from '../ast.js';
 import { getExternalModuleName, isImportCall, isInJSFile, isRequireCall } from '../ast-utilities.js';
 import { isAssignmentExpression, isDestructuringAssignment } from '../binder-utilities.js';
 import { JsxEmit, ModuleKind, ScriptTarget, getEmitModuleKind, getEmitScriptTarget, } from '../options.js';
@@ -869,7 +869,7 @@ export class CommonJSModuleTransformer extends Transformer {
         const callee = node.expression;
         if (callee instanceof Identifier) {
             const expression = this.visitExpressionIdentifier(callee);
-            const updated = this.factory.updateCallExpression(node, expression, node.questionDotToken, undefined, this.visitNodes(node.arguments), node.flags);
+            const updated = this.factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, this.visitNodes(node.arguments), node.flags);
             if (!(expression instanceof Identifier) && (this.context.getEmitFlags(callee) & 1024 /* EmitFlags.HelperName */) === 0)
                 this.context.addEmitFlags(updated, 1048576 /* EmitFlags.IndirectCall */);
             return updated;
@@ -938,7 +938,7 @@ export class CommonJSModuleTransformer extends Transformer {
             if (rewritten !== first || visitedRest !== rest)
                 args = new NodeList(args.pos, args.end, [rewritten].concat(visitedRest));
         }
-        return factory.updateCallExpression(node, expression, node.questionDotToken, undefined, args, node.flags);
+        return factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, args, node.flags);
     }
     visitTaggedTemplateExpression(node) {
         const tag = node.tag;

package/dist/api/compiler/transformers/declarations-pseudo.js

@@ -2,7 +2,7 @@
 // pseudochecker and the isolatedDeclarations rules. Annotations, literals, `as const` values
 // and function expressions with annotated returns have pseudo-types; everything else is
 // "inferred" and needs the checker.
-import { ArrayLiteralExpression, ArrowFunction, FunctionExpression, MethodDeclaration, GetAccessorDeclaration, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, PropertyDeclaration, ReturnStatement, SetAccessorDeclaration, TypeReferenceNode, VariableDeclaration, UnionTypeNode, IntersectionTypeNode, getAsteriskToken, getBody, getExpression, getName, getParameters, getPostfixToken, getSymbol, getType, getTypeParameters, } from '../ast.js';
+import { ArrayLiteralExpression, ArrowFunction, FunctionExpression, MethodDeclaration, GetAccessorDeclaration, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, PropertyDeclaration, ReturnStatement, SetAccessorDeclaration, TypeReferenceNode, VariableDeclaration, UnionTypeNode, IntersectionTypeNode, getAsteriskToken, getBody, getExpression, getName, getParameters, getPostfixToken, getSymbol, getType, getTypeParameters, propertyAssignmentPostfixToken, } from '../ast.js';
 import { isFunctionLike, nodeIsMissing } from '../ast-utilities.js';
 import { getCombinedNodeFlags, hasSyntacticModifier, isIdentifierNamed } from '../binder-utilities.js';
 import { getAllAccessorDeclarations } from './declarations-diagnostics.js';
@@ -416,7 +416,7 @@ export class PseudoChecker {
                 }
                 case 303 /* SyntaxKind.PropertyAssignment */: {
                     const assignment = property;
-                    const postfix = assignment.postfixToken;
+                    const postfix = propertyAssignmentPostfixToken(assignment);
                     members.push(new PseudoMember(1 /* PseudoMemberKind.Property */, assignment.name, postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */, false, undefined, [], [], this.typeFromExpression(assignment.initializer)));
                     break;
                 }

package/dist/api/compiler/transformers/module.js

@@ -1,6 +1,6 @@
 // `"use strict"` prologues and module output: ECMAScript modules, CommonJS, or each file in the
 // format its extension and package.json imply.
-import { CallExpression, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, MetaProperty, NamedExports, NamedImports, NamespaceExport, NamespaceImport, NodeList, SourceFile, StringLiteral, NoSubstitutionTemplateLiteral, Identifier, } from '../ast.js';
+import { CallExpression, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, MetaProperty, NamedExports, NamedImports, NamespaceExport, NamespaceImport, NodeList, SourceFile, StringLiteral, NoSubstitutionTemplateLiteral, Identifier, callQuestionDotToken, } from '../ast.js';
 import { isAnyImportOrReExport, isImportCall, isInJSFile, isRequireCall } from '../ast-utilities.js';
 import { JsxEmit, ModuleKind, getEmitModuleKind, getIsolatedModules } from '../options.js';
 import { isPrologueDirective } from '../printer/utilities.js';
@@ -257,7 +257,7 @@ export class ESModuleTransformer extends Transformer {
             ? rewriteModuleSpecifier(this.context, first, this.options)
             : factory.createRewriteRelativeImportExtensionsHelper(first, this.options.jsx === JsxEmit.Preserve);
         const rest = this.visitArray(args.slice(1));
-        return factory.updateCallExpression(node, this.visitNode(node.expression), node.questionDotToken, undefined, new NodeList(node.arguments.pos, node.arguments.end, [argument].concat(rest)), node.flags);
+        return factory.updateCallExpression(node, this.visitNode(node.expression), callQuestionDotToken(node), undefined, new NodeList(node.arguments.pos, node.arguments.end, [argument].concat(rest)), node.flags);
     }
     importAttributes(node) {
         const visited = this.visitNode(node);

package/dist/api/compiler/transformers/optional-chain.js

@@ -1,5 +1,5 @@
 // Lowers optional chains such as `a?.b.c()` to conditionals on `null` and `undefined` (ES2020).
-import { CallExpression, DeleteExpression, ElementAccessExpression, ParenthesizedExpression, PropertyAccessExpression, SyntheticReferenceExpression, TaggedTemplateExpression, } from '../ast.js';
+import { CallExpression, DeleteExpression, ElementAccessExpression, ParenthesizedExpression, PropertyAccessExpression, SyntheticReferenceExpression, TaggedTemplateExpression, callQuestionDotToken, newCallExpression, } from '../ast.js';
 import { skipParentheses } from '../binder-utilities.js';
 import { skipPartiallyEmittedExpressions } from '../printer/utilities.js';
 import { isSimpleCopiableExpression } from './destructuring.js';
@@ -147,7 +147,7 @@ export class OptionalChainTransformer extends Transformer {
                     rightExpression = factory.createFunctionCallCall(rightExpression, callThisArg, this.visitNodes(segment.arguments).nodes);
                 }
                 else
-                    rightExpression = factory.created(new CallExpression(rightExpression, undefined, undefined, this.visitNodes(segment.arguments), 0 /* NodeFlags.None */));
+                    rightExpression = factory.created(newCallExpression(rightExpression, undefined, undefined, this.visitNodes(segment.arguments), 0 /* NodeFlags.None */, false));
             }
             context.setOriginal(rightExpression, segment);
         }
@@ -169,7 +169,7 @@ function questionDotTokenOf(node) {
     if (node instanceof ElementAccessExpression)
         return node.questionDotToken;
     if (node instanceof CallExpression)
-        return node.questionDotToken;
+        return callQuestionDotToken(node);
     return undefined;
 }
 /** The expression a link of a chain accesses or calls. */

package/dist/api/compiler/transformers/subtree-facts.js

@@ -1,6 +1,6 @@
 // Whether a subtree contains TypeScript-only syntax, computed as tsgo's subtree facts are.
 // Transforms skip subtrees without it; that also decides how malformed code is emitted.
-import { ClassDeclaration, ClassExpression, ConstructorDeclaration, ExportAssignment, ExportDeclaration, ExportSpecifier, FunctionDeclaration, GetAccessorDeclaration, Identifier, ImportClause, ImportEqualsDeclaration, ImportSpecifier, MethodDeclaration, NodeVisitor, ParameterDeclaration, PropertyDeclaration, SetAccessorDeclaration, VariableDeclaration, VariableStatement, ArrowFunction, FunctionExpression, CallExpression, NewExpression, TaggedTemplateExpression, ExpressionWithTypeArguments, JsxOpeningElement, JsxSelfClosingElement, HeritageClause, getModifiers, } from '../ast.js';
+import { ClassDeclaration, ClassExpression, ConstructorDeclaration, ExportAssignment, ExportDeclaration, ExportSpecifier, FunctionDeclaration, GetAccessorDeclaration, Identifier, ImportClause, ImportEqualsDeclaration, ImportSpecifier, MethodDeclaration, NodeVisitor, ParameterDeclaration, PropertyDeclaration, SetAccessorDeclaration, VariableDeclaration, VariableStatement, ArrowFunction, FunctionExpression, CallExpression, NewExpression, TaggedTemplateExpression, ExpressionWithTypeArguments, JsxOpeningElement, JsxSelfClosingElement, HeritageClause, getModifiers, callTypeArguments, } from '../ast.js';
 import { ClusteredIntLinkTable } from '../link-tables.js';
 import { isTypeNodeKind } from '../printer/utilities.js';
 /** Memoized `containsTypeScript` answers for one emit. */
@@ -185,7 +185,7 @@ function ownFacts(node) {
                 ? 1 /* Facts.TypeScript */
                 : 0 /* Facts.None */;
         case 214 /* SyntaxKind.CallExpression */:
-            return node instanceof CallExpression && node.typeArguments !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+            return node instanceof CallExpression && callTypeArguments(node) !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
         case 215 /* SyntaxKind.NewExpression */:
             return node instanceof NewExpression && node.typeArguments !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
         case 216 /* SyntaxKind.TaggedTemplateExpression */:

package/dist/api/compiler/transformers/tagged-template.js

@@ -1,6 +1,6 @@
 // Lowers tagged templates with invalid escapes, allowed in tagged templates since ES2018, to
 // calls with a `__makeTemplateObject` template object.
-import { ArrayLiteralExpression, CallExpression, NoSubstitutionTemplateLiteral, SourceFile, TaggedTemplateExpression, TemplateExpression, TemplateMiddle, TemplateTail, } from '../ast.js';
+import { ArrayLiteralExpression, NoSubstitutionTemplateLiteral, SourceFile, TaggedTemplateExpression, TemplateExpression, TemplateMiddle, TemplateTail, newCallExpression, } from '../ast.js';
 import { getSourceTextOfNode } from '../printer/utilities.js';
 import { Transformer } from './transformer.js';
 import { isExternalModule } from './utilities.js';
@@ -83,7 +83,7 @@ export class TaggedTemplateTransformer extends Transformer {
             templateObject = factory.createLogicalOr(name, factory.createAssignment(name, helperCall));
         }
         args.unshift(templateObject);
-        const call = factory.created(new CallExpression(tag, undefined, undefined, factory.createNodeList(args), 0));
+        const call = factory.created(newCallExpression(tag, undefined, undefined, factory.createNodeList(args), 0, false));
         call.pos = node.pos;
         call.end = node.end;
         return call;