Merge pull request swiftlang#34382 from DougGregor/concurrency-objc-get-async

[Concurrency] Asynchronous Objective-C method importer naming adjustments

Author: DougGregor

include/swift/Basic/StringExtras.h

@@ -442,6 +442,8 @@ class InheritedNameSet {
 ///
 /// \param allPropertyNames The set of property names in the enclosing context.
 ///
+/// \param isAsync Whether this is a function imported as 'async'.
+///
 /// \param scratch Scratch space that will be used for modifications beyond
 /// just chopping names.
 ///
@@ -455,6 +457,7 @@ bool omitNeedlessWords(StringRef &baseName,
                        bool returnsSelf,
                        bool isProperty,
                        const InheritedNameSet *allPropertyNames,
+                       bool isAsync,
                        StringScratchSpace &scratch);
 
 } // end namespace swift

lib/Basic/StringExtras.cpp

@@ -1220,6 +1220,7 @@ bool swift::omitNeedlessWords(StringRef &baseName,
                               bool returnsSelf,
                               bool isProperty,
                               const InheritedNameSet *allPropertyNames,
+                              bool isAsync,
                               StringScratchSpace &scratch) {
   bool anyChanges = false;
   OmissionTypeName resultType = returnsSelf ? contextType : givenResultType;
@@ -1287,11 +1288,28 @@ bool swift::omitNeedlessWords(StringRef &baseName,
     }
   }
 
+  // If the base name of a method imported as "async" starts with the word
+  // "get", drop the "get".
+  if (isAsync && camel_case::getFirstWord(baseName) == "get" &&
+      baseName.size() > 3) {
+    baseName = baseName.substr(3);
+    anyChanges = true;
+  }
+
   // If needed, split the base name.
   if (!argNames.empty() &&
       splitBaseName(baseName, argNames[0], paramTypes[0], firstParamName))
     anyChanges = true;
 
+  // For a method imported as "async", drop the "Asynchronously" suffix from
+  // the base name. It is redundant with 'async'.
+  const StringRef asynchronously = "Asynchronously";
+  if (isAsync && camel_case::getLastWord(baseName) == asynchronously &&
+      baseName.size() > asynchronously.size()) {
+    baseName = baseName.drop_back(asynchronously.size());
+    anyChanges = true;
+  }
+
   // Omit needless words based on parameter types.
   for (unsigned i = 0, n = argNames.size(); i != n; ++i) {
     // If there is no corresponding parameter, there is nothing to

lib/ClangImporter/IAMInference.cpp

@@ -448,7 +448,7 @@ class IAMInference {
     baseName = humbleBaseName.userFacingName();
     bool didOmit =
         omitNeedlessWords(baseName, argStrs, "", "", "", paramTypeNames, false,
-                          false, nullptr, scratch);
+                          false, nullptr, false, scratch);
     SmallVector<Identifier, 8> argLabels;
     for (auto str : argStrs)
       argLabels.push_back(getIdentifier(str));

lib/ClangImporter/ImportName.cpp

@@ -804,7 +804,7 @@ static bool omitNeedlessWordsInFunctionName(
     ArrayRef<const clang::ParmVarDecl *> params, clang::QualType resultType,
     const clang::DeclContext *dc, const SmallBitVector &nonNullArgs,
     Optional<unsigned> errorParamIndex, bool returnsSelf, bool isInstanceMethod,
-    NameImporter &nameImporter) {
+    Optional<unsigned> completionHandlerIndex, NameImporter &nameImporter) {
   clang::ASTContext &clangCtx = nameImporter.getClangContext();
 
   // Collect the parameter type names.
@@ -817,10 +817,6 @@ static bool omitNeedlessWordsInFunctionName(
     if (i == 0)
       firstParamName = param->getName();
 
-    // Determine the number of parameters.
-    unsigned numParams = params.size();
-    if (errorParamIndex) --numParams;
-
     bool isLastParameter
       = (i == params.size() - 1) ||
         (i == params.size() - 2 &&
@@ -858,7 +854,8 @@ static bool omitNeedlessWordsInFunctionName(
                            getClangTypeNameForOmission(clangCtx, resultType),
                            getClangTypeNameForOmission(clangCtx, contextType),
                            paramTypes, returnsSelf, /*isProperty=*/false,
-                           allPropertyNames, nameImporter.getScratch());
+                           allPropertyNames, completionHandlerIndex.hasValue(),
+                           nameImporter.getScratch());
 }
 
 /// Prepare global name for importing onto a swift_newtype.
@@ -1831,8 +1828,7 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
         result.info.accessorKind == ImportedAccessorKind::None) {
       if (auto asyncInfo = considerAsyncImport(
               objcMethod, baseName, argumentNames, params, isInitializer,
-              /*hasCustomName=*/false,
-              result.getErrorInfo())) {
+              /*hasCustomName=*/false, result.getErrorInfo())) {
         result.info.hasAsyncInfo = true;
         result.info.asyncInfo = *asyncInfo;
       }
@@ -1972,7 +1968,7 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
         (void)omitNeedlessWords(baseName, {}, "", propertyTypeName,
                                 contextTypeName, {}, /*returnsSelf=*/false,
                                 /*isProperty=*/true, allPropertyNames,
-                                scratch);
+                                /*isAsync=*/false, scratch);
       }
     }
 
@@ -1984,7 +1980,12 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
           result.getErrorInfo()
               ? Optional<unsigned>(result.getErrorInfo()->ErrorParameterIndex)
               : None,
-          method->hasRelatedResultType(), method->isInstanceMethod(), *this);
+          method->hasRelatedResultType(), method->isInstanceMethod(),
+          result.getAsyncInfo().map(
+            [](const ForeignAsyncConvention::Info &info) {
+              return info.CompletionHandlerParamIndex;
+            }),
+          *this);
     }
 
     // If the result is a value, lowercase it.

lib/Sema/MiscDiagnostics.cpp

@@ -4867,7 +4867,8 @@ Optional<DeclName> TypeChecker::omitNeedlessWords(AbstractFunctionDecl *afd) {
                                 getTypeNameForOmission(resultType),
                                 getTypeNameForOmission(contextType),
                                 paramTypes, returnsSelf, false,
-                                /*allPropertyNames=*/nullptr, scratch))
+                                /*allPropertyNames=*/nullptr,
+                                afd->hasAsync(), scratch))
     return None;
 
   /// Retrieve a replacement identifier.
@@ -4922,7 +4923,8 @@ Optional<Identifier> TypeChecker::omitNeedlessWords(VarDecl *var) {
   OmissionTypeName contextTypeName = getTypeNameForOmission(contextType);
   if (::omitNeedlessWords(name, { }, "", typeName, contextTypeName, { },
                           /*returnsSelf=*/false, true,
-                          /*allPropertyNames=*/nullptr, scratch)) {
+                          /*allPropertyNames=*/nullptr, /*isAsync=*/false,
+                          scratch)) {
     return Context.getIdentifier(name);
   }
 

test/ClangImporter/objc_async.swift

@@ -18,6 +18,9 @@ func testSlowServer(slowServer: SlowServer) async throws {
   // still async version...
   let _: Int = slowServer.doSomethingConflicted("thinking")
   // expected-error@-1{{call is 'async' but is not marked with 'await'}}
+
+  let _: String? = await try slowServer.fortune()
+  let _: Int = await try slowServer.magicNumber(withSeed: 42)
 }
 
 func testSlowServerSynchronous(slowServer: SlowServer) {

test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h

@@ -10,6 +10,8 @@
 -(void)findAnswerAsynchronously:(void (^)(NSString *_Nullable, NSError * _Nullable))handler __attribute__((swift_name("findAnswer(completionHandler:)")));
 -(BOOL)findAnswerFailinglyWithError:(NSError * _Nullable * _Nullable)error completion:(void (^)(NSString *_Nullable, NSError * _Nullable))handler __attribute__((swift_name("findAnswerFailingly(completionHandler:)")));
 -(void)doSomethingFun:(NSString *)operation then:(void (^)(void))completionHandler;
+-(void)getFortuneAsynchronouslyWithCompletionHandler:(void (^)(NSString *_Nullable, NSError * _Nullable))handler;
+-(void)getMagicNumberAsynchronouslyWithSeed:(NSInteger)seed completionHandler:(void (^)(NSInteger, NSError * _Nullable))handler;
 @property(readwrite) void (^completionHandler)(NSInteger);
 
 -(void)doSomethingConflicted:(NSString *)operation completionHandler:(void (^)(NSInteger))handler;