[Clang Importer] Initial support for swift_newtype(struct)

This introduces support for swift_newtype(struct) attribute (also
known as swift_wrapper). The Clang importer will create a brand new
struct corresponding to the annotated typedefs, which has a backing
raw value. Globals of that type are imported as static members on the
struct.

Additionally, this interacts seamlessly with prior import-as-member
work, meaning that the newly created type can be imported onto. Tests
included.

Author: milseman

lib/ClangImporter/ClangImporter.cpp

@@ -2034,6 +2034,17 @@ static bool moduleIsInferImportAsMember(const clang::NamedDecl *decl,
   return false;
 }
 
+// If this decl is associated with a swift_newtype typedef, return it, otherwise
+// null
+static clang::TypedefNameDecl *findSwiftNewtype(const clang::Decl *decl) {
+  if (auto varDecl = dyn_cast<clang::VarDecl>(decl))
+    if (auto typedefTy = varDecl->getType()->getAs<clang::TypedefType>())
+      if (typedefTy->getDecl()->hasAttr<clang::SwiftNewtypeAttr>())
+        return typedefTy->getDecl();
+
+  return nullptr;
+}
+
 auto ClangImporter::Implementation::importFullName(
        const clang::NamedDecl *D,
        ImportNameOptions options,
@@ -2068,8 +2079,11 @@ auto ClangImporter::Implementation::importFullName(
       result.EffectiveContext = enumDecl->getRedeclContext();
       break;
     }
+  // Import onto a swift_newtype if present
+  } else if (auto newtypeDecl = findSwiftNewtype(D)) {
+    result.EffectiveContext = newtypeDecl;
+  // Everything else goes into its redeclaration context.
   } else {
-    // Everything else goes into its redeclaration context.
     result.EffectiveContext = dc->getRedeclContext();
   }
 
@@ -2538,6 +2552,31 @@ auto ClangImporter::Implementation::importFullName(
 
   // Omit needless words.
   StringScratchSpace omitNeedlessWordsScratch;
+
+  // swift_newtype-ed declarations may have common words with the type name
+  // stripped.
+  if (auto newtypeDecl = findSwiftNewtype(D)) {
+    SmallString<32> newNameBuffer;
+    auto newtypeNameWords = camel_case::getWords(newtypeDecl->getName());
+    auto declNameWords = camel_case::getWords(baseName);
+
+    // Scan the decl name, and drop any words that appear in order in the type
+    // name
+    for (auto wI = declNameWords.begin(), skipWI = newtypeNameWords.begin();
+         wI != declNameWords.end(); ++wI) {
+      if (skipWI != newtypeNameWords.end() && *wI == *skipWI) {
+        ++skipWI;
+        continue;
+      }
+      newNameBuffer.append(*wI);
+    }
+
+    if (newNameBuffer.str() != baseName) {
+      baseName = omitNeedlessWordsScratch.copyString(newNameBuffer);
+      strippedPrefix = true;
+    }
+  }
+
   if (!result.isSubscriptAccessor()) {
     // Check whether the module in which the declaration resides has a
     // module prefix and will map into Swift as a type. If so, strip

lib/ClangImporter/ImportDecl.cpp

@@ -1275,6 +1275,44 @@ namespace {
       if (!DC)
         return nullptr;
 
+      // Check for swift_newtype
+      if (!SwiftType) {
+        if (auto newtypeAttr =
+                Decl->template getAttr<clang::SwiftNewtypeAttr>()) {
+          switch (newtypeAttr->getNewtypeKind()) {
+          case clang::SwiftNewtypeAttr::NK_Struct: {
+
+            auto underlyingType = Impl.importType(
+                Decl->getUnderlyingType(), ImportTypeKind::Typedef,
+                isInSystemModule(DC),
+                Decl->getUnderlyingType()->isBlockPointerType());
+
+            auto &cxt = Impl.SwiftContext;
+            auto Loc = Impl.importSourceLoc(Decl->getLocation());
+
+            auto structDecl = Impl.createDeclWithClangNode<StructDecl>(
+                Decl, Loc, Name, Loc, None, nullptr, DC);
+            structDecl->computeType();
+
+            ProtocolDecl *protocols[] = {
+                cxt.getProtocol(KnownProtocolKind::RawRepresentable),
+            };
+            makeStructRawValued(structDecl, underlyingType,
+                                {KnownProtocolKind::RawRepresentable},
+                                protocols);
+
+            Impl.ImportedDecls[Decl->getCanonicalDecl()] = structDecl;
+            Impl.registerExternalDecl(structDecl);
+            return structDecl;
+          }
+
+          case clang::SwiftNewtypeAttr::NK_Enum:
+            // TODO: support enum
+            break;
+          }
+        }
+      }
+
       if (!SwiftType) {
         // Import typedefs of blocks as their fully-bridged equivalent Swift
         // type. That matches how we want to use them in most cases. All other

lib/ClangImporter/ImportType.cpp

@@ -87,6 +87,9 @@ namespace {
 
       /// The source type is any other pointer type.
       OtherPointer,
+
+      /// The source type created a new Swift type, using swift_newtype
+      SwiftNewtype,
     };
 
     ImportHintKind Kind;
@@ -118,6 +121,7 @@ namespace {
     case ImportHint::NSUInteger:
     case ImportHint::Reference:
     case ImportHint::Void:
+    case ImportHint::SwiftNewtype:
       return false;
 
     case ImportHint::Block:
@@ -544,8 +548,11 @@ namespace {
       Type mappedType = decl->getDeclaredType();
       ImportHint hint = ImportHint::None;
 
+      if (type->getDecl()->hasAttr<clang::SwiftNewtypeAttr>()) {
+        hint = ImportHint::SwiftNewtype;
+
       // For certain special typedefs, we don't want to use the imported type.
-      if (auto specialKind = Impl.getSpecialTypedefKind(type->getDecl())) {
+      } else if (auto specialKind = Impl.getSpecialTypedefKind(type->getDecl())) {
         switch (specialKind.getValue()) {
         case MappedTypeNameKind::DoNothing:
         case MappedTypeNameKind::DefineAndUse:

lib/ClangImporter/SwiftLookupTable.h

@@ -146,7 +146,7 @@ const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MAJOR = 1;
 /// Lookup table minor version number.
 ///
 /// When the format changes IN ANY WAY, this number should be incremented.
-const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MINOR = 12; // CG import-as-member
+const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MINOR = 13; // swift_newtype(struct)
 
 /// A lookup table that maps Swift names to the set of Clang
 /// declarations with that particular name.

test/IDE/Inputs/custom-modules/Newtype.h

@@ -0,0 +1,19 @@
+@import Foundation;
+
+typedef NSString *SNTErrorDomain __attribute((swift_newtype(struct)))
+__attribute((swift_name("ErrorDomain")));
+
+extern void SNTErrorDomainProcess(SNTErrorDomain d)
+    __attribute((swift_name("ErrorDomain.process(self:)")));
+
+typedef struct {} Foo;
+
+extern const SNTErrorDomain SNTErrOne
+    __attribute((swift_name("ErrorDomain.one")));
+extern const SNTErrorDomain SNTErrTwo;
+extern const SNTErrorDomain SNTErrorDomainThree;
+extern const SNTErrorDomain SNTFourErrorDomain;
+extern const SNTErrorDomain SNTFive
+    __attribute((swift_name("stillAMember")));
+extern const SNTErrorDomain SNTElsewhere
+    __attribute((swift_name("Foo.err")));

test/IDE/Inputs/custom-modules/module.map

@@ -11,6 +11,11 @@ module ImportedProtocols {
   }
 }
 
+module Newtype {
+  export *
+  header "Newtype.h"
+}
+
 module ImportAsMember {
   export *
 

test/IDE/newtype.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -I %t -I %S/Inputs/custom-modules -print-module -source-filename %s -module-to-print=Newtype > %t.printed.A.txt
+// RUN: FileCheck %s -check-prefix=PRINT -strict-whitespace < %t.printed.A.txt
+// REQUIRES: objc_interop
+
+// PRINT:      struct ErrorDomain : RawRepresentable {
+// PRINT-NEXT:   init(rawValue: NSString)
+// PRINT-NEXT:   let rawValue: NSString
+// PRINT-NEXT: }
+// PRINT-NEXT: extension ErrorDomain {
+// PRINT-NEXT:   func process()
+// PRINT-NEXT:   static let one: ErrorDomain
+// PRINT-NEXT:   static let errTwo: ErrorDomain
+// PRINT-NEXT:   static let three: ErrorDomain
+// PRINT-NEXT:   static let four: ErrorDomain
+// PRINT-NEXT:   static let stillAMember: ErrorDomain
+// PRINT-NEXT: }
+// PRINT-NEXT: struct Foo {
+// PRINT-NEXT:   init()
+// PRINT-NEXT: }
+// PRINT-NEXT: extension Foo {
+// PRINT-NEXT:   static let err: ErrorDomain
+// PRINT-NEXT: }
+
+