Internal change

PiperOrigin-RevId: 483712521

Author: Closure Team

src/com/google/javascript/jscomp/GatherModuleMetadata.java

@@ -69,6 +69,10 @@ public final class GatherModuleMetadata implements CompilerPass {
       DiagnosticType.error(
           "JSC_INVALID_REQUIRE_TYPE", "Argument to goog.requireType must be a string.");
 
+  static final DiagnosticType INVALID_REQUIRE_DYNAMIC =
+      DiagnosticType.error(
+          "JSC_INVALID_REQUIRE_DYNAMIC", "Argument to goog.requireDynamic must be a string.");
+
   static final DiagnosticType INVALID_SET_TEST_ONLY =
       DiagnosticType.error(
           "JSC_INVALID_SET_TEST_ONLY",
@@ -81,6 +85,7 @@ public final class GatherModuleMetadata implements CompilerPass {
   private static final Node GOOG_MODULE = IR.getprop(IR.name("goog"), "module");
   private static final Node GOOG_REQUIRE = IR.getprop(IR.name("goog"), "require");
   private static final Node GOOG_REQUIRE_TYPE = IR.getprop(IR.name("goog"), "requireType");
+  private static final Node GOOG_REQUIRE_DYNAMIC = IR.getprop(IR.name("goog"), "requireDynamic");
   private static final Node GOOG_SET_TEST_ONLY = IR.getprop(IR.name("goog"), "setTestOnly");
   private static final Node GOOG_MODULE_DECLARELEGACYNAMESPACE =
       IR.getprop(GOOG_MODULE.cloneTree(), "declareLegacyNamespace");
@@ -429,6 +434,15 @@ private void visitGoogCall(NodeTraversal t, Node n) {
         } else {
           t.report(n, INVALID_SET_TEST_ONLY);
         }
+      } else if (getprop.matchesQualifiedName(GOOG_REQUIRE_DYNAMIC)) {
+        if (n.hasTwoChildren() && n.getLastChild().isStringLit()) {
+          currentModule
+              .metadataBuilder
+              .dynamicallyRequiredGoogNamespacesBuilder()
+              .add(n.getLastChild().getString());
+        } else {
+          t.report(n, INVALID_REQUIRE_DYNAMIC);
+        }
       }
     }
 

src/com/google/javascript/jscomp/deps/JsFileFullParser.java

@@ -77,6 +77,7 @@ public enum ModuleType {
     public final Set<String> deltemplates = new TreeSet<>();
     // Use a LinkedHashSet as import order matters!
     public final Set<String> importedModules = new LinkedHashSet<>();
+    public final Set<String> dynamicRequires = new LinkedHashSet<>();
     public final List<String> modName = new ArrayList<>();
     public final List<String> mods = new ArrayList<>();
 
@@ -98,8 +99,8 @@ private static class CommentAnnotation {
     /** Annotation name, e.g. "@fileoverview" or "@externs". */
     final String name;
     /**
-     * Annotation value: either the bare identifier immediately after the
-     * annotation, or else string in braces.
+     * Annotation value: either the bare identifier immediately after the annotation, or else string
+     * in braces.
      */
     final String value;
 
@@ -211,8 +212,7 @@ protected void printSummary() {}
       return info; // Avoid potential crashes due to assumptions of the code below being violated.
     }
     ModuleMetadata module =
-        Iterables.getOnlyElement(
-            compiler.getModuleMetadataMap().getModulesByPath().values());
+        Iterables.getOnlyElement(compiler.getModuleMetadataMap().getModulesByPath().values());
     if (module.isEs6Module()) {
       info.loadFlags.put("module", "es6");
     } else if (module.isGoogModule()) {
@@ -250,6 +250,7 @@ private static void recordModuleMetadata(FileInfo info, ModuleMetadata module) {
     if (module.usesClosure()) {
       info.provides.addAll(module.googNamespaces());
       info.requires.addAll(module.stronglyRequiredGoogNamespaces());
+      info.dynamicRequires.addAll(module.dynamicallyRequiredGoogNamespaces());
       info.typeRequires.addAll(module.weaklyRequiredGoogNamespaces());
       info.testonly = module.isTestOnly();
     }

src/com/google/javascript/jscomp/modules/ModuleMetadataMap.java

@@ -175,6 +175,15 @@ public boolean isModule() {
      */
     public abstract ImmutableMultiset<String> stronglyRequiredGoogNamespaces();
 
+    /**
+     * Closure namespaces this file dynamically require, i.e., arguments to goog.requireDynamic()
+     * calls.
+     *
+     * <p>This is a multiset as it does not warn on duplicate namespaces, but will still encapsulate
+     * that information with this multiset.
+     */
+    public abstract ImmutableMultiset<String> dynamicallyRequiredGoogNamespaces();
+
     /**
      * Closure namespaces this file weakly requires, i.e., arguments to goog.requireType calls.
      *
@@ -222,6 +231,8 @@ public Builder addGoogNamespace(String namespace) {
 
       public abstract ImmutableMultiset.Builder<String> stronglyRequiredGoogNamespacesBuilder();
 
+      public abstract ImmutableMultiset.Builder<String> dynamicallyRequiredGoogNamespacesBuilder();
+
       public abstract ImmutableMultiset.Builder<String> weaklyRequiredGoogNamespacesBuilder();
 
       public abstract ImmutableMultiset.Builder<String> es6ImportSpecifiersBuilder();

test/com/google/javascript/jscomp/GatherModuleMetadataTest.java

@@ -573,6 +573,23 @@ public void testRequireType() {
     assertThat(m.weaklyRequiredGoogNamespaces()).containsExactly("my.Type");
   }
 
+  @Test
+  public void testRequireDynamic() {
+    testSame("async function test() {await goog.requireDynamic('my.Type');}");
+    ModuleMetadata m = metadataMap().getModulesByPath().get("testcode");
+    assertThat(m.dynamicallyRequiredGoogNamespaces()).containsExactly("my.Type");
+  }
+
+  @Test
+  public void testRequireDynamicWithIllegalArg() {
+    testError(
+        "async function test() {await goog.requireDynamic('my.Type','extra.Type');}",
+        GatherModuleMetadata.INVALID_REQUIRE_DYNAMIC);
+    testError(
+        "async function test() {await goog.requireDynamic(42);}",
+        GatherModuleMetadata.INVALID_REQUIRE_DYNAMIC);
+  }
+
   @Test
   public void testRequiredClosureNamespaces() {
     testSame("goog.require('my.Type');");

test/com/google/javascript/jscomp/deps/JsFileFullParserTest.java

@@ -82,11 +82,13 @@ public void testProvidesRequires() {
         parse(
             "goog.provide('providedSymbol');",
             "goog.require('stronglyRequiredSymbol');",
-            "goog.requireType('weaklyRequiredSymbol');");
+            "goog.requireType('weaklyRequiredSymbol');",
+            "async function test() {await goog.requireDynamic('dynamicallyRequiredSymbol');}");
 
     assertThat(info.provides).containsExactly("providedSymbol");
     assertThat(info.requires).containsExactly("stronglyRequiredSymbol");
     assertThat(info.typeRequires).containsExactly("weaklyRequiredSymbol");
+    assertThat(info.dynamicRequires).containsExactly("dynamicallyRequiredSymbol");
   }
 
   @Test