[MiscDiagnostics] OpaqueChecker: Double-check validity of last expression

It's possible that TypeChecker::typeCheckStmt has did not propagate
`HadError` properly while checking the body of a function, so opaque
result checker has to be careful about requesting types from expressions.

Resolves: rdar://100066109

Author: xedin

lib/Sema/MiscDiagnostics.cpp

@@ -2718,20 +2718,28 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         auto element = Body->getLastElement();
         // Let's see if the last statement would make for a valid return value.
         if (auto expr = element.dyn_cast<Expr *>()) {
-          bool conforms = llvm::all_of(OpaqueDecl->getOpaqueInterfaceGenericSignature().getRequirements(),
-                                       [&expr, this](auto requirement) {
-            if (requirement.getKind() == RequirementKind::Conformance) {
-              auto conformance =
-                  TypeChecker::conformsToProtocol(expr->getType()->getRValueType(),
-                                                  requirement.getProtocolDecl(),
-                                                  Implementation->getModuleContext(),
-                                                  /*allowMissing=*/ false);
-              return !conformance.isInvalid();
-            }
-            // If we encounter any requirements other than `Conformance`, we do
-            // not attempt to type check the expression.
-            return false;
-          });
+          auto exprType = expr->getType();
+          // Function body might not be valid and we cannot reply on
+          // \c typeCheckStmt here to propagate HadError because its
+          // unreliable.
+          if (!exprType || exprType->hasError())
+            return;
+
+          bool conforms = llvm::all_of(
+              OpaqueDecl->getOpaqueInterfaceGenericSignature()
+                  .getRequirements(),
+              [&exprType, this](auto requirement) {
+                if (requirement.getKind() == RequirementKind::Conformance) {
+                  auto conformance = TypeChecker::conformsToProtocol(
+                      exprType->getRValueType(), requirement.getProtocolDecl(),
+                      Implementation->getModuleContext(),
+                      /*allowMissing=*/false);
+                  return !conformance.isInvalid();
+                }
+                // If we encounter any requirements other than `Conformance`, we
+                // do not attempt to type check the expression.
+                return false;
+              });
 
           // If all requirements are fulfilled, we offer to insert `return` to
           // fix the issue.

test/type/opaque.swift

@@ -571,4 +571,10 @@ do {
     let x = S2()
     x // expected-warning {{expression of type 'S2' is unused}}
   }
+
+  func test5() -> some P1 {
+    // expected-error@-1 {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+    let x = invalid // expected-error {{cannot find 'invalid' in scope}}
+    x
+  }
 }