[NFC] AST: Rename IdentTypeRepr → UnqualifiedIdentTypeRepr

AnthonyLatsis · AnthonyLatsis · commit 68746a0579fc · 2024-03-02T08:28:47.000+03:00
diff --git a/include/swift/AST/Attr.h b/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> {
@@ -1766,7 +1766,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; }
diff --git a/include/swift/AST/TypeDeclFinder.h b/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;
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
@@ -324,7 +324,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 +361,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;
@@ -426,18 +426,18 @@ class DeclRefTypeRepr : public TypeRepr {
 ///   Foo
 ///   Bar<Gen>
 /// \endcode
-class IdentTypeRepr : public DeclRefTypeRepr {
+class UnqualifiedIdentTypeRepr : public DeclRefTypeRepr {
 protected:
-  IdentTypeRepr(TypeReprKind K, DeclNameLoc Loc, DeclNameRef Id,
-                unsigned NumGenericArgs, bool hasGenericArgList)
+  UnqualifiedIdentTypeRepr(TypeReprKind K, DeclNameLoc Loc, DeclNameRef Id,
+                           unsigned NumGenericArgs, bool hasGenericArgList)
       : DeclRefTypeRepr(K, Id, Loc, NumGenericArgs, hasGenericArgList) {}
 
 public:
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::SimpleIdent ||
            T->getKind() == TypeReprKind::GenericIdent;
   }
-  static bool classof(const IdentTypeRepr *T) { return true; }
+  static bool classof(const UnqualifiedIdentTypeRepr *T) { return true; }
 
 protected:
   SourceLoc getStartLocImpl() const { return getNameLoc().getStartLoc(); }
@@ -446,11 +446,12 @@ class IdentTypeRepr : public DeclRefTypeRepr {
 };
 
 /// A simple identifier type like "Int".
-class SimpleIdentTypeRepr : public IdentTypeRepr {
+class SimpleIdentTypeRepr : public UnqualifiedIdentTypeRepr {
 public:
   SimpleIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id)
-      : IdentTypeRepr(TypeReprKind::SimpleIdent, Loc, Id, /*NumGenericArgs=*/0,
-                      /*HasAngleBrackets=*/false) {}
+      : UnqualifiedIdentTypeRepr(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.
@@ -474,7 +475,7 @@ class SimpleIdentTypeRepr : public IdentTypeRepr {
 ///   Bar<Gen>
 /// \endcode
 class GenericIdentTypeRepr final
-    : public IdentTypeRepr,
+    : public UnqualifiedIdentTypeRepr,
       private llvm::TrailingObjects<GenericIdentTypeRepr, TypeRepr *> {
   friend TrailingObjects;
   SourceRange AngleBrackets;
diff --git a/include/swift/AST/TypeReprNodes.def b/include/swift/AST/TypeReprNodes.def
@@ -46,9 +46,9 @@ TYPEREPR(Error, TypeRepr)
 TYPEREPR(Attributed, TypeRepr)
 
 ABSTRACT_TYPEREPR(DeclRef, TypeRepr)
-  ABSTRACT_TYPEREPR(Ident, DeclRefTypeRepr)
-    TYPEREPR(SimpleIdent, IdentTypeRepr)
-    TYPEREPR(GenericIdent, IdentTypeRepr)
+  ABSTRACT_TYPEREPR(UnqualifiedIdent, DeclRefTypeRepr)
+    TYPEREPR(SimpleIdent, UnqualifiedIdentTypeRepr)
+    TYPEREPR(GenericIdent, UnqualifiedIdentTypeRepr)
   TYPEREPR(Member, DeclRefTypeRepr)
 
 TYPEREPR(Function, TypeRepr)
diff --git a/include/swift/Parse/Parser.h b/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;
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3297,7 +3297,9 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
   }
 
   void visitDeclRefTypeRepr(DeclRefTypeRepr *T, StringRef label) {
-    printCommon(isa<IdentTypeRepr>(T) ? "type_ident" : "type_member", label);
+    printCommon(isa<UnqualifiedIdentTypeRepr>(T) ? "type_unqualified_ident"
+                                                 : "type_member",
+                label);
 
     printFieldQuoted(T->getNameRef(), "id", IdentifierColor);
     if (T->isBound())
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -2749,13 +2749,13 @@ CustomAttr *CustomAttr::create(ASTContext &ctx, SourceLoc atLoc, TypeExpr *type,
       CustomAttr(atLoc, range, type, initContext, argList, implicit);
 }
 
-std::pair<IdentTypeRepr *, DeclRefTypeRepr *>
+std::pair<UnqualifiedIdentTypeRepr *, DeclRefTypeRepr *>
 CustomAttr::destructureMacroRef() {
   TypeRepr *typeRepr = getTypeRepr();
   if (!typeRepr)
     return {nullptr, nullptr};
-  if (auto *identType = dyn_cast<IdentTypeRepr>(typeRepr))
-    return {nullptr, identType};
+  if (auto *unqualIdentType = dyn_cast<UnqualifiedIdentTypeRepr>(typeRepr))
+    return {nullptr, unqualIdentType};
   if (auto *memType = dyn_cast<MemberTypeRepr>(typeRepr)) {
     if (auto *base = dyn_cast<SimpleIdentTypeRepr>(memType->getBase())) {
       return {base, memType};
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -6732,7 +6732,7 @@ NominalTypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
       continue;
 
     auto *subjectRepr =
-        dyn_cast<IdentTypeRepr>(requirementRepr.getSubjectRepr());
+        dyn_cast<UnqualifiedIdentTypeRepr>(requirementRepr.getSubjectRepr());
 
     if (!(subjectRepr && subjectRepr->isBound()))
       continue;
@@ -6775,7 +6775,8 @@ ProtocolDecl::hasInverseMarking(InvertibleProtocolKind target) const {
         reqRepr.getKind() != RequirementReprKind::TypeConstraint)
       continue;
 
-    auto *subjectRepr = dyn_cast<IdentTypeRepr>(reqRepr.getSubjectRepr());
+    auto *subjectRepr =
+        dyn_cast<UnqualifiedIdentTypeRepr>(reqRepr.getSubjectRepr());
     auto *constraintRepr = reqRepr.getConstraintRepr();
 
     if (!subjectRepr || !subjectRepr->getNameRef().isSimpleName(ctx.Id_Self))
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -2270,7 +2270,7 @@ TypeExpr *TypeExpr::createForSpecializedDecl(DeclRefTypeRepr *ParentTR,
     return nullptr;
   }
 
-  if (isa<IdentTypeRepr>(ParentTR)) {
+  if (isa<UnqualifiedIdentTypeRepr>(ParentTR)) {
     specializedTR = GenericIdentTypeRepr::create(
         C, ParentTR->getNameLoc(), ParentTR->getNameRef(), Args, AngleLocs);
     specializedTR->setValue(boundDecl, ParentTR->getDeclContext());
diff --git a/lib/AST/TypeRepr.cpp b/lib/AST/TypeRepr.cpp
@@ -189,7 +189,7 @@ DeclRefTypeRepr *DeclRefTypeRepr::create(const ASTContext &C, TypeRepr *Base,
 }
 
 TypeRepr *DeclRefTypeRepr::getBase() const {
-  if (isa<IdentTypeRepr>(this)) {
+  if (isa<UnqualifiedIdentTypeRepr>(this)) {
     return nullptr;
   }
 
@@ -202,8 +202,8 @@ TypeRepr *DeclRefTypeRepr::getRoot() {
 }
 
 const TypeRepr *DeclRefTypeRepr::getRoot() const {
-  if (auto *ITR = dyn_cast<IdentTypeRepr>(this))
-    return ITR;
+  if (auto *UITR = dyn_cast<UnqualifiedIdentTypeRepr>(this))
+    return UITR;
 
   return cast<MemberTypeRepr>(this)->getRoot();
 }
@@ -481,9 +481,9 @@ TupleTypeRepr *TupleTypeRepr::createEmpty(const ASTContext &C,
 GenericIdentTypeRepr::GenericIdentTypeRepr(DeclNameLoc Loc, DeclNameRef Id,
                                            ArrayRef<TypeRepr *> GenericArgs,
                                            SourceRange AngleBrackets)
-    : IdentTypeRepr(TypeReprKind::GenericIdent, Loc, Id,
-                    /*NumGenericArgs=*/GenericArgs.size(),
-                    /*HasAngleBrackets=*/AngleBrackets.isValid()),
+    : UnqualifiedIdentTypeRepr(TypeReprKind::GenericIdent, Loc, Id,
+                               /*NumGenericArgs=*/GenericArgs.size(),
+                               /*HasAngleBrackets=*/AngleBrackets.isValid()),
       AngleBrackets(AngleBrackets) {
 #ifndef NDEBUG
   for (auto arg : GenericArgs)
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -218,9 +218,8 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
       if (isa<MemberTypeRepr>(declRefTR))
         return false;
 
-      const auto *identTR = cast<IdentTypeRepr>(declRefTR);
       ImportPath::Module::Builder builder(
-          identTR->getNameRef().getBaseIdentifier(), identTR->getLoc());
+          declRefTR->getNameRef().getBaseIdentifier(), declRefTR->getLoc());
 
       if (auto Module = Context.getLoadedModule(builder.get()))
         ParsedTypeLoc.setType(ModuleType::get(Module));
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -711,7 +711,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
           } else if (auto *TE = dyn_cast<TypeExpr>(E)) {
             if (auto *TR =
                     dyn_cast_or_null<MemberTypeRepr>(TE->getTypeRepr())) {
-              if (!isa<IdentTypeRepr>(TR->getRoot())) {
+              if (!isa<UnqualifiedIdentTypeRepr>(TR->getRoot())) {
                 behavior = DiagnosticBehavior::Warning;
               }
             }
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
@@ -184,7 +184,7 @@ static DeclRefTypeRepr *translateExprToDeclRefTypeRepr(Expr *E, ASTContext &C) {
     DeclRefTypeRepr *visitExpr(Expr *e) { return nullptr; }
 
     DeclRefTypeRepr *visitTypeExpr(TypeExpr *te) {
-      return dyn_cast_or_null<IdentTypeRepr>(te->getTypeRepr());
+      return dyn_cast_or_null<UnqualifiedIdentTypeRepr>(te->getTypeRepr());
     }
 
     DeclRefTypeRepr *visitDeclRefExpr(DeclRefExpr *dre) {
@@ -565,7 +565,7 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     EnumElementDecl *referencedElement = nullptr;
     TypeExpr *baseTE = nullptr;
 
-    if (isa<IdentTypeRepr>(repr)) {
+    if (isa<UnqualifiedIdentTypeRepr>(repr)) {
       // Not qualified. Try looking up an enum element in context.
       referencedElement = lookupUnqualifiedEnumMemberElement(
           DC, repr->getNameRef(), repr->getLoc());
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -1278,7 +1278,7 @@ static void maybeDiagnoseBadConformanceRef(DeclContext *dc,
 static Type resolveTypeDecl(TypeDecl *typeDecl, DeclContext *foundDC,
                             TypeResolution resolution,
                             SILTypeResolutionContext *silContext,
-                            IdentTypeRepr *repr) {
+                            UnqualifiedIdentTypeRepr *repr) {
   // Resolve the type declaration to a specific type. How this occurs
   // depends on the current context and where the type was found.
   Type type = resolution.resolveTypeInContext(typeDecl, foundDC,
@@ -1338,7 +1338,7 @@ static Type diagnoseUnknownType(TypeResolution resolution,
                                 SourceRange parentRange,
                                 DeclRefTypeRepr *repr,
                                 NameLookupOptions lookupOptions) {
-  assert(parentType || isa<IdentTypeRepr>(repr));
+  assert(parentType || isa<UnqualifiedIdentTypeRepr>(repr));
 
   auto dc = resolution.getDeclContext();
   ASTContext &ctx = dc->getASTContext();
@@ -1587,7 +1587,7 @@ static SelfTypeKind getSelfTypeKind(DeclContext *dc,
 }
 
 static void diagnoseGenericArgumentsOnSelf(TypeResolution resolution,
-                                           IdentTypeRepr *repr,
+                                           UnqualifiedIdentTypeRepr *repr,
                                            DeclContext *typeDC) {
   ASTContext &ctx = resolution.getASTContext();
   auto &diags = ctx.Diags;
@@ -1612,9 +1612,10 @@ static void diagnoseGenericArgumentsOnSelf(TypeResolution resolution,
 ///
 /// \returns Either the resolved type or a null type, the latter of
 /// which indicates that some dependencies were unsatisfied.
-static Type resolveUnqualifiedIdentTypeRepr(TypeResolution resolution,
-                                            SILTypeResolutionContext *silContext,
-                                            IdentTypeRepr *repr) {
+static Type
+resolveUnqualifiedIdentTypeRepr(TypeResolution resolution,
+                                SILTypeResolutionContext *silContext,
+                                UnqualifiedIdentTypeRepr *repr) {
   const auto options = resolution.getOptions();
   ASTContext &ctx = resolution.getASTContext();
   auto &diags = ctx.Diags;
@@ -4708,10 +4709,10 @@ TypeResolver::resolveDeclRefTypeReprRec(DeclRefTypeRepr *repr,
 
   Type result;
 
-  if (auto *identTR = dyn_cast<IdentTypeRepr>(repr)) {
+  if (auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(repr)) {
     // The base component uses unqualified lookup.
     result = resolveUnqualifiedIdentTypeRepr(resolution.withOptions(options),
-                                             silContext, identTR);
+                                             silContext, unqualIdentTR);
 
     if (result && result->isParameterPack() &&
         // Workaround to allow 'shape' type checking of SIL.
@@ -5362,7 +5363,8 @@ NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,
     auto diag =
         ctx.Diags.diagnose(repr->getLoc(), diag::each_non_pack, packReference);
     bool addEachFixitApplied = false;
-    if (auto *packIdent = dyn_cast<IdentTypeRepr>(repr->getPackType())) {
+    if (auto *packIdent =
+            dyn_cast<UnqualifiedIdentTypeRepr>(repr->getPackType())) {
       if (auto *packIdentBinding = packIdent->getBoundDecl()) {
         if (packIdentBinding->getLoc().isValid()) {
           diag.fixItInsert(packIdentBinding->getLoc(), "each ");
diff --git a/test/AutoDiff/Parse/differentiable_func_type.swift b/test/AutoDiff/Parse/differentiable_func_type.swift
@@ -14,10 +14,10 @@ let c: @differentiable(reverse) (Float, @noDerivative Float) -> Float // okay
 // CHECK-NEXT: (type_attributed attrs="@differentiable(reverse) "
 // CHECK-NEXT:  (type_function
 // CHECK-NEXT:    (type_tuple
-// CHECK-NEXT:      (type_ident id="Float" unbound)
+// CHECK-NEXT:      (type_unqualified_ident id="Float" unbound)
 // CHECK-NEXT:      (type_attributed attrs="@noDerivative "
-// CHECK-NEXT:        (type_ident id="Float" unbound))
-// CHECK-NEXT:    (type_ident id="Float" unbound))))
+// CHECK-NEXT:        (type_unqualified_ident id="Float" unbound))
+// CHECK-NEXT:    (type_unqualified_ident id="Float" unbound))))
 
 let d: @differentiable(reverse) (Float) throws -> Float // okay
 // CHECK: (pattern_named "d"
diff --git a/test/Frontend/dump-parse.swift b/test/Frontend/dump-parse.swift
@@ -114,7 +114,7 @@ struct SelfParam {
   // CHECK-NEXT:    (parameter "self")
   // CHECK-NEXT:    (parameter_list range=[{{.+}}])
   // CHECK-NEXT:    (result=type_optional
-  // CHECK-NEXT:      (type_ident id="SelfParam" unbound))
+  // CHECK-NEXT:      (type_unqualified_ident id="SelfParam" unbound))
   static func createOptional() -> SelfParam? {
 
     // CHECK-LABEL: (call_expr type="<null>"
@@ -127,6 +127,6 @@ struct SelfParam {
 // CHECK-LABEL: (func_decl range=[{{.+}}] "dumpMemberTypeRepr()"
 // CHECK-NEXT:    (parameter_list range=[{{.+}}])
 // CHECK-NEXT:    (result=type_member id="Element" unbound
-// CHECK-NEXT:      (type_ident id="Array" unbound
-// CHECK-NEXT:        (type_ident id="Bool" unbound))
+// CHECK-NEXT:      (type_unqualified_ident id="Array" unbound
+// CHECK-NEXT:        (type_unqualified_ident id="Bool" unbound))
 func dumpMemberTypeRepr() -> Array<Bool>.Element { true }
diff --git a/test/Frontend/module-alias-dump-ast.swift b/test/Frontend/module-alias-dump-ast.swift
@@ -16,7 +16,7 @@
 // CHECK-AST-NOT: bind="XLogging"
 // CHECK-AST-NOT: module<XLogging>
 // CHECK-AST-NOT: decl="XLogging"
-// CHECK-AST: type_ident id="XLogging" bind="AppleLogging"
+// CHECK-AST: type_unqualified_ident id="XLogging" bind="AppleLogging"
 // CHECK-AST: module<AppleLogging>
 // CHECK-AST: decl="AppleLogging"
 

Original file line number	Diff line number	Diff line change
`@@ -3297,7 +3297,9 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,`
`3297`	`3297`	`}`
`3298`	`3298`
`3299`	`3299`	`void visitDeclRefTypeRepr(DeclRefTypeRepr *T, StringRef label) {`
`3300`		`- printCommon(isa<IdentTypeRepr>(T) ? "type_ident" : "type_member", label);`
	`3300`	`+ printCommon(isa<UnqualifiedIdentTypeRepr>(T) ? "type_unqualified_ident"`
	`3301`	`+ : "type_member",`
	`3302`	`+ label);`
`3301`	`3303`
`3302`	`3304`	`printFieldQuoted(T->getNameRef(), "id", IdentifierColor);`
`3303`	`3305`	`if (T->isBound())`
Original file line number	Diff line number	Diff line change
`@@ -2270,7 +2270,7 @@ TypeExpr TypeExpr::createForSpecializedDecl(DeclRefTypeRepr ParentTR,`
`2270`	`2270`	`return nullptr;`
`2271`	`2271`	`}`
`2272`	`2272`
`2273`		`- if (isa<IdentTypeRepr>(ParentTR)) {`
	`2273`	`+ if (isa<UnqualifiedIdentTypeRepr>(ParentTR)) {`
`2274`	`2274`	`specializedTR = GenericIdentTypeRepr::create(`
`2275`	`2275`	`C, ParentTR->getNameLoc(), ParentTR->getNameRef(), Args, AngleLocs);`
`2276`	`2276`	`specializedTR->setValue(boundDecl, ParentTR->getDeclContext());`