---

yaml
---
r: 284607
b: refs/heads/swift-5.1-branch-04-24-2019
c: f135577
h: refs/heads/master
i:
  284605: ffc1ba9
  284603: 0654ebd
  284599: 70ddc65
  284591: d2b8b61
  284575: 70457ea
  284543: ff7d609

Author: jckarter

[refs]

@@ -1319,4 +1319,4 @@ refs/heads/revert-24065-raj-es-perf-bench: acd6c09b6bd8c5aa922845ee4465bf1333e4f
 refs/heads/rxwei-patch-3: d5f349dedfb5fcaf84c5ac788ad33ea47e502d11
 refs/heads/rxwei-patch-4: d60ed33a03d398b956e1aa81f37b04d0b1cf101e
 refs/heads/rxwei-patch-4-1: b7adfa58fd761906363d280fe323578f61097822
-refs/heads/swift-5.1-branch-04-24-2019: cb2fcb6e5624163cc7f7526991eda23e10f195e4
+refs/heads/swift-5.1-branch-04-24-2019: f13557735cabc8edd9a18d58fac74e63f400ae0f

branches/swift-5.1-branch-04-24-2019/include/swift/AST/Decl.h

@@ -4391,6 +4391,8 @@ class AbstractStorageDecl : public ValueDecl {
   }
 
   void computeIsValidKeyPathComponent();
+  
+  OpaqueTypeDecl *OpaqueReturn = nullptr;
 
 public:
 
@@ -4676,6 +4678,14 @@ class AbstractStorageDecl : public ValueDecl {
 
   bool hasDidSetOrWillSetDynamicReplacement() const;
 
+  OpaqueTypeDecl *getOpaqueResultTypeDecl() const {
+    return OpaqueReturn;
+  }
+  void setOpaqueResultTypeDecl(OpaqueTypeDecl *decl) {
+    assert(!OpaqueReturn && "already has opaque type decl");
+    OpaqueReturn = decl;
+  }
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractStorageDecl &&

branches/swift-5.1-branch-04-24-2019/include/swift/AST/DiagnosticsParse.def

@@ -786,7 +786,7 @@ ERROR(sil_box_expected_r_angle,none,
 
 // Opaque types
 ERROR(opaque_mid_composition,none,
-      "'opaque' should appear at the beginning of a composition", ())
+      "'some' should appear at the beginning of a composition", ())
 
 //------------------------------------------------------------------------------
 // MARK: Layout constraint diagnostics

branches/swift-5.1-branch-04-24-2019/include/swift/AST/DiagnosticsSema.def

@@ -3558,7 +3558,10 @@ ERROR(unreferenced_generic_parameter,none,
 
 // Opaque types
 ERROR(unsupported_opaque_type,none,
-      "'opaque' types are only implemented for the declared type of properties and subscripts and the return type of functions", ())
+      "'some' types are only implemented for the declared type of properties and subscripts and the return type of functions", ())
+
+ERROR(opaque_type_unsupported_pattern,none,
+      "'some' type can only be declared on a single property declaration", ())
 
 // SIL
 ERROR(opened_non_protocol,none,

branches/swift-5.1-branch-04-24-2019/lib/AST/Decl.cpp

@@ -2319,6 +2319,8 @@ void ValueDecl::setOverriddenDecls(ArrayRef<ValueDecl *> overridden) {
 OpaqueTypeDecl *ValueDecl::getOpaqueResultTypeDecl() const {
   if (auto func = dyn_cast<FuncDecl>(this)) {
     return func->getOpaqueResultTypeDecl();
+  } else if (auto storage = dyn_cast<AbstractStorageDecl>(this)) {
+    return storage->getOpaqueResultTypeDecl();
   } else {
     return nullptr;
   }
@@ -2327,6 +2329,8 @@ OpaqueTypeDecl *ValueDecl::getOpaqueResultTypeDecl() const {
 void ValueDecl::setOpaqueResultTypeDecl(OpaqueTypeDecl *D) {
   if (auto func = dyn_cast<FuncDecl>(this)) {
     func->setOpaqueResultTypeDecl(D);
+  } else if (auto storage = dyn_cast<AbstractStorageDecl>(this)){
+    storage->setOpaqueResultTypeDecl(D);
   } else {
     llvm_unreachable("decl does not support opaque result types");
   }

branches/swift-5.1-branch-04-24-2019/lib/Sema/TypeCheckGeneric.cpp

@@ -173,10 +173,9 @@ static void revertDependentTypeLoc(TypeLoc &tl) {
 
 /// Get the opaque type representing the return type of a declaration, or
 /// create it if it does not yet exist.
-static Type getOpaqueResultType(TypeChecker &tc,
-                                TypeResolution resolution,
-                                ValueDecl *originatingDecl,
-                                OpaqueReturnTypeRepr *repr) {
+Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
+                                              ValueDecl *originatingDecl,
+                                              OpaqueReturnTypeRepr *repr) {
   // If the decl already has an opaque type decl for its return type, use it.
   if (auto existingDecl = originatingDecl->getOpaqueResultTypeDecl()) {
     return existingDecl->getDeclaredInterfaceType();
@@ -188,16 +187,16 @@ static Type getOpaqueResultType(TypeChecker &tc,
   TypeLoc constraintTypeLoc(repr->getConstraint());
   // Pass along the error type if resolving the repr failed.
   bool validationError
-    = tc.validateType(constraintTypeLoc, resolution, options);
+    = validateType(constraintTypeLoc, resolution, options);
   auto constraintType = constraintTypeLoc.getType();
   if (validationError)
     return constraintType;
 
   // Error out if the constraint type isn't a class or existential type.
   if (!constraintType->getClassOrBoundGenericClass()
       && !constraintType->isExistentialType()) {
-    tc.diagnose(repr->getConstraint()->getLoc(),
-                diag::opaque_type_invalid_constraint);
+    diagnose(repr->getConstraint()->getLoc(),
+             diag::opaque_type_invalid_constraint);
     return constraintTypeLoc.getType();
   }
 
@@ -222,7 +221,7 @@ static Type getOpaqueResultType(TypeChecker &tc,
   if (!interfaceGenericParams.empty())
     returnTypeDepth = interfaceGenericParams.back()->getDepth() + 1;
   auto returnTypeParam = GenericTypeParamType::get(returnTypeDepth, 0,
-                                                   tc.Context);
+                                                   Context);
   interfaceGenericParams.push_back(returnTypeParam);
 
   if (constraintType->getClassOrBoundGenericClass()) {
@@ -252,14 +251,17 @@ static Type getOpaqueResultType(TypeChecker &tc,
   // It has the same parent context and generic environment as the originating
   // decl.
   auto dc = originatingDecl->getDeclContext();
-  // TODO: generalize
-  auto genericParams = cast<FuncDecl>(originatingDecl)->getGenericParams();
-
-  auto opaqueDecl = new (tc.Context) OpaqueTypeDecl(originatingDecl,
-                                                    genericParams,
-                                                    dc,
-                                                    interfaceSignature,
-                                                    returnTypeParam);
+  
+  auto originatingGenericContext = originatingDecl->getAsGenericContext();
+  GenericParamList *genericParams = originatingGenericContext
+    ? originatingGenericContext->getGenericParams()
+    : nullptr;
+
+  auto opaqueDecl = new (Context) OpaqueTypeDecl(originatingDecl,
+                                                 genericParams,
+                                                 dc,
+                                                 interfaceSignature,
+                                                 returnTypeParam);
   opaqueDecl->copyFormalAccessFrom(originatingDecl);
   if (auto originatingEnv = originatingDC->getGenericEnvironmentOfContext()) {
     opaqueDecl->setGenericEnvironment(originatingEnv);
@@ -315,7 +317,7 @@ static void checkGenericFuncSignature(TypeChecker &tc,
         // checking.
         if (resolution.getStage() != TypeResolutionStage::Structural) {
           resultTypeLoc.setType(
-                          getOpaqueResultType(tc, resolution, fn, opaqueType));
+                    tc.getOrCreateOpaqueResultType(resolution, fn, opaqueType));
         }
       } else {
         TypeResolutionOptions options(fn->hasDynamicSelf()
@@ -676,9 +678,17 @@ static void checkGenericSubscriptSignature(TypeChecker &tc,
   }
 
   // Check the element type.
-  tc.validateType(subscript->getElementTypeLoc(), resolution,
-                  TypeResolverContext::FunctionResult);
-
+  // It's allowed to be an opaque return type.
+  if (auto opaqueReturn = dyn_cast<OpaqueReturnTypeRepr>(
+                               subscript->getElementTypeLoc().getTypeRepr())) {
+    auto opaqueTy = tc.getOrCreateOpaqueResultType(resolution, subscript,
+                                                   opaqueReturn);
+    subscript->getElementTypeLoc().setType(opaqueTy);
+  } else {
+    tc.validateType(subscript->getElementTypeLoc(), resolution,
+                    TypeResolverContext::FunctionResult);
+  }
+  
   // Infer requirements from it.
   if (builder) {
     auto source =

branches/swift-5.1-branch-04-24-2019/lib/Sema/TypeCheckPattern.cpp

@@ -684,7 +684,28 @@ static bool validateTypedPattern(TypeChecker &TC,
     return TP->getType()->hasError();
 
   TypeLoc TL = TP->getTypeLoc();
-  bool hadError = TC.validateType(TL, resolution, options);
+  
+  bool hadError;
+  
+  // If the pattern declares an opaque type, and applies to a single
+  // variable binding, then we can bind the opaque return type from the
+  // property definition.
+  if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(TL.getTypeRepr())) {
+    auto named = dyn_cast<NamedPattern>(
+                           TP->getSubPattern()->getSemanticsProvidingPattern());
+    if (named) {
+      auto opaqueTy = TC.getOrCreateOpaqueResultType(resolution,
+                                                     named->getDecl(),
+                                                     opaqueRepr);
+      TL.setType(opaqueTy);
+      hadError = opaqueTy->hasError();
+    } else {
+      TC.diagnose(TP->getLoc(), diag::opaque_type_unsupported_pattern);
+      hadError = true;
+    }
+  } else {
+    hadError = TC.validateType(TL, resolution, options);
+  }
 
   if (hadError) {
     TP->setType(ErrorType::get(TC.Context));

branches/swift-5.1-branch-04-24-2019/lib/Sema/TypeChecker.h

@@ -2113,6 +2113,10 @@ class TypeChecker final : public LazyResolver {
   /// Check if the given decl has a @_semantics attribute that gives it
   /// special case type-checking behavior.
   DeclTypeCheckingSemantics getDeclTypeCheckingSemantics(ValueDecl *decl);
+  
+  Type getOrCreateOpaqueResultType(TypeResolution resolution,
+                                   ValueDecl *originatingDecl,
+                                   OpaqueReturnTypeRepr *repr);
 };
 
 /// Temporary on-stack storage and unescaping for encoded diagnostic

branches/swift-5.1-branch-04-24-2019/test/type/opaque.swift

@@ -14,14 +14,23 @@ class D: C, P, Q { func paul() {}; func priscilla() {}; func quinn() {} }
 
 // TODO: Should be valid
 
-let foo: some P = 1 // FIXME expected-error{{'opaque' types are only implemented}}
-var computedFoo: some P {  // FIXME expected-error{{'opaque' types are only implemented}}
-  get { return 1 }
-  set { _ = newValue + 1 }
+let property: some P = 1 // TODO expected-error{{cannot convert}}
+
+struct GenericProperty<T: P> {
+  var x: T
+  var property: some P {
+    return x // TODO expected-error{{cannot convert}}
+  }
+}
+
+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}}
+  set { _ = newValue + 1 } // TODO expected-error{{}} expected-note{{}}
 }
 struct SubscriptTest {
-  subscript(_ x: Int) -> some P { // expected-error{{'opaque' types are only implemented}}
-    return x
+  subscript(_ x: Int) -> some P {
+    return x // TODO expected-error{{cannot convert}}
   }
 }
 
@@ -64,23 +73,23 @@ struct Test {
   let inferredOpaqueStructural2 = (bar(), bas()) // expected-error{{inferred type}}
 }
 
-//let zingle = {() -> some P in 1 } // FIXME ex/pected-error{{'opaque' types are only implemented}}
+//let zingle = {() -> some P in 1 } // FIXME ex/pected-error{{'some' types are only implemented}}
 
 // Invalid positions
 
-typealias Foo = some P // expected-error{{'opaque' types are only implemented}}
+typealias Foo = some P // expected-error{{'some' types are only implemented}}
 
-func blibble(blobble: some P) {} // expected-error{{'opaque' types are only implemented}}
+func blibble(blobble: some P) {} // expected-error{{'some' types are only implemented}}
 
-let blubble: () -> some P = { 1 } // expected-error{{'opaque' types are only implemented}}
+let blubble: () -> some P = { 1 } // expected-error{{'some' types are only implemented}}
 
-func blib() -> P & some Q { return 1 } // expected-error{{'opaque' should appear at the beginning}}
-func blab() -> (P, some Q) { return (1, 2) } // expected-error{{'opaque' types are only implemented}}
-func blob() -> (some P) -> P { return { $0 } } // expected-error{{'opaque' types are only implemented}}
-func blorb<T: some P>(_: T) { } // expected-error{{'opaque' types are only implemented}}
-func blub<T>() -> T where T == some P { return 1 } // expected-error{{'opaque' types are only implemented}} expected-error{{cannot convert}}
+func blib() -> P & some Q { return 1 } // expected-error{{'some' should appear at the beginning}}
+func blab() -> (P, some Q) { return (1, 2) } // expected-error{{'some' types are only implemented}}
+func blob() -> (some P) -> P { return { $0 } } // expected-error{{'some' types are only implemented}}
+func blorb<T: some P>(_: T) { } // expected-error{{'some' types are only implemented}}
+func blub<T>() -> T where T == some P { return 1 } // expected-error{{'some' types are only implemented}} expected-error{{cannot convert}}
 
-protocol OP: some P {} // expected-error{{'opaque' types are only implemented}}
+protocol OP: some P {} // expected-error{{'some' types are only implemented}}
 
 func foo() -> some P {
   let x = (some P).self // expected-error*{{}}
@@ -89,9 +98,9 @@ func foo() -> some P {
 
 // Invalid constraints
 
-let zug: some Int = 1 // FIXME expected-error{{'opaque' types are only implemented}}
-let zwang: some () = () // FIXME expected-error{{'opaque' types are only implemented}}
-let zwoggle: some (() -> ()) = {} // FIXME expected-error{{'opaque' types are only implemented}}
+let zug: some Int = 1 // FIXME expected-error{{must specify only}}
+let zwang: some () = () // FIXME expected-error{{must specify only}}
+let zwoggle: some (() -> ()) = {} // FIXME expected-error{{must specify only}}
 
 // Type-checking of expressions of opaque type
 
@@ -251,6 +260,12 @@ struct DoesNotConform {}
 func doesNotConform() -> some P {
   return DoesNotConform()
 }
+
+var doesNotConformProp: some P = DoesNotConform()
+
+var DoesNotConformComputedProp: some P {
+  return DoesNotConform()
+}
 */