tsc-ts 0.0.9 → 0.1.0

package/src/compiler/program-utilities.ts

@@ -4,6 +4,7 @@
 import {
   ExportDeclaration,
   ExternalModuleIndicatorOptions,
+  Identifier,
   ImportAttribute,
   ImportAttributes,
   ImportClause,
@@ -19,7 +20,7 @@ import {
   type Node,
   type SourceFile,
 } from './ast.js';
-import { isImportCall, isRequireCall } from './ast-utilities.js';
+import { isImportCall, isRequireCall, isSourcePhaseImportCall } from './ast-utilities.js';
 import { libMap } from './option-declarations.js';
 import {
   getEmitModuleDetectionKind,
@@ -59,6 +60,8 @@ export function getDefaultLibFileName(options: CompilerOptions): string {
   switch (getEmitScriptTarget(options)) {
     case ScriptTarget.ESNext:
       return 'lib.esnext.full.d.ts';
+    case ScriptTarget.ES2026:
+      return 'lib.es2026.full.d.ts';
     case ScriptTarget.ES2025:
       return 'lib.es2025.full.d.ts';
     case ScriptTarget.ES2024:
@@ -115,6 +118,8 @@ export function scriptTargetName(target: ScriptTarget): string {
       return 'ES2024';
     case ScriptTarget.ES2025:
       return 'ES2025';
+    case ScriptTarget.ES2026:
+      return 'ES2026';
     case ScriptTarget.ESNext:
       return 'ESNext';
     case ScriptTarget.JSON:
@@ -316,21 +321,27 @@ function literalText(node: Node): string {
 
 /** The `resolution-mode` of `import type` attributes, or `None`. */
 export function getResolutionModeOverride(attributes: ImportAttributes | undefined): ModuleKind {
-  if (attributes === undefined) return ModuleKind.None;
-  const elements = attributes.attributes.nodes;
-  if (elements.length !== 1) return ModuleKind.None;
-  const attribute = elements[0]!;
-  if (!(attribute instanceof ImportAttribute)) return ModuleKind.None;
-  const name = attribute.name;
-  if (name === undefined || !isStringLiteralLike(name) || literalText(name) !== 'resolution-mode')
-    return ModuleKind.None;
-  if (!isStringLiteralLike(attribute.value)) return ModuleKind.None;
+  const attribute = resolutionModeAttribute(attributes);
+  if (attribute === undefined || !isStringLiteralLike(attribute.value)) return ModuleKind.None;
   const text = literalText(attribute.value);
   if (text === 'import') return ModuleKind.ESNext;
   if (text === 'require') return ModuleKind.CommonJS;
   return ModuleKind.None;
 }
 
+/** The `resolution-mode` attribute among import attributes, as tsgo's `GetResolutionModeOverride` finds it. */
+export function resolutionModeAttribute(attributes: ImportAttributes | undefined): ImportAttribute | undefined {
+  if (attributes === undefined) return undefined;
+  for (const attribute of attributes.attributes.nodes) {
+    if (!(attribute instanceof ImportAttribute)) continue;
+    const name = attribute.name;
+    if (name === undefined) continue;
+    const text = name instanceof Identifier ? name.text : literalText(name);
+    if (text === 'resolution-mode') return attribute;
+  }
+  return undefined;
+}
+
 /** The attributes of an import or export declaration or a JSDoc `@import`, if any. */
 function importOrExportAttributes(node: Node | undefined): ImportAttributes | undefined {
   if (node instanceof ImportDeclaration) return node.attributes;
@@ -404,6 +415,8 @@ export function getEmitSyntaxForUsageLocation(
   const fileEmitMode = getEmitModuleFormatOfFile(fileName, options, metadata);
   const call = walkUpParenthesizedExpressions(parent);
   if (call !== undefined && isImportCall(call)) {
+    // `import.source()` is never transformed to `require`.
+    if (isSourcePhaseImportCall(call)) return ModuleKind.ESNext;
     return shouldTransformImportCall(options, fileEmitMode) ? ModuleKind.CommonJS : ModuleKind.ESNext;
   }
   if (fileEmitMode === ModuleKind.CommonJS) return ModuleKind.CommonJS;

package/src/compiler/program.ts

@@ -27,6 +27,7 @@ import {
   equalDiagnosticsNoRelatedInfo,
   type DiagnosticMessage,
   type Locale,
+  sortDiagnostics,
   useThreadTextCaches,
 } from './diagnostics.js';
 import {
@@ -84,6 +85,7 @@ import {
   pathIsRelative,
   toFileNameLowerCase,
   toPath,
+  isNetworkPathValue,
 } from './path.js';
 import {
   getDefaultResolutionModeForFile,
@@ -105,6 +107,7 @@ import {
   type SourceOutputAndProjectReference,
 } from './tsconfig.js';
 import { SyntaxKind } from './syntax-kind.js';
+import { isSourcePhaseImport } from './ast-utilities.js';
 import { KnownSymlinks } from './symlinks.js';
 import { mark } from './timeline.js';
 import { LanguageVariant } from './types.js';
@@ -293,6 +296,11 @@ export class Program implements OutputPathsHost {
     return this.processed.redirectTargets.get(path) ?? [];
   }
 
+  /** The nearest `package.json` lookup at or above `directory`. */
+  getPackageScopeForPath(directory: string): PackageJsonInfo | undefined {
+    return this.processed.resolver.getPackageScopeForPath(directory);
+  }
+
   /** The directory of the nearest `package.json` at or above `directory`, or `''`. */
   getNearestAncestorDirectoryWithPackageJson(directory: string): string {
     const scope = this.processed.resolver.getPackageScopeForPath(directory);
@@ -361,7 +369,8 @@ export class Program implements OutputPathsHost {
         )
           continue;
         const resolved = resolver.resolvePackageDirectory(dependency, packageJsonName, ModuleKind.CommonJS);
-        if (resolved !== undefined && resolved.resolvedFileName !== '')
+        // A dependency installed in place has no original path to map from.
+        if (resolved !== undefined && resolved.resolvedFileName !== '' && resolved.originalPath !== '')
           symlinks.processResolution(
             combinePaths(resolved.originalPath, 'package.json'),
             combinePaths(resolved.resolvedFileName, 'package.json'),
@@ -455,30 +464,9 @@ export class Program implements OutputPathsHost {
     return this.processed.resolvedModules.get(file.path)?.get(modeAwareKey(moduleName, mode));
   }
 
-  /** The program files that the imports and type reference directives of `file` resolved to. */
-  /**
-   * The files `file` imports and references through type directives. `byFileName`, the program's
-   * files by file name, finds a file without computing its path when it is resolved by that name.
-   */
-  getResolvedFilesOf(file: SourceFile, byFileName?: ReadonlyMap<string, SourceFile>): SourceFile[] {
-    const result: SourceFile[] = [];
-    const modules = this.processed.resolvedModules.get(file.path);
-    if (modules !== undefined)
-      for (const resolved of modules.values()) {
-        const name = resolved.resolvedFileName;
-        if (name === '') continue;
-        const target = byFileName?.get(name) ?? this.getSourceFileForResolvedModule(name);
-        if (target !== undefined) result.push(target);
-      }
-    const types = this.processed.typeResolutionsInFile.get(file.path);
-    if (types !== undefined)
-      for (const resolved of types.values()) {
-        const name = resolved.resolvedFileName;
-        if (name === '') continue;
-        const target = byFileName?.get(name) ?? this.getSourceFile(name);
-        if (target !== undefined) result.push(target);
-      }
-    return result;
+  /** The files each file added to the program (`ProcessedFiles.addedFiles`), as indices of `getSourceFiles`. */
+  addedFiles(): readonly (readonly number[])[] {
+    return this.processed.addedFiles;
   }
 
   /** The specifier of the implicit JSX runtime import of `file`, if any. */
@@ -487,6 +475,8 @@ export class Program implements OutputPathsHost {
   }
 
   getResolvedModuleFromModuleSpecifier(file: SourceFile, specifier: Node): ResolvedModule | undefined {
+    // A source phase import loads no module declarations.
+    if (specifier.parent !== undefined && isSourcePhaseImport(specifier.parent)) return undefined;
     const text = specifierText(specifier);
     return this.getResolvedModule(file, text, this.getModeForUsageLocation(file, specifier));
   }
@@ -935,6 +925,8 @@ export class Program implements OutputPathsHost {
               Diagnostics.Non_relative_paths_are_not_allowed_Did_you_forget_a_leading_Slash,
               [],
             );
+          } else if (isNetworkPathValue(substitution, options.pathsBasePath ?? this.currentDirectory)) {
+            this.pathsValueDiagnostic(key, i, Diagnostics.Network_path_0_is_not_supported, [substitution]);
           }
         }
       }
@@ -1398,7 +1390,7 @@ class NodeCollector extends NodeVisitor {
 
 /** Sorts diagnostics and merges duplicates, combining their related information. */
 export function sortAndDeduplicateDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[] {
-  const sorted = [...diagnostics].sort(compareDiagnostics);
+  const sorted = sortDiagnostics(diagnostics);
   if (sorted.length < 2) return sorted;
   const result: Diagnostic[] = [];
   let i = 0;

package/src/compiler/pseudo-bigint.ts

@@ -60,3 +60,20 @@ export function parsePseudoBigInt(literal: string): string {
   }
   return result;
 }
+
+/** Compares two bigint values in decimal, each optionally prefixed with `-`, by numeric value. */
+export function comparePseudoBigInts(a: string, b: string): number {
+  const negative = a.charCodeAt(0) === CharacterCodes.minus;
+  const r = pseudoBigIntSign(a) - pseudoBigIntSign(b);
+  if (r !== 0) return r;
+  const digitsA = negative ? a.substring(1) : a;
+  const digitsB = negative ? b.substring(1) : b;
+  let magnitude = digitsA.length - digitsB.length;
+  if (magnitude === 0) magnitude = digitsA < digitsB ? -1 : digitsA > digitsB ? 1 : 0;
+  return negative ? -magnitude : magnitude;
+}
+
+function pseudoBigIntSign(value: string): number {
+  if (value.charCodeAt(0) === CharacterCodes.minus) return -1;
+  return value === '0' ? 0 : 1;
+}

package/src/compiler/regexp-checker.ts

@@ -9,7 +9,7 @@ import {
 } from './character-codes.js';
 import { Diagnostics } from './diagnostic-messages.js';
 import type { DiagnosticMessage } from './diagnostics.js';
-import type { Scanner } from './scanner.js';
+import { IdentifierVariant, type Scanner } from './scanner.js';
 import { getSpellingSuggestion } from './spelling.js';
 import { ScriptTarget } from './types.js';
 import {
@@ -243,13 +243,24 @@ class RegularExpressionChecker {
 
   // Disjunction ::= Alternative ('|' Alternative)*
   private scanDisjunction(isInGroup: boolean): void {
+    // The names any alternative defines. One alternative matches, so in a group they join the
+    // enclosing alternative's scope: `(?:(?<a>x))(?<a>z)` defines `a` twice.
+    let disjunctionNames: Set<string> | undefined;
     for (;;) {
       this.namedCapturingGroups.push(new Set<string>());
       this.scanAlternative(isInGroup);
-      this.namedCapturingGroups.pop();
-      if (this.char() !== CharacterCodes.bar) return;
+      const alternativeNames = this.namedCapturingGroups.pop()!;
+      if (alternativeNames.size > 0) {
+        if (disjunctionNames === undefined) disjunctionNames = new Set<string>();
+        for (const name of alternativeNames) disjunctionNames.add(name);
+      }
+      if (this.char() !== CharacterCodes.bar) break;
       this.scanner.pos = (this.scanner.pos + 1) | 0;
     }
+    if (isInGroup && disjunctionNames !== undefined && this.namedCapturingGroups.length > 0) {
+      const parentScope = this.namedCapturingGroups[this.namedCapturingGroups.length - 1]!;
+      for (const name of disjunctionNames) parentScope.add(name);
+    }
   }
 
   // Alternative ::= Term*
@@ -317,6 +328,14 @@ class RegularExpressionChecker {
                     noArgs,
                   );
               }
+              // Modifier characters make this `(?flags:` rather than a plain `(?:` group.
+              if (this.scanner.pos !== flagsStart && this.scanner.languageVersion() < ScriptTarget.ES2025)
+                this.error(
+                  Diagnostics.Regular_expression_pattern_modifiers_are_only_available_when_targeting_0_or_later,
+                  flagsStart,
+                  this.scanner.pos - flagsStart,
+                  ['es2025'],
+                );
               this.scanExpectedChar(CharacterCodes.colon);
               isPreviousTermQuantifiable = true;
             }
@@ -443,10 +462,8 @@ class RegularExpressionChecker {
           size,
           noArgs,
         );
-      else {
-        currentFlags |= flag;
-        this.scanner.checkRegularExpressionFlagAvailability(flag, this.scanner.pos, size);
-      }
+      // Modifiers need ES2025, later than any flag they can toggle, and the group reports that.
+      else currentFlags |= flag;
       this.scanner.pos = (this.scanner.pos + size) | 0;
     }
     return currentFlags;
@@ -545,9 +562,8 @@ class RegularExpressionChecker {
   private scanGroupName(isReference: boolean): void {
     const scanner = this.scanner;
     scanner.tokenStart = this.scanner.pos | 0;
-    scanner.scanIdentifier(0);
     const start = scanner.tokenStart;
-    if (this.scanner.pos === start) {
+    if (!scanner.scanIdentifier(0, IdentifierVariant.RegExpGroupName)) {
       this.error(Diagnostics.Expected_a_capturing_group_name, this.scanner.pos, 0, noArgs);
       return;
     }
@@ -562,6 +578,20 @@ class RegularExpressionChecker {
         noArgs,
       );
     } else {
+      // An earlier definition is in a mutually exclusive alternative. Below ES2018 the group is
+      // reported already.
+      const languageVersion = this.scanner.languageVersion();
+      if (
+        this.groupSpecifiers.has(name) &&
+        languageVersion >= ScriptTarget.ES2018 &&
+        languageVersion < ScriptTarget.ES2025
+      )
+        this.error(
+          Diagnostics.Duplicate_named_capturing_groups_are_only_available_when_targeting_0_or_later,
+          start,
+          this.scanner.pos - start,
+          ['es2025'],
+        );
       if (this.namedCapturingGroups.length > 0)
         this.namedCapturingGroups[this.namedCapturingGroups.length - 1]!.add(name);
       this.groupSpecifiers.add(name);
@@ -667,9 +697,6 @@ class RegularExpressionChecker {
           this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
           return this.mayContainStrings;
         }
-        this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos, 1, [
-          String.fromCharCode(ch),
-        ]);
         break;
       default:
         if (isCharacterComplement && this.mayContainStrings)
@@ -730,29 +757,26 @@ class RegularExpressionChecker {
         } else if (operand >= 0 && secondOperand >= 0 && operand > secondOperand) {
           this.error(Diagnostics.Range_out_of_order_in_character_class, start, this.scanner.pos - start, noArgs);
         }
-      } else if (ch === CharacterCodes.ampersand) {
+      } else if (
+        ch === CharacterCodes.ampersand &&
+        this.scanner.pos + 1 < this.end &&
+        this.charAt(this.scanner.pos + 1) === CharacterCodes.ampersand
+      ) {
         start = this.scanner.pos;
-        this.scanner.pos = (this.scanner.pos + 1) | 0;
+        this.scanner.pos = (this.scanner.pos + 2) | 0;
+        this.error(
+          Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead,
+          this.scanner.pos - 2,
+          2,
+          noArgs,
+        );
         if (this.char() === CharacterCodes.ampersand) {
-          this.scanner.pos = (this.scanner.pos + 1) | 0;
-          this.error(
-            Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead,
-            this.scanner.pos - 2,
-            2,
-            noArgs,
-          );
-          if (this.char() === CharacterCodes.ampersand) {
-            this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos, 1, [
-              String.fromCharCode(ch),
-            ]);
-            this.scanner.pos = (this.scanner.pos + 1) | 0;
-          }
-        } else {
-          this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos - 1, 1, [
+          this.error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, this.scanner.pos, 1, [
             String.fromCharCode(ch),
           ]);
+          this.scanner.pos = (this.scanner.pos + 1) | 0;
         }
-        operand = this.scanner.pos - start === 1 ? CharacterCodes.ampersand : ClassValue.String;
+        operand = ClassValue.String;
         continue;
       }
       if (this.isClassContentExit(this.char())) break;
@@ -768,6 +792,15 @@ class RegularExpressionChecker {
         operand = ClassValue.String;
       } else {
         operand = this.scanClassSetOperand();
+        // Each operand of a negated union must match single characters.
+        if (isCharacterComplement && this.mayContainStrings)
+          this.error(
+            Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class,
+            start,
+            this.scanner.pos - start,
+            noArgs,
+          );
+        expressionMayContainStrings = expressionMayContainStrings || this.mayContainStrings;
       }
     }
     this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;