[Clang Importer] Import ns_error_domain attribute with _BridgedNSError

milseman · milseman · commit 55ca60aa65ec · 2016-02-03T16:32:26.000-08:00
ns_error_domain can now be used to communicate with the ClangImporter
when an enum has an associated error domain string. In this case, when
we import it as a Swift enum, we can also synthesize a conformance to
_BridgedNSError.

This allows the creation of something like NS_ERROR_ENUM, in which the
developer can declare an enum for the purposes of error handling. Adds
Sema and executable tests demonstrating this funcionality.
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -1870,7 +1870,8 @@ namespace {
       
       // Create the enum declaration and record it.
       NominalTypeDecl *result;
-      auto enumKind = Impl.getEnumKind(decl);
+      auto enumInfo = Impl.getEnumInfo(decl);
+      auto enumKind = enumInfo.getKind();
       switch (enumKind) {
       case EnumKind::Constants: {
         // There is no declaration. Rather, the type is mapped to the
@@ -1954,69 +1955,139 @@ namespace {
       }
 
       case EnumKind::Enum: {
+        auto &swiftCtx = Impl.SwiftContext;
         EnumDecl *nativeDecl;
         bool declaredNative = hasNativeSwiftDecl(decl, name, dc, nativeDecl);
         if (declaredNative && nativeDecl)
           return nativeDecl;
 
         // Compute the underlying type.
-        auto underlyingType = Impl.importType(decl->getIntegerType(),
-                                              ImportTypeKind::Enum,
-                                              isInSystemModule(dc),
-                                              /*isFullyBridgeable*/false);
+        auto underlyingType = Impl.importType(
+            decl->getIntegerType(), ImportTypeKind::Enum, isInSystemModule(dc),
+            /*isFullyBridgeable*/ false);
         if (!underlyingType)
           return nullptr;
-        
-        auto enumDecl = Impl.createDeclWithClangNode<EnumDecl>(decl,
-                   Impl.importSourceLoc(decl->getLocStart()),
-                   name, Impl.importSourceLoc(decl->getLocation()),
-                   None, nullptr, dc);
+
+        auto enumDecl = Impl.createDeclWithClangNode<EnumDecl>(
+            decl, Impl.importSourceLoc(decl->getLocStart()), name,
+            Impl.importSourceLoc(decl->getLocation()), None, nullptr, dc);
         enumDecl->computeType();
-        
+
         // Set up the C underlying type as its Swift raw type.
         enumDecl->setRawType(underlyingType);
-        
+
         // Add protocol declarations to the enum declaration.
-        enumDecl->setInherited(
-          Impl.SwiftContext.AllocateCopy(
-            llvm::makeArrayRef(TypeLoc::withoutLoc(underlyingType))));
+        SmallVector<TypeLoc, 2> inheritedTypes;
+        inheritedTypes.push_back(TypeLoc::withoutLoc(underlyingType));
+        if (enumInfo.isErrorEnum())
+          inheritedTypes.push_back(TypeLoc::withoutLoc(
+              swiftCtx.getProtocol(KnownProtocolKind::BridgedNSError)
+                  ->getDeclaredType()));
+        enumDecl->setInherited(swiftCtx.AllocateCopy(inheritedTypes));
         enumDecl->setCheckedInheritanceClause();
 
+        // Set up error conformance to be lazily expanded
+        if (enumInfo.isErrorEnum())
+          enumDecl->getAttrs().add(new (swiftCtx) SynthesizedProtocolAttr(
+              KnownProtocolKind::BridgedNSError));
+
         // Provide custom implementations of the init(rawValue:) and rawValue
         // conversions that just do a bitcast. We can't reliably filter a
         // C enum without additional knowledge that the type has no
         // undeclared values, and won't ever add cases.
         auto rawValueConstructor = makeEnumRawValueConstructor(Impl, enumDecl);
 
-        auto varName = Impl.SwiftContext.Id_rawValue;
-        auto rawValue = new (Impl.SwiftContext) VarDecl(/*static*/ false,
-                                                   /*IsLet*/ false,
-                                                   SourceLoc(), varName,
-                                                   underlyingType,
-                                                   enumDecl);
+        auto varName = swiftCtx.Id_rawValue;
+        auto rawValue = new (swiftCtx) VarDecl(
+            /*static*/ false,
+            /*IsLet*/ false, SourceLoc(), varName, underlyingType, enumDecl);
         rawValue->setImplicit();
         rawValue->setAccessibility(Accessibility::Public);
         rawValue->setSetterAccessibility(Accessibility::Private);
-        
+
         // Create a pattern binding to describe the variable.
         Pattern *varPattern = createTypedNamedPattern(rawValue);
-        
-        auto rawValueBinding =
-          PatternBindingDecl::create(Impl.SwiftContext, SourceLoc(),
-                                     StaticSpellingKind::None, SourceLoc(),
-                                     varPattern, nullptr, enumDecl);
+
+        auto rawValueBinding = PatternBindingDecl::create(
+            swiftCtx, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
+            varPattern, nullptr, enumDecl);
 
         auto rawValueGetter = makeEnumRawValueGetter(Impl, enumDecl, rawValue);
 
         enumDecl->addMember(rawValueConstructor);
         enumDecl->addMember(rawValueGetter);
         enumDecl->addMember(rawValue);
         enumDecl->addMember(rawValueBinding);
-        
         result = enumDecl;
+
+        // Set up the domain error member to be lazily added
+        if (enumInfo.isErrorEnum()) {
+          auto clangDomainIdent = enumInfo.getErrorDomain();
+          auto &clangSema = Impl.getClangSema();
+          clang::LookupResult lookupResult(
+              clangSema, clang::DeclarationName(clangDomainIdent),
+              clang::SourceLocation(),
+              clang::Sema::LookupNameKind::LookupOrdinaryName);
+
+          if (!clangSema.LookupName(lookupResult, clangSema.TUScope)) {
+            // Couldn't actually import it as an error enum, fall back to enum
+            break;
+          }
+
+          auto clangDecl = lookupResult.getAsSingle<clang::NamedDecl>();
+          if (!clangDecl) {
+            // Couldn't actually import it as an error enum, fall back to enum
+            break;
+          }
+          auto swiftDecl = Impl.importDecl(clangDecl);
+          if (!swiftDecl || !isa<ValueDecl>(swiftDecl)) {
+            // Couldn't actually import it as an error enum, fall back to enum
+            break;
+          }
+          SourceLoc noLoc = SourceLoc();
+          bool isStatic = true;
+          bool isImplicit = true;
+
+          DeclRefExpr *domainDeclRef = new (swiftCtx) DeclRefExpr(
+              ConcreteDeclRef(cast<ValueDecl>(swiftDecl)), {}, isImplicit);
+          auto stringTy = swiftCtx.getStringDecl()->getDeclaredType();
+          ParameterList *params[] = {
+              ParameterList::createWithoutLoc(
+                  ParamDecl::createSelf(noLoc, enumDecl, isStatic)),
+              ParameterList::createEmpty(swiftCtx)};
+          auto toStringTy = ParameterList::getFullType(stringTy, params);
+
+          FuncDecl *getterDecl =
+              FuncDecl::create(swiftCtx, noLoc, StaticSpellingKind::None, noLoc,
+                               {}, noLoc, noLoc, noLoc, nullptr, toStringTy,
+                               params, TypeLoc::withoutLoc(stringTy), enumDecl);
+
+          // Make the property decl
+          auto errorDomainPropertyDecl = new (swiftCtx)
+              VarDecl(isStatic,
+                      /*isLet=*/false, noLoc, swiftCtx.Id_NSErrorDomain,
+                      stringTy, enumDecl);
+          errorDomainPropertyDecl->setAccessibility(Accessibility::Public);
+
+          enumDecl->addMember(errorDomainPropertyDecl);
+          enumDecl->addMember(getterDecl);
+          errorDomainPropertyDecl->makeComputed(
+              noLoc, getterDecl, /*Set=*/nullptr,
+              /*MaterializeForSet=*/nullptr, noLoc);
+
+          getterDecl->setImplicit();
+          getterDecl->setStatic(isStatic);
+          getterDecl->setBodyResultType(stringTy);
+          getterDecl->setAccessibility(Accessibility::Public);
+
+          auto ret = new (swiftCtx) ReturnStmt(noLoc, {domainDeclRef});
+          getterDecl->setBody(
+              BraceStmt::create(swiftCtx, noLoc, {ret}, noLoc, isImplicit));
+          Impl.registerExternalDecl(getterDecl);
+        }
         break;
       }
-          
+
       case EnumKind::Options: {
         result = importAsOptionSetType(dc, name, decl);
         if (!result)
diff --git a/lib/ClangImporter/ImportEnumInfo.cpp b/lib/ClangImporter/ImportEnumInfo.cpp
@@ -37,6 +37,20 @@ void EnumInfo::classifyEnum(const clang::EnumDecl *decl,
     return;
   }
 
+  // First, check for attributes that denote the classification
+  clang::NSErrorDomainAttr *domainAttr = nullptr;
+  for (auto attr : decl->attrs()) {
+    if (isa<clang::NSErrorDomainAttr>(attr)) {
+      domainAttr = cast<clang::NSErrorDomainAttr>(attr);
+      break;
+    }
+  }
+  if (domainAttr) {
+    kind = EnumKind::Enum;
+    attribute = domainAttr;
+    return;
+  }
+
   // Was the enum declared using *_ENUM or *_OPTIONS?
   // FIXME: Use Clang attributes instead of grovelling the macro expansion loc.
   auto loc = decl->getLocStart();
diff --git a/lib/ClangImporter/ImportEnumInfo.h b/lib/ClangImporter/ImportEnumInfo.h
@@ -53,13 +53,21 @@ enum class EnumKind {
 };
 
 class EnumInfo {
+  using AttributePtrUnion = clang::NSErrorDomainAttr *;
+
   /// \brief The kind
   EnumKind kind = EnumKind::Unknown;
 
   /// \brief The enum's common constant name prefix, which will be stripped from
   /// constants
   StringRef constantNamePrefix = StringRef();
 
+  /// \brief The identifying attribute for specially imported enums
+  ///
+  /// Currently, only NS_ERROR_ENUM creates one for its error domain, but others
+  /// should in the future.
+  AttributePtrUnion attribute = nullptr;
+
 public:
   EnumInfo() = default;
 
@@ -72,6 +80,17 @@ class EnumInfo {
 
   StringRef getConstantNamePrefix() const { return constantNamePrefix; }
 
+  /// \brief Whether this maps to an enum who also provides an error domain
+  bool isErrorEnum() const {
+    return getKind() == EnumKind::Enum && attribute;
+  }
+
+  /// \brief For this error enum, extract the name of the error domain constant
+  clang::IdentifierInfo *getErrorDomain() const {
+    assert(isErrorEnum() && "not error enum");
+    return attribute->getErrorDomain();
+  }
+
 private:
   void determineConstantNamePrefix(const clang::EnumDecl *);
   void classifyEnum(const clang::EnumDecl *, clang::Preprocessor &);
diff --git a/test/ClangModules/Inputs/enum-new.h b/test/ClangModules/Inputs/enum-new.h
@@ -50,3 +50,19 @@ typedef CF_OPTIONS(unsigned, ColorOptions) {
   Pastel, Swift
 };
 ColorOptions getColorOptions();
+
+#define NS_ERROR_ENUM(_type, _name, _domain)                                   \
+  enum _name : _type _name;                                                    \
+  enum __attribute__((ns_error_domain(_domain))) _name : _type
+
+@class NSString;
+extern NSString *const TestErrorDomain;
+typedef NS_ERROR_ENUM(int, TestError, TestErrorDomain) {
+	TENone,
+	TEOne,
+	TETwo,
+};
+
+TestError getErr();
+
+
diff --git a/test/ClangModules/Inputs/enum-new.m b/test/ClangModules/Inputs/enum-new.m
@@ -0,0 +1,7 @@
+#include "enum-new.h"
+
+NSString *const TestErrorDomain;
+
+TestError getErr() {
+	return TEOne;
+}
diff --git a/test/ClangModules/enum-new-execute.swift b/test/ClangModules/enum-new-execute.swift
@@ -0,0 +1,52 @@
+// RUN: mkdir -p %t
+// RUN: %target-clang %S/Inputs/enum-new.m -c -o %t/enum-new.o
+// RUN: %target-build-swift -import-objc-header %S/Inputs/enum-new.h -Xlinker %t/enum-new.o %s -o %t/a.out
+// RUN: %target-run %t/a.out | FileCheck %s
+
+// REQUIRES: executable_test
+
+import Foundation
+
+func printError(err: TestError) {
+  switch (err) {
+    case .TENone:
+    print("TestError: TENone")
+    break
+
+    case .TEOne:
+    print("TestError: TEOne")
+    break
+
+    case .TETwo:
+    print("TestError: TETwo")
+    break
+  }
+}
+
+func testError() {
+  let terr = getErr()
+  switch (terr) { case .TENone, .TEOne, .TETwo: break } // ok
+  printError(terr)
+    // CHECK: TestError: TEOne
+
+  do {
+    throw TestError.TETwo
+  } catch let error as TestError {
+    printError(error)
+    // CHECK-NEXT: TestError: TETwo
+  } catch {
+    assert(false)
+  }
+
+  do {
+    enum LocalError : ErrorType { case Err }
+    throw LocalError.Err
+  } catch let error as TestError {
+    printError(error)
+  } catch {
+    print("other error found")
+    // CHECK-NEXT: other error found
+  }
+}
+
+testError()
diff --git a/test/ClangModules/enum-new.swift b/test/ClangModules/enum-new.swift
@@ -23,3 +23,19 @@ func test() {
   } // expected-error {{switch must be exhaustive, consider adding a default clause}}
 }
 
+func testError() {
+  let terr = getErr()
+  switch (terr) { case .TENone, .TEOne, .TETwo: break } // ok
+
+  switch (terr) { case .TENone, .TEOne: break }
+    // expected-error@-1 {{switch must be exhaustive, consider adding a default clause}}
+
+  let _ = TestError(rawValue: 2)!
+
+  do {
+    throw TestError.TEOne
+  } catch is TestError {
+  } catch {
+  }
+
+}
