maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Sema/var-redecl.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

71 lines
2.8 KiB
C
Raw Normal View History

Update tests to use %clang_cc1 instead of 'clang-cc' or 'clang -cc1'. - This is designed to make it obvious that %clang_cc1 is a "test variable" which is substituted. It is '%clang_cc1' instead of '%clang -cc1' because it can be useful to redefine what gets run as 'clang -cc1' (for example, to set a default target). llvm-svn: 91446
2009-12-16 04:14:24 +08:00
// RUN: %clang_cc1 -fsyntax-only -verify %s
Extend the implicit declaration and checking against out-of-scope external declarations to also support external variable declarations. Unified the code for these two cases into two new subroutines. Note that we fail to diagnose cases like the one Neil pointed out, where a visible non-external declaration hides an external declaration by the same name. That will require some reshuffling of name lookup. llvm-svn: 65385
2009-02-25 03:23:27 +08:00
int outer1; // expected-note{{previous definition is here}}
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern int outer2; // expected-note{{previous declaration is here}}
Extend the implicit declaration and checking against out-of-scope external declarations to also support external variable declarations. Unified the code for these two cases into two new subroutines. Note that we fail to diagnose cases like the one Neil pointed out, where a visible non-external declaration hides an external declaration by the same name. That will require some reshuffling of name lookup. llvm-svn: 65385
2009-02-25 03:23:27 +08:00
int outer4;
int outer4; // expected-note{{previous definition is here}}
Sema: Check type compatibility with the most recent decl when merging We would check the type information from the declaration found by lookup but we would neglect checking compatibility with the most recent declaration. This would make it possible for us to not correctly diagnose inconsistencies with declarations which were made in a different scope. llvm-svn: 225934
2015-01-14 10:27:38 +08:00
int outer5;
Extend the implicit declaration and checking against out-of-scope external declarations to also support external variable declarations. Unified the code for these two cases into two new subroutines. Note that we fail to diagnose cases like the one Neil pointed out, where a visible non-external declaration hides an external declaration by the same name. That will require some reshuffling of name lookup. llvm-svn: 65385
2009-02-25 03:23:27 +08:00
int outer6(float); // expected-note{{previous definition is here}}
int outer7(float);
void outer_test() {
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern float outer1; // expected-error{{redeclaration of 'outer1' with a different type}}
extern float outer2; // expected-error{{redeclaration of 'outer2' with a different type}}
extern float outer3; // expected-note{{previous declaration is here}}
Extend the implicit declaration and checking against out-of-scope external declarations to also support external variable declarations. Unified the code for these two cases into two new subroutines. Note that we fail to diagnose cases like the one Neil pointed out, where a visible non-external declaration hides an external declaration by the same name. That will require some reshuffling of name lookup. llvm-svn: 65385
2009-02-25 03:23:27 +08:00
double outer4;
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern int outer5; // expected-note{{previous declaration is here}}
Extend the implicit declaration and checking against out-of-scope external declarations to also support external variable declarations. Unified the code for these two cases into two new subroutines. Note that we fail to diagnose cases like the one Neil pointed out, where a visible non-external declaration hides an external declaration by the same name. That will require some reshuffling of name lookup. llvm-svn: 65385
2009-02-25 03:23:27 +08:00
extern int outer6; // expected-error{{redefinition of 'outer6' as different kind of symbol}}
int outer7;
extern int outer8; // expected-note{{previous definition is here}}
extern int outer9;
{
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern int outer9; // expected-note{{previous declaration is here}}
Extend the implicit declaration and checking against out-of-scope external declarations to also support external variable declarations. Unified the code for these two cases into two new subroutines. Note that we fail to diagnose cases like the one Neil pointed out, where a visible non-external declaration hides an external declaration by the same name. That will require some reshuffling of name lookup. llvm-svn: 65385
2009-02-25 03:23:27 +08:00
}
}
int outer3; // expected-error{{redefinition of 'outer3' with a different type}}
float outer4; // expected-error{{redefinition of 'outer4' with a different type}}
float outer5; // expected-error{{redefinition of 'outer5' with a different type}}
int outer8(int); // expected-error{{redefinition of 'outer8' as different kind of symbol}}
float outer9; // expected-error{{redefinition of 'outer9' with a different type}}
When we're declaring an object or function with linkage, teach name lookup to skip over names without linkage. This finishes <rdar://problem/6127293>. llvm-svn: 65386
2009-02-25 04:03:32 +08:00
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern int outer13; // expected-note{{previous declaration is here}}
When we're declaring an object or function with linkage, teach name lookup to skip over names without linkage. This finishes <rdar://problem/6127293>. llvm-svn: 65386
2009-02-25 04:03:32 +08:00
void outer_shadowing_test() {
extern int outer10;
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern int outer11; // expected-note{{previous declaration is here}}
extern int outer12; // expected-note{{previous declaration is here}}
When we're declaring an object or function with linkage, teach name lookup to skip over names without linkage. This finishes <rdar://problem/6127293>. llvm-svn: 65386
2009-02-25 04:03:32 +08:00
{
float outer10;
float outer11;
float outer12;
{
extern int outer10; // okay
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern float outer11; // expected-error{{redeclaration of 'outer11' with a different type}}
When we're declaring an object or function with linkage, teach name lookup to skip over names without linkage. This finishes <rdar://problem/6127293>. llvm-svn: 65386
2009-02-25 04:03:32 +08:00
static double outer12;
{
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
extern float outer12; // expected-error{{redeclaration of 'outer12' with a different type}}
extern float outer13; // expected-error{{redeclaration of 'outer13' with a different type}}
When we're declaring an object or function with linkage, teach name lookup to skip over names without linkage. This finishes <rdar://problem/6127293>. llvm-svn: 65386
2009-02-25 04:03:32 +08:00
}
}
}
}
Rework the way we find locally-scoped external declarations when we need them to evaluate redeclarations or call a function that hasn't already been declared. We now keep a DenseMap of these locally-scoped declarations so that they are not visible but can be quickly found, e.g., when we're looking for previous declarations or before we go ahead and implicitly declare a function that's being called. Fixes PR3672. llvm-svn: 65792
2009-03-02 08:19:53 +08:00
Whenever we emit a typo-correction diagnostic, also emit a note pointing to the declaration that we found that has that name (if it is unique). llvm-svn: 92877
2010-01-07 08:17:44 +08:00
void g18(void) { // expected-note{{'g18' declared here}}
Rework the way we find locally-scoped external declarations when we need them to evaluate redeclarations or call a function that hasn't already been declared. We now keep a DenseMap of these locally-scoped declarations so that they are not visible but can be quickly found, e.g., when we're looking for previous declarations or before we go ahead and implicitly declare a function that's being called. Fixes PR3672. llvm-svn: 65792
2009-03-02 08:19:53 +08:00
extern int g19;
}
Implement typo correction for id-expressions, e.g., typo.cpp:22:10: error: use of undeclared identifier 'radious'; did you mean 'radius'? return radious * pi; ^~~~~~~ radius This was super-easy, since we already had decent recovery by looking for names in dependent base classes. llvm-svn: 92341
2009-12-31 13:20:13 +08:00
int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}} \
// expected-warning{{incompatible pointer types}}
Variables marked as "extern" can actually have internal linkage if there is a previous declaration marked "static". This fixes PR3645. llvm-svn: 67336
2009-03-20 06:01:50 +08:00
// PR3645
static int a;
Sema: Static redeclaration after extern declarations is a Microsoft Extension CL permits static redeclarations to follow extern declarations. The storage specifier on the latter declaration has no effect. This fixes PR20034. Differential Revision: http://reviews.llvm.org/D4149 llvm-svn: 211238
2014-06-19 07:26:25 +08:00
extern int a; // expected-note {{previous declaration is here}}
Fixes a corner case bug whereby declaring and defining an extern variable in a particular sequence causes its definition to not be generated in the object file. (fixes radar 8071804). llvm-svn: 106424
2010-06-22 00:08:37 +08:00
int a; // expected-error {{non-static declaration of 'a' follows static declaration}}
Sema: An extern declaration can't be a redeclaration of a parameter In the following: void f(int x) { extern int x; } The second declaration of 'x' shouldn't be considered a redeclaration of the parameter. This is a different approach to r225780. llvm-svn: 225875
2015-01-14 08:31:13 +08:00
void f(int x) { // expected-note {{previous definition is here}}
extern int x; // expected-error {{extern declaration of 'x' follows non-extern declaration}}
}
Sema: Check type compatibility with the most recent decl when merging We would check the type information from the declaration found by lookup but we would neglect checking compatibility with the most recent declaration. This would make it possible for us to not correctly diagnose inconsistencies with declarations which were made in a different scope. llvm-svn: 225934
2015-01-14 10:27:38 +08:00
extern int b[];
[Sema] Emit a better diagnostic when variable redeclarations disagree We referred to all declaration in definitions in our diagnostic messages which is can be inaccurate. Instead, classify the declaration and emit an appropriate diagnostic for the new declaration and an appropriate note pointing to the old one. This fixes PR24116. llvm-svn: 242190
2015-07-15 04:08:49 +08:00
void g20() { extern int b[3]; } // expected-note{{previous declaration is here}}
Recommit: Compress formatting of array type names (int [4] -> int[4]) Based on post-commit review discussion on 2bd84938470bf2e337801faafb8a67710f46429d with Richard Smith. Other uses of forcing HasEmptyPlaceHolder to false seem OK to me - they're all around pointer/reference types where the pointer/reference token will appear at the rightmost side of the left side of the type name, so they make nested types (eg: the "int" in "int *") behave as though there is a non-empty placeholder (because the "*" is essentially the placeholder as far as the "int" is concerned). This was originally committed in 277623f4d5a672d707390e2c3eaf30a9eb4b075c Reverted in f9ad1d1c775a8e264bebc15d75e0c6e5c20eefc7 due to breakages outside of clang - lldb seems to have some strange/strong dependence on "char [N]" versus "char[N]" when printing strings (not due to that name appearing in DWARF, but probably due to using clang to stringify type names) that'll need to be addressed, plus a few other odds and ends in other subprojects (clang-tools-extra, compiler-rt, etc).
2021-10-15 05:52:47 +08:00
void g21() { extern int b[4]; } // expected-error{{redeclaration of 'b' with a different type: 'int[4]' vs 'int[3]'}}