Allow opaque parameters in structural positions

Author: DougGregor

include/swift/AST/TypeRepr.h

@@ -47,6 +47,9 @@ enum class TypeReprKind : uint8_t {
 enum : unsigned { NumTypeReprKindBits =
   countBitsUsed(static_cast<unsigned>(TypeReprKind::Last_TypeRepr)) };
 
+class OpaqueReturnTypeRepr;
+using CollectedOpaqueReprs = SmallVector<OpaqueReturnTypeRepr *, 2>;
+
 /// Representation of a type as written in source.
 class alignas(1 << TypeReprAlignInBits) TypeRepr
     : public ASTAllocated<TypeRepr> {
@@ -165,6 +168,10 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   /// opaque return type reprs.
   bool hasOpaque();
 
+  /// Walk the type representation recursively, collecting any
+  /// `OpaqueReturnTypeRepr`s.
+  CollectedOpaqueReprs collectOpaqueReturnTypeReprs();
+
   //*** Allocation Routines ************************************************/
 
   void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const;

lib/AST/NameLookup.cpp

@@ -2594,31 +2594,31 @@ createOpaqueParameterGenericParams(
   SmallVector<GenericTypeParamDecl *, 2> implicitGenericParams;
   auto dc = value->getInnermostDeclContext();
   for (auto param : *params) {
-    // Don't permit variadic or inout parameters.
-    if (param->isVariadic() || param->isInOut())
+    // Don't permit variadic parameters.
+    if (param->isVariadic())
       continue;
 
     auto typeRepr = param->getTypeRepr();
     if (!typeRepr)
       continue;
 
-    // FIXME: Do we want to allow any structure here? Optionals?
-    auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(typeRepr);
-    if (!opaqueRepr)
-      continue;
-
-    // Allocate a new generic parameter to represent this opaque type.
-    auto gp = GenericTypeParamDecl::create(
-        dc, Identifier(), SourceLoc(), /*isTypeSequence=*/false,
-        GenericTypeParamDecl::InvalidDepth, index++, /*isOpaqueType=*/true,
-        opaqueRepr);
-    gp->setImplicit();
-
-    // Use the underlying constraint as the constraint on the generic parameter.
-    InheritedEntry inherited[1] = { { TypeLoc(opaqueRepr->getConstraint()) } };
-    gp->setInherited(ctx.AllocateCopy(inherited));
-
-    implicitGenericParams.push_back(gp);
+    auto opaqueTypeReprs = typeRepr->collectOpaqueReturnTypeReprs();
+    for (auto opaqueRepr : opaqueTypeReprs) {
+      // Allocate a new generic parameter to represent this opaque type.
+      auto gp = GenericTypeParamDecl::create(
+          dc, Identifier(), SourceLoc(), /*isTypeSequence=*/false,
+          GenericTypeParamDecl::InvalidDepth, index++, /*isOpaqueType=*/true,
+          opaqueRepr);
+      gp->setImplicit();
+
+      // Use the underlying constraint as the constraint on the generic parameter.
+      InheritedEntry inherited[1] = {
+        { TypeLoc(opaqueRepr->getConstraint()) }
+      };
+      gp->setInherited(ctx.AllocateCopy(inherited));
+
+      implicitGenericParams.push_back(gp);
+    }
   }
 
   return implicitGenericParams;

lib/AST/TypeRepr.cpp

@@ -102,6 +102,25 @@ bool TypeRepr::hasOpaque() {
     findIf([](TypeRepr *ty) { return isa<OpaqueReturnTypeRepr>(ty); });
 }
 
+CollectedOpaqueReprs TypeRepr::collectOpaqueReturnTypeReprs() {
+  class Walker : public ASTWalker {
+    CollectedOpaqueReprs &Reprs;
+
+  public:
+    explicit Walker(CollectedOpaqueReprs &reprs) : Reprs(reprs) {}
+
+    bool walkToTypeReprPre(TypeRepr *repr) override {
+      if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr))
+        Reprs.push_back(opaqueRepr);
+      return true;
+    }
+  };
+
+  CollectedOpaqueReprs reprs;
+  walk(Walker(reprs));
+  return reprs;
+}
+
 SourceLoc TypeRepr::findUncheckedAttrLoc() const {
   auto typeRepr = this;
   while (auto attrTypeRepr = dyn_cast<AttributedTypeRepr>(typeRepr)) {

lib/Sema/TypeCheckGeneric.cpp

@@ -78,28 +78,6 @@ TypeChecker::gatherGenericParamBindingsText(
   return result.str().str();
 }
 
-// An alias to avoid repeating the `SmallVector`'s size parameter.
-using CollectedOpaqueReprs = SmallVector<OpaqueReturnTypeRepr *, 2>;
-
-/// Walk `repr` recursively, collecting any `OpaqueReturnTypeRepr`s.
-static CollectedOpaqueReprs collectOpaqueReturnTypeReprs(TypeRepr *repr) {
-  class Walker : public ASTWalker {
-    CollectedOpaqueReprs &Reprs;
-
-  public:
-    explicit Walker(CollectedOpaqueReprs &reprs) : Reprs(reprs) {}
-
-    bool walkToTypeReprPre(TypeRepr *repr) override {
-      if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr))
-        Reprs.push_back(opaqueRepr);
-      return true;
-    }
-  };
-
-  CollectedOpaqueReprs reprs;
-  repr->walk(Walker(reprs));
-  return reprs;
-}
 
 //
 // Generic functions
@@ -206,7 +184,7 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
       return nullptr;
     }
   } else {
-    opaqueReprs = collectOpaqueReturnTypeReprs(repr);
+    opaqueReprs = repr->collectOpaqueReturnTypeReprs();
     SmallVector<GenericTypeParamType *, 2> genericParamTypes;
     SmallVector<Requirement, 2> requirements;
     for (unsigned i = 0; i < opaqueReprs.size(); ++i) {

test/type/opaque_parameters.swift

@@ -51,6 +51,22 @@ func testTakeMultiple(
   takeMultiple(d, arrayOfInts, arrayOfInts) // expected-error{{global function 'takeMultiple' requires that '[Int]' conform to 'P'}}
 }
 
+// inout
+
+func anyInOut(_: inout some P) { }
+
+func testAnyInOut() {
+  var i = 17
+  anyInOut(&i)
+}
+
+// In structural positions.
+func anyDictionary(_ dict: [some Hashable: some Any]) { }
+
+func testAnyDictionary(numberNames: [Int: String]) {
+  anyDictionary(numberNames)
+}
+
 // Combine with parameterized protocol types
 protocol PrimaryCollection: Collection {
   @_primaryAssociatedType associatedtype Element