[NFC] AST: Rename MemberTypeRepr → QualifiedIdentTypeRepr

Author: AnthonyLatsis

include/swift/AST/ASTWalker.h

@@ -102,8 +102,8 @@ enum class MacroWalking {
   None
 };
 
-/// A scheme for walking a `MemberTypeRepr`.
-enum class MemberTypeReprWalkingScheme {
+/// A scheme for walking a `QualifiedIdentTypeRepr`.
+enum class QualifiedIdentTypeReprWalkingScheme {
   /// Walk in source order, such that each subsequent dot-separated component is
   /// a child of the previous one. For example, walk `A.B<T.U>.C` like so
   /// (top-down order):
@@ -593,9 +593,10 @@ class ASTWalker {
     return Action::Continue();
   }
 
-  /// This method configures how to walk `MemberTypeRepr` nodes.
-  virtual MemberTypeReprWalkingScheme getMemberTypeReprWalkingScheme() const {
-    return MemberTypeReprWalkingScheme::ASTOrderRecursive;
+  /// This method configures how to walk `QualifiedIdentTypeRepr` nodes.
+  virtual QualifiedIdentTypeReprWalkingScheme
+  getQualifiedIdentTypeReprWalkingScheme() const {
+    return QualifiedIdentTypeReprWalkingScheme::ASTOrderRecursive;
   }
 
   /// This method configures whether the walker should explore into the generic

include/swift/AST/TypeRepr.h

@@ -410,7 +410,7 @@ class DeclRefTypeRepr : public TypeRepr {
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::UnqualifiedIdent ||
-           T->getKind() == TypeReprKind::Member;
+           T->getKind() == TypeReprKind::QualifiedIdent;
   }
   static bool classof(const DeclRefTypeRepr *T) { return true; }
 
@@ -474,9 +474,10 @@ class UnqualifiedIdentTypeRepr final
 ///   Foo.Bar<Gen>.Baz
 ///   [Int].Bar
 /// \endcode
-class MemberTypeRepr final
+class QualifiedIdentTypeRepr final
     : public DeclRefTypeRepr,
-      private llvm::TrailingObjects<MemberTypeRepr, TypeRepr *, SourceRange> {
+      private llvm::TrailingObjects<QualifiedIdentTypeRepr, TypeRepr *,
+                                    SourceRange> {
   friend TrailingObjects;
 
   /// The qualifier or base type representation. For example, `A.B` for `A.B.C`.
@@ -486,19 +487,20 @@ class MemberTypeRepr final
     return getNumGenericArgs();
   }
 
-  MemberTypeRepr(TypeRepr *Base, DeclNameRef Name, DeclNameLoc NameLoc);
+  QualifiedIdentTypeRepr(TypeRepr *Base, DeclNameRef Name, DeclNameLoc NameLoc);
 
-  MemberTypeRepr(TypeRepr *Base, DeclNameRef Name, DeclNameLoc NameLoc,
-                 ArrayRef<TypeRepr *> GenericArgs, SourceRange AngleBrackets);
+  QualifiedIdentTypeRepr(TypeRepr *Base, DeclNameRef Name, DeclNameLoc NameLoc,
+                         ArrayRef<TypeRepr *> GenericArgs,
+                         SourceRange AngleBrackets);
 
 public:
-  static MemberTypeRepr *create(const ASTContext &C, TypeRepr *Base,
-                                DeclNameLoc NameLoc, DeclNameRef Name);
+  static QualifiedIdentTypeRepr *create(const ASTContext &C, TypeRepr *Base,
+                                        DeclNameLoc NameLoc, DeclNameRef Name);
 
-  static MemberTypeRepr *create(const ASTContext &C, TypeRepr *Base,
-                                DeclNameLoc NameLoc, DeclNameRef Name,
-                                ArrayRef<TypeRepr *> GenericArgs,
-                                SourceRange AngleBrackets);
+  static QualifiedIdentTypeRepr *create(const ASTContext &C, TypeRepr *Base,
+                                        DeclNameLoc NameLoc, DeclNameRef Name,
+                                        ArrayRef<TypeRepr *> GenericArgs,
+                                        SourceRange AngleBrackets);
 
   /// Returns the qualifier or base type representation. For example, `A.B`
   /// for `A.B.C`.
@@ -512,9 +514,9 @@ class MemberTypeRepr final
   SourceRange getAngleBrackets() const;
 
   static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::Member;
+    return T->getKind() == TypeReprKind::QualifiedIdent;
   }
-  static bool classof(const MemberTypeRepr *T) { return true; }
+  static bool classof(const QualifiedIdentTypeRepr *T) { return true; }
 
 private:
   SourceLoc getStartLocImpl() const;
@@ -1603,7 +1605,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::PackElement:
     return false;
   case TypeReprKind::UnqualifiedIdent:
-  case TypeReprKind::Member:
+  case TypeReprKind::QualifiedIdent:
   case TypeReprKind::Metatype:
   case TypeReprKind::Protocol:
   case TypeReprKind::Dictionary:

include/swift/AST/TypeReprNodes.def

@@ -47,7 +47,7 @@ TYPEREPR(Attributed, TypeRepr)
 
 ABSTRACT_TYPEREPR(DeclRef, TypeRepr)
   TYPEREPR(UnqualifiedIdent, DeclRefTypeRepr)
-  TYPEREPR(Member, DeclRefTypeRepr)
+  TYPEREPR(QualifiedIdent, DeclRefTypeRepr)
 TYPEREPR(Function, TypeRepr)
 TYPEREPR(Array, TypeRepr)
 TYPEREPR(Dictionary, TypeRepr)

lib/AST/ASTDumper.cpp

@@ -3298,7 +3298,7 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
 
   void visitDeclRefTypeRepr(DeclRefTypeRepr *T, StringRef label) {
     printCommon(isa<UnqualifiedIdentTypeRepr>(T) ? "type_unqualified_ident"
-                                                 : "type_member",
+                                                 : "type_qualified_ident",
                 label);
 
     printFieldQuoted(T->getNameRef(), "id", IdentifierColor);
@@ -3307,8 +3307,8 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
     else
       printFlag("unbound");
 
-    if (auto *memberTR = dyn_cast<MemberTypeRepr>(T)) {
-      printRec(memberTR->getBase());
+    if (auto *qualIdentTR = dyn_cast<QualifiedIdentTypeRepr>(T)) {
+      printRec(qualIdentTR->getBase());
     }
 
     for (auto *genArg : T->getGenericArgs()) {

lib/AST/ASTWalker.cpp

@@ -1627,19 +1627,19 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   }
 
 private:
-  /// Walk a `MemberTypeRepr` in source order such that each subsequent
+  /// Walk a `QualifiedIdentTypeRepr` in source order such that each subsequent
   /// dot-separated component is a child of the previous one
-  [[nodiscard]] bool doItInSourceOrderRecursive(MemberTypeRepr *T);
+  [[nodiscard]] bool doItInSourceOrderRecursive(QualifiedIdentTypeRepr *T);
 
 public:
   /// Returns true on failure.
   [[nodiscard]]
   bool doIt(TypeRepr *T) {
-    if (auto *MTR = dyn_cast<MemberTypeRepr>(T)) {
-      switch (Walker.getMemberTypeReprWalkingScheme()) {
-      case MemberTypeReprWalkingScheme::SourceOrderRecursive:
-        return doItInSourceOrderRecursive(MTR);
-      case MemberTypeReprWalkingScheme::ASTOrderRecursive:
+    if (auto *QualIdentTR = dyn_cast<QualifiedIdentTypeRepr>(T)) {
+      switch (Walker.getQualifiedIdentTypeReprWalkingScheme()) {
+      case QualifiedIdentTypeReprWalkingScheme::SourceOrderRecursive:
+        return doItInSourceOrderRecursive(QualIdentTR);
+      case QualifiedIdentTypeReprWalkingScheme::ASTOrderRecursive:
         break;
       }
     }
@@ -1723,11 +1723,11 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
 
 } // end anonymous namespace
 
-bool Traversal::doItInSourceOrderRecursive(MemberTypeRepr *T) {
+bool Traversal::doItInSourceOrderRecursive(QualifiedIdentTypeRepr *T) {
   // Qualified types are modeled resursively such that each previous
   // dot-separated component is a child of the next one. To walk a member type
   // representation according to
-  // `MemberTypeReprWalkingScheme::SourceOrderRecursive`:
+  // `QualifiedIdentTypeReprWalkingScheme::SourceOrderRecursive`:
 
   // 1. Pre-walk the dot-separated components in source order. If asked to skip
   //    the children of a given component:
@@ -1737,8 +1737,8 @@ bool Traversal::doItInSourceOrderRecursive(MemberTypeRepr *T) {
       doItInSourceOrderPre = [&](TypeRepr *T,
                                  std::optional<unsigned> &StartPostWalkDepth,
                                  unsigned Depth) {
-        if (auto *MemberTR = dyn_cast<MemberTypeRepr>(T)) {
-          if (doItInSourceOrderPre(MemberTR->getBase(), StartPostWalkDepth,
+        if (auto *QualIdentTR = dyn_cast<QualifiedIdentTypeRepr>(T)) {
+          if (doItInSourceOrderPre(QualIdentTR->getBase(), StartPostWalkDepth,
                                    Depth + 1)) {
             return true;
           }
@@ -1789,9 +1789,9 @@ bool Traversal::doItInSourceOrderRecursive(MemberTypeRepr *T) {
           }
         }
 
-        if (auto *MemberTR = dyn_cast<MemberTypeRepr>(T)) {
-          return doItInSourceOrderPost(MemberTR->getBase(), StartPostWalkDepth,
-                                       Depth + 1);
+        if (auto *QualIdentTR = dyn_cast<QualifiedIdentTypeRepr>(T)) {
+          return doItInSourceOrderPost(QualIdentTR->getBase(),
+                                       StartPostWalkDepth, Depth + 1);
         }
 
         return false;
@@ -2231,8 +2231,8 @@ bool Traversal::visitAttributedTypeRepr(AttributedTypeRepr *T) {
 }
 
 bool Traversal::visitDeclRefTypeRepr(DeclRefTypeRepr *T) {
-  if (auto *memberTR = dyn_cast<MemberTypeRepr>(T)) {
-    if (doIt(memberTR->getBase())) {
+  if (auto *qualIdentTR = dyn_cast<QualifiedIdentTypeRepr>(T)) {
+    if (doIt(qualIdentTR->getBase())) {
       return true;
     }
   }
@@ -2250,7 +2250,7 @@ bool Traversal::visitUnqualifiedIdentTypeRepr(UnqualifiedIdentTypeRepr *T) {
   return visitDeclRefTypeRepr(T);
 }
 
-bool Traversal::visitMemberTypeRepr(MemberTypeRepr *T) {
+bool Traversal::visitQualifiedIdentTypeRepr(QualifiedIdentTypeRepr *T) {
   return visitDeclRefTypeRepr(T);
 }
 

lib/AST/Attr.cpp

@@ -2756,10 +2756,11 @@ CustomAttr::destructureMacroRef() {
     return {nullptr, nullptr};
   if (auto *unqualIdentType = dyn_cast<UnqualifiedIdentTypeRepr>(typeRepr))
     return {nullptr, unqualIdentType};
-  if (auto *memType = dyn_cast<MemberTypeRepr>(typeRepr)) {
-    if (auto *base = dyn_cast<UnqualifiedIdentTypeRepr>(memType->getBase())) {
+  if (auto *qualIdentType = dyn_cast<QualifiedIdentTypeRepr>(typeRepr)) {
+    if (auto *base =
+            dyn_cast<UnqualifiedIdentTypeRepr>(qualIdentType->getBase())) {
       if (!base->hasGenericArgList())
-        return {base, memType};
+        return {base, qualIdentType};
     }
   }
   return {nullptr, nullptr};

lib/AST/Expr.cpp

@@ -2241,22 +2241,22 @@ TypeExpr *TypeExpr::createForMemberDecl(DeclNameLoc ParentNameLoc,
                                                   Parent->createNameRef());
   BaseTR->setValue(Parent, nullptr);
 
-  auto *MemberTR =
-      MemberTypeRepr::create(C, BaseTR, NameLoc, Decl->createNameRef());
-  MemberTR->setValue(Decl, nullptr);
+  auto *QualIdentTR =
+      QualifiedIdentTypeRepr::create(C, BaseTR, NameLoc, Decl->createNameRef());
+  QualIdentTR->setValue(Decl, nullptr);
 
-  return new (C) TypeExpr(MemberTR);
+  return new (C) TypeExpr(QualIdentTR);
 }
 
 TypeExpr *TypeExpr::createForMemberDecl(TypeRepr *ParentTR, DeclNameLoc NameLoc,
                                         TypeDecl *Decl) {
   ASTContext &C = Decl->getASTContext();
 
-  auto *MemberTR =
-      MemberTypeRepr::create(C, ParentTR, NameLoc, Decl->createNameRef());
-  MemberTR->setValue(Decl, nullptr);
+  auto *QualIdentTR = QualifiedIdentTypeRepr::create(C, ParentTR, NameLoc,
+                                                     Decl->createNameRef());
+  QualIdentTR->setValue(Decl, nullptr);
 
-  return new (C) TypeExpr(MemberTR);
+  return new (C) TypeExpr(QualIdentTR);
 }
 
 TypeExpr *TypeExpr::createForSpecializedDecl(DeclRefTypeRepr *ParentTR,
@@ -2275,7 +2275,7 @@ TypeExpr *TypeExpr::createForSpecializedDecl(DeclRefTypeRepr *ParentTR,
         C, ParentTR->getNameLoc(), ParentTR->getNameRef(), Args, AngleLocs);
     specializedTR->setValue(boundDecl, ParentTR->getDeclContext());
   } else {
-    auto *const memberTR = cast<MemberTypeRepr>(ParentTR);
+    auto *const qualIdentTR = cast<QualifiedIdentTypeRepr>(ParentTR);
     if (isa<TypeAliasDecl>(boundDecl)) {
       // If any of our parent types are unbound, bail out and let
       // the constraint solver can infer generic parameters for them.
@@ -2289,7 +2289,7 @@ TypeExpr *TypeExpr::createForSpecializedDecl(DeclRefTypeRepr *ParentTR,
       //
       // FIXME: Once we can model generic typealiases properly, rip
       // this out.
-      MemberTypeRepr *currTR = memberTR;
+      QualifiedIdentTypeRepr *currTR = qualIdentTR;
       while (auto *declRefBaseTR =
                  dyn_cast<DeclRefTypeRepr>(currTR->getBase())) {
         if (!declRefBaseTR->hasGenericArgList()) {
@@ -2299,16 +2299,16 @@ TypeExpr *TypeExpr::createForSpecializedDecl(DeclRefTypeRepr *ParentTR,
             return nullptr;
         }
 
-        currTR = dyn_cast<MemberTypeRepr>(declRefBaseTR);
+        currTR = dyn_cast<QualifiedIdentTypeRepr>(declRefBaseTR);
         if (!currTR) {
           break;
         }
       }
     }
 
-    specializedTR =
-        MemberTypeRepr::create(C, memberTR->getBase(), ParentTR->getNameLoc(),
-                               ParentTR->getNameRef(), Args, AngleLocs);
+    specializedTR = QualifiedIdentTypeRepr::create(
+        C, qualIdentTR->getBase(), ParentTR->getNameLoc(),
+        ParentTR->getNameRef(), Args, AngleLocs);
     specializedTR->setValue(boundDecl, ParentTR->getDeclContext());
   }
 

lib/AST/NameLookup.cpp

@@ -2774,11 +2774,12 @@ resolveTypeDeclsToNominal(Evaluator &evaluator,
               anyObject = true;
         }
         // TypeRepr version: Builtin.AnyObject
-        else if (auto *memberTR = dyn_cast_or_null<MemberTypeRepr>(
+        else if (auto *qualIdentTR = dyn_cast_or_null<QualifiedIdentTypeRepr>(
                      typealias->getUnderlyingTypeRepr())) {
-          if (!memberTR->hasGenericArgList() &&
-              memberTR->getNameRef().isSimpleName("AnyObject") &&
-              memberTR->getBase()->isSimpleUnqualifiedIdentifier("Builtin")) {
+          if (!qualIdentTR->hasGenericArgList() &&
+              qualIdentTR->getNameRef().isSimpleName("AnyObject") &&
+              qualIdentTR->getBase()->isSimpleUnqualifiedIdentifier(
+                  "Builtin")) {
             anyObject = true;
           }
         }
@@ -2941,9 +2942,9 @@ static DirectlyReferencedTypeDecls
 directReferencesForDeclRefTypeRepr(Evaluator &evaluator, ASTContext &ctx,
                                    DeclRefTypeRepr *repr, DeclContext *dc,
                                    bool allowUsableFromInline) {
-  if (auto *memberTR = dyn_cast<MemberTypeRepr>(repr)) {
+  if (auto *qualIdentTR = dyn_cast<QualifiedIdentTypeRepr>(repr)) {
     auto result = directReferencesForTypeRepr(
-        evaluator, ctx, memberTR->getBase(), dc, allowUsableFromInline);
+        evaluator, ctx, qualIdentTR->getBase(), dc, allowUsableFromInline);
 
     // For a qualified identifier, perform qualified name lookup.
     result.first = directReferencesForQualifiedTypeLookup(
@@ -2993,7 +2994,7 @@ directReferencesForTypeRepr(Evaluator &evaluator,
     return result;
   }
 
-  case TypeReprKind::Member:
+  case TypeReprKind::QualifiedIdent:
   case TypeReprKind::UnqualifiedIdent:
     return directReferencesForDeclRefTypeRepr(evaluator, ctx,
                                               cast<DeclRefTypeRepr>(typeRepr),
@@ -3495,9 +3496,9 @@ CollectedOpaqueReprs swift::collectOpaqueTypeReprs(TypeRepr *r, ASTContext &ctx,
         // We only care about the type of an outermost member type
         // representation. For example, in `A<T>.B.C<U>`, check `C` and generic
         // arguments `U` and `T`, but not `A` or `B`.
-        if (auto *parentMemberTR =
-                dyn_cast_or_null<MemberTypeRepr>(Parent.getAsTypeRepr())) {
-          if (repr == parentMemberTR->getBase()) {
+        if (auto *parentQualIdentTR = dyn_cast_or_null<QualifiedIdentTypeRepr>(
+                Parent.getAsTypeRepr())) {
+          if (repr == parentQualIdentTR->getBase()) {
             return Action::Continue();
           }
         }
@@ -3765,8 +3766,8 @@ CustomAttrNominalRequest::evaluate(Evaluator &evaluator,
             auto *baseTR = UnqualifiedIdentTypeRepr::create(
                 ctx, nameLoc, DeclNameRef(moduleName));
 
-            auto *newTE = new (ctx)
-                TypeExpr(MemberTypeRepr::create(ctx, baseTR, nameLoc, name));
+            auto *newTE = new (ctx) TypeExpr(
+                QualifiedIdentTypeRepr::create(ctx, baseTR, nameLoc, name));
             attr->resetTypeInformation(newTE);
             return nominal;
           }