Check the underlying type of get-only computed properties with opaque return types.

Author: jckarter

lib/Sema/MiscDiagnostics.cpp

@@ -2804,6 +2804,13 @@ void swift::performAbstractFuncDeclDiagnostics(TypeChecker &TC,
   // to determine the underlying type.
   if (auto opaqueResultTy = AFD->getOpaqueResultTypeDecl()) {
     OpaqueUnderlyingTypeChecker(TC, AFD, opaqueResultTy).check();
+  } else if (auto accessor = dyn_cast<AccessorDecl>(AFD)) {
+    if (accessor->isGetter()) {
+      if (auto opaqueResultTy
+                          = accessor->getStorage()->getOpaqueResultTypeDecl()) {
+        OpaqueUnderlyingTypeChecker(TC, AFD, opaqueResultTy).check();
+      }
+    }
   }
 }
 

lib/Sema/TypeCheckStmt.cpp

@@ -468,11 +468,26 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
 
     // If the result type is an opaque type, this is an opportunity to resolve
     // the underlying type.
+    auto isOpaqueReturnTypeOfCurrentFunc = [&](OpaqueTypeDecl *opaque) -> bool {
+      // Closures currently don't support having opaque types.
+      auto funcDecl = TheFunc->getAbstractFunctionDecl();
+      if (!funcDecl)
+        return false;
+      // Either the function is declared with its own opaque return type...
+      if (opaque->getNamingDecl() == funcDecl)
+        return true;
+      // ...or the function is a getter for a property or subscript with an
+      // opaque return type.
+      if (auto accessor = dyn_cast<AccessorDecl>(funcDecl)) {
+        return accessor->isGetter()
+          && opaque->getNamingDecl() == accessor->getStorage();
+      }
+      return false;
+    };
+    
     if (auto opaque = ResultTy->getAs<OpaqueTypeArchetypeType>()) {
-      if (auto funcDecl = TheFunc->getAbstractFunctionDecl()) {
-        if (opaque->getDecl()->getNamingDecl() == funcDecl) {
-          options |= TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType;
-        }
+      if (isOpaqueReturnTypeOfCurrentFunc(opaque->getDecl())) {
+        options |= TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType;
       }
     }
 

test/type/opaque.swift

@@ -15,22 +15,23 @@ class D: C, P, Q { func paul() {}; func priscilla() {}; func quinn() {} }
 // TODO: Should be valid
 
 let property: some P = 1 // TODO expected-error{{cannot convert}}
+let deflessProperty: some P // TODO e/xpected-error{{butz}}
 
 struct GenericProperty<T: P> {
   var x: T
   var property: some P {
-    return x // TODO expected-error{{cannot convert}}
+    return x
   }
 }
 
 let (bim, bam): some P = (1, 2) // expected-error{{'some' type can only be declared on a single property declaration}}
 var computedProperty: some P {
-  get { return 1 } // TODO expected-error{{cannot convert}}
+  get { return 1 }
   set { _ = newValue + 1 } // TODO expected-error{{}} expected-note{{}}
 }
 struct SubscriptTest {
   subscript(_ x: Int) -> some P {
-    return x // TODO expected-error{{cannot convert}}
+    return x
   }
 }
 
@@ -183,6 +184,24 @@ func mismatchedReturnTypes(_ x: Bool, _ y: Int, _ z: String) -> some P { // expe
   }
 }
 
+var mismatchedReturnTypesProperty: some P { // expected-error{{do not have matching underlying types}}
+  if true {
+    return 0 // expected-note{{underlying type 'Int'}}
+  } else {
+    return "" // expected-note{{underlying type 'String'}}
+  }
+}
+
+struct MismatchedReturnTypesSubscript {
+  subscript(x: Bool, y: Int, z: String) -> some P { // expected-error{{do not have matching underlying types}}
+    if x {
+      return y // expected-note{{underlying type 'Int'}}
+    } else {
+      return z // expected-note{{underlying type 'String'}}
+    }
+  }
+}
+
 func jan() -> some P {
   return [marcia(), marcia(), marcia()]
 }