AST: Rename PackReferenceTypeRepr => PackElementTypeRepr

Author: slavapestov

include/swift/AST/TypeRepr.h

@@ -821,22 +821,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 +1439,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:

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)

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;

include/swift/Sema/ConstraintSystem.h

@@ -6208,7 +6208,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

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) << ')';
   }

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());
 }
 

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);
       }
 

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);

lib/AST/TypeRepr.cpp

@@ -473,8 +473,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);
 }

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 * {