[NFC] Introduce TypeRepr::isSimpleUnqualifiedIdentifier to simplify some code

Author: AnthonyLatsis

include/swift/AST/TypeRepr.h

@@ -195,6 +195,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.
+  bool isSimpleUnqualifiedIdentifier(Identifier identifier) const;
+
+  /// Whether this is a `SimpleIdentTypeRepr` matching the given string.
+  bool isSimpleUnqualifiedIdentifier(StringRef str) const;
+
   //*** Allocation Routines ************************************************/
 
   void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const;

lib/AST/ASTPrinter.cpp

@@ -4990,14 +4990,13 @@ void PrintAST::visitFuncDecl(FuncDecl *decl) {
         }
       }
 
-      if (!ResultTyLoc.getTypeRepr())
-        ResultTyLoc = TypeLoc::withoutLoc(ResultTy);
       // FIXME: Hacky way to workaround the fact that 'Self' as return
       // TypeRepr is not getting 'typechecked'. See
       // \c resolveTopLevelIdentTypeComponent function in TypeCheckType.cpp.
-      if (auto *simId = dyn_cast_or_null<SimpleIdentTypeRepr>(ResultTyLoc.getTypeRepr())) {
-        if (simId->getNameRef().isSimpleName(Ctx.Id_Self))
-          ResultTyLoc = TypeLoc::withoutLoc(ResultTy);
+      if (ResultTyLoc.getTypeRepr() &&
+          ResultTyLoc.getTypeRepr()->isSimpleUnqualifiedIdentifier(
+              Ctx.Id_Self)) {
+        ResultTyLoc = TypeLoc::withoutLoc(ResultTy);
       }
       Printer << " -> ";
 

lib/AST/Decl.cpp

@@ -2290,9 +2290,8 @@ static bool isDefaultInitializable(const TypeRepr *typeRepr, ASTContext &ctx) {
 
   // Also support the desugared 'Optional<T>' spelling.
   if (!ctx.isSwiftVersionAtLeast(5)) {
-    if (auto *identRepr = dyn_cast<SimpleIdentTypeRepr>(typeRepr)) {
-      if (identRepr->getNameRef().getBaseIdentifier() == ctx.Id_Void)
-        return true;
+    if (typeRepr->isSimpleUnqualifiedIdentifier(ctx.Id_Void)) {
+      return true;
     }
 
     if (auto *identRepr = dyn_cast<GenericIdentTypeRepr>(typeRepr)) {

lib/AST/NameLookup.cpp

@@ -1123,9 +1123,7 @@ SelfBounds SelfBoundsFromWhereClauseRequest::evaluate(
     // The left-hand side of the type constraint must be 'Self'.
     bool isSelfLHS = false;
     if (auto typeRepr = req.getSubjectRepr()) {
-      if (auto identTypeRepr = dyn_cast<SimpleIdentTypeRepr>(typeRepr))
-        isSelfLHS = (identTypeRepr->getNameRef().getBaseIdentifier() ==
-                     ctx.Id_Self);
+      isSelfLHS = typeRepr->isSimpleUnqualifiedIdentifier(ctx.Id_Self);
     }
     if (!isSelfLHS)
       continue;
@@ -2750,13 +2748,11 @@ resolveTypeDeclsToNominal(Evaluator &evaluator,
         // TypeRepr version: Builtin.AnyObject
         if (auto typeRepr = typealias->getUnderlyingTypeRepr()) {
           if (auto memberTR = dyn_cast<MemberTypeRepr>(typeRepr)) {
-            if (auto identRoot = dyn_cast<IdentTypeRepr>(memberTR->getRoot())) {
-              auto memberComps = memberTR->getMemberComponents();
-              if (memberComps.size() == 1 &&
-                  identRoot->getNameRef().isSimpleName("Builtin") &&
-                  memberComps.front()->getNameRef().isSimpleName("AnyObject")) {
-                anyObject = true;
-              }
+            auto memberComps = memberTR->getMemberComponents();
+            if (memberComps.size() == 1 &&
+                memberComps.front()->getNameRef().isSimpleName("AnyObject") &&
+                memberTR->getRoot()->isSimpleUnqualifiedIdentifier("Builtin")) {
+              anyObject = true;
             }
           }
         }

lib/AST/TypeRepr.cpp

@@ -119,6 +119,26 @@ TypeRepr *TypeRepr::getWithoutParens() const {
   return repr;
 }
 
+bool TypeRepr::isSimpleUnqualifiedIdentifier(Identifier identifier) const {
+  if (auto *identTR = dyn_cast<SimpleIdentTypeRepr>(this)) {
+    if (identTR->getNameRef().getBaseIdentifier() == identifier) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool TypeRepr::isSimpleUnqualifiedIdentifier(StringRef str) const {
+  if (auto *identTR = dyn_cast<SimpleIdentTypeRepr>(this)) {
+    if (identTR->getNameRef().getBaseIdentifier().is(str)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 SourceLoc TypeRepr::findAttrLoc(TypeAttrKind kind) const {
   auto typeRepr = this;
   while (auto attrTypeRepr = dyn_cast<AttributedTypeRepr>(typeRepr)) {

lib/Parse/ParseType.cpp

@@ -470,26 +470,16 @@ ParserResult<TypeRepr> Parser::parseTypeScalar(
     TupleTypeRepr *argsTyR = nullptr;
     if (auto *TTArgs = dyn_cast<TupleTypeRepr>(tyR)) {
       argsTyR = TTArgs;
-    } else {
-      bool isVoid = false;
-      if (const auto Void = dyn_cast<SimpleIdentTypeRepr>(tyR)) {
-        if (Void->getNameRef().isSimpleName(Context.Id_Void)) {
-          isVoid = true;
-        }
-      }
-
-      if (isVoid) {
-        diagnose(tyR->getStartLoc(), diag::function_type_no_parens)
+    } else if (tyR->isSimpleUnqualifiedIdentifier(Context.Id_Void)) {
+      diagnose(tyR->getStartLoc(), diag::function_type_no_parens)
           .fixItReplace(tyR->getStartLoc(), "()");
-        argsTyR = TupleTypeRepr::createEmpty(Context, tyR->getSourceRange());
-      } else {
-        diagnose(tyR->getStartLoc(), diag::function_type_no_parens)
+      argsTyR = TupleTypeRepr::createEmpty(Context, tyR->getSourceRange());
+    } else {
+      diagnose(tyR->getStartLoc(), diag::function_type_no_parens)
           .highlight(tyR->getSourceRange())
           .fixItInsert(tyR->getStartLoc(), "(")
           .fixItInsertAfter(tyR->getEndLoc(), ")");
-        argsTyR = TupleTypeRepr::create(Context, {tyR},
-                                        tyR->getSourceRange());
-      }
+      argsTyR = TupleTypeRepr::create(Context, {tyR}, tyR->getSourceRange());
     }
 
     // Parse substitutions for substituted SIL types.

lib/Sema/PreCheckExpr.cpp

@@ -1997,14 +1997,7 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
     if (!AE->isFolded()) return nullptr;
 
     auto diagnoseMissingParens = [](ASTContext &ctx, TypeRepr *tyR) {
-      bool isVoid = false;
-      if (const auto Void = dyn_cast<SimpleIdentTypeRepr>(tyR)) {
-        if (Void->getNameRef().isSimpleName(ctx.Id_Void)) {
-          isVoid = true;
-        }
-      }
-
-      if (isVoid) {
+      if (tyR->isSimpleUnqualifiedIdentifier(ctx.Id_Void)) {
         ctx.Diags.diagnose(tyR->getStartLoc(), diag::function_type_no_parens)
             .fixItReplace(tyR->getStartLoc(), "()");
       } else {

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1583,11 +1583,7 @@ static bool isModuleQualified(TypeRepr *repr, ModuleDecl *module) {
 
   // FIXME(ModQual): This needs to be updated once we have an explicit
   //                 module qualification syntax.
-  IdentTypeRepr *rootIdent = dyn_cast<IdentTypeRepr>(memberTy->getRoot());
-  if (!rootIdent) {
-    return false;
-  }
-  return rootIdent->getNameRef().isSimpleName(module->getName());
+  return memberTy->getRoot()->isSimpleUnqualifiedIdentifier(module->getName());
 }
 
 /// If the provided type is an AttributedTypeRepr, unwraps it and provides both

lib/Sema/TypeCheckType.cpp

@@ -1354,8 +1354,7 @@ static Type diagnoseUnknownType(TypeResolution resolution,
       return ErrorType::get(ctx);
     }
 
-    if (repr->getNameRef().isSimpleName(ctx.Id_Self) &&
-        !isa<GenericIdentTypeRepr>(repr)) {
+    if (repr->isSimpleUnqualifiedIdentifier(ctx.Id_Self)) {
       DeclContext *nominalDC = nullptr;
       NominalTypeDecl *nominal = nullptr;
       if ((nominalDC = dc->getInnermostTypeContext()) &&
@@ -3847,6 +3846,7 @@ TypeResolver::resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
 NeverNullType TypeResolver::resolveASTFunctionType(
     FunctionTypeRepr *repr, TypeResolutionOptions parentOptions,
     TypeAttrSet *attrs) {
+  auto &ctx = getASTContext();
 
   auto isolatedAttr = claim<IsolatedTypeAttr>(attrs);
 
@@ -3907,7 +3907,7 @@ NeverNullType TypeResolver::resolveASTFunctionType(
       diagnoseInvalid(
           repr, diffAttr->getAtLoc(),
           diag::differentiable_programming_attr_used_without_required_module,
-          diffAttr->getAttrName(), getASTContext().Id_Differentiation);
+          diffAttr->getAttrName(), ctx.Id_Differentiation);
     }
   }
 
@@ -3921,8 +3921,8 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     diagnose(repr->getLoc(), diag::isolated_parameter_duplicate_type)
         .warnUntilSwiftVersion(6);
 
-    if (getASTContext().LangOpts.isSwiftVersionAtLeast(6))
-      return ErrorType::get(getASTContext());
+    if (ctx.LangOpts.isSwiftVersionAtLeast(6))
+      return ErrorType::get(ctx);
     else
       repr->setWarned();
   }
@@ -3974,19 +3974,19 @@ NeverNullType TypeResolver::resolveASTFunctionType(
   if (auto patternParams = repr->getPatternGenericParams()) {
     diagnose(patternParams->getLAngleLoc(),
              diag::ast_subst_function_type);
-    return ErrorType::get(getASTContext());
+    return ErrorType::get(ctx);
   } else if (!repr->getInvocationSubstitutions().empty()) {
     diagnose(repr->getInvocationSubstitutions()[0]->getStartLoc(),
              diag::ast_subst_function_type);
-    return ErrorType::get(getASTContext());
+    return ErrorType::get(ctx);
   }
 
   llvm::Optional<SILInnerGenericContextRAII> innerGenericContext;
   if (auto *genericParams = repr->getGenericParams()) {
     if (!silContext) {
       diagnose(genericParams->getLAngleLoc(), diag::generic_function_type)
         .highlight(genericParams->getSourceRange());
-      return ErrorType::get(getASTContext());
+      return ErrorType::get(ctx);
     }
     innerGenericContext.emplace(silContext, genericParams);
   }
@@ -4000,7 +4000,7 @@ NeverNullType TypeResolver::resolveASTFunctionType(
   resultOptions.setContext(TypeResolverContext::FunctionResult);
   auto outputTy = resolveType(repr->getResultTypeRepr(), resultOptions);
   if (outputTy->hasError()) {
-    return ErrorType::get(getASTContext());
+    return ErrorType::get(ctx);
   }
 
   // If this is a function type without parens around the parameter list,
@@ -4011,13 +4011,10 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     // asking if they meant () -> ().
     auto args = repr->getArgsTypeRepr();
     if (args->getNumElements() == 1) {
-      if (const auto Void =
-          dyn_cast<SimpleIdentTypeRepr>(args->getElementType(0))) {
-        if (Void->getNameRef().isSimpleName(getASTContext().Id_Void)) {
-          diagnose(args->getStartLoc(), diag::paren_void_probably_void)
+      if (args->getElementType(0)->isSimpleUnqualifiedIdentifier(ctx.Id_Void)) {
+        diagnose(args->getStartLoc(), diag::paren_void_probably_void)
             .fixItReplace(args->getSourceRange(), "()");
-          repr->setWarned();
-        }
+        repr->setWarned();
       }
     }
   }