Handle interop between goog.provides and goog.modules and fix typedef…

… bug

 - declare legacy namespace exports in the global scope
 - goog.modules can require a goog.provide'd name

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

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

@@ -466,16 +466,17 @@ private void validateNameType(Node nameNode) {
   private void validateCallType(Node callNode) {
     // TODO(b/74537281): Shouldn't CALL nodes always have a type, even if it is unknown?
     Node callee = callNode.getFirstChild();
-    JSType calleeTypeI =
+    JSType calleeType =
         checkNotNull(callee.getJSType(), "Callee of\n\n%s\nhas no type.", callNode.toStringTree());
 
-    if (calleeTypeI.isFunctionType()) {
-      FunctionType calleeFunctionTypeI = calleeTypeI.toMaybeFunctionType();
-      JSType returnTypeI = calleeFunctionTypeI.getReturnType();
+    if (calleeType.isFunctionType()) {
+      FunctionType calleeFunctionType = calleeType.toMaybeFunctionType();
+      JSType returnType = calleeFunctionType.getReturnType();
       // Skip this check if the call node was originally in a cast, because the cast type may be
-      // narrower than the return type.
-      if (callNode.getJSTypeBeforeCast() == null) {
-        expectMatchingTypeInformation(callNode, returnTypeI);
+      // narrower than the return type. Also skip the check if the function's return type is the
+      // any (formerly unknown) type, since we may have inferred a better type.
+      if (callNode.getJSTypeBeforeCast() == null && !returnType.isUnknownType()) {
+        expectMatchingTypeInformation(callNode, returnType);
       }
     } // TODO(b/74537281): What other cases should be covered?
   }

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

@@ -15,6 +15,7 @@
  */
 package com.google.javascript.jscomp;
 
+import static com.google.common.base.Preconditions.checkArgument;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.javascript.jscomp.modules.Module;
@@ -74,23 +75,36 @@ ScopedName getClosureNamespaceTypeFromCall(Node googRequire) {
     if (module == null) {
       return null;
     }
+    switch (module.metadata().moduleType()) {
+      case GOOG_PROVIDE:
+        // Expect this to be a global variable
+        Node provide = module.metadata().rootNode();
+        if (provide != null && provide.isScript()) {
+          return ScopedName.of(moduleId, provide.getGrandparent());
+        } else {
+          // Unknown module requires default to 'goog provides', but we don't want to type them.
+          return null;
+        }
 
-    Node scopeRoot = getModuleScopeRoot(module);
-    if (scopeRoot != null) {
-      return ScopedName.of("exports", scopeRoot);
+      case GOOG_MODULE:
+      case LEGACY_GOOG_MODULE:
+        // TODO(b/124919359): Fix getGoogModuleScopeRoot to never return null.
+        Node scopeRoot = getGoogModuleScopeRoot(module);
+        return scopeRoot != null ? ScopedName.of("exports", scopeRoot) : null;
+      case ES6_MODULE:
+        throw new IllegalStateException("Type checking ES modules not yet supported");
+      case COMMON_JS:
+        throw new IllegalStateException("Type checking CommonJs modules not yet supported");
+      case SCRIPT:
+        throw new IllegalStateException("Cannot import a name from a SCRIPT");
     }
-    // TODO(b/124919359): assert that this is non-nullable once getModuleScopeRoot handles modules
-    // other than goog.modules.
-    return null;
+    throw new AssertionError();
   }
 
-  /** Converts a {@link Module} reference to a {@link Node} scope root. */
+  /** Returns the corresponding scope root Node from a goog.module. */
   @Nullable
-  private Node getModuleScopeRoot(@Nullable Module module) {
-    if (!module.metadata().isGoogModule()) {
-      // TODO(b/124919359): also handle ES modules and goog.provides
-      return null;
-    }
+  private Node getGoogModuleScopeRoot(@Nullable Module module) {
+    checkArgument(module.metadata().isGoogModule(), module.metadata());
     Node scriptNode = module.metadata().rootNode();
 
     if (scriptNode.isScript()

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

@@ -54,6 +54,9 @@
  * <p>This also annotates all provided namespace definitions `a.b = {};` with {@link
  * Node#IS_NAMESPACE} so that later passes know they refer to a goog.provide'd namespace.
  *
+ * <p>If modules have not been rewritten, this pass also includes legacy Closure module namespaces
+ * in the list of {@link ProvidedName}s.
+ *
  * @author chrisn@google.com (Chris Nokleberg)
  */
 class ProcessClosureProvidesAndRequires {
@@ -151,6 +154,20 @@ private void checkForLateOrMissingProvide(UnrecognizedRequire r) {
   private class CollectDefinitions implements NodeTraversal.Callback {
     @Override
     public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
+      // Don't recurse into modules, which cannot have goog.provides.  We do need to handle legacy
+      // goog.modules, but we do that quickly here rather than descending all the way into them.
+      // We completely ignore ES modules and CommonJS modules.
+      if ((n.isModuleBody() && n.getParent().getBooleanProp(Node.GOOG_MODULE))
+          || NodeUtil.isBundledGoogModuleScopeRoot(n)) {
+        Node googModuleCall = n.getFirstChild();
+        String closureNamespace = googModuleCall.getFirstChild().getSecondChild().getString();
+        Node maybeLegacyNamespaceCall = googModuleCall.getNext();
+        if (maybeLegacyNamespaceCall != null
+            && NodeUtil.isGoogModuleDeclareLegacyNamespaceCall(maybeLegacyNamespaceCall)) {
+          processLegacyModuleCall(closureNamespace, googModuleCall, t.getModule());
+        }
+        return false;
+      }
       return !n.isModuleBody();
     }
 
@@ -322,6 +339,19 @@ private void processRequireCall(NodeTraversal t, Node n, Node parent) {
     }
   }
 
+  /** Handles a goog.module that is a legacy namespace. */
+  private void processLegacyModuleCall(String namespace, Node googModuleCall, JSModule module) {
+    registerAnyProvidedPrefixes(namespace, googModuleCall, module);
+    providedNames.put(
+        namespace,
+        new ProvidedName(
+            namespace,
+            googModuleCall,
+            module,
+            /* explicit= */ true,
+            /* fromPreviousProvide= */ false));
+  }
+
   /** Handles a goog.provide call. */
   private void processProvideCall(NodeTraversal t, Node n, Node parent) {
     checkState(n.isCall());
@@ -700,8 +730,8 @@ private boolean hasCandidateDefinitionNotFromPreviousPass() {
     }
 
     /**
-     * Returns the `goog.provide` call that created this name, if any, or otherwise the first
-     * 'previous provide' assignmetn that created this name.
+     * Returns the `goog.provide` or legacy namespace `goog.module` call that created this name, if
+     * any, or otherwise the first 'previous provide' assignment that created this name.
      */
     Node getFirstProvideCall() {
       return firstNode;