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

35 lines
1.0 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 -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
}
Correctly refer to element CVR qualifications when determining if a type is more or less cv-qualified than another during implicit conversion and overload resolution ([basic.type.qualifier] p5). Factors the logic out of template deduction and into the ASTContext so it can be shared. This fixes several aspects of PR5542, but not all of them. llvm-svn: 92248
2009-12-29 15:16:59 +08:00
void aquals1(int const (*p)[1]);
void aquals2(int * const (*pp)[1]);
void aquals2a(int const * (*pp2)[1]); // expected-note{{candidate function}}
void test_aquals(int (*p)[1], int * (*pp)[1], int * (*pp2)[1]) {
int const (*p2)[1] = p;
aquals1(p);
aquals2(pp);
aquals2a(pp2); // expected-error {{no matching}}
}