llvm-project/clang/test/SemaTemplate/qualified-names-diag.cpp

// RUN: %clang_cc1 -fsyntax-only -verify %s

namespace std {
  template<typename T> class vector { }; // expected-note{{candidate}}
}

typedef int INT;
typedef float Real;

void test() {
  using namespace std;

  std::vector<INT> v1;
  vector<Real> v2;
  v1 = v2; // expected-error{{no viable overloaded '='}}
}
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 use of QualifiedNameType to the creation of class template specialization names. This way, we keep track of sugared types like std::vector<Real> I believe we are now using QualifiedNameTypes everywhere we can. Next step: QualifiedDeclRefExprs. llvm-svn: 67268 2009-03-19 08:39:20 +08:00
			`namespace std {`
When overload resolution fails for an overloaded operator, show the overload candidates (but not the built-in ones). We still rely on the underlying built-in semantic analysis to produce the initial diagnostic, then print the candidates following that diagnostic. One side advantage of this approach is that we can perform more validation of C++'s operator overloading with built-in candidates vs. the semantic analysis for those built-in operators: when there are no viable candidates, we know to expect an error from the built-in operator handling code. Otherwise, we are not modeling the built-in semantics properly within operator overloading. This is checked as: assert(Result.isInvalid() && "C++ binary operator overloading is missing candidates!"); if (Result.isInvalid()) PrintOverloadCandidates(CandidateSet, /OnlyViable=/false); The assert() catches cases where we're wrong in a +Asserts build. The "if" makes sure that, if this happens in a production clang (-Asserts), we still build the proper built-in operator and continue on our merry way. This is effectively what happened before this change, but we've added the assert() to catch more flies. llvm-svn: 83175 2009-10-01 05:46:01 +08:00			`template<typename T> class vector { }; // expected-note{{candidate}}`
Extend the use of QualifiedNameType to the creation of class template specialization names. This way, we keep track of sugared types like std::vector<Real> I believe we are now using QualifiedNameTypes everywhere we can. Next step: QualifiedDeclRefExprs. llvm-svn: 67268 2009-03-19 08:39:20 +08:00			`}`

			`typedef int INT;`
			`typedef float Real;`

			`void test() {`
			`using namespace std;`

			`std::vector<INT> v1;`
			`vector<Real> v2;`
Avoid using the built-in type checker for assignment in C++ when classes are involved. Patch by Vyacheslav Kononenko. llvm-svn: 72212 2009-05-21 19:50:50 +08:00			`v1 = v2; // expected-error{{no viable overloaded '='}}`
Extend the use of QualifiedNameType to the creation of class template specialization names. This way, we keep track of sugared types like std::vector<Real> I believe we are now using QualifiedNameTypes everywhere we can. Next step: QualifiedDeclRefExprs. llvm-svn: 67268 2009-03-19 08:39:20 +08:00			`}`