Merge pull request swiftlang#18988 from rjmccall/param-get-param-type

[NFC] Add a convenience getter for a Param's parameter type

Author: rjmccall

include/swift/AST/Types.h

@@ -1799,6 +1799,14 @@ class YieldTypeFlags {
     return YieldTypeFlags(isOwned ? value | Owned : value - Owned);
   }
 
+  /// Return these flags interpreted as parameter flags.
+  ParameterTypeFlags asParamFlags() const {
+    return ParameterTypeFlags(/*variadic*/ false,
+                              /*autoclosure*/ false,
+                              /*escaping*/ false,
+                              getValueOwnership());
+  }
+
   bool operator ==(const YieldTypeFlags &other) const {
     return value.toRaw() == other.value.toRaw();
   }
@@ -2653,6 +2661,10 @@ class AnyFunctionType : public TypeBase {
 
     Type getPlainType() const { return Ty; }
 
+    /// The type of the parameter.  Adjusts for varargs, but not inout.
+    Type getParameterType(bool forCanonical = false,
+                          ASTContext *ctx = nullptr) const;
+
     bool hasLabel() const { return !Label.empty(); }
     Identifier getLabel() const { return Label; }
 
@@ -2696,6 +2708,9 @@ class AnyFunctionType : public TypeBase {
 
     CanType getType() const { return CanType(Param::getType()); }
     CanType getPlainType() const { return CanType(Param::getPlainType()); }
+    CanType getParameterType() const {
+      return CanType(Param::getParameterType(/*forCanonical*/ true));
+    }
   };
 
   using CanParamArrayRef =
@@ -2719,6 +2734,13 @@ class AnyFunctionType : public TypeBase {
 
     CanYield getCanonical() const;
 
+    /// There are a number of places where it's convenient to re-use
+    /// the call machinery, processing yields as if they were
+    /// parameters of a call.  Return this reinterpreted as a parameter.
+    Param asParam() const {
+      return Param(getType(), Identifier(), getFlags().asParamFlags());
+    }
+
     Yield subst(SubstitutionMap subs, SubstOptions options = None) const {
       return Yield(getType().subst(subs, options), getFlags());
     }
@@ -2738,6 +2760,7 @@ class AnyFunctionType : public TypeBase {
       : Yield(type, flags) {}
 
     CanType getType() const { return CanType(Yield::getType()); }
+    CanParam asParam() const { return CanParam::getFromParam(Yield::asParam());}
 
     CanYield subst(SubstitutionMap subs, SubstOptions options = None) const {
       return CanYield(getType().subst(subs, options)->getCanonicalType(),

lib/AST/ASTContext.cpp

@@ -3563,19 +3563,27 @@ void AnyFunctionType::decomposeInput(
   }
 }
 
+Type AnyFunctionType::Param::getParameterType(bool forCanonical,
+                                              ASTContext *ctx) const {
+  Type type = getPlainType();
+  if (isVariadic()) {
+    if (!ctx) ctx = &type->getASTContext();
+    auto arrayDecl = ctx->getArrayDecl();
+    if (!arrayDecl)
+      type = ErrorType::get(*ctx);
+    else if (forCanonical)
+      type = BoundGenericType::get(arrayDecl, Type(), {type});
+    else
+      type = ArraySliceType::get(type);
+  }
+  return type;
+}
+
 Type AnyFunctionType::composeInput(ASTContext &ctx, ArrayRef<Param> params,
                                    bool canonicalVararg) {
   SmallVector<TupleTypeElt, 4> elements;
   for (const auto &param : params) {
-    Type eltType = param.getPlainType();
-    if (param.isVariadic()) {
-      if (!ctx.getArrayDecl())
-        eltType = ErrorType::get(ctx);
-      else if (canonicalVararg)
-        eltType = BoundGenericType::get(ctx.getArrayDecl(), Type(), {eltType});
-      else
-        eltType = ArraySliceType::get(eltType);
-    }
+    Type eltType = param.getParameterType(canonicalVararg, &ctx);
     elements.emplace_back(eltType, param.getLabel(),
                           param.getParameterFlags());
   }

lib/Sema/TypeCheckPattern.cpp

@@ -1656,12 +1656,7 @@ bool TypeChecker::coerceParameterListToType(ParameterList *P, ClosureExpr *CE,
   };
 
   auto getType = [](const AnyFunctionType::Param &param) -> Type {
-    auto type = param.getPlainType();
-
-    if (param.isVariadic())
-      return ArraySliceType::get(type);
-
-    return type;
+    return param.getParameterType();
   };
 
   // If the closure is called with a single argument of tuple type