Merge pull request #4598 from jtbandes/swift-3.0-branch

[Swift 3] print `__attribute__((noescape))` in generated Obj-C headers

Author: tkremenek

lib/ClangImporter/ImportType.cpp

@@ -492,6 +492,7 @@ namespace {
         // FIXME: If we were walking TypeLocs, we could actually get parameter
         // names. The probably doesn't matter outside of a FuncDecl, which
         // we'll have to special-case, but it's an interesting bit of data loss.
+        // We also lose `noescape`. <https://bugs.swift.org/browse/SR-2529>
         params.push_back(swiftParamTy);
       }
 

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -81,6 +81,12 @@ namespace {
     Normal = false,
     CustomNamesOnly = true,
   };
+
+  /// Whether the type being printed is in function param position.
+  enum IsFunctionParam_t : bool {
+    IsFunctionParam = true,
+    IsNotFunctionParam = false,
+  };
 }
 
 static StringRef getNameForObjC(const ValueDecl *VD,
@@ -361,7 +367,7 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
         (clangParam && isNSUInteger(clangParam->getType()))) {
       os << "NSUInteger";
     } else {
-      print(param->getType(), OTK_None);
+      print(param->getType(), OTK_None, Identifier(), IsFunctionParam);
     }
     os << ")";
 
@@ -542,19 +548,6 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
 
     os << ";\n";
   }
-  
-  void printSingleFunctionParam(const ParamDecl *param) {
-    // The type name may be multi-part.
-    PrintMultiPartType multiPart(*this);
-    visitPart(param->getType(), OTK_None);
-    auto name = param->getName();
-    if (name.empty())
-      return;
-    
-    os << ' ' << name;
-    if (isClangKeyword(name))
-      os << "_";
-  }
 
   void printAbstractFunctionAsFunction(FuncDecl *FD) {
     printDocumentationComment(FD);
@@ -578,7 +571,8 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     auto params = FD->getParameterLists().back();
     interleave(*params,
                [&](const ParamDecl *param) {
-                 printSingleFunctionParam(param);
+                 print(param->getType(), OTK_None, param->getName(),
+                       IsFunctionParam);
                },
                [&]{ os << ", "; });
 
@@ -1437,12 +1431,13 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
       } else {
         interleave(tupleTy->getElements(),
                    [this](TupleTypeElt elt) {
-                     print(elt.getType(), OTK_None, elt.getName());
+                     print(elt.getType(), OTK_None, elt.getName(),
+                           IsFunctionParam);
                    },
                    [this] { os << ", "; });
       }
     } else {
-      print(paramsTy, OTK_None);
+      print(paramsTy, OTK_None, Identifier(), IsFunctionParam);
     }
     os << ")";
   }
@@ -1516,9 +1511,16 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
   /// visitPart().
 public:
   void print(Type ty, Optional<OptionalTypeKind> optionalKind, 
-             Identifier name = Identifier()) {
+             Identifier name = Identifier(),
+             IsFunctionParam_t isFuncParam = IsNotFunctionParam) {
     PrettyStackTraceType trace(M.getASTContext(), "printing", ty);
 
+    if (isFuncParam)
+      if (auto fnTy = ty->lookThroughAllAnyOptionalTypes()
+                        ->getAs<AnyFunctionType>())
+        if (fnTy->isNoEscape())
+          os << "SWIFT_NOESCAPE ";
+
     PrintMultiPartType multiPart(*this);
     visitPart(ty, optionalKind);
     if (!name.empty()) {
@@ -2080,6 +2082,11 @@ class ModuleWriter {
            "#else\n"
            "# define SWIFT_METHOD_FAMILY(X)\n"
            "#endif\n"
+           "#if defined(__has_attribute) && __has_attribute(noescape)\n"
+           "# define SWIFT_NOESCAPE __attribute__((noescape))\n"
+           "#else\n"
+           "# define SWIFT_NOESCAPE\n"
+           "#endif\n"
            "#if !defined(SWIFT_CLASS_EXTRA)\n"
            "# define SWIFT_CLASS_EXTRA\n"
            "#endif\n"

lib/Sema/TypeCheckType.cpp

@@ -1410,9 +1410,9 @@ static bool isDefaultNoEscapeContext(const DeclContext *DC) {
 }
 
 // Hack to apply context-specific @escaping to an AST function type.
-static Type adjustFunctionExtInfo(DeclContext *DC,
-                                  Type ty,
-                                  TypeResolutionOptions options) {
+static Type applyNonEscapingFromContext(DeclContext *DC,
+                                        Type ty,
+                                        TypeResolutionOptions options) {
   // Remember whether this is a function parameter.
   bool isFunctionParam =
     options.contains(TR_FunctionInput) ||
@@ -1426,7 +1426,12 @@ static Type adjustFunctionExtInfo(DeclContext *DC,
   if (defaultNoEscape && !extInfo.isNoEscape()) {
     extInfo = extInfo.withNoEscape();
 
-    // We lost the sugar to flip the isNoEscape bit
+    // We lost the sugar to flip the isNoEscape bit.
+    //
+    // FIXME: It would be better to add a new AttributedType sugared type,
+    // which would wrap the NameAliasType or ParenType, and apply the
+    // isNoEscape bit when de-sugaring.
+    // <https://bugs.swift.org/browse/SR-2520>
     return FunctionType::get(funcTy->getInput(), funcTy->getResult(), extInfo);
   }
 
@@ -1467,7 +1472,7 @@ Type TypeChecker::resolveIdentifierType(
   // Hack to apply context-specific @escaping to a typealias with an underlying
   // function type.
   if (result->is<FunctionType>())
-    result = adjustFunctionExtInfo(DC, result, options);
+    result = applyNonEscapingFromContext(DC, result, options);
 
   // We allow a type to conform to a protocol that is less available than
   // the type itself. This enables a type to retroactively model or directly
@@ -1716,7 +1721,7 @@ Type TypeResolver::resolveType(TypeRepr *repr, TypeResolutionOptions options) {
       // Default non-escaping for closure parameters
       auto result = resolveASTFunctionType(cast<FunctionTypeRepr>(repr), options);
       if (result && result->is<FunctionType>())
-        return adjustFunctionExtInfo(DC, result, options);
+        return applyNonEscapingFromContext(DC, result, options);
       return result;
     }
     return resolveSILFunctionType(cast<FunctionTypeRepr>(repr), options);
@@ -1973,10 +1978,6 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
           .fixItReplace(resultRange, "Never");
     }
 
-    if (attrs.has(TAK_noescape)) {
-      // FIXME: diagnostic to tell user this is redundant and drop it
-    }
-
     // Resolve the function type directly with these attributes.
     FunctionType::ExtInfo extInfo(rep,
                                   attrs.has(TAK_autoclosure),
@@ -2016,7 +2017,7 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
       attrs.clearAttribute(TAK_escaping);
     } else {
       // No attribute; set the isNoEscape bit if we're in parameter context.
-      ty = adjustFunctionExtInfo(DC, ty, options);
+      ty = applyNonEscapingFromContext(DC, ty, options);
     }
   }
 
@@ -2034,6 +2035,7 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
       }
     }
   } else if (hasFunctionAttr && fnRepr) {
+    // Remove the function attributes from the set so that we don't diagnose.
     for (auto i : FunctionAttrs)
       attrs.clearAttribute(i);
     attrs.convention = None;
@@ -2484,6 +2486,11 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
 
   // If this is the top level of a function input list, peel off the
   // ImmediateFunctionInput marker and install a FunctionInput one instead.
+  //
+  // If we have a single ParenType though, don't clear these bits; we
+  // still want to parse the type contained therein as if it were in
+  // parameter position, meaning function types are not @escaping by
+  // default.
   auto elementOptions = options;
   if (!repr->isParenType()) {
     elementOptions = withoutContext(elementOptions);

test/ClangModules/blocks_parse.swift

@@ -19,6 +19,8 @@ func testNoEscape(f: @convention(block) () -> Void, nsStr: NSString,
                   fStr: (String!) -> Void) {
   accepts_noescape_block(f)
   accepts_noescape_block(f)
+  
+  // Please see related tests in PrintAsObjC/imported-block-typedefs.swift.
 
   // rdar://problem/19818617
   nsStr.enumerateLines(fStr) // okay due to @noescape

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

@@ -19,3 +19,5 @@ my_block_t __nullable blockWithNullable();
 void accepts_block(my_block_t) __attribute__((nonnull));
 void accepts_noescape_block(__attribute__((noescape)) my_block_t) __attribute__((nonnull));
 
+// Please see related tests in PrintAsObjC/imported-block-typedefs.swift.
+

test/PrintAsObjC/Inputs/comments-expected-output.h

@@ -127,7 +127,7 @@ SWIFT_CLASS("_TtC8comments16ClosureContainer")
   \a combine error: Nothing.
 
 */
-- (void)closureParameterExplodedExplodedWithA:(NSInteger)a combine:(NSInteger (^ _Nonnull)(NSInteger, NSInteger))combine;
+- (void)closureParameterExplodedExplodedWithA:(NSInteger)a combine:(SWIFT_NOESCAPE NSInteger (^ _Nonnull)(NSInteger, NSInteger))combine;
 /**
   Partially applies a binary operator.
   \param a The left-hand side to partially apply.
@@ -150,7 +150,7 @@ SWIFT_CLASS("_TtC8comments16ClosureContainer")
   \a combine error: Nothing.
 
 */
-- (void)closureParameterOutlineExplodedWithA:(NSInteger)a combine:(NSInteger (^ _Nonnull)(NSInteger, NSInteger))combine;
+- (void)closureParameterOutlineExplodedWithA:(NSInteger)a combine:(SWIFT_NOESCAPE NSInteger (^ _Nonnull)(NSInteger, NSInteger))combine;
 /**
   Partially applies a binary operator.
   \param a The left-hand side to partially apply.
@@ -173,7 +173,7 @@ SWIFT_CLASS("_TtC8comments16ClosureContainer")
   \a combine error: Nothing.
 
 */
-- (void)closureParameterOutlineOutlineWithA:(NSInteger)a combine:(NSInteger (^ _Nonnull)(NSInteger, NSInteger))combine;
+- (void)closureParameterOutlineOutlineWithA:(NSInteger)a combine:(SWIFT_NOESCAPE NSInteger (^ _Nonnull)(NSInteger, NSInteger))combine;
 - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
 @end
 

test/PrintAsObjC/Inputs/imported-block-typedefs.h

@@ -0,0 +1,5 @@
+typedef void (^PlainBlock)(void);
+typedef void (^BlockWithEscapingParam)(PlainBlock);
+typedef void (^BlockWithNoescapeParam)(__attribute__((noescape)) PlainBlock);
+typedef BlockWithEscapingParam (^BlockReturningBlockWithEscapingParam)(void);
+typedef BlockWithNoescapeParam (^BlockReturningBlockWithNoescapeParam)(void);