@ttsc/paths 0.19.3 → 0.20.0

package/driver/paths.go

@@ -6,6 +6,7 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 
@@ -32,12 +33,14 @@ func (plugin) ApplyProgram(prog *driver.Program, _ driver.PluginContext) error {
 // rewriter holds the resolved tsconfig paths configuration used to rewrite
 // module specifiers across an entire program.
 type rewriter struct {
-  basePath    string
-  jsxPreserve bool
-  outDir      string
-  patterns    []pathPattern
-  rootDir     string
-  sourceFiles map[string]string // normalized source path → same path (used as a set)
+  checker           *shimchecker.Checker
+  basePath          string
+  canonicalFileName func(string) string
+  jsxPreserve       bool
+  outDir            string
+  patterns          []pathPattern
+  rootDir           string
+  sourceFiles       map[string]string // canonical source path → original normalized path
 }
 
 // pathPattern is a single tsconfig paths entry with its wildcard pattern and
@@ -56,10 +59,17 @@ var sourceLookupExtensions = []string{
 // Patterns are sorted by decreasing specificity (longer literal prefix first)
 // so the most-specific match wins on overlapping patterns.
 func newRewriter(prog *driver.Program) *rewriter {
-  out := &rewriter{sourceFiles: map[string]string{}}
+  caseSensitive := useCaseSensitiveFileNames(prog)
+  out := &rewriter{
+    canonicalFileName: func(name string) string {
+      return shimtspath.GetCanonicalFileName(name, caseSensitive)
+    },
+    sourceFiles: map[string]string{},
+  }
   if prog == nil || prog.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig == nil || prog.ParsedConfig.ParsedConfig.CompilerOptions == nil {
     return out
   }
+  out.checker = prog.Checker
   options := prog.ParsedConfig.ParsedConfig.CompilerOptions
   cwd := prog.Host.GetCurrentDirectory()
   out.basePath = filepath.Clean(options.GetPathsBasePath(cwd))
@@ -75,7 +85,7 @@ func newRewriter(prog *driver.Program) *rewriter {
     out.rootDir = inferredRootDir(options.ConfigFilePath, fileNames, cwd, useCaseSensitiveFileNames(prog))
   }
   for _, name := range fileNames {
-    out.sourceFiles[name] = name
+    out.sourceFiles[out.sourceKey(name)] = name
   }
   if options.Paths != nil {
     for key, targets := range options.Paths.Entries() {
@@ -104,7 +114,7 @@ func (r *rewriter) apply(file *shimast.SourceFile) {
   if r == nil || file == nil || len(r.patterns) == 0 {
     return
   }
-  visitModuleSpecifiers(file.AsNode(), func(lit *shimast.Node) {
+  visitModuleSpecifiers(file, r.checker, func(lit *shimast.Node) {
     if lit == nil || lit.Kind != shimast.KindStringLiteral {
       return
     }
@@ -118,16 +128,16 @@ func (r *rewriter) apply(file *shimast.SourceFile) {
   })
 }
 
-// visitModuleSpecifiers recursively walks the AST rooted at node, calling
-// visit for every string-literal module specifier it finds. Covered nodes
-// include import/export declarations, require() calls, dynamic import()
-// expressions, import-equals declarations, and import-type nodes.
+// visitModuleSpecifiers recursively walks file, calling visit for every
+// string-literal module reference it finds. Syntax identifies candidates, then
+// SourceFile and Checker facts exclude declarations and calls whose literal is
+// not actually a module reference in the containing file.
 //
 // The recursion runs through one closure created per walk, not one per node:
 // handing ForEachChild a fresh closure at every node would allocate once per
 // AST node across the whole program on every apply pass.
-func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
-  if node == nil {
+func visitModuleSpecifiers(file *shimast.SourceFile, checker *shimchecker.Checker, visit func(*shimast.Node)) {
+  if file == nil {
     return
   }
   var walk func(node *shimast.Node) bool
@@ -152,24 +162,24 @@ func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
       }
     case shimast.KindModuleDeclaration:
       decl := node.AsModuleDeclaration()
-      if decl != nil {
+      if file.ExternalModuleIndicator != nil && decl != nil {
         visit(decl.Name())
       }
     case shimast.KindCallExpression:
       call := node.AsCallExpression()
-      if isModuleSpecifierCall(call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+      if isModuleSpecifierCall(checker, call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
         visit(call.Arguments.Nodes[0])
       }
     }
     node.ForEachChild(walk)
     return false
   }
-  walk(node)
+  walk(file.AsNode())
 }
 
 // isModuleSpecifierCall reports whether call is a dynamic import() or a
-// CommonJS require() expression.
-func isModuleSpecifierCall(call *shimast.CallExpression) bool {
+// CommonJS require() expression that resolves to the module loader.
+func isModuleSpecifierCall(checker *shimchecker.Checker, call *shimast.CallExpression) bool {
   if call == nil || call.Expression == nil {
     return false
   }
@@ -177,12 +187,28 @@ func isModuleSpecifierCall(call *shimast.CallExpression) bool {
   case shimast.KindImportKeyword:
     return true
   case shimast.KindIdentifier:
-    return call.Expression.Text() == "require"
+    return call.Expression.Text() == "require" && isModuleLoader(checker, call.Expression)
   default:
     return false
   }
 }
 
+// isModuleLoader reports whether expression names the CommonJS loader rather
+// than a parameter, local, or imported binding named require. An unresolved
+// bare require is the runtime CommonJS global; declared loaders are ambient.
+func isModuleLoader(checker *shimchecker.Checker, expression *shimast.Node) bool {
+  if checker == nil || expression == nil {
+    return false
+  }
+  symbol := checker.GetSymbolAtLocation(expression)
+  if symbol == nil {
+    return true
+  }
+  return symbol.Flags&shimast.SymbolFlagsAlias == 0 &&
+    symbol.ValueDeclaration != nil &&
+    symbol.ValueDeclaration.Flags&shimast.NodeFlagsAmbient != 0
+}
+
 // rewrite resolves specifier from fromSource using the tsconfig paths table and
 // returns the relative output path. Returns (specifier, false) when the specifier
 // is already relative, absolute, or does not match any paths pattern.
@@ -236,23 +262,35 @@ func (r *rewriter) resolveSource(specifier string) (string, bool) {
 // extension) corresponds to a known source file. It tries the exact path, stem
 // with each known TypeScript/JavaScript source extension, and index files.
 func (r *rewriter) lookupSource(candidate string) (string, bool) {
-  if source, ok := r.sourceFiles[normalizePath(candidate)]; ok {
+  normalized := normalizePath(candidate)
+  if source, ok := r.sourceFiles[r.sourceKey(normalized)]; ok {
     return source, true
   }
-  stem := stripKnownSourceExtension(normalizePath(candidate))
+  stem := stripKnownSourceExtension(normalized)
   for _, ext := range sourceLookupExtensions {
-    if source, ok := r.sourceFiles[stem+ext]; ok {
+    if source, ok := r.sourceFiles[r.sourceKey(stem+ext)]; ok {
       return source, true
     }
   }
   for _, ext := range sourceLookupExtensions {
-    if source, ok := r.sourceFiles[normalizePath(filepath.Join(stem, "index"+ext))]; ok {
+    if source, ok := r.sourceFiles[r.sourceKey(filepath.Join(stem, "index"+ext))]; ok {
       return source, true
     }
   }
   return "", false
 }
 
+// sourceKey applies the compiler host's filesystem identity rule to one path.
+// Synthetic test rewriters leave canonicalFileName nil and retain the previous
+// exact-key behavior.
+func (r *rewriter) sourceKey(value string) string {
+  normalized := normalizePath(value)
+  if r.canonicalFileName == nil {
+    return normalized
+  }
+  return r.canonicalFileName(normalized)
+}
+
 // outputPathForSource maps a source file path to its emitted output path under
 // outDir, swapping the source extension for the appropriate JS extension. Returns
 // "" when outDir or rootDir is unset, or when source is outside rootDir.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/paths",
-  "version": "0.19.3",
+  "version": "0.20.0",
   "description": "First-party ttsc plugin that rewrites emitted module specifiers from tsconfig paths.",
   "main": "src/index.cjs",
   "exports": {