[NFC] AST: Actually remodel MemberTypeRepr to be recursive

Author: AnthonyLatsis

include/swift/AST/TypeRepr.h

@@ -84,17 +84,14 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
     NumElements : 32
   );
 
-  SWIFT_INLINE_BITFIELD_EMPTY(DeclRefTypeRepr, TypeRepr);
-  SWIFT_INLINE_BITFIELD_EMPTY(IdentTypeRepr, DeclRefTypeRepr);
-
-  SWIFT_INLINE_BITFIELD_FULL(GenericIdentTypeRepr, IdentTypeRepr, 32,
+  SWIFT_INLINE_BITFIELD_FULL(DeclRefTypeRepr, TypeRepr, 1+32,
+    /// Whether this instance has a valid angle bracket source range.
+    HasAngleBrackets: 1,
     : NumPadBits,
+
     NumGenericArgs : 32
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(MemberTypeRepr, DeclRefTypeRepr, 32,
-                             : NumPadBits, NumMemberComponents : 32);
-
   SWIFT_INLINE_BITFIELD_FULL(CompositionTypeRepr, TypeRepr, 32,
     : NumPadBits,
     NumTypes : 32
@@ -332,8 +329,23 @@ class IdentTypeRepr;
 ///   Foo.Bar<Gen>
 /// \endcode
 class DeclRefTypeRepr : public TypeRepr {
+  DeclNameLoc NameLoc;
+
+  /// Either the identifier or declaration that describes this
+  /// component.
+  ///
+  /// The initial parsed representation is always an identifier, and
+  /// name lookup will resolve this to a specific declaration.
+  llvm::PointerUnion<DeclNameRef, TypeDecl *> NameOrDecl;
+
+  /// The declaration context from which the bound declaration was
+  /// found. only valid if IdOrDecl is a TypeDecl.
+  DeclContext *DC;
+
 protected:
-  explicit DeclRefTypeRepr(TypeReprKind K) : TypeRepr(K) {}
+  explicit DeclRefTypeRepr(TypeReprKind K, DeclNameRef Name,
+                           DeclNameLoc NameLoc, unsigned NumGenericArgs,
+                           bool HasAngleBrackets);
 
 public:
   static DeclRefTypeRepr *create(const ASTContext &C, TypeRepr *Base,
@@ -356,10 +368,6 @@ class DeclRefTypeRepr : public TypeRepr {
   /// qualifier of a `IdentTypeRepr` is itself.
   const TypeRepr *getRoot() const;
 
-  /// Returns \c this if it is a \c IdentTypeRepr. Otherwise, \c this
-  /// is a \c MemberTypeRepr, and the method returns its last member component.
-  IdentTypeRepr *getLastComponent();
-
   DeclNameLoc getNameLoc() const;
   DeclNameRef getNameRef() const;
 
@@ -387,6 +395,11 @@ class DeclRefTypeRepr : public TypeRepr {
 
   ArrayRef<TypeRepr *> getGenericArgs() const;
 
+protected:
+  /// Returns whether this instance has a valid angle bracket source range.
+  bool hasAngleBrackets() const;
+
+public:
   SourceRange getAngleBrackets() const;
 
   static bool classof(const TypeRepr *T) {
@@ -397,6 +410,8 @@ class DeclRefTypeRepr : public TypeRepr {
   static bool classof(const DeclRefTypeRepr *T) { return true; }
 
 protected:
+  SourceLoc getLocImpl() const;
+
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
 
   friend class TypeRepr;
@@ -408,55 +423,20 @@ class DeclRefTypeRepr : public TypeRepr {
 ///   Bar<Gen>
 /// \endcode
 class IdentTypeRepr : public DeclRefTypeRepr {
-  DeclNameLoc Loc;
-
-  /// Either the identifier or declaration that describes this
-  /// component.
-  ///
-  /// The initial parsed representation is always an identifier, and
-  /// name lookup will resolve this to a specific declaration.
-  llvm::PointerUnion<DeclNameRef, TypeDecl *> IdOrDecl;
-
-  /// The declaration context from which the bound declaration was
-  /// found. only valid if IdOrDecl is a TypeDecl.
-  DeclContext *DC;
-
 protected:
-  IdentTypeRepr(TypeReprKind K, DeclNameLoc Loc, DeclNameRef Id)
-      : DeclRefTypeRepr(K), Loc(Loc), IdOrDecl(Id), DC(nullptr) {}
+  IdentTypeRepr(TypeReprKind K, DeclNameLoc Loc, DeclNameRef Id,
+                unsigned NumGenericArgs, bool hasGenericArgList)
+      : DeclRefTypeRepr(K, Id, Loc, NumGenericArgs, hasGenericArgList) {}
 
 public:
-  DeclNameLoc getNameLoc() const { return Loc; }
-  DeclNameRef getNameRef() const;
-
-  /// Replace the identifier with a new identifier, e.g., due to typo
-  /// correction.
-  void overwriteNameRef(DeclNameRef newId) { IdOrDecl = newId; }
-
-  /// Return true if this name has been resolved to a type decl. This happens
-  /// during type resolution.
-  bool isBound() const { return IdOrDecl.is<TypeDecl *>(); }
-
-  TypeDecl *getBoundDecl() const { return IdOrDecl.dyn_cast<TypeDecl*>(); }
-
-  DeclContext *getDeclContext() const {
-    assert(isBound());
-    return DC;
-  }
-
-  void setValue(TypeDecl *TD, DeclContext *DC) {
-    IdOrDecl = TD;
-    this->DC = DC;
-  }
-
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::SimpleIdent ||
            T->getKind() == TypeReprKind::GenericIdent;
   }
   static bool classof(const IdentTypeRepr *T) { return true; }
 
 protected:
-  SourceLoc getLocImpl() const { return Loc.getBaseNameLoc(); }
+  SourceLoc getStartLocImpl() const { return getNameLoc().getStartLoc(); }
 
   friend class TypeRepr;
 };
@@ -465,7 +445,8 @@ class IdentTypeRepr : public DeclRefTypeRepr {
 class SimpleIdentTypeRepr : public IdentTypeRepr {
 public:
   SimpleIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id)
-      : IdentTypeRepr(TypeReprKind::SimpleIdent, Loc, Id) {}
+      : IdentTypeRepr(TypeReprKind::SimpleIdent, Loc, Id, /*NumGenericArgs=*/0,
+                      /*HasAngleBrackets=*/false) {}
 
   // SmallVector::emplace_back will never need to call this because
   // we reserve the right size, but it does try statically.
@@ -480,7 +461,6 @@ class SimpleIdentTypeRepr : public IdentTypeRepr {
   static bool classof(const SimpleIdentTypeRepr *T) { return true; }
 
 private:
-  SourceLoc getStartLocImpl() const { return getNameLoc().getStartLoc(); }
   SourceLoc getEndLocImpl() const { return getNameLoc().getEndLoc(); }
   friend class TypeRepr;
 };
@@ -497,17 +477,7 @@ class GenericIdentTypeRepr final
 
   GenericIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id,
                        ArrayRef<TypeRepr *> GenericArgs,
-                       SourceRange AngleBrackets)
-      : IdentTypeRepr(TypeReprKind::GenericIdent, Loc, Id),
-        AngleBrackets(AngleBrackets) {
-    Bits.GenericIdentTypeRepr.NumGenericArgs = GenericArgs.size();
-#ifndef NDEBUG
-    for (auto arg : GenericArgs)
-      assert(arg != nullptr);
-#endif
-    std::uninitialized_copy(GenericArgs.begin(), GenericArgs.end(),
-                            getTrailingObjects<TypeRepr*>());
-  }
+                       SourceRange AngleBrackets);
 
 public:
   static GenericIdentTypeRepr *create(const ASTContext &C,
@@ -516,13 +486,8 @@ class GenericIdentTypeRepr final
                                       ArrayRef<TypeRepr*> GenericArgs,
                                       SourceRange AngleBrackets);
 
-  unsigned getNumGenericArgs() const {
-    return Bits.GenericIdentTypeRepr.NumGenericArgs;
-  }
-
   ArrayRef<TypeRepr*> getGenericArgs() const {
-    return {getTrailingObjects<TypeRepr*>(),
-            Bits.GenericIdentTypeRepr.NumGenericArgs};
+    return {getTrailingObjects<TypeRepr *>(), getNumGenericArgs()};
   }
   SourceRange getAngleBrackets() const { return AngleBrackets; }
 
@@ -532,7 +497,6 @@ class GenericIdentTypeRepr final
   static bool classof(const GenericIdentTypeRepr *T) { return true; }
 
 private:
-  SourceLoc getStartLocImpl() const { return getNameLoc().getStartLoc(); }
   SourceLoc getEndLocImpl() const { return AngleBrackets.End; }
   friend class TypeRepr;
 };
@@ -543,25 +507,23 @@ class GenericIdentTypeRepr final
 ///   Foo.Bar<Gen>.Baz
 ///   [Int].Bar
 /// \endcode
-class MemberTypeRepr final : public DeclRefTypeRepr,
-      private llvm::TrailingObjects<MemberTypeRepr, IdentTypeRepr *> {
+class MemberTypeRepr final
+    : public DeclRefTypeRepr,
+      private llvm::TrailingObjects<MemberTypeRepr, TypeRepr *, SourceRange> {
   friend TrailingObjects;
 
-  const ASTContext *C;
-
-  /// The root component, which is not necessarily an identifier type.
-  TypeRepr *Root;
+  /// The qualifier or base type representation. For example, `A.B` for `A.B.C`.
+  TypeRepr *Base;
 
-  MemberTypeRepr(TypeRepr *Root, ArrayRef<IdentTypeRepr *> MemberComponents,
-                 const ASTContext &C)
-      : DeclRefTypeRepr(TypeReprKind::Member), C(&C), Root(Root) {
-    Bits.MemberTypeRepr.NumMemberComponents = MemberComponents.size();
-    assert(MemberComponents.size() > 0 &&
-           "MemberTypeRepr requires at least 1 member component");
-    std::uninitialized_copy(MemberComponents.begin(), MemberComponents.end(),
-                            getTrailingObjects<IdentTypeRepr *>());
+  size_t numTrailingObjects(OverloadToken<TypeRepr *>) const {
+    return getNumGenericArgs();
   }
 
+  MemberTypeRepr(TypeRepr *Base, DeclNameRef Name, DeclNameLoc NameLoc);
+
+  MemberTypeRepr(TypeRepr *Base, DeclNameRef Name, DeclNameLoc NameLoc,
+                 ArrayRef<TypeRepr *> GenericArgs, SourceRange AngleBrackets);
+
 public:
   static MemberTypeRepr *create(const ASTContext &C, TypeRepr *Base,
                                 DeclNameLoc NameLoc, DeclNameRef Name);
@@ -571,37 +533,25 @@ class MemberTypeRepr final : public DeclRefTypeRepr,
                                 ArrayRef<TypeRepr *> GenericArgs,
                                 SourceRange AngleBrackets);
 
-  static TypeRepr *create(const ASTContext &Ctx, TypeRepr *Root,
-                          ArrayRef<IdentTypeRepr *> MemberComponents);
-
-  static DeclRefTypeRepr *create(const ASTContext &Ctx,
-                                 ArrayRef<IdentTypeRepr *> Components);
-
   /// Returns the qualifier or base type representation. For example, `A.B`
   /// for `A.B.C`.
   TypeRepr *getBase() const;
 
   /// Returns the root qualifier. For example, `A` for `A.B.C`.
-  TypeRepr *getRoot() const { return Root; }
+  TypeRepr *getRoot() const;
 
-  ArrayRef<IdentTypeRepr *> getMemberComponents() const {
-    return {getTrailingObjects<IdentTypeRepr *>(),
-            Bits.MemberTypeRepr.NumMemberComponents};
-  }
+  ArrayRef<TypeRepr *> getGenericArgs() const;
 
-  IdentTypeRepr *getLastComponent() const {
-    return getMemberComponents().back();
-  }
+  SourceRange getAngleBrackets() const;
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Member;
   }
   static bool classof(const MemberTypeRepr *T) { return true; }
 
 private:
-  SourceLoc getStartLocImpl() const { return getRoot()->getStartLoc(); }
-  SourceLoc getEndLocImpl() const { return getLastComponent()->getEndLoc(); }
-  SourceLoc getLocImpl() const { return getLastComponent()->getLoc(); }
+  SourceLoc getStartLocImpl() const;
+  SourceLoc getEndLocImpl() const;
 
   friend class TypeRepr;
 };