Added @escaping attribute parsing

tanadeau · tanadeau · commit 6ef59c09e558 · 2016-07-08T21:14:39.000-04:00
diff --git a/include/swift/AST/Attr.def b/include/swift/AST/Attr.def
@@ -35,6 +35,7 @@ TYPE_ATTR(autoclosure)
 TYPE_ATTR(convention)
 TYPE_ATTR(noreturn)
 TYPE_ATTR(noescape)
+TYPE_ATTR(escaping)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)
@@ -263,6 +264,8 @@ SIMPLE_DECL_ATTR(discardableResult, DiscardableResult,
 
 SIMPLE_DECL_ATTR(GKInspectable, GKInspectable, OnVar, 66)
 
+SIMPLE_DECL_ATTR(escaping, Escaping, OnParam, 67)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef SIMPLE_DECL_ATTR
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -1247,7 +1247,6 @@ ERROR(attr_swift3_migration_expected_rparen,none,
 ERROR(attr_bad_swift_name,none,
       "ill-formed Swift name '%0'", (StringRef))
 
-
 // unowned
 ERROR(attr_unowned_invalid_specifier,none,
       "expected 'safe' or 'unsafe'", ())
@@ -1260,6 +1259,10 @@ WARNING(attr_warn_unused_result_removed,none,
 ERROR(attr_warn_unused_result_expected_rparen,none,
       "expected ')' after 'warn_unused_result' attribute", ())
 
+// escaping
+ERROR(attr_escaping_conflicts_noescape,none,
+      "@escaping conflicts with @noescape", ())
+
 //------------------------------------------------------------------------------
 // Generics parsing diagnostics
 //------------------------------------------------------------------------------
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1788,7 +1788,8 @@ ERROR(noescape_implied_by_autoclosure,none,
       "redundantly specified", ())
 ERROR(noescape_conflicts_escaping_autoclosure,none,
       "@noescape conflicts with @autoclosure(escaping)", ())
-
+ERROR(escaping_function_type,none,
+      "@escaping may only be applied to parameters of function type", ())
 
 // NSManaged attribute
 ERROR(attr_NSManaged_not_instance_member,none,
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -2159,11 +2159,12 @@ class AnyFunctionType : public TypeBase {
     //   |representation|isAutoClosure|noReturn|noEscape|throws|
     //   |    0 .. 3    |      4      |   5    |    6   |   7  |
     //
-    enum : uint16_t { RepresentationMask = 0x00F };
-    enum : uint16_t { AutoClosureMask    = 0x010 };
-    enum : uint16_t { NoReturnMask       = 0x020 };
-    enum : uint16_t { NoEscapeMask       = 0x040 };
-    enum : uint16_t { ThrowsMask         = 0x080 };
+    enum : uint16_t { RepresentationMask     = 0x00F };
+    enum : uint16_t { AutoClosureMask        = 0x010 };
+    enum : uint16_t { NoReturnMask           = 0x020 };
+    enum : uint16_t { NoEscapeMask           = 0x040 };
+    enum : uint16_t { ThrowsMask             = 0x080 };
+    enum : uint16_t { ExplicitlyEscapingMask = 0x100 };
 
     uint16_t Bits;
 
@@ -2186,15 +2187,18 @@ class AnyFunctionType : public TypeBase {
 
     // Constructor with no defaults.
     ExtInfo(Representation Rep, bool IsNoReturn,
-            bool IsAutoClosure, bool IsNoEscape, bool Throws)
+            bool IsAutoClosure, bool IsNoEscape, bool IsExplicitlyEscaping,
+            bool Throws)
       : ExtInfo(Rep, IsNoReturn, Throws) {
       Bits |= (IsAutoClosure ? AutoClosureMask : 0);
       Bits |= (IsNoEscape ? NoEscapeMask : 0);
+      Bits |= (IsExplicitlyEscaping ? ExplicitlyEscapingMask : 0);
     }
 
     bool isNoReturn() const { return Bits & NoReturnMask; }
     bool isAutoClosure() const { return Bits & AutoClosureMask; }
     bool isNoEscape() const { return Bits & NoEscapeMask; }
+    bool isExplicitlyEscaping() const { return Bits & ExplicitlyEscapingMask; }
     bool throws() const { return Bits & ThrowsMask; }
     Representation getRepresentation() const {
       unsigned rawRep = Bits & RepresentationMask;
@@ -2327,6 +2331,12 @@ class AnyFunctionType : public TypeBase {
   bool isNoEscape() const {
     return getExtInfo().isNoEscape();
   }
+
+  /// \brief True if the parameter declaration it is attached to has explicitly
+  /// been marked with the @escaping attribute. This is a temporary measure.
+  bool isExplicitlyEscaping() const {
+    return getExtInfo().isExplicitlyEscaping();
+  }
   
   bool throws() const {
     return getExtInfo().throws();
diff --git a/include/swift/Serialization/ModuleFormat.h b/include/swift/Serialization/ModuleFormat.h
@@ -590,6 +590,7 @@ namespace decls_block {
     BCFixed<1>,  // auto-closure?
     BCFixed<1>,  // noreturn?
     BCFixed<1>,  // noescape?
+    BCFixed<1>,  // explicitlyEscaping?
     BCFixed<1>   // throws?
   >;
 
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -2899,6 +2899,7 @@ namespace {
       printFlag(T->isNoReturn(), "noreturn");
       printFlag(T->isAutoClosure(), "autoclosure");
       printFlag(T->isNoEscape(), "noescape");
+      printFlag(T->isExplicitlyEscaping(), "escaping");
       printFlag(T->throws(), "throws");
 
       printRec("input", T->getInput());
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3655,9 +3655,12 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         Printer << "@autoclosure ";
       else
         Printer << "@autoclosure(escaping) ";
-    } else if (info.isNoEscape())
+    } else if (info.isNoEscape()) {
       // autoclosure implies noescape.
       Printer << "@noescape ";
+    } else if (info.isExplicitlyEscaping()) {
+      Printer << "@escaping ";
+    }
 
     if (Options.PrintFunctionRepresentationAttrs) {
       // TODO: coalesce into a single convention attribute.
diff --git a/lib/AST/TypeRepr.cpp b/lib/AST/TypeRepr.cpp
@@ -283,6 +283,7 @@ void AttributedTypeRepr::printAttrs(ASTPrinter &Printer) const {
   case 2: Printer << "@autoclosure(escaping) "; break;
   case 3: Printer << "@autoclosure "; break;
   }
+  if (Attrs.has(TAK_escaping))     Printer << "@escaping ";
   if (Attrs.has(TAK_thin))         Printer << "@thin ";
   if (Attrs.has(TAK_thick))        Printer << "@thick ";
   if (Attrs.convention.hasValue()) {
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -1522,6 +1522,18 @@ bool Parser::parseTypeAttribute(TypeAttributes &Attributes, bool justChecking) {
       diagnose(Loc, diag::attr_noescape_conflicts_escaping_autoclosure);
       return false;
     }
+    // You can't specify @noescape and @escaping together.
+    if (Attributes.has(TAK_escaping)) {
+      diagnose(Loc, diag::attr_escaping_conflicts_noescape);
+      return false;
+    }
+    break;
+  case TAK_escaping:
+    // You can't specify @noescape and @escaping together.
+    if (Attributes.has(TAK_noescape)) {
+      diagnose(Loc, diag::attr_escaping_conflicts_noescape);
+      return false;
+    }
     break;
   case TAK_out:
   case TAK_in:
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -5480,6 +5480,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
                                         toEI.isNoReturn() | fromEI.isNoReturn(),
                                         toEI.isAutoClosure(),
                                         toEI.isNoEscape() | fromEI.isNoEscape(),
+                                        toEI.isExplicitlyEscaping() | fromEI.isExplicitlyEscaping(),
                                         toEI.throws() & fromEI.throws());
         auto newToType = FunctionType::get(fromFunc->getInput(),
                                            fromFunc->getResult(), newEI);
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -98,6 +98,15 @@ class AttributeEarlyChecker : public AttributeVisitor<AttributeEarlyChecker> {
     TC.checkNoEscapeAttr(cast<ParamDecl>(D), attr);
   }
 
+  void visitEscapingAttr(EscapingAttr *attr) {
+    auto *PD = cast<ParamDecl>(D);
+    auto *FTy = PD->getType()->getAs<FunctionType>();
+    if (FTy == 0) {
+      TC.diagnose(attr->getLocation(), diag::escaping_function_type);
+      attr->setInvalid();
+    }
+  }
+
   void visitTransparentAttr(TransparentAttr *attr);
   void visitMutationAttr(DeclAttribute *attr);
   void visitMutatingAttr(MutatingAttr *attr) { visitMutationAttr(attr); }
@@ -668,6 +677,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     IGNORED_ATTR(WarnUnqualifiedAccess)
     IGNORED_ATTR(ShowInInterface)
     IGNORED_ATTR(DiscardableResult)
+    IGNORED_ATTR(Escaping)
 
     // FIXME: We actually do have things to enforce for versioned API.
     IGNORED_ATTR(Versioned)
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -5223,6 +5223,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // These can't appear on overridable declarations.
     UNINTERESTING_ATTR(AutoClosure)
     UNINTERESTING_ATTR(NoEscape)
+    UNINTERESTING_ATTR(Escaping)
 
     UNINTERESTING_ATTR(Prefix)
     UNINTERESTING_ATTR(Postfix)
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -1739,7 +1739,8 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
   // function-type creator.
   static const TypeAttrKind FunctionAttrs[] = {
     TAK_convention, TAK_noreturn, TAK_pseudogeneric,
-    TAK_callee_owned, TAK_callee_guaranteed, TAK_noescape, TAK_autoclosure
+    TAK_callee_owned, TAK_callee_guaranteed, TAK_noescape, TAK_autoclosure,
+    TAK_escaping
   };
 
   auto checkUnsupportedAttr = [&](TypeAttrKind attr) {
@@ -1858,6 +1859,7 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
                                   attrs.has(TAK_noreturn),
                                   attrs.has(TAK_autoclosure),
                                   attrs.has(TAK_noescape),
+                                  attrs.has(TAK_escaping),
                                   fnRepr->throws());
 
     ty = resolveASTFunctionType(fnRepr, options, extInfo);
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -3439,13 +3439,14 @@ Type ModuleFile::getType(TypeID TID) {
     TypeID inputID;
     TypeID resultID;
     uint8_t rawRepresentation;
-    bool autoClosure, noreturn, noescape, throws;
+    bool autoClosure, noreturn, noescape, explicitlyEscaping, throws;
 
     decls_block::FunctionTypeLayout::readRecord(scratch, inputID, resultID,
                                                 rawRepresentation,
                                                 autoClosure,
                                                 noreturn,
                                                 noescape,
+                                                explicitlyEscaping,
                                                 throws);
     auto representation = getActualFunctionTypeRepresentation(rawRepresentation);
     if (!representation.hasValue()) {
@@ -3454,7 +3455,8 @@ Type ModuleFile::getType(TypeID TID) {
     }
     
     auto Info = FunctionType::ExtInfo(*representation,
-                               noreturn, autoClosure, noescape, throws);
+                               noreturn, autoClosure, noescape,
+                               explicitlyEscaping, throws);
     
     typeOrOffset = FunctionType::get(getType(inputID), getType(resultID),
                                      Info);
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -2954,6 +2954,7 @@ void Serializer::writeType(Type ty) {
            fnTy->isAutoClosure(),
            fnTy->isNoReturn(),
            fnTy->isNoEscape(),
+           fnTy->isExplicitlyEscaping(),
            fnTy->throws());
     break;
   }
diff --git a/test/IDE/complete_decl_attribute.swift b/test/IDE/complete_decl_attribute.swift
@@ -35,9 +35,10 @@
 
 func method(@#^KEYWORD1^#) {}
 
-// KEYWORD1:                  Begin completions, 2 items
+// KEYWORD1:                  Begin completions, 3 items
 // KEYWORD1-NEXT:             Keyword/None:                       autoclosure[#Param Attribute#]; name=autoclosure{{$}}
 // KEYWORD1-NEXT:             Keyword/None:                       noescape[#Param Attribute#]; name=noescape{{$}}
+// KEYWORD1-NEXT:             Keyword/None:                       escaping[#Param Attribute#]; name=escaping{{$}}
 // KEYWORD1-NEXT:             End completions
 
 @#^KEYWORD2^#
@@ -89,7 +90,7 @@ struct S{}
 
 @#^KEYWORD_LAST^#
 
-// KEYWORD_LAST:                  Begin completions, 21 items
+// KEYWORD_LAST:                  Begin completions, 22 items
 // KEYWORD_LAST-NEXT:             Keyword/None:                       available[#Declaration Attribute#]; name=available{{$}}
 // KEYWORD_LAST-NEXT:             Keyword/None:                       objc[#Declaration Attribute#]; name=objc{{$}}
 // KEYWORD_LAST-NEXT:             Keyword/None:                       swift3_migration[#Declaration Attribute#]; name=swift3_migration{{$}}
@@ -111,4 +112,5 @@ struct S{}
 // KEYWORD_LAST-NEXT:             Keyword/None:                       warn_unqualified_access[#Declaration Attribute#]; name=warn_unqualified_access
 // KEYWORD_LAST-NEXT:             Keyword/None:                       discardableResult[#Declaration Attribute#]; name=discardableResult
 // KEYWORD_LAST-NEXT:             Keyword/None:                       GKInspectable[#Declaration Attribute#]; name=GKInspectable{{$}}
+// KEYWORD_LAST-NEXT:             Keyword/None:                       escaping[#Declaration Attribute#]; name=escaping{{$}}
 // KEYWORD_LAST-NEXT:             End completions
diff --git a/test/IDE/print_ast_tc_decls.swift b/test/IDE/print_ast_tc_decls.swift
@@ -1320,6 +1320,11 @@ public func ParamAttrs3(a : @noescape () -> ()) {
   a()
 }
 
+// PASS_PRINT_AST: public func ParamAttrs4(a: @escaping () -> ())
+public func ParamAttrs4(a : @escaping () -> ()) {
+  a()
+}
+
 // Protocol extensions
 
 protocol ProtocolToExtend {
diff --git a/test/attr/attr_escaping.swift b/test/attr/attr_escaping.swift
@@ -0,0 +1,9 @@
+// RUN: %target-parse-verify-swift
+
+@escaping var fn : () -> Int = { 4 }  // expected-error {{@escaping may only be used on 'parameter' declarations}} {{1-11=}}
+
+func wrongParamType(a: @escaping Int) {} // expected-error {{@escaping attribute only applies to function types}}
+
+func conflictingAttrs(_ fn: @noescape @escaping () -> Int) {} // expected-error {{@escaping conflicts with @noescape}}
+
+func takesEscaping(_ fn: @escaping () -> Int) {} // ok
diff --git a/test/attr/attr_noescape.swift b/test/attr/attr_noescape.swift
@@ -2,6 +2,8 @@
 
 @noescape var fn : () -> Int = { 4 }  // expected-error {{@noescape may only be used on 'parameter' declarations}} {{1-11=}}
 
+func conflictingAttrs(_ fn: @noescape @escaping () -> Int) {} // expected-error {{@escaping conflicts with @noescape}}
+
 func doesEscape(_ fn : () -> Int) {}
 
 func takesGenericClosure<T>(_ a : Int, _ fn : @noescape () -> T) {}

Original file line number	Diff line number	Diff line change
`@@ -283,6 +283,7 @@ void AttributedTypeRepr::printAttrs(ASTPrinter &Printer) const {`
`283`	`283`	`case 2: Printer << "@autoclosure(escaping) "; break;`
`284`	`284`	`case 3: Printer << "@autoclosure "; break;`
`285`	`285`	`}`
	`286`	`+ if (Attrs.has(TAK_escaping)) Printer << "@escaping ";`
`286`	`287`	`if (Attrs.has(TAK_thin)) Printer << "@thin ";`
`287`	`288`	`if (Attrs.has(TAK_thick)) Printer << "@thick ";`
`288`	`289`	`if (Attrs.convention.hasValue()) {`