[SourceKit] For clang enums imported as error domains, make sure to use unique USRs.

Error domain enums are imported with synthesizing something like this:

 struct MyError {
     enum Code : Int32 {
         case errFirst
         case errSecond
     }
     static var errFirst: MyError.Code { get }
     static var errSecond: MyError.Code { get }
 }

The clang enum and enum constants are associated with both the
struct/nested enum, and the static vars/enum cases.
But we want unique USRs for the above symbols, so use the clang USR
for the enum and enum cases, and the Swift USR for the struct and vars.

rdar://27550967

Author: akyrtzi

lib/AST/USRGeneration.cpp

@@ -18,6 +18,7 @@
 #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"
@@ -55,7 +56,39 @@ bool ide::printDeclUSR(const ValueDecl *D, raw_ostream &OS) {
 
   ValueDecl *VD = const_cast<ValueDecl *>(D);
 
-  if (ClangNode ClangN = VD->getClangNode()) {
+  auto interpretAsClangNode = [](const ValueDecl *D)->ClangNode {
+    ClangNode ClangN = D->getClangNode();
+    if (auto ClangD = ClangN.getAsDecl()) {
+      // NSErrorDomain causes the clang enum to be imported like this:
+      //
+      // struct MyError {
+      //     enum Code : Int32 {
+      //         case errFirst
+      //         case errSecond
+      //     }
+      //     static var errFirst: MyError.Code { get }
+      //     static var errSecond: MyError.Code { get }
+      // }
+      //
+      // The clang enum and enum constants are associated with both the
+      // struct/nested enum, and the static vars/enum cases.
+      // But we want unique USRs for the above symbols, so use the clang USR
+      // for the enum and enum cases, and the Swift USR for the struct and vars.
+      //
+      if (isa<clang::EnumDecl>(ClangD)) {
+        if (ClangD->hasAttr<clang::NSErrorDomainAttr>() && isa<StructDecl>(D))
+          return ClangNode();
+      } else if (auto *ClangEnumConst = dyn_cast<clang::EnumConstantDecl>(ClangD)) {
+        if (auto *ClangEnum = dyn_cast<clang::EnumDecl>(ClangEnumConst->getDeclContext())) {
+          if (ClangEnum->hasAttr<clang::NSErrorDomainAttr>() && isa<VarDecl>(D))
+            return ClangNode();
+        }
+      }
+    }
+    return ClangN;
+  };
+
+  if (ClangNode ClangN = interpretAsClangNode(D)) {
     llvm::SmallString<128> Buf;
     if (auto ClangD = ClangN.getAsDecl()) {
       bool Ignore = clang::index::generateUSRForDecl(ClangD, Buf);

test/SourceKit/DocSupport/Inputs/MyError.h

@@ -0,0 +1,14 @@
+@import Foundation;
+
+#define NS_ERROR_ENUM(_type, _name, _domain)  \
+  enum _name : _type _name; enum __attribute__((ns_error_domain(_domain))) _name : _type
+
+@class NSString;
+extern const NSString *const MyErrorDomain;
+/// This is my cool error code.
+typedef NS_ERROR_ENUM(int, MyErrorCode, MyErrorDomain) {
+	/// This is first error.
+	MyErrFirst,
+	/// This is second error.
+	MyErrSecond,
+};

test/SourceKit/DocSupport/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module "MyError" {
+  header "MyError.h"
+  export *
+}

test/SourceKit/DocSupport/doc_error_domain.swift

@@ -0,0 +1,32 @@
+// REQUIRES: OS=macosx
+// RUN: %sourcekitd-test -req=doc-info -module MyError -- -I %S/Inputs \
+// RUN:         %mcp_opt -sdk %sdk | %sed_clean > %t.response
+// RUN: FileCheck -input-file=%t.response %s
+
+// CHECK: struct MyError {
+// CHECK:     enum Code : Int32 {
+// CHECK:         case errFirst
+// CHECK:         case errSecond
+// CHECK:     }
+// CHECK:     static var errFirst: MyError.Code { get }
+// CHECK:     static var errSecond: MyError.Code { get }
+
+// CHECK:         key.kind: source.lang.swift.decl.struct,
+// CHECK-NEXT:    key.name: "MyError",
+// CHECK-NEXT:    key.usr: "s:VSC7MyError",
+// CHECK-NEXT:    This is my cool error code.
+
+// CHECK:             key.kind: source.lang.swift.decl.enum,
+// CHECK-NEXT:        key.name: "Code",
+// CHECK-NEXT:        key.usr: "c:@E@MyErrorCode",
+// CHECK-NEXT:        This is my cool error code.
+
+// CHECK:                 key.kind: source.lang.swift.decl.enumelement,
+// CHECK-NEXT:            key.name: "errFirst",
+// CHECK-NEXT:            key.usr: "c:@E@MyErrorCode@MyErrFirst",
+// CHECK-NEXT:            This is first error.
+
+// CHECK:             key.kind: source.lang.swift.decl.var.static,
+// CHECK-NEXT:        key.name: "errFirst",
+// CHECK-NEXT:        key.usr: "s:ZvVSC7MyError8errFirstOS_4Code",
+// CHECK-NEXT:        This is first error.