[MiscDiagnostics] Run opaque return checker only if all of the return expressions are correct

Author: xedin

lib/Sema/MiscDiagnostics.cpp

@@ -2218,6 +2218,9 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
   AbstractFunctionDecl *Implementation;
   OpaqueTypeDecl *OpaqueDecl;
   SmallVector<std::pair<Expr*, Type>, 4> Candidates;
+
+  bool HasInvalidReturn = false;
+
 public:
   OpaqueUnderlyingTypeChecker(TypeChecker &TC,
                               AbstractFunctionDecl *Implementation,
@@ -2231,7 +2234,13 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
 
   void check() {
     Implementation->getBody()->walk(*this);
-    
+
+    // If given function has any invalid returns in the body
+    // let's not try to validate the types, since it wouldn't
+    // be accurate.
+    if (HasInvalidReturn)
+      return;
+
     // If there are no candidates, then the body has no return statements, and
     // we have nothing to infer the underlying type from.
     if (Candidates.empty()) {
@@ -2310,6 +2319,20 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
     }
     return std::make_pair(false, E);
   }
+
+  std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
+    if (auto *RS = dyn_cast<ReturnStmt>(S)) {
+      if (RS->hasResult()) {
+        auto resultTy = RS->getResult()->getType();
+        // If expression associated with return statement doesn't have
+        // a type or type has an error, checking opaque types is going
+        // to produce incorrect diagnostics.
+        HasInvalidReturn |= resultTy.isNull() || resultTy->hasError();
+      }
+    }
+
+    return {true, S};
+  }
 };
 
 } // end anonymous namespace

test/type/opaque.swift

@@ -319,36 +319,40 @@ func diagnose_requirement_failures() {
   struct S {
     var foo: some P { return S() } // expected-note {{declared here}}
     // expected-error@-1 {{return type of property 'foo' requires that 'S' conform to 'P'}}
-    // expected-error@-2 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
     subscript(_: Int) -> some P { // expected-note {{declared here}}
-      // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
       return S()
       // expected-error@-1 {{return type of subscript 'subscript(_:)' requires that 'S' conform to 'P'}}
     }
 
     func bar() -> some P { // expected-note {{declared here}}
-      // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
       return S()
       // expected-error@-1 {{return type of instance method 'bar()' requires that 'S' conform to 'P'}}
     }
 
     static func baz(x: String) -> some P { // expected-note {{declared here}}
-      // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
       return S()
       // expected-error@-1 {{return type of static method 'baz(x:)' requires that 'S' conform to 'P'}}
     }
   }
 
   func fn() -> some P { // expected-note {{declared here}}
-    // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
     return S()
     // expected-error@-1 {{return type of local function 'fn()' requires that 'S' conform to 'P'}}
   }
 }
 
 func global_function_with_requirement_failure() -> some P { // expected-note {{declared here}}
-  // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
   return 42 as Double
   // expected-error@-1 {{return type of global function 'global_function_with_requirement_failure()' requires that 'Double' conform to 'P'}}
 }
+
+func recursive_func_is_invalid_opaque() {
+  func rec(x: Int) -> some P {
+    // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+    if x == 0 {
+      return rec(x: 0)
+    }
+    return rec(x: x - 1)
+  }
+}