[Sema] Create Opaque Decls from Composition Types

Author: angela-laar

lib/AST/NameLookup.cpp

@@ -2774,7 +2774,10 @@ static bool declsAreProtocols(ArrayRef<TypeDecl *> decls) {
 
 bool TypeRepr::isProtocol(DeclContext *dc){
   auto &ctx = dc->getASTContext();
-  return findIf([&ctx, dc](TypeRepr *ty) { return declsAreProtocols(directReferencesForTypeRepr(ctx.evaluator, ctx, ty, dc)); });
+  return findIf([&ctx, dc](TypeRepr *ty) {
+    return declsAreProtocols(directReferencesForTypeRepr(ctx.evaluator, ctx, ty, dc));
+
+  });
 }
 
 
@@ -2819,7 +2822,6 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
       }
 
       if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
-
         if (auto existential = dyn_cast<ExistentialTypeRepr>(repr)) {
           auto generic = dyn_cast<GenericIdentTypeRepr>(existential->getConstraint());
           if(generic)
@@ -2833,11 +2835,9 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
             Reprs.push_back(compositionRepr);
           return Action::SkipChildren();
         } else if (auto generic = dyn_cast<GenericIdentTypeRepr>(repr)) {
-          if (!Reprs.empty()){
-            if(isa<ExistentialTypeRepr>(Reprs.front())){
+          if (!Reprs.empty() && isa<ExistentialTypeRepr>(Reprs.front())){
               Reprs.clear();
               Action::Continue();
-            }
           }
           Reprs.push_back(generic);
         } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)) {

lib/Sema/TypeCheckType.cpp

@@ -2260,21 +2260,23 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
       return ty;
     };
 
-    if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(DC)) {
-      if (auto ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(repr))
-        return diagnoseDisallowedExistential(getIdentityOpaqueTypeArchetypeType(opaqueDecl, *ordinal));
-    }
-    
-    // Check whether any of the generic parameters in the context represents
-    // this opaque type. If so, return that generic parameter.
-    if (options.isConstraintImplicitExistential()) {
-      if (auto declDC = DC->getAsDecl()) {
-        if (auto genericContext = declDC->getAsGenericContext()) {
-          if (auto genericParams = genericContext->getGenericParams()) {
-            for (auto genericParam : *genericParams) {
-              if (genericParam->getOpaqueTypeRepr() == repr)
-                return diagnoseDisallowedExistential(
-                                                     genericParam->getDeclaredInterfaceType());
+    if(getASTContext().LangOpts.hasFeature(Feature::ImplicitSome)){
+      if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(DC)) {
+        if (auto ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(repr))
+          return diagnoseDisallowedExistential(getIdentityOpaqueTypeArchetypeType(opaqueDecl, *ordinal));
+      }
+
+      // Check whether any of the generic parameters in the context represents
+      // this opaque type. If so, return that generic parameter.
+      if (options.isConstraintImplicitExistential()) {
+        if (auto declDC = DC->getAsDecl()) {
+          if (auto genericContext = declDC->getAsGenericContext()) {
+            if (auto genericParams = genericContext->getGenericParams()) {
+              for (auto genericParam : *genericParams) {
+                if (genericParam->getOpaqueTypeRepr() == repr)
+                  return diagnoseDisallowedExistential(
+                                                       genericParam->getDeclaredInterfaceType());
+              }
             }
           }
         }
@@ -2321,8 +2323,32 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
   case TypeReprKind::Tuple:
     return resolveTupleType(cast<TupleTypeRepr>(repr), options);
 
-  case TypeReprKind::Composition:
-    return resolveCompositionType(cast<CompositionTypeRepr>(repr), options);
+    case TypeReprKind::Composition: {
+      auto *DC = getDeclContext();
+      auto diagnoseDisallowedExistential = [&](Type ty) {
+        if (!(options & TypeResolutionFlags::SilenceErrors) &&
+            options.contains(TypeResolutionFlags::DisallowOpaqueTypes)) {
+          // We're specifically looking at an existential type `any P<some Q>`,
+          // so emit a tailored diagnostic. We don't emit an ErrorType here
+          // for better recovery.
+          diagnose(repr->getLoc(),
+                   diag::unsupported_opaque_type_in_existential);
+          // FIXME: We shouldn't have to invalid the type repr here, but not
+          // doing so causes a double-diagnostic.
+          repr->setInvalid();
+        }
+        return ty;
+      };
+
+      if(getASTContext().LangOpts.hasFeature(Feature::ImplicitSome)){
+        if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(DC)) {
+          if (auto ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(repr))
+            return diagnoseDisallowedExistential(getIdentityOpaqueTypeArchetypeType(opaqueDecl, *ordinal));
+        }
+      }
+
+      return resolveCompositionType(cast<CompositionTypeRepr>(repr), options);
+    }
 
   case TypeReprKind::Metatype:
     return resolveMetatypeType(cast<MetatypeTypeRepr>(repr), options);

test/type/implicit_some/opaque_return.swift

@@ -1,5 +1,15 @@
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -warn-redundant-requirements  -enable-experimental-implicit-some
 
+protocol Eatery {
+  func lunch()
+  func dinner()
+  func dessert()
+}
+
+protocol Shop {
+  func coffee ()
+}
+
 // Access Return Type Constraint
 protocol Cafe {
   func breakfast()
@@ -23,7 +33,7 @@ cafe.treats()
 typealias Snack = Shop & Cafe
 typealias Meal = Eatery
 
-struct CoffeeBar: Snack {
+struct CoffeeShop(): Snack {
   func coffee(){ }
   func breakfast() { }
   func treats(){ }
@@ -41,33 +51,34 @@ class TopTier: Eatery {
   func dessert() { }
 }
 
-func list(_: Snack) {}
-
-func find( _: Snack) -> Snack { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+func find() -> Eatery { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
-// tuple types
-func list(_: (Meal, Meal)) {}
+func find() -> AnyObject {
+  return CoffeeShop() // expected-error {{return expression of type 'CoffeeBar' expected to be an instance of a class or class-constrained type}}
+}
 
-func highestRated() -> (Eatery, Eatery) {
-   return (Best(), TopTier())
+func find() -> Any {
+  return CoffeeShop()
 }
 
-func highestRated() -> (some Snack, some Snack) { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+// tuple types
+func highestRated() -> (Eatery, Eatery) { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
-// opaque compostion types
-func find() -> Shop & Cafe {
-  return CoffeeBar()
+// type alias
+func inspect( _ snack: some Snack) -> some Snack {
+  return CoffeeShop();
 }
+// tuple type alias
+func highestRated() -> (some Snack, some Snack) { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
-func find() -> AnyObject {
-  return CoffeeBar() //  expected-error {{Return expression of type 'CoffeeBar' expected to be an instance of a class or class-constrained type}} 
-}
+// TO-DO: Fix type alias for plain protocols; resolves as an existential type
+func list(_: (Meal, Meal)) -> (Meal, Meal){ }
+func find() -> Snack { }
 
-func find() -> Any {
-  return CoffeeBar()
-}
+// opaque compostion types
+func search() -> Shop & Cafe { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
-// protocol with associated type constraint
+// associated type constraint
 protocol Basket {
   associatedtype Fruit
   associatedtype MiniBasket: Basket where MiniBasket.Fruit == Fruit