Merge pull request #70608 from AnthonyLatsis/unqualified-ident

[NFC] AST: Merge `SimpleIdentTypeRepr` & `GenericIdentTypeRepr` into `IdentTypeRepr`

Author: AnthonyLatsis

include/swift/AST/ASTBridging.h

@@ -1525,8 +1525,8 @@ enum ENUM_EXTENSIBILITY_ATTR(open) BridgedAttributedTypeSpecifier : size_t {
   BridgedAttributedTypeSpecifierTransferring,
 };
 
-SWIFT_NAME("BridgedSimpleIdentTypeRepr.createParsed(_:loc:name:)")
-BridgedSimpleIdentTypeRepr BridgedSimpleIdentTypeRepr_createParsed(
+SWIFT_NAME("BridgedUnqualifiedIdentTypeRepr.createParsed(_:loc:name:)")
+BridgedUnqualifiedIdentTypeRepr BridgedUnqualifiedIdentTypeRepr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cLoc, BridgedIdentifier id);
 
 SWIFT_NAME(
@@ -1574,9 +1574,9 @@ BridgedFunctionTypeRepr BridgedFunctionTypeRepr_createParsed(
     BridgedNullableTypeRepr thrownType, BridgedSourceLoc cArrowLoc,
     BridgedTypeRepr resultType);
 
-SWIFT_NAME("BridgedGenericIdentTypeRepr.createParsed(_:name:nameLoc:"
+SWIFT_NAME("BridgedUnqualifiedIdentTypeRepr.createParsed(_:name:nameLoc:"
            "genericArgs:leftAngleLoc:rightAngleLoc:)")
-BridgedGenericIdentTypeRepr BridgedGenericIdentTypeRepr_createParsed(
+BridgedUnqualifiedIdentTypeRepr BridgedUnqualifiedIdentTypeRepr_createParsed(
     BridgedASTContext cContext, BridgedIdentifier name,
     BridgedSourceLoc cNameLoc, BridgedArrayRef genericArgs,
     BridgedSourceLoc cLAngleLoc, BridgedSourceLoc cRAngleLoc);

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/Attr.h

@@ -66,7 +66,7 @@ class ModuleDecl;
 class PatternBindingInitializer;
 class TrailingWhereClause;
 class TypeExpr;
-class IdentTypeRepr;
+class UnqualifiedIdentTypeRepr;
 
 class alignas(1 << AttrAlignInBits) AttributeBase
     : public ASTAllocated<AttributeBase> {
@@ -1771,7 +1771,8 @@ class CustomAttr final : public DeclAttribute {
   ///
   /// For an identifier type repr, return a pair of `nullptr` and the
   /// identifier.
-  std::pair<IdentTypeRepr *, DeclRefTypeRepr *> destructureMacroRef();
+  std::pair<UnqualifiedIdentTypeRepr *, DeclRefTypeRepr *>
+  destructureMacroRef();
 
   /// Whether the attribute has any arguments.
   bool hasArgs() const { return argList != nullptr; }

include/swift/AST/TypeDeclFinder.h

@@ -44,7 +44,7 @@ class TypeDeclFinder : public TypeWalker {
 /// equivalently and where generic arguments can be walked to separately from
 /// the generic type.
 class SimpleTypeDeclFinder : public TypeDeclFinder {
-  /// The function to call when a \c IdentTypeRepr is seen.
+  /// The function to call when a \c TypeDecl is seen.
   llvm::function_ref<Action(const TypeDecl *)> Callback;
 
   Action visitNominalType(NominalType *ty) override;

include/swift/AST/TypeRepr.h

@@ -196,10 +196,12 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   /// \c Type::getCanonicalType() or \c Type::getWithoutParens().
   TypeRepr *getWithoutParens() const;
 
-  /// Whether this is a `SimpleIdentTypeRepr` matching the given identifier.
+  /// Whether this is a `UnqualifiedIdentTypeRepr` with no generic arguments,
+  /// matching the given identifier.
   bool isSimpleUnqualifiedIdentifier(Identifier identifier) const;
 
-  /// Whether this is a `SimpleIdentTypeRepr` matching the given string.
+  /// Whether this is a `UnqualifiedIdentTypeRepr` with no generic arguments,
+  /// matching the given string.
   bool isSimpleUnqualifiedIdentifier(StringRef str) const;
 
   //*** Allocation Routines ************************************************/
@@ -324,7 +326,7 @@ class AttributedTypeRepr final
   friend class TypeRepr;
 };
 
-class IdentTypeRepr;
+class UnqualifiedIdentTypeRepr;
 
 /// This is the abstract base class for types that directly reference a
 /// type declaration. In written syntax, this type representation consists of
@@ -361,15 +363,15 @@ class DeclRefTypeRepr : public TypeRepr {
                                  SourceRange AngleBrackets);
 
   /// Returns the qualifier or base type representation. For example, `A.B`
-  /// for `A.B.C`. The base of a `IdentTypeRepr` is null.
+  /// for `A.B.C`. The base of a `UnqualifiedIdentTypeRepr` is null.
   TypeRepr *getBase() const;
 
   /// Returns the root qualifier. For example, `A` for `A.B.C`. The root
-  /// qualifier of a `IdentTypeRepr` is itself.
+  /// qualifier of a `UnqualifiedIdentTypeRepr` is itself.
   TypeRepr *getRoot();
 
   /// Returns the root qualifier. For example, `A` for `A.B.C`. The root
-  /// qualifier of a `IdentTypeRepr` is itself.
+  /// qualifier of a `UnqualifiedIdentTypeRepr` is itself.
   const TypeRepr *getRoot() const;
 
   DeclNameLoc getNameLoc() const;
@@ -407,101 +409,62 @@ class DeclRefTypeRepr : public TypeRepr {
   SourceRange getAngleBrackets() const;
 
   static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::SimpleIdent ||
-           T->getKind() == TypeReprKind::GenericIdent ||
-           T->getKind() == TypeReprKind::Member;
+    return T->getKind() == TypeReprKind::UnqualifiedIdent ||
+           T->getKind() == TypeReprKind::QualifiedIdent;
   }
   static bool classof(const DeclRefTypeRepr *T) { return true; }
 
 protected:
   SourceLoc getLocImpl() const;
+  SourceLoc getEndLocImpl() const;
 
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
 
   friend class TypeRepr;
 };
 
-/// An identifier type with an optional set of generic arguments.
+/// An unqualified identifier type an optional set of generic arguments.
 /// \code
 ///   Foo
 ///   Bar<Gen>
 /// \endcode
-class IdentTypeRepr : public DeclRefTypeRepr {
-protected:
-  IdentTypeRepr(TypeReprKind K, DeclNameLoc Loc, DeclNameRef Id,
-                unsigned NumGenericArgs, bool hasGenericArgList)
-      : DeclRefTypeRepr(K, Id, Loc, NumGenericArgs, hasGenericArgList) {}
+class UnqualifiedIdentTypeRepr final
+    : public DeclRefTypeRepr,
+      private llvm::TrailingObjects<UnqualifiedIdentTypeRepr, TypeRepr *,
+                                    SourceRange> {
+  friend TrailingObjects;
 
-public:
-  static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::SimpleIdent ||
-           T->getKind() == TypeReprKind::GenericIdent;
+  size_t numTrailingObjects(OverloadToken<TypeRepr *>) const {
+    return getNumGenericArgs();
   }
-  static bool classof(const IdentTypeRepr *T) { return true; }
 
-protected:
-  SourceLoc getStartLocImpl() const { return getNameLoc().getStartLoc(); }
+  UnqualifiedIdentTypeRepr(DeclNameRef Name, DeclNameLoc NameLoc);
 
-  friend class TypeRepr;
-};
+  UnqualifiedIdentTypeRepr(DeclNameRef Name, DeclNameLoc NameLoc,
+                           ArrayRef<TypeRepr *> GenericArgs,
+                           SourceRange AngleBrackets);
 
-/// A simple identifier type like "Int".
-class SimpleIdentTypeRepr : public IdentTypeRepr {
 public:
-  SimpleIdentTypeRepr(DeclNameLoc Loc, DeclNameRef 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.
-  SimpleIdentTypeRepr(const SimpleIdentTypeRepr &repr)
-      : SimpleIdentTypeRepr(repr.getNameLoc(), repr.getNameRef()) {
-    llvm_unreachable("should not be called dynamically");
-  }
-
-  static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::SimpleIdent;
-  }
-  static bool classof(const SimpleIdentTypeRepr *T) { return true; }
-
-private:
-  SourceLoc getEndLocImpl() const { return getNameLoc().getEndLoc(); }
-  friend class TypeRepr;
-};
-
-/// An identifier type with generic arguments.
-/// \code
-///   Bar<Gen>
-/// \endcode
-class GenericIdentTypeRepr final
-    : public IdentTypeRepr,
-      private llvm::TrailingObjects<GenericIdentTypeRepr, TypeRepr *> {
-  friend TrailingObjects;
-  SourceRange AngleBrackets;
+  static UnqualifiedIdentTypeRepr *
+  create(const ASTContext &C, DeclNameLoc NameLoc, DeclNameRef Name);
 
-  GenericIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id,
-                       ArrayRef<TypeRepr *> GenericArgs,
-                       SourceRange AngleBrackets);
+  static UnqualifiedIdentTypeRepr *create(const ASTContext &C,
+                                          DeclNameLoc NameLoc, DeclNameRef Name,
+                                          ArrayRef<TypeRepr *> GenericArgs,
+                                          SourceRange AngleBrackets);
 
-public:
-  static GenericIdentTypeRepr *create(const ASTContext &C,
-                                      DeclNameLoc Loc,
-                                      DeclNameRef Id,
-                                      ArrayRef<TypeRepr*> GenericArgs,
-                                      SourceRange AngleBrackets);
+  ArrayRef<TypeRepr *> getGenericArgs() const;
 
-  ArrayRef<TypeRepr*> getGenericArgs() const {
-    return {getTrailingObjects<TypeRepr *>(), getNumGenericArgs()};
-  }
-  SourceRange getAngleBrackets() const { return AngleBrackets; }
+  SourceRange getAngleBrackets() const;
 
   static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::GenericIdent;
+    return T->getKind() == TypeReprKind::UnqualifiedIdent;
   }
-  static bool classof(const GenericIdentTypeRepr *T) { return true; }
+  static bool classof(const UnqualifiedIdentTypeRepr *T) { return true; }
+
+protected:
+  SourceLoc getStartLocImpl() const { return getNameLoc().getStartLoc(); }
 
-private:
-  SourceLoc getEndLocImpl() const { return AngleBrackets.End; }
   friend class TypeRepr;
 };
 
@@ -511,9 +474,10 @@ class GenericIdentTypeRepr 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`.
@@ -523,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`.
@@ -549,13 +514,12 @@ 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;
-  SourceLoc getEndLocImpl() const;
 
   friend class TypeRepr;
 };
@@ -1640,9 +1604,8 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Existential:
   case TypeReprKind::PackElement:
     return false;
-  case TypeReprKind::SimpleIdent:
-  case TypeReprKind::GenericIdent:
-  case TypeReprKind::Member:
+  case TypeReprKind::UnqualifiedIdent:
+  case TypeReprKind::QualifiedIdent:
   case TypeReprKind::Metatype:
   case TypeReprKind::Protocol:
   case TypeReprKind::Dictionary:

include/swift/AST/TypeReprNodes.def

@@ -46,11 +46,8 @@ TYPEREPR(Error, TypeRepr)
 TYPEREPR(Attributed, TypeRepr)
 
 ABSTRACT_TYPEREPR(DeclRef, TypeRepr)
-  ABSTRACT_TYPEREPR(Ident, DeclRefTypeRepr)
-    TYPEREPR(SimpleIdent, IdentTypeRepr)
-    TYPEREPR(GenericIdent, IdentTypeRepr)
-  TYPEREPR(Member, DeclRefTypeRepr)
-
+  TYPEREPR(UnqualifiedIdent, DeclRefTypeRepr)
+  TYPEREPR(QualifiedIdent, DeclRefTypeRepr)
 TYPEREPR(Function, TypeRepr)
 TYPEREPR(Array, TypeRepr)
 TYPEREPR(Dictionary, TypeRepr)

include/swift/Parse/Parser.h

@@ -42,23 +42,16 @@ namespace llvm {
 }
 
 namespace swift {
-  class IdentTypeRepr;
-  class ErrorTypeRepr;
   class CodeCompletionCallbacks;
   class DoneParsingCallback;
-  class IDEInspectionCallbacksFactory;
   class DefaultArgumentInitializer;
   class DiagnosticEngine;
   class Expr;
   class Lexer;
   class PersistentParserState;
   class RequirementRepr;
   class SILParserStateBase;
-  class ScopeInfo;
-  class SingleValueStmtExpr;
   class SourceManager;
-  class TupleType;
-  class TypeLoc;
   class UUID;
 
   struct EnumElementInfo;

lib/AST/ASTBridging.cpp

@@ -2052,14 +2052,14 @@ BridgedTypeAttribute BridgedTypeAttribute_createIsolated(
 // MARK: TypeReprs
 //===----------------------------------------------------------------------===//
 
-BridgedSimpleIdentTypeRepr BridgedSimpleIdentTypeRepr_createParsed(
+BridgedUnqualifiedIdentTypeRepr BridgedUnqualifiedIdentTypeRepr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cLoc, BridgedIdentifier id) {
-  ASTContext &context = cContext.unbridged();
-  return new (context) SimpleIdentTypeRepr(DeclNameLoc(cLoc.unbridged()),
-                                           DeclNameRef(id.unbridged()));
+  return UnqualifiedIdentTypeRepr::create(cContext.unbridged(),
+                                          DeclNameLoc(cLoc.unbridged()),
+                                          DeclNameRef(id.unbridged()));
 }
 
-BridgedGenericIdentTypeRepr BridgedGenericIdentTypeRepr_createParsed(
+BridgedUnqualifiedIdentTypeRepr BridgedUnqualifiedIdentTypeRepr_createParsed(
     BridgedASTContext cContext, BridgedIdentifier name,
     BridgedSourceLoc cNameLoc, BridgedArrayRef genericArgs,
     BridgedSourceLoc cLAngleLoc, BridgedSourceLoc cRAngleLoc) {
@@ -2068,9 +2068,9 @@ BridgedGenericIdentTypeRepr BridgedGenericIdentTypeRepr_createParsed(
   auto Name = DeclNameRef(name.unbridged());
   SourceLoc lAngleLoc = cLAngleLoc.unbridged();
   SourceLoc rAngleLoc = cRAngleLoc.unbridged();
-  return GenericIdentTypeRepr::create(context, Loc, Name,
-                                      genericArgs.unbridged<TypeRepr *>(),
-                                      SourceRange{lAngleLoc, rAngleLoc});
+  return UnqualifiedIdentTypeRepr::create(context, Loc, Name,
+                                          genericArgs.unbridged<TypeRepr *>(),
+                                          SourceRange{lAngleLoc, rAngleLoc});
 }
 
 BridgedOptionalTypeRepr