---

yaml
---
r: 284415
b: refs/heads/swift-5.1-branch
c: 6500ef3
h: refs/heads/master
i:
  284413: a10023a
  284411: c9a9f4e
  284407: 123d0c5
  284399: 0b0e6de
  284383: 69150ec
  284351: 0773ae6
  284287: e3a1c2a
  284159: 5d96af4

Author: jckarter

[refs]

@@ -1242,7 +1242,7 @@ refs/heads/marcrasi-astverifier-disable: 3fac766a23a77ebd0640296bfd7fc116ea60a4e
 refs/heads/revert-22227-a-tall-white-fountain-played: adfce60b2eaa54903ea189bed8a783bca609fa53
 refs/heads/revert-22300-revert-22227-a-tall-white-fountain-played: 5f92040224df7dd4e618fdfb367349df64d8acad
 refs/heads/swift-5.1-old-llvm-branch: 9cef8175146f25b72806154b8a0f4a3f52e3e400
-refs/heads/swift-5.1-branch: dc9b907b4dfa5b634dfaaf73224bcec83b074746
+refs/heads/swift-5.1-branch: 6500ef339208ef007e3aca8e4e79b433e65879c5
 refs/tags/swift-4.2.2-RELEASE: e429d1f1aaf59e69d38207a96e56265c7f6fccec
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-02-a: 3e5a03d32ff3b1e9af90d6c1198c14f938379a6e
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-03-a: 4591c933063ddcb0d6cd6d0cdd01086b2f9b244d

branches/swift-5.1-branch/lib/Parse/ParseDecl.cpp

@@ -5197,12 +5197,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
@@ -6364,6 +6374,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);
+    }
+  }
 
   // Parse a 'where' clause if present, adding it to our GenericParamList.
   if (Tok.is(tok::kw_where)) {

branches/swift-5.1-branch/lib/Sema/TypeCheckDecl.cpp

@@ -1986,6 +1986,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);
 

branches/swift-5.1-branch/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}}

branches/swift-5.1-branch/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
   }
 }