fix(javascript): exclude erased imports from runtime bindings (#6994)

src/domain/javascript/javascriptSemanticAnalysis.require_links.test.ts

@@ -160,6 +160,11 @@ describe("TypeScript type-only module links", () => {
       export type { hiddenFunction };
     `);
 
+    expect(ir.bindings.map(({ name }) => name).sort()).toEqual([
+      "hiddenFunction",
+      "value",
+    ]);
+
     const externalLinks = ir.moduleLinks
       .filter(({ specifier }) => specifier !== null)
       .map(

src/domain/javascript/javascriptSemanticAnalysis.ts

@@ -80,6 +80,8 @@ import {
 } from "./javascriptSemanticAmbientWrites.js";
 import {
   hasUncertainTypeOnlyModuleSideEffect,
+  isTypeOnlyImportDeclaration,
+  isTypeOnlyImportSpecifier,
   semanticImportEqualsSpecifier,
 } from "./javascriptModuleDeclaration.js";
 import {
@@ -2038,7 +2040,10 @@ const bindImports = (
   scope: JavaScriptSemanticScopeState,
   state: JavaScriptSemanticAnalysisState,
 ): void => {
+  if (isTypeOnlyImportDeclaration(node)) return;
   for (const specifier of node.specifiers) {
+    if (t.isImportSpecifier(specifier) && isTypeOnlyImportSpecifier(specifier))
+      continue;
     const importedPath = t.isImportDefaultSpecifier(specifier)
       ? ["default"]
       : t.isImportNamespaceSpecifier(specifier)
@@ -2053,12 +2058,7 @@ const bindImports = (
       definitionNode: specifier.local,
       initializer: null,
       directOrigin: { specifier: node.source.value, importedPath },
-      runtimeImport:
-        node.importKind !== "type" &&
-        node.importKind !== "typeof" &&
-        (!t.isImportSpecifier(specifier) ||
-          (specifier.importKind !== "type" &&
-            specifier.importKind !== "typeof")),
+      runtimeImport: true,
     });
   }
 };

src/domain/javascript/javascriptSemanticValues.ts

@@ -1192,16 +1192,7 @@ const provenanceForBindingInitializers = (
         : "Catch binding provenance depends on the thrown value.",
     );
   if (binding.directOrigins.length > 0)
-    return binding.kind === "import" &&
-      !binding.runtimeImport &&
-      binding.directOrigins.every(
-        ({ resolutionMode }) => resolutionMode !== "require",
-      )
-      ? semanticAmbiguousProvenance(
-          binding.directOrigins,
-          "A type-only import does not establish a runtime module value.",
-        )
-      : semanticOriginsProvenance(binding.directOrigins);
+    return semanticOriginsProvenance(binding.directOrigins);
   if (binding.initializers.length === 0) return semanticLocalProvenance();
   if (binding.initializers.length > 1)
     return semanticAmbiguousProvenance(