[Sema] Avoid relying on ParenType in space engine

Refactor `decomposeDisjuncts` to avoid relying on
the modeling of single unlabeled associated values
as ParenTypes.

Author: hamishknight

include/swift/AST/Decl.h

@@ -8547,6 +8547,10 @@ class EnumElementDecl : public DeclContext, public ValueDecl {
   /// associated values, or null if there are no associated values.
   Type getPayloadInterfaceType() const;
 
+  /// Retrieve the parameters of the implicit case constructor for the enum
+  /// element.
+  ArrayRef<AnyFunctionType::Param> getCaseConstructorParams() const;
+
   void setParameterList(ParameterList *params);
   ParameterList *getParameterList() const { return Params; }
 

lib/AST/Decl.cpp

@@ -10733,22 +10733,32 @@ SourceRange EnumElementDecl::getSourceRange() const {
   return {getStartLoc(), getNameLoc()};
 }
 
-Type EnumElementDecl::getPayloadInterfaceType() const {
+ArrayRef<AnyFunctionType::Param>
+EnumElementDecl::getCaseConstructorParams() const {
   if (!hasAssociatedValues())
-    return nullptr;
+    return {};
 
   auto interfaceType = getInterfaceType();
-  if (interfaceType->is<ErrorType>()) {
-    return interfaceType;
-  }
+  if (interfaceType->is<ErrorType>())
+    return {};
 
   auto funcTy = interfaceType->castTo<AnyFunctionType>();
-  funcTy = funcTy->getResult()->castTo<FunctionType>();
+  return funcTy->getResult()->castTo<FunctionType>()->getParams();
+}
+
+Type EnumElementDecl::getPayloadInterfaceType() const {
+  if (!hasAssociatedValues())
+    return Type();
+
+  auto interfaceType = getInterfaceType();
+  if (interfaceType->is<ErrorType>())
+    return interfaceType;
 
   // The payload type of an enum is an imploded tuple of the internal arguments
   // of the case constructor. As such, compose a tuple type with the parameter
   // flags dropped.
-  return AnyFunctionType::composeTuple(getASTContext(), funcTy->getParams(),
+  return AnyFunctionType::composeTuple(getASTContext(),
+                                       getCaseConstructorParams(),
                                        ParameterFlagHandling::IgnoreNonEmpty);
 }
 

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -785,28 +785,11 @@ namespace {
         }
       }
 
-      /// Use this if you're doing getAs<TupleType> on a Type (and it succeeds)
-      /// to compute the spaces for it. Handy for disambiguating fields
-      /// that are tuples from associated values.
-      ///
-      ///    .e((a: X, b: X)) -> ((a: X, b: X))
-      /// vs .f(a: X, b: X)   -> (a: X, b: X)
-      static void getTupleTypeSpaces(Type &outerType,
-                                     TupleType *tty,
+      /// Splat a tuple type into a set of element type spaces.
+      static void getTupleTypeSpaces(TupleType *tty,
                                      SmallVectorImpl<Space> &spaces) {
-        ArrayRef<TupleTypeElt> ttyElts = tty->getElements();
-        if (isa<ParenType>(outerType.getPointer())) {
-          // We had an actual tuple!
-          SmallVector<Space, 4> innerSpaces;
-          for (auto &elt: ttyElts)
-            innerSpaces.push_back(Space::forType(elt.getType(), elt.getName()));
-          spaces.push_back(
-            Space::forConstructor(tty, Identifier(), innerSpaces));
-        } else {
-          // We're looking at the fields of a constructor here.
-          for (auto &elt: ttyElts)
-            spaces.push_back(Space::forType(elt.getType(), elt.getName()));
-        }
+        for (auto &elt : tty->getElements())
+          spaces.push_back(Space::forType(elt.getType(), elt.getName()));
       };
 
       // Decompose a type into its component spaces, ignoring any enum
@@ -843,19 +826,29 @@ namespace {
                   return Space();
                 }
 
-                // .e(a: X, b: X)   -> (a: X, b: X)
-                // .f((a: X, b: X)) -> ((a: X, b: X)
                 SmallVector<Space, 4> constElemSpaces;
-                if (auto payloadTy = eed->getPayloadInterfaceType()) {
-                  auto eedTy = tp->getCanonicalType()->getTypeOfMember(
-                      eed, payloadTy);
-                  if (auto *TTy = eedTy->getAs<TupleType>()) {
-                    Space::getTupleTypeSpaces(eedTy, TTy, constElemSpaces);
-                  } else if (auto *TTy =
-                                 dyn_cast<ParenType>(eedTy.getPointer())) {
-                    constElemSpaces.push_back(
-                        Space::forType(TTy->getUnderlyingType(), Identifier()));
+                auto params = eed->getCaseConstructorParams();
+                auto isParenLike = params.size() == 1 && !params[0].hasLabel();
+
+                // .e(a: X, b: X)   -> (a: X, b: X)
+                // .f((a: X, b: X)) -> ((a: X, b: X))
+                for (auto &param : params) {
+                  auto payloadTy = tp->getCanonicalType()->getTypeOfMember(
+                      eed, param.getParameterType());
+                  // A single tuple payload gets splatted into a constructor
+                  // space of its constituent elements. This allows the
+                  // deprecated ability to match using a .x(a, b, c) pattern
+                  // instead of a .x((a, b, c)) pattern.
+                  auto *tupleTy = payloadTy->getAs<TupleType>();
+                  if (tupleTy && isParenLike) {
+                    SmallVector<Space, 4> innerSpaces;
+                    Space::getTupleTypeSpaces(tupleTy, innerSpaces);
+                    constElemSpaces.push_back(Space::forConstructor(
+                        tupleTy, Identifier(), innerSpaces));
+                    continue;
                   }
+                  constElemSpaces.push_back(
+                      Space::forType(payloadTy, param.getLabel()));
                 }
                 return Space::forConstructor(tp, eed->getName(),
                                              constElemSpaces);
@@ -870,11 +863,8 @@ namespace {
         } else if (auto *TTy = tp->castTo<TupleType>()) {
           // Decompose each of the elements into its component type space.
           SmallVector<Space, 4> constElemSpaces;
-          llvm::transform(TTy->getElements(),
-                          std::back_inserter(constElemSpaces),
-                          [&](TupleTypeElt elt) {
-            return Space::forType(elt.getType(), elt.getName());
-          });
+          Space::getTupleTypeSpaces(TTy, constElemSpaces);
+
           // Create an empty constructor head for the tuple space.
           arr.push_back(Space::forConstructor(tp, Identifier(),
                                               constElemSpaces));
@@ -1519,12 +1509,12 @@ namespace {
           // matched by a single var pattern.  Project it like the tuple it
           // really is.
           //
-          // FIXME: SE-0155 makes this case unreachable.
+          // FIXME: SE-0155 will eventually this case unreachable. For now it's
+          // permitted as a deprecated behavior.
           if (SP->getKind() == PatternKind::Named
               || SP->getKind() == PatternKind::Any) {
-            Type outerType = SP->getType();
-            if (auto *TTy = outerType->getAs<TupleType>())
-              Space::getTupleTypeSpaces(outerType, TTy, conArgSpace);
+            if (auto *TTy = SP->getType()->getAs<TupleType>())
+              Space::getTupleTypeSpaces(TTy, conArgSpace);
             else
               conArgSpace.push_back(projectPattern(SP));
           } else if (SP->getKind() == PatternKind::Tuple) {