maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/SemaCXX/qualification-conversion.cpp

24 lines
730 B
C++
Raw Normal View History

Rename clang to clang-cc. Tests and drivers updated, still need to shuffle dirs. llvm-svn: 67602
2009-03-24 10:24:46 +08:00
// RUN: clang-cc -fsyntax-only -pedantic -verify %s
Initial step toward supporting qualification conversions (C++ 4.4). Changes: - Sema::IsQualificationConversion determines whether we have a qualification conversion. - Sema::CheckSingleAssignment constraints now follows the C++ rules in C++, performing an implicit conversion from the right-hand side to the type of the left-hand side rather than checking based on the C notion of "compatibility". We now rely on the implicit-conversion code to determine whether the conversion can happen or not. Sema::TryCopyInitialization has an ugly reference-related hack to cope with the initialization of references, for now. - When building DeclRefExprs, strip away the reference type, since there are no expressions whose type is a reference. We'll need to do this throughout Sema. - Expr::isLvalue now permits functions to be lvalues in C++ (but not in C). llvm-svn: 57935
2008-10-22 07:43:52 +08:00
int* quals1(int const * p);
int* quals2(int const * const * pp);
Initial implementation of argument dependent lookup (a.k.a. ADL, a.k.a. Koenig lookup) in C++. Most of the pieces are in place, but for two: - In an unqualified call g(x), even if the name does not refer to anything in the current scope, we can still find functions named "g" based on ADL. We don't yet have this ability. - ADL will need updating for friend functions and templates. llvm-svn: 63692
2009-02-04 08:32:51 +08:00
int* quals3(int const * * const * ppp); // expected-note{{candidate function}}
Initial step toward supporting qualification conversions (C++ 4.4). Changes: - Sema::IsQualificationConversion determines whether we have a qualification conversion. - Sema::CheckSingleAssignment constraints now follows the C++ rules in C++, performing an implicit conversion from the right-hand side to the type of the left-hand side rather than checking based on the C notion of "compatibility". We now rely on the implicit-conversion code to determine whether the conversion can happen or not. Sema::TryCopyInitialization has an ugly reference-related hack to cope with the initialization of references, for now. - When building DeclRefExprs, strip away the reference type, since there are no expressions whose type is a reference. We'll need to do this throughout Sema. - Expr::isLvalue now permits functions to be lvalues in C++ (but not in C). llvm-svn: 57935
2008-10-22 07:43:52 +08:00
void test_quals(int * p, int * * pp, int * * * ppp) {
int const * const * pp2 = pp;
quals1(p);
quals2(pp);
Initial implementation of argument dependent lookup (a.k.a. ADL, a.k.a. Koenig lookup) in C++. Most of the pieces are in place, but for two: - In an unqualified call g(x), even if the name does not refer to anything in the current scope, we can still find functions named "g" based on ADL. We don't yet have this ability. - ADL will need updating for friend functions and templates. llvm-svn: 63692
2009-02-04 08:32:51 +08:00
quals3(ppp); // expected-error {{no matching}}
Initial step toward supporting qualification conversions (C++ 4.4). Changes: - Sema::IsQualificationConversion determines whether we have a qualification conversion. - Sema::CheckSingleAssignment constraints now follows the C++ rules in C++, performing an implicit conversion from the right-hand side to the type of the left-hand side rather than checking based on the C notion of "compatibility". We now rely on the implicit-conversion code to determine whether the conversion can happen or not. Sema::TryCopyInitialization has an ugly reference-related hack to cope with the initialization of references, for now. - When building DeclRefExprs, strip away the reference type, since there are no expressions whose type is a reference. We'll need to do this throughout Sema. - Expr::isLvalue now permits functions to be lvalues in C++ (but not in C). llvm-svn: 57935
2008-10-22 07:43:52 +08:00
}
Implement implicit conversions for pointers-to-member. llvm-svn: 62971
2009-01-26 03:43:20 +08:00
struct A {};
void mquals1(int const A::*p);
void mquals2(int const A::* const A::*pp);
Initial implementation of argument dependent lookup (a.k.a. ADL, a.k.a. Koenig lookup) in C++. Most of the pieces are in place, but for two: - In an unqualified call g(x), even if the name does not refer to anything in the current scope, we can still find functions named "g" based on ADL. We don't yet have this ability. - ADL will need updating for friend functions and templates. llvm-svn: 63692
2009-02-04 08:32:51 +08:00
void mquals3(int const A::* A::* const A::*ppp); // expected-note{{candidate function}}
Implement implicit conversions for pointers-to-member. llvm-svn: 62971
2009-01-26 03:43:20 +08:00
void test_mquals(int A::*p, int A::* A::*pp, int A::* A::* A::*ppp) {
int const A::* const A::* pp2 = pp;
mquals1(p);
mquals2(pp);
Initial implementation of argument dependent lookup (a.k.a. ADL, a.k.a. Koenig lookup) in C++. Most of the pieces are in place, but for two: - In an unqualified call g(x), even if the name does not refer to anything in the current scope, we can still find functions named "g" based on ADL. We don't yet have this ability. - ADL will need updating for friend functions and templates. llvm-svn: 63692
2009-02-04 08:32:51 +08:00
mquals3(ppp); // expected-error {{no matching}}
Implement implicit conversions for pointers-to-member. llvm-svn: 62971
2009-01-26 03:43:20 +08:00
}