maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeCompletion/ordinary-name.cpp

243 lines
12 KiB
C++
Raw Normal View History

Improve code completion by introducing patterns for the various C and C++ grammatical constructs that show up in top-level (namespace-level) declarations, member declarations, template declarations, statements, expressions, conditions, etc. For example, we now provide a pattern for static_cast<type>(expr) when we can have an expression, or using namespace identifier; when we can have a using directive. Also, improves the results of code completion at the beginning of a top-level declaration. Previously, we would see value names (function names, global variables, etc.); now we see types, namespace names, etc., but no values. llvm-svn: 93134
2010-01-11 07:08:15 +08:00
struct X { int x; };
void z(int);
typedef struct t TYPEDEF;
void foo() {
int y = 17;
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// 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
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1: COMPLETION: bool
// CHECK-CC1-NEXT: COMPLETION: char
// CHECK-CC1-NEXT: COMPLETION: class
// CHECK-CC1-NEXT: COMPLETION: const
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : const_cast<<#type#>>(<#expression#>)
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC1: COMPLETION: Pattern : [#void#]delete <#expression#>
// CHECK-CC1-NEXT: COMPLETION: Pattern : [#void#]delete [] <#expression#>
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : do{
// CHECK-CC1-NEXT: <#statements#>
// CHECK-CC1-NEXT: }
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1: COMPLETION: double
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : dynamic_cast<<#type#>>(<#expression#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: enum
// CHECK-CC1-NEXT: COMPLETION: extern
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : [#bool#]false
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: float
// CHECK-CC1-NEXT: COMPLETION: foo : [#void#]foo()
Fix the mapping of vertical-space cursor kinds to produce a newline, rather than a space. llvm-svn: 116097
2010-10-09 04:39:29 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : for(<#init-statement#>;<#condition#>;<#inc-expression#>){
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-CC1-NEXT: <#statements#>{{$}}
// CHECK-CC1-NEXT: }
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-CC1: COMPLETION: Pattern : goto <#label#>;
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : if(<#condition#>){
// CHECK-CC1-NEXT: <#statements#>{{$}}
// CHECK-CC1-NEXT: }
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1: COMPLETION: int
// CHECK-CC1-NEXT: COMPLETION: long
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : new <#type#>(<#expressions#>)
// CHECK-CC1-NEXT: COMPLETION: Pattern : new <#type#>[<#size#>](<#expressions#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: operator
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : reinterpret_cast<<#type#>>(<#expression#>)
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : return;
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: short
// CHECK-CC1-NEXT: COMPLETION: signed
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : [#size_t#]sizeof(<#expression-or-type#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: static
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : static_cast<<#type#>>(<#expression#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: struct
// CHECK-CC1-NEXT: COMPLETION: Pattern : switch(<#condition#>){
// CHECK-CC1: COMPLETION: t : t
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : [#void#]throw <#expression#>
// CHECK-CC1-NEXT: COMPLETION: Pattern : [#bool#]true
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : try{
// CHECK-CC1-NEXT: <#statements#>
// CHECK-CC1-NEXT: }catch(<#declaration#>){
// CHECK-CC1-NEXT: <#statements#>
// CHECK-CC1-NEXT: }
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1: COMPLETION: TYPEDEF : TYPEDEF
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : typedef <#type#> <#name#>
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : [#std::type_info#]typeid(<#expression-or-type#>)
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : typename <#qualifier#>::<#name#>
// CHECK-CC1-NEXT: COMPLETION: Pattern : typeof <#expression#>
// CHECK-CC1-NEXT: COMPLETION: Pattern : typeof(<#type#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: union
// CHECK-CC1-NEXT: COMPLETION: unsigned
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : using namespace <#identifier#>;
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1-NEXT: COMPLETION: void
// CHECK-CC1-NEXT: COMPLETION: volatile
// CHECK-CC1-NEXT: COMPLETION: wchar_t
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-CC1-NEXT: COMPLETION: Pattern : while(<#condition#>){
// CHECK-CC1-NEXT: <#statements#>
// CHECK-CC1-NEXT: }
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC1: COMPLETION: X : X
// CHECK-CC1-NEXT: COMPLETION: y : [#int#]y
// CHECK-CC1-NEXT: COMPLETION: z : [#void#]z(<#int#>)
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// 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
Do not produce semicolons at the end of code-completion results llvm-svn: 100557
2010-04-07 04:11:37 +08:00
// CHECK-CC2: COMPLETION: Pattern : asm(<#string-literal#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC2-NEXT: COMPLETION: bool
// CHECK-CC2-NEXT: COMPLETION: char
// CHECK-CC2-NEXT: COMPLETION: class
// CHECK-CC2-NEXT: COMPLETION: const
// 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
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-CC2-NEXT: COMPLETION: Pattern : namespace <#identifier#>{
// CHECK-CC2-NEXT: <#declarations#>
// CHECK-CC2-NEXT: }
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-CC2: COMPLETION: Pattern : namespace <#name#> = <#namespace#>;
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// 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
Do not produce semicolons at the end of code-completion results llvm-svn: 100557
2010-04-07 04:11:37 +08:00
// CHECK-CC2-NEXT: COMPLETION: Pattern : template <#declaration#>
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC2-NEXT: COMPLETION: Pattern : template<<#parameters#>>
// CHECK-CC2-NEXT: COMPLETION: TYPEDEF : TYPEDEF
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// 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#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC2-NEXT: COMPLETION: union
// CHECK-CC2-NEXT: COMPLETION: unsigned
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-CC2-NEXT: COMPLETION: Pattern : using namespace <#identifier#>;
// CHECK-CC2-NEXT: COMPLETION: Pattern : using <#qualifier#>::<#name#>;
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC2-NEXT: COMPLETION: void
// CHECK-CC2-NEXT: COMPLETION: volatile
// CHECK-CC2-NEXT: COMPLETION: wchar_t
// CHECK-CC2-NEXT: COMPLETION: X : X
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// 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
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC3: COMPLETION: bool
// CHECK-CC3-NEXT: COMPLETION: char
// CHECK-CC3-NEXT: COMPLETION: class
// CHECK-CC3-NEXT: COMPLETION: const
// 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#>>
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// 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#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC3-NEXT: COMPLETION: union
// CHECK-CC3-NEXT: COMPLETION: unsigned
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-CC3-NEXT: COMPLETION: Pattern : using <#qualifier#>::<#name#>;
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// 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
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// 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
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4: COMPLETION: bool
// CHECK-CC4-NEXT: COMPLETION: char
// CHECK-CC4-NEXT: COMPLETION: class
// CHECK-CC4-NEXT: COMPLETION: const
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : const_cast<<#type#>>(<#expression#>)
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#void#]delete <#expression#>
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#void#]delete [] <#expression#>
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: double
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : dynamic_cast<<#type#>>(<#expression#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: enum
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#bool#]false
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: float
// CHECK-CC4-NEXT: COMPLETION: foo : [#void#]foo()
// CHECK-CC4-NEXT: COMPLETION: int
// CHECK-CC4-NEXT: COMPLETION: long
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : new <#type#>(<#expressions#>)
// CHECK-CC4-NEXT: COMPLETION: Pattern : new <#type#>[<#size#>](<#expressions#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: operator
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : reinterpret_cast<<#type#>>(<#expression#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: short
// CHECK-CC4-NEXT: COMPLETION: signed
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#size_t#]sizeof(<#expression-or-type#>)
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : static_cast<<#type#>>(<#expression#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: struct
// CHECK-CC4-NEXT: COMPLETION: t : t
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#void#]throw <#expression#>
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#bool#]true
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// CHECK-CC4-NEXT: COMPLETION: TYPEDEF : TYPEDEF
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : [#std::type_info#]typeid(<#expression-or-type#>)
Make -code-completion-patterns only cover multi-line code completions. Plus, tweak a few completion patterns to better reflect the language grammar. llvm-svn: 104905
2010-05-28 08:22:41 +08:00
// CHECK-CC4-NEXT: COMPLETION: Pattern : typename <#qualifier#>::<#name#>
// CHECK-CC4-NEXT: COMPLETION: Pattern : typeof <#expression#>
// CHECK-CC4-NEXT: COMPLETION: Pattern : typeof(<#type#>)
Improve the sorting of code-completion results. We now always sort by the "typed" text, first, then take into account nested-name-specifiers, name hiding, etc. This means that the resulting sort is actually alphabetical :) llvm-svn: 93370
2010-01-14 07:24:38 +08:00
// 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: z : [#void#]z(<#int#>)
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
[Tests] Modified Lit Tests to be C++11 compatibile This 2nd patch should not change the test results, but it is useful if clang's default C++ language is ever changed from gnu++98. llvm-svn: 246183
2015-08-28 02:49:15 +08:00
// 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
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// CHECK-NO-RTTI: COMPLETION: bool
// CHECK-NO-RTTI-NEXT: COMPLETION: char
// CHECK-NO-RTTI-NEXT: COMPLETION: class
// CHECK-NO-RTTI-NEXT: COMPLETION: const
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : const_cast<<#type#>>(<#expression#>)
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-NO-RTTI: COMPLETION: Pattern : [#void#]delete <#expression#>
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : [#void#]delete [] <#expression#>
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : do{
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// CHECK-NO-RTTI: COMPLETION: double
// CHECK-NO-RTTI-NOT: dynamic_cast
// CHECK-NO-RTTI: COMPLETION: enum
// CHECK-NO-RTTI-NEXT: COMPLETION: extern
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : [#bool#]false
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// 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#>){
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-NO-RTTI: COMPLETION: Pattern : goto <#label#>;
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : if(<#condition#>){
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// 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: operator
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : reinterpret_cast<<#type#>>(<#expression#>)
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : return;
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: short
// CHECK-NO-RTTI-NEXT: COMPLETION: signed
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : [#size_t#]sizeof(<#expression-or-type#>)
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// 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
Provide result types for code completions that describe built-in expressions (this, sizeof, etc.). llvm-svn: 142424
2011-10-19 05:20:17 +08:00
// CHECK-NO-RTTI: COMPLETION: Pattern : [#bool#]true
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// 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
[CodeComplete] Add a trailing semicolons to some pattern completions Summary: Where semicolon is required in any case. Here's a list of completions that now have a semicolon: - namespace <name> = <target>; - using namespace <name>; - using <qualifier>::<name>; - continue; - break; - goto <label>; - return; - return <expression>; Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61589 llvm-svn: 360042
2019-05-06 21:18:00 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : using namespace <#identifier#>;
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: void
// CHECK-NO-RTTI-NEXT: COMPLETION: volatile
// CHECK-NO-RTTI-NEXT: COMPLETION: wchar_t
[CodeComplete] Consistently break after '{' in multi-line patterns Summary: Completion can return multi-line patterns in some cases, e.g. for (<#init#>; <#cond#>; <#inc#>) { <#body#> } However, most patterns break the line only before closing brace, resulting in code like: namespace <#name#> { <#decls#> } While some (e.g. the 'for' example above) are breaking lines after the opening brace too. This change ensures all patterns consistently break after the opening brace, this leads to nicer UX when using those in an actual editor. Reviewers: gribozavr Reviewed By: gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D62405 llvm-svn: 361829
2019-05-28 22:33:16 +08:00
// CHECK-NO-RTTI-NEXT: COMPLETION: Pattern : while(<#condition#>){
Don't suggest dynamic_cast or typeid as code completion results when RTTI is disabled. Similarly, don't suggest throw or try as code completion results when C++ exceptions are disabled. Fixes <rdar://problem/9193560>. llvm-svn: 129346
2011-04-12 10:47:21 +08:00
// CHECK-NO-RTTI: COMPLETION: X : X
// CHECK-NO-RTTI-NEXT: COMPLETION: y : [#int#]y
// CHECK-NO-RTTI-NEXT: COMPLETION: z : [#void#]z(<#int#>)