Merge pull request #11909 from slavapestov/divorce-clang-importer-from-sema-part-6

ClangImporter: Don't record redundant inheritance clause entries

Author: slavapestov

lib/AST/ASTPrinter.cpp

@@ -594,15 +594,12 @@ class PrintAST : public ASTVisitor<PrintAST> {
                     bool openBracket = true, bool closeBracket = true);
   void printNominalDeclGenericParams(NominalTypeDecl *decl);
   void printNominalDeclGenericRequirements(NominalTypeDecl *decl);
-  void printInherited(const Decl *decl,
-                      ArrayRef<TypeLoc> inherited,
-                      ArrayRef<ProtocolDecl *> protos,
-                      Type superclass = {});
-
-  void printInherited(const NominalTypeDecl *decl);
-  void printInherited(const EnumDecl *D);
-  void printInherited(const ExtensionDecl *decl);
+  void printInherited(const Decl *decl, ArrayRef<TypeLoc> inherited);
+
+  void printInherited(const NominalTypeDecl *D);
+  void printInherited(const ExtensionDecl *D);
   void printInherited(const GenericTypeParamDecl *D);
+  void printInherited(const AssociatedTypeDecl *D);
 
   void printEnumElement(EnumElementDecl *elt);
 
@@ -1659,93 +1656,55 @@ void PrintAST::printNominalDeclGenericRequirements(NominalTypeDecl *decl) {
       printGenericSignature(GenericSig, PrintRequirements | InnermostOnly);
 }
 
-void PrintAST::printInherited(const Decl *decl,
-                              ArrayRef<TypeLoc> inherited,
-                              ArrayRef<ProtocolDecl *> protos,
-                              Type superclass) {
-  if (inherited.empty() && superclass.isNull()) {
-    if (protos.empty())
-      return;
-  }
-
-  if (inherited.empty()) {
-    bool PrintedColon = false;
-    bool PrintedInherited = false;
-
-    if (superclass) {
-      bool ShouldPrintSuper = true;
-      if (auto NTD = superclass->getAnyNominal()) {
-        ShouldPrintSuper = shouldPrint(NTD);
-      }
-      if (ShouldPrintSuper) {
-        Printer << " : ";
-        superclass.print(Printer, Options);
-        PrintedInherited = true;
-      }
+void PrintAST::printInherited(const Decl *decl, ArrayRef<TypeLoc> inherited) {
+  SmallVector<TypeLoc, 6> TypesToPrint;
+  for (auto TL : inherited) {
+    if (auto Ty = TL.getType()) {
+      if (auto NTD = Ty->getAnyNominal())
+        if (!shouldPrint(NTD))
+          continue;
     }
+    TypesToPrint.push_back(TL);
+  }
 
-    for (auto Proto : protos) {
-      if (!shouldPrint(Proto))
+  auto &ctx = decl->getASTContext();
+  for (auto attr : decl->getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
+    if (auto *proto = ctx.getProtocol(attr->getProtocolKind())) {
+      if (!shouldPrint(proto))
         continue;
-      if (auto Enum = dyn_cast<EnumDecl>(decl)) {
-        // Conformance to RawRepresentable is implied by having a raw type.
-        if (Enum->hasRawType()
-            && Proto->isSpecificProtocol(KnownProtocolKind::RawRepresentable))
-          continue;
-        // Conformance to Equatable and Hashable is implied by being a "simple"
-        // no-payload enum with cases.
-        if (Enum->hasCases()
-            && Enum->hasOnlyCasesWithoutAssociatedValues()
-            && (Proto->isSpecificProtocol(KnownProtocolKind::Equatable)
-                || Proto->isSpecificProtocol(KnownProtocolKind::Hashable)))
-          continue;
-      }
-
-      if (PrintedInherited)
-        Printer << ", ";
-      else if (!PrintedColon)
-        Printer << " : ";
-      Proto->getDeclaredType()->print(Printer, Options);
-      PrintedInherited = true;
-      PrintedColon = true;
-    }
-  } else {
-    SmallVector<TypeLoc, 6> TypesToPrint;
-    for (auto TL : inherited) {
-      if (auto Ty = TL.getType()) {
-        if (auto NTD = Ty->getAnyNominal())
-          if (!shouldPrint(NTD))
-            continue;
-      }
-      TypesToPrint.push_back(TL);
+      if (attr->getProtocolKind() == KnownProtocolKind::RawRepresentable &&
+          isa<EnumDecl>(decl) &&
+          cast<EnumDecl>(decl)->hasRawType())
+        continue;
+      TypesToPrint.push_back(TypeLoc::withoutLoc(proto->getDeclaredType()));
     }
-    if (TypesToPrint.empty())
-      return;
+  }
+  if (TypesToPrint.empty())
+    return;
 
-    Printer << " : ";
+  Printer << " : ";
 
-    interleave(TypesToPrint, [&](TypeLoc TL) {
-      printTypeLoc(TL);
-    }, [&]() {
-      Printer << ", ";
-    });
-  }
+  interleave(TypesToPrint, [&](TypeLoc TL) {
+    printTypeLoc(TL);
+  }, [&]() {
+    Printer << ", ";
+  });
 }
 
-void PrintAST::printInherited(const NominalTypeDecl *decl) {
-  printInherited(decl, decl->getInherited(), { }, nullptr);
+void PrintAST::printInherited(const NominalTypeDecl *D) {
+  printInherited(D, D->getInherited());
 }
 
-void PrintAST::printInherited(const EnumDecl *decl) {
-  printInherited(decl, decl->getInherited(), { });
+void PrintAST::printInherited(const ExtensionDecl *D) {
+  printInherited(D, D->getInherited());
 }
 
-void PrintAST::printInherited(const ExtensionDecl *decl) {
-  printInherited(decl, decl->getInherited(), { });
+void PrintAST::printInherited(const GenericTypeParamDecl *D) {
+  printInherited(D, D->getInherited());
 }
 
-void PrintAST::printInherited(const GenericTypeParamDecl *D) {
-  printInherited(D, D->getInherited(), { });
+void PrintAST::printInherited(const AssociatedTypeDecl *D) {
+  printInherited(D, D->getInherited());
 }
 
 static void getModuleEntities(const clang::Module *ClangMod,
@@ -2022,7 +1981,7 @@ void PrintAST::visitGenericTypeParamDecl(GenericTypeParamDecl *decl) {
     Printer.printName(decl->getName(), PrintNameContext::GenericParameter);
   });
 
-  printInherited(decl, decl->getInherited(), { });
+  printInherited(decl);
 }
 
 void PrintAST::visitAssociatedTypeDecl(AssociatedTypeDecl *decl) {
@@ -2039,7 +1998,7 @@ void PrintAST::visitAssociatedTypeDecl(AssociatedTypeDecl *decl) {
   if (proto->isRequirementSignatureComputed()) {
     printInheritedFromRequirementSignature(proto, decl);
   } else {
-    printInherited(decl, decl->getInherited(), { });
+    printInherited(decl);
   }
 
   if (!decl->getDefaultDefinitionLoc().isNull()) {

lib/AST/ProtocolConformance.cpp

@@ -896,37 +896,37 @@ void NominalTypeDecl::prepareConformanceTable() const {
     return;
   }
 
-  // Add any synthesized conformances.
+  SmallPtrSet<ProtocolDecl *, 2> protocols;
+
+  auto addSynthesized = [&](KnownProtocolKind kind) {
+    if (auto *proto = getASTContext().getProtocol(kind)) {
+      if (protocols.count(proto) == 0) {
+        ConformanceTable->addSynthesizedConformance(mutableThis, proto);
+        protocols.insert(proto);
+      }
+    }
+  };
+
+  // Add protocols for any synthesized protocol attributes.
+  for (auto attr : getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
+    addSynthesized(attr->getProtocolKind());
+  }
+
+  // Add any implicit conformances.
   if (auto theEnum = dyn_cast<EnumDecl>(mutableThis)) {
     if (theEnum->hasCases() && theEnum->hasOnlyCasesWithoutAssociatedValues()) {
       // Simple enumerations conform to Equatable.
-      if (auto equatable = ctx.getProtocol(KnownProtocolKind::Equatable)) {
-        ConformanceTable->addSynthesizedConformance(mutableThis, equatable);
-      }
+      addSynthesized(KnownProtocolKind::Equatable);
 
       // Simple enumerations conform to Hashable.
-      if (auto hashable = getASTContext().getProtocol(
-                            KnownProtocolKind::Hashable)) {
-        ConformanceTable->addSynthesizedConformance(mutableThis, hashable);
-      }
+      addSynthesized(KnownProtocolKind::Hashable);
     }
 
     // Enumerations with a raw type conform to RawRepresentable.
     if (resolver)
       resolver->resolveRawType(theEnum);
     if (theEnum->hasRawType()) {
-      if (auto rawRepresentable =
-            ctx.getProtocol(KnownProtocolKind::RawRepresentable)) {
-        ConformanceTable->addSynthesizedConformance(mutableThis,
-                                                    rawRepresentable);
-      }
-    }
-  }
-
-  // Add protocols for any synthesized protocol attributes.
-  for (auto attr : getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
-    if (auto proto = getASTContext().getProtocol(attr->getProtocolKind())) {
-      ConformanceTable->addSynthesizedConformance(mutableThis, proto);
+      addSynthesized(KnownProtocolKind::RawRepresentable);
     }
   }
 }