ClangImporter: Sink getEffectiveClangNode() down from IDE to the importer and clean up related code

Author: slavapestov

include/swift/ClangImporter/ClangImporter.h

@@ -215,8 +215,9 @@ class ClangImporter final : public ClangModuleLoader {
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) override;
 
-  /// Look up the nested 'Code' enum for an error wrapper struct.
-  EnumDecl *lookupErrorCodeEnum(const StructDecl *errorWrapper) const;
+  /// Just like Decl::getClangNode() except we look through to the 'Code'
+  /// enum of an error wrapper struct.
+  ClangNode getEffectiveClangNode(const Decl *decl) const;
 
   /// Look for textually included declarations from the bridging header.
   ///

lib/ClangImporter/ClangImporter.cpp

@@ -2167,26 +2167,9 @@ static bool isVisibleFromModule(const ClangModuleUnit *ModuleFilter,
   if (!Wrapper)
     return false;
 
-  auto ClangNode = VD->getClangNode();
-  if (!ClangNode) {
-    // If we synthesized a ValueDecl, it won't have a Clang node. Find the
-    // associated declaration that /does/ have a Clang node, and use that.
-    auto *SynthesizedTypeAttr =
-        VD->getAttrs().getAttribute<ClangImporterSynthesizedTypeAttr>();
-    assert(SynthesizedTypeAttr);
-
-    switch (SynthesizedTypeAttr->getKind()) {
-    case ClangImporterSynthesizedTypeAttr::Kind::NSErrorWrapper:
-    case ClangImporterSynthesizedTypeAttr::Kind::NSErrorWrapperAnon: {
-      ASTContext &Ctx = ContainingUnit->getASTContext();
-      auto *Importer = static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
-      auto WrapperStruct = cast<StructDecl>(VD);
-      auto *CodeEnum = Importer->lookupErrorCodeEnum(WrapperStruct);
-      ClangNode = CodeEnum->getClangNode();
-      break;
-    }
-    }
-  }
+  ASTContext &Ctx = ContainingUnit->getASTContext();
+  auto *Importer = static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
+  auto ClangNode = Importer->getEffectiveClangNode(VD);
 
   // Macros can be "redeclared" by putting an equivalent definition in two
   // different modules. (We don't actually check the equivalence.)
@@ -2493,8 +2476,19 @@ void ClangImporter::lookupValue(DeclName name, VisibleDeclConsumer &consumer) {
   });
 }
 
-EnumDecl *ClangImporter::lookupErrorCodeEnum(const StructDecl *errorWrapper) const {
-  return Impl.lookupErrorCodeEnum(errorWrapper);
+ClangNode ClangImporter::getEffectiveClangNode(const Decl *decl) const {
+  // Directly...
+  if (auto clangNode = decl->getClangNode())
+    return clangNode;
+
+  // Or via the nested "Code" enum.
+  if (auto *errorWrapper = dyn_cast<StructDecl>(decl)) {
+    if (auto *code = Impl.lookupErrorCodeEnum(errorWrapper))
+      if (auto clangNode = code->getClangNode())
+        return clangNode;
+  }
+
+  return ClangNode();
 }
 
 void ClangImporter::lookupTypeDecl(

lib/ClangImporter/ImportDecl.cpp

@@ -2942,7 +2942,7 @@ namespace {
                          AccessLevel::Public, loc, SourceLoc(),
                          C.Id_ErrorType, loc,
                          /*genericparams=*/nullptr, enumDecl);
-          alias->setUnderlyingType(Impl.getSugaredTypeReference(errorWrapper));
+          alias->setUnderlyingType(errorWrapper->getDeclaredInterfaceType());
           enumDecl->addMember(alias);
 
           // Add the 'Code' enum to the error wrapper.
@@ -5161,7 +5161,7 @@ namespace {
           typealias->setGenericParams(GTD->getGenericParams()->clone(typealias));
       }
 
-      typealias->setUnderlyingType(Impl.getSugaredTypeReference(typeDecl));
+      typealias->setUnderlyingType(typeDecl->getDeclaredInterfaceType());
       return typealias;
     }
 
@@ -5393,7 +5393,7 @@ Decl *SwiftDeclConverter::importCompatibilityTypeAlias(
       alias->setGenericParams(GTD->getGenericParams()->clone(alias));
   }
 
-  alias->setUnderlyingType(Impl.getSugaredTypeReference(typeDecl));
+  alias->setUnderlyingType(typeDecl->getDeclaredInterfaceType());
 
   // Record that this is the official version of this declaration.
   Impl.ImportedDecls[{decl->getCanonicalDecl(), getVersion()}] = alias;

lib/ClangImporter/ImportType.cpp

@@ -819,33 +819,17 @@ namespace {
       return getAdjustedTypeDeclReferenceType(decl);
     }
 
-    /// Retrieve the 'Code' type for a bridged NSError, or nullptr if
-    /// this is not a bridged NSError type.
-    TypeDecl *getBridgedNSErrorCode(TypeDecl *decl) {
-      auto errorWrapper = dyn_cast<StructDecl>(decl);
-      if (!errorWrapper) return nullptr;
-
-      const DeclAttributes &allAttrs = errorWrapper->getAttrs();
-      for (auto attr : allAttrs.getAttributes<SynthesizedProtocolAttr>()) {
-        if (attr->getProtocolKind() ==
-            KnownProtocolKind::BridgedStoredNSError) {
-          return Impl.lookupErrorCodeEnum(errorWrapper);
-        }
-      }
-
-      return nullptr;
-    }
-
     /// Retrieve the adjusted type of a reference to the given type declaration.
-    Type getAdjustedTypeDeclReferenceType(TypeDecl *type) {
+    Type getAdjustedTypeDeclReferenceType(TypeDecl *decl) {
       // If the imported declaration is a bridged NSError, dig out
       // the Code nested type. References to the enum type from C
       // code need to map to the code type (which is ABI compatible with C),
       // and the bridged error type is used elsewhere.
-      if (auto codeDecl = getBridgedNSErrorCode(type))
-        return Impl.getSugaredTypeReference(codeDecl);
+      if (auto *structDecl = dyn_cast<StructDecl>(decl))
+        if (auto *codeEnum = Impl.lookupErrorCodeEnum(structDecl))
+          return codeEnum->getDeclaredInterfaceType();
 
-      return Impl.getSugaredTypeReference(type);
+      return decl->getDeclaredInterfaceType();
     }
 
     ImportResult VisitEnumType(const clang::EnumType *type) {
@@ -2514,23 +2498,6 @@ static Type getNamedProtocolType(ClangImporter::Implementation &impl,
   return Type();
 }
 
-Type ClangImporter::Implementation::getSugaredTypeReference(TypeDecl *type) {
-  // For typealiases, build a sugared type.
-  if (auto typealias = dyn_cast<TypeAliasDecl>(type)) {
-    // If this typealias is nested, retrieve the parent type.
-    Type parentType;
-    if (auto nominal = typealias->getDeclContext()->getSelfNominalTypeDecl()) {
-      if (!nominal->getGenericSignature())
-        parentType = nominal->getDeclaredInterfaceType();
-    }
-
-    return TypeAliasType::get(typealias, parentType, SubstitutionMap(),
-                              typealias->getUnderlyingTypeLoc().getType());
-  }
-
-  return type->getDeclaredInterfaceType();
-}
-
 Type ClangImporter::Implementation::getNSCopyingType() {
   return getNamedProtocolType(*this, "NSCopying");
 }

lib/ClangImporter/ImporterImpl.h

@@ -950,9 +950,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// Retrieve the NSCopying protocol type.
   Type getNSCopyingType();
 
-  /// Retrieve a sugared referenece to the given (imported) type.
-  Type getSugaredTypeReference(TypeDecl *type);
-
   /// Determines whether the given type matches an implicit type
   /// bound of "Hashable", which is used to validate NSDictionary/NSSet.
   bool matchesHashableBound(Type type);

lib/IDE/Utils.cpp

@@ -954,21 +954,9 @@ bool swift::ide::isFromClang(const Decl *D) {
 }
 
 ClangNode swift::ide::getEffectiveClangNode(const Decl *decl) {
-  // Directly...
-  if (auto clangNode = decl->getClangNode())
-    return clangNode;
-
-  // Or via the nested "Code" enum.
-  if (auto *errorWrapper = dyn_cast<StructDecl>(decl)) {
-    auto &ctx = errorWrapper->getASTContext();
-    auto *importer = static_cast<ClangImporter *>(ctx.getClangModuleLoader());
-    if (importer)
-      if (auto *code = importer->lookupErrorCodeEnum(errorWrapper))
-        if (auto clangDecl = code->getClangDecl())
-          return clangDecl;
-  }
-
-  return ClangNode();
+  auto &ctx = decl->getASTContext();
+  auto *importer = static_cast<ClangImporter *>(ctx.getClangModuleLoader());
+  return importer->getEffectiveClangNode(decl);
 }
 
 /// Retrieve the Clang node for the given extension, if it has one.