[C++17] Fix class template argument deduction for default constructors without an initializer

[Rakete1111]

Summary

As the title says, this makes following code compile:

template<typename> struct Foo {};
Foo() -> Foo<void>;

Foo f; // ok

Thanks Nicolas Lesser for coining the fix.

[Rakete1111]

Rebased and friendly ping :)

[Rakete1111]

Slight change + rebased + friendly ping :)

[lichray]

The standard hasn't allowed deducing any placeholder type without an initializer (10.1.7.4.1 [dcl.type.auto.deduct]/2) yet.

It's unclear to me what

extern A x;

wants to archive. Usually when people writing extern then expect an initializer to appear somewhere else, but with this declaration, defining

A x = ...;

later may fail by resolving to a different type, which feels... interesting.

[Rakete1111]

@lichray Isn't [dcl.type.auto.deduct] only for auto and decltype(auto)? Class template argument deduction is in [dcl.type.class.deduct], which doesn't seem to disallow declarations without an initializer.

About that extern business, yes that's indeed counter intuitive and weird. Couldn't find anything in the standard prohibiting this though, but I'm not so good at that either.

[lichray]

In D38216#922709, @Rakete1111 wrote:

@lichray Isn't [dcl.type.auto.deduct] only for auto and decltype(auto)?

Sorry, reasoned on a confusingly similar part... Here is
updated information:

10.1.7.5 [dcl.type.class.deduct]
If a placeholder for a deduced class type appears as a decl-specifier in
the decl-specifier-seq of an initializing declaration (11.6) of a variable,
[...].

11.6 [dcl.init]/22
A declaration that specifies the initialization of a variable, whether from
an explicit initializer or by default initialization, is called the initializing
declaration of that variable. [ Note: In most cases this is the defining
declaration (6.1) of the variable, but the initializing declaration of a non-
inline static data member (12.2.3.2) might be the declaration within the
class definition and not the definition at namespace scope. —end note ]

So deducing from default initialization is indeed allowed, but extern
could be interpreted as outlawed because similar to the case of non-
inline static data member, where the declaration doesn't give the
initialization of that variable. @rsmith, comments?

[rsmith]

In D38216#922768, @lichray wrote:

So deducing from default initialization is indeed allowed, but extern
could be interpreted as outlawed because similar to the case of non-
inline static data member, where the declaration doesn't give the
initialization of that variable. @rsmith, comments?

That's almost right, but not all extern declarations are disallowed. (An extern declaration is still a defining declaration if it has an initializer.)

lib/Sema/SemaDecl.cpp

10208

Please put this ?: expression into the declaration of DeduceInits instead of here. (We should build an empty list instead of a list of one null pointer when there is no init.)

[Rakete1111]

Made DeduceInits empty instead of a workaround somewhere else. Is it still ok, @rsmith ?

[lichray]

In D38216#923580, @rsmith wrote:

That's almost right, but not all extern declarations are disallowed. (An extern declaration is still a defining declaration if it has an initializer.)

Good to know, thanks.

So gcc got this wrong?

https://wandbox.org/permlink/RVApvaca1ebUfInn

[rsmith]

In D38216#924039, @lichray wrote:

So gcc got this wrong?

https://wandbox.org/permlink/RVApvaca1ebUfInn

Yes, the declaration extern A a; in that example is ill-formed.

[Rakete1111]

Rebased + friendly 2018 ping

[rsmith]

Per [dcl.type.class.deduct]p1, only the initializing declaration of a variable can use a placeholder type. The existing diagnostic was correct in many of the modified cases.

test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.class.deduct/p1.cpp

15

This should be ill-formed: this is not the initializing declaration of B::a.

17–19

Likewise, this should remain ill-formed.

test/Parser/cxx1z-class-template-argument-deduction.cpp

78

Likewise.

[Rakete1111]

Addressed review comments :)

Thanks!

[lichray]

LGTM

test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.class.deduct/p1.cpp

17–19

Please add one more test to the end of the file saying

static A y;

as a remainder to the readers.

[Rakete1111]

@lichray Ok done :) Thanks for reviewing

[rsmith]

test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.class.deduct/p1.cpp

17

The diagnostic we produce in this case is not very good. The problem is not that the declaration requires an initializer (how can a forward declaration like this require an initializer?), instead the problem is that type deduction is only possible for the initializing declaration of a variable.

lib/Sema/SemaDecl.cpp

public:
     // Reference types not handled in HandleValue are handled here since all
     // uses of references are bad, not just r-value uses.
     void VisitDeclRefExpr(DeclRefExpr *E) {
       if (isReferenceType)
         HandleDeclRefExpr(E);
     }
 
     void VisitImplicitCastExpr(ImplicitCastExpr *E) {
       if (E->getCastKind() == CK_LValueToRValue) {
         HandleValue(E->getSubExpr());
         return;
       }
 
       Inherited::VisitImplicitCastExpr(E);
     }
 
     void VisitMemberExpr(MemberExpr *E) {
QualType Sema::deduceVarTypeFromInitializer(VarDecl *VDecl,
   VarDeclOrName VN{VDecl, Name};
 
   DeducedType *Deduced = Type->getContainedDeducedType();
   assert(Deduced && "deduceVarTypeFromInitializer for non-deduced type");
 
   // C++11 [dcl.spec.auto]p3
   if (!Init) {
     assert(VDecl && "no init for init capture deduction?");
+
+    // Except for class argument deduction, and then for an initializing
+    // declaration only, i.e. no static at class scope or extern.
+    if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
+        VDecl->hasExternalStorage() ||
+        VDecl->isStaticDataMember()) {
       Diag(VDecl->getLocation(), diag::err_auto_var_requires_init)
         << VDecl->getDeclName() << Type;
       return QualType();
     }
+  }
+
+  ArrayRef<Expr*> DeduceInits;
+  if (Init)
+    DeduceInits = Init;
 
-  ArrayRef<Expr*> DeduceInits = Init;
   if (DirectInit) {
     if (auto *PL = dyn_cast_or_null<ParenListExpr>(Init))
       DeduceInits = PL->exprs();
   }
 
   if (isa<DeducedTemplateSpecializationType>(Deduced)) {
     assert(VDecl && "non-auto type for init capture deduction?");
     InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);

test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.class.deduct/p1.cpp

 // RUN: %clang_cc1 -std=c++1z -verify %s
 
 template<typename T> struct A { constexpr A(int = 0) {} };
 A() -> A<int>;
 A(int) -> A<char>;
 
 static constexpr inline const volatile A a = {}; // ok, specifiers are permitted
-// FIXME: There isn't really a good reason to reject this.
-A b; // expected-error {{requires an initializer}}
+A b;
 A c [[]] {};
 
 A d = {}, e = {};
 A f(0), g{}; // expected-error {{template arguments deduced as 'A<char>' in declaration of 'f' and deduced as 'A<int>' in declaration of 'g'}}
 
 struct B {
   static A a; // expected-error {{requires an initializer}}
 };
 extern A x; // expected-error {{requires an initializer}}
+static A y;
+

test/Parser/cxx1z-class-template-argument-deduction.cpp

struct member {
   const A c; // expected-error {{requires template arguments}}
 
   void f() throw (A); // expected-error {{requires template arguments}}
 
   friend A; // expected-error {{requires template arguments; argument deduction not allowed in friend declaration}}
 
   operator A(); // expected-error {{requires template arguments; argument deduction not allowed in conversion function type}}
 
   static A x; // expected-error {{declaration of variable 'x' with deduced type 'A' requires an initializer}}
   static constexpr A y = 0;
 };
 
 namespace in_typedef {
   typedef A *AutoPtr; // expected-error {{requires template arguments; argument deduction not allowed in typedef}}
   typedef A (*PFun)(int a); // expected-error{{requires template arguments; argument deduction not allowed in typedef}}
   typedef A Fun(int a) -> decltype(a + a); // expected-error{{requires template arguments; argument deduction not allowed in function return type}}
 }
void j() {
     (void)*(A*)(&n); // expected-error{{requires template arguments; argument deduction not allowed here}}
     (void)(A)(n); // expected-error{{requires template arguments; argument deduction not allowed here}}
     (void)(A){n}; // expected-error{{requires template arguments; argument deduction not allowed here}}
 
     (void)A(n);
     (void)A{n};
     (void)new A(n);
     (void)new A{n};
-    // FIXME: We should diagnose the lack of an initializer here.
     (void)new A;
   }
 }
 
 namespace decl {
   enum E : A {}; // expected-error{{requires template arguments; argument deduction not allowed here}}
   struct F : A {}; // expected-error{{expected class name}}
 
   using B = A; // expected-error{{requires template arguments}}
 
   auto k() -> A; // expected-error{{requires template arguments}}
 
-  A a; // expected-error {{declaration of variable 'a' with deduced type 'A' requires an initializer}}
+  A a;
   A b = 0;
   const A c = 0;
   A (parens) = 0; // expected-error {{cannot use parentheses when declaring variable with deduced class template specialization type}}
   A *p = 0; // expected-error {{cannot form pointer to deduced class template specialization type}}
   A &r = *p; // expected-error {{cannot form reference to deduced class template specialization type}}
   A arr[3] = 0; // expected-error {{cannot form array of deduced class template specialization type}}
   A F::*pm = 0; // expected-error {{cannot form pointer to deduced class template specialization type}}
   A (*fp)() = 0; // expected-error {{cannot form function returning deduced class template specialization type}}