Support async functions in CheckMissingReturn

For async functions, if the declared type in JSDoc is Promise<T> or IThenable<T>, we will use T as the declared return type. Otherwise we treat the declared return type as unknown.

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

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

@@ -16,6 +16,7 @@
 
 package com.google.javascript.jscomp;
 
+
 import com.google.common.base.Predicate;
 import com.google.javascript.jscomp.ControlFlowGraph.Branch;
 import com.google.javascript.jscomp.NodeTraversal.ScopedCallback;
@@ -25,6 +26,7 @@
 import com.google.javascript.rhino.jstype.JSType;
 import com.google.javascript.rhino.jstype.JSTypeNative;
 import com.google.javascript.rhino.jstype.TernaryValue;
+import javax.annotation.Nullable;
 
 /**
  * Checks functions for missing return statements. Return statements are only
@@ -91,7 +93,7 @@ public boolean apply(DiGraphEdge<Node, ControlFlowGraph.Branch> input) {
   @Override
   public void enterScope(NodeTraversal t) {
     Node n = t.getScopeRoot();
-    JSType returnType = explicitReturnExpected(n);
+    JSType returnType = getExplicitReturnTypeIfExpected(n);
 
     if (returnType == null) {
       // No return value is expected, so nothing to check.
@@ -172,7 +174,12 @@ public void visit(NodeTraversal t, Node n, Node parent) {
    *
    * @return If a return type is expected, returns it. Otherwise, returns null.
    */
-  private JSType explicitReturnExpected(Node scopeRoot) {
+  @Nullable
+  private JSType getExplicitReturnTypeIfExpected(Node scopeRoot) {
+    if (!scopeRoot.isFunction()) {
+      // Nothing to do in a global/module/block scope.
+      return null;
+    }
     FunctionType scopeType = JSType.toMaybeFunctionType(scopeRoot.getJSType());
 
     if (scopeType == null) {
@@ -193,6 +200,11 @@ private JSType explicitReturnExpected(Node scopeRoot) {
       return null;
     }
 
+    if (scopeRoot.isAsyncFunction()) {
+      // Unwrap the declared return type (e.g. "!Promise<number>" becomes "number")
+      returnType = Promises.getTemplateTypeOfThenable(compiler.getTypeRegistry(), returnType);
+    }
+
     if (!isVoidOrUnknown(returnType)) {
       return returnType;
     }

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

@@ -332,4 +332,29 @@ public void testGeneratorFunctionDoesntWarn() {
             "/** @return {!Object} */", // Return type more vague than Generator is also OK
             "function *gen() {}"));
   }
+
+  public void testAsyncFunction_noJSDoc() {
+    setAcceptedLanguage(LanguageMode.ECMASCRIPT_2017);
+    // Note: we add the alert because CheckMissingReturn never warns on functions with empty bodies.
+    testNoWarning("async function foo() { alert(1); }");
+  }
+
+  public void testAsyncFunction_returnsUndefined() {
+    setAcceptedLanguage(LanguageMode.ECMASCRIPT_2017);
+    testNoWarning("/** @return {!Promise<undefined>} */ async function foo() { alert(1); }");
+  }
+
+  public void testAsyncFunction_returnsUnknown() {
+    setAcceptedLanguage(LanguageMode.ECMASCRIPT_2017);
+    testNoWarning("/** @return {!Promise<?>} */ async function foo() { alert(1); }");
+  }
+
+  public void testAsyncFunction_returnsNumber() {
+    setAcceptedLanguage(LanguageMode.ECMASCRIPT_2017);
+    testNoWarning("/** @return {!Promise<number>} */ async function foo() { return 1; }");
+
+    testWarning(
+        "/** @return {!Promise<string>} */ async function foo() { alert(1); }",
+        CheckMissingReturn.MISSING_RETURN_STATEMENT);
+  }
 }