Merge pull request #80074 from dylansturg/objc_enum_refs

The Error enum synthesized declarations, e.g. the struct and its static accessors, should generally appear to be identical to the underlying Clang definitions. There are some specific use cases where the synthesized declarations are necessary though.

I've added an option for USR generation to override the Clang node and emit the USR of the synthesized Swift declaration. This is used by SwiftDocSupport so that the USRs of the synthesized declarations are emitted.

Fixes 79912

Author: dylansturg

include/swift/AST/ClangModuleLoader.h

@@ -33,6 +33,7 @@ class SourceLocation;
 namespace swift {
 
 class ClangInheritanceInfo;
+class ClangNode;
 class ConcreteDeclRef;
 class Decl;
 class FuncDecl;
@@ -321,6 +322,10 @@ class ClangModuleLoader : public ModuleLoader {
   getTypeDefForCXXCFOptionsDefinition(const clang::Decl *candidateDecl) = 0;
 
   virtual SourceLoc importSourceLocation(clang::SourceLocation loc) = 0;
+
+  /// Just like Decl::getClangNode() except we look through to the 'Code'
+  /// enum of an error wrapper struct.
+  virtual ClangNode getEffectiveClangNode(const Decl *decl) const = 0;
 };
 
 /// Describes a C++ template instantiation error.

include/swift/AST/TypeCheckRequests.h

@@ -735,20 +735,45 @@ class RequirementRequest :
   bool isCached() const;
 };
 
+struct USRGenerationOptions {
+  /// @brief Whether to emit USRs using the Swift declaration when it is
+  /// synthesized from a Clang based declaration. Useful in cases where Swift
+  /// declarations are synthesized from Clang nodes but the caller actually
+  /// wants the USR of the Swift declaration.
+  bool distinguishSynthesizedDecls;
+
+  friend llvm::hash_code hash_value(const USRGenerationOptions &options) {
+    return llvm::hash_value(options.distinguishSynthesizedDecls);
+  }
+
+  friend bool operator==(const USRGenerationOptions &lhs,
+                         const USRGenerationOptions &rhs) {
+    return lhs.distinguishSynthesizedDecls == rhs.distinguishSynthesizedDecls;
+  }
+
+  friend bool operator!=(const USRGenerationOptions &lhs,
+                         const USRGenerationOptions &rhs) {
+    return !(lhs == rhs);
+  }
+};
+
+void simple_display(llvm::raw_ostream &out,
+                    const USRGenerationOptions &options);
+
 /// Generate the USR for the given declaration.
-class USRGenerationRequest :
-    public SimpleRequest<USRGenerationRequest,
-                         std::string(const ValueDecl*),
-                         RequestFlags::Cached>
-{
+class USRGenerationRequest
+    : public SimpleRequest<USRGenerationRequest,
+                           std::string(const ValueDecl *, USRGenerationOptions),
+                           RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  std::string evaluate(Evaluator &eval, const ValueDecl *d) const;
+  std::string evaluate(Evaluator &eval, const ValueDecl *d,
+                       USRGenerationOptions options) const;
 
 public:
   // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -364,7 +364,8 @@ SWIFT_REQUEST(TypeChecker, TypeCheckASTNodeAtLocRequest,
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, UnderlyingTypeRequest, Type(TypeAliasDecl *),
               SeparatelyCached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, USRGenerationRequest, std::string(const ValueDecl *),
+SWIFT_REQUEST(TypeChecker, USRGenerationRequest,
+              std::string(const ValueDecl *, USRGenerationOptions),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsABICompatibleOverrideRequest,
               bool(ValueDecl *), Cached, NoLocationInfo)

include/swift/AST/USRGeneration.h

@@ -43,8 +43,11 @@ bool printTypeUSR(Type Ty, raw_ostream &OS);
 bool printDeclTypeUSR(const ValueDecl *D, raw_ostream &OS);
 
 /// Prints out the USR for the given ValueDecl.
+/// @param distinguishSynthesizedDecls Whether to use the USR of the
+/// synthesized declaration instead of the USR of the underlying Clang USR.
 /// \returns true if it failed, false on success.
-bool printValueDeclUSR(const ValueDecl *D, raw_ostream &OS);
+bool printValueDeclUSR(const ValueDecl *D, raw_ostream &OS,
+                       bool distinguishSynthesizedDecls = false);
 
 /// Prints out the USR for the given ModuleEntity.
 /// In case module aliasing is used, it prints the real module name. For example,
@@ -64,8 +67,11 @@ bool printAccessorUSR(const AbstractStorageDecl *D, AccessorKind AccKind,
 bool printExtensionUSR(const ExtensionDecl *ED, raw_ostream &OS);
 
 /// Prints out the USR for the given Decl.
+/// @param distinguishSynthesizedDecls Whether to use the USR of the
+/// synthesized declaration instead of the USR of the underlying Clang USR.
 /// \returns true if it failed, false on success.
-bool printDeclUSR(const Decl *D, raw_ostream &OS);
+bool printDeclUSR(const Decl *D, raw_ostream &OS,
+                  bool distinguishSynthesizedDecls = false);
 
 /// Demangle a mangle-name-based USR to a human readable name.
 std::string demangleUSR(StringRef mangled);

include/swift/ClangImporter/ClangImporter.h

@@ -330,7 +330,7 @@ class ClangImporter final : public ClangModuleLoader {
 
   /// Just like Decl::getClangNode() except we look through to the 'Code'
   /// enum of an error wrapper struct.
-  ClangNode getEffectiveClangNode(const Decl *decl) const;
+  ClangNode getEffectiveClangNode(const Decl *decl) const override;
 
   /// Look for textually included declarations from the bridging header.
   ///

lib/AST/USRGeneration.cpp

@@ -10,25 +10,25 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/AST/USRGeneration.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTMangler.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/GenericParamList.h"
 #include "swift/AST/Module.h"
-#include "swift/AST/USRGeneration.h"
-#include "swift/AST/ASTMangler.h"
 #include "swift/AST/SwiftNameTranslation.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/USRGeneration.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Demangling/Demangler.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/Index/USRGeneration.h"
 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Lex/Preprocessor.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
 using namespace ide;
@@ -170,9 +170,15 @@ static bool shouldUseObjCUSR(const Decl *D) {
   return false;
 }
 
+void swift::simple_display(llvm::raw_ostream &out,
+                           const USRGenerationOptions &options) {
+  out << "USRGenerationOptions (distinguishSynthesizedDecls: "
+      << options.distinguishSynthesizedDecls << ")";
+}
+
 std::string
-swift::USRGenerationRequest::evaluate(Evaluator &evaluator,
-                                      const ValueDecl *D) const {
+swift::USRGenerationRequest::evaluate(Evaluator &evaluator, const ValueDecl *D,
+                                      USRGenerationOptions options) const {
   if (auto *VD = dyn_cast<VarDecl>(D))
     D = VD->getCanonicalVarDecl();
 
@@ -184,8 +190,9 @@ swift::USRGenerationRequest::evaluate(Evaluator &evaluator,
   if (isa<ModuleDecl>(D))
     return std::string(); // Ignore.
 
-  auto interpretAsClangNode = [](const ValueDecl *D)->ClangNode {
-    ClangNode ClangN = D->getClangNode();
+  auto interpretAsClangNode = [&options](const ValueDecl *D) -> ClangNode {
+    auto *importer = D->getASTContext().getClangModuleLoader();
+    ClangNode ClangN = importer->getEffectiveClangNode(D);
     if (auto ClangD = ClangN.getAsDecl()) {
       // NSErrorDomain causes the clang enum to be imported like this:
       //
@@ -203,12 +210,19 @@ swift::USRGenerationRequest::evaluate(Evaluator &evaluator,
       // But we want unique USRs for the above symbols, so use the clang USR
       // for the enum cases, and the Swift USR for the vars.
       //
+      if (!options.distinguishSynthesizedDecls) {
+        return ClangN;
+      }
       if (auto *ClangEnumConst = dyn_cast<clang::EnumConstantDecl>(ClangD)) {
-        if (auto *ClangEnum = dyn_cast<clang::EnumDecl>(ClangEnumConst->getDeclContext())) {
+        if (auto *ClangEnum =
+                dyn_cast<clang::EnumDecl>(ClangEnumConst->getDeclContext())) {
           if (ClangEnum->hasAttr<clang::NSErrorDomainAttr>() && isa<VarDecl>(D))
             return ClangNode();
         }
       }
+      if (D->getAttrs().hasAttribute<ClangImporterSynthesizedTypeAttr>()) {
+        return ClangNode();
+      }
     }
     return ClangN;
   };
@@ -292,10 +306,11 @@ bool ide::printModuleUSR(ModuleEntity Mod, raw_ostream &OS) {
   }
 }
 
-bool ide::printValueDeclUSR(const ValueDecl *D, raw_ostream &OS) {
-  auto result = evaluateOrDefault(D->getASTContext().evaluator,
-                                  USRGenerationRequest { D },
-                                  std::string());
+bool ide::printValueDeclUSR(const ValueDecl *D, raw_ostream &OS,
+                            bool distinguishSynthesizedDecls) {
+  auto result = evaluateOrDefault(
+      D->getASTContext().evaluator,
+      USRGenerationRequest{D, {distinguishSynthesizedDecls}}, std::string());
   if (result.empty())
     return true;
   OS << result;
@@ -354,9 +369,10 @@ bool ide::printExtensionUSR(const ExtensionDecl *ED, raw_ostream &OS) {
   return true;
 }
 
-bool ide::printDeclUSR(const Decl *D, raw_ostream &OS) {
+bool ide::printDeclUSR(const Decl *D, raw_ostream &OS,
+                       bool distinguishSynthesizedDecls) {
   if (auto *VD = dyn_cast<ValueDecl>(D)) {
-    if (ide::printValueDeclUSR(VD, OS)) {
+    if (ide::printValueDeclUSR(VD, OS, distinguishSynthesizedDecls)) {
       return true;
     }
   } else if (auto *ED = dyn_cast<ExtensionDecl>(D)) {

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -472,7 +472,7 @@ void ClangSyntaxPrinter::printSymbolUSRAttribute(const ValueDecl *D) const {
     return;
   }
   auto result = evaluateOrDefault(D->getASTContext().evaluator,
-                                  USRGenerationRequest{D}, std::string());
+                                  USRGenerationRequest{D, {}}, std::string());
   if (result.empty())
     return;
   os << " SWIFT_SYMBOL(\"" << result << "\")";

lib/SymbolGraphGen/Symbol.cpp

@@ -852,7 +852,7 @@ void Symbol::printPath(llvm::raw_ostream &OS) const {
 
 void Symbol::getUSR(SmallVectorImpl<char> &USR) const {
   llvm::raw_svector_ostream OS(USR);
-  ide::printDeclUSR(D, OS);
+  ide::printDeclUSR(D, OS, /*distinguishSynthesizedDecls*/ true);
   if (SynthesizedBaseTypeDecl) {
     OS << "::SYNTHESIZED::";
     ide::printDeclUSR(SynthesizedBaseTypeDecl, OS);

test/Index/index_imported_objc.swift

@@ -21,6 +21,18 @@
 @property int categoryAddedProperty;
 @end
 
+extern NSErrorDomain const TestErrorDomain;
+
+typedef NS_ERROR_ENUM(TestErrorDomain, TestError){
+    TestErrorFoo = 0,
+    TestErrorBar = 1,
+};
+
+typedef NS_ENUM(NSInteger, ErrCategory) {
+  ErrCategoryA = 0,
+  ErrCategoryB = 1,
+};
+
 //--- module.modulemap
 module objc_decls {
   header "objc_decls.h"
@@ -48,3 +60,34 @@ class SubObjCClass: ObjCClass {
   // CHECK-NEXT: RelOver | instance-method/Swift | protocolAddedMethod() | c:objc(pl)MemberAdding(im)protocolAddedMethod
   // CHECK-NEXT: RelChild | class/Swift | SubObjCClass | c:@M@swift_ide_test@objc(cs)SubObjCClass
 }
+func testEnumIndex() {
+  let _: TestError.Code = .bar
+  // CHECK: [[@LINE-1]]:10 | struct/Swift | TestError | c:@E@TestError | Ref | rel: 0
+  // CHECK: [[@LINE-2]]:20 | enum/Swift | Code | c:@E@TestError | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-3]]:28 | enumerator/Swift | bar | c:@E@TestError@TestErrorBar | Ref,RelCont | rel: 1
+  let e = TestError.foo
+  // CHECK: [[@LINE-1]]:11 | struct/Swift | TestError | c:@E@TestError | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-2]]:21 | static-property/Swift | foo | c:@E@TestError@TestErrorFoo | Ref,Read,RelCont | rel: 1
+  switch e {
+    case TestError.foo: break
+    // CHECK: [[@LINE-1]]:10 | struct/Swift | TestError | c:@E@TestError | Ref,RelCont | rel: 1
+    // CHECK: [[@LINE-2]]:20 | static-property/Swift | foo | c:@E@TestError@TestErrorFoo | Ref,Read,RelCont | rel: 1
+    case .bar: break
+    // CHECK: [[@LINE-1]]:11 | enumerator/Swift | bar | c:@E@TestError@TestErrorBar | Ref,RelCont | rel: 1
+    default: break
+  }
+  let _ = ErrCategory.B
+  // CHECK: [[@LINE-1]]:11 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-2]]:23 | enumerator/Swift | B | c:@E@ErrCategory@ErrCategoryB | Ref,RelCont | rel: 1
+  let c: ErrCategory = .A
+  // CHECK: [[@LINE-1]]:10 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-2]]:25 | enumerator/Swift | A | c:@E@ErrCategory@ErrCategoryA | Ref,RelCont | rel: 1
+  switch c {
+    case ErrCategory.A: break
+    // CHECK: [[@LINE-1]]:22 | enumerator/Swift | A | c:@E@ErrCategory@ErrCategoryA | Ref,RelCont | rel: 1
+    // CHECK: [[@LINE-2]]:10 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+    // CHECK: [[@LINE-3]]:22 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+    case .B: break
+    // CHECK: [[@LINE-1]]:11 | enumerator/Swift | B | c:@E@ErrCategory@ErrCategoryB | Ref,RelCont | rel: 1
+  }
+}

test/SymbolGraph/ClangImporter/ErrorEnum.swift

@@ -18,6 +18,12 @@
 // but it should be hidden for a similar reason
 // CHECK-NOT: "precise": "s:SYsSHRzSH8RawValueSYRpzrlE4hash4intoys6HasherVz_tF::SYNTHESIZED::c:@E@MyErrorCode"
 
+// MyError
+// CHECK-DAG: "precise": "s:SC11MyErrorCodeLeV"
+
+// MyError.errFirst
+// CHECK-DAG: "precise": "s:SC11MyErrorCodeLeV8errFirstSoAAVvpZ"
+
 // MyErrorCode.Code
 // CHECK-DAG: "precise": "c:@E@MyErrorCode"