tsc-ts 0.0.5 → 0.0.7

package/src/compiler/checker-types.ts

@@ -388,23 +388,6 @@ export class TypeAlias {
   }
 }
 
-/** One entry of a `TypeListCache`: the parts of its key, its value, and the next entry with the same hash. */
-class TypeListEntry<V> {
-  readonly types: readonly Type[];
-  readonly alias: TypeAlias | undefined;
-  readonly tag: number;
-  value: V;
-  next: TypeListEntry<V> | undefined;
-
-  constructor(types: readonly Type[], alias: TypeAlias | undefined, tag: number, value: V) {
-    this.types = types;
-    this.alias = alias;
-    this.tag = tag;
-    this.value = value;
-    this.next = undefined;
-  }
-}
-
 function sameTypeListParts(a: readonly Type[], b: readonly Type[]): boolean {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) if (a[i]! !== b[i]!) return false;
@@ -421,34 +404,149 @@ function sameAliasParts(a: TypeAlias | undefined, b: TypeAlias | undefined): boo
  * aliasKey(alias)` plus a suffix spelled, without building them. A lookup takes a number hashing the
  * parts (`typeListHash`); entries keep their parts, so a match is exact and keys sharing a hash chain.
  * Like tsgo's hashed type list keys. A list must not change after it keys an entry.
+ *
+ * Entries are numbered in the order they are added: `heads` maps a hash to its first entry, and the
+ * lists and values of the entries are kept in arrays by number. Aliases, tags and the chains of
+ * entries that share a hash get arrays once an entry needs them.
  */
 export class TypeListCache<V> {
-  private readonly entries = new Map<number, TypeListEntry<V>>();
+  private heads: Map<number, number>;
+  private lists: (readonly Type[])[];
+  private values: V[];
+  private aliases: (TypeAlias | undefined)[] | undefined;
+  private tags: number[] | undefined;
+  /** The next entry with the same hash, or -1. */
+  private nexts: number[] | undefined;
+
+  constructor() {
+    this.heads = new Map<number, number>();
+    this.lists = [];
+    this.values = [];
+    this.aliases = undefined;
+    this.tags = undefined;
+    this.nexts = undefined;
+  }
 
   get(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number): V | undefined {
-    for (let e = this.entries.get(hash); e !== undefined; e = e.next)
-      if (e.tag === tag && sameTypeListParts(e.types, types) && sameAliasParts(e.alias, alias)) return e.value;
-    return undefined;
+    const entry = this.find(hash, types, alias, tag);
+    return entry >= 0 ? this.values[entry] : undefined;
   }
 
   set(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number, value: V): void {
-    const head = this.entries.get(hash);
+    const head = this.heads.get(hash);
+    if (head !== undefined) {
+      const entry = this.findFrom(head, types, alias, tag);
+      if (entry >= 0) {
+        this.values[entry] = value;
+        return;
+      }
+    }
+    const entry = this.lists.length;
+    this.lists.push(types);
+    this.values.push(value);
+    const aliases = this.aliases;
+    if (aliases !== undefined) aliases.push(alias);
+    else if (alias !== undefined) {
+      const created: (TypeAlias | undefined)[] = [];
+      for (let i = 0; i < entry; i++) created.push(undefined);
+      created.push(alias);
+      this.aliases = created;
+    }
+    const tags = this.tags;
+    if (tags !== undefined) tags.push(tag);
+    else if (tag !== 0) {
+      const created: number[] = [];
+      for (let i = 0; i < entry; i++) created.push(0);
+      created.push(tag);
+      this.tags = created;
+    }
+    let nexts = this.nexts;
+    if (nexts !== undefined) nexts.push(-1);
     if (head === undefined) {
-      this.entries.set(hash, new TypeListEntry(types, alias, tag, value));
+      this.heads.set(hash, entry);
       return;
     }
-    for (let e: TypeListEntry<V> | undefined = head; e !== undefined; e = e.next)
-      if (e.tag === tag && sameTypeListParts(e.types, types) && sameAliasParts(e.alias, alias)) {
-        e.value = value;
-        return;
-      }
-    const entry = new TypeListEntry(types, alias, tag, value);
-    entry.next = head.next;
-    head.next = entry;
+    // A second entry with this hash: chain it after the first.
+    if (nexts === undefined) {
+      nexts = [];
+      for (let i = 0; i <= entry; i++) nexts.push(-1);
+      this.nexts = nexts;
+    }
+    nexts[entry] = nexts[head]!;
+    nexts[head] = entry;
   }
 
   clear(): void {
-    this.entries.clear();
+    this.heads = new Map<number, number>();
+    this.lists = [];
+    this.values = [];
+    this.aliases = undefined;
+    this.tags = undefined;
+    this.nexts = undefined;
+  }
+
+  /** The number of the entry with these parts, or -1. */
+  private find(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number): number {
+    const head = this.heads.get(hash);
+    return head !== undefined ? this.findFrom(head, types, alias, tag) : -1;
+  }
+
+  private findFrom(head: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number): number {
+    const tags = this.tags;
+    const aliases = this.aliases;
+    const nexts = this.nexts;
+    for (let entry = head; entry >= 0; entry = nexts !== undefined ? nexts[entry]! : -1)
+      if (
+        (tags !== undefined ? tags[entry]! : 0) === tag &&
+        sameTypeListParts(this.lists[entry]!, types) &&
+        sameAliasParts(aliases !== undefined ? aliases[entry] : undefined, alias)
+      )
+        return entry;
+    return -1;
+  }
+}
+
+/**
+ * One list for each sequence of types that a checker keeps (`Checker.typeLists`): references and
+ * instantiation caches hold the same type arguments in many places, mostly lists of one or two types,
+ * and share one list for them. A list must not change once it is in the table.
+ */
+export class TypeListTable {
+  private readonly heads = new Map<number, number>();
+  private readonly lists: Type[][] = [];
+  /** The next list with the same hash, or -1, once two lists share one. */
+  private nexts: number[] | undefined = undefined;
+
+  /**
+   * The list in the table with the types of `types`, in order, or `types` itself, which joins the
+   * table. `hash` is `typeListHash(types, undefined, 0)`.
+   */
+  intern(hash: number, types: Type[]): Type[] {
+    if (types.length === 0) return types;
+    const head = this.heads.get(hash);
+    const nexts = this.nexts;
+    if (head !== undefined)
+      for (let entry = head; entry >= 0; entry = nexts !== undefined ? nexts[entry]! : -1) {
+        const list = this.lists[entry]!;
+        if (sameTypeListParts(list, types)) return list;
+      }
+    const entry = this.lists.length;
+    this.lists.push(types);
+    if (nexts !== undefined) nexts.push(-1);
+    if (head === undefined) {
+      this.heads.set(hash, entry);
+      return types;
+    }
+    // A second list with this hash: chain it after the first.
+    let chain = nexts;
+    if (chain === undefined) {
+      chain = [];
+      for (let i = 0; i <= entry; i++) chain.push(-1);
+      this.nexts = chain;
+    }
+    chain[entry] = chain[head]!;
+    chain[head] = entry;
+    return types;
   }
 }
 
@@ -505,7 +603,7 @@ export class TypeExtra implements ProgramLifetime {
   origin: Type | undefined;
   keyPropertyName: string;
   constituentMap: Map<Type, Type> | undefined;
-  constituentSet: Set<Type> | undefined;
+  constituentIds: Int32Array | undefined;
   membershipTests: number;
   // IntersectionType
   uniqueLiteralFilledInstantiation: Type | undefined;
@@ -519,7 +617,7 @@ export class TypeExtra implements ProgramLifetime {
     this.origin = undefined;
     this.keyPropertyName = '';
     this.constituentMap = undefined;
-    this.constituentSet = undefined;
+    this.constituentIds = undefined;
     this.membershipTests = 0;
     this.uniqueLiteralFilledInstantiation = undefined;
   }
@@ -1105,21 +1203,48 @@ export class EvolvingArrayType extends ObjectType {
   }
 }
 
-export class UnionOrIntersectionType extends StructuredType {
+/**
+ * A union or intersection. Few have their members resolved or their properties cached, so those
+ * live in `membersOf` (`UnionOrIntersectionMembers`), which is created when they are first written.
+ */
+export class UnionOrIntersectionType extends Type {
   readonly types: Type[];
-  propertyCache: SymbolTable | undefined;
-  propertyCacheWithoutFunctionPropertyAugment: SymbolTable | undefined;
-  resolvedProperties: Symbol[] | undefined;
+  membersOf: UnionOrIntersectionMembers | undefined;
 
   constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, types: Type[]) {
     super(flags, objectFlags, id, undefined);
     this.types = types;
+    this.membersOf = undefined;
+  }
+}
+
+/**
+ * The resolved members of a union or intersection (`membersHolder`) and the caches of its
+ * properties, created on first use.
+ */
+export class UnionOrIntersectionMembers extends StructuredType {
+  propertyCache: SymbolTable | undefined;
+  propertyCacheWithoutFunctionPropertyAugment: SymbolTable | undefined;
+  resolvedProperties: Symbol[] | undefined;
+
+  constructor(flags: TypeFlags, id: number) {
+    super(flags, ObjectFlags.None, id, undefined);
     this.propertyCache = undefined;
     this.propertyCacheWithoutFunctionPropertyAugment = undefined;
     this.resolvedProperties = undefined;
   }
 }
 
+/** The members holder of a union or intersection, created if it has none yet. */
+export function unionOrIntersectionMembers(t: UnionOrIntersectionType): UnionOrIntersectionMembers {
+  let members = t.membersOf;
+  if (members === undefined) {
+    members = new UnionOrIntersectionMembers(t.flags, t.id);
+    t.membersOf = members;
+  }
+  return members;
+}
+
 /** A union; all of its own fields are rarely set and live in `extra`. */
 export class UnionType extends UnionOrIntersectionType {
   constructor(objectFlags: ObjectFlags, id: number, types: Type[]) {
@@ -1173,14 +1298,18 @@ export class UnionType extends UnionOrIntersectionType {
     if (map !== undefined || this.extra !== undefined) typeExtra(this).constituentMap = map;
   }
 
-  /** The constituents of a large union, for membership tests; created on the second test. */
-  get constituentSet(): Set<Type> | undefined {
+  /**
+   * A hash table of the ids of a large union's constituents, for membership tests; created on the
+   * second test (`constituentTable`). About eight bytes a constituent, where a set of them took
+   * about five times that.
+   */
+  get constituentIds(): Int32Array | undefined {
     const extra = this.extra;
-    return extra !== undefined ? extra.constituentSet : undefined;
+    return extra !== undefined ? extra.constituentIds : undefined;
   }
 
-  set constituentSet(set: Set<Type> | undefined) {
-    if (set !== undefined || this.extra !== undefined) typeExtra(this).constituentSet = set;
+  set constituentIds(ids: Int32Array | undefined) {
+    if (ids !== undefined || this.extra !== undefined) typeExtra(this).constituentIds = ids;
   }
 
   get membershipTests(): number {
@@ -1694,6 +1823,45 @@ export class ArrayTypeMapper extends TypeMapper {
   mapsThisOnly(): boolean {
     return this.sources.length === 1 && isThisTypeParameter(this.sources[0]!);
   }
+
+  /** The number of targets, one per source. */
+  targetCount(): number {
+    return this.targets.length;
+  }
+
+  /** The target of the source at `index`. */
+  targetAt(index: number): Type {
+    return this.targets[index]!;
+  }
+}
+
+/**
+ * The mapper of a type reference's members: its type arguments, then the reference itself for the
+ * last source, the class or interface's `this` type. `targets` holds the type arguments only, so the
+ * reference's own list serves without a copy that adds the reference.
+ */
+export class ThisArgumentTypeMapper extends ArrayTypeMapper {
+  readonly thisTarget: Type;
+
+  constructor(sources: Type[], typeArguments: Type[], thisTarget: Type) {
+    super(sources, typeArguments);
+    this.thisTarget = thisTarget;
+  }
+
+  map(type: Type): Type {
+    const sources = this.sources;
+    const last = sources.length - 1;
+    for (let i = 0; i < last; i++) if (type === sources[i]!) return this.targets[i]!;
+    return type === sources[last]! ? this.thisTarget : type;
+  }
+
+  targetCount(): number {
+    return this.targets.length + 1;
+  }
+
+  targetAt(index: number): Type {
+    return index < this.targets.length ? this.targets[index]! : this.thisTarget;
+  }
 }
 
 /**
@@ -1771,6 +1939,18 @@ export function newTypeMapper(sources: Type[], targets: Type[]): TypeMapper {
     : new ArrayTypeMapper(sources, targets);
 }
 
+/** `newTypeMapper(sources, [...typeArguments, thisTarget])`, without building that list where it can. */
+export function newThisArgumentTypeMapper(sources: Type[], typeArguments: Type[], thisTarget: Type): TypeMapper {
+  if (sources.length === 1) return new SimpleTypeMapper(sources[0]!, thisTarget);
+  if (sources.length >= indexedTypeMapperThreshold) {
+    const targets: Type[] = [];
+    for (const t of typeArguments) targets.push(t);
+    targets.push(thisTarget);
+    return new IndexedArrayTypeMapper(sources, targets);
+  }
+  return new ThisArgumentTypeMapper(sources, typeArguments, thisTarget);
+}
+
 export function mergeTypeMappers(m1: TypeMapper | undefined, m2: TypeMapper): TypeMapper {
   return m1 !== undefined ? new MergedTypeMapper(m1, m2) : m2;
 }

package/src/compiler/checker-unused.ts

@@ -49,7 +49,6 @@ import {
 } from './binder-utilities.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
 import { Diagnostic, DiagnosticCategory, Diagnostics } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { getResolvedSymbol } from './checker-expressions.js';
@@ -61,6 +60,7 @@ import type { Type } from './checker-types.js';
 import { getLiteralTypeFromPropertyName } from './checker-type-operators.js';
 import { getPropertyOfType } from './checker-members.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName } from './checker-utilities.js';
+import { CheckFlags, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 // ---- References
 
@@ -438,7 +438,7 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
       (local.flags & SymbolFlags.ModuleExports) !== 0
     )
       continue;
-    for (const declaration of local.declarations) {
+    for (const declaration of getDeclarations(local)) {
       switch (declaration.kind) {
         case SyntaxKind.VariableDeclaration:
         case SyntaxKind.Parameter:
@@ -634,7 +634,7 @@ function isUnreferencedTypeParameter(c: Checker, typeParameter: Node): boolean {
 }
 
 function allDeclarationsInSameSourceFile(symbol: Symbol): boolean {
-  const declarations = symbol.declarations;
+  const declarations = getDeclarations(symbol);
   if (declarations.length <= 1) return true;
   const file = getSourceFileOfNode(declarations[0]!);
   for (let i = 1; i < declarations.length; i++) if (getSourceFileOfNode(declarations[i]!) !== file) return false;

package/src/compiler/checker.ts

@@ -33,7 +33,7 @@ import type { DeferredCollisionCheck } from './checker-generated-code.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import { sideOf } from './side-state.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics, compareDiagnostics } from './diagnostics.js';
 import {
@@ -66,11 +66,13 @@ import {
   emptyTypes,
   VarianceFlags,
   TypeListCache,
+  TypeListTable,
   type ConditionalType,
   type InterfaceType,
   type TypeChecking,
 } from './checker-types.js';
 import { getBaseTypes } from './checker-declared-types.js';
+import type { ModuleResolution } from './checker-modules.js';
 import { getFalseTypeFromConditionalType, getTrueTypeFromConditionalType } from './checker-type-operators.js';
 import {
   createArrayType,
@@ -107,11 +109,11 @@ import type { FlowNode, FlowReduceLabel } from './flow.js';
 import { JsxState } from './checker-jsx.js';
 import type { DeferredIterationError, IterationTypes } from './checker-iteration.js';
 import type { SpreadIndices } from './checker-contextual.js';
-import type { SlotSiblingProperties } from './checker-symbol-types.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile } 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 abstract class CheckerHost {
@@ -264,6 +266,23 @@ function stableSort(list: Diagnostic[]): void {
 /** Maximum depth of nested `typeToString` calls before diagnostics are discarded. */
 export const maxSerializationLevel = 2;
 
+/**
+ * File positions per symbol id in `ExternalModuleContainerIndex.keys`. Symbol ids are int32, so the
+ * keys stay exact.
+ */
+export const fileIndexScale = 2 ** 21;
+
+/** The modules that export each symbol, built once from every module's exports. */
+export class ExternalModuleContainerIndex {
+  complete = false;
+  /**
+   * One key per symbol and module that exports it, ascending: the id of the symbol the export
+   * resolves to times `fileIndexScale`, plus the module's file position in `Checker.files`. The
+   * keys of one symbol are contiguous and in program order.
+   */
+  keys: number[] = [];
+}
+
 /** The checker's caches for symbol accessibility. */
 export class SymbolAccessibilityCaches {
   /** Accessible chains by symbol id, then by `chainCacheKey`. */
@@ -274,6 +293,8 @@ export class SymbolAccessibilityCaches {
   readonly containersByFile = new Map<number, Map<number, Symbol[]>>();
   /** All modules that export a symbol, by symbol id. */
   readonly containers = new Map<number, Symbol[]>();
+  /** The modules each symbol is exported from, built on the first search of all modules. */
+  externalModuleContainers: ExternalModuleContainerIndex | undefined = undefined;
   /** The name tables of named class expressions, by node id. */
   readonly classExpressionNames = new Map<number, SymbolTable>();
   /** Computed declaration visibility by node id (see isDeclarationVisible), 0 if not computed. */
@@ -326,6 +347,15 @@ export class Checker implements TypeChecking {
 
   readonly diagnostics = new DiagnosticCollection();
   readonly 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). */
+  readonly moduleResolutions = new 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 = false;
   /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
   readonly moduleSpecifiers = new Map<string, string>();
   /** Specifier generation for hosts without a program. */
@@ -340,6 +370,11 @@ export class Checker implements TypeChecking {
   readonly sideHolders = new LinkTable<Type>();
   /** The same for signatures with side state (`signatureSideOf`), by signature id. */
   readonly signatureSideHolders = new 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 = new Map<Symbol[], PropertyListIndex | number | null>();
   /** The type of a value symbol. */
   readonly symbolTypes = new LinkTable<Type>();
   /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -360,7 +395,7 @@ export class Checker implements TypeChecking {
   /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
   readonly symbolReferenceKinds = new IntLinkTable();
   /** The resolved symbol of an identifier, entity name or call. */
-  readonly resolvedSymbols = new SparseLinkTable<Symbol>();
+  readonly resolvedSymbols = new CompactSymbolLinkTable();
   /** The resolved type of a type node or expression. */
   readonly resolvedTypes = new SparseLinkTable<Type>();
   /** The resolved signature of a call-like node or a signature declaration. */
@@ -398,10 +433,6 @@ export class Checker implements TypeChecking {
   readonly unresolvedSymbols = new Map<string, Symbol>();
   /** Widening's optional `undefined` properties by the id of the property each is created from. */
   readonly undefinedProperties = new Map<number, Symbol>();
-  /** By file and name, the property that widening's optional `undefined` properties are created from. */
-  readonly firstSiblingProperties = new Map<SourceFile, Map<string, Node>>();
-  /** By tsgo checker, the first sibling properties of its files (firstSiblingProperty). */
-  readonly slotSiblingProperties = new Map<number, SlotSiblingProperties>();
 
   // Interning tables.
   readonly stringLiteralTypes = new Map<string, LiteralType>();
@@ -421,6 +452,8 @@ export class Checker implements TypeChecking {
   readonly templateLiteralTypes = new Map<string, Type>();
   /** Instantiations of template literal types: the instantiated types, tagged with the template's id. */
   readonly templateLiteralInstantiations = new TypeListCache<Type>();
+  /** The type argument lists that references and instantiations keep, one of each (`TypeListTable`). */
+  readonly typeLists = new TypeListTable();
   readonly stringMappingTypes = new Map<string, Type>();
   readonly substitutionTypes = new Map<string, Type>();
   readonly subtypeReductionCache = new TypeListCache<Type[]>();
@@ -558,6 +591,13 @@ export class Checker implements TypeChecking {
    */
   readonly freeMapperCaches: Map<number, Type>[] = [];
   freeMapperCacheCount = 0;
+  /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
+  readonly freeTypeLists: Type[][] = [];
+  /**
+   * 1 by type id for the anonymous and mapped types whose declaration has no outer type parameters
+   * to instantiate (`getObjectTypeInstantiation`).
+   */
+  readonly withoutOuterTypeParameters = new IntLinkTable();
   conditionalConstraintDepth = 0;
 
   readonly suggestionResolver: SuggestionNameResolver;
@@ -870,6 +910,7 @@ export class Checker implements TypeChecking {
     this.diagnostics.startLog();
     this.suggestionDiagnostics.startLog();
     mergeAmbientModulesAndAugmentations(this);
+    this.modulesMerged = true;
     this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
   }
 
@@ -1002,11 +1043,13 @@ export class Checker implements TypeChecking {
   }
 
   addDiagnostic(diagnostic: Diagnostic): void {
+    this.reports++;
     // Discard diagnostics created while at the maximum number of nested typeToString calls.
     if (this.serializationLevel < maxSerializationLevel) this.diagnostics.add(diagnostic);
   }
 
   addSuggestion(diagnostic: Diagnostic): void {
+    this.reports++;
     this.suggestionDiagnostics.add(diagnostic);
   }
 
@@ -1051,8 +1094,6 @@ export function disposeChecker(c: Checker): void {
   c.symbolAccessibilityCaches = undefined;
   c.unresolvedSymbols.clear();
   c.undefinedProperties.clear();
-  c.firstSiblingProperties.clear();
-  c.slotSiblingProperties.clear();
   c.stringLiteralTypes.clear();
   c.numberLiteralTypes.clear();
   c.bigintLiteralTypes.clear();

package/src/compiler/decoder.ts

@@ -13,7 +13,6 @@ import {
   BindingPattern,
   Block,
   BreakStatement,
-  CallExpression,
   CallSignatureDeclaration,
   CaseBlock,
   CaseOrDefaultClause,
@@ -149,7 +148,6 @@ import {
   PrefixUnaryExpression,
   PrivateIdentifier,
   PropertyAccessExpression,
-  PropertyAssignment,
   PropertyDeclaration,
   PropertySignatureDeclaration,
   QualifiedName,
@@ -197,6 +195,8 @@ import {
   WhileStatement,
   WithStatement,
   YieldExpression,
+  newCallExpression,
+  newPropertyAssignment,
 } from './ast.js';
 import { modifiersToFlags } from './ast-utilities.js';
 import { protocolVersion } from './encoder.js';
@@ -883,7 +883,7 @@ class Decoder {
       case SyntaxKind.ElementAccessExpression:
         return new ElementAccessExpression(this.required(0), this.token(1), this.required(2), 0);
       case SyntaxKind.CallExpression:
-        return new CallExpression(this.required(0), this.token(1), this.list(2), this.requiredList(3), 0);
+        return newCallExpression(this.required(0), this.token(1), this.list(2), this.requiredList(3), 0, false);
       case SyntaxKind.NewExpression:
         return new NewExpression(this.required(0), this.list(1), this.list(2));
       case SyntaxKind.MetaProperty:
@@ -910,12 +910,13 @@ class Decoder {
       case SyntaxKind.SpreadAssignment:
         return new SpreadAssignment(this.required(0));
       case SyntaxKind.PropertyAssignment:
-        return new PropertyAssignment(
+        return newPropertyAssignment(
           this.modifiers(0),
           this.required(1),
           this.token(2),
           this.node(3),
           this.required(4),
+          false,
         );
       case SyntaxKind.ShorthandPropertyAssignment:
         return new ShorthandPropertyAssignment(