tsc-ts 0.0.5 → 0.0.6

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,6 +66,7 @@ import {
   emptyTypes,
   VarianceFlags,
   TypeListCache,
+  TypeListTable,
   type ConditionalType,
   type InterfaceType,
   type TypeChecking,
@@ -107,7 +108,6 @@ 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';
@@ -264,6 +264,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 +291,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. */
@@ -360,7 +379,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 +417,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 +436,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 +575,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;
@@ -1051,8 +1075,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/diagnostics.ts

@@ -2,7 +2,7 @@
  * Diagnostics: message lookup and localization, the `Diagnostic` type, and tsc's plain and
  * pretty diagnostic output.
  */
-import { CharacterCodes, isDigit, isUnicodeWhiteSpace, utf8Length } from './character-codes.js';
+import { isDigit, isUnicodeWhiteSpace, utf8Length } from './character-codes.js';
 import { Locale, translations } from './diagnostic-locales.js';
 import { Diagnostics, messageCodes, messageFlags, messageKeys, messageTexts } from './diagnostic-messages.js';
 import { getPathComponentsRelativeTo, getPathFromPathComponents, isRootedDiskPath, pathIsAbsolute } from './path.js';
@@ -146,15 +146,15 @@ function toWellFormed(text: string): string {
 /**
  * Where this thread computes the line starts and UTF-8 offsets of files that may be shared with other
  * threads (`useThreadTextCaches`): a copy of each such file, by file, that computes them in place.
- * Files leave the parser with line starts, except declaration files, and without UTF-8 offsets.
+ * Files leave the parser without line starts and UTF-8 offsets, except JSON files, which have line
+ * starts.
  */
 let threadCopies: Map<DiagnosticFile, DiagnosticFile> | undefined = undefined;
 
 /**
  * Makes this thread compute the caches of files that do not have them yet in copies of its own: the
- * files may be published (immutable) and shared with other threads. Declaration files leave the
- * parser without them (`Parser.parseSourceFile`): they make up most of the text of a typical program,
- * and are rarely checked or pointed into by a diagnostic.
+ * files may be published (immutable) and shared with other threads. Files leave the parser without
+ * them (`Parser.parseSourceFile`): most files are never pointed into by a diagnostic.
  */
 export function useThreadTextCaches(): void {
   if (threadCopies === undefined) threadCopies = new Map<DiagnosticFile, DiagnosticFile>();
@@ -174,15 +174,6 @@ function threadCopyOf(file: DiagnosticFile): DiagnosticFile | undefined {
   return copy;
 }
 
-/** The position of the first code unit at or after `pos` that is a CR or below, or not ASCII; or `end`. */
-function skipPlainASCII(units: Uint16Array, pos: number, end: number): number {
-  for (let i = pos | 0; i < end; i = (i + 1) | 0) {
-    const c = units[i] | 0;
-    if (c <= CharacterCodes.carriageReturn || c >= 0x80) return i;
-  }
-  return end;
-}
-
 /** The text of a file diagnostics point into. */
 export class DiagnosticFile {
   readonly fileName: string;
@@ -206,36 +197,6 @@ export class DiagnosticFile {
     if (this.lineStarts.length === 0) this.lineStarts = computeLineStarts(this.text);
   }
 
-  /**
-   * Like `computeCaches`, from the text's UTF-16 code units `units[0, text.length)`, so the text
-   * itself is neither searched nor copied.
-   */
-  computeCachesFromUnits(units: Uint16Array): void {
-    const text = this.text;
-    // ASCII texts are searched faster than walked.
-    if (this.lineStarts.length !== 0 || Buffer.byteLength(text, 'utf8') === text.length) {
-      this.computeCaches();
-      return;
-    }
-    const length = text.length | 0;
-    const lineStarts: number[] = [0];
-    // Visit only the code units that may break a line; `skipPlainASCII` runs over the rest without
-    // calls, so native builds keep its loop on registers. A CR followed by an LF leaves the line start
-    // to the LF.
-    for (let i = skipPlainASCII(units, 0, length); i < length; i = skipPlainASCII(units, (i + 1) | 0, length)) {
-      const ch = units[i] | 0;
-      if (
-        ch === CharacterCodes.lineFeed ||
-        (ch === CharacterCodes.carriageReturn &&
-          (i + 1 >= length || (units[(i + 1) | 0] | 0) !== CharacterCodes.lineFeed)) ||
-        ch === CharacterCodes.lineSeparator ||
-        ch === CharacterCodes.paragraphSeparator
-      )
-        lineStarts.push(i + 1);
-    }
-    this.lineStarts = lineStarts;
-  }
-
   /** Start offsets of each line, split at CR, LF, CRLF, LS and PS. */
   getLineStarts(): readonly number[] {
     if (this.lineStarts.length === 0) {