[ClangImporter] Add fast-path lookup for error code enums as well.

These are also imported as local types, so they can have the same
issues as the previous commit.

Author: jrose-apple

lib/ClangImporter/ClangImporter.cpp

@@ -2435,6 +2435,23 @@ static bool isVisibleClangEntry(clang::ASTContext &ctx,
 TypeDecl *
 ClangModuleUnit::lookupNestedType(Identifier name,
                                   const NominalTypeDecl *baseType) const {
+  // Special case for error code enums: try looking directly into the struct
+  // first. But only if it looks like a synthesized error wrapped struct.
+  if (name == getASTContext().Id_Code && !baseType->hasClangNode() &&
+      isa<StructDecl>(baseType) && !baseType->hasLazyMembers() &&
+      baseType->isChildContextOf(this)) {
+    auto *mutableBase = const_cast<NominalTypeDecl *>(baseType);
+    auto codeEnum = mutableBase->lookupDirect(name,/*ignoreNewExtensions*/true);
+    // Double-check that we actually have a good result. It's possible what we
+    // found is /not/ a synthesized error struct, but just something that looks
+    // like it. But if we still found a good result we should return that.
+    if (codeEnum.size() == 1 && isa<TypeDecl>(codeEnum.front()))
+      return cast<TypeDecl>(codeEnum.front());
+    if (codeEnum.size() > 1)
+      return nullptr;
+    // Otherwise, fall back and try via lookup table.
+  }
+
   auto lookupTable = owner.findLookupTable(clangModule);
   if (!lookupTable)
     return nullptr;
@@ -2491,9 +2508,13 @@ ClangModuleUnit::lookupNestedType(Identifier name,
     });
   }
 
-  if (results.size() == 1)
-    return results.front();
-  return nullptr;
+  if (results.size() != 1) {
+    // It's possible that two types were import-as-member'd onto the same base
+    // type with the same name. In this case, fall back to regular lookup.
+    return nullptr;
+  }
+
+  return results.front();
 }
 
 void ClangImporter::loadExtensions(NominalTypeDecl *nominal,

test/Serialization/Inputs/xref-nested-clang-type/NestedClangTypes.h

@@ -5,3 +5,14 @@ struct Outer {
 struct __attribute__((swift_name("Outer.InterestingValue"))) Inner {
   int value;
 };
+
+#if __OBJC__
+
+@import Foundation;
+
+extern NSString * const ErrorCodeDomain;
+enum __attribute__((ns_error_domain(ErrorCodeDomain))) ErrorCodeEnum {
+  ErrorCodeEnumA
+};
+
+#endif // __OBJC__

test/Serialization/xref-nested-clang-type.swift

@@ -1,16 +1,21 @@
 // RUN: %empty-directory(%t)
 
-// RUN: %target-swift-frontend -emit-module -o %t -I %S/Inputs/xref-nested-clang-type/ %s -module-name Lib
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -o %t -I %S/Inputs/xref-nested-clang-type/ %s -module-name Lib
 
-// RUN: %target-swift-frontend -typecheck -I %t -I %S/Inputs/xref-nested-clang-type/ %s -DCLIENT -verify
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %t -I %S/Inputs/xref-nested-clang-type/ %s -DCLIENT -verify
 
 #if CLIENT
 
 import Lib
 
 func test(x: MyInner) {}
 
-#else
+#if _runtime(_ObjC)
+import Foundation
+func test(x: MyCode) {}
+#endif // ObjC
+
+#else // CLIENT
 
 import NestedClangTypes
 
@@ -21,4 +26,13 @@ extension MyOuter {
   public func use(inner: MyInner) {}
 }
 
-#endif
+#if _runtime(_ObjC)
+import Foundation
+
+public typealias MyCode = ErrorCodeEnum.Code
+extension ErrorCodeEnum {
+  public func whatever(code: MyCode) {}
+}
+#endif // ObjC
+
+#endif // CLIENT