On Tue, Aug 18, 2015 at 12:20 PM, Li, Charles via cfe-commits < cfe-commits@lists.llvm.org> wrote:
> Hi Justin and Richard, > > >> +// RUN: %clang_cc1 -E -C -P -triple x86_64-apple-darwin10 %s > %t1.c > >> +// RUN: %clang_cc1 -fsyntax-only -verify -triple > >> +x86_64-apple-darwin10 %t1.c > > > I think you forgot to switch this one to stop preprocessing first. > > Thank you for catching this. I have removed it for this patch. > > > > +#if (!defined(__cplusplus)) || (__cplusplus <= 199711L) // C or C++03 > or earlier modes > > You can simplify that to: > > #if __cplusplus <= 199711L > > Otherwise, this LGTM. > > Thank you, I have made the simplifications > > > > __cplusplus will expand to 0 inside a #if in C (as will any un#defined > identifier). > > As an aside, I did a "-E -dM" and __cplusplus is not in the macro dump. > Likewise, having __cplusplus stand alone inside a t.c file will not cause > preprocessor to replace it with 0. > It appears the macro replacement of __cplusplus is context sensitive. > This happens for any identifier used in the condition of a #if that is not #defined; this is a standard feature of the C preprocessor. > Cheers, > Charles > > -----Original Message----- > From: Justin Bogner [mailto:jus...@justinbogner.com] On Behalf Of Justin > Bogner > Sent: Monday, August 17, 2015 9:28 PM > To: Li, Charles > Cc: Richard Smith; cfe-commits@lists.llvm.org > Subject: Re: Second Lit tests C++11 compatibility patch: using > preprocessor to filter expected-error > > "Li, Charles" <charles...@playstation.sony.com> writes: > > Hi Richard, > > > > I have modified the “expected-“ lines as you requested. > > > > Cheers, > > > > Charles > > > > From: meta...@gmail.com [mailto:meta...@gmail.com] On Behalf Of > > Richard Smith > > Sent: Monday, August 17, 2015 5:41 PM > > To: Li, Charles > > Cc: Justin Bogner; cfe-commits@lists.llvm.org > > Subject: Re: Second Lit tests C++11 compatibility patch: using > > preprocessor to filter expected-error > > > > On Mon, Aug 17, 2015 at 5:15 PM, Li, Charles via cfe-commits < > > cfe-commits@lists.llvm.org> wrote: > > > > Hi Richard and Justin, > > > >> What's the upside to this approach? AFAICT it makes the test harder > >> to read > > and errors less informative due to pointing at the wrong lines, but > > (at least in switch-1.c) it doesn't actually reduce any code > > duplication or anything like that. What is this gaining us apart from > > not having to create one more file? > > > > Thank you Justin. > > > > Our original intention was to get the Lit tests to run at any default > > C++ dialect. > > > > We first discovered that FileCheck does not respect #ifdef since it > > does not know about pre-defined macros. > > > > So we figured if we preprocess the source first, the preprocessor will > > filter the #ifdef sections and the output will feed nicely into > FileCheck. > > > > The upside is the test can run at the default dialect in addition to > > explicitly specified dialect. > > > > The downside is, as you mentioned, the errors diagnostics would point > > to the wrong lines. > > > >> The only thing novel about this approach is using the preprocessor to > > achieve it. -verify *does* respect #ifdef, and we have a lot of tests > > that rely on that. > > > > Thank you Richard. > > > > We erroneously assumed that “// CHECK:” and “// expected-error” work > > the same way. > > > > But now we realized that assumption was wrong. > > > > In light this discussion, I have removed the preprocessing to > > temporary step for all tests. > > > > The attached patch (Lit_24.patch) revised 2 test fixes relative to the > > previous patch (Lit_22.patch) > > > > test/Analysis/temp-obj-dtors-cfg-output.cpp > > > > This test uses FileCheck to check for CFG dump. > > > > Instead of using #ifdef for the dialect specific “// CHECK:” > > lines, > > > > I have created 2 check-prefixes “CXX11” and “CXX98”. > > > > The pre-process step have been removed. > > > > test/Sema/switch-1.c > > > > This test uses –verify to check for integer overflows diagnostics. > > > > The pre-process step have been removed. > > > > The #ifdef is kept since it works with -verify. > > > > Instead of duplicating the code, you can do this: > > > > case blah: > > > > #if __cplusplus >= 201103L > > > > // expected-error@-2 {{error 2 lines above}} > > > > #else > > > > // expected-error@-4 {{error 4 lines above}} > > > > #endif > > > > Please let me know how you feel about this patch. > > > > Sincerely, > > > > Charles > > > > From: meta...@gmail.com [mailto:meta...@gmail.com] On Behalf Of > Richard > > Smith > > Sent: Monday, August 17, 2015 1:07 PM > > To: Li, Charles > > Cc: cfe-commits@lists.llvm.org > > Subject: Re: Second Lit tests C++11 compatibility patch: using > > preprocessor to filter expected-error > > > > On Mon, Aug 17, 2015 at 9:56 AM, Li, Charles via cfe-commits < > > cfe-commits@lists.llvm.org> wrote: > > > > Hi Clang developers, > > > > We here at Sony are continuing to update the Lit tests for C++ > dialects > > compatibility. > > > > Attached is the second patch. (As a reference, here is the link to > the > > discussion on the previous Lit patch. > http://lists.cs.uiuc.edu/pipermail/ > > cfe-commits/Week-of-Mon-20150727/134667.html) > > > > In this second patch, there is 1 complicated change and 3 simple > changes. > > > > Here is the complicated change first. > > > > test/Sema/switch-1.c > > > > This test verifies the diagnostics for integer overflows. > > > > Due to C++11’s more strict requirements on constant-expressions in > > 5.19p2 [expr.const], > > > > The diagnostics have changed from “overflow in expression” to “not > a > > constant expression”. > > > > Usually we would create a C++11 version of the switch-1.c file. > > > > But here we propose a novel approach to “#ifdef” the expected > > diagnostics. (We hope to use this approach for all similar cases in > the > > future.) > > > > Normally ‘// expected-error’ does not honor any ‘#ifdef’. > > > > But if we first preprocess the source into a temporary file, only > the > > valid ‘#ifdef’ sections remain. > > > > We then run the preprocessed file at the desired dialect. > > > > The main downside to this approach is If the test fails, the > errors are > > reported on the temporary file, not on the original file, and the > line > > numbers of these two files do not match > > > > The only thing novel about this approach is using the preprocessor to > > achieve it. -verify *does* respect #ifdef, and we have a lot of > tests that > > rely on that. > > > > Here are the simple changes. > > > > test/Analysis/temp-obj-dtors-cfg-output.cpp > > > > This test verifies CFG dump for temporary destructors > > > > C++11 no longer has the following implicit cast. > > > > (ImplicitCastExpr, NoOp, const struct D) > > > > We modified the test using the #ifdef approach to have the > > preprocessor generate the desired CHECK lines. > > > > test/CodeCompletion/ordinary-name.cpp > > > > This test verifies for code completion patterns. > > > > Since C++11 has more keywords than C++98, > > > > We made this test to be C++98 specific, and create a separate > C++11 > > version. > > > > test/CodeCompletion/ordinary-name-cxx11.cpp > > > > This is the C++11 specific version of the code completion. > > > > This test added patterns for the following keywords: > > > > char16, char32, noexcept, nullptr, sizeof..., > > > > auto, decltype, char16_t, char32_t > > > > test/Sema/thread-specifier.c > > > > Tests for __thread specifier at various C++ dialects > > > > We made the default RUN line explicit to be at –std=c++98 > > > > If there is anything that seems confusing to you, please let me > know. > > > > I would be more than happy to expand on the reasons for the these > > changes. > > > > Thanks, > > > > Charles > > > > _______________________________________________ > > cfe-commits mailing list > > cfe-commits@lists.llvm.org > > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits > > > > _______________________________________________ > > cfe-commits mailing list > > cfe-commits@lists.llvm.org > > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits > > > > diff --git test/Analysis/temp-obj-dtors-cfg-output.cpp > > test/Analysis/temp-obj-dtors-cfg-output.cpp > > index 491c68e..dc10e87 100644 > > --- test/Analysis/temp-obj-dtors-cfg-output.cpp > > +++ test/Analysis/temp-obj-dtors-cfg-output.cpp > > @@ -1,6 +1,8 @@ > > // RUN: rm -f %t > > -// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG > > -analyzer-config cfg-temporary-dtors=true %s > %t 2>&1 -// RUN: > > FileCheck --input-file=%t %s > > +// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG > > +-analyzer-config cfg-temporary-dtors=true -std=c++98 %s > %t 2>&1 // > > +RUN: FileCheck --input-file=%t -check-prefix=CXX98 > > +-check-prefix=CHECK %s // RUN: %clang_cc1 -analyze > > +-analyzer-checker=debug.DumpCFG -analyzer-config > > +cfg-temporary-dtors=true -std=c++11 %s > %t 2>&1 // RUN: FileCheck > > +--input-file=%t -check-prefix=CXX11 -check-prefix=CHECK %s > > > > class A { > > public: > > @@ -671,15 +673,23 @@ int testConsistencyNestedNormalReturn(bool value) { > > // CHECK: Succs (1): B0 > > // CHECK: [B3] > > // CHECK: 1: D() (CXXConstructExpr, struct D) > > -// CHECK: 2: [B3.1] (ImplicitCastExpr, NoOp, const struct D) > > -// CHECK: 3: [B3.2] > > -// CHECK: 4: [B3.3] (CXXConstructExpr, struct D) > > -// CHECK: 5: D d = D(); > > -// CHECK: 6: d > > -// CHECK: 7: [B3.6].operator bool > > -// CHECK: 8: [B3.6] > > -// CHECK: 9: [B3.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) > > -// CHECK: T: if [B3.9] > > +// CXX98: 2: [B3.1] (ImplicitCastExpr, NoOp, const struct D) > > +// CXX98: 3: [B3.2] > > +// CXX98: 4: [B3.3] (CXXConstructExpr, struct D) > > +// CXX98: 5: D d = D(); > > +// CXX98: 6: d > > +// CXX98: 7: [B3.6].operator bool > > +// CXX98: 8: [B3.6] > > +// CXX98: 9: [B3.8] (ImplicitCastExpr, UserDefinedConversion, _Bool) > > +// CXX98: T: if [B3.9] > > +// CXX11: 2: [B3.1] > > +// CXX11: 3: [B3.2] (CXXConstructExpr, struct D) > > +// CXX11: 4: D d = D(); > > +// CXX11: 5: d > > +// CXX11: 6: [B3.5].operator bool > > +// CXX11: 7: [B3.5] > > +// CXX11: 8: [B3.7] (ImplicitCastExpr, UserDefinedConversion, _Bool) > > +// CXX11: T: if [B3.8] > > // CHECK: Preds (1): B4 > > // CHECK: Succs (2): B2 B1 > > // CHECK: [B0 (EXIT)] > > diff --git test/CodeCompletion/ordinary-name.cpp > > test/CodeCompletion/ordinary-name.cpp > > index d0b09b5..03dbbca 100644 > > --- test/CodeCompletion/ordinary-name.cpp > > +++ test/CodeCompletion/ordinary-name.cpp > > @@ -4,7 +4,7 @@ typedef struct t TYPEDEF; > > > > void foo() { > > int y = 17; > > - // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions > > -code-completion-patterns -code-completion-at=%s:6:14 %s -o - | > > FileCheck -check-prefix=CHECK-CC1 %s > > + // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions > > + -code-completion-patterns -code-completion-at=%s:6:14 -std=gnu++98 > > + %s -o - | FileCheck -check-prefix=CHECK-CC1 %s > > // CHECK-CC1: COMPLETION: bool > > // CHECK-CC1-NEXT: COMPLETION: char > > // CHECK-CC1-NEXT: COMPLETION: class @@ -58,7 +58,7 @@ void foo() { > > // CHECK-CC1-NEXT: COMPLETION: y : [#int#]y > > // CHECK-CC1-NEXT: COMPLETION: z : [#void#]z(<#int#>) > > > > - // RUN: %clang_cc1 -fsyntax-only -code-completion-patterns > > -code-completion-at=%s:4:1 %s -o - | FileCheck -check-prefix=CHECK-CC2 > > %s > > + // RUN: %clang_cc1 -fsyntax-only -code-completion-patterns > > + -code-completion-at=%s:4:1 -std=gnu++98 %s -o - | FileCheck > > + -check-prefix=CHECK-CC2 %s > > // CHECK-CC2: COMPLETION: Pattern : asm(<#string-literal#>) > > // CHECK-CC2-NEXT: COMPLETION: bool > > // CHECK-CC2-NEXT: COMPLETION: char @@ -95,7 +95,7 @@ void foo() { > > // CHECK-CC2-NEXT: COMPLETION: wchar_t > > // CHECK-CC2-NEXT: COMPLETION: X : X > > > > - // RUN: %clang_cc1 -fsyntax-only -code-completion-patterns > > -code-completion-at=%s:1:19 %s -o - | FileCheck > > -check-prefix=CHECK-CC3 %s > > + // RUN: %clang_cc1 -fsyntax-only -code-completion-patterns > > + -code-completion-at=%s:1:19 -std=gnu++98 %s -o - | FileCheck > > + -check-prefix=CHECK-CC3 %s > > // CHECK-CC3: COMPLETION: bool > > // CHECK-CC3-NEXT: COMPLETION: char > > // CHECK-CC3-NEXT: COMPLETION: class @@ -132,7 +132,7 @@ void foo() > > { > > // CHECK-CC3-NEXT: COMPLETION: wchar_t > > // CHECK-CC3-NEXT: COMPLETION: X : X > > > > - // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions > > -code-completion-patterns -code-completion-at=%s:6:11 %s -o - | > > FileCheck -check-prefix=CHECK-CC4 %s > > + // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions > > + -code-completion-patterns -code-completion-at=%s:6:11 -std=gnu++98 > > + %s -o - | FileCheck -check-prefix=CHECK-CC4 %s > > // CHECK-CC4: COMPLETION: bool > > // CHECK-CC4-NEXT: COMPLETION: char > > // CHECK-CC4-NEXT: COMPLETION: class @@ -174,7 +174,7 @@ void foo() > > { > > // CHECK-CC4-NEXT: COMPLETION: y : [#int#]y > > // CHECK-CC4-NEXT: COMPLETION: z : [#void#]z(<#int#>) > > > > - // RUN: %clang_cc1 -fsyntax-only -fno-rtti > > -code-completion-patterns -code-completion-at=%s:6:14 %s -o - | > > FileCheck -check-prefix=CHECK-NO-RTTI %s > > + // RUN: %clang_cc1 -fsyntax-only -fno-rtti > > + -code-completion-patterns -code-completion-at=%s:6:14 -std=gnu++98 > > + %s -o - | FileCheck -check-prefix=CHECK-NO-RTTI %s > > // CHECK-NO-RTTI: COMPLETION: bool > > // CHECK-NO-RTTI-NEXT: COMPLETION: char > > // CHECK-NO-RTTI-NEXT: COMPLETION: class diff --git > > test/Sema/switch-1.c test/Sema/switch-1.c index 5191c92..ae1bd9c > > 100644 > > --- test/Sema/switch-1.c > > +++ test/Sema/switch-1.c > > @@ -1,18 +1,51 @@ > > -// RUN: %clang_cc1 -fsyntax-only -verify -triple > > x86_64-apple-darwin10 %s > > +// RUN: %clang_cc1 -E -C -P -triple x86_64-apple-darwin10 %s > %t1.c > > +// RUN: %clang_cc1 -fsyntax-only -verify -triple > > +x86_64-apple-darwin10 %t1.c > > I think you forgot to switch this one to stop preprocessing first. > > > // RUN: %clang_cc1 -x c++ -fsyntax-only -verify -triple > > x86_64-apple-darwin10 %s > > +// RUN: %clang_cc1 -x c++ -fsyntax-only -verify -triple > > +x86_64-apple-darwin10 -std=c++98 %s // RUN: %clang_cc1 -x c++ > > +-fsyntax-only -verify -triple x86_64-apple-darwin10 -std=c++11 %s > > // rdar://11577384 > > // rdar://13423975 > > > > int f(int i) { > > switch (i) { > > - case 2147483647 + 2: // expected-warning {{overflow in expression; > result is -2147483647 with type 'int'}} > > + case 2147483647 + 2: > > +#if (!defined(__cplusplus)) || (__cplusplus <= 199711L) // C or C++03 > or earlier modes > > + // expected-warning@-2 {{overflow in expression; result is > > +-2147483647 with type 'int'}} #else > > + // expected-error@-4 {{case value is not a constant expression}} \ > > + // expected-note@-4 {{value 2147483649 is outside the range of > > +representable values of type 'int'}} #endif > > return 1; > > - case 9223372036854775807L * 4: // expected-warning {{overflow in > expression; result is -4 with type 'long'}} > > + case 9223372036854775807L * 4: > > +#if (!defined(__cplusplus)) || (__cplusplus <= 199711L) > > + // expected-warning@-2 {{overflow in expression; result is -4 > > +with type 'long'}} #else > > + // expected-error@-4 {{case value is not a constant expression}} \ > > + // expected-note@-4 {{value 36893488147419103228 is outside the > > +range of representable values of type 'long'}} #endif > > return 2; > > - case (123456 *789012) + 1: // expected-warning {{overflow in > expression; result is -1375982336 with type 'int'}} > > + case (123456 *789012) + 1: > > +#if (!defined(__cplusplus)) || (__cplusplus <= 199711L) > > + // expected-warning@-2 {{overflow in expression; result is > > +-1375982336 with type 'int'}} #else > > + // expected-error@-4 {{case value is not a constant expression}} \ > > + // expected-note@-4 {{value 97408265472 is outside the range of > > +representable values of type 'int'}} #endif > > return 3; > > - case (2147483647*4)/4: // expected-warning {{overflow in > expression; result is -4 with type 'int'}} > > - case (2147483647*4)%4: // expected-warning {{overflow in > expression; result is -4 with type 'int'}} > > + case (2147483647*4)/4: > > +#if (!defined(__cplusplus)) || (__cplusplus <= 199711L) > > + // expected-warning@-2 {{overflow in expression; result is -4 > > +with type 'int'}} #else > > + // expected-error@-4 {{case value is not a constant expression}} \ > > + // expected-note@-4 {{value 8589934588 is outside the range of > > +representable values of type 'int'}} #endif > > + case (2147483647*4)%4: > > +#if (!defined(__cplusplus)) || (__cplusplus <= 199711L) > > + // expected-warning@-2 {{overflow in expression; result is -4 > > +with type 'int'}} #else > > + // expected-error@-4 {{case value is not a constant expression}} \ > > + // expected-note@-4 {{value 8589934588 is outside the range of > > +representable values of type 'int'}} #endif > > return 4; > > case 2147483647: > > return 0; > > diff --git test/Sema/thread-specifier.c test/Sema/thread-specifier.c > > index 3968ae1..a93850d 100644 > > --- test/Sema/thread-specifier.c > > +++ test/Sema/thread-specifier.c > > @@ -1,7 +1,7 @@ > > // RUN: %clang_cc1 -triple i686-pc-linux-gnu -fsyntax-only > > -Wno-private-extern -verify -pedantic %s -DGNU -// RUN: %clang_cc1 > > -triple i686-pc-linux-gnu -fsyntax-only -Wno-private-extern -verify > > -pedantic -x c++ %s -DGNU > > +// RUN: %clang_cc1 -triple i686-pc-linux-gnu -fsyntax-only > > +-Wno-private-extern -verify -pedantic -x c++ %s -DGNU -std=c++98 > > // RUN: %clang_cc1 -triple i686-pc-linux-gnu -fsyntax-only > > -Wno-private-extern -verify -pedantic %s -DC11 > > -D__thread=_Thread_local -// RUN: %clang_cc1 -triple i686-pc-linux-gnu > > -fsyntax-only -Wno-private-extern -verify -pedantic -x c++ %s -DC11 > > -D__thread=_Thread_local > > +// RUN: %clang_cc1 -triple i686-pc-linux-gnu -fsyntax-only > > +-Wno-private-extern -verify -pedantic -x c++ %s -DC11 > > +-D__thread=_Thread_local -std=c++98 > > // RUN: %clang_cc1 -triple i686-pc-linux-gnu -fsyntax-only > > -Wno-private-extern -verify -pedantic -x c++ %s -DCXX11 > > -D__thread=thread_local -std=c++11 -Wno-deprecated // RUN: %clang_cc1 > > -triple i686-pc-linux-gnu -fsyntax-only -Wno-private-extern -verify > > -pedantic -x c++ %s -DC11 -D__thread=_Thread_local -std=c++11 > > -Wno-deprecated > > > > diff --git test/CodeCompletion/ordinary-name-cxx11.cpp > > test/CodeCompletion/ordinary-name-cxx11.cpp > > new file mode 100644 > > index 0000000..8e6f383 > > --- /dev/null > > +++ test/CodeCompletion/ordinary-name-cxx11.cpp > > @@ -0,0 +1,252 @@ > > +struct X { int x; }; > > +void z(int); > > +typedef struct t TYPEDEF; > > + > > +void foo() { > > + int y = 17; > > + // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions > > +-code-completion-patterns -code-completion-at=%s:6:14 -std=gnu++11 %s > > +-o - | FileCheck -check-prefix=CHECK-CC1 %s > > + // CHECK-CC1: COMPLETION: bool > > + // CHECK-CC1-NEXT: COMPLETION: char > > + // CHECK-CC1-NEXT: COMPLETION: char16 > > + // CHECK-CC1-NEXT: COMPLETION: char32 > > + // CHECK-CC1-NEXT: COMPLETION: class > > + // CHECK-CC1-NEXT: COMPLETION: const > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +const_cast<<#type#>>(<#expression#>) > > + // CHECK-CC1: COMPLETION: Pattern : [#void#]delete <#expression#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : [#void#]delete [] > > +<#expression#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : do{<#statements#> > > + // CHECK-CC1: COMPLETION: double > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +dynamic_cast<<#type#>>(<#expression#>) > > + // CHECK-CC1-NEXT: COMPLETION: enum > > + // CHECK-CC1-NEXT: COMPLETION: extern > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : [#bool#]false > > + // CHECK-CC1-NEXT: COMPLETION: float > > + // CHECK-CC1-NEXT: COMPLETION: foo : [#void#]foo() > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +for(<#init-statement#>;<#condition#>;<#inc-expression#>){ > > + // CHECK-CC1: COMPLETION: Pattern : goto <#label#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +if(<#condition#>){<#statements#> > > + // CHECK-CC1: COMPLETION: int > > + // CHECK-CC1-NEXT: COMPLETION: long > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : new > > +<#type#>(<#expressions#>) > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : new > > +<#type#>[<#size#>](<#expressions#>) > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +[#bool#]noexcept(<#expression#>) > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : [#std::nullptr_t#]nullptr > > + // CHECK-CC1-NEXT: COMPLETION: operator > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +reinterpret_cast<<#type#>>(<#expression#>) > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : return > > + // CHECK-CC1-NEXT: COMPLETION: short > > + // CHECK-CC1-NEXT: COMPLETION: signed > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +[#size_t#]sizeof(<#expression-or-type#>) > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +[#size_t#]sizeof...(<#parameter-pack#>) > > + // CHECK-CC1-NEXT: COMPLETION: static > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +static_cast<<#type#>>(<#expression#>) > > + // CHECK-CC1-NEXT: COMPLETION: struct > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : switch(<#condition#>){ > > + // CHECK-CC1: COMPLETION: t : t > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : [#void#]throw > > +<#expression#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : [#bool#]true > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : try{<#statements#> > > + // CHECK-CC1: COMPLETION: TYPEDEF : TYPEDEF > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : typedef <#type#> <#name#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +[#std::type_info#]typeid(<#expression-or-type#>) > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : typename > > +<#qualifier#>::<#name#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : typeof <#expression#> > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : typeof(<#type#>) > > + // CHECK-CC1-NEXT: COMPLETION: union > > + // CHECK-CC1-NEXT: COMPLETION: unsigned > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : using namespace > > +<#identifier#> > > + // CHECK-CC1-NEXT: COMPLETION: void > > + // CHECK-CC1-NEXT: COMPLETION: volatile > > + // CHECK-CC1-NEXT: COMPLETION: wchar_t > > + // CHECK-CC1-NEXT: COMPLETION: Pattern : > > +while(<#condition#>){<#statements#> > > + // CHECK-CC1: COMPLETION: X : X > > + // CHECK-CC1-NEXT: COMPLETION: y : [#int#]y > > + // CHECK-CC1-NEXT: COMPLETION: z : [#void#]z(<#int#>) > > + > > + // RUN: %clang_cc1 -fsyntax-only -code-completion-patterns > > + -code-completion-at=%s:4:1 -std=gnu++11 %s -o - | FileCheck > > + -check-prefix=CHECK-CC2 %s // CHECK-CC2: COMPLETION: Pattern : > > + asm(<#string-literal#>) // CHECK-CC2: COMPLETION: auto // > > + CHECK-CC2-NEXT: COMPLETION: bool // CHECK-CC2-NEXT: COMPLETION: > > + char // CHECK-CC2-NEXT: COMPLETION: char16 // CHECK-CC2-NEXT: > > + COMPLETION: char32 // CHECK-CC2-NEXT: COMPLETION: class // > > + CHECK-CC2-NEXT: COMPLETION: const // CHECK-CC2-NEXT: COMPLETION: > > + Pattern : decltype(<#expression#>) // CHECK-CC2-NEXT: COMPLETION: > > + double // CHECK-CC2-NEXT: COMPLETION: enum // CHECK-CC2-NEXT: > > + COMPLETION: extern // CHECK-CC2-NEXT: COMPLETION: float // > > + CHECK-CC2-NEXT: COMPLETION: inline // CHECK-CC2-NEXT: COMPLETION: > > + int // CHECK-CC2-NEXT: COMPLETION: long // CHECK-CC2-NEXT: > > + COMPLETION: Pattern : namespace <#identifier#>{<#declarations#> // > > + CHECK-CC2: COMPLETION: Pattern : namespace <#name#> = <#namespace#> > > + // CHECK-CC2-NEXT: COMPLETION: operator // CHECK-CC2-NEXT: > > + COMPLETION: short // CHECK-CC2-NEXT: COMPLETION: signed // > > + CHECK-CC2-NEXT: COMPLETION: static // CHECK-CC2-NEXT: COMPLETION: > > + struct // CHECK-CC2-NEXT: COMPLETION: t : t // CHECK-CC2-NEXT: > > + COMPLETION: Pattern : template <#declaration#> // CHECK-CC2-NEXT: > > + COMPLETION: Pattern : template<<#parameters#>> // CHECK-CC2-NEXT: > > + COMPLETION: TYPEDEF : TYPEDEF // CHECK-CC2-NEXT: COMPLETION: > > + Pattern : typedef <#type#> <#name#> // CHECK-CC2-NEXT: COMPLETION: > > + Pattern : typename <#qualifier#>::<#name#> // CHECK-CC2-NEXT: > > + COMPLETION: Pattern : typeof <#expression#> // CHECK-CC2-NEXT: > > + COMPLETION: Pattern : typeof(<#type#>) // CHECK-CC2-NEXT: > > + COMPLETION: union // CHECK-CC2-NEXT: COMPLETION: unsigned // > > + CHECK-CC2-NEXT: COMPLETION: Pattern : using namespace <#identifier#> > > + // CHECK-CC2-NEXT: COMPLETION: Pattern : using > > + <#qualifier#>::<#name#> // CHECK-CC2-NEXT: COMPLETION: void // > > + CHECK-CC2-NEXT: COMPLETION: volatile // CHECK-CC2-NEXT: COMPLETION: > > + wchar_t // CHECK-CC2-NEXT: COMPLETION: X : X > > + > > + // RUN: %clang_cc1 -fsyntax-only -code-completion-patterns > > + -code-completion-at=%s:1:19 -std=gnu++11 %s -o - | FileCheck > > + -check-prefix=CHECK-CC3 %s // CHECK-CC3: COMPLETION: bool // > > + CHECK-CC3-NEXT: COMPLETION: char // CHECK-CC3-NEXT: COMPLETION: > > + char16_t // CHECK-CC3-NEXT: COMPLETION: char32_t // > > + CHECK-CC3-NEXT: COMPLETION: class // CHECK-CC3-NEXT: COMPLETION: > > + const // CHECK-CC3-NEXT: COMPLETION: Pattern : > > + decltype(<#expression#>) // CHECK-CC3-NEXT: COMPLETION: double // > > + CHECK-CC3-NEXT: COMPLETION: enum // CHECK-CC3-NEXT: COMPLETION: > > + explicit // CHECK-CC3-NEXT: COMPLETION: extern // CHECK-CC3-NEXT: > > + COMPLETION: float // CHECK-CC3-NEXT: COMPLETION: friend // > > + CHECK-CC3-NEXT: COMPLETION: inline // CHECK-CC3-NEXT: COMPLETION: > > + int // CHECK-CC3-NEXT: COMPLETION: long // CHECK-CC3-NEXT: > > + COMPLETION: mutable // CHECK-CC3-NEXT: COMPLETION: operator // > > + CHECK-CC3-NEXT: COMPLETION: Pattern : private: > > + // CHECK-CC3-NEXT: COMPLETION: Pattern : protected: > > + // CHECK-CC3-NEXT: COMPLETION: Pattern : public: > > + // CHECK-CC3-NEXT: COMPLETION: short // CHECK-CC3-NEXT: > > + COMPLETION: signed // CHECK-CC3-NEXT: COMPLETION: static // > > + CHECK-CC3-NEXT: COMPLETION: struct // CHECK-CC3-NEXT: COMPLETION: > > + Pattern : template<<#parameters#>> // CHECK-CC3-NEXT: COMPLETION: > > + Pattern : typedef <#type#> <#name#> // CHECK-CC3-NEXT: COMPLETION: > > + Pattern : typename <#qualifier#>::<#name#> // CHECK-CC3-NEXT: > > + COMPLETION: Pattern : typeof <#expression#> // CHECK-CC3-NEXT: > > + COMPLETION: Pattern : typeof(<#type#>) // CHECK-CC3-NEXT: > > + COMPLETION: union // CHECK-CC3-NEXT: COMPLETION: unsigned // > > + CHECK-CC3-NEXT: COMPLETION: Pattern : using <#qualifier#>::<#name#> > > + // CHECK-CC3-NEXT: COMPLETION: virtual // CHECK-CC3-NEXT: > > + COMPLETION: void // CHECK-CC3-NEXT: COMPLETION: volatile // > > + CHECK-CC3-NEXT: COMPLETION: wchar_t // CHECK-CC3-NEXT: COMPLETION: > > + X : X > > + > > + // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions > > + -code-completion-patterns -code-completion-at=%s:6:11 -std=gnu++11 > > + %s -o - | FileCheck -check-prefix=CHECK-CC4 %s // CHECK-CC4: > > + COMPLETION: bool // CHECK-CC4-NEXT: COMPLETION: char // > > + CHECK-CC4-NEXT: COMPLETION: char16_t // CHECK-CC4-NEXT: COMPLETION: > > + char32_t // CHECK-CC4-NEXT: COMPLETION: class // CHECK-CC4-NEXT: > > + COMPLETION: const // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + const_cast<<#type#>>(<#expression#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : decltype(<#expression#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : [#void#]delete > > + <#expression#> // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + [#void#]delete [] <#expression#> // CHECK-CC4-NEXT: COMPLETION: > > + double // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + dynamic_cast<<#type#>>(<#expression#>) > > + // CHECK-CC4-NEXT: COMPLETION: enum // CHECK-CC4-NEXT: COMPLETION: > > + Pattern : [#bool#]false // CHECK-CC4-NEXT: COMPLETION: float // > > + CHECK-CC4-NEXT: COMPLETION: foo : [#void#]foo() // CHECK-CC4-NEXT: > > + COMPLETION: int // CHECK-CC4-NEXT: COMPLETION: long // > > + CHECK-CC4-NEXT: COMPLETION: Pattern : new <#type#>(<#expressions#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : new > > + <#type#>[<#size#>](<#expressions#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + [#bool#]noexcept(<#expression#>) // CHECK-CC4-NEXT: COMPLETION: > > + Pattern : [#std::nullptr_t#]nullptr // CHECK-CC4-NEXT: COMPLETION: > > + operator // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + reinterpret_cast<<#type#>>(<#expression#>) > > + // CHECK-CC4-NEXT: COMPLETION: short // CHECK-CC4-NEXT: > > + COMPLETION: signed // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + [#size_t#]sizeof(<#expression-or-type#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + [#size_t#]sizeof...(<#parameter-pack#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + static_cast<<#type#>>(<#expression#>) > > + // CHECK-CC4-NEXT: COMPLETION: struct // CHECK-CC4-NEXT: > > + COMPLETION: t : t // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + [#void#]throw <#expression#> // CHECK-CC4-NEXT: COMPLETION: Pattern > > + : [#bool#]true // CHECK-CC4-NEXT: COMPLETION: TYPEDEF : TYPEDEF // > > + CHECK-CC4-NEXT: COMPLETION: Pattern : > > + [#std::type_info#]typeid(<#expression-or-type#>) > > + // CHECK-CC4-NEXT: COMPLETION: Pattern : typename > > + <#qualifier#>::<#name#> // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + typeof <#expression#> // CHECK-CC4-NEXT: COMPLETION: Pattern : > > + typeof(<#type#>) // CHECK-CC4-NEXT: COMPLETION: union // > > + CHECK-CC4-NEXT: COMPLETION: unsigned // CHECK-CC4-NEXT: COMPLETION: > > + void // CHECK-CC4-NEXT: COMPLETION: volatile // CHECK-CC4-NEXT: > > + COMPLETION: wchar_t // CHECK-CC4-NEXT: COMPLETION: X : X // > > + CHECK-CC4-NEXT: COMPLETION: y : [#int#]y // CHECK-CC4-NEXT: > > + COMPLETION: z : [#void#]z(<#int#>) > > + > > + // RUN: %clang_cc1 -fsyntax-only -fno-rtti > > + -code-completion-patterns -code-completion-at=%s:6:14 -std=gnu++11 > > + %s -o - | FileCheck -check-prefix=CHECK-NO-RTTI %s // > > + CHECK-NO-RTTI: COMPLETION: bool // CHECK-NO-RTTI-NEXT: COMPLETION: > > + char // CHECK-NO-RTTI-NEXT: COMPLETION: char16_t // > > + CHECK-NO-RTTI-NEXT: COMPLETION: char32_t // CHECK-NO-RTTI-NEXT: > > + COMPLETION: class // CHECK-NO-RTTI-NEXT: COMPLETION: const // > > + CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + const_cast<<#type#>>(<#expression#>) > > + // CHECK-NO-RTTI: COMPLETION: Pattern : [#void#]delete > > + <#expression#> // CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + [#void#]delete [] <#expression#> // CHECK-NO-RTTI-NEXT: COMPLETION: > > + Pattern : do{<#statements#> // CHECK-NO-RTTI: COMPLETION: double > > + // CHECK-NO-RTTI-NOT: dynamic_cast // CHECK-NO-RTTI: COMPLETION: > > + enum // CHECK-NO-RTTI-NEXT: COMPLETION: extern // > > + CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : [#bool#]false // > > + CHECK-NO-RTTI-NEXT: COMPLETION: float // CHECK-NO-RTTI-NEXT: > > + COMPLETION: foo : [#void#]foo() // CHECK-NO-RTTI-NEXT: COMPLETION: > > + Pattern : for(<#init-statement#>;<#condition#>;<#inc-expression#>){ > > + // CHECK-NO-RTTI: COMPLETION: Pattern : goto <#label#> // > > + CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + if(<#condition#>){<#statements#> // CHECK-NO-RTTI: COMPLETION: int > > + // CHECK-NO-RTTI-NEXT: COMPLETION: long // CHECK-NO-RTTI-NEXT: > > + COMPLETION: Pattern : new <#type#>(<#expressions#>) // > > + CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : new > > + <#type#>[<#size#>](<#expressions#>) > > + // CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + [#bool#]noexcept(<#expression#>) // CHECK-NO-RTTI-NEXT: COMPLETION: > > + Pattern : [#std::nullptr_t#]nullptr // CHECK-NO-RTTI-NEXT: > > + COMPLETION: operator // CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + reinterpret_cast<<#type#>>(<#expression#>) > > + // CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : return // > > + CHECK-NO-RTTI-NEXT: COMPLETION: short // CHECK-NO-RTTI-NEXT: > > + COMPLETION: signed // CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + [#size_t#]sizeof(<#expression-or-type#>) > > + // CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + [#size_t#]sizeof...(<#parameter-pack#>) > > + // CHECK-NO-RTTI-NEXT: COMPLETION: static // CHECK-NO-RTTI-NEXT: > > + COMPLETION: Pattern : static_cast<<#type#>>(<#expression#>) > > + // CHECK-NO-RTTI-NEXT: COMPLETION: struct // CHECK-NO-RTTI-NEXT: > > + COMPLETION: Pattern : switch(<#condition#>){ // CHECK-NO-RTTI: > > + COMPLETION: t : t // CHECK-NO-RTTI-NOT: throw // CHECK-NO-RTTI: > > + COMPLETION: Pattern : [#bool#]true // CHECK-NO-RTTI-NOT: try // > > + CHECK-NO-RTTI: COMPLETION: TYPEDEF : TYPEDEF // CHECK-NO-RTTI-NEXT: > > + COMPLETION: Pattern : typedef <#type#> <#name#> // > > + CHECK-NO-RTTI-NOT: typeid // CHECK-NO-RTTI: COMPLETION: Pattern : > > + typename <#qualifier#>::<#name#> // CHECK-NO-RTTI-NEXT: COMPLETION: > > + Pattern : typeof <#expression#> // CHECK-NO-RTTI-NEXT: COMPLETION: > > + Pattern : typeof(<#type#>) // CHECK-NO-RTTI-NEXT: COMPLETION: union > > + // CHECK-NO-RTTI-NEXT: COMPLETION: unsigned // CHECK-NO-RTTI-NEXT: > > + COMPLETION: Pattern : using namespace <#identifier#> // > > + CHECK-NO-RTTI-NEXT: COMPLETION: void // CHECK-NO-RTTI-NEXT: > > + COMPLETION: volatile // CHECK-NO-RTTI-NEXT: COMPLETION: wchar_t // > > + CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : > > + while(<#condition#>){<#statements#> > > + // CHECK-NO-RTTI: COMPLETION: X : X // CHECK-NO-RTTI-NEXT: > > + COMPLETION: y : [#int#]y // CHECK-NO-RTTI-NEXT: COMPLETION: z : > > + [#void#]z(<#int#>) > > _______________________________________________ > cfe-commits mailing list > cfe-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits > >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
