Merge pull request #2864 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/AST/Attr.def

@@ -624,7 +624,7 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
-DECL_ATTR(hasAsyncAlternative, HasAsyncAlternative,
+DECL_ATTR(completionHandlerAsync, CompletionHandlerAsync,
   OnAbstractFunction | ConcurrencyOnly |
   ABIStableToAdd | ABIStableToRemove |
   APIStableToAdd | APIStableToRemove,

include/swift/AST/Attr.h

@@ -2147,27 +2147,59 @@ class TransposeAttr final
   }
 };
 
-/// The `@hasAsyncAlternative` attribute marks a function as having an async
+/// The `@completionHandlerAsync` attribute marks a function as having an async
 /// alternative, optionally providing a name (for cases when the alternative
 /// has a different name).
-class HasAsyncAlternativeAttr final : public DeclAttribute  {
+class CompletionHandlerAsyncAttr final : public DeclAttribute {
+private:
+  /// DeclName of the async function in the attribute
+  const DeclNameRef AsyncFunctionName;
+
 public:
-  /// An optional name of the async alternative function, where the name of the
-  /// attributed function is used otherwise.
-  const DeclNameRef Name;
+  /// Source location of the async function name in the attribute
+  const SourceLoc AsyncFunctionNameLoc;
 
-  HasAsyncAlternativeAttr(DeclNameRef Name, SourceLoc AtLoc, SourceRange Range)
-    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false),
-      Name(Name) {}
+  /// Get the name of the async function
+  ///
+  /// The name will come from the AsyncFunctionDecl if available, otherwise will
+  /// fall back on the user-provided name. If that is not defined, this function
+  /// will abort.
+  DeclNameRef getAsyncFunctionName() const;
+
+  /// The index of the completion handler
+  const size_t CompletionHandlerIndex;
+
+  /// Source location of the completion handler index passed to the index
+  const SourceLoc CompletionHandlerIndexLoc;
+
+  AbstractFunctionDecl *AsyncFunctionDecl = nullptr;
+
+  CompletionHandlerAsyncAttr(DeclNameRef asyncFunctionName,
+                             SourceLoc asyncFunctionNameLoc,
+                             size_t completionHandlerIndex,
+                             SourceLoc completionHandlerIndexLoc,
+                             SourceLoc atLoc, SourceRange range)
+      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
+                      /*implicit*/ false),
+        AsyncFunctionName(asyncFunctionName),
+        AsyncFunctionNameLoc(asyncFunctionNameLoc),
+        CompletionHandlerIndex(completionHandlerIndex),
+        CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}
+
+  CompletionHandlerAsyncAttr(AbstractFunctionDecl &asyncFunctionDecl,
+                             size_t completionHandlerIndex,
+                             SourceLoc completionHandlerIndexLoc,
+                             SourceLoc atLoc, SourceRange range)
+      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
+                      /*implicit*/ false),
+        CompletionHandlerIndex(completionHandlerIndex),
+        CompletionHandlerIndexLoc(completionHandlerIndexLoc),
+        AsyncFunctionDecl(&asyncFunctionDecl) {}
 
-  HasAsyncAlternativeAttr(SourceLoc AtLoc, SourceRange Range)
-    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false) {}
 
-  /// Determine whether this attribute has a name associated with it.
-  bool hasName() const { return !Name.getBaseName().empty(); }
 
   static bool classof(const DeclAttribute *DA) {
-    return DA->getKind() == DAK_HasAsyncAlternative;
+    return DA->getKind() == DAK_CompletionHandlerAsync;
   }
 };
 

include/swift/AST/DiagnosticsParse.def

@@ -1376,6 +1376,9 @@ ERROR(attr_expected_comma,none,
 ERROR(attr_expected_string_literal,none,
 "expected string literal in '%0' attribute", (StringRef))
 
+ERROR(attr_expected_integer_literal,none,
+"expected integer literal in '%0' attribute", (StringRef))
+
 ERROR(attr_expected_option_such_as,none,
       "expected '%0' option such as '%1'", (StringRef, StringRef))
 
@@ -1675,8 +1678,8 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
-// hasAsyncAlternative
-ERROR(has_async_alternative_invalid_name, none,
+// completionHandlerAsync
+ERROR(attr_completion_handler_async_invalid_name, none,
       "argument of '%0' attribute must be an identifier or full function name",
       (StringRef))
 

include/swift/AST/DiagnosticsSema.def

@@ -854,6 +854,9 @@ NOTE(unspaced_binary_operators_candidate,none,
 ERROR(unspaced_unary_operator,none,
       "unary operators must not be juxtaposed; parenthesize inner expression",
       ())
+ERROR(nonexistent_power_operator,none,
+      "no operator '**' is defined; did you mean 'pow(_:_:)'?",
+      ())
 
 ERROR(cannot_find_in_scope,none,
       "cannot %select{find|find operator}1 %0 in scope", (DeclNameRef, bool))
@@ -3340,6 +3343,33 @@ ERROR(diff_params_clause_param_not_differentiable,none,
       "can only differentiate with respect to parameters that conform to "
       "'Differentiable', but %0 does not conform to 'Differentiable'", (Type))
 
+// completionHanderAsync attribute
+ERROR(attr_completion_handler_async_handler_not_func,none,
+      "'%0' should be attached to a non-async completion-handler function",
+      (DeclAttribute))
+
+NOTE(note_attr_function_declared_async,none,
+     "function declared async", ())
+
+NOTE(note_attr_completion_function_must_return_void,none,
+     "completion handler must return 'Void'", ())
+
+NOTE(note_attr_completion_handler_async_type_is_not_function,none,
+     "%0 is not a function type", (Type))
+
+NOTE(note_attr_completion_handler_async_handler_attr_req,none,
+     "completion handler must%select{ not|}0 be '@%1'",
+     (bool, StringRef))
+
+ERROR(attr_completion_handler_async_handler_out_of_range,none,
+      "completion handler index out of range of the function parameters", ())
+
+ERROR(attr_completion_handler_async_ambiguous_function,none,
+      "ambiguous '%0' async function %1", (DeclAttribute, DeclNameRef))
+
+ERROR(attr_completion_handler_async_no_suitable_function,none,
+      "no corresponding async function named %0", (DeclNameRef))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Expressions
 //------------------------------------------------------------------------------

lib/AST/Attr.cpp

@@ -1225,8 +1225,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "derivative";
   case DAK_Transpose:
     return "transpose";
-  case DAK_HasAsyncAlternative:
-    return "hasAsyncAlternative";
+  case DAK_CompletionHandlerAsync:
+    return "completionHandlerAsync";
   }
   llvm_unreachable("bad DeclAttrKind");
 }
@@ -2002,3 +2002,11 @@ void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);
 }
+
+DeclNameRef CompletionHandlerAsyncAttr::getAsyncFunctionName() const {
+  if (AsyncFunctionDecl)
+    return DeclNameRef(AsyncFunctionDecl->getName());
+  if (AsyncFunctionName)
+    return AsyncFunctionName;
+  llvm_unreachable("completionHandlerAsync attr missing async function name");
+}

lib/Parse/ParseDecl.cpp

@@ -1570,42 +1570,68 @@ void Parser::parseAllAvailabilityMacroArguments() {
   AvailabilityMacrosComputed = true;
 }
 
-static HasAsyncAlternativeAttr *parseAsyncAlternativeAttribute(
-    Parser &P, StringRef AttrName, SourceLoc AtLoc, DeclAttrKind DK) {
+static CompletionHandlerAsyncAttr *
+parseCompletionHandlerAsyncAttribute(Parser &P, StringRef AttrName,
+                                     SourceLoc AtLoc, DeclAttrKind DK) {
   SourceLoc Loc = P.PreviousLoc;
 
-  // Unnamed @hasAsyncAlternative attribute
-  if (P.Tok.isNot(tok::l_paren))
-    return new (P.Context) HasAsyncAlternativeAttr(AtLoc, Loc);
-
-  P.consumeToken(tok::l_paren);
+  if (!P.consumeIf(tok::l_paren)) {
+    P.diagnose(P.getEndOfPreviousLoc(), diag::attr_expected_lparen, AttrName,
+               DeclAttribute::isDeclModifier(DK));
+    return nullptr;
+  }
 
   if (!P.Tok.is(tok::string_literal)) {
     P.diagnose(Loc, diag::attr_expected_string_literal, AttrName);
     return nullptr;
   }
 
-  auto Value = P.getStringLiteralIfNotInterpolated(
-      Loc, ("argument of '" + AttrName + "'").str());
+  SourceLoc nameLoc = P.Tok.getLoc();
+  Optional<StringRef> asyncFunctionName = P.getStringLiteralIfNotInterpolated(
+      nameLoc, ("argument of '" + AttrName + "'").str());
   P.consumeToken(tok::string_literal);
-  if (!Value)
+
+  if (!asyncFunctionName)
     return nullptr;
 
-  ParsedDeclName parsedName = parseDeclName(Value.getValue());
-  if (!parsedName || !parsedName.ContextName.empty()) {
-    P.diagnose(AtLoc, diag::has_async_alternative_invalid_name, AttrName);;
+  ParsedDeclName parsedAsyncName = parseDeclName(*asyncFunctionName);
+  if (!parsedAsyncName || !parsedAsyncName.ContextName.empty()) {
+    P.diagnose(nameLoc, diag::attr_completion_handler_async_invalid_name,
+               AttrName);
     return nullptr;
   }
 
+  size_t handlerIndex = 0;
+  SourceLoc handlerIndexLoc = SourceLoc();
+  if (P.consumeIf(tok::comma)) {
+    // The completion handler is explicitly specified, parse it
+    if (P.parseSpecificIdentifier("completionHandlerIndex",
+                                  diag::attr_missing_label,
+                                  "completionHandlerIndex", AttrName) ||
+        P.parseToken(tok::colon, diag::expected_colon_after_label,
+                     "completionHandlerIndex")) {
+      return nullptr;
+    }
+
+    if (P.Tok.getText().getAsInteger(0, handlerIndex)) {
+      P.diagnose(P.Tok.getLoc(), diag::attr_expected_integer_literal, AttrName);
+      return nullptr;
+    }
+
+    handlerIndexLoc = P.consumeToken(tok::integer_literal);
+  }
+
   SourceRange AttrRange = SourceRange(Loc, P.Tok.getRange().getStart());
   if (!P.consumeIf(tok::r_paren)) {
-    P.diagnose(Loc, diag::attr_expected_rparen, AttrName,
+    P.diagnose(P.getEndOfPreviousLoc(), diag::attr_expected_rparen, AttrName,
                DeclAttribute::isDeclModifier(DK));
     return nullptr;
   }
 
-  return new (P.Context) HasAsyncAlternativeAttr(
-      parsedName.formDeclNameRef(P.Context), AtLoc, AttrRange);
+  return new (P.Context) CompletionHandlerAsyncAttr(
+      parsedAsyncName.formDeclNameRef(P.Context), nameLoc,
+      handlerIndex, handlerIndexLoc, AtLoc,
+      AttrRange);
 }
 
 bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
@@ -2686,8 +2712,9 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
         name, AtLoc, range, /*implicit*/ false));
     break;
   }
-  case DAK_HasAsyncAlternative: {
-    auto *attr = parseAsyncAlternativeAttribute(*this, AttrName, AtLoc, DK);
+  case DAK_CompletionHandlerAsync: {
+    auto *attr =
+        parseCompletionHandlerAsyncAttribute(*this, AttrName, AtLoc, DK);
     if (!attr) {
       skipUntilDeclStmtRBrace(tok::r_paren);
       consumeIf(tok::r_paren);

lib/Sema/PreCheckExpr.cpp

@@ -238,6 +238,30 @@ static bool diagnoseRangeOperatorMisspell(DiagnosticEngine &Diags,
   return false;
 }
 
+static bool diagnoseNonexistentPowerOperator(DiagnosticEngine &Diags,
+                                             UnresolvedDeclRefExpr *UDRE,
+                                             DeclContext *DC) {
+  auto name = UDRE->getName().getBaseIdentifier();
+  if (!(name.isOperator() && name.is("**")))
+    return false;
+
+  DC = DC->getModuleScopeContext();
+
+  auto &ctx = DC->getASTContext();
+  DeclNameRef powerName(ctx.getIdentifier("pow"));
+
+  // Look if 'pow(_:_:)' exists within current context.
+  auto lookUp = TypeChecker::lookupUnqualified(
+      DC, powerName, UDRE->getLoc(), defaultUnqualifiedLookupOptions);
+  if (lookUp) {
+    Diags.diagnose(UDRE->getLoc(), diag::nonexistent_power_operator)
+        .highlight(UDRE->getSourceRange());
+    return true;
+  }
+
+  return false;
+}
+
 static bool diagnoseIncDecOperator(DiagnosticEngine &Diags,
                                    UnresolvedDeclRefExpr *UDRE) {
   auto name = UDRE->getName().getBaseIdentifier();
@@ -446,7 +470,8 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
     // e.g. (x*-4) that needs whitespace.
     if (diagnoseRangeOperatorMisspell(Context.Diags, UDRE) ||
         diagnoseIncDecOperator(Context.Diags, UDRE) ||
-        diagnoseOperatorJuxtaposition(UDRE, DC)) {
+        diagnoseOperatorJuxtaposition(UDRE, DC) ||
+        diagnoseNonexistentPowerOperator(Context.Diags, UDRE, DC)) {
       return errorResult();
     }