Progress towards implementing SE-0049 - Allow autoclosure in parameter types

lattner · lattner · commit ab14e6706f91 · 2016-04-14T23:13:43.000-07:00
as well as on parameter decls.  Also, tighten up the type checker to look at
parameter types instead of decl attributes in some cases (exposing a type
checker bug).

Still TODO:
 - Reject autoclosure/noescape on non-parameter types.
 - Move stdlib and other code to use noescape and autoclosure in the right
   spot.
 - Warn about autoclosure/noescape on parameters decls, with a fixit to move it.
 - Upgrade the warning to an error.
diff --git a/include/swift/AST/Attr.def b/include/swift/AST/Attr.def
@@ -31,8 +31,10 @@
 #endif
 
 // Type attributes
+TYPE_ATTR(autoclosure)
 TYPE_ATTR(convention)
 TYPE_ATTR(noreturn)
+TYPE_ATTR(noescape)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)
@@ -46,7 +48,6 @@ TYPE_ATTR(in)
 TYPE_ATTR(inout)
 TYPE_ATTR(inout_aliasable)
 TYPE_ATTR(in_guaranteed)
-TYPE_ATTR(noescape)
 TYPE_ATTR(owned)
 TYPE_ATTR(unowned_inner_pointer)
 TYPE_ATTR(guaranteed)
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -2972,7 +2972,8 @@ class ClosureExpr : public AbstractClosureExpr {
 /// when a scalar expression is converted to @autoclosure function type.
 /// For example:
 /// \code
-///   @autoclosure var x : () -> Int = 4
+///   func f(x : @autoclosure () -> Int)
+///   f(42)  // AutoclosureExpr convert from Int to ()->Int
 /// \endcode
 class AutoClosureExpr : public AbstractClosureExpr {
   BraceStmt *Body;
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -2362,13 +2362,10 @@ BEGIN_CAN_TYPE_WRAPPER(AnyFunctionType, Type)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getResult)
 END_CAN_TYPE_WRAPPER(AnyFunctionType, Type)
 
-/// FunctionType - A monomorphic function type.
+/// FunctionType - A monomorphic function type, specified with an arrow.
 ///
-/// If the AutoClosure bit is set to true, then the input type is known to be ()
-/// and a value of this function type is only assignable (in source code) from
-/// the destination type of the function. Sema inserts an ImplicitClosure to
-/// close over the value.  For example:
-///   @autoclosure var x : () -> Int = 4
+/// For example:
+///   let x : (Float, Int) -> Int
 class FunctionType : public AnyFunctionType {
 public:
   /// 'Constructor' Factory Function
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3695,9 +3695,12 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       return Options.ExcludeAttrList.end() != std::find(Options.ExcludeAttrList.
         begin(), Options.ExcludeAttrList.end(), Kind);
     };
-    if (info.isAutoClosure() && !IsAttrExcluded(DAK_AutoClosure))
-      Printer << "@autoclosure ";
-    else if (info.isNoEscape() && !IsAttrExcluded(DAK_NoEscape))
+    if (info.isAutoClosure() && !IsAttrExcluded(DAK_AutoClosure)) {
+      if (info.isNoEscape())
+        Printer << "@autoclosure ";
+      else
+        Printer << "@autoclosure(escaping) ";
+    } else if (info.isNoEscape() && !IsAttrExcluded(DAK_NoEscape))
       // autoclosure implies noescape.
       Printer << "@noescape ";
 
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -1546,6 +1546,37 @@ bool Parser::parseTypeAttribute(TypeAttributes &Attributes, bool justChecking) {
     Attributes.setAttr(attr, Loc);
   }
   
+  // Handle @autoclosure(escaping)
+  if (attr == TAK_autoclosure) {
+    bool isEscaping = false;
+
+    // We need to do a bit of lookahead here to make sure we parse a (weird)
+    // type like: "@autoclosure (escaping) -> Int" correctly (escaping is the
+    // name of a type here).  We also want to support the case where the
+    // function type coming up is a typealias, e.g. "@autoclosure (escaping) T".
+    if (Tok.is(tok::l_paren) && peekToken().getText() == "escaping") {
+      Parser::BacktrackingScope Backtrack(*this);
+      consumeToken(tok::l_paren);
+      consumeToken(tok::identifier);
+      isEscaping = Tok.is(tok::r_paren) && peekToken().isNot(tok::arrow);
+    }
+
+    if (isEscaping) {
+      consumeToken(tok::l_paren);
+      consumeToken(tok::identifier);
+      consumeToken(tok::r_paren);
+    }
+    
+    if (!justChecking) {
+      if (isEscaping)
+        ;
+      else
+        Attributes.setAttr(TAK_noescape, Loc);
+    }
+  }
+  
+  
+  
   // Handle any attribute-specific processing logic.
 
   // In just-checking mode, we only need additional parsing for the "cc"
@@ -1697,9 +1728,9 @@ bool Parser::parseDeclAttributeList(DeclAttributes &Attributes,
       Token next = peekToken();
       auto Kind = TypeAttributes::getAttrKindFromString(next.getText());
 
-      // noescape is only valid as a decl attribute and type attribute (in
-      // parameter lists) but we disambiguate it as a decl attribute.
-      if (Kind == TAK_noescape)
+      // noescape/autoclosure are valid as a decl attribute and type attribute
+      // (in parameter lists) but we disambiguate them as a decl attribute.
+      if (Kind == TAK_noescape || Kind == TAK_autoclosure)
         Kind = TAK_Count;
 
       if (Kind != TAK_Count)
diff --git a/lib/Sema/CSSolver.cpp b/lib/Sema/CSSolver.cpp
@@ -290,7 +290,7 @@ enumerateDirectSupertypes(TypeChecker &tc, Type type) {
     // FIXME: Can weaken input type, but we really don't want to get in the
     // business of strengthening the result type.
 
-    // An [autoclosure] function type can be viewed as scalar of the result
+    // An @autoclosure function type can be viewed as scalar of the result
     // type.
     if (functionTy->isAutoClosure())
       result.push_back(functionTy->getResult());
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -446,8 +446,7 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
 
       TC.diagnose(DRE->getStartLoc(), diag::invalid_noescape_use,
                   DRE->getDecl()->getName(), isa<ParamDecl>(DRE->getDecl()));
-      if (DRE->getDecl()->getAttrs().hasAttribute<AutoClosureAttr>() &&
-          DRE->getDecl()->getAttrs().getAttribute<NoEscapeAttr>()->isImplicit())
+      if (AFT->isAutoClosure())
         TC.diagnose(DRE->getDecl()->getLoc(), diag::noescape_autoclosure,
                     DRE->getDecl()->getName());
     }
diff --git a/lib/Sema/TypeCheckExpr.cpp b/lib/Sema/TypeCheckExpr.cpp
@@ -821,7 +821,8 @@ namespace {
 
       // If VD is a noescape decl, then the closure we're computing this for
       // must also be noescape.
-      if (VD->getAttrs().hasAttribute<NoEscapeAttr>() &&
+      if (VD->hasType() && VD->getType()->is<AnyFunctionType>() &&
+          VD->getType()->castTo<AnyFunctionType>()->isNoEscape() &&
           !capture.isNoEscape() &&
           // Don't repeatedly diagnose the same thing.
           Diagnosed.insert(VD).second) {
@@ -832,8 +833,7 @@ namespace {
         TC.diagnose(Loc, isDecl ? diag::decl_closure_noescape_use :
                     diag::closure_noescape_use, VD->getName());
 
-        if (VD->getAttrs().hasAttribute<AutoClosureAttr>() &&
-            VD->getAttrs().getAttribute<NoEscapeAttr>()->isImplicit())
+        if (VD->getType()->castTo<AnyFunctionType>()->isAutoClosure())
           TC.diagnose(VD->getLoc(), diag::noescape_autoclosure,
                       VD->getName());
       }
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -1601,7 +1601,7 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
   // function-type creator.
   static const TypeAttrKind FunctionAttrs[] = {
     TAK_objc_block, TAK_convention, TAK_thin, TAK_noreturn,
-    TAK_callee_owned, TAK_callee_guaranteed, TAK_noescape
+    TAK_callee_owned, TAK_callee_guaranteed, TAK_noescape, TAK_autoclosure
   };
 
   auto checkUnsupportedAttr = [&](TypeAttrKind attr) {
@@ -1649,8 +1649,6 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
       thin = false;
     }
     
-    bool isNoEscape = attrs.has(TAK_noescape);
-
     auto calleeConvention = ParameterConvention::Direct_Unowned;
     if (attrs.has(TAK_callee_owned)) {
       if (attrs.has(TAK_callee_guaranteed)) {
@@ -1783,8 +1781,8 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
       // Resolve the function type directly with these attributes.
       FunctionType::ExtInfo extInfo(rep,
                                     attrs.has(TAK_noreturn),
-                                    /*autoclosure is a decl attr*/false,
-                                    isNoEscape,
+                                    attrs.has(TAK_autoclosure),
+                                    attrs.has(TAK_noescape),
                                     fnRepr->throws());
 
       ty = resolveASTFunctionType(fnRepr, options, extInfo);
diff --git a/test/attr/attr_autoclosure.swift b/test/attr/attr_autoclosure.swift
@@ -23,7 +23,7 @@ func func8(@autoclosure _ x: inout () -> Bool) -> Bool {  // expected-error {{@a
 
 
 // <rdar://problem/19707366> QoI: @autoclosure declaration change fixit
-let migrate4 : @autoclosure() -> ()   // expected-error {{attribute can only be applied to declarations, not types}} {{1-1=@autoclosure }} {{16-28=}}
+let migrate4 : (@autoclosure() -> ())->()
 
 
 struct SomeStruct {
@@ -110,8 +110,13 @@ class TestFunc12 {
 
 
 enum AutoclosureFailableOf<T> {
-  case Success(@autoclosure () -> T)  // expected-error {{attribute can only be applied to declarations, not types}}
+  case Success(@autoclosure () -> T)
   case Failure()
 }
 
+let _ : (@autoclosure () -> ()) -> ()
+let _ : (@autoclosure(escaping) () -> ()) -> ()
+
+// escaping is the name of param type
+let _ : (@autoclosure(escaping) -> ()) -> ()  // expected-error {{use of undeclared type 'escaping'}}
 
diff --git a/test/attr/attr_noescape.swift b/test/attr/attr_noescape.swift
@@ -260,12 +260,12 @@ var escape : CompletionHandlerNE
 func doThing1(@noescape _ completion: CompletionHandler) {
   // expected-error @+2 {{@noescape value 'escape' may only be called}}
   // expected-error @+1 {{@noescape parameter 'completion' may only be called}}
-  escape = completion
+  escape = completion // expected-error {{declaration closing over @noescape parameter 'escape' may allow it to escape}}
 }
 func doThing2(_ completion: CompletionHandlerNE) {
   // expected-error @+2 {{@noescape value 'escape' may only be called}}
   // expected-error @+1 {{@noescape parameter 'completion' may only be called}}
-  escape = completion
+  escape = completion // expected-error {{declaration closing over @noescape parameter 'escape' may allow it to escape}}
 }
 
 // <rdar://problem/19997680> @noescape doesn't work on parameters of function type
@@ -296,7 +296,7 @@ enum r19997577Type {
 func noescapeD(@noescape f: () -> Bool) {} // ok
 func noescapeT(f: @noescape () -> Bool) {} // ok
 func autoclosureD(@autoclosure f: () -> Bool) {} // ok
-func autoclosureT(f: @autoclosure () -> Bool) {} // expected-error {{attribute can only be applied to declarations, not types}} {{1-1=@autoclosure }} {{22-35=}}
+func autoclosureT(f: @autoclosure () -> Bool) {}  // ok
 
 func noescapeD_noescapeT(@noescape f: @noescape () -> Bool) {} // ok
 func autoclosureD_noescapeT(@autoclosure f: @noescape () -> Bool) {} // ok

Original file line number	Diff line number	Diff line change
`@@ -446,8 +446,7 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,`
`446`	`446`
`447`	`447`	`TC.diagnose(DRE->getStartLoc(), diag::invalid_noescape_use,`
`448`	`448`	`DRE->getDecl()->getName(), isa<ParamDecl>(DRE->getDecl()));`
`449`		`- if (DRE->getDecl()->getAttrs().hasAttribute<AutoClosureAttr>() &&`
`450`		`- DRE->getDecl()->getAttrs().getAttribute<NoEscapeAttr>()->isImplicit())`
	`449`	`+ if (AFT->isAutoClosure())`
`451`	`450`	`TC.diagnose(DRE->getDecl()->getLoc(), diag::noescape_autoclosure,`
`452`	`451`	`DRE->getDecl()->getName());`
`453`	`452`	`}`