Remove non-essential uses of SimpleIdentTypeRepr & GenericIdentTypeRepr

Author: AnthonyLatsis

lib/AST/Attr.cpp

@@ -2757,8 +2757,9 @@ CustomAttr::destructureMacroRef() {
   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};
+    if (auto *base = dyn_cast<UnqualifiedIdentTypeRepr>(memType->getBase())) {
+      if (!base->hasGenericArgList())
+        return {base, memType};
     }
   }
   return {nullptr, nullptr};

lib/AST/Decl.cpp

@@ -2294,9 +2294,9 @@ static bool isDefaultInitializable(const TypeRepr *typeRepr, ASTContext &ctx) {
       return true;
     }
 
-    if (auto *identRepr = dyn_cast<GenericIdentTypeRepr>(typeRepr)) {
-      if (identRepr->getNameRef().getBaseIdentifier() == ctx.Id_Optional &&
-          identRepr->getNumGenericArgs() == 1)
+    if (auto *unqualIdentRepr = dyn_cast<UnqualifiedIdentTypeRepr>(typeRepr)) {
+      if (unqualIdentRepr->getNumGenericArgs() == 1 &&
+          unqualIdentRepr->getNameRef().getBaseIdentifier() == ctx.Id_Optional)
         return true;
     }
   }

lib/AST/NameLookup.cpp

@@ -3734,15 +3734,19 @@ CustomAttrNominalRequest::evaluate(Evaluator &evaluator,
   // If we found declarations that are associated types, look outside of
   // the current context to see if we can recover.
   if (declsAreAssociatedTypes(decls.first)) {
-    if (auto typeRepr = attr->getTypeRepr()) {
-      if (auto identTypeRepr = dyn_cast<SimpleIdentTypeRepr>(typeRepr)) {
+    if (auto *unqualIdentRepr =
+            dyn_cast_or_null<UnqualifiedIdentTypeRepr>(attr->getTypeRepr())) {
+      if (!unqualIdentRepr->hasGenericArgList()) {
         auto assocType = cast<AssociatedTypeDecl>(decls.first.front());
 
+        const auto name = unqualIdentRepr->getNameRef();
+        const auto nameLoc = unqualIdentRepr->getNameLoc();
+        const auto loc = unqualIdentRepr->getLoc();
+
         modulesFound.clear();
         anyObject = false;
         decls = directReferencesForUnqualifiedTypeLookup(
-            identTypeRepr->getNameRef(), identTypeRepr->getLoc(), dc,
-            LookupOuterResults::Included);
+            name, loc, dc, LookupOuterResults::Included);
         nominals = resolveTypeDeclsToNominal(evaluator, ctx, decls.first,
                                              ResolveToNominalOptions(),
                                              modulesFound, anyObject);
@@ -3751,22 +3755,19 @@ CustomAttrNominalRequest::evaluate(Evaluator &evaluator,
           if (nominal->getDeclContext()->isModuleScopeContext()) {
             // Complain, producing module qualification in a Fix-It.
             auto moduleName = nominal->getParentModule()->getName();
-            ctx.Diags.diagnose(typeRepr->getLoc(),
-                               diag::warn_property_wrapper_module_scope,
-                               identTypeRepr->getNameRef(),
-                               moduleName)
-              .fixItInsert(typeRepr->getLoc(),
-                           moduleName.str().str() + ".");
+            ctx.Diags
+                .diagnose(loc, diag::warn_property_wrapper_module_scope, name,
+                          moduleName)
+                .fixItInsert(loc, moduleName.str().str() + ".");
             ctx.Diags.diagnose(assocType, diag::kind_declname_declared_here,
                                assocType->getDescriptiveKind(),
                                assocType->getName());
 
             auto *baseTR = UnqualifiedIdentTypeRepr::create(
-                ctx, identTypeRepr->getNameLoc(), DeclNameRef(moduleName));
+                ctx, nameLoc, DeclNameRef(moduleName));
 
-            auto *newTE = new (ctx) TypeExpr(
-                MemberTypeRepr::create(ctx, baseTR, identTypeRepr->getNameLoc(),
-                                       identTypeRepr->getNameRef()));
+            auto *newTE = new (ctx)
+                TypeExpr(MemberTypeRepr::create(ctx, baseTR, nameLoc, name));
             attr->resetTypeInformation(newTE);
             return nominal;
           }

lib/Parse/ParseDecl.cpp

@@ -9886,9 +9886,8 @@ Parser::parseDeclInit(ParseDeclOptions Flags, DeclAttributes &Attributes) {
 
   if (auto *lifetimeTyR =
           dyn_cast_or_null<LifetimeDependentReturnTypeRepr>(FuncRetTy)) {
-    auto *identTyR = dyn_cast<SimpleIdentTypeRepr>(lifetimeTyR->getBase());
-    if (!identTyR ||
-        identTyR->getNameRef().getBaseIdentifier() != Context.Id_Self) {
+    if (!lifetimeTyR->getBase()->isSimpleUnqualifiedIdentifier(
+            Context.Id_Self)) {
       diagnose(FuncRetTy->getStartLoc(),
                diag::lifetime_dependence_invalid_init_return);
       return nullptr;

lib/Parse/ParseType.cpp

@@ -562,10 +562,11 @@ ParserResult<TypeRepr> Parser::parseTypeScalar(
 
       PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
         // Only unqualified identifiers can reference generic parameters.
-        if (auto *simpleIdentTR = dyn_cast<SimpleIdentTypeRepr>(T)) {
+        auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(T);
+        if (unqualIdentTR && !unqualIdentTR->hasGenericArgList()) {
           if (auto *genericParam = dyn_cast_or_null<GenericTypeParamDecl>(
-                  simpleIdentTR->getBoundDecl())) {
-            simpleIdentTR->overwriteNameRef(genericParam->createNameRef());
+                  unqualIdentTR->getBoundDecl())) {
+            unqualIdentTR->overwriteNameRef(genericParam->createNameRef());
           }
         }
         return Action::Continue();

lib/Sema/AssociatedTypeInference.cpp

@@ -1234,15 +1234,23 @@ class TypeReprCycleCheckWalker : private ASTWalker {
 
 private:
   PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
+    auto *declRefTyR = dyn_cast<DeclRefTypeRepr>(T);
+    if (!declRefTyR || declRefTyR->hasGenericArgList()) {
+      return Action::Continue();
+    }
+
+    auto *memberTyR = dyn_cast<MemberTypeRepr>(T);
+
     // If we're inferring `Foo`, don't look at a witness mentioning `Foo`.
-    if (auto *identTyR = dyn_cast<SimpleIdentTypeRepr>(T)) {
-      if (circularNames.count(identTyR->getNameRef().getBaseIdentifier()) > 0) {
+    if (!memberTyR) {
+      if (circularNames.count(declRefTyR->getNameRef().getBaseIdentifier()) >
+          0) {
         // If unqualified lookup can find a type with this name without looking
         // into protocol members, don't skip the witness, since this type might
         // be a candidate witness.
         auto desc = UnqualifiedLookupDescriptor(
-            identTyR->getNameRef(), witness->getDeclContext(),
-            identTyR->getLoc(), UnqualifiedLookupOptions());
+            declRefTyR->getNameRef(), witness->getDeclContext(),
+            declRefTyR->getLoc(), UnqualifiedLookupOptions());
 
         auto results =
             evaluateOrDefault(ctx.evaluator, UnqualifiedLookupRequest{desc}, {});
@@ -1259,23 +1267,18 @@ class TypeReprCycleCheckWalker : private ASTWalker {
     }
 
     // If we're inferring `Foo`, don't look at a witness mentioning `Self.Foo`.
-    auto *memberTyR = dyn_cast<MemberTypeRepr>(T);
-    if (!memberTyR || memberTyR->hasGenericArgList()) {
-      return Action::Continue();
-    }
-
     if (!memberTyR->getBase()->isSimpleUnqualifiedIdentifier(ctx.Id_Self)) {
       return Action::Continue();
     }
 
-    if (circularNames.count(memberTyR->getNameRef().getBaseIdentifier()) > 0) {
+    if (circularNames.count(declRefTyR->getNameRef().getBaseIdentifier()) > 0) {
       // But if qualified lookup can find a type with this name without looking
       // into protocol members, don't skip the witness, since this type might
       // be a candidate witness.
       SmallVector<ValueDecl *, 2> results;
       witness->getInnermostDeclContext()->lookupQualified(
           witness->getDeclContext()->getSelfTypeInContext(),
-          memberTyR->getNameRef(), SourceLoc(), NLOptions(), results);
+          declRefTyR->getNameRef(), SourceLoc(), NLOptions(), results);
 
       // Ok, resolving this member type would trigger associated type
       // inference recursively. We're going to skip this witness.

lib/Sema/CSDiagnostics.cpp

@@ -4696,7 +4696,8 @@ bool InvalidMemberRefOnExistential::diagnoseAsError() {
   while (auto *metatype = dyn_cast<MetatypeTypeRepr>(constraintRepr)) {
     // The generic equivalent of 'any P.Type' is '(some P).Type'
     constraintRepr = metatype->getBase()->getWithoutParens();
-    if (isa<SimpleIdentTypeRepr>(constraintRepr))
+    if (isa<UnqualifiedIdentTypeRepr>(constraintRepr) &&
+        !cast<UnqualifiedIdentTypeRepr>(constraintRepr)->hasGenericArgList())
       needsParens = !isa<TupleTypeRepr>(metatype->getBase());
   }
 

lib/Sema/TypeCheckAvailability.cpp

@@ -4055,11 +4055,11 @@ class TypeReprAvailabilityWalker : public ASTWalker {
 
     bool foundAnyIssues = false;
 
-    if (auto *GTR = dyn_cast<GenericIdentTypeRepr>(declRefTR)) {
+    if (declRefTR->hasGenericArgList()) {
       auto genericFlags = flags;
       genericFlags -= DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol;
 
-      for (auto *genericArg : GTR->getGenericArgs()) {
+      for (auto *genericArg : declRefTR->getGenericArgs()) {
         if (diagnoseTypeReprAvailability(genericArg, where, genericFlags))
           foundAnyIssues = true;
 

lib/Sema/TypeCheckType.cpp

@@ -2754,9 +2754,10 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
       // FIXME: Temporary hack to resolve an identifier type to one of the
       // generic parameters of the opaque return type. This should be subsumed
       // be proper name lookup, OF COURSE.
-      if (auto simpleIdent = dyn_cast<SimpleIdentTypeRepr>(
-              opaqueRepr->getBase())) {
-        Identifier name = simpleIdent->getNameRef().getBaseIdentifier();
+      auto *unqualIdentRepr =
+          dyn_cast<UnqualifiedIdentTypeRepr>(opaqueRepr->getBase());
+      if (unqualIdentRepr && !unqualIdentRepr->hasGenericArgList()) {
+        Identifier name = unqualIdentRepr->getNameRef().getBaseIdentifier();
         if (auto gpDecl = opaqueRepr->getGenericParams()
                 ->lookUpGenericParam(name)) {
           auto outerGenericSignature = opaqueDecl->getNamingDecl()
@@ -3833,12 +3834,12 @@ NeverNullType
 TypeResolver::resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
                                       unsigned ordinal,
                                       TypeResolutionOptions options) {
-  // The type repr should be a generic identifier type. We don't really use
-  // the identifier for anything, but we do resolve the generic arguments
-  // to instantiate the possibly-generic opaque type.
+  // The type representation should be an unqualified identifier. We don't
+  // really use the identifier for anything, but we do resolve any generic
+  // arguments to instantiate the possibly-generic opaque type.
   SmallVector<Type, 4> TypeArgsBuf;
-  if (auto generic = dyn_cast<GenericIdentTypeRepr>(repr)) {
-    for (auto argRepr : generic->getGenericArgs()) {
+  if (auto *unqualIdentRepr = dyn_cast<UnqualifiedIdentTypeRepr>(repr)) {
+    for (auto argRepr : unqualIdentRepr->getGenericArgs()) {
       auto argTy = resolveType(argRepr, options);
       // If we cannot resolve the generic parameter, propagate the error out.
       if (argTy->hasError()) {
@@ -3847,7 +3848,7 @@ TypeResolver::resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
       TypeArgsBuf.push_back(argTy);
     }
   }
-  
+
   // Use type reconstruction to summon the opaque type decl.
   Demangler demangle;
   auto definingDeclNode = demangle.demangleSymbol(mangledName);

lib/Sema/TypeChecker.cpp

@@ -490,10 +490,11 @@ namespace {
 
     PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
       // Only unqualified identifiers can reference generic parameters.
-      if (auto *simpleIdentTR = dyn_cast<SimpleIdentTypeRepr>(T)) {
-        auto name = simpleIdentTR->getNameRef().getBaseIdentifier();
+      auto *unqualIdentTR = dyn_cast<UnqualifiedIdentTypeRepr>(T);
+      if (unqualIdentTR && !unqualIdentTR->hasGenericArgList()) {
+        auto name = unqualIdentTR->getNameRef().getBaseIdentifier();
         if (auto *paramDecl = params->lookUpGenericParam(name)) {
-          simpleIdentTR->setValue(paramDecl, dc);
+          unqualIdentTR->setValue(paramDecl, dc);
         }
       }