From: Michael Kruse Date: Fri, 3 Aug 2018 01:21:16 +0000 (+0000) Subject: Append new attributes to the end of an AttributeList. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=915cb4dbc21080a91a9a6277c2bc81c2c6f79d09;p=clang Append new attributes to the end of an AttributeList. Recommit of r335084 after revert in r335516. ... instead of prepending it at the beginning (the original behavior since implemented in r122535 2010-12-23). This builds up an AttributeList in the the order in which the attributes appear in the source. The reverse order caused nodes for attributes in the AST (e.g. LoopHint) to be in the reverse order, and therefore printed in the wrong order in -ast-dump. Some TODO comments mention this. The order was explicitly reversed for enable_if attribute overload resolution and name mangling, which is not necessary anymore with this patch. The change unfortunately has some secondary effect, especially on diagnostic output. In the simplest cases, the CHECK lines or expected diagnostic were changed to the the new output. If the kind of error/warning changed, the attributes' order was changed instead. This unfortunately causes some 'previous occurrence here' hints to be textually after the main marker. This typically happens when attributes are merged, but are incompatible to each other. Interchanging the role of the the main and note SourceLocation will also cause the case where two different declaration's attributes (in contrast to multiple attributes of the same declaration) are merged to be reverse. There is no easy fix because sometimes previous attributes are merged into a new declaration's attribute list, sometimes new attributes are added to a previous declaration's attribute list. Since 'previous occurrence here' pointing to locations after the main marker is not rare, I left the markers as-is; it is only relevant when the attributes are declared in the same declaration anyway. Differential Revision: https://reviews.llvm.org/D48100 git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@338800 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Sema/ParsedAttr.h b/include/clang/Sema/ParsedAttr.h index cfb91af783..1c33346a25 100644 --- a/include/clang/Sema/ParsedAttr.h +++ b/include/clang/Sema/ParsedAttr.h @@ -728,10 +728,6 @@ public: ParsedAttr &operator[](SizeType pos) { return *AttrList[pos]; } const ParsedAttr &operator[](SizeType pos) const { return *AttrList[pos]; } - void addAtStart(ParsedAttr *newAttr) { - assert(newAttr); - AttrList.insert(AttrList.begin(), newAttr); - } void addAtEnd(ParsedAttr *newAttr) { assert(newAttr); AttrList.push_back(newAttr); @@ -785,6 +781,23 @@ public: iterator end() { return iterator(AttrList.end()); } const_iterator end() const { return const_iterator(AttrList.end()); } + ParsedAttr &front() { + assert(!empty()); + return *AttrList.front(); + } + const ParsedAttr &front() const { + assert(!empty()); + return *AttrList.front(); + } + ParsedAttr &back() { + assert(!empty()); + return *AttrList.back(); + } + const ParsedAttr &back() const { + assert(!empty()); + return *AttrList.back(); + } + bool hasAttribute(ParsedAttr::Kind K) const { return llvm::any_of( AttrList, [K](const ParsedAttr *AL) { return AL->getKind() == K; }); @@ -826,7 +839,7 @@ public: SourceLocation ellipsisLoc = SourceLocation()) { ParsedAttr *attr = pool.create(attrName, attrRange, scopeName, scopeLoc, args, numArgs, syntax, ellipsisLoc); - addAtStart(attr); + addAtEnd(attr); return attr; } @@ -842,7 +855,7 @@ public: ParsedAttr *attr = pool.create( attrName, attrRange, scopeName, scopeLoc, Param, introduced, deprecated, obsoleted, unavailable, MessageExpr, syntax, strict, ReplacementExpr); - addAtStart(attr); + addAtEnd(attr); return attr; } @@ -853,7 +866,7 @@ public: IdentifierLoc *Param3, ParsedAttr::Syntax syntax) { ParsedAttr *attr = pool.create(attrName, attrRange, scopeName, scopeLoc, Param1, Param2, Param3, syntax); - addAtStart(attr); + addAtEnd(attr); return attr; } @@ -867,7 +880,7 @@ public: ParsedAttr *attr = pool.createTypeTagForDatatype( attrName, attrRange, scopeName, scopeLoc, argumentKind, matchingCType, layoutCompatible, mustBeNull, syntax); - addAtStart(attr); + addAtEnd(attr); return attr; } @@ -878,7 +891,7 @@ public: ParsedAttr::Syntax syntaxUsed) { ParsedAttr *attr = pool.createTypeAttribute(attrName, attrRange, scopeName, scopeLoc, typeArg, syntaxUsed); - addAtStart(attr); + addAtEnd(attr); return attr; } @@ -891,7 +904,7 @@ public: ParsedAttr *attr = pool.createPropertyAttribute(attrName, attrRange, scopeName, scopeLoc, getterId, setterId, syntaxUsed); - addAtStart(attr); + addAtEnd(attr); return attr; } diff --git a/lib/AST/ItaniumMangle.cpp b/lib/AST/ItaniumMangle.cpp index 2dc04f2f3d..b483187394 100644 --- a/lib/AST/ItaniumMangle.cpp +++ b/lib/AST/ItaniumMangle.cpp @@ -721,10 +721,8 @@ void CXXNameMangler::mangleFunctionEncodingBareType(const FunctionDecl *FD) { if (FD->hasAttr()) { FunctionTypeDepthState Saved = FunctionTypeDepth.push(); Out << "Ua9enable_ifI"; - // FIXME: specific_attr_iterator iterates in reverse order. Fix that and use - // it here. - for (AttrVec::const_reverse_iterator I = FD->getAttrs().rbegin(), - E = FD->getAttrs().rend(); + for (AttrVec::const_iterator I = FD->getAttrs().begin(), + E = FD->getAttrs().end(); I != E; ++I) { EnableIfAttr *EIA = dyn_cast(*I); if (!EIA) diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp index 9ba44d07ab..17dd246122 100644 --- a/lib/Parse/ParseDeclCXX.cpp +++ b/lib/Parse/ParseDeclCXX.cpp @@ -3875,7 +3875,7 @@ bool Parser::ParseCXX11AttributeArgs(IdentifierInfo *AttrName, if (!Attrs.empty() && IsBuiltInOrStandardCXX11Attribute(AttrName, ScopeName)) { - ParsedAttr &Attr = *Attrs.begin(); + ParsedAttr &Attr = Attrs.back(); // If the attribute is a standard or built-in attribute and we are // parsing an argument list, we need to determine whether this attribute // was allowed to have an argument list (such as [[deprecated]]), and how diff --git a/lib/Parse/ParseObjc.cpp b/lib/Parse/ParseObjc.cpp index 99e5edb9d4..655ae56159 100644 --- a/lib/Parse/ParseObjc.cpp +++ b/lib/Parse/ParseObjc.cpp @@ -384,12 +384,12 @@ static void addContextSensitiveTypeNullability(Parser &P, if (D.getNumTypeObjects() > 0) { // Add the attribute to the declarator chunk nearest the declarator. - D.getTypeObject(0).getAttrs().addAtStart( + D.getTypeObject(0).getAttrs().addAtEnd( getNullabilityAttr(D.getAttributePool())); } else if (!addedToDeclSpec) { // Otherwise, just put it on the declaration specifiers (if one // isn't there already). - D.getMutableDeclSpec().getAttributes().addAtStart( + D.getMutableDeclSpec().getAttributes().addAtEnd( getNullabilityAttr(D.getMutableDeclSpec().getAttributes().getPool())); addedToDeclSpec = true; } @@ -1198,7 +1198,7 @@ static void takeDeclAttributes(ParsedAttributesView &attrs, for (auto &AL : llvm::reverse(from)) { if (!AL.isUsedAsTypeAttr()) { from.remove(&AL); - attrs.addAtStart(&AL); + attrs.addAtEnd(&AL); } } } diff --git a/lib/Sema/SemaAttr.cpp b/lib/Sema/SemaAttr.cpp index 1a8a000753..f6f7afe757 100644 --- a/lib/Sema/SemaAttr.cpp +++ b/lib/Sema/SemaAttr.cpp @@ -661,7 +661,7 @@ void Sema::AddPragmaAttributes(Scope *S, Decl *D) { Entry.IsUsed = true; PragmaAttributeCurrentTargetDecl = D; ParsedAttributesView Attrs; - Attrs.addAtStart(Attribute); + Attrs.addAtEnd(Attribute); ProcessDeclAttributeList(S, D, Attrs); PragmaAttributeCurrentTargetDecl = nullptr; } diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index 08af485ef4..6b0837849b 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -6215,24 +6215,6 @@ Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance, return nullptr; } -// specific_attr_iterator iterates over enable_if attributes in reverse, and -// enable_if is order-sensitive. As a result, we need to reverse things -// sometimes. Size of 4 elements is arbitrary. -static SmallVector -getOrderedEnableIfAttrs(const FunctionDecl *Function) { - SmallVector Result; - if (!Function->hasAttrs()) - return Result; - - const auto &FuncAttrs = Function->getAttrs(); - for (Attr *Attr : FuncAttrs) - if (auto *EnableIf = dyn_cast(Attr)) - Result.push_back(EnableIf); - - std::reverse(Result.begin(), Result.end()); - return Result; -} - static bool convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, ArrayRef Args, Sema::SFINAETrap &Trap, @@ -6306,9 +6288,8 @@ convertArgsForAvailabilityChecks(Sema &S, FunctionDecl *Function, Expr *ThisArg, EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef Args, bool MissingImplicitThis) { - SmallVector EnableIfAttrs = - getOrderedEnableIfAttrs(Function); - if (EnableIfAttrs.empty()) + auto EnableIfAttrs = Function->specific_attrs(); + if (EnableIfAttrs.begin() == EnableIfAttrs.end()) return nullptr; SFINAETrap Trap(*this); @@ -6318,7 +6299,7 @@ EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef Args, if (!convertArgsForAvailabilityChecks( *this, Function, /*ThisArg=*/nullptr, Args, Trap, /*MissingImplicitThis=*/true, DiscardedThis, ConvertedArgs)) - return EnableIfAttrs[0]; + return *EnableIfAttrs.begin(); for (auto *EIA : EnableIfAttrs) { APValue Result; @@ -8967,24 +8948,21 @@ static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1, return Cand1Attr ? Comparison::Better : Comparison::Worse; } - // FIXME: The next several lines are just - // specific_attr_iterator but going in declaration order, - // instead of reverse order which is how they're stored in the AST. - auto Cand1Attrs = getOrderedEnableIfAttrs(Cand1); - auto Cand2Attrs = getOrderedEnableIfAttrs(Cand2); - - // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1 - // has fewer enable_if attributes than Cand2. - if (Cand1Attrs.size() < Cand2Attrs.size()) - return Comparison::Worse; + auto Cand1Attrs = Cand1->specific_attrs(); + auto Cand2Attrs = Cand2->specific_attrs(); auto Cand1I = Cand1Attrs.begin(); llvm::FoldingSetNodeID Cand1ID, Cand2ID; - for (auto &Cand2A : Cand2Attrs) { + for (EnableIfAttr *Cand2A : Cand2Attrs) { Cand1ID.clear(); Cand2ID.clear(); - auto &Cand1A = *Cand1I++; + // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1 + // has fewer enable_if attributes than Cand2. + auto Cand1A = Cand1I++; + if (Cand1A == Cand1Attrs.end()) + return Comparison::Worse; + Cand1A->getCond()->Profile(Cand1ID, S.getASTContext(), true); Cand2A->getCond()->Profile(Cand2ID, S.getASTContext(), true); if (Cand1ID != Cand2ID) diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp index 284d34b22c..7bd9c8f315 100644 --- a/lib/Sema/SemaType.cpp +++ b/lib/Sema/SemaType.cpp @@ -246,7 +246,7 @@ namespace { getMutableDeclSpec().getAttributes().clearListOnly(); for (ParsedAttr *AL : savedAttrs) - getMutableDeclSpec().getAttributes().addAtStart(AL); + getMutableDeclSpec().getAttributes().addAtEnd(AL); } }; } // end anonymous namespace @@ -255,7 +255,7 @@ static void moveAttrFromListToList(ParsedAttr &attr, ParsedAttributesView &fromList, ParsedAttributesView &toList) { fromList.remove(&attr); - toList.addAtStart(&attr); + toList.addAtEnd(&attr); } /// The location of a type attribute. @@ -4128,7 +4128,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, SourceRange(pointerLoc), nullptr, SourceLocation(), nullptr, 0, syntax); - attrs.addAtStart(nullabilityAttr); + attrs.addAtEnd(nullabilityAttr); if (inferNullabilityCS) { state.getDeclarator().getMutableDeclSpec().getObjCQualifiers() @@ -5093,7 +5093,7 @@ static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, &S.Context.Idents.get("objc_ownership"), SourceLocation(), /*scope*/ nullptr, SourceLocation(), /*args*/ &Args, 1, ParsedAttr::AS_GNU); - chunk.getAttrs().addAtStart(attr); + chunk.getAttrs().addAtEnd(attr); // TODO: mark whether we did this inference? } diff --git a/lib/Serialization/ASTReaderDecl.cpp b/lib/Serialization/ASTReaderDecl.cpp index 613579d907..c8ce1a1fcd 100644 --- a/lib/Serialization/ASTReaderDecl.cpp +++ b/lib/Serialization/ASTReaderDecl.cpp @@ -2832,36 +2832,25 @@ static bool hasSameOverloadableAttrs(const FunctionDecl *A, // Note that pass_object_size attributes are represented in the function's // ExtParameterInfo, so we don't need to check them here. - SmallVector AEnableIfs; - // Since this is an equality check, we can ignore that enable_if attrs show up - // in reverse order. - for (const auto *EIA : A->specific_attrs()) - AEnableIfs.push_back(EIA); - - SmallVector BEnableIfs; - for (const auto *EIA : B->specific_attrs()) - BEnableIfs.push_back(EIA); - - // Two very common cases: either we have 0 enable_if attrs, or we have an - // unequal number of enable_if attrs. - if (AEnableIfs.empty() && BEnableIfs.empty()) - return true; - - if (AEnableIfs.size() != BEnableIfs.size()) - return false; - + // Return false if any of the enable_if expressions of A and B are different. llvm::FoldingSetNodeID Cand1ID, Cand2ID; - for (unsigned I = 0, E = AEnableIfs.size(); I != E; ++I) { + auto AEnableIfAttrs = A->specific_attrs(); + auto BEnableIfAttrs = B->specific_attrs(); + auto AEnableIf = AEnableIfAttrs.begin(); + auto BEnableIf = BEnableIfAttrs.begin(); + for (; AEnableIf != AEnableIfAttrs.end() && BEnableIf != BEnableIfAttrs.end(); + ++BEnableIf, ++AEnableIf) { Cand1ID.clear(); Cand2ID.clear(); - AEnableIfs[I]->getCond()->Profile(Cand1ID, A->getASTContext(), true); - BEnableIfs[I]->getCond()->Profile(Cand2ID, B->getASTContext(), true); + AEnableIf->getCond()->Profile(Cand1ID, A->getASTContext(), true); + BEnableIf->getCond()->Profile(Cand2ID, B->getASTContext(), true); if (Cand1ID != Cand2ID) return false; } - return true; + // Return false if the number of enable_if attributes was different. + return AEnableIf == AEnableIfAttrs.end() && BEnableIf == BEnableIfAttrs.end(); } /// Determine whether the two declarations refer to the same entity. diff --git a/test/Index/annotate-comments-availability-attrs.cpp b/test/Index/annotate-comments-availability-attrs.cpp index f31c4e16cc..2722c06fc8 100644 --- a/test/Index/annotate-comments-availability-attrs.cpp +++ b/test/Index/annotate-comments-availability-attrs.cpp @@ -13,7 +13,7 @@ void attr_availability_1() __attribute__((availability(macosx,obsoleted=10.0,introduced=8.0,deprecated=9.0, message="use availability_test in "))) __attribute__((availability(ios,unavailable, message="not for iOS"))); -// CHECK: FullCommentAsXML=[attr_availability_1c:@F@attr_availability_1#void attr_availability_1() Aaa.not for iOS8.09.010.0use availability_test in <foo.h>] +// CHECK: FullCommentAsXML=[attr_availability_1c:@F@attr_availability_1#void attr_availability_1() Aaa.8.09.010.0use availability_test in <foo.h>not for iOS] /// Aaa. void attr_availability_2() __attribute__((availability(macosx,obsoleted=10.0.1,introduced=8.0.1,deprecated=9.0.1))); diff --git a/test/Index/complete-with-annotations.cpp b/test/Index/complete-with-annotations.cpp index 7bad8f1b7c..459bd9f573 100644 --- a/test/Index/complete-with-annotations.cpp +++ b/test/Index/complete-with-annotations.cpp @@ -14,7 +14,7 @@ void X::doSomething() { } // CHECK: CXXMethod:{ResultType void}{TypedText doSomething}{LeftParen (}{RightParen )} (34) -// CHECK: FieldDecl:{ResultType int}{TypedText field} (35) ("three", "two", "one") +// CHECK: FieldDecl:{ResultType int}{TypedText field} (35) ("one", "two", "three") // CHECK: CXXMethod:{ResultType void}{TypedText func2}{LeftParen (}{RightParen )} (34) ("some annotation") // CHECK: FieldDecl:{ResultType int}{TypedText member2} (35) ("another annotation", "some annotation") // CHECK: CXXMethod:{ResultType X &}{TypedText operator=}{LeftParen (}{Placeholder const X &}{RightParen )} (79) diff --git a/test/Misc/ast-print-pragmas.cpp b/test/Misc/ast-print-pragmas.cpp index f1a7b2479b..a87be2a340 100644 --- a/test/Misc/ast-print-pragmas.cpp +++ b/test/Misc/ast-print-pragmas.cpp @@ -1,11 +1,8 @@ // RUN: %clang_cc1 -ast-print %s -o - | FileCheck %s // RUN: %clang_cc1 -DMS_EXT -fsyntax-only -fms-extensions %s -triple x86_64-pc-win32 -ast-print | FileCheck %s --check-prefix=MS-EXT -// FIXME: A bug in ParsedAttributes causes the order of the attributes to be -// reversed. The checks are consequently in the reverse order below. - -// CHECK: #pragma clang loop interleave_count(8){{$}} -// CHECK-NEXT: #pragma clang loop vectorize_width(4) +// CHECK: #pragma clang loop vectorize_width(4) +// CHECK-NEXT: #pragma clang loop interleave_count(8){{$}} void test(int *List, int Length) { int i = 0; @@ -17,9 +14,9 @@ void test(int *List, int Length) { i++; } -// CHECK: #pragma clang loop interleave(disable) +// CHECK: #pragma clang loop distribute(disable) // CHECK-NEXT: #pragma clang loop vectorize(enable) -// CHECK-NEXT: #pragma clang loop distribute(disable) +// CHECK-NEXT: #pragma clang loop interleave(disable) #pragma clang loop distribute(disable) #pragma clang loop vectorize(enable) @@ -30,9 +27,9 @@ void test(int *List, int Length) { i++; } -// CHECK: #pragma clang loop interleave(enable) +// CHECK: #pragma clang loop distribute(enable) // CHECK-NEXT: #pragma clang loop vectorize(disable) -// CHECK-NEXT: #pragma clang loop distribute(enable) +// CHECK-NEXT: #pragma clang loop interleave(enable) #pragma clang loop distribute(enable) #pragma clang loop vectorize(disable) @@ -52,8 +49,8 @@ void test_nontype_template_param(int *List, int Length) { } } -// CHECK: #pragma clang loop interleave_count(I) // CHECK: #pragma clang loop vectorize_width(V) +// CHECK: #pragma clang loop interleave_count(I) void test_templates(int *List, int Length) { test_nontype_template_param<2, 4>(List, Length); diff --git a/test/PCH/pragma-loop.cpp b/test/PCH/pragma-loop.cpp index 7f443ddb03..b8079ff608 100644 --- a/test/PCH/pragma-loop.cpp +++ b/test/PCH/pragma-loop.cpp @@ -1,26 +1,23 @@ // RUN: %clang_cc1 -emit-pch -o %t.a %s // RUN: %clang_cc1 -include-pch %t.a %s -ast-print -o - | FileCheck %s -// FIXME: A bug in ParsedAttributes causes the order of the attributes to be -// reversed. The checks are consequently in the reverse order below. - -// CHECK: #pragma clang loop unroll_count(16){{$}} -// CHECK: #pragma clang loop interleave_count(8) // CHECK: #pragma clang loop vectorize_width(4) -// CHECK: #pragma clang loop distribute(enable) -// CHECK: #pragma clang loop unroll(disable) -// CHECK: #pragma clang loop interleave(disable) +// CHECK: #pragma clang loop interleave_count(8) +// CHECK: #pragma clang loop unroll_count(16){{$}} // CHECK: #pragma clang loop vectorize(enable) -// CHECK: #pragma clang loop distribute(disable) -// CHECK: #pragma clang loop unroll(full) -// CHECK: #pragma clang loop interleave(enable) +// CHECK: #pragma clang loop interleave(disable) +// CHECK: #pragma clang loop unroll(disable) +// CHECK: #pragma clang loop distribute(enable) // CHECK: #pragma clang loop vectorize(disable) +// CHECK: #pragma clang loop interleave(enable) +// CHECK: #pragma clang loop unroll(full) +// CHECK: #pragma clang loop distribute(disable) // FIXME: "#pragma unroll (enable)" is invalid and is not the input source. // CHECK: #pragma unroll (enable){{$}} // CHECK: #pragma unroll (32){{$}} // CHECK: #pragma nounroll{{$}} -// CHECK: #pragma clang loop interleave_count(I) // CHECK: #pragma clang loop vectorize_width(V) +// CHECK: #pragma clang loop interleave_count(I) #ifndef HEADER #define HEADER diff --git a/test/Parser/pragma-loop-safety.cpp b/test/Parser/pragma-loop-safety.cpp index ab87dcdcb6..1393cf7474 100644 --- a/test/Parser/pragma-loop-safety.cpp +++ b/test/Parser/pragma-loop-safety.cpp @@ -25,10 +25,10 @@ void test(int *List, int Length) { List[i] = i; } -/* expected-error {{duplicate directives 'vectorize(assume_safety)' and 'vectorize(enable)'}} */ #pragma clang loop vectorize(enable) -#pragma clang loop vectorize(assume_safety) -/* expected-error {{duplicate directives 'interleave(assume_safety)' and 'interleave(enable)'}} */ #pragma clang loop interleave(enable) -#pragma clang loop interleave(assume_safety) +#pragma clang loop vectorize(enable) +/* expected-error {{duplicate directives 'vectorize(enable)' and 'vectorize(assume_safety)'}} */ #pragma clang loop vectorize(assume_safety) +#pragma clang loop interleave(enable) +/* expected-error {{duplicate directives 'interleave(enable)' and 'interleave(assume_safety)'}} */ #pragma clang loop interleave(assume_safety) while (i-9 < Length) { List[i] = i; } diff --git a/test/Parser/pragma-loop.cpp b/test/Parser/pragma-loop.cpp index f42d196ce8..3db0fc4596 100644 --- a/test/Parser/pragma-loop.cpp +++ b/test/Parser/pragma-loop.cpp @@ -231,51 +231,50 @@ const int VV = 4; // of the next three tests rather than the last, and the order of the kinds // is also reversed. -/* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize_width(4) -#pragma clang loop vectorize(disable) -/* expected-error {{incompatible directives 'interleave(disable)' and 'interleave_count(4)'}} */ #pragma clang loop interleave_count(4) -#pragma clang loop interleave(disable) -/* expected-error {{incompatible directives 'unroll(disable)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4) -#pragma clang loop unroll(disable) +#pragma clang loop vectorize_width(4) +/* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize(disable) +#pragma clang loop interleave_count(4) +/* expected-error {{incompatible directives 'interleave(disable)' and 'interleave_count(4)'}} */ #pragma clang loop interleave(disable) +#pragma clang loop unroll_count(4) +/* expected-error {{incompatible directives 'unroll(disable)' and 'unroll_count(4)'}} */ #pragma clang loop unroll(disable) while (i-8 < Length) { List[i] = i; } -/* expected-error {{duplicate directives 'vectorize(disable)' and 'vectorize(enable)'}} */ #pragma clang loop vectorize(enable) -#pragma clang loop vectorize(disable) -/* expected-error {{duplicate directives 'interleave(disable)' and 'interleave(enable)'}} */ #pragma clang loop interleave(enable) -#pragma clang loop interleave(disable) -/* expected-error {{duplicate directives 'unroll(disable)' and 'unroll(full)'}} */ #pragma clang loop unroll(full) -#pragma clang loop unroll(disable) -/* expected-error {{duplicate directives 'distribute(disable)' and 'distribute(enable)'}} */ #pragma clang loop distribute(enable) -#pragma clang loop distribute(disable) +#pragma clang loop vectorize(enable) +/* expected-error {{duplicate directives 'vectorize(enable)' and 'vectorize(disable)'}} */ #pragma clang loop vectorize(disable) +#pragma clang loop interleave(enable) +/* expected-error {{duplicate directives 'interleave(enable)' and 'interleave(disable)'}} */ #pragma clang loop interleave(disable) +#pragma clang loop unroll(full) +/* expected-error {{duplicate directives 'unroll(full)' and 'unroll(disable)'}} */ #pragma clang loop unroll(disable) +#pragma clang loop distribute(enable) +/* expected-error {{duplicate directives 'distribute(enable)' and 'distribute(disable)'}} */ #pragma clang loop distribute(disable) while (i-9 < Length) { List[i] = i; } -/* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize(disable) -#pragma clang loop vectorize_width(4) -/* expected-error {{incompatible directives 'interleave(disable)' and 'interleave_count(4)'}} */ #pragma clang loop interleave(disable) -#pragma clang loop interleave_count(4) -/* expected-error {{incompatible directives 'unroll(disable)' and 'unroll_count(4)'}} */ #pragma clang loop unroll(disable) -#pragma clang loop unroll_count(4) +#pragma clang loop vectorize(disable) +/* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize_width(4) +#pragma clang loop interleave(disable) +/* expected-error {{incompatible directives 'interleave(disable)' and 'interleave_count(4)'}} */ #pragma clang loop interleave_count(4) +#pragma clang loop unroll(disable) +/* expected-error {{incompatible directives 'unroll(disable)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4) while (i-10 < Length) { List[i] = i; } -/* expected-error {{duplicate directives 'vectorize_width(4)' and 'vectorize_width(8)'}} */ #pragma clang loop vectorize_width(8) -#pragma clang loop vectorize_width(4) -/* expected-error {{duplicate directives 'interleave_count(4)' and 'interleave_count(8)'}} */ #pragma clang loop interleave_count(8) -#pragma clang loop interleave_count(4) -/* expected-error {{duplicate directives 'unroll_count(4)' and 'unroll_count(8)'}} */ #pragma clang loop unroll_count(8) -#pragma clang loop unroll_count(4) +#pragma clang loop vectorize_width(8) +/* expected-error {{duplicate directives 'vectorize_width(8)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize_width(4) +#pragma clang loop interleave_count(8) +/* expected-error {{duplicate directives 'interleave_count(8)' and 'interleave_count(4)'}} */ #pragma clang loop interleave_count(4) +#pragma clang loop unroll_count(8) +/* expected-error {{duplicate directives 'unroll_count(8)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4) while (i-11 < Length) { List[i] = i; } - -/* expected-error {{incompatible directives 'unroll(full)' and 'unroll_count(4)'}} */ #pragma clang loop unroll(full) -#pragma clang loop unroll_count(4) +#pragma clang loop unroll(full) +/* expected-error {{incompatible directives 'unroll(full)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4) while (i-11 < Length) { List[i] = i; } diff --git a/test/Parser/pragma-unroll-and-jam.cpp b/test/Parser/pragma-unroll-and-jam.cpp index 391d6b23ea..8452156f69 100644 --- a/test/Parser/pragma-unroll-and-jam.cpp +++ b/test/Parser/pragma-unroll-and-jam.cpp @@ -50,8 +50,8 @@ void test(int *List, int Length, int Value) { #pragma nounroll_and_jam /* expected-error {{expected a for, while, or do-while loop to follow '#pragma nounroll_and_jam'}} */ int l = Length; -/* expected-error {{incompatible directives '#pragma nounroll_and_jam' and '#pragma unroll_and_jam(4)'}} */ #pragma unroll_and_jam 4 -#pragma nounroll_and_jam +#pragma unroll_and_jam 4 +/* expected-error {{incompatible directives '#pragma nounroll_and_jam' and '#pragma unroll_and_jam(4)'}} */ #pragma nounroll_and_jam for (int i = 0; i < Length; i++) { for (int j = 0; j < Length; j++) { List[i * Length + j] = Value; diff --git a/test/Parser/pragma-unroll.cpp b/test/Parser/pragma-unroll.cpp index b1d7798798..fb71381287 100644 --- a/test/Parser/pragma-unroll.cpp +++ b/test/Parser/pragma-unroll.cpp @@ -55,56 +55,56 @@ void test(int *List, int Length) { #pragma nounroll /* expected-error {{expected a for, while, or do-while loop to follow '#pragma nounroll'}} */ int l = Length; -/* expected-error {{incompatible directives 'unroll(disable)' and '#pragma unroll(4)'}} */ #pragma unroll 4 -#pragma clang loop unroll(disable) +#pragma unroll 4 +/* expected-error {{incompatible directives 'unroll(disable)' and '#pragma unroll(4)'}} */ #pragma clang loop unroll(disable) while (i-10 < Length) { List[i] = i; } -/* expected-error {{incompatible directives 'unroll(full)' and '#pragma unroll(4)'}} */ #pragma unroll(4) -#pragma clang loop unroll(full) +#pragma unroll(4) +/* expected-error {{incompatible directives 'unroll(full)' and '#pragma unroll(4)'}} */ #pragma clang loop unroll(full) while (i-11 < Length) { List[i] = i; } -/* expected-error {{incompatible directives 'unroll(enable)' and '#pragma unroll(4)'}} */ #pragma unroll(4) -#pragma clang loop unroll(enable) +#pragma unroll(4) +/* expected-error {{incompatible directives 'unroll(enable)' and '#pragma unroll(4)'}} */ #pragma clang loop unroll(enable) while (i-11 < Length) { List[i] = i; } -/* expected-error {{incompatible directives '#pragma unroll' and '#pragma unroll(4)'}} */ #pragma unroll(4) -#pragma unroll +#pragma unroll(4) +/* expected-error {{incompatible directives '#pragma unroll' and '#pragma unroll(4)'}} */ #pragma unroll while (i-11 < Length) { List[i] = i; } -/* expected-error {{incompatible directives '#pragma nounroll' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4) -#pragma nounroll +#pragma clang loop unroll_count(4) +/* expected-error {{incompatible directives '#pragma nounroll' and 'unroll_count(4)'}} */ #pragma nounroll while (i-12 < Length) { List[i] = i; } -/* expected-error {{duplicate directives '#pragma nounroll' and '#pragma nounroll'}} */ #pragma nounroll #pragma nounroll +/* expected-error {{duplicate directives '#pragma nounroll' and '#pragma nounroll'}} */ #pragma nounroll while (i-13 < Length) { List[i] = i; } -/* expected-error {{duplicate directives '#pragma unroll' and '#pragma unroll'}} */ #pragma unroll #pragma unroll +/* expected-error {{duplicate directives '#pragma unroll' and '#pragma unroll'}} */ #pragma unroll while (i-14 < Length) { List[i] = i; } -/* expected-error {{duplicate directives 'unroll(full)' and '#pragma unroll'}} */ #pragma unroll -#pragma clang loop unroll(full) +#pragma unroll +/* expected-error {{duplicate directives '#pragma unroll' and 'unroll(full)'}} */ #pragma clang loop unroll(full) while (i-15 < Length) { List[i] = i; } -/* expected-error {{duplicate directives '#pragma unroll(4)' and '#pragma unroll(4)'}} */ #pragma unroll 4 -#pragma unroll(4) +#pragma unroll 4 +/* expected-error {{duplicate directives '#pragma unroll(4)' and '#pragma unroll(4)'}} */ #pragma unroll(4) while (i-16 < Length) { List[i] = i; } diff --git a/test/Sema/attr-availability-tvos.c b/test/Sema/attr-availability-tvos.c index 68337e49ce..4f8c4588ec 100644 --- a/test/Sema/attr-availability-tvos.c +++ b/test/Sema/attr-availability-tvos.c @@ -27,10 +27,8 @@ void test_transcribed_availability() { f9(0); } -__attribute__((availability(ios,introduced=9_0,deprecated=9_0,message="" ))) // expected-note{{previous attribute is here}} \ - // expected-note{{previous attribute is here}} -__attribute__((availability(ios,introduced=7_0))) // expected-warning{{availability does not match previous declaration}} \ - // expected-warning{{availability does not match previous declaration}} +__attribute__((availability(ios,introduced=9_0,deprecated=9_0,message="" ))) // expected-warning 2{{availability does not match previous declaration}} +__attribute__((availability(ios,introduced=7_0))) // expected-note 2{{previous attribute is here}} void f10(int); // Test tvOS specific attributes. diff --git a/test/Sema/attr-availability.c b/test/Sema/attr-availability.c index 1b8cbd256c..4a26638252 100644 --- a/test/Sema/attr-availability.c +++ b/test/Sema/attr-availability.c @@ -64,8 +64,8 @@ enum { void f4(int) __attribute__((availability(ios,deprecated=3.0))); void f4(int) __attribute__((availability(ios,introduced=4.0))); // expected-warning {{feature cannot be deprecated in iOS version 3.0 before it was introduced in version 4.0; attribute ignored}} -void f5(int) __attribute__((availability(ios,deprecated=3.0), - availability(ios,introduced=4.0))); // expected-warning {{feature cannot be deprecated in iOS version 3.0 before it was introduced in version 4.0; attribute ignored}} +void f5(int) __attribute__((availability(ios,deprecated=3.0), // expected-warning {{feature cannot be deprecated in iOS version 3.0 before it was introduced in version 4.0; attribute ignored}} + availability(ios,introduced=4.0))); void f6(int) __attribute__((availability(ios,deprecated=3.0))); // expected-note {{previous attribute is here}} void f6(int) __attribute__((availability(ios,deprecated=4.0))); // expected-warning {{availability does not match previous declaration}} diff --git a/test/Sema/attr-coldhot.c b/test/Sema/attr-coldhot.c index 972f5a5266..a4b1582206 100644 --- a/test/Sema/attr-coldhot.c +++ b/test/Sema/attr-coldhot.c @@ -6,7 +6,7 @@ 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}} \ +int qux() __attribute__((__hot__)) __attribute__((__cold__)); // expected-error{{'__cold__' and 'hot' 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}} \ +int baz() __attribute__((__cold__)) __attribute__((__hot__)); // expected-error{{'__hot__' and 'cold' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} diff --git a/test/Sema/attr-disable-tail-calls.c b/test/Sema/attr-disable-tail-calls.c index e8f5bcc73e..0545e951e6 100644 --- a/test/Sema/attr-disable-tail-calls.c +++ b/test/Sema/attr-disable-tail-calls.c @@ -1,10 +1,10 @@ // RUN: %clang_cc1 -fsyntax-only -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}} +void __attribute__((disable_tail_calls,naked)) foo1(int a) { // expected-error {{'naked' and 'disable_tail_calls' 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}} +void __attribute__((naked,disable_tail_calls)) foo2(int a) { // expected-error {{'disable_tail_calls' and 'naked' attributes are not compatible}} expected-note {{conflicting attribute is here}} __asm__(""); } diff --git a/test/Sema/attr-long-call.c b/test/Sema/attr-long-call.c index cd3de1bf9e..e80f8fdd52 100644 --- a/test/Sema/attr-long-call.c +++ b/test/Sema/attr-long-call.c @@ -19,8 +19,8 @@ __attribute((near)) void foo6(); __attribute((long_call, far)) void foo7(); __attribute((short_call, near)) void foo11(); -__attribute((far, near)) void foo8(); // expected-error {{'far' and 'near' attributes are not compatible}} \ +__attribute((far, near)) void foo8(); // expected-error {{'near' and 'far' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} -__attribute((short_call, long_call)) void foo12(); // expected-error {{'short_call' and 'long_call' attributes are not compatible}} \ +__attribute((short_call, long_call)) void foo12(); // expected-error {{'long_call' and 'short_call' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} diff --git a/test/Sema/attr-micromips.c b/test/Sema/attr-micromips.c index fe587fa3db..27c9d3b54f 100644 --- a/test/Sema/attr-micromips.c +++ b/test/Sema/attr-micromips.c @@ -6,9 +6,9 @@ __attribute__((micromips(1))) void foo2(); // expected-error {{'micromips' at __attribute((nomicromips)) int a; // expected-error {{attribute only applies to functions}} __attribute((micromips)) int b; // expected-error {{attribute only applies to functions}} -__attribute__((micromips,mips16)) void foo5(); // expected-error {{'micromips' and 'mips16' attributes are not compatible}} \ +__attribute__((micromips,mips16)) void foo5(); // expected-error {{'mips16' and 'micromips' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} -__attribute__((mips16,micromips)) void foo6(); // expected-error {{'mips16' and 'micromips' attributes are not compatible}} \ +__attribute__((mips16,micromips)) void foo6(); // expected-error {{'micromips' and 'mips16' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} __attribute((micromips)) void foo7(); diff --git a/test/Sema/attr-notail.c b/test/Sema/attr-notail.c index 4d05fcf6f2..f65af47518 100644 --- a/test/Sema/attr-notail.c +++ b/test/Sema/attr-notail.c @@ -1,8 +1,8 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s -int callee0() __attribute__((not_tail_called,always_inline)); // expected-error{{'not_tail_called' and 'always_inline' attributes are not compatible}} \ +int callee0() __attribute__((not_tail_called,always_inline)); // expected-error{{'always_inline' and 'not_tail_called' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} -int callee1() __attribute__((always_inline,not_tail_called)); // expected-error{{'always_inline' and 'not_tail_called' attributes are not compatible}} \ +int callee1() __attribute__((always_inline,not_tail_called)); // expected-error{{'not_tail_called' and 'always_inline' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} int foo(int a) { diff --git a/test/Sema/attr-ownership.c b/test/Sema/attr-ownership.c index ff6c7197df..5ce758d9f4 100644 --- a/test/Sema/attr-ownership.c +++ b/test/Sema/attr-ownership.c @@ -16,11 +16,11 @@ void *f11(float i) __attribute__((ownership_returns(foo, 1))); // expected-erro void *f12(float i, int k, int f, int *j) __attribute__((ownership_returns(foo, 4))); // expected-error {{'ownership_returns' attribute only applies to integer arguments}} void f13(int *i, int *j) __attribute__((ownership_holds(foo, 1))) __attribute__((ownership_takes(foo, 2))); -void f14(int i, int j, int *k) __attribute__((ownership_holds(foo, 3))) __attribute__((ownership_takes(foo, 3))); // expected-error {{'ownership_holds' and 'ownership_takes' attributes are not compatible}} +void f14(int i, int j, int *k) __attribute__((ownership_holds(foo, 3))) __attribute__((ownership_takes(foo, 3))); // expected-error {{'ownership_takes' and 'ownership_holds' attributes are not compatible}} void f15(int, int) - __attribute__((ownership_returns(foo, 1))) // expected-note {{declared with index 1 here}} - __attribute__((ownership_returns(foo, 2))); // expected-error {{'ownership_returns' attribute index does not match; here it is 2}} + __attribute__((ownership_returns(foo, 1))) // expected-error {{'ownership_returns' attribute index does not match; here it is 1}} + __attribute__((ownership_returns(foo, 2))); // expected-note {{declared with index 2 here}} void f16(int *i, int *j) __attribute__((ownership_holds(foo, 1))) __attribute__((ownership_holds(foo, 1))); // OK, same index void f17(void*) __attribute__((ownership_takes(__, 1))); void f18() __attribute__((ownership_takes(foo, 1))); // expected-warning {{'ownership_takes' attribute only applies to non-K&R-style functions}} diff --git a/test/Sema/attr-ownership.cpp b/test/Sema/attr-ownership.cpp index cde195ff0a..7381285e2d 100644 --- a/test/Sema/attr-ownership.cpp +++ b/test/Sema/attr-ownership.cpp @@ -2,6 +2,6 @@ class C { void f(int, int) - __attribute__((ownership_returns(foo, 2))) // expected-note {{declared with index 2 here}} - __attribute__((ownership_returns(foo, 3))); // expected-error {{'ownership_returns' attribute index does not match; here it is 3}} + __attribute__((ownership_returns(foo, 2))) // expected-error {{'ownership_returns' attribute index does not match; here it is 2}} + __attribute__((ownership_returns(foo, 3))); // expected-note {{declared with index 3 here}} }; diff --git a/test/Sema/attr-print.c b/test/Sema/attr-print.c index 16b440d5d7..a326e1c58f 100644 --- a/test/Sema/attr-print.c +++ b/test/Sema/attr-print.c @@ -22,15 +22,13 @@ int * __ptr32 p32; // CHECK: int * __ptr64 p64; int * __ptr64 p64; -// TODO: the Type Printer has no way to specify the order to print attributes -// in, and so it currently always prints them in reverse order. Fix this. -// CHECK: int * __ptr32 __uptr p32_2; +// CHECK: int * __uptr __ptr32 p32_2; int * __uptr __ptr32 p32_2; -// CHECK: int * __ptr64 __sptr p64_2; +// CHECK: int * __sptr __ptr64 p64_2; int * __sptr __ptr64 p64_2; -// CHECK: int * __ptr32 __uptr p32_3; +// CHECK: int * __uptr __ptr32 p32_3; int * __uptr __ptr32 p32_3; // CHECK: int * __sptr * __ptr32 ppsp32; diff --git a/test/Sema/attr-visibility.c b/test/Sema/attr-visibility.c index ed52ec2743..798d6dcd78 100644 --- a/test/Sema/attr-visibility.c +++ b/test/Sema/attr-visibility.c @@ -15,8 +15,8 @@ struct test5; struct __attribute__((visibility("hidden"))) test5; // expected-note {{previous attribute is here}} struct __attribute__((visibility("default"))) test5; // expected-error {{visibility does not match previous declaration}} -void test6() __attribute__((visibility("hidden"), // expected-note {{previous attribute is here}} - visibility("default"))); // expected-error {{visibility does not match previous declaration}} +void test6() __attribute__((visibility("default"), // expected-error {{visibility does not match previous declaration}} + visibility("hidden"))); // expected-note {{previous attribute is here}} extern int test7 __attribute__((visibility("default"))); // expected-note {{previous attribute is here}} extern int test7 __attribute__((visibility("hidden"))); // expected-error {{visibility does not match previous declaration}} diff --git a/test/Sema/internal_linkage.c b/test/Sema/internal_linkage.c index 57315d826e..cc8039acd2 100644 --- a/test/Sema/internal_linkage.c +++ b/test/Sema/internal_linkage.c @@ -1,9 +1,9 @@ // RUN: %clang_cc1 -fsyntax-only -verify -fdouble-square-bracket-attributes %s int var __attribute__((internal_linkage)); -int var2 __attribute__((internal_linkage,common)); // expected-error{{'internal_linkage' and 'common' attributes are not compatible}} \ +int var2 __attribute__((internal_linkage,common)); // expected-error{{'common' and 'internal_linkage' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} -int var3 __attribute__((common,internal_linkage)); // expected-error{{'common' and 'internal_linkage' attributes are not compatible}} \ +int var3 __attribute__((common,internal_linkage)); // expected-error{{'internal_linkage' and 'common' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} int var4 __attribute__((common)); // expected-error{{'common' and 'internal_linkage' attributes are not compatible}} \ diff --git a/test/Sema/mips-interrupt-attr.c b/test/Sema/mips-interrupt-attr.c index 17344b6edc..7c5c9ddab5 100644 --- a/test/Sema/mips-interrupt-attr.c +++ b/test/Sema/mips-interrupt-attr.c @@ -19,11 +19,11 @@ __attribute__((interrupt(""))) void food() {} __attribute__((interrupt)) int foob() {return 0;} // expected-warning {{MIPS 'interrupt' attribute only applies to functions that have a 'void' return type}} __attribute__((interrupt())) void fooc(int a) {} // expected-warning {{MIPS 'interrupt' attribute only applies to functions that have no parameters}} -__attribute__((interrupt,mips16)) void fooe() {} // expected-error {{'interrupt' and 'mips16' attributes are not compatible}} \ +__attribute__((interrupt,mips16)) void fooe() {} // expected-error {{'mips16' and 'interrupt' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} -__attribute__((mips16,interrupt)) void foof() {} // expected-error {{'mips16' and 'interrupt' attributes are not compatible}} \ +__attribute__((mips16,interrupt)) void foof() {} // expected-error {{'interrupt' and 'mips16' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} -__attribute__((interrupt)) __attribute__ ((mips16)) void foo10() {} // expected-error {{'interrupt' and 'mips16' attributes are not compatible}} \ +__attribute__((interrupt)) __attribute__ ((mips16)) void foo10() {} // expected-error {{'mips16' and 'interrupt' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} -__attribute__((mips16)) __attribute ((interrupt)) void foo11() {} // expected-error {{'mips16' and 'interrupt' attributes are not compatible}} \ +__attribute__((mips16)) __attribute ((interrupt)) void foo11() {} // expected-error {{'interrupt' and 'mips16' attributes are not compatible}} \ // expected-note {{conflicting attribute is here}} diff --git a/test/Sema/nullability.c b/test/Sema/nullability.c index a0247e5af8..a5cb4b9a03 100644 --- a/test/Sema/nullability.c +++ b/test/Sema/nullability.c @@ -20,8 +20,8 @@ typedef int * _Null_unspecified null_unspecified_int_ptr; typedef int * _Nonnull _Nonnull redundant_1; // expected-warning{{duplicate nullability specifier '_Nonnull'}} // Conflicting nullability type specifiers. -typedef int * _Nonnull _Nullable conflicting_1; // expected-error{{nullability specifier '_Nonnull' conflicts with existing specifier '_Nullable'}} -typedef int * _Null_unspecified _Nonnull conflicting_2; // expected-error{{nullability specifier '_Null_unspecified' conflicts with existing specifier '_Nonnull'}} +typedef int * _Nonnull _Nullable conflicting_1; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} +typedef int * _Null_unspecified _Nonnull conflicting_2; // expected-error{{nullability specifier '_Nonnull' conflicts with existing specifier '_Null_unspecified'}} // Redundant nullability specifiers via a typedef are okay. typedef nonnull_int_ptr _Nonnull redundant_okay_1; diff --git a/test/SemaCXX/attr-print.cpp b/test/SemaCXX/attr-print.cpp index 960050bc71..d7ef42306b 100644 --- a/test/SemaCXX/attr-print.cpp +++ b/test/SemaCXX/attr-print.cpp @@ -13,8 +13,8 @@ void foo() __attribute__((const)); // CHECK: void bar() __attribute__((__const)); void bar() __attribute__((__const)); -// FIXME: Print this with correct format and order. -// CHECK: void foo1() __attribute__((pure)) __attribute__((noinline)); +// FIXME: Print this with correct format. +// CHECK: void foo1() __attribute__((noinline)) __attribute__((pure)); void foo1() __attribute__((noinline, pure)); // CHECK: typedef int Small1 __attribute__((mode(byte))); diff --git a/test/SemaCXX/ms-uuid.cpp b/test/SemaCXX/ms-uuid.cpp index 624ac0541d..c177570682 100644 --- a/test/SemaCXX/ms-uuid.cpp +++ b/test/SemaCXX/ms-uuid.cpp @@ -62,14 +62,14 @@ class __declspec(uuid("110000A0-0000-0000-C000-000000000049")) C2_2; [uuid("220000A0-0000-0000-C000-000000000049")] class C4 {}; // Both cl and clang-cl error out on this: -// expected-note@+1 {{previous uuid specified here}} -class __declspec(uuid("000000A0-0000-0000-C000-000000000049")) // expected-error@+1 {{uuid does not match previous declaration}} +class __declspec(uuid("000000A0-0000-0000-C000-000000000049")) +// expected-note@+1 {{previous uuid specified here}} __declspec(uuid("110000A0-0000-0000-C000-000000000049")) C5; -// expected-note@+1 {{previous uuid specified here}} -[uuid("000000A0-0000-0000-C000-000000000049"), // expected-error@+1 {{uuid does not match previous declaration}} +[uuid("000000A0-0000-0000-C000-000000000049"), +// expected-note@+1 {{previous uuid specified here}} uuid("110000A0-0000-0000-C000-000000000049")] class C6; // cl doesn't diagnose having one uuid each as []-style attributes and as diff --git a/test/SemaObjC/nullability.m b/test/SemaObjC/nullability.m index 93f4d1d499..885ced692e 100644 --- a/test/SemaObjC/nullability.m +++ b/test/SemaObjC/nullability.m @@ -36,14 +36,14 @@ __attribute__((objc_root_class)) - (nonnull NSFoo **)invalidMethod1; // expected-error{{nullability keyword 'nonnull' cannot be applied to multi-level pointer type 'NSFoo **'}} // expected-note@-1{{use nullability type specifier '_Nonnull' to affect the innermost pointer type of 'NSFoo **'}} -- (nonnull NSFoo * _Nullable)conflictingMethod1; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} -- (nonnull NSFoo * _Nonnull)redundantMethod1; // expected-warning{{duplicate nullability specifier '_Nonnull'}} +- (nonnull NSFoo * _Nullable)conflictingMethod1; // expected-error{{nullability specifier 'nonnull' conflicts with existing specifier '_Nullable'}} +- (nonnull NSFoo * _Nonnull)redundantMethod1; // expected-warning{{duplicate nullability specifier 'nonnull'}} @property(nonnull,retain) NSFoo *property1; @property(nullable,assign) NSFoo ** invalidProperty1; // expected-error{{nullability keyword 'nullable' cannot be applied to multi-level pointer type 'NSFoo **'}} // expected-note@-1{{use nullability type specifier '_Nullable' to affect the innermost pointer type of 'NSFoo **'}} -@property(null_unspecified,retain) NSFoo * _Nullable conflictingProperty1; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Null_unspecified'}} -@property(retain,nonnull) NSFoo * _Nonnull redundantProperty1; // expected-warning{{duplicate nullability specifier '_Nonnull'}} +@property(null_unspecified,retain) NSFoo * _Nullable conflictingProperty1; // expected-error{{nullability specifier 'null_unspecified' conflicts with existing specifier '_Nullable'}} +@property(retain,nonnull) NSFoo * _Nonnull redundantProperty1; // expected-warning{{duplicate nullability specifier 'nonnull'}} @property(null_unspecified,retain,nullable) NSFoo *conflictingProperty3; // expected-error{{nullability specifier 'nullable' conflicts with existing specifier 'null_unspecified'}} @property(nullable,retain,nullable) NSFoo *redundantProperty3; // expected-warning{{duplicate nullability specifier 'nullable'}} @@ -53,8 +53,8 @@ __attribute__((objc_root_class)) @property(nonnull,retain) NSFoo *property2; @property(nullable,assign) NSFoo ** invalidProperty2; // expected-error{{nullability keyword 'nullable' cannot be applied to multi-level pointer type 'NSFoo **'}} // expected-note@-1{{use nullability type specifier '_Nullable' to affect the innermost pointer type of 'NSFoo **'}} -@property(null_unspecified,retain) NSFoo * _Nullable conflictingProperty2; // expected-error{{nullability specifier '_Nullable' conflicts with existing specifier '_Null_unspecified'}} -@property(retain,nonnull) NSFoo * _Nonnull redundantProperty2; // expected-warning{{duplicate nullability specifier '_Nonnull'}} +@property(null_unspecified,retain) NSFoo * _Nullable conflictingProperty2; // expected-error{{nullability specifier 'null_unspecified' conflicts with existing specifier '_Nullable'}} +@property(retain,nonnull) NSFoo * _Nonnull redundantProperty2; // expected-warning{{duplicate nullability specifier 'nonnull'}} @end void test_accepts_nonnull_null_pointer_literal(NSFoo *foo, _Nonnull NSBar *bar) { @@ -157,7 +157,7 @@ __attribute__((objc_root_class)) - (nullable instancetype)returnMe; + (nullable instancetype)returnInstanceOfMe; -- (nonnull instancetype _Nullable)initWithBlah2:(nonnull id)blah; // expected-error {{nullability specifier '_Nullable' conflicts with existing specifier '_Nonnull'}} +- (nonnull instancetype _Nullable)initWithBlah2:(nonnull id)blah; // expected-error {{nullability specifier 'nonnull' conflicts with existing specifier '_Nullable'}} - (instancetype _Nullable)returnMe2; + (_Nonnull instancetype)returnInstanceOfMe2; @end diff --git a/test/SemaOpenCL/address-spaces.cl b/test/SemaOpenCL/address-spaces.cl index 52c891e16b..3ac2569bc2 100644 --- a/test/SemaOpenCL/address-spaces.cl +++ b/test/SemaOpenCL/address-spaces.cl @@ -61,8 +61,8 @@ __generic int func_return_generic(void); //expected-error {{return value cann void func_multiple_addr(void) { typedef __private int private_int_t; - __local __private int var1; // expected-error {{multiple address spaces specified for type}} - __local __private int *var2; // expected-error {{multiple address spaces specified for type}} + __private __local int var1; // expected-error {{multiple address spaces specified for type}} + __private __local int *var2; // expected-error {{multiple address spaces specified for type}} __local private_int_t var3; // expected-error {{multiple address spaces specified for type}} __local private_int_t *var4; // expected-error {{multiple address spaces specified for type}} __private private_int_t var5; // expected-warning {{multiple identical address spaces specified for type}} diff --git a/test/SemaTemplate/attributes.cpp b/test/SemaTemplate/attributes.cpp index 7634b937c9..7a04c4705b 100644 --- a/test/SemaTemplate/attributes.cpp +++ b/test/SemaTemplate/attributes.cpp @@ -55,11 +55,11 @@ namespace PR9049 { } // CHECK: FunctionTemplateDecl {{.*}} HasAnnotations -// CHECK: AnnotateAttr {{.*}} "ANNOTATE_BAR" // CHECK: AnnotateAttr {{.*}} "ANNOTATE_FOO" +// CHECK: AnnotateAttr {{.*}} "ANNOTATE_BAR" // CHECK: FunctionDecl {{.*}} HasAnnotations // CHECK: TemplateArgument type 'int' -// CHECK: AnnotateAttr {{.*}} "ANNOTATE_BAR" // CHECK: AnnotateAttr {{.*}} "ANNOTATE_FOO" +// CHECK: AnnotateAttr {{.*}} "ANNOTATE_BAR" template [[clang::annotate("ANNOTATE_FOO"), clang::annotate("ANNOTATE_BAR")]] void HasAnnotations(); void UseAnnotations() { HasAnnotations(); }