Merge pull request swiftlang#63704 from slavapestov/pack-element-type-repr-fixes

slavapestov · web-flow · commit 7d1f7f62e62f · 2023-02-16T07:51:29.000-05:00
A couple of PackElementTypeRepr fixes
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
@@ -724,20 +724,12 @@ class VarargTypeRepr final : public TypeRepr {
   friend class TypeRepr;
 };
 
-/// A pack expansion 'T...' with a pattern 'T'.
+/// A pack expansion 'repeat T' with a pattern 'T'.
 ///
 /// Can appear in the following positions:
 /// - The type of a parameter declaration in a function declaration
 /// - The type of a parameter in a function type
 /// - The element of a tuple
-///
-/// In the first two cases, it also spells an old-style variadic parameter
-/// desugaring to an array type. The two meanings are distinguished by the
-/// presence of at least one pack type parameter in the pack expansion
-/// pattern.
-///
-/// In the third case, tuples cannot contain an old-style variadic element,
-/// so the pack expansion must be a real variadic pack expansion.
 class PackExpansionTypeRepr final : public TypeRepr {
   SourceLoc RepeatLoc;
   TypeRepr *Pattern;
@@ -821,22 +813,22 @@ class PackTypeRepr final
 ///   func f(value: (each T)...) where each T: P {}
 /// }
 /// \endcode
-class PackReferenceTypeRepr: public TypeRepr {
+class PackElementTypeRepr: public TypeRepr {
   TypeRepr *PackType;
   SourceLoc EachLoc;
 
 public:
-  PackReferenceTypeRepr(SourceLoc eachLoc, TypeRepr *packType)
-    : TypeRepr(TypeReprKind::PackReference), PackType(packType),
+  PackElementTypeRepr(SourceLoc eachLoc, TypeRepr *packType)
+    : TypeRepr(TypeReprKind::PackElement), PackType(packType),
       EachLoc(eachLoc) {}
 
   TypeRepr *getPackType() const { return PackType; }
   SourceLoc getEachLoc() const { return EachLoc; }
 
   static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::PackReference;
+    return T->getKind() == TypeReprKind::PackElement;
   }
-  static bool classof(const PackReferenceTypeRepr *T) { return true; }
+  static bool classof(const PackElementTypeRepr *T) { return true; }
 
 private:
   SourceLoc getStartLocImpl() const { return EachLoc; }
@@ -1439,7 +1431,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::OpaqueReturn:
   case TypeReprKind::NamedOpaqueReturn:
   case TypeReprKind::Existential:
-  case TypeReprKind::PackReference:
+  case TypeReprKind::PackElement:
     return false;
   case TypeReprKind::SimpleIdent:
   case TypeReprKind::GenericIdent:
diff --git a/include/swift/AST/TypeReprNodes.def b/include/swift/AST/TypeReprNodes.def
@@ -66,7 +66,7 @@ TYPEREPR(OpaqueReturn, TypeRepr)
 TYPEREPR(NamedOpaqueReturn, TypeRepr)
 TYPEREPR(Existential, TypeRepr)
 TYPEREPR(Pack, TypeRepr)
-TYPEREPR(PackReference, TypeRepr)
+TYPEREPR(PackElement, TypeRepr)
 TYPEREPR(Placeholder, TypeRepr)
 ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   SPECIFIER_TYPEREPR(InOut, SpecifierTypeRepr)
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -72,7 +72,6 @@ class InOutType;
 class OpaqueTypeDecl;
 class OpenedArchetypeType;
 class PackType;
-class PackReferenceTypeRepr;
 class PlaceholderTypeRepr;
 enum class ReferenceCounting : uint8_t;
 enum class ResilienceExpansion : unsigned;
diff --git a/include/swift/Sema/ConstraintSystem.h b/include/swift/Sema/ConstraintSystem.h
@@ -6216,7 +6216,7 @@ class OpenPackElementType {
     this->locator = cs.getConstraintLocator(locator);
   }
 
-  Type operator()(Type packType, PackReferenceTypeRepr *packRepr) const {
+  Type operator()(Type packType, PackElementTypeRepr *packRepr) const {
     // Only assert we have an element environment when invoking the function
     // object. In cases where pack elements are referenced outside of a
     // pack expansion, type resolution will error before opening the pack
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3211,8 +3211,8 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
-  void visitPackReferenceTypeRepr(PackReferenceTypeRepr *T) {
-    printCommon("pack_reference");
+  void visitPackElementTypeRepr(PackElementTypeRepr *T) {
+    printCommon("pack_element");
     printRec(T->getPackType());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
diff --git a/lib/AST/ASTWalker.cpp b/lib/AST/ASTWalker.cpp
@@ -2034,7 +2034,7 @@ bool Traversal::visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
   return doIt(T->getPatternType());
 }
 
-bool Traversal::visitPackReferenceTypeRepr(PackReferenceTypeRepr *T) {
+bool Traversal::visitPackElementTypeRepr(PackElementTypeRepr *T) {
   return doIt(T->getPackType());
 }
 
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1284,7 +1284,7 @@ void PackExpansionExpr::getExpandedPacks(SmallVectorImpl<ASTNode> &packs) {
         return Action::SkipChildren();
       }
 
-      if (isa<PackReferenceTypeRepr>(T)) {
+      if (isa<PackElementTypeRepr>(T)) {
         packs.push_back(T);
       }
 
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -2618,8 +2618,8 @@ directReferencesForTypeRepr(Evaluator &evaluator,
                                        allowUsableFromInline);
   }
 
-  case TypeReprKind::PackReference: {
-    auto packReferenceRepr = cast<PackReferenceTypeRepr>(typeRepr);
+  case TypeReprKind::PackElement: {
+    auto packReferenceRepr = cast<PackElementTypeRepr>(typeRepr);
     return directReferencesForTypeRepr(evaluator, ctx,
                                        packReferenceRepr->getPackType(), dc,
                                        allowUsableFromInline);
diff --git a/lib/AST/TypeRepr.cpp b/lib/AST/TypeRepr.cpp
@@ -482,8 +482,8 @@ void PackExpansionTypeRepr::printImpl(ASTPrinter &Printer,
   printTypeRepr(Pattern, Printer, Opts);
 }
 
-void PackReferenceTypeRepr::printImpl(ASTPrinter &Printer,
-                                      const PrintOptions &Opts) const {
+void PackElementTypeRepr::printImpl(ASTPrinter &Printer,
+                                    const PrintOptions &Opts) const {
   Printer.printKeyword("each", Opts, /*Suffix=*/" ");
   printTypeRepr(PackType, Printer, Opts);
 }
diff --git a/lib/Parse/ParseType.cpp b/lib/Parse/ParseType.cpp
@@ -903,12 +903,12 @@ Parser::parseTypeSimpleOrComposition(Diag<> MessageID, ParseTypeReason reason) {
     // Treat 'each' as a keyword.
     TokReceiver->registerTokenKindChange(Tok.getLoc(), tok::contextual_keyword);
     SourceLoc eachLoc = consumeToken();
-    ParserResult<TypeRepr> packRef = parseTypeSimple(MessageID, reason);
-    if (packRef.isNull())
-      return packRef;
+    ParserResult<TypeRepr> packElt = parseTypeSimple(MessageID, reason);
+    if (packElt.isNull())
+      return packElt;
 
-    auto *typeRepr = new (Context) PackReferenceTypeRepr(eachLoc, packRef.get());
-    return makeParserResult(ParserStatus(packRef), typeRepr);
+    auto *typeRepr = new (Context) PackElementTypeRepr(eachLoc, packElt.get());
+    return makeParserResult(ParserStatus(packElt), typeRepr);
   }
 
   auto applyOpaque = [&](TypeRepr *type) -> TypeRepr * {
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -3062,7 +3062,7 @@ namespace {
         Type packType;
         if (auto *elementExpr = getAsExpr<PackElementExpr>(pack)) {
           packType = CS.getType(elementExpr->getPackRefExpr());
-        } else if (auto *elementType = getAsTypeRepr<PackReferenceTypeRepr>(pack)) {
+        } else if (auto *elementType = getAsTypeRepr<PackElementTypeRepr>(pack)) {
           packType = CS.getType(elementType->getPackType());
         } else {
           llvm_unreachable("unsupported pack reference ASTNode");
diff --git a/lib/Sema/PreCheckExpr.cpp b/lib/Sema/PreCheckExpr.cpp
@@ -1487,6 +1487,7 @@ bool PreCheckExpression::exprLooksLikeAType(Expr *expr) {
       isa<ParenExpr>(expr) ||
       isa<ArrowExpr>(expr) ||
       isa<PackExpansionExpr>(expr) ||
+      isa<PackElementExpr>(expr) ||
       isa<TupleExpr>(expr) ||
       (isa<ArrayExpr>(expr) &&
        cast<ArrayExpr>(expr)->getElements().size() == 1) ||
@@ -1984,6 +1985,15 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
     }
   }
 
+  // Fold a PackElementExpr into a TypeExpr when the element is a TypeExpr
+  if (auto *element = dyn_cast<PackElementExpr>(E)) {
+    if (auto *refExpr = dyn_cast<TypeExpr>(element->getPackRefExpr())) {
+      auto *repr = new (Ctx) PackElementTypeRepr(element->getStartLoc(),
+                                                 refExpr->getTypeRepr());
+      return new (Ctx) TypeExpr(repr);
+    }
+  }
+
   return nullptr;
 }
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -2066,8 +2066,8 @@ namespace {
                                   bool direct = false);
     NeverNullType resolvePackExpansionType(PackExpansionTypeRepr *repr,
                                            TypeResolutionOptions options);
-    NeverNullType resolvePackReference(PackReferenceTypeRepr *repr,
-                                       TypeResolutionOptions options);
+    NeverNullType resolvePackElement(PackElementTypeRepr *repr,
+                                     TypeResolutionOptions options);
     NeverNullType resolveTupleType(TupleTypeRepr *repr,
                                    TypeResolutionOptions options);
     NeverNullType resolveCompositionType(CompositionTypeRepr *repr,
@@ -2337,8 +2337,8 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
   case TypeReprKind::PackExpansion:
     return resolvePackExpansionType(cast<PackExpansionTypeRepr>(repr), options);
 
-  case TypeReprKind::PackReference:
-    return resolvePackReference(cast<PackReferenceTypeRepr>(repr), options);
+  case TypeReprKind::PackElement:
+    return resolvePackElement(cast<PackElementTypeRepr>(repr), options);
 
   case TypeReprKind::Tuple:
     return resolveTupleType(cast<TupleTypeRepr>(repr), options);
@@ -4507,8 +4507,8 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
   return PackExpansionType::get(patternType, rootParameterPacks[0]);
 }
 
-NeverNullType TypeResolver::resolvePackReference(PackReferenceTypeRepr *repr,
-                                                 TypeResolutionOptions options) {
+NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,
+                                               TypeResolutionOptions options) {
   auto &ctx = getASTContext();
   options |= TypeResolutionFlags::FromPackReference;
   auto packReference = resolveType(repr->getPackType(), options);
@@ -5038,7 +5038,7 @@ class ExistentialTypeVisitor
     case TypeReprKind::Vararg:
     case TypeReprKind::Pack:
     case TypeReprKind::PackExpansion:
-    case TypeReprKind::PackReference:
+    case TypeReprKind::PackElement:
       return false;
     }
   }
diff --git a/lib/Sema/TypeCheckType.h b/lib/Sema/TypeCheckType.h
@@ -27,6 +27,7 @@ namespace swift {
 class ASTContext;
 class TypeRepr;
 class IdentTypeRepr;
+class PackElementTypeRepr;
 class GenericEnvironment;
 class GenericSignature;
 class SILTypeResolutionContext;
@@ -491,10 +492,10 @@ using OpenUnboundGenericTypeFn = llvm::function_ref<Type(UnboundGenericType *)>;
 using HandlePlaceholderTypeReprFn =
     llvm::function_ref<Type(ASTContext &, PlaceholderTypeRepr *)>;
 
-/// A function reference used to replace pack references with opened
-/// element archetypes when resolving a \c PackReferenceTypeRepr.
+/// A function reference used to replace pack elements with opened
+/// element archetypes when resolving a \c PackElementTypeRepr.
 using OpenPackElementFn =
-    llvm::function_ref<Type(Type, PackReferenceTypeRepr *)>;
+    llvm::function_ref<Type(Type, PackElementTypeRepr *)>;
 
 /// Handles the resolution of types within a given declaration context,
 /// which might involve resolving generic parameters to a particular

Original file line number	Diff line number	Diff line change
`@@ -6216,7 +6216,7 @@ class OpenPackElementType {`
`6216`	`6216`	`this->locator = cs.getConstraintLocator(locator);`
`6217`	`6217`	`}`
`6218`	`6218`
`6219`		`- Type operator()(Type packType, PackReferenceTypeRepr *packRepr) const {`
	`6219`	`+ Type operator()(Type packType, PackElementTypeRepr *packRepr) const {`
`6220`	`6220`	`// Only assert we have an element environment when invoking the function`
`6221`	`6221`	`// object. In cases where pack elements are referenced outside of a`
`6222`	`6222`	`// pack expansion, type resolution will error before opening the pack`
Original file line number	Diff line number	Diff line change
`@@ -3211,8 +3211,8 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {`
`3211`	`3211`	`PrintWithColorRAII(OS, ParenthesisColor) << ')';`
`3212`	`3212`	`}`
`3213`	`3213`
`3214`		`- void visitPackReferenceTypeRepr(PackReferenceTypeRepr *T) {`
`3215`		`- printCommon("pack_reference");`
	`3214`	`+ void visitPackElementTypeRepr(PackElementTypeRepr *T) {`
	`3215`	`+ printCommon("pack_element");`
`3216`	`3216`	`printRec(T->getPackType());`
`3217`	`3217`	`PrintWithColorRAII(OS, ParenthesisColor) << ')';`
`3218`	`3218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2034,7 +2034,7 @@ bool Traversal::visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {`
`2034`	`2034`	`return doIt(T->getPatternType());`
`2035`	`2035`	`}`
`2036`	`2036`
`2037`		`-bool Traversal::visitPackReferenceTypeRepr(PackReferenceTypeRepr *T) {`
	`2037`	`+bool Traversal::visitPackElementTypeRepr(PackElementTypeRepr *T) {`
`2038`	`2038`	`return doIt(T->getPackType());`
`2039`	`2039`	`}`
`2040`	`2040`
Original file line number	Diff line number	Diff line change
`@@ -1284,7 +1284,7 @@ void PackExpansionExpr::getExpandedPacks(SmallVectorImpl<ASTNode> &packs) {`
`1284`	`1284`	`return Action::SkipChildren();`
`1285`	`1285`	`}`
`1286`	`1286`
`1287`		`- if (isa<PackReferenceTypeRepr>(T)) {`
	`1287`	`+ if (isa<PackElementTypeRepr>(T)) {`
`1288`	`1288`	`packs.push_back(T);`
`1289`	`1289`	`}`
`1290`	`1290`
Original file line number	Diff line number	Diff line change
`@@ -482,8 +482,8 @@ void PackExpansionTypeRepr::printImpl(ASTPrinter &Printer,`
`482`	`482`	`printTypeRepr(Pattern, Printer, Opts);`
`483`	`483`	`}`
`484`	`484`
`485`		`-void PackReferenceTypeRepr::printImpl(ASTPrinter &Printer,`
`486`		`- const PrintOptions &Opts) const {`
	`485`	`+void PackElementTypeRepr::printImpl(ASTPrinter &Printer,`
	`486`	`+ const PrintOptions &Opts) const {`
`487`	`487`	`Printer.printKeyword("each", Opts, /Suffix=/" ");`
`488`	`488`	`printTypeRepr(PackType, Printer, Opts);`
`489`	`489`	`}`