Allow various function attributes to be specified on Objective-C blocks too.

[comex]

Summary

This mostly "just works" by adding Block to the subject list, but there is an
issue with warnings in attribute handlers tied to the return type, which for
blocks can be inferred. My solution to this is a bit ugly but seems to do the
right thing.

The list: always_inline, noinline, cold, hot, minsize, malloc,
disable_tail_calls, noalias, noduplicate, nonnull, returns_nonnull, optnone.

nonnull already partially worked on blocks, but fix applying it to parameters
on them; also, improve the error message and add additional tests.

Most of these attributes only make sense when the target of a function call is
known; since blocks are always called indirectly via pointers, these will only
work if the optimizer is able to replace the indirect calls with direct calls
(ergo not at all at -O0). However, this can still be useful in practice.

For now, all of them only apply to the block implementation function itself, as
opposed to the copy and dispose helpers. For those it might make sense to
propagate always_inline in particular, or perhaps to just add some explicit
syntax for putting attributes on them, but it's not essential.

Incidentally, for some of these attributes and some not included, such as
returns_nonnull, printf, warn_unused_result, etc., it would be somewhat useful
and more principled to allow them as part of function types rather than just
functions themselves, for the sake of both standard function pointer calls and
blocks. Currently only a handful of attributes can be used on types: noreturn,
ns_returns_retained, regparm, and calling convention. However, that would be a
larger change and orthogonal to this patch.

[comex]

Ping, and adding potential reviewers like I was supposed to do in the first place.

[aaron.ballman]

At a high level, is there a reason why these should be supported on block, but not on ObjC method declarations? It smells like these may be useful there as well, which could also simplify the patch slightly.

include/clang/Basic/Attr.td

992

Since you updated ClangAttrEmitter.cpp, you shouldn't need this last argument since it can now be inferred.

lib/Parse/ParseExpr.cpp

2679

This (and its related changes) look good to me, but should be in a separate patch since they are orthogonal to the rest of the changes in this patch.

lib/Sema/SemaDeclAttr.cpp

1282

Please do not add any parameters to these function signatures. We try to keep them uniform in the hopes that maybe someday we can refactor this code to do dispatch more easily. (It's fine to add an extra level of indirection through a helper function that then has the additional parameter.)

5654

This doesn't seem like the correct way to solve the problem -- everyone who calls ProcessDeclAttributes should not have to understand what an overridden return type is for objective-c blocks. I'm not certain of a better way to solve it right now, but I would rather see the changes for this one split out into its own patch so we can make progress on the other improvements.

include/clang/Basic/Attr.td

def AlignMac68k : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
 def AlwaysInline : InheritableAttr {
   let Spellings = [GCC<"always_inline">, Keyword<"__forceinline">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   let Documentation = [Undocumented];
 }
 
 def TLSModel : InheritableAttr {
   let Spellings = [GCC<"tls_model">];
   let Subjects = SubjectList<[TLSVar], ErrorDiag, "ExpectedTLSVar">;
   let Args = [StringArgument<"Model">];
   let Documentation = [TLSModelDocs];
def Cleanup : InheritableAttr {
   let Spellings = [GCC<"cleanup">];
   let Args = [FunctionArgument<"FunctionDecl">];
   let Subjects = SubjectList<[Var]>;
   let Documentation = [Undocumented];
 }
 
 def Cold : InheritableAttr {
   let Spellings = [GCC<"cold">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   let Documentation = [Undocumented];
 }
 
 def Common : InheritableAttr {
   let Spellings = [GCC<"common">];
   let Subjects = SubjectList<[Var]>;
   let Documentation = [Undocumented];
 }
def Final : InheritableAttr {
   let Spellings = [Keyword<"final">, Keyword<"sealed">];
   let Accessors = [Accessor<"isSpelledAsSealed", [Keyword<"sealed">]>];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
 def MinSize : InheritableAttr {
   let Spellings = [GNU<"minsize">];
-  let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>;
+  let Subjects = SubjectList<[Function, ObjCMethod, Block], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
 def FlagEnum : InheritableAttr {
   let Spellings = [GNU<"flag_enum">];
   let Subjects = SubjectList<[Enum]>;
   let Documentation = [FlagEnumDocs];
   let LangOpts = [COnly];

 def GNUInline : InheritableAttr {
   let Spellings = [GCC<"gnu_inline">];
   let Subjects = SubjectList<[Function]>;
   let Documentation = [Undocumented];
 }
 
 def Hot : InheritableAttr {
   let Spellings = [GCC<"hot">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   // An AST node is created for this attribute, but not actually used beyond
   // semantic checking for mutual exclusion with the Cold attribute.
   let Documentation = [Undocumented];
 }
 
 def IBAction : InheritableAttr {
   let Spellings = [GNU<"ibaction">];
   let Subjects = SubjectList<[ObjCInstanceMethod], WarnDiag,
def IBOutletCollection : InheritableAttr {
   let Spellings = [GNU<"iboutletcollection">];
   let Args = [TypeArgument<"Interface", 1>];
 //  let Subjects = [ObjCIvar, ObjCProperty];
   let Documentation = [Undocumented];
 }
 
 def Restrict : InheritableAttr {
   let Spellings = [Declspec<"restrict">, GCC<"malloc">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   let Documentation = [Undocumented];
 }
 
 def MaxFieldAlignment : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let Args = [UnsignedArgument<"Alignment">];
   let SemaHandler = 0;
def ReturnsTwice : InheritableAttr {
   let Spellings = [GCC<"returns_twice">];
   let Subjects = SubjectList<[Function]>;
   let Documentation = [Undocumented];
 }
 
 def DisableTailCalls : InheritableAttr {
   let Spellings = [GNU<"disable_tail_calls">,
                    CXX11<"clang", "disable_tail_calls">];
-  let Subjects = SubjectList<[Function, ObjCMethod]>;
+  let Subjects = SubjectList<[Function, ObjCMethod, Block]>;
   let Documentation = [DisableTailCallsDocs];
 }
 
 def NoAlias : InheritableAttr {
   let Spellings = [Declspec<"noalias">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   let Documentation = [NoAliasDocs];
 }
 
 def NoCommon : InheritableAttr {
   let Spellings = [GCC<"nocommon">];
   let Subjects = SubjectList<[Var]>;
   let Documentation = [Undocumented];
 }
 
 def NoDebug : InheritableAttr {
   let Spellings = [GCC<"nodebug">];
   let Documentation = [Undocumented];
 }
 
 def NoDuplicate : InheritableAttr {
   let Spellings = [GNU<"noduplicate">, CXX11<"clang", "noduplicate">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   let Documentation = [NoDuplicateDocs];
 }
 
 def NoInline : InheritableAttr {
   let Spellings = [GCC<"noinline">, Declspec<"noinline">];
-  let Subjects = SubjectList<[Function]>;
+  let Subjects = SubjectList<[Function, Block]>;
   let Documentation = [Undocumented];
 }
 
 def NoMips16 : InheritableAttr, TargetSpecificAttr<TargetMips> {
   let Spellings = [GCC<"nomips16">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];
 }

 def NoSplitStack : InheritableAttr {
   let Spellings = [GCC<"no_split_stack">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [NoSplitStackDocs];
 }
 
 def NonNull : InheritableAttr {
   let Spellings = [GCC<"nonnull">];
-  let Subjects = SubjectList<[ObjCMethod, HasFunctionProto, ParmVar], WarnDiag,
-                             "ExpectedFunctionMethodOrParameter">;
+  let Subjects = SubjectList<[ObjCMethod, HasFunctionProto, ParmVar],
+                             WarnDiag, "ExpectedFunctionMethodParameterOrBlock">;
   let Args = [VariadicUnsignedArgument<"Args">];
   let AdditionalMembers =
 [{bool isNonNull(unsigned idx) const {
     if (!args_size())
       return true;
     for (const auto &V : args())
       if (V == idx)
         return true;
     return false;
   } }];
   // FIXME: We should merge duplicates into a single nonnull attribute.
   let DuplicatesAllowedWhileMerging = 1;
   let Documentation = [NonNullDocs];
 }
 
 def ReturnsNonNull : InheritableAttr {
   let Spellings = [GCC<"returns_nonnull">];
-  let Subjects = SubjectList<[ObjCMethod, Function], WarnDiag,
-                             "ExpectedFunctionOrMethod">;
+  let Subjects = SubjectList<[Function, ObjCMethod, Block], WarnDiag>;
   let Documentation = [ReturnsNonNullDocs];
 }
 
 // pass_object_size(N) indicates that the parameter should have
 // __builtin_object_size with Type=N evaluated on the parameter at the callsite.
 def PassObjectSize : InheritableParamAttr {
   let Spellings = [GNU<"pass_object_size">];
   let Args = [IntArgument<"Type">];

 def ObjCBoxable : Attr {
   let Spellings = [GNU<"objc_boxable">];
   let Subjects = SubjectList<[Record], ErrorDiag, "ExpectedStructOrUnion">;
   let Documentation = [ObjCBoxableDocs];
 }
 
 def OptimizeNone : InheritableAttr {
   let Spellings = [GNU<"optnone">, CXX11<"clang", "optnone">];
-  let Subjects = SubjectList<[Function, ObjCMethod]>;
+  let Subjects = SubjectList<[Function, ObjCMethod, Block]>;
   let Documentation = [OptnoneDocs];
 }
 
 def Overloadable : Attr {
   let Spellings = [GNU<"overloadable">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [OverloadableDocs];
 }

include/clang/Basic/DiagnosticSemaKinds.td

def warn_alias_with_section : Warning<
   InGroup<IgnoredAttributes>;
 def err_duplicate_mangled_name : Error<
   "definition with same mangled name as another definition">;
 def err_cyclic_alias : Error<
   "alias definition is part of a cycle">;
 def warn_attribute_wrong_decl_type : Warning<
   "%0 attribute only applies to %select{functions|unions|"
   "variables and functions|functions and methods|parameters|"
-  "functions, methods and blocks|functions, methods, and classes|"
-  "functions, methods, and parameters|classes|enums|variables|methods|"
+  "functions and blocks|functions, methods and blocks|"
+  "functions, methods and classes|functions, methods and parameters|"
+  "functions, methods, parameters and blocks|"
+  "classes|enums|variables|methods|"
   "variables, functions and labels|fields and global variables|structs|"
   "variables and typedefs|thread-local variables|"
   "variables and fields|variables, data members and tag types|"
   "types and namespaces|Objective-C interfaces|methods and properties|"
   "struct or union|struct, union or class|types|"
   "Objective-C instance methods|init methods of interface or class extension declarations|"
   "variables, functions and classes|Objective-C protocols|"
-  "functions and global variables|structs, unions, and typedefs|structs and typedefs|"
+  "functions and global variables|structs, unions and typedefs|structs and typedefs|"
   "interface or protocol declarations|kernel functions|non-K&R-style functions}1">,
   InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>;
 def warn_type_attribute_wrong_type : Warning<
   "'%0' only applies to %select{function|pointer|"
   "Objective-C object or block pointer}1 types; type here is %2">,
   InGroup<IgnoredAttributes>;
 def warn_incomplete_encoded_type : Warning<

include/clang/Parse/Parser.h

public:
   TypeResult ParseTypeName(SourceRange *Range = nullptr,
                            Declarator::TheContext Context
                              = Declarator::TypeNameContext,
                            AccessSpecifier AS = AS_none,
                            Decl **OwnedType = nullptr,
                            ParsedAttributes *Attrs = nullptr);
 
 private:
-  void ParseBlockId(SourceLocation CaretLoc);
-
   // Check for the start of a C++11 attribute-specifier-seq in a context where
   // an attribute is not allowed.
   bool CheckProhibitedCXX11Attribute() {
     assert(Tok.is(tok::l_square));
     if (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))
       return false;
     return DiagnoseProhibitedCXX11Attribute();
   }

include/clang/Sema/AttributeList.h

 /// These constants match the enumerated choices of
 /// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
 enum AttributeDeclKind {
   ExpectedFunction,
   ExpectedUnion,
   ExpectedVariableOrFunction,
   ExpectedFunctionOrMethod,
   ExpectedParameter,
+  ExpectedFunctionOrBlock,
   ExpectedFunctionMethodOrBlock,
   ExpectedFunctionMethodOrClass,
   ExpectedFunctionMethodOrParameter,
+  ExpectedFunctionMethodParameterOrBlock,
   ExpectedClass,
   ExpectedEnum,
   ExpectedVariable,
   ExpectedMethod,
   ExpectedVariableFunctionOrLabel,
   ExpectedFieldOrGlobalVar,
   ExpectedStruct,
   ExpectedVariableOrTypedef,

include/clang/Sema/Sema.h

public:
   NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
                                       Scope *S);
   void AddKnownFunctionAttributes(FunctionDecl *FD);
 
   // More parsing and symbol table subroutines.
 
   void ProcessPragmaWeak(Scope *S, Decl *D);
   // Decl attributes - this routine is the top level dispatcher.
-  void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
+  void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
+                             QualType *OverrideRetType = nullptr);
   void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL,
-                                bool IncludeCXX11Attributes = true);
+                                bool IncludeCXX11Attributes = true,
+                                QualType *OverrideRetType = nullptr);
   bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
                                       const AttributeList *AttrList);
 
   void checkUnusedDeclAttributes(Declarator &D);
 
   /// Determine if type T is a valid subject for a nonnull and similar
   /// attributes. By default, we look through references (the behavior used by
   /// nonnull), but if the second parameter is true, then we treat a reference
public:
 
   /// ActOnBlockError - If there is an error parsing a block, this callback
   /// is invoked to pop the information about the block from the action impl.
   void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
 
   /// ActOnBlockStmtExpr - This is called when the body of a block statement
   /// literal was successfully completed.  ^(int x){...}
   ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
-                                Scope *CurScope);
+                                Scope *CurScope, Declarator *ParamInfo);
 
   //===---------------------------- Clang Extensions ----------------------===//
 
   /// __builtin_convertvector(...)
   ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
                                     SourceLocation BuiltinLoc,
                                     SourceLocation RParenLoc);
 

lib/Parse/ParseExpr.cpp

while (1) {
     if (Tok.isNot(tok::comma))
       return false;
 
     // Move to the next argument, remember where the comma was.
     CommaLocs.push_back(ConsumeToken());
   }
 }
 
-/// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
-///
-/// \verbatim
-/// [clang] block-id:
-/// [clang]   specifier-qualifier-list block-declarator
-/// \endverbatim
-void Parser::ParseBlockId(SourceLocation CaretLoc) {
-  if (Tok.is(tok::code_completion)) {
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
-    return cutOffParsing();
-  }
-  
-  // Parse the specifier-qualifier-list piece.
-  DeclSpec DS(AttrFactory);
-  ParseSpecifierQualifierList(DS);
-
-  // Parse the block-declarator.
-  Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext);
-  ParseDeclarator(DeclaratorInfo);
-
-  MaybeParseGNUAttributes(DeclaratorInfo);
-
-  // Inform sema that we are starting a block.
-  Actions.ActOnBlockArguments(CaretLoc, DeclaratorInfo, getCurScope());
-}
-
 /// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
 /// like ^(int x){ return x+1; }
 ///
 /// \verbatim
 ///         block-literal:
 /// [clang]   '^' block-args[opt] compound-statement
 /// [clang]   '^' block-id compound-statement
 /// [clang] block-args:
 /// [clang]   '(' parameter-list ')'
+/// [clang] block-id:
+/// [clang]   specifier-qualifier-list block-declarator
 /// \endverbatim
 ExprResult Parser::ParseBlockLiteralExpression() {
   assert(Tok.is(tok::caret) && "block literal starts with ^");
   SourceLocation CaretLoc = ConsumeToken();
 
   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc,
                                 "block literal parsing");
 
if (Tok.is(tok::l_paren)) {
     ParamInfo.SetRangeEnd(Tmp);
     if (ParamInfo.isInvalidType()) {
       // If there was an error parsing the arguments, they may have
       // tried to use ^(x+y) which requires an argument list.  Just
       // skip the whole block literal.
       Actions.ActOnBlockError(CaretLoc, getCurScope());
       return ExprError();
     }
-
-    MaybeParseGNUAttributes(ParamInfo);
-
-    // Inform sema that we are starting a block.
-    Actions.ActOnBlockArguments(CaretLoc, ParamInfo, getCurScope());
   } else if (!Tok.is(tok::l_brace)) {
-    ParseBlockId(CaretLoc);
+    // This is a block-id.
+    if (Tok.is(tok::code_completion)) {
+      Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
+      cutOffParsing();
+    }
+    ParseSpecifierQualifierList(DS);
+    ParseDeclarator(ParamInfo);
   } else {
     // Otherwise, pretend we saw (void).
     ParsedAttributes attrs(AttrFactory);
     SourceLocation NoLoc;
     ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/true,
                                              /*IsAmbiguous=*/false,
                                              /*RParenLoc=*/NoLoc,
                                              /*ArgInfo=*/nullptr,
ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/true,
                                              /*Exceptions=*/nullptr,
                                              /*ExceptionRanges=*/nullptr,
                                              /*NumExceptions=*/0,
                                              /*NoexceptExpr=*/nullptr,
                                              /*ExceptionSpecTokens=*/nullptr,
                                              CaretLoc, CaretLoc,
                                              ParamInfo),
                           attrs, CaretLoc);
+  }
 
-    MaybeParseGNUAttributes(ParamInfo);
 
-    // Inform sema that we are starting a block.
-    Actions.ActOnBlockArguments(CaretLoc, ParamInfo, getCurScope());
-  }
 
 
   ExprResult Result(true);
   if (!Tok.is(tok::l_brace)) {
     // Saw something like: ^expr
     Diag(Tok, diag::err_expected_expression);
     Actions.ActOnBlockError(CaretLoc, getCurScope());
     return ExprError();
   }
 
   StmtResult Stmt(ParseCompoundStatementBody());
   BlockScope.Exit();
   if (!Stmt.isInvalid())
-    Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.get(), getCurScope());
+    Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.get(), getCurScope(),
+                                        &ParamInfo);
   else
     Actions.ActOnBlockError(CaretLoc, getCurScope());
   return Result;
 }
 
 /// ParseObjCBoolLiteral - This handles the objective-c Boolean literals.
 ///
 ///         '__objc_yes'
 ///         '__objc_no'
 ExprResult Parser::ParseObjCBoolLiteral() {
   tok::TokenKind Kind = Tok.getKind();
   return Actions.ActOnObjCBoolLiteral(ConsumeToken(), Kind);
 }

lib/Sema/SemaDeclAttr.cpp

 }
 
 static QualType getFunctionOrMethodResultType(const Decl *D) {
   if (const FunctionType *FnTy = D->getFunctionType())
     return cast<FunctionType>(FnTy)->getReturnType();
   return cast<ObjCMethodDecl>(D)->getReturnType();
 }
 
+static QualType getPossiblyOverriddenResultType(const Decl *D, QualType *OverrideRetType) {
+  return OverrideRetType ? *OverrideRetType : getFunctionOrMethodResultType(D);
+}
+
 static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D) {
   if (const auto *FD = dyn_cast<FunctionDecl>(D))
     return FD->getReturnTypeSourceRange();
   if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
     return MD->getReturnTypeSourceRange();
   return SourceRange();
 }
 
static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
   D->addAttr(::new (S.Context)
              NonNullAttr(Attr.getRange(), S.Context, Start, Size,
                          Attr.getAttributeSpellingListIndex()));
 }
 
 static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
                                        const AttributeList &Attr) {
   if (Attr.getNumArgs() > 0) {
-    if (D->getFunctionType()) {
+    if (D->getFunctionType(/*BlocksToo=*/true)) {
       handleNonNullAttr(S, D, Attr);
     } else {
       S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
         << D->getSourceRange();
     }
     return;
   }
 
   // Is the argument a pointer type?
   if (!attrNonNullArgCheck(S, D->getType(), Attr, SourceRange(),
                            D->getSourceRange()))
     return;
 
   D->addAttr(::new (S.Context)
              NonNullAttr(Attr.getRange(), S.Context, nullptr, 0,
                          Attr.getAttributeSpellingListIndex()));
 }
 
 static void handleReturnsNonNullAttr(Sema &S, Decl *D,
-                                     const AttributeList &Attr) {
-  QualType ResultType = getFunctionOrMethodResultType(D);
+                                     const AttributeList &Attr,
+                                     QualType ResultType) {
   SourceRange SR = getFunctionOrMethodResultSourceRange(D);
   if (!attrNonNullArgCheck(S, ResultType, Attr, SourceRange(), SR,
                            /* isReturnValue */ true))
     return;
 
   D->addAttr(::new (S.Context)
             ReturnsNonNullAttr(Attr.getRange(), S.Context,
                                Attr.getAttributeSpellingListIndex()));
if (Model != "global-dynamic" && Model != "local-dynamic"
     return;
   }
 
   D->addAttr(::new (S.Context)
              TLSModelAttr(Attr.getRange(), S.Context, Model,
                           Attr.getAttributeSpellingListIndex()));
 }
 
-static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr) {
-  QualType ResultType = getFunctionOrMethodResultType(D);
+static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr,
+                               QualType ResultType) {
   if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
     D->addAttr(::new (S.Context) RestrictAttr(
         Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
     return;
   }
 
   S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
       << Attr.getName() << getFunctionOrMethodResultSourceRange(D);

 // Top Level Sema Entry Points
 //===----------------------------------------------------------------------===//
 
 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
 /// the attribute applies to decls.  If the attribute is a type attribute, just
 /// silently ignore it if a GNU attribute.
 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
                                  const AttributeList &Attr,
-                                 bool IncludeCXX11Attributes) {
+                                 bool IncludeCXX11Attributes,
+                                 QualType *OverrideRetType) {
   if (Attr.isInvalid() || Attr.getKind() == AttributeList::IgnoredAttribute)
     return;
 
   // Ignore C++11 attributes on declarator chunks: they appertain to the type
   // instead.
   if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
     return;
 
case AttributeList::AT_CUDAHost:
     break;
   case AttributeList::AT_GNUInline:
     handleGNUInlineAttr(S, D, Attr);
     break;
   case AttributeList::AT_CUDALaunchBounds:
     handleLaunchBoundsAttr(S, D, Attr);
     break;
   case AttributeList::AT_Restrict:
-    handleRestrictAttr(S, D, Attr);
+    handleRestrictAttr(S, D, Attr,
+                       getPossiblyOverriddenResultType(D, OverrideRetType));
     break;
   case AttributeList::AT_MayAlias:
     handleSimpleAttribute<MayAliasAttr>(S, D, Attr);
     break;
   case AttributeList::AT_Mode:
     handleModeAttr(S, D, Attr);
     break;
   case AttributeList::AT_NoAlias:
     handleSimpleAttribute<NoAliasAttr>(S, D, Attr);
     break;
   case AttributeList::AT_NoCommon:
     handleSimpleAttribute<NoCommonAttr>(S, D, Attr);
     break;
   case AttributeList::AT_NoSplitStack:
     handleSimpleAttribute<NoSplitStackAttr>(S, D, Attr);
     break;
   case AttributeList::AT_NonNull:
     if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D))
       handleNonNullAttrParameter(S, PVD, Attr);
     else
       handleNonNullAttr(S, D, Attr);
     break;
   case AttributeList::AT_ReturnsNonNull:
-    handleReturnsNonNullAttr(S, D, Attr);
+    handleReturnsNonNullAttr(S, D, Attr,
+                             getPossiblyOverriddenResultType(D, OverrideRetType));
     break;
   case AttributeList::AT_AssumeAligned:
     handleAssumeAlignedAttr(S, D, Attr);
     break;
   case AttributeList::AT_Overloadable:
     handleSimpleAttribute<OverloadableAttr>(S, D, Attr);
     break;
   case AttributeList::AT_Ownership:
case AttributeList::AT_TypeTagForDatatype:
     break;
   }
 }
 
 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
 /// attribute list to the specified decl, ignoring any type attributes.
 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
                                     const AttributeList *AttrList,
-                                    bool IncludeCXX11Attributes) {
+                                    bool IncludeCXX11Attributes,
+                                    QualType *OverrideRetType) {
   for (const AttributeList* l = AttrList; l; l = l->getNext())
-    ProcessDeclAttribute(*this, S, D, *l, IncludeCXX11Attributes);
+    ProcessDeclAttribute(*this, S, D, *l, IncludeCXX11Attributes,
+                         OverrideRetType);
 
   // FIXME: We should be able to handle these cases in TableGen.
   // GCC accepts
   // static int a9 __attribute__((weakref));
   // but that looks really pointless. We reject it.
   if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
     Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias)
       << cast<NamedDecl>(D);

 }
 
 // Annotation attributes are the only attributes allowed after an access
 // specifier.
 bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
                                           const AttributeList *AttrList) {
   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
     if (l->getKind() == AttributeList::AT_Annotate) {
-      ProcessDeclAttribute(*this, nullptr, ASDecl, *l, l->isCXX11Attribute());
+      ProcessDeclAttribute(*this, nullptr, ASDecl, *l, l->isCXX11Attribute(),
+                           nullptr);
     } else {
       Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
       return true;
     }
   }
 
   return false;
 }
if (ND) {
       }
     }
   }
 }
 
 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
 /// it, apply them to D.  This is a bit tricky because PD can have attributes
 /// specified in many different places, and we need to find and apply them all.
-void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
+void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
+                                 QualType *OverrideRetType) {
   // Apply decl attributes from the DeclSpec if present.
   if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
-    ProcessDeclAttributeList(S, D, Attrs);
+    ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/true,
+                             OverrideRetType);
 
   // Walk the declarator structure, applying decl attributes that were in a type
   // position to the decl itself.  This handles cases like:
   //   int *__attr__(x)** D;
   // when X is a decl attribute.
   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
     if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
-      ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/false);
+      ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/false,
+                               OverrideRetType);
 
   // Finally, apply any attributes on the decl itself.
   if (const AttributeList *Attrs = PD.getAttributes())
-    ProcessDeclAttributeList(S, D, Attrs);
+    ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/true,
+                             OverrideRetType);
 }
 
 /// Is the given declaration allowed to use a forbidden type?
 /// If so, it'll still be annotated with an attribute that makes it
 /// illegal to actually use.
 static bool isForbiddenTypeAllowed(Sema &S, Decl *decl,
                                    const DelayedDiagnostic &diag,
                                    UnavailableAttr::ImplicitReason &reason) {

lib/Sema/SemaExpr.cpp

void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
 
   // Set the parameters on the block decl.
   if (!Params.empty()) {
     CurBlock->TheDecl->setParams(Params);
     CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(),
                              CurBlock->TheDecl->param_end(),
                              /*CheckParameterNames=*/false);
   }
-  
-  // Finally we can process decl attributes.
-  ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
-
   // Put the parameter variables in scope.
   for (auto AI : CurBlock->TheDecl->params()) {
     AI->setOwningFunction(CurBlock->TheDecl);
 
     // If this has an identifier, add it to the scope stack.
     if (AI->getIdentifier()) {
       CheckShadow(CurBlock->TheScope, AI);
 
void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
   // Pop off CurBlock, handle nested blocks.
   PopDeclContext();
   PopFunctionScopeInfo();
 }
 
 /// ActOnBlockStmtExpr - This is called when the body of a block statement
 /// literal was successfully completed.  ^(int x){...}
 ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
-                                    Stmt *Body, Scope *CurScope) {
+                                    Stmt *Body, Scope *CurScope,
+                                    Declarator *ParamInfo) {
   // If blocks are disabled, emit an error.
   if (!LangOpts.Blocks)
     Diag(CaretLoc, diag::err_blocks_disable);
 
   // Leave the expression-evaluation context.
   if (hasAnyUnrecoverableErrorsInThisFunction())
     DiscardCleanupsInEvaluationContext();
   assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!");
   PopExpressionEvaluationContext();
 
   BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back());
 
   if (BSI->HasImplicitReturnType)
     deduceClosureReturnType(*BSI);
 
   PopDeclContext();
 
   QualType RetTy = Context.VoidTy;
   if (!BSI->ReturnType.isNull())
     RetTy = BSI->ReturnType;
 
+  // We have to process attributes super late, because some of them warn on
+  // unsupported return types, but the return type here can be inferred.
+  // ParamInfo could be null if called from TransformBlockExpr.
+  if (ParamInfo)
+    ProcessDeclAttributes(CurScope, BSI->TheDecl, *ParamInfo, &RetTy);
+
   bool NoReturn = BSI->TheDecl->hasAttr<NoReturnAttr>();
   QualType BlockTy;
 
   // Set the captured variables on the block.
   // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo!
   SmallVector<BlockDecl::Capture, 4> Captures;
   for (CapturingScopeInfo::Capture &Cap : BSI->Captures) {
     if (Cap.isThisCapture())

lib/Sema/TreeTransform.h

for (const auto &I : oldBlock->captures()) {
                                                  oldCapture));
       assert(blockScope->CaptureMap.count(newCapture));
     }
     assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
   }
 #endif
 
   return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
-                                    /*Scope=*/nullptr);
+                                    /*Scope=*/nullptr, /*ParamInfo=*/nullptr);
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
   llvm_unreachable("Cannot transform asType expressions yet");
 }
 

test/CXX/dcl.dcl/dcl.attr/dcl.attr.depend/p1.cpp

 // RUN: %clang_cc1 -verify -std=c++11 %s
 
 [[carries_dependency, carries_dependency]] int m1(); // expected-error {{attribute 'carries_dependency' cannot appear multiple times in an attribute specifier}}
 [[carries_dependency]] [[carries_dependency]] int m2(); // ok
 [[carries_dependency()]] int m3(); // expected-error {{attribute 'carries_dependency' cannot have an argument list}}
 
 [[carries_dependency]] void f1(); // FIXME: warn here
 [[carries_dependency]] int f2(); // ok
 int f3(int param [[carries_dependency]]); // ok
-[[carries_dependency]] int (*f4)(); // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}}
-int (*f5 [[carries_dependency]])(); // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}}
+[[carries_dependency]] int (*f4)(); // expected-error {{'carries_dependency' attribute only applies to functions, methods and parameters}}
+int (*f5 [[carries_dependency]])(); // expected-error {{'carries_dependency' attribute only applies to functions, methods and parameters}}
 int (*f6)() [[carries_dependency]]; // expected-error {{'carries_dependency' attribute cannot be applied to types}}
 int (*f7)(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}}
 int (((f8)))(int n [[carries_dependency]]); // ok
 int (*f9(int n))(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}}
 int typedef f10(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}}
 using T = int(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}}
 struct S {
   [[carries_dependency]] int f(int n [[carries_dependency]]); // ok
   int (*p)(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}}
 };
 void f() {
   [[carries_dependency]] int f(int n [[carries_dependency]]); // ok
-  [[carries_dependency]] // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}}
+  [[carries_dependency]] // expected-error {{'carries_dependency' attribute only applies to functions, methods and parameters}}
       int (*p)(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}}
 }
 
 auto l1 = [](int n [[carries_dependency]]) {};
 // There's no way to write a lambda such that the return value carries
 // a dependency, because an attribute applied to the lambda appertains to
 // the *type* of the operator() function, not to the function itself.
 auto l2 = []() [[carries_dependency]] {}; // expected-error {{'carries_dependency' attribute cannot be applied to types}}

test/CodeGen/always-inline.c

 // RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
 // RUN: %clang_cc1 -fno-inline -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fno-inline -fno-inline-functions -fblocks -O -DBLOCKS_TOO -emit-llvm %s -o - | FileCheck %s
 
 // CHECK-NOT: foo
 
-void bar() {
-}
+extern void bar();
 
 inline void __attribute__((__always_inline__)) foo() {
   bar();
 }
 
 void i_want_bar() {
   foo();
 }
+
+#ifdef BLOCKS_TOO
+void i_want_bar_from_block() {
+  void (^foo)() = ^ __attribute__((__always_inline__)) { bar(); };
+  foo();
+  foo();
+}
+#endif

test/CodeGen/attr-disable-tail-calls.c

-// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 %s -emit-llvm -mdisable-tail-calls -o - | FileCheck %s -check-prefix=DISABLE
-// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 %s -emit-llvm -o - | FileCheck %s -check-prefix=ENABLE
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 -fblocks %s -emit-llvm -mdisable-tail-calls -o - | FileCheck %s -check-prefix=DISABLE
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 -fblocks %s -emit-llvm -o - | FileCheck %s -check-prefix=ENABLE
 
 // DISABLE: define i32 @f1() [[ATTRTRUE:#[0-9]+]] {
 // DISABLE: define i32 @f2() [[ATTRTRUE]] {
 // ENABLE: define i32 @f1() [[ATTRFALSE:#[0-9]+]] {
 // ENABLE: define i32 @f2() [[ATTRTRUE:#[0-9]+]] {
 
 int f1() {
   return 0;
 }
 
 int f2() __attribute__((disable_tail_calls)) {
   return 0;
 }
 
+// ENABLE: define internal i32 @b_block_invoke{{.*}} [[ATTRTRUE2:#[0-9]+]] {
+
+// (cold avoids ATTRTRUE == ATTRTRUE2)
+int (^b)() = ^ __attribute__((disable_tail_calls, cold)) {
+  return 0;
+};
+
 // DISABLE: attributes [[ATTRTRUE]] = { {{.*}}"disable-tail-calls"="true"{{.*}} }
 // ENABLE: attributes [[ATTRFALSE]] = { {{.*}}"disable-tail-calls"="false"{{.*}} }
 // ENABLE: attributes [[ATTRTRUE]] = { {{.*}}"disable-tail-calls"="true"{{.*}} }
+// ENABLE: attributes [[ATTRTRUE2]] = { {{.*}}"disable-tail-calls"="true"{{.*}} }

test/CodeGen/attr-noinline.c

-// RUN: %clang_cc1 -debug-info-kind=limited -emit-llvm -o %t %s
-// RUN: grep 'noinline' %t
+// RUN: %clang_cc1 -debug-info-kind=limited -fblocks -emit-llvm -o %t %s
+// RUN: grep 'Function Attrs:.*noinline' %t | count 2
 
 void t1() __attribute__((noinline));
 
 void t1()
 {
 }
 
+void (^t2)() = ^ __attribute__((noinline)) {};

test/CodeGen/attr-optnone.c

-// RUN: %clang_cc1 -emit-llvm < %s > %t
+// RUN: %clang_cc1 -emit-llvm -fblocks < %s > %t
 // RUN: FileCheck %s --check-prefix=PRESENT < %t
 // RUN: FileCheck %s --check-prefix=ABSENT  < %t
-// RUN: %clang_cc1 -emit-llvm -Os < %s > %t
+// RUN: %clang_cc1 -emit-llvm -fblocks -Os < %s > %t
 // RUN: FileCheck %s --check-prefix=PRESENT < %t
 // RUN: FileCheck %s --check-prefix=OPTSIZE < %t
-// RUN: %clang_cc1 -emit-llvm -Oz < %s > %t
+// RUN: %clang_cc1 -emit-llvm -fblocks -Oz < %s > %t
 // RUN: FileCheck %s --check-prefix=PRESENT < %t
 // RUN: FileCheck %s --check-prefix=MINSIZE < %t
 
 __attribute__((always_inline))
 int test2() { return 0; }
 // OPTSIZE: @test2{{.*}}[[ATTR2:#[0-9]+]]
 // MINSIZE: @test2{{.*}}[[ATTR2:#[0-9]+]]
 
 __attribute__((optnone))
 int test3() { return 0; }
 // PRESENT-DAG: @test3{{.*}}[[ATTR3:#[0-9]+]]
 
 __attribute__((optnone)) __attribute__((cold))
 int test4() { return test2(); }
 // PRESENT-DAG: @test4{{.*}}[[ATTR4:#[0-9]+]]
 // Also check that test2 is inlined into test4 (always_inline still works).
 // PRESENT-NOT: call i32 @test2
 
+int (^test5)() = ^ __attribute__((optnone)) { return 0; };
+// PRESENT-DAG: @test5_block_invoke{{.*}}[[ATTR5:#[0-9]+]]
+
 // Check for both noinline and optnone on each optnone function.
 // PRESENT-DAG: attributes [[ATTR3]] = { {{.*}}noinline{{.*}}optnone{{.*}} }
 // PRESENT-DAG: attributes [[ATTR4]] = { {{.*}}noinline{{.*}}optnone{{.*}} }
+// PRESENT-DAG: attributes [[ATTR5]] = { {{.*}}noinline{{.*}}optnone{{.*}} }
 
 // Check that no 'optsize' or 'minsize' attributes appear.
 // ABSENT-NOT: optsize
 // ABSENT-NOT: minsize
 
 // With -Os, check that 'optsize' appears only on test2.
 // OPTSIZE-NOT: optsize
 // OPTSIZE: attributes [[ATTR2]] = { {{.*}}optsize{{.*}} }
 // OPTSIZE-NOT: optsize
 
 // With -Oz, check that 'minsize' appears only on test2.
 // MINSIZE-NOT: minsize
 // MINSIZE: attributes [[ATTR2]] = { {{.*}}minsize{{.*}} }
 // MINSIZE-NOT: minsize

test/CodeGen/nonnull.c

-// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm < %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -fblocks -emit-llvm < %s | FileCheck %s
 
 // CHECK: define void @foo(i32* nonnull %x)
 void foo(int * __attribute__((nonnull)) x) {
   *x = 0;
 }
 
 // CHECK: define void @bar(i32* nonnull %x)
 void bar(int * x) __attribute__((nonnull(1)))  {

 
 // CHECK: define void @bar7(i32* nonnull %a, i32* nonnull %b)
 void bar7(int *a, int *b) __attribute__((nonnull(1)))
 __attribute__((nonnull(2))) {}
 
 // CHECK: define void @bar8(i32* nonnull %a, i32* nonnull %b)
 void bar8(int *a, int *b) __attribute__((nonnull))
 __attribute__((nonnull(1))) {}
+
+// CHECK: define internal void @blk_block_invoke(i8* %.block_descriptor, i32* nonnull %a)
+void (^blk)(int *) = ^(int *a) __attribute__((nonnull)) {};

test/Parser/cxx0x-attributes.cpp

 
 // Forbid [[gnu::...]] attributes on declarator chunks.
 int *[[gnu::unused]] v3; // expected-warning {{attribute 'unused' ignored}}
 int v4[2][[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
 int v5()[[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
 
 [[attribute_declaration]]; // expected-warning {{unknown attribute 'attribute_declaration' ignored}}
 [[noreturn]]; // expected-error {{'noreturn' attribute only applies to functions}}
-[[carries_dependency]]; // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}}
+[[carries_dependency]]; // expected-error {{'carries_dependency' attribute only applies to functions, methods and parameters}}
 
 class A {
   A([[gnu::unused]] int a);
 };
 A::A([[gnu::unused]] int a) {}
 
 namespace GccConst {
   // GCC's tokenizer treats const and __const as the same token.

test/Sema/attr-capabilities.c

 // RUN: %clang_cc1 -fsyntax-only -Wthread-safety -verify %s
 
 typedef int __attribute__((capability("role"))) ThreadRole;
 struct __attribute__((shared_capability("mutex"))) Mutex {};
 struct NotACapability {};
 
 // Put capability attributes on unions
 union __attribute__((capability("mutex"))) MutexUnion { int a; char* b; };
 typedef union { int a; char* b; } __attribute__((capability("mutex"))) MutexUnion2;
 
 // Test an invalid capability name
 struct __attribute__((capability("wrong"))) IncorrectName {}; // expected-warning {{invalid capability name 'wrong'; capability name must be 'mutex' or 'role'}}
 
-int Test1 __attribute__((capability("test1")));  // expected-error {{'capability' attribute only applies to structs, unions, and typedefs}}
-int Test2 __attribute__((shared_capability("test2"))); // expected-error {{'shared_capability' attribute only applies to structs, unions, and typedefs}}
+int Test1 __attribute__((capability("test1")));  // expected-error {{'capability' attribute only applies to structs, unions and typedefs}}
+int Test2 __attribute__((shared_capability("test2"))); // expected-error {{'shared_capability' attribute only applies to structs, unions and typedefs}}
 int Test3 __attribute__((acquire_capability("test3")));  // expected-warning {{'acquire_capability' attribute only applies to functions}}
 int Test4 __attribute__((try_acquire_capability("test4"))); // expected-error {{'try_acquire_capability' attribute only applies to functions}}
 int Test5 __attribute__((release_capability("test5"))); // expected-warning {{'release_capability' attribute only applies to functions}}
 
 struct __attribute__((capability(12))) Test3 {}; // expected-error {{'capability' attribute requires a string}}
 struct __attribute__((shared_capability(Test2))) Test4 {}; // expected-error {{'shared_capability' attribute requires a string}}
 
 struct __attribute__((capability)) Test5 {}; // expected-error {{'capability' attribute takes one argument}}

test/Sema/attr-coldhot.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fblocks -fsyntax-only -verify %s
 
 int foo() __attribute__((__hot__));
 int bar() __attribute__((__cold__));
 
 int var1 __attribute__((__cold__)); // expected-warning{{'__cold__' attribute only applies to functions}}
 int var2 __attribute__((__hot__)); // expected-warning{{'__hot__' attribute only applies to functions}}
 
 int qux() __attribute__((__hot__)) __attribute__((__cold__)); // expected-error{{'__hot__' and 'cold' attributes are not compatible}} \
 // expected-note{{conflicting attribute is here}}
 int baz() __attribute__((__cold__)) __attribute__((__hot__)); // expected-error{{'__cold__' and 'hot' attributes are not compatible}} \
 // expected-note{{conflicting attribute is here}}
+
+enum { s = sizeof(^() __attribute__((__cold__)) __attribute__((__hot__)) {}) }; // expected-error{{'__cold__' and 'hot' attributes are not compatible}} \
+// expected-note{{conflicting attribute is here}}

test/Sema/attr-disable-tail-calls.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fblocks -verify %s
 
 void __attribute__((disable_tail_calls,naked)) foo1(int a) { // expected-error {{'disable_tail_calls' and 'naked' attributes are not compatible}} expected-note {{conflicting attribute is here}}
   __asm__("");
 }
 
 void __attribute__((naked,disable_tail_calls)) foo2(int a) { // expected-error {{'naked' and 'disable_tail_calls' attributes are not compatible}} expected-note {{conflicting attribute is here}}
   __asm__("");
 }
 
-int g0 __attribute__((disable_tail_calls)); // expected-warning {{'disable_tail_calls' attribute only applies to functions and methods}}
+int g0 __attribute__((disable_tail_calls)); // expected-warning {{'disable_tail_calls' attribute only applies to functions, methods and blocks}}
 
 int foo3(int a) __attribute__((disable_tail_calls("abc"))); // expected-error {{'disable_tail_calls' attribute takes no arguments}}

test/Sema/attr-malloc.c

-// RUN: %clang_cc1 -verify -fsyntax-only %s
-// RUN: %clang_cc1 -emit-llvm -o %t %s
+// RUN: %clang_cc1 -fblocks -verify -fsyntax-only %s
+// RUN: %clang_cc1 -fblocks -emit-llvm -o %t %s
 
 #include <stddef.h>
 
 // Declare malloc here explicitly so we don't depend on system headers.
 void * malloc(size_t) __attribute((malloc));
 
-int no_vars __attribute((malloc)); // expected-warning {{attribute only applies to functions}}
+int no_vars __attribute((malloc)); // expected-warning {{attribute only applies to functions and blocks}}
 
 void  returns_void  (void) __attribute((malloc)); // expected-warning {{attribute only applies to return values that are pointers}}
 int   returns_int   (void) __attribute((malloc)); // expected-warning {{attribute only applies to return values that are pointers}}
 int * returns_intptr(void) __attribute((malloc)); // no-warning
 typedef int * iptr;
 iptr  returns_iptr  (void) __attribute((malloc)); // no-warning
 
-__attribute((malloc)) void *(*f)(); //  expected-warning{{attribute only applies to functions}}
-__attribute((malloc)) int (*g)(); // expected-warning{{attribute only applies to functions}}
+__attribute((malloc)) void *(*f)(); //  expected-warning{{attribute only applies to functions and blocks}}
+__attribute((malloc)) int (*g)(); // expected-warning{{attribute only applies to functions and blocks}}
+
+enum { s1 = sizeof(^ __attribute((malloc)) {}) }; // expected-warning {{attribute only applies to return values that are pointers}}
+enum { s2 = sizeof(^() __attribute((malloc)) {}) }; // expected-warning {{attribute only applies to return values that are pointers}}
+enum { s3 = sizeof(^void *() __attribute((malloc)) { return 0; }) }; // no-warning
 
 __attribute((malloc))
 void * xalloc(unsigned n) { return malloc(n); } // no-warning
 // RUN: grep 'define .*noalias .* @xalloc(' %t %t
 
 #define malloc_like __attribute((__malloc__))
 void * xalloc2(unsigned) malloc_like;
 void * xalloc2(unsigned n) { return malloc(n); }
 // RUN: grep 'define .*noalias .* @xalloc2(' %t %t
 

test/Sema/attr-minsize.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fblocks -verify %s
 
 int foo() __attribute__((__minsize__));
 
-int var1 __attribute__((__minsize__)); // expected-error{{'__minsize__' attribute only applies to functions and methods}}
+int var1 __attribute__((__minsize__)); // expected-error{{'__minsize__' attribute only applies to functions, methods and blocks}}
+
+void (^bar)() = ^ __attribute__((__minsize__)) {};

test/Sema/attr-noinline.c

-// RUN: %clang_cc1 %s -verify -fsyntax-only
+// RUN: %clang_cc1 %s -verify -fblocks -fsyntax-only
 
 int a __attribute__((noinline)); // expected-warning {{'noinline' attribute only applies to functions}}
 
 void t1() __attribute__((noinline));
 
 void t2() __attribute__((noinline(2))); // expected-error {{'noinline' attribute takes no arguments}}
 
+void (^t3)() = ^ __attribute__((noinline)) {};

test/Sema/nonnull.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fblocks -fsyntax-only -verify %s
 // rdar://9584012
 
 typedef struct {
   char *str;
 } Class;
 
 typedef union {
   Class *object;
void test_baz() {
   baz2(0); // no-warning
   baz3(0); // no-warning
 }
 
 void test_void_returns_nonnull(void) __attribute__((returns_nonnull)); // expected-warning {{'returns_nonnull' attribute only applies to return values that are pointers}}
 int test_int_returns_nonnull(void) __attribute__((returns_nonnull)); // expected-warning {{'returns_nonnull' attribute only applies to return values that are pointers}}
 void *test_ptr_returns_nonnull(void) __attribute__((returns_nonnull)); // no-warning
 
-int i __attribute__((nonnull)); // expected-warning {{'nonnull' attribute only applies to functions, methods, and parameters}}
-int j __attribute__((returns_nonnull)); // expected-warning {{'returns_nonnull' attribute only applies to functions and methods}}
+int i __attribute__((nonnull)); // expected-warning {{'nonnull' attribute only applies to functions, methods, parameters and blocks}}
+int j __attribute__((returns_nonnull)); // expected-warning {{'returns_nonnull' attribute only applies to functions, methods and blocks}}
 void *test_no_fn_proto() __attribute__((returns_nonnull)); // no-warning
 void *test_with_fn_proto(void) __attribute__((returns_nonnull)); // no-warning
 
 __attribute__((returns_nonnull))
 void *test_bad_returns_null(void) {
   return 0; // expected-warning {{null returned from function that requires a non-null return value}}
 }
 

 }
 
 void pr21668_2(__attribute__((nonnull)) const char *p) {
   p = 0;
   if (p) // No warning
     ;
 }
 
+void (^block1)() = ^(int a) __attribute__((nonnull(2))) {}; // expected-error {{'nonnull' attribute parameter 1 is out of bounds}}
+void (^block2)() = ^(int a) __attribute__((nonnull)) {}; // expected-warning {{'nonnull' attribute applied to function with no pointer arguments}}
+void (^block3)() = ^() __attribute__((returns_nonnull)) {}; // expected-warning {{'returns_nonnull' attribute only applies to return values that are pointers}}
+int (^block4)() = ^int() __attribute__((returns_nonnull)) { return 0; }; // expected-warning {{'returns_nonnull' attribute only applies to return values that are pointers}}
+void *(^block5)() = ^() __attribute__((returns_nonnull)) { return (void *) 0; };
+
 __attribute__((returns_nonnull)) void *returns_nonnull_whee();
 
 void returns_nonnull_warning_tests() {
   if (returns_nonnull_whee() == NULL) {} // expected-warning {{comparison of nonnull function call 'returns_nonnull_whee()' equal to a null pointer is 'false' on first encounter}}
 
   if (returns_nonnull_whee() != NULL) {} // expected-warning {{comparison of nonnull function call 'returns_nonnull_whee()' not equal to a null pointer is 'true' on first encounter}}
 
   if (returns_nonnull_whee()) {} // expected-warning {{nonnull function call 'returns_nonnull_whee()' will evaluate to 'true' on first encounter}}
   if (!returns_nonnull_whee()) {} // expected-warning {{nonnull function call 'returns_nonnull_whee()' will evaluate to 'true' on first encounter}}
 
   int and_again = !returns_nonnull_whee(); // expected-warning {{nonnull function call 'returns_nonnull_whee()' will evaluate to 'true' on first encounter}}
   and_again = !returns_nonnull_whee(); // expected-warning {{nonnull function call 'returns_nonnull_whee()' will evaluate to 'true' on first encounter}}
 }

test/SemaObjC/attr-cf_returns.m

 // RUN: %clang_cc1 -verify -fsyntax-only -fobjc-arc -fblocks %s
 
 #if __has_feature(attribute_cf_returns_on_parameters)
 # error "okay!"
 // expected-error@-1 {{okay!}}
 #else
 # error "uh-oh"
 #endif
 
 #define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
 #define CF_RETURNS_NOT_RETAINED __attribute__((cf_returns_not_retained))
 
-int x CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions, methods, and parameters}}
-int y CF_RETURNS_NOT_RETAINED; // expected-warning{{'cf_returns_not_retained' attribute only applies to functions, methods, and parameters}}
+int x CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions, methods and parameters}}
+int y CF_RETURNS_NOT_RETAINED; // expected-warning{{'cf_returns_not_retained' attribute only applies to functions, methods and parameters}}
 
 typedef struct __CFFoo *CFFooRef;
 
 int invalid1() CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions that return a pointer}}
 void invalid2() CF_RETURNS_RETAINED; // expected-warning{{'cf_returns_retained' attribute only applies to functions that return a pointer}}
 
 CFFooRef valid1() CF_RETURNS_RETAINED;
 id valid2() CF_RETURNS_RETAINED;

test/SemaObjC/objcbridge-attribute-arc.m

 
 typedef union __CFUColor __attribute__((objc_bridge(NSUColor))) *CFUColor1Ref; // expected-error {{parameter of 'objc_bridge' attribute must be 'id' when used on a typedef}}
 
 typedef union __attribute__((objc_bridge(NSUColor))) __CFUPrimeColor XXX;
 typedef XXX *CFUColor2Ref;
 
 @interface I
 {
-   __attribute__((objc_bridge(NSError))) void * color; // expected-error {{'objc_bridge' attribute only applies to structs, unions, and typedefs}};
+   __attribute__((objc_bridge(NSError))) void * color; // expected-error {{'objc_bridge' attribute only applies to structs, unions and typedefs}};
 }
 @end
 
 @protocol NSTesting @end
 @class NSString;
 
 typedef struct __attribute__((objc_bridge(NSTesting))) __CFError *CFTestingRef; // expected-note {{declared here}}
 

test/SemaObjC/objcbridge-attribute.m

 typedef struct Opaque *OpaqueRef __attribute__((objc_bridge(id))); // expected-error {{'objc_bridge(id)' is only allowed on structs and typedefs of void pointers}}
 
 #if !__has_feature(objc_bridge_id_on_typedefs)
 #error objc_bridge(id) on typedefs feature not found!
 #endif
 
 @interface I
 {
-   __attribute__((objc_bridge(NSError))) void * color; // expected-error {{'objc_bridge' attribute only applies to structs, unions, and typedefs}};
+   __attribute__((objc_bridge(NSError))) void * color; // expected-error {{'objc_bridge' attribute only applies to structs, unions and typedefs}};
 }
 @end
 
 @protocol NSTesting @end
 @class NSString;
 
 typedef struct __attribute__((objc_bridge(NSTesting))) __CFError *CFTestingRef; // expected-note {{declared here}}
 

utils/TableGen/ClangAttrEmitter.cpp

switch (SubMask) {
     case ObjCProtocol: return "ExpectedObjectiveCProtocol";
     
     // "GenericRecord" means struct, union or class; check the language options
     // and if not compiling for C++, strip off the class part. Note that this
     // relies on the fact that the context for this declares "Sema &S".
     case GenericRecord:
       return "(S.getLangOpts().CPlusPlus ? ExpectedStructOrUnionOrClass : "
                                            "ExpectedStructOrUnion)";
+    case Func | Block: return "ExpectedFunctionOrBlock";
     case Func | ObjCMethod | Block: return "ExpectedFunctionMethodOrBlock";
     case Func | ObjCMethod | Class: return "ExpectedFunctionMethodOrClass";
     case Func | Param:
     case Func | ObjCMethod | Param: return "ExpectedFunctionMethodOrParameter";
+    case Func | ObjCMethod | Block | Param: return "ExpectedFunctionMethodBlockOrParameter";
     case Func | ObjCMethod: return "ExpectedFunctionOrMethod";
     case Func | Var: return "ExpectedVariableOrFunction";
 
     // If not compiling for C++, the class portion does not apply.
     case Func | Var | Class:
       return "(S.getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : "
                                            "ExpectedVariableOrFunction)";