Track var/subscript opaque return decls for type reconstruction.

Author: jckarter

lib/Parse/ParseDecl.cpp

@@ -5226,12 +5226,22 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
       pattern = patternRes.get();
     }
 
+    bool hasOpaqueReturnTy = false;
+    if (auto typedPattern = dyn_cast<TypedPattern>(pattern)) {
+      hasOpaqueReturnTy =
+                        isa<OpaqueReturnTypeRepr>(typedPattern->getTypeRepr());
+    }
+    auto sf = CurDeclContext->getParentSourceFile();
+    
     // Configure all vars with attributes, 'static' and parent pattern.
     pattern->forEachVariable([&](VarDecl *VD) {
       VD->setStatic(StaticLoc.isValid());
       VD->getAttrs() = Attributes;
       setLocalDiscriminator(VD);
       Decls.push_back(VD);
+      if (hasOpaqueReturnTy && sf) {
+        sf->addUnvalidatedDeclWithOpaqueResultType(VD);
+      }
     });
 
     // Remember this pattern/init pair for our ultimate PatternBindingDecl. The
@@ -6394,6 +6404,13 @@ Parser::parseDeclSubscript(SourceLoc StaticLoc,
                                                 CurDeclContext,
                                                 nullptr);
   Subscript->getAttrs() = Attributes;
+  
+  // Let the source file track the opaque return type mapping, if any.
+  if (ElementTy.get() && isa<OpaqueReturnTypeRepr>(ElementTy.get())) {
+    if (auto sf = CurDeclContext->getParentSourceFile()) {
+      sf->addUnvalidatedDeclWithOpaqueResultType(Subscript);
+    }
+  }
 
   DefaultArgs.setFunctionContext(Subscript, Subscript->getIndices());
 

lib/Sema/TypeCheckDecl.cpp

@@ -1981,6 +1981,12 @@ static bool shouldUseOpaqueReadAccessor(TypeChecker &TC,
 
 static void validateAbstractStorageDecl(TypeChecker &TC,
                                         AbstractStorageDecl *storage) {
+  if (storage->getOpaqueResultTypeDecl()) {
+    if (auto sf = storage->getInnermostDeclContext()->getParentSourceFile()) {
+      sf->markDeclWithOpaqueResultTypeAsValidated(storage);
+    }
+  }
+  
   if (shouldUseOpaqueReadAccessor(TC, storage))
     storage->setOpaqueReadOwnership(OpaqueReadOwnership::Borrowed);
 

test/ParseableInterface/Inputs/opaque-result-types-client.swift

@@ -3,6 +3,12 @@ import OpaqueResultTypes
 func getAssocType<T: AssocTypeInference>(_ x: T) -> T.Assoc {
   return x.foo(0)
 }
+func getAssocPropType<T: AssocTypeInference>(_ x: T) -> T.AssocProperty {
+  return x.prop
+}
+func getAssocSubscriptType<T: AssocTypeInference>(_ x: T) -> T.AssocSubscript {
+  return x[]
+}
 
 struct MyFoo: Foo {}
 struct YourFoo: Foo {}
@@ -29,6 +35,18 @@ func someTypeIsTheSame() {
   d = barString.foo(0) // expected-error{{cannot assign}}
   d = getAssocType(barInt)
   d = getAssocType(barString) // expected-error{{cannot assign}}
+  
+  var d2 = barInt.prop
+  d2 = barInt.prop
+  d2 = barString.prop // expected-error{{cannot assign}}
+  d2 = getAssocPropType(barInt)
+  d2 = getAssocPropType(barString) // expected-error{{cannot assign}}
+
+  var d3 = barInt[]
+  d3 = barInt[]
+  d3 = barString[] // expected-error{{cannot assign}}
+  d3 = getAssocSubscriptType(barInt)
+  d3 = getAssocSubscriptType(barString) // expected-error{{cannot assign}}
 
   var e = barString.foo(0)
   e = barInt.foo(0) // expected-error{{cannot assign}}

test/ParseableInterface/opaque-result-types.swift

@@ -23,8 +23,13 @@ public func foo<T: Foo>(_ x: T) -> some Foo {
 
 public protocol AssocTypeInference {
   associatedtype Assoc: Foo
+  associatedtype AssocProperty: Foo
+  associatedtype AssocSubscript: Foo
 
   func foo(_: Int) -> Assoc
+
+  var prop: AssocProperty { get }
+  subscript() -> AssocSubscript { get }
 }
 
 public struct Bar<T>: AssocTypeInference {
@@ -61,7 +66,16 @@ public struct Bar<T>: AssocTypeInference {
       return x
     }
 
+    public var prop: some Foo {
+      return 123
+    }
+    public subscript() -> some Foo {
+      return 123
+    }
+
     // CHECK-LABEL: public typealias Assoc = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T>
+    // CHECK-LABEL: public typealias AssocProperty = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T>
+    // CHECK-LABEL: public typealias AssocSubscript = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T>
   }
 
   public struct Bass<U: Foo>: AssocTypeInference {
@@ -85,11 +99,28 @@ public struct Bar<T>: AssocTypeInference {
     public func foo<V: Foo>(_ x: V) -> some Foo {
       return x
     }
+    public var prop: some Foo {
+      return 123
+    }
+    public subscript() -> some Foo {
+      return 123
+    }
 
     // CHECK-LABEL: public typealias Assoc = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T, U>
+    // CHECK-LABEL: public typealias AssocProperty = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T, U>
+    // CHECK-LABEL: public typealias AssocSubscript = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T, U>
+  }
+
+  public var prop: some Foo {
+    return 123
+  }
+  public subscript() -> some Foo {
+    return 123
   }
 
   // CHECK-LABEL: public typealias Assoc = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T>
+  // CHECK-LABEL: public typealias AssocProperty = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T>
+  // CHECK-LABEL: public typealias AssocSubscript = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<T>
 }
 
 public struct Zim: AssocTypeInference {
@@ -123,6 +154,13 @@ public struct Zim: AssocTypeInference {
     public func foo<U: Foo>(_ x: U) -> some Foo {
       return x
     }
+
+    public var prop: some Foo {
+      return 123
+    }
+    public subscript() -> some Foo {
+      return 123
+    }
   }
 
   public struct Zung<U: Foo>: AssocTypeInference {
@@ -146,6 +184,22 @@ public struct Zim: AssocTypeInference {
       return x
     }
 
+    public var prop: some Foo {
+      return 123
+    }
+    public subscript() -> some Foo {
+      return 123
+    }
+
     // CHECK-LABEL: public typealias Assoc = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<U>
+    // CHECK-LABEL: public typealias AssocProperty = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<U>
+    // CHECK-LABEL: public typealias AssocSubscript = @_opaqueReturnTypeOf("{{.*}}", 0) {{.*}}<U>
+  }
+
+  public var prop: some Foo {
+    return 123
+  }
+  public subscript() -> some Foo {
+    return 123
   }
 }