Merge pull request #36012 from DougGregor/explicit-concurrent-closure

Add support for @Concurrent attribute on closures.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -276,6 +276,10 @@ ERROR(incorrect_explicit_closure_result,none,
       "declared closure result %0 is incompatible with contextual type %1",
       (Type, Type))
 
+ERROR(unsupported_closure_attr,none,
+      "%select{attribute |}0 '%1' is not supported on a closure",
+      (bool, StringRef))
+
 NOTE(suggest_expected_match,none,
      "%select{expected an argument list|produces result}0 of type '%1'",
      (bool, StringRef))

include/swift/AST/Expr.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_AST_EXPR_H
 #define SWIFT_AST_EXPR_H
 
+#include "swift/AST/Attr.h"
 #include "swift/AST/CaptureInfo.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DeclContext.h"
@@ -3771,6 +3772,9 @@ class ClosureExpr : public AbstractClosureExpr {
   };
 
 private:
+  /// The attributes attached to the closure.
+  DeclAttributes Attributes;
+
   /// The range of the brackets of the capture list, if present.
   SourceRange BracketRange;
 
@@ -3803,13 +3807,14 @@ class ClosureExpr : public AbstractClosureExpr {
   /// was originally just a single expression.
   llvm::PointerIntPair<BraceStmt *, 1, bool> Body;
 public:
-  ClosureExpr(SourceRange bracketRange, VarDecl *capturedSelfDecl,
+  ClosureExpr(const DeclAttributes &attributes,
+              SourceRange bracketRange, VarDecl *capturedSelfDecl,
               ParameterList *params, SourceLoc asyncLoc, SourceLoc throwsLoc,
               SourceLoc arrowLoc, SourceLoc inLoc, TypeExpr *explicitResultType,
               unsigned discriminator, DeclContext *parent)
     : AbstractClosureExpr(ExprKind::Closure, Type(), /*Implicit=*/false,
                           discriminator, parent),
-      BracketRange(bracketRange),
+      Attributes(attributes), BracketRange(bracketRange),
       CapturedSelfDecl(capturedSelfDecl),
       AsyncLoc(asyncLoc), ThrowsLoc(throwsLoc), ArrowLoc(arrowLoc),
       InLoc(inLoc),
@@ -3830,6 +3835,9 @@ class ClosureExpr : public AbstractClosureExpr {
     Body.setInt(isSingleExpression);
   }
 
+  DeclAttributes &getAttrs() { return Attributes; }
+  const DeclAttributes &getAttrs() const { return Attributes; }
+
   /// Determine whether the parameters of this closure are actually
   /// anonymous closure variables.
   bool hasAnonymousClosureVars() const {

include/swift/Parse/Parser.h

@@ -688,6 +688,9 @@ class Parser {
   /// Skip over SIL decls until we encounter the start of a Swift decl or eof.
   void skipSILUntilSwiftDecl();
 
+  /// Skip over any attribute.
+  void skipAnyAttribute();
+
   /// If the parser is generating only a syntax tree, try loading the current
   /// node from a previously generated syntax tree.
   /// Returns \c true if the node has been loaded and inserted into the current
@@ -1575,6 +1578,7 @@ class Parser {
   /// \returns ParserStatus error if an error occurred. Success if no signature
   /// is present or succssfully parsed.
   ParserStatus parseClosureSignatureIfPresent(
+          DeclAttributes &attributes,
           SourceRange &bracketRange,
           SmallVectorImpl<CaptureListEntry> &captureList,
           VarDecl *&capturedSelfParamDecl,

lib/Parse/ParseDecl.cpp

@@ -5728,6 +5728,15 @@ void Parser::skipSILUntilSwiftDecl() {
   }
 }
 
+void Parser::skipAnyAttribute() {
+  consumeToken(tok::at_sign);
+  if (!consumeIf(tok::identifier))
+    return;
+
+  if (consumeIf(tok::l_paren))
+    skipUntil(tok::r_paren);
+}
+
 /// Returns a descriptive name for the given accessor/addressor kind.
 static StringRef getAccessorNameForDiagnostic(AccessorKind accessorKind,
                                               bool article) {

lib/Parse/ParseExpr.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/Parse/Parser.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/Attr.h"
 #include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/TypeRepr.h"
 #include "swift/Basic/EditorPlaceholder.h"
@@ -2335,6 +2336,7 @@ static void printTupleNames(const TypeRepr *typeRepr, llvm::raw_ostream &OS) {
 }
 
 ParserStatus Parser::parseClosureSignatureIfPresent(
+    DeclAttributes &attributes,
     SourceRange &bracketRange,
     SmallVectorImpl<CaptureListEntry> &captureList,
     VarDecl *&capturedSelfDecl,
@@ -2344,6 +2346,7 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
     TypeExpr *&explicitResultType, SourceLoc &inLoc) {
   // Clear out result parameters.
   bracketRange = SourceRange();
+  attributes = DeclAttributes();
   capturedSelfDecl = nullptr;
   params = nullptr;
   throwsLoc = SourceLoc();
@@ -2360,9 +2363,16 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
 
   // If we have a leading token that may be part of the closure signature, do a
   // speculative parse to validate it and look for 'in'.
-  if (Tok.isAny(tok::l_paren, tok::l_square, tok::identifier, tok::kw__)) {
+  if (Tok.isAny(
+          tok::at_sign, tok::l_paren, tok::l_square, tok::identifier,
+          tok::kw__)) {
     BacktrackingScope backtrack(*this);
 
+    // Consume attributes.
+    while (Tok.is(tok::at_sign)) {
+      skipAnyAttribute();
+    }
+
     // Skip by a closure capture list if present.
     if (consumeIf(tok::l_square)) {
       skipUntil(tok::r_square);
@@ -2425,6 +2435,9 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
   }
   ParserStatus status;
   SyntaxParsingContext ClosureSigCtx(SyntaxContext, SyntaxKind::ClosureSignature);
+
+  (void)parseDeclAttributeList(attributes);
+
   if (Tok.is(tok::l_square) && peekToken().is(tok::r_square)) {
 
     SyntaxParsingContext CaptureCtx(SyntaxContext,
@@ -2721,6 +2734,7 @@ ParserResult<Expr> Parser::parseExprClosure() {
   SourceLoc leftBrace = consumeToken();
 
   // Parse the closure-signature, if present.
+  DeclAttributes attributes;
   SourceRange bracketRange;
   SmallVector<CaptureListEntry, 2> captureList;
   VarDecl *capturedSelfDecl;
@@ -2731,8 +2745,8 @@ ParserResult<Expr> Parser::parseExprClosure() {
   TypeExpr *explicitResultType;
   SourceLoc inLoc;
   Status |= parseClosureSignatureIfPresent(
-      bracketRange, captureList, capturedSelfDecl, params, asyncLoc, throwsLoc,
-      arrowLoc, explicitResultType, inLoc);
+      attributes, bracketRange, captureList, capturedSelfDecl, params, asyncLoc,
+      throwsLoc, arrowLoc, explicitResultType, inLoc);
 
   // If the closure was created in the context of an array type signature's
   // size expression, there will not be a local context. A parse error will
@@ -2748,8 +2762,8 @@ ParserResult<Expr> Parser::parseExprClosure() {
 
   // Create the closure expression and enter its context.
   auto *closure = new (Context) ClosureExpr(
-      bracketRange, capturedSelfDecl, params, asyncLoc, throwsLoc, arrowLoc,
-      inLoc, explicitResultType, discriminator, CurDeclContext);
+      attributes, bracketRange, capturedSelfDecl, params, asyncLoc, throwsLoc,
+      arrowLoc, inLoc, explicitResultType, discriminator, CurDeclContext);
   ParseFunctionBody cc(*this, closure);
 
   // Handle parameters.

lib/Sema/CSApply.cpp

@@ -7640,8 +7640,12 @@ namespace {
           });
 
       switch (result) {
-      case SolutionApplicationToFunctionResult::Success:
+      case SolutionApplicationToFunctionResult::Success: {
+        if (auto closure = dyn_cast_or_null<ClosureExpr>(
+                fn.getAbstractClosureExpr()))
+          TypeChecker::checkClosureAttributes(closure);
         return false;
+      }
 
       case SolutionApplicationToFunctionResult::Failure:
         return true;

lib/Sema/ConstraintSystem.cpp

@@ -2358,17 +2358,19 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
   // set of effects.
   bool throws = expr->getThrowsLoc().isValid();
   bool async = expr->getAsyncLoc().isValid();
+  bool concurrent = expr->getAttrs().hasAttribute<ConcurrentAttr>();
   if (throws || async) {
     return ASTExtInfoBuilder()
       .withThrows(throws)
       .withAsync(async)
+      .withConcurrent(concurrent)
       .build();
   }
 
   // Scan the body to determine the effects.
   auto body = expr->getBody();
   if (!body)
-    return FunctionType::ExtInfo();
+    return ASTExtInfoBuilder().withConcurrent(concurrent).build();
 
   auto throwFinder = FindInnerThrows(*this, expr);
   body->walk(throwFinder);
@@ -2377,6 +2379,7 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
   auto result = ASTExtInfoBuilder()
     .withThrows(throwFinder.foundThrow())
     .withAsync(asyncFinder.foundAsync())
+    .withConcurrent(concurrent)
     .build();
   closureEffectsCache[expr] = result;
   return result;

lib/Sema/DebuggerTestingTransform.cpp

@@ -226,7 +226,8 @@ class DebuggerTestingTransform : public ASTWalker {
     // Create the closure.
     auto *Params = ParameterList::createEmpty(Ctx);
     auto *Closure = new (Ctx)
-        ClosureExpr(SourceRange(), nullptr, Params, SourceLoc(), SourceLoc(),
+        ClosureExpr(DeclAttributes(), SourceRange(), nullptr, Params,
+                    SourceLoc(), SourceLoc(),
                     SourceLoc(), SourceLoc(), nullptr,
                     DF.getNextDiscriminator(), getCurrentDeclContext());
     Closure->setImplicit(true);

lib/Sema/TypeCheckAttr.cpp

@@ -5475,4 +5475,35 @@ void AttributeChecker::visitReasyncAttr(ReasyncAttr *attr) {
   // FIXME
 }
 
-void AttributeChecker::visitAtReasyncAttr(AtReasyncAttr *attr) {}
+void AttributeChecker::visitAtReasyncAttr(AtReasyncAttr *attr) {}
+
+namespace {
+
+class ClosureAttributeChecker
+    : public AttributeVisitor<ClosureAttributeChecker> {
+  ASTContext &ctx;
+public:
+  ClosureAttributeChecker(ClosureExpr *closure)
+    : ctx(closure->getASTContext()) { }
+
+  void visitDeclAttribute(DeclAttribute *attr) {
+    ctx.Diags.diagnose(
+        attr->getLocation(), diag::unsupported_closure_attr,
+        attr->isDeclModifier(), attr->getAttrName())
+      .fixItRemove(attr->getRangeWithAt());
+    attr->setInvalid();
+  }
+
+  void visitConcurrentAttr(ConcurrentAttr *attr) {
+    // Nothing else to check.
+  }
+};
+
+}
+
+void TypeChecker::checkClosureAttributes(ClosureExpr *closure) {
+  ClosureAttributeChecker checker(closure);
+  for (auto attr : closure->getAttrs()) {
+    checker.visit(attr);
+  }
+}

lib/Sema/TypeCheckStmt.cpp

@@ -2077,6 +2077,7 @@ TypeCheckFunctionBodyRequest::evaluate(Evaluator &evaluator,
 }
 
 bool TypeChecker::typeCheckClosureBody(ClosureExpr *closure) {
+  TypeChecker::checkClosureAttributes(closure);
   TypeChecker::checkParameterList(closure->getParameters(), closure);
 
   BraceStmt *body = closure->getBody();

lib/Sema/TypeChecker.h

@@ -451,6 +451,7 @@ void typeCheckDecl(Decl *D);
 
 void addImplicitDynamicAttribute(Decl *D);
 void checkDeclAttributes(Decl *D);
+void checkClosureAttributes(ClosureExpr *closure);
 void checkParameterList(ParameterList *params, DeclContext *owner);
 
 void diagnoseDuplicateBoundVars(Pattern *pattern);

test/attr/attr_concurrent.swift

@@ -118,3 +118,10 @@ func testCaseNonTrivialValue() {
 
   j = 17
 }
+
+func testExplicitConcurrentClosure() {
+  let fn = { @concurrent in
+    17
+  }
+  let _: String = fn // expected-error{{cannot convert value of type '@concurrent () -> Int' to specified type 'String'}}
+}

test/attr/closures.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift -swift-version 5
+
+func testNonacceptedClosures() {
+  let fn = { @usableFromInline in // expected-error{{'usableFromInline' is not supported on a closure}}
+    "hello"
+  }
+
+  let fn2: (Int) -> Int = { @usableFromInline x in  // expected-error{{'usableFromInline' is not supported on a closure}}
+    print("hello")
+    return x
+  }
+
+  _ = fn
+  _ = fn2
+}