[Clang importer] Factor the checking for -enable-swift-newtype more sensibly. NFC

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -2034,13 +2034,12 @@ static bool moduleIsInferImportAsMember(const clang::NamedDecl *decl,
 
 // If this decl is associated with a swift_newtype typedef, return it, otherwise
 // null
-static clang::TypedefNameDecl *findSwiftNewtype(const clang::Decl *decl,
-                                                bool honorSwiftNewtypeAttr) {
-  if (!honorSwiftNewtypeAttr) return nullptr;
-
+static clang::TypedefNameDecl *findSwiftNewtype(
+     ClangImporter::Implementation &impl,
+     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>())
+      if (impl.getSwiftNewtypeAttr(typedefTy->getDecl()))
         return typedefTy->getDecl();
 
   return nullptr;
@@ -2081,7 +2080,7 @@ auto ClangImporter::Implementation::importFullName(
       break;
     }
   // Import onto a swift_newtype if present
-  } else if (auto newtypeDecl = findSwiftNewtype(D, HonorSwiftNewtypeAttr)) {
+  } else if (auto newtypeDecl = findSwiftNewtype(*this, D)) {
     result.EffectiveContext = newtypeDecl;
   // Everything else goes into its redeclaration context.
   } else {
@@ -2556,7 +2555,7 @@ auto ClangImporter::Implementation::importFullName(
 
   // swift_newtype-ed declarations may have common words with the type name
   // stripped.
-  if (auto newtypeDecl = findSwiftNewtype(D, HonorSwiftNewtypeAttr)) {
+  if (auto newtypeDecl = findSwiftNewtype(*this, D)) {
     // Skip a leading 'k' in a 'kConstant' pattern
     if (baseName.size() >= 2 && baseName[0] == 'k' &&
         clang::isUppercase(baseName[1]))

lib/ClangImporter/ImportDecl.cpp

@@ -1300,9 +1300,8 @@ namespace {
         return nullptr;
 
       // Check for swift_newtype
-      if (!SwiftType && Impl.HonorSwiftNewtypeAttr) {
-        if (auto newtypeAttr =
-                Decl->template getAttr<clang::SwiftNewtypeAttr>()) {
+      if (!SwiftType) {
+        if (auto newtypeAttr = Impl.getSwiftNewtypeAttr(Decl)) {
           switch (newtypeAttr->getNewtypeKind()) {
           case clang::SwiftNewtypeAttr::NK_Enum:
             // TODO: import as closed enum instead
@@ -5597,6 +5596,17 @@ canSkipOverTypedef(ClangImporter::Implementation &Impl,
   return UnderlyingDecl;
 }
 
+clang::SwiftNewtypeAttr *ClangImporter::Implementation::getSwiftNewtypeAttr(
+      const clang::TypedefNameDecl *decl) {
+  // If we aren't honoring the swift_newtype attribute, don't even
+  // bother looking.
+  if (!HonorSwiftNewtypeAttr)
+    return nullptr;
+
+  // Retrieve the attribute.
+  return decl->getAttr<clang::SwiftNewtypeAttr>();
+}
+
 /// Import Clang attributes as Swift attributes.
 void ClangImporter::Implementation::importAttributes(
     const clang::NamedDecl *ClangDecl,

lib/ClangImporter/ImportType.cpp

@@ -551,8 +551,7 @@ namespace {
       Type mappedType = decl->getDeclaredType();
       ImportHint hint = ImportHint::None;
 
-      if (Impl.HonorSwiftNewtypeAttr &&
-          type->getDecl()->hasAttr<clang::SwiftNewtypeAttr>()) {
+      if (Impl.getSwiftNewtypeAttr(type->getDecl())) {
         hint = ImportHint::SwiftNewtype;
 
       // For certain special typedefs, we don't want to use the imported type.

lib/ClangImporter/ImporterImpl.h

@@ -973,6 +973,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// translated into Swift.
   ValueDecl *importMacro(Identifier name, clang::MacroInfo *macro);
 
+  /// Find the swift_newtype attribute on the given typedef, if present.
+  clang::SwiftNewtypeAttr *getSwiftNewtypeAttr(
+       const clang::TypedefNameDecl *decl);
+
   /// Import attributes from the given Clang declaration to its Swift
   /// equivalent.
   ///