Have Es6RewriteModules and RewriteGoogJsImports still do their best t…

…o rewrite in the event of missing files / namespaces. This is required for some tools that just want information of ES modules after type checking, like clutz.

Once modules are type checked this should no longer be a concern.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=225434089

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

@@ -431,10 +431,11 @@ private void visitImport(NodeTraversal t, Node importDecl, Node parent) {
 
       if (m == null) {
         t.report(importDecl, MISSING_MODULE_OR_PROVIDE, namespace);
-      } else {
-        moduleName = ModuleRenaming.getGlobalName(m, namespace);
-        checkState(m.isEs6Module() || m.isGoogModule() || m.isGoogProvide());
+        m = getFallbackMetadataForNamespace(namespace);
       }
+
+      moduleName = ModuleRenaming.getGlobalName(m, namespace);
+      checkState(m.isEs6Module() || m.isGoogModule() || m.isGoogProvide());
     } else {
       ModuleLoader.ModulePath modulePath =
           t.getInput()
@@ -825,6 +826,24 @@ private void visitGoogModuleGet(NodeTraversal t, Node getCall, Node parent) {
     visitRequireOrGet(t, getCall, parent, /* isRequire= */ false);
   }
 
+  /**
+   * Gets some made-up metadata for the given Closure namespace.
+   *
+   * <p>This is used when the namespace is not part of the input so that this pass can be fault
+   * tolerant and still rewrite to something. Some tools don't care about rewriting correctly and
+   * just want the type information of this module (e.g. clutz).
+   */
+  private ModuleMetadata getFallbackMetadataForNamespace(String namespace) {
+    // Assume a provide'd file to be consistent with goog.module rewriting.
+    ModuleMetadata.Builder builder =
+        ModuleMetadata.builder()
+            .moduleType(ModuleMetadataMap.ModuleType.GOOG_PROVIDE)
+            .usesClosure(true)
+            .isTestOnly(false);
+    builder.googNamespacesBuilder().add(namespace);
+    return builder.build();
+  }
+
   private void visitRequireOrGet(
       NodeTraversal t, Node requireCall, Node parent, boolean isRequire) {
     if (!requireCall.hasTwoChildren() || !requireCall.getLastChild().isString()) {
@@ -850,7 +869,7 @@ private void visitRequireOrGet(
 
     if (m == null) {
       t.report(requireCall, MISSING_MODULE_OR_PROVIDE, namespace);
-      return;
+      m = getFallbackMetadataForNamespace(namespace);
     }
 
     if (isStoredInDeclaration) {

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

@@ -155,9 +155,11 @@ public boolean shouldTraverse(NodeTraversal nodeTraversal, Node n, Node parent)
   private class ReferenceReplacer extends AbstractPostOrderCallback {
     private boolean hasBadExport;
     private final Node googImportNode;
+    private final boolean globalizeAllReferences;
 
-    public ReferenceReplacer(Node script, Node googImportNode) {
+    public ReferenceReplacer(Node script, Node googImportNode, boolean globalizeAllReferences) {
       this.googImportNode = googImportNode;
+      this.globalizeAllReferences = globalizeAllReferences;
       NodeTraversal.traverse(compiler, script, this);
 
       if (googImportNode.getSecondChild().isImportStar()) {
@@ -184,7 +186,8 @@ private void maybeRewriteBadGoogJsImportRef(NodeTraversal t, Node nameNode, Node
         return;
       }
 
-      if (exportsFinder.exportedNames.contains(parent.getSecondChild().getString())) {
+      if (globalizeAllReferences
+          || exportsFinder.exportedNames.contains(parent.getSecondChild().getString())) {
         return;
       }
 
@@ -311,10 +314,11 @@ public void hotSwapScript(Node scriptRoot, Node originalRoot) {
       Node googImportNode = findGoogImportNode(scriptRoot);
       NodeTraversal.traverse(compiler, scriptRoot, new FindReexports(googImportNode != null));
 
-      // exportsFinder can be null in LINT_AND_REWRITE which indicates that goog.js is not part of
-      // the input. Meaning we should just lint and do not do any rewriting.
-      if (exportsFinder != null && googImportNode != null && mode == Mode.LINT_AND_REWRITE) {
-        new ReferenceReplacer(scriptRoot, googImportNode);
+      if (googImportNode != null && mode == Mode.LINT_AND_REWRITE) {
+        // If exportsFinder is null then goog.js was not part of the input. Try to be fault tolerant
+        // and just assume that everything exported is on the global goog.
+        new ReferenceReplacer(
+            scriptRoot, googImportNode, /* globalizeAllReferences= */ exportsFinder == null);
       }
     }
   }

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

@@ -971,4 +971,25 @@ public void testForwardDeclareEs6ModuleInEs6Module() {
                     "alias = goog.modle.get('es6');"))),
         FORWARD_DECLARE_FOR_ES6_SHOULD_BE_CONST);
   }
+
+  @Test
+  public void testMissingRequireAssumesGoogProvide() {
+    ignoreWarnings(MISSING_MODULE_OR_PROVIDE);
+
+    test(
+        srcs(
+            lines(
+                "const missing = goog.require('is.missing');", //
+                "use(missing);",
+                "export {};")),
+        expected(lines("use(is.missing);", "/** @const */ var module$testcode = {};")));
+
+    test(
+        srcs(
+            lines(
+                "import missing from 'goog:is.missing';", //
+                "use(missing);",
+                "export {};")),
+        expected(lines("use(is.missing);", "/** @const */ var module$testcode = {};")));
+  }
 }

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

@@ -65,17 +65,20 @@ public void testBaseAndGoogUntouched() {
   }
 
   @Test
-  public void testIfCannotDetectGoogJsThenDoesNotRewrite() {
+  public void testIfCannotDetectGoogJsThenGlobalizesAll() {
     SourceFile testcode =
         SourceFile.fromCode(
             "testcode", "import * as goog from './closure/goog.js'; use(goog.bad);");
 
+    SourceFile expected =
+        SourceFile.fromCode("testcode", "import './closure/goog.js'; use(goog.bad);");
+
     // No base.js = no detecting goog.js
-    testSame(srcs(GOOG, testcode));
+    test(srcs(GOOG, testcode), expected(GOOG, expected));
 
     // No goog.js
-    testSame(srcs(BASE, testcode));
-    testSame(srcs(testcode));
+    test(srcs(BASE, testcode), expected(BASE, expected));
+    test(srcs(testcode), expected(expected));
 
     // Linting still happens.
     testError("import * as notgoog from './goog.js';", GOOG_JS_IMPORT_MUST_BE_GOOG_STAR);
@@ -121,7 +124,7 @@ public void testGoogAndBaseInExterns() {
   }
 
   @Test
-  public void testBadPropertyAccess() {
+  public void testKnownBadPropertyAccess() {
     test(
         srcs(
             BASE,