Fix for Bug 33471: Preventing operator auto from resolving to a template operator.

[erichkeane]

Summary

As the bug report says,
struct A
{

template<typename T> operator T();

};

void foo()
{

A().operator auto();

}

causes: "undeduced type in IR-generation
UNREACHABLE executed at llvm/tools/clang/lib/CodeGen/CodeGenFunction.cpp:208!"

The problem is that in this case, "T" is being deduced as "auto", which I believe is incorrect.

The 'operator auto' implementation in Clang is standards compliant, however there is a defect report against core (1670).

[rsmith]

lib/Sema/SemaLookup.cpp

870–872 ↗

(On Diff #103115)

This is not sufficient to catch cases such as operator auto*, and one day there'll be concepts and potentially class template argument deduction here too. Use Ty->getContainedDeducedType() instead.

[erichkeane]

Hi @rsmith
Thanks for the quick response! I spent a while going over it, and think I have what you were looking for. I Also added the operator auto * tests.

[rsmith]

Looks good, thanks!

lib/Sema/SemaLookup.cpp

870 ↗

(On Diff #103224)

Maybe only call this once?

[erichkeane]

lib/Sema/SemaLookup.cpp

870 ↗

(On Diff #103224)

Sure, I'll extract this into a variable above the if statement before committing.

cfe/trunk/lib/Sema/SemaLookup.cpp

static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
   // C++ [temp.mem]p6:
   //   A specialization of a conversion function template is not found by
   //   name lookup. Instead, any conversion function templates visible in the
   //   context of the use are considered. [...]
   const CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
   if (!Record->isCompleteDefinition())
     return Found;
 
+  // For conversion operators, 'operator auto' should only match
+  // 'operator auto'.  Since 'auto' is not a type, it shouldn't be considered
+  // as a candidate for template substitution.
+  auto *ContainedDeducedType =
+      R.getLookupName().getCXXNameType()->getContainedDeducedType();
+  if (R.getLookupName().getNameKind() ==
+          DeclarationName::CXXConversionFunctionName &&
+      ContainedDeducedType && ContainedDeducedType->isUndeducedType())
+    return Found;
+
   for (CXXRecordDecl::conversion_iterator U = Record->conversion_begin(),
          UEnd = Record->conversion_end(); U != UEnd; ++U) {
     FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(*U);
     if (!ConvTemplate)
       continue;
 
     // When we're performing lookup for the purposes of redeclaration, just
     // add the conversion function template. When we deduce template

cfe/trunk/test/SemaCXX/cxx1y-deduced-return-type.cpp

 auto *a(); // expected-error {{differ only in their return type}}
 
 auto b(bool k) {
   if (k)
     return "hello";
   return "goodbye";
 }
 
+// Allow 'operator auto' to call only the explicit operator auto.
+struct BothOps {
+  template <typename T> operator T();
+  template <typename T> operator T *();
+  operator auto() { return 0; }
+  operator auto *() { return this; }
+};
+struct JustTemplateOp {
+  template <typename T> operator T();
+  template <typename T> operator T *();
+};
+
+auto c() {
+  BothOps().operator auto(); // ok
+  BothOps().operator auto *(); // ok
+  JustTemplateOp().operator auto(); // expected-error {{no member named 'operator auto' in 'JustTemplateOp'}}
+  JustTemplateOp().operator auto *(); // expected-error {{no member named 'operator auto *' in 'JustTemplateOp'}}
+}
+
 auto *ptr_1() {
   return 100; // expected-error {{cannot deduce return type 'auto *' from returned value of type 'int'}}
 }
 
 const auto &ref_1() {
   return 0; // expected-warning {{returning reference to local temporary}}
 }