Clang importer: handle enumerator prefix stripping in importFullName().

Centralize the mapping of C names to Swift names further by including
enumerator prefix stripping, rather than having that as a separate
path. The actual logic and code for computing the prefix is unchanged
(despite moving from one file to another). This corrects the name
computed for the Swift lookup tables, but is an NFC refactoring for
everything else.

With this, kill off importName(), because it's been entirely
superseded by importFullName().

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -1349,6 +1349,232 @@ static DeclName parseDeclName(ASTContext &ctx, StringRef Name) {
   return DeclName(ctx, BaseID, ParamIDs);
 }
 
+/// \brief Returns the common prefix of two strings at camel-case word
+/// granularity.
+///
+/// For example, given "NSFooBar" and "NSFooBas", returns "NSFoo"
+/// (not "NSFooBa"). The returned StringRef is a slice of the "a" argument.
+///
+/// If either string has a non-identifier character immediately after the
+/// prefix, \p followedByNonIdentifier will be set to \c true. If both strings
+/// have identifier characters after the prefix, \p followedByNonIdentifier will
+/// be set to \c false. Otherwise, \p followedByNonIdentifier will not be
+/// changed from its initial value.
+///
+/// This is used to derive the common prefix of enum constants so we can elide
+/// it from the Swift interface.
+static StringRef getCommonWordPrefix(StringRef a, StringRef b,
+                                     bool &followedByNonIdentifier) {
+  auto aWords = camel_case::getWords(a), bWords = camel_case::getWords(b);
+  auto aI = aWords.begin(), aE = aWords.end(),
+       bI = bWords.begin(), bE = bWords.end();
+
+  unsigned prevLength = 0;
+  unsigned prefixLength = 0;
+  for ( ; aI != aE && bI != bE; ++aI, ++bI) {
+    if (*aI != *bI) {
+      followedByNonIdentifier = false;
+      break;
+    }
+
+    prevLength = prefixLength;
+    prefixLength = aI.getPosition() + aI->size();
+  }
+
+  // Avoid creating a prefix where the rest of the string starts with a number.
+  if ((aI != aE && !Lexer::isIdentifier(*aI)) ||
+      (bI != bE && !Lexer::isIdentifier(*bI))) {
+    followedByNonIdentifier = true;
+    prefixLength = prevLength;
+  }
+
+  return a.slice(0, prefixLength);
+}
+
+/// Returns the common word-prefix of two strings, allowing the second string
+/// to be a common English plural form of the first.
+///
+/// For example, given "NSProperty" and "NSProperties", the full "NSProperty"
+/// is returned. Given "NSMagicArmor" and "NSMagicArmory", only
+/// "NSMagic" is returned.
+///
+/// The "-s", "-es", and "-ies" patterns cover every plural NS_OPTIONS name
+/// in Cocoa and Cocoa Touch.
+///
+/// \see getCommonWordPrefix
+static StringRef getCommonPluralPrefix(StringRef singular, StringRef plural) {
+  assert(!plural.empty());
+
+  if (singular.empty())
+    return singular;
+
+  bool ignored;
+  StringRef commonPrefix = getCommonWordPrefix(singular, plural, ignored);
+  if (commonPrefix.size() == singular.size() || plural.back() != 's')
+    return commonPrefix;
+
+  StringRef leftover = singular.substr(commonPrefix.size());
+  StringRef firstLeftoverWord = camel_case::getFirstWord(leftover);
+  StringRef commonPrefixPlusWord =
+      singular.substr(0, commonPrefix.size() + firstLeftoverWord.size());
+
+  // Is the plural string just "[singular]s"?
+  plural = plural.drop_back();
+  if (plural.endswith(firstLeftoverWord))
+    return commonPrefixPlusWord;
+
+  if (plural.empty() || plural.back() != 'e')
+    return commonPrefix;
+
+  // Is the plural string "[singular]es"?
+  plural = plural.drop_back();
+  if (plural.endswith(firstLeftoverWord))
+    return commonPrefixPlusWord;
+
+  if (plural.empty() || !(plural.back() == 'i' && singular.back() == 'y'))
+    return commonPrefix;
+
+  // Is the plural string "[prefix]ies" and the singular "[prefix]y"?
+  plural = plural.drop_back();
+  firstLeftoverWord = firstLeftoverWord.drop_back();
+  if (plural.endswith(firstLeftoverWord))
+    return commonPrefixPlusWord;
+
+  return commonPrefix;
+}
+
+StringRef ClangImporter::Implementation::getEnumConstantNamePrefix(
+            const clang::EnumDecl *decl) {
+  switch (classifyEnum(decl)) {
+  case EnumKind::Enum:
+  case EnumKind::Options:
+    // Enums are mapped to Swift enums, Options to Swift option sets, both
+    // of which attempt prefix-stripping.
+    break;
+
+  case EnumKind::Constants:
+  case EnumKind::Unknown:
+    // Nothing to do.
+    return StringRef();
+  }
+
+  // If there are no enumers, there is no prefix to compute.
+  auto ec = decl->enumerator_begin(), ecEnd = decl->enumerator_end();
+  if (ec == ecEnd)
+    return StringRef();
+
+  // If we've already computed the prefix, return it.
+  auto known = EnumConstantNamePrefixes.find(decl);
+  if (known != EnumConstantNamePrefixes.end())
+    return known->second;
+
+  // Determine whether the given enumerator is non-deprecated and has no
+  // specifically-provided name.
+  auto isNonDeprecatedWithoutCustomName =
+    [](const clang::EnumConstantDecl *elem) -> bool {
+      if (elem->hasAttr<clang::SwiftNameAttr>())
+        return false;
+
+      clang::VersionTuple maxVersion{~0U, ~0U, ~0U};
+      switch (elem->getAvailability(nullptr, maxVersion)) {
+      case clang::AR_Available:
+      case clang::AR_NotYetIntroduced:
+        for (auto attr : elem->attrs()) {
+          if (auto annotate = dyn_cast<clang::AnnotateAttr>(attr)) {
+            if (annotate->getAnnotation() == "swift1_unavailable")
+              return false;
+          }
+          if (auto avail = dyn_cast<clang::AvailabilityAttr>(attr)) {
+            if (avail->getPlatform()->getName() == "swift")
+              return false;
+          }
+        }
+        return true;
+
+      case clang::AR_Deprecated:
+      case clang::AR_Unavailable:
+        return false;
+      }
+    };
+
+  // Move to the first non-deprecated enumerator, or non-swift_name'd
+  // enumerator, if present.
+  auto firstNonDeprecated = std::find_if(ec, ecEnd,
+                                         isNonDeprecatedWithoutCustomName);
+  bool hasNonDeprecated = (firstNonDeprecated != ecEnd);
+  if (hasNonDeprecated) {
+    ec = firstNonDeprecated;
+  } else {
+    // Advance to the first case without a custom name, deprecated or not.
+    while (ec != ecEnd && (*ec)->hasAttr<clang::SwiftNameAttr>())
+      ++ec;
+    if (ec == ecEnd) {
+      EnumConstantNamePrefixes.insert({decl, StringRef()});
+      return StringRef();
+    }
+  }
+
+  // Compute th e common prefix.
+  StringRef commonPrefix = (*ec)->getName();
+  bool followedByNonIdentifier = false;
+  for (++ec; ec != ecEnd; ++ec) {
+    // Skip deprecated or swift_name'd enumerators.
+    const clang::EnumConstantDecl *elem = *ec;
+    if (hasNonDeprecated) {
+      if (!isNonDeprecatedWithoutCustomName(elem))
+        continue;
+    } else {
+      if (elem->hasAttr<clang::SwiftNameAttr>())
+        continue;
+    }
+
+    commonPrefix = getCommonWordPrefix(commonPrefix, elem->getName(),
+                                       followedByNonIdentifier);
+    if (commonPrefix.empty())
+      break;
+  }
+
+  if (!commonPrefix.empty()) {
+    StringRef checkPrefix = commonPrefix;
+
+    // Account for the 'kConstant' naming convention on enumerators.
+    if (checkPrefix[0] == 'k') {
+      bool canDropK;
+      if (checkPrefix.size() >= 2)
+        canDropK = clang::isUppercase(checkPrefix[1]);
+      else
+        canDropK = !followedByNonIdentifier;
+
+      if (canDropK)
+        checkPrefix = checkPrefix.drop_front();
+    }
+
+    // Account for the enum being imported using
+    // __attribute__((swift_private)). This is a little ad hoc, but it's a
+    // rare case anyway.
+    Identifier enumName = importFullName(decl).getBaseName();
+    StringRef enumNameStr = enumName.str();
+    if (enumNameStr.startswith("__") && !checkPrefix.startswith("__"))
+      enumNameStr = enumNameStr.drop_front(2);
+
+    StringRef commonWithEnum = getCommonPluralPrefix(checkPrefix,
+                                                     enumNameStr);
+    size_t delta = commonPrefix.size() - checkPrefix.size();
+
+    // Account for the 'EnumName_Constant' convention on enumerators.
+    if (commonWithEnum.size() < checkPrefix.size() &&
+        checkPrefix[commonWithEnum.size()] == '_' &&
+        !followedByNonIdentifier) {
+      delta += 1;
+    }
+
+    commonPrefix = commonPrefix.slice(0, commonWithEnum.size() + delta);
+  }
+
+  EnumConstantNamePrefixes.insert({decl, commonPrefix});
+  return commonPrefix;
+}
+
 DeclName ClangImporter::Implementation::importFullName(
            const clang::NamedDecl *D,
            bool *hasCustomName,
@@ -1433,6 +1659,16 @@ DeclName ClangImporter::Implementation::importFullName(
   }
   }
 
+  // Perform automatic name transformations.
+
+  // Enumeration constants may have common prefixes stripped.
+  if (isa<clang::EnumConstantDecl>(D)) {
+    auto enumDecl = cast<clang::EnumDecl>(D->getDeclContext());
+    StringRef removePrefix = getEnumConstantNamePrefix(enumDecl);
+    if (baseName.startswith(removePrefix))
+      baseName = baseName.substr(removePrefix.size());
+  }
+
   // Local function to determine whether the given declaration is subject to
   // a swift_private attribute.
   auto hasSwiftPrivate = [this](const clang::NamedDecl *D) {
@@ -1558,87 +1794,6 @@ ClangImporter::Implementation::importIdentifier(
   return SwiftContext.getIdentifier(name);
 }
 
-Identifier
-ClangImporter::Implementation::importName(const clang::NamedDecl *D,
-                                          StringRef removePrefix) {
-  if (auto *nameAttr = D->getAttr<clang::SwiftNameAttr>()) {
-    StringRef customName = nameAttr->getName();
-    if (Lexer::isIdentifier(customName))
-      return SwiftContext.getIdentifier(customName);
-
-    return Identifier();
-  }
-
-  Identifier result = importIdentifier(D->getIdentifier(), removePrefix);
-  if (result.empty())
-    return result;
-
-  auto hasSwiftPrivate = [this](const clang::NamedDecl *D) {
-    if (D->hasAttr<clang::SwiftPrivateAttr>())
-      return true;
-
-    // Enum constants that are not imported as members should be considered
-    // private if the parent enum is marked private.
-    if (auto *ECD = dyn_cast<clang::EnumConstantDecl>(D)) {
-      auto *ED = cast<clang::EnumDecl>(ECD->getDeclContext());
-      switch (classifyEnum(ED)) {
-      case EnumKind::Constants:
-      case EnumKind::Unknown:
-        if (ED->hasAttr<clang::SwiftPrivateAttr>())
-          return true;
-        if (auto *enumTypedef = ED->getTypedefNameForAnonDecl())
-          if (enumTypedef->hasAttr<clang::SwiftPrivateAttr>())
-            return true;
-        break;
-
-      case EnumKind::Enum:
-      case EnumKind::Options:
-        break;
-      }
-    }
-
-    return false;
-  };
-
-  if (hasSwiftPrivate(D) && D->getDeclName().isIdentifier()) {
-    SmallString<64> name{"__"};
-    name += result.str();
-    result = SwiftContext.getIdentifier(name.str());
-  }
-
-  // Omit needless words from properties.
-  if (OmitNeedlessWords) {
-    if (auto objcProperty = dyn_cast<clang::ObjCPropertyDecl>(D)) {
-      auto contextType = getClangDeclContextType(D->getDeclContext());
-      if (!contextType.isNull()) {
-        auto contextTypeName = getClangTypeNameForOmission(contextType);
-        auto propertyTypeName = getClangTypeNameForOmission(
-                                  objcProperty->getType());
-        StringScratchSpace scratch;
-        StringRef name = result.str();
-
-        // Find the property names.
-        const InheritedNameSet *allPropertyNames = nullptr;
-        if (!contextType.isNull()) {
-          if (auto objcPtrType = contextType->getAsObjCInterfacePointerType())
-            if (auto objcClassDecl = objcPtrType->getInterfaceDecl())
-              allPropertyNames = SwiftContext.getAllPropertyNames(
-                                   objcClassDecl,
-                                   /*forInstance=*/true);
-        }
-
-        if (omitNeedlessWords(name, { }, "", propertyTypeName, contextTypeName,
-                              { }, /*returnsSelf=*/false, /*isProperty=*/true,
-                              allPropertyNames, scratch)) {
-          result = SwiftContext.getIdentifier(name);
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
 /// Import an argument name.
 static Identifier importArgName(ASTContext &ctx, StringRef name,
                                 bool dropWith, bool isSwiftPrivate) {