refactor(core): remove ext: modules from the module map (#19040)

Rather than disallowing `ext:` resolution, clear the module map after
initializing extensions so extension modules are anonymized. This
operation is explicitly called in `deno_runtime`. Re-inject `node:`
specifiers into the module map after doing this.

Fixes #17717.

cli/build.rs

@@ -40,7 +40,7 @@ mod ts {
 
     let node_built_in_module_names = SUPPORTED_BUILTIN_NODE_MODULES
       .iter()
-      .map(|s| s.name)
+      .map(|p| p.module_name())
       .collect::<Vec<&str>>();
     let build_libs = state.borrow::<Vec<&str>>();
     json!({

cli/graph_util.rs

@@ -378,9 +378,8 @@ pub fn enhanced_resolution_error_message(error: &ResolutionError) -> String {
 pub fn get_resolution_error_bare_node_specifier(
   error: &ResolutionError,
 ) -> Option<&str> {
-  get_resolution_error_bare_specifier(error).filter(|specifier| {
-    deno_node::resolve_builtin_node_module(specifier).is_ok()
-  })
+  get_resolution_error_bare_specifier(error)
+    .filter(|specifier| deno_node::is_builtin_node_module(specifier))
 }
 
 fn get_resolution_error_bare_specifier(

cli/lsp/diagnostics.rs

@@ -1023,7 +1023,7 @@ fn diagnose_resolution(
         }
       } else if let Some(module_name) = specifier.as_str().strip_prefix("node:")
       {
-        if deno_node::resolve_builtin_node_module(module_name).is_err() {
+        if !deno_node::is_builtin_node_module(module_name) {
           diagnostics
             .push(DenoDiagnostic::InvalidNodeSpecifier(specifier.clone()));
         } else if let Some(npm_resolver) = &snapshot.maybe_npm_resolver {

cli/lsp/documents.rs

@@ -1090,7 +1090,7 @@ impl Documents {
         }
       }
       if let Some(module_name) = specifier.strip_prefix("node:") {
-        if deno_node::resolve_builtin_node_module(module_name).is_ok() {
+        if deno_node::is_builtin_node_module(module_name) {
           // return itself for node: specifiers because during type checking
           // we resolve to the ambient modules in the @types/node package
           // rather than deno_std/node

cli/module_loader.rs

@@ -47,7 +47,6 @@ use deno_graph::Module;
 use deno_graph::Resolution;
 use deno_lockfile::Lockfile;
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolution;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::NodeResolver;
@@ -496,9 +495,7 @@ impl ModuleLoader for CliModuleLoader {
               .shared
               .npm_module_loader
               .resolve_nv_ref(&module.nv_reference, permissions),
-            Some(Module::Node(module)) => {
-              deno_node::resolve_builtin_node_module(&module.module_name)
-            }
+            Some(Module::Node(module)) => Ok(module.specifier.clone()),
             Some(Module::Esm(module)) => Ok(module.specifier.clone()),
             Some(Module::Json(module)) => Ok(module.specifier.clone()),
             Some(Module::External(module)) => {
@@ -517,11 +514,6 @@ impl ModuleLoader for CliModuleLoader {
       }
     }
 
-    // Built-in Node modules
-    if let Some(module_name) = specifier.strip_prefix("node:") {
-      return deno_node::resolve_builtin_node_module(module_name);
-    }
-
     // FIXME(bartlomieju): this is a hacky way to provide compatibility with REPL
     // and `Deno.core.evalContext` API. Ideally we should always have a referrer filled
     // but sadly that's not the case due to missing APIs in V8.
@@ -802,8 +794,6 @@ impl NpmModuleLoader {
     if let NodeResolution::CommonJs(specifier) = &response {
       // remember that this was a common js resolution
       self.cjs_resolutions.insert(specifier.clone());
-    } else if let NodeResolution::BuiltIn(specifier) = &response {
-      return deno_node::resolve_builtin_node_module(specifier);
     }
     Ok(response.into_url())
   }

cli/standalone/mod.rs

@@ -39,7 +39,6 @@ use deno_core::ModuleType;
 use deno_core::ResolutionKind;
 use deno_npm::NpmSystemInfo;
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node;
 use deno_runtime::deno_node::analyze::NodeCodeTranslator;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_tls::rustls::RootCertStore;
@@ -128,11 +127,6 @@ impl ModuleLoader for EmbeddedModuleLoader {
         .resolve_req_reference(&reference, permissions);
     }
 
-    // Built-in Node modules
-    if let Some(module_name) = specifier_text.strip_prefix("node:") {
-      return deno_node::resolve_builtin_node_module(module_name);
-    }
-
     match maybe_mapped {
       Some(resolved) => Ok(resolved),
       None => deno_core::resolve_import(specifier, referrer.as_str())

cli/tests/testdata/run/extension_dynamic_import.ts.out

@@ -1,4 +1,10 @@
-error: Uncaught (in promise) TypeError: Cannot load extension module from external code
+error: Uncaught (in promise) TypeError: Unsupported scheme "ext" for module "ext:runtime/01_errors.js". Supported schemes: [
+    "data",
+    "blob",
+    "file",
+    "http",
+    "https",
+]
 await import("ext:runtime/01_errors.js");
 ^
-    at [WILDCARD]/extension_dynamic_import.ts:1:1
+    at async [WILDCARD]/extension_dynamic_import.ts:1:1

cli/tests/testdata/run/extension_import.ts.out

@@ -5,4 +5,4 @@ error: Unsupported scheme "ext" for module "ext:runtime/01_errors.js". Supported
     "http",
     "https",
 ]
-    at [WILDCARD]
+    at [WILDCARD]/extension_import.ts:1:8

cli/tsc/mod.rs

@@ -538,7 +538,7 @@ fn op_resolve(
   };
   for specifier in args.specifiers {
     if let Some(module_name) = specifier.strip_prefix("node:") {
-      if deno_node::resolve_builtin_node_module(module_name).is_ok() {
+      if deno_node::is_builtin_node_module(module_name) {
         // return itself for node: specifiers because during type checking
         // we resolve to the ambient modules in the @types/node package
         // rather than deno_std/node