@ttsc/evidence 0.28.6 → 0.30.0

package/native/export_resolution.go

@@ -0,0 +1,275 @@
+package evidence
+
+import (
+  "sort"
+  "strings"
+)
+
+// Export names are finite even when modules re-export each other. Discover
+// that vocabulary before resolving bindings, and expand namespace paths only
+// after a binding is known. A module recursion guard cannot answer whether a
+// particular export exists: the module may be busy resolving another name.
+type typeScriptExportResolver struct {
+  loader   *typeScriptLoader
+  modules  map[string]*typeScriptExportModule
+  bindings map[scopedTargetKey][]reachedSymbol
+  owned    *ownedUnitIndex
+}
+
+type typeScriptExportModule struct {
+  exports []moduleExport
+  targets map[string]string
+  names   map[string]bool
+  named   map[string][]moduleExport
+  stars   []moduleExport
+}
+
+func newTypeScriptExportResolver(loader *typeScriptLoader, entries []string) *typeScriptExportResolver {
+  resolver := &typeScriptExportResolver{loader: loader, modules: map[string]*typeScriptExportModule{}, bindings: map[scopedTargetKey][]reachedSymbol{}}
+  resolver.owned = newOwnedUnitIndex(loader)
+  for _, entry := range entries {
+    resolver.load(entry)
+  }
+  keys := make([]string, 0, len(resolver.modules))
+  for key := range resolver.modules {
+    keys = append(keys, key)
+  }
+  sort.Strings(keys)
+  // Only star edges add names. Namespace and named re-exports already have
+  // explicit names, so namespace cycles cannot grow this fixed point forever.
+  for changed := true; changed; {
+    changed = false
+    for _, key := range keys {
+      module := resolver.modules[key]
+      for _, export := range module.stars {
+        target := resolver.modules[module.targets[export.Specifier]]
+        if target == nil {
+          continue
+        }
+        for name := range target.names {
+          if name != "default" && !module.names[name] {
+            module.names[name] = true
+            changed = true
+          }
+        }
+      }
+    }
+  }
+  if loader.boundary != nil {
+    for _, key := range keys {
+      module := resolver.modules[key]
+      for _, export := range module.exports {
+        if export.Specifier == "" || export.Namespace || export.Imported == "" {
+          continue
+        }
+        target := module.targets[export.Specifier]
+        if resolver.modules[target] == nil {
+          continue
+        }
+        if len(resolver.resolve(target, export.Imported)) == 0 {
+          loader.failures[key+" -> "+export.Specifier+"#"+export.Imported] = "the module has no public export named '" + export.Imported + "'"
+        }
+      }
+    }
+  }
+  return resolver
+}
+
+func (resolver *typeScriptExportResolver) load(entry string) {
+  if _, loaded := resolver.modules[entry]; loaded {
+    return
+  }
+  inventory := resolver.loader.inventory(entry)
+  if inventory == nil {
+    return
+  }
+  module := &typeScriptExportModule{exports: inventory.Exports, targets: map[string]string{}, names: map[string]bool{}, named: map[string][]moduleExport{}}
+  declarations := map[string]bool{}
+  if inventory.Source != nil && inventory.Source.Statements != nil {
+    for _, statement := range inventory.Source.Statements.Nodes {
+      if statement == nil {
+        continue
+      }
+      for _, declaration := range topLevelDeclaredNames(statement) {
+        declarations[declaration.Name] = true
+      }
+      if name := typeScriptDeclarationName(statement); name != "" {
+        declarations[name] = true
+      }
+    }
+  }
+  resolver.modules[entry] = module
+  for _, export := range module.exports {
+    if resolver.loader.boundary != nil && export.Specifier == "" && !declarations[export.Local] {
+      resolver.loader.failures[entry+"#"+export.Public] = "the exported binding '" + export.Local + "' has no declaration in this module"
+      continue
+    }
+    if export.Public != "" {
+      module.names[export.Public] = true
+      module.named[export.Public] = append(module.named[export.Public], export)
+    } else if export.Specifier != "" {
+      module.stars = append(module.stars, export)
+    }
+    if export.Specifier == "" {
+      continue
+    }
+    if _, resolved := module.targets[export.Specifier]; resolved {
+      continue
+    }
+    target := resolver.loader.resolve(entry, export.Specifier)
+    module.targets[export.Specifier] = target
+    if target != "" {
+      resolver.load(target)
+    }
+  }
+}
+
+// accessor follows only the namespace segments the citation actually names.
+// Each hop consumes at least one query segment, so namespace cycles are finite.
+// Legacy inline spelling can join several query segments into a literal export
+// name; Address records the consumed query segments for the remaining lookup.
+func (resolver *typeScriptExportResolver) accessor(entry string, segments []string, prefix []string, typeOnly bool, legacy bool) []reachedSymbol {
+  if len(segments) == 0 {
+    return nil
+  }
+  result := []reachedSymbol{}
+  limit := 1
+  if legacy {
+    limit = len(segments)
+  }
+  for consumed := 1; consumed <= limit; consumed++ {
+    name := strings.Join(segments[:consumed], ".")
+    for _, binding := range resolver.resolve(entry, name) {
+      binding.Address = append(append([]string{}, prefix...), segments[:consumed]...)
+      binding.TypeOnly = binding.TypeOnly || typeOnly
+      // Keep namespace prefixes for diagnostics, including when the next name
+      // is missing. They never become units in lookup or population traversal.
+      result = append(result, binding)
+      if binding.Local == "" {
+        result = append(result, resolver.accessor(binding.Path, segments[consumed:], binding.Address, binding.TypeOnly, legacy)...)
+      }
+    }
+  }
+  return result
+}
+
+func (resolver *typeScriptExportResolver) lookup(entry string, segments []string, legacy bool) []*evidenceUnit {
+  result := []*evidenceUnit{}
+  seen := map[string]bool{}
+  for _, binding := range resolver.accessor(entry, segments, nil, false, legacy) {
+    if binding.Local == "" {
+      continue
+    }
+    target := append([]string{binding.Local}, segments[len(binding.Address):]...)
+    for _, unit := range resolver.owned.of(binding.Path, binding.Local) {
+      if binding.TypeOnly && unit.ValueSpace && !unit.TypeSpace {
+        continue
+      }
+      matches := encodeTypeScriptIdentity(unit.Identity) == encodeTypeScriptIdentity(target)
+      if legacy {
+        matches = strings.Join(unit.Identity, ".") == strings.Join(target, ".")
+      }
+      if matches && !seen[unit.ID] {
+        seen[unit.ID] = true
+        result = append(result, unit)
+      }
+    }
+  }
+  return result
+}
+
+func (resolver *typeScriptExportResolver) resolve(module string, name string) []reachedSymbol {
+  key := scopedTargetKey{path: module, target: name}
+  if cached, exists := resolver.bindings[key]; exists {
+    return cached
+  }
+  resolved := resolver.resolveFrom(key, map[scopedTargetKey]bool{})
+  resolver.bindings[key] = resolved
+  return resolved
+}
+
+func (resolver *typeScriptExportResolver) resolveFrom(key scopedTargetKey, visited map[scopedTargetKey]bool) []reachedSymbol {
+  if visited[key] {
+    return nil
+  }
+  if cached, exists := resolver.bindings[key]; exists {
+    return cached
+  }
+  module := resolver.modules[key.path]
+  if module == nil {
+    return nil
+  }
+  visited[key] = true
+  defer delete(visited, key)
+  result := []reachedSymbol{}
+  byBinding := map[scopedTargetKey]int{}
+  add := func(binding reachedSymbol, typeOnly bool) {
+    binding.TypeOnly = binding.TypeOnly || typeOnly
+    identity := scopedTargetKey{path: binding.Path, target: binding.Local}
+    if index, exists := byBinding[identity]; exists {
+      result[index].TypeOnly = result[index].TypeOnly && binding.TypeOnly
+      return
+    }
+    byBinding[identity] = len(result)
+    result = append(result, binding)
+  }
+  exports := module.named[key.target]
+  if len(exports) == 0 && key.target != "default" {
+    exports = module.stars
+  }
+  for _, export := range exports {
+    if export.Specifier == "" {
+      local := export.Public
+      if export.Identity != "" {
+        local = export.Identity
+      }
+      add(reachedSymbol{Path: key.path, Local: local}, export.TypeOnly)
+      continue
+    }
+    target := module.targets[export.Specifier]
+    if resolver.modules[target] == nil {
+      continue
+    }
+    if export.Namespace {
+      add(reachedSymbol{Path: target}, export.TypeOnly)
+      continue
+    }
+    imported := key.target
+    if export.Imported != "" {
+      imported = export.Imported
+    }
+    for _, binding := range resolver.resolveFrom(scopedTargetKey{path: target, target: imported}, visited) {
+      add(binding, export.TypeOnly)
+    }
+  }
+  return result
+}
+
+func (resolver *typeScriptExportResolver) traverse(entry string, prefix []string, visited map[string]bool, typeOnly bool) []reachedSymbol {
+  if visited[entry] {
+    return nil
+  }
+  module := resolver.modules[entry]
+  if module == nil {
+    return nil
+  }
+  visited[entry] = true
+  defer delete(visited, entry)
+  names := make([]string, 0, len(module.names))
+  for name := range module.names {
+    names = append(names, name)
+  }
+  sort.Strings(names)
+  reached := []reachedSymbol{}
+  for _, name := range names {
+    for _, binding := range resolver.resolve(entry, name) {
+      binding.Address = append(append([]string{}, prefix...), name)
+      binding.TypeOnly = binding.TypeOnly || typeOnly
+      reached = append(reached, binding)
+      if binding.Local == "" {
+        reached = append(reached, resolver.traverse(binding.Path, binding.Address, visited, binding.TypeOnly)...)
+      }
+    }
+  }
+  return reached
+}

package/native/exports.go

@@ -13,6 +13,9 @@ import (
 // another. Keeping the two apart is what lets identity stay with the declaring
 // file while reachability is decided by whoever re-exports it.
 type moduleExport struct {
+  // Identity overrides the local unit name for a default alias. The alias
+  // adds reachability without materializing a second declaration.
+  Identity string
   // Public is the name an importer sees. Empty for `export * from`, which
   // contributes its target's names rather than a name of its own.
   Public string
@@ -49,6 +52,7 @@ func collectModuleExports(file *shimast.SourceFile) []moduleExport {
     return exports
   }
   locals := collectLocalExportNames(file.Statements)
+  defaults := collectDefaultExportBindings(file.Statements)
   for _, statement := range file.Statements.Nodes {
     if statement == nil {
       continue
@@ -60,6 +64,13 @@ func collectModuleExports(file *shimast.SourceFile) []moduleExport {
     if !isSyntacticallyExported(statement) {
       continue
     }
+    if isDefaultExported(statement) {
+      name := typeScriptDeclarationName(statement)
+      if name != "" {
+        exports = append(exports, moduleExport{Public: "default", Local: name, Identity: name})
+      }
+      continue
+    }
     for _, declared := range topLevelDeclaredNames(statement) {
       exports = append(exports, moduleExport{
         Public: declared.Name,
@@ -68,8 +79,9 @@ func collectModuleExports(file *shimast.SourceFile) []moduleExport {
       for _, exported := range locals[declared.Name] {
         if exported.Public != declared.Name {
           exports = append(exports, moduleExport{
-            Public: exported.Public,
-            Local:  declared.Name,
+            Public:   exported.Public,
+            Local:    declared.Name,
+            TypeOnly: exported.TypeOnly,
           })
         }
       }
@@ -77,15 +89,41 @@ func collectModuleExports(file *shimast.SourceFile) []moduleExport {
   }
   for local, names := range locals {
     for _, exported := range names {
-      if exported.Public == "" {
+      if exported.Public == "" || exported.IdentityOnly {
         continue
       }
       exports = append(exports, moduleExport{
-        Public: exported.Public,
-        Local:  local,
+        Public:   exported.Public,
+        Local:    local,
+        TypeOnly: exported.TypeOnly,
       })
     }
   }
+  for local, binding := range defaults {
+    identity := local
+    chosen := false
+    for _, name := range locals[local] {
+      if !binding.TypeOnly && name.TypeOnly && !name.ValueIdentity {
+        continue
+      }
+      if !chosen || name.Public < identity {
+        identity, chosen = name.Public, true
+      }
+    }
+    exports = append(exports, moduleExport{Public: "default", Local: local, Identity: identity, TypeOnly: binding.TypeOnly})
+  }
+  imports := collectImportBindings(file)
+  for index := range exports {
+    export := &exports[index]
+    if export.Specifier != "" {
+      continue
+    }
+    if binding, imported := imports[export.Local]; imported {
+      export.Specifier, export.Imported, export.Namespace = binding.Specifier, binding.Imported, binding.Namespace
+      export.Identity = ""
+      export.TypeOnly = export.TypeOnly || binding.TypeOnly
+    }
+  }
   return dedupeModuleExports(exports)
 }
 
@@ -181,6 +219,7 @@ func dedupeModuleExports(exports []moduleExport) []moduleExport {
 // yields: the obligations, the scopes above them, and the addresses that reach
 // them.
 type traversedPopulation struct {
+  Code    *typeScriptExportResolver
   Units   []*evidenceUnit
   Reached []*evidenceUnit
   // Hidden are the reached declarations that withdrew themselves from the
@@ -198,9 +237,10 @@ type traversedPopulation struct {
 // several selected modules publish the same declaration: each address is legal
 // exactly where it is written, and none of them is legal everywhere.
 type publishedAddress struct {
-  Module  string
-  Address string
-  Unit    *evidenceUnit
+  Module   string
+  Address  string
+  Segments []string
+  Unit     *evidenceUnit
 }
 
 type reachedSymbol struct {
@@ -208,7 +248,8 @@ type reachedSymbol struct {
   Address []string
   // Path is the file that declares the symbol, which owns its identity.
   Path string
-  // Local is the name that file's inventory gives the declaration, which is
+  // Local is empty for a module namespace, which publishes names but declares
+  // no evidence unit. Otherwise it is the name that file's inventory gives the declaration, which is
   // the name it exposes rather than the binding it wrote. `export { a as b }`
   // declares one unit called `b`, so matching on `a` would find nothing.
   Local string
@@ -219,123 +260,6 @@ type reachedSymbol struct {
   TypeOnly bool
 }
 
-// traverseEntryExports walks a module's export graph and reports every public
-// symbol it reaches, with the address the entry gives it.
-//
-// Membership comes from reachability and identity comes from the declaring
-// file, so a symbol re-exported through two barrels is reached twice and still
-// resolves to one unit. Cycles are bounded by the visited set: a barrel that
-// re-exports itself is a real shape, not a reason to hang the build.
-func traverseEntryExports(
-  loader *typeScriptLoader,
-  entry string,
-  prefix []string,
-  visited map[string]bool,
-  typeOnly bool,
-) []reachedSymbol {
-  if visited[entry] {
-    return nil
-  }
-  visited[entry] = true
-  defer delete(visited, entry)
-
-  inventory := loader.inventory(entry)
-  if inventory == nil {
-    return nil
-  }
-  reached := []reachedSymbol{}
-  // Named re-exports are grouped by the module they come from and that module
-  // is walked once. Walking it per specifier would re-traverse the whole
-  // subtree for every name a barrel forwards, which is quadratic on exactly
-  // the wide generated barrels this selection exists to describe.
-  surfaces := map[string]map[string]reachedSymbol{}
-  surfaceOf := func(target string) map[string]reachedSymbol {
-    if surface, built := surfaces[target]; built {
-      return surface
-    }
-    surface := map[string]reachedSymbol{}
-    for _, nested := range traverseEntryExports(loader, target, nil, visited, false) {
-      if len(nested.Address) != 1 {
-        continue
-      }
-      existing, taken := surface[nested.Address[0]]
-      // First wins, because two paths to one declaration name the same unit and
-      // the entry has to keep describing a path that exists.
-      //
-      // The type-only mark is unioned, and only between paths to the same
-      // declaration. It differs per path while the population is the union of
-      // what the paths reach, so a value path has to clear a type-only one
-      // rather than lose to declaration order. Doing that unconditionally is
-      // two different mistakes: replacing the entry swaps `Path` and `Local`,
-      // and clearing the mark alone leaves `Path` from one entry with the mark
-      // from another, which is a combination no path produced. Two entries
-      // under one name are not always one declaration, since an explicit named
-      // re-export shadows a star, and either mistake publishes the value
-      // members of a declaration this module reaches type-only.
-      switch {
-      case !taken:
-        surface[nested.Address[0]] = nested
-      case existing.TypeOnly && !nested.TypeOnly &&
-        existing.Path == nested.Path && existing.Local == nested.Local:
-        existing.TypeOnly = false
-        surface[nested.Address[0]] = existing
-      }
-    }
-    surfaces[target] = surface
-    return surface
-  }
-  for _, export := range inventory.Exports {
-    if export.Specifier == "" {
-      // A declaration this module exposes is inventoried under the name it
-      // exposes it as. `export { local as renamed }` is one unit named
-      // `renamed`, so the local binding never identifies it.
-      reached = append(reached, reachedSymbol{
-        Address:  append(append([]string{}, prefix...), export.Public),
-        Path:     entry,
-        Local:    export.Public,
-        TypeOnly: typeOnly,
-      })
-      continue
-    }
-    target := loader.resolve(entry, export.Specifier)
-    if target == "" {
-      continue
-    }
-    switch {
-    case export.Namespace:
-      reached = append(reached, traverseEntryExports(
-        loader,
-        target,
-        append(append([]string{}, prefix...), export.Public),
-        visited,
-        typeOnly || export.TypeOnly,
-      )...)
-    case export.Imported == "":
-      reached = append(reached, traverseEntryExports(
-        loader,
-        target,
-        prefix,
-        visited,
-        typeOnly || export.TypeOnly,
-      )...)
-    default:
-      nested, found := surfaceOf(target)[export.Imported]
-      if !found {
-        continue
-      }
-      reached = append(reached, reachedSymbol{
-        Address: append(append([]string{}, prefix...), export.Public),
-        Path:    nested.Path,
-        Local:   nested.Local,
-        // The edge into this module and every edge the target itself walked
-        // both count, so a type-only hop anywhere on the path withholds.
-        TypeOnly: typeOnly || export.TypeOnly || nested.TypeOnly,
-      })
-    }
-  }
-  return reached
-}
-
 // materializeEntryUnits turns reached symbols into the units an obligation
 // counts, giving each its entry-relative address.
 //
@@ -362,8 +286,9 @@ func materializeEntryUnits(
   order := []string{}
   published := []publishedAddress{}
   candidates := newOwnedUnitIndex(loader)
+  exports := newTypeScriptExportResolver(loader, entries)
   for _, entry := range entries {
-    for _, symbol := range traverseEntryExports(loader, entry, nil, map[string]bool{}, false) {
+    for _, symbol := range exports.traverse(entry, nil, map[string]bool{}, false) {
       if symbol.Local == "" {
         continue
       }
@@ -403,14 +328,15 @@ func materializeEntryUnits(
           }
         }
         published = append(published, publishedAddress{
-          Module:  entry,
-          Address: target,
-          Unit:    current,
+          Module:   entry,
+          Address:  target,
+          Segments: append([]string{}, address...),
+          Unit:     current,
         })
       }
     }
   }
-  population := traversedPopulation{Published: published}
+  population := traversedPopulation{Published: published, Code: exports}
   for _, id := range order {
     unit := byID[id]
     sort.Strings(unit.Aliases)
@@ -460,6 +386,7 @@ func narrowTraversedPopulation(
     withdrawn[unit.ID] = true
   }
   narrowed := traversedPopulation{
+    Code:      published.Code,
     Reached:   published.Reached,
     Published: published.Published,
   }
@@ -509,26 +436,17 @@ func (index *ownedUnitIndex) of(path string, local string) []*evidenceUnit {
     }
     index.byPath[path] = roots
   }
-  root := local
-  if cut := strings.Index(local, "."); cut != -1 {
-    root = local[:cut]
-  }
-  return roots[root]
+  return roots[local]
 }
 
 // identitySuffix reports the segments below a reached declaration, and whether
 // the unit belongs to it at all.
 func identitySuffix(identity []string, local string) ([]string, bool) {
-  owner := strings.Split(local, ".")
-  if len(identity) < len(owner) {
+  // Local is one module export, including a quoted name containing a dot.
+  if len(identity) == 0 || identity[0] != local {
     return nil, false
   }
-  for index, segment := range owner {
-    if identity[index] != segment {
-      return nil, false
-    }
-  }
-  return identity[len(owner):], true
+  return identity[1:], true
 }
 
 func containsString(values []string, wanted string) bool {