PR10405 Missing actual type (aka) in error message when using decltype as a template parameter

[nikola]

Summary

Desugar TemplateSpecializationType if any of the template arguments is a decltype.

'aka Foo<int>' is much better than 'Foo<decltype(arbitrary expression of type int)>' :)

[rsmith]

This seems like a very special case; I wonder if there's some more general rule we should be using here. (Perhaps we should provide an 'aka' if there's a decltype anywhere in the type?) In any case, the same rule should also apply to GNU __typeof.

[nikola]

What cases would we need to handle to make this more generic? I'm thinking FunctionType (return type and parameters) and Template specialization (but at arbitrary nesting level, vector<vector<decltype(something)>>). Have I missed any (plain arrays), and more importantly is there a way to get this info at the moment?

[rsmith]

I think the best approach for a template specialization type would probably be to walk the explicitly-specified template arguments, and desugar each one as if it were a top-level type. If you desugar any, rebuild the template specialization type with the desugared type. Doing the same thing for the parameter and return types of function types might also make some sense.

[nikola]

This should handle templates in a generic way for both decltype and __typeof.

[nikola]

In what situation would FunctionType show up? In this case x is a PointerType which is not sugared.

int (*x)();
int t = x;

[rsmith]

Here's one way to get a diagnostic with a FunctionType in it:

void (&f)(decltype(1+1)) = 0;

This gives:

<stdin>:1:8: error: non-const lvalue reference to type 'void (decltype(1 + 1))' cannot bind to a temporary of type 'int'

lib/AST/ASTDiagnostic.cpp

68–69

Better would be something like "Desugar template specializations if any template argument should be desugared."

70–81

It'd be better here to rebuild a TemplateSpecializationType that has the desugared template arguments in it.

72

Please don't use a TemplateSpecializationType as a container like this; it's not notionally a container of template arguments. Instead, add an arguments member function to TemplateSpecializationType to return the arguments list.

73

Please use 2-space indent, not 4.

[nikola]

lib/AST/ASTDiagnostic.cpp

72

The class already has getArgs, getNumArgs and getArg methods. But why does it have begin and end if not to be used as a container?

[nikola]

lib/AST/ASTDiagnostic.cpp

70–81

What exactly do you mean by rebuild?

[rsmith]

lib/AST/ASTDiagnostic.cpp

70–81

I mean, ask the ASTContext to create a new TemplateSpecializationType with the desugared template arguments.

[nikola]

lib/AST/ASTDiagnostic.cpp

70–81

I thought it'd be obvious why I was doing this after I did it but I guess I should have asked. At first I though this was an optimization, create this QualType now as it will certainly be created later on. But I've noticed that getting the canonical type from sugared type returns a different type object with same 'spelling'. I know that we're supposed to have only one QualType per type and I'm lost... Is this what you had in mind, and more importantly why?

if (const TemplateSpecializationType *TST =
        dyn_cast<TemplateSpecializationType>(Ty)) {
  SmallVector<TemplateArgument, 4> Args;
  for (TemplateSpecializationType::iterator I = TST->args_begin(),
                                            E = TST->args_end();
       I != E; ++I) {
    if (I->getKind() == TemplateArgument::Type)
      Args.push_back(Desugar(Context, I->getAsType(), ShouldAKA));
    else
      Args.push_back(*I);
  }

  if (ShouldAKA || TST->isTypeAlias()) {
    QT = Context.getTemplateSpecializationType(
        TST->getTemplateName(), Args.data(), Args.size(), QT);
    break;
  }
}

[rsmith]

lib/AST/ASTDiagnostic.cpp

70–81

Yes, that's approximately what I had in mind. This way, we should perform an appropriate amount of desugaring on template arguments, and not just flatten them straight to their canonical types.

Comments on that code:

• ShouldAKA might have been set by something already; track your own variable to determine if you desugared any arguments
• It would be useful to also desugar non-type template arguments; maybe pick up the canonical TST's template argument if the non-type template argument is in Expression form?

[nikola]

It's been some time since we looked at this.

I'm having issues addressing your last comment, non type template parameters. What's the idea here, to turn A<1+2> into A<int>? While tinkering with this I managed to produce desugar A<1+2> as A<3> by accident so I'm not really sure what you meant.

I was surprised to see that both A<1> and A<1+2> have a TemplateArgument with Expression kind. Having 'aka A<int>' for each A<1> seems too spammy but I couldn't figure out how to differentiate them.

[nikola]

Ping.

[nikola]

Pong.

[nikola]

Ding.

[rsmith]

Looks great, thanks!

[nikola]

Committed in r242371 with minor changes to preserve nullability attribute.

lib/AST/ASTDiagnostic.cpp

while (true) {
     }
     // ... or an auto type.
     if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
       if (!AT->isSugared())
         break;
       QT = AT->desugar();
       continue;
     }
 
-    // Don't desugar template specializations, unless it's an alias template.
-    if (const TemplateSpecializationType *TST
-          = dyn_cast<TemplateSpecializationType>(Ty))
-      if (!TST->isTypeAlias())
+    // Desugar FunctionType if return type or any parameter type should be
+    // desugared.
+    if (const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
+      bool DesugarReturn = false;
+      QualType RT = Desugar(Context, FT->getReturnType(), DesugarReturn);
+
+      bool DesugarArgument = false;
+      SmallVector<QualType, 4> Args;
+      const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT);
+      if (FPT) {
+        for (const auto &ParamType : FPT->param_types())
+          Args.push_back(Desugar(Context, ParamType, DesugarArgument));
+      }
+
+      if (DesugarReturn || DesugarArgument) {
+        ShouldAKA = true;
+        QT = FPT ? Context.getFunctionType(RT, Args, FPT->getExtProtoInfo())
+                 : Context.getFunctionNoProtoType(RT, FT->getExtInfo());
         break;
+      }
+    }
+
+    // Desugar template specializations if any template argument should be
+    // desugared.
+    if (const TemplateSpecializationType *TST =
+            dyn_cast<TemplateSpecializationType>(Ty)) {
+      if (!TST->isTypeAlias()) {
+        bool DesugarArgument = false;
+        SmallVector<TemplateArgument, 4> Args;
+        for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
+          const TemplateArgument &Arg = TST->getArg(I);
+          if (Arg.getKind() == TemplateArgument::Type)
+            Args.push_back(Desugar(Context, Arg.getAsType(), DesugarArgument));
+          else
+            Args.push_back(Arg);
+        }
+
+        if (DesugarArgument) {
+          ShouldAKA = true;
+          QT = Context.getTemplateSpecializationType(
+              TST->getTemplateName(), Args.data(), Args.size(), QT);
+        }
+        break;
+      }
+    }
 
     // Don't desugar magic Objective-C types.
     if (QualType(Ty,0) == Context.getObjCIdType() ||
         QualType(Ty,0) == Context.getObjCClassType() ||
         QualType(Ty,0) == Context.getObjCSelType() ||
         QualType(Ty,0) == Context.getObjCProtoType())
       break;
 

test/ASTMerge/function.c

 // RUN: %clang_cc1 -emit-pch -o %t.1.ast %S/Inputs/function1.c
 // RUN: %clang_cc1 -emit-pch -o %t.2.ast %S/Inputs/function2.c
 // RUN: not %clang_cc1 -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only %s 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only -verify %s
 
-// CHECK: function2.c:3:6: error: external function 'f1' declared with incompatible types in different translation units ('void (Int, double)' vs. 'void (int, float)')
+// CHECK: function2.c:3:6: error: external function 'f1' declared with incompatible types in different translation units ('void (Int, double)' (aka 'void (int, double)') vs. 'void (int, float)')
 // CHECK: function1.c:2:6: note: declared here with type 'void (int, float)'
 // CHECK: function2.c:5:6: error: external function 'f3' declared with incompatible types in different translation units ('void (int)' vs. 'void (void)')
 // CHECK: function1.c:4:6: note: declared here with type 'void (void)'
 // CHECK: 2 errors generated
 
 // expected-error@Inputs/function2.c:3 {{external function 'f1' declared with incompatible types}}
 // expected-note@Inputs/function1.c:2 {{declared here}}
 // expected-error@Inputs/function2.c:5 {{external function 'f3' declared with incompatible types}}
 // expected-note@Inputs/function1.c:4 {{declared here}}

test/Misc/diag-aka-types.cpp

 
 typedef void (*callback)(struct data *);
 
 void helper(callback cb) {} // expected-note{{candidate function not viable: no known conversion from 'void (*)(struct data *)' (aka 'void (*)(ns::data *)') to 'callback' (aka 'void (*)(struct data *)') for 1st argument}}
 
 void test() {
  helper(&ns::str::method); // expected-error{{no matching function for call to 'helper'}}
 }
+
+template <typename T>
+class A {};
+
+int a1 = A<decltype(1 + 2)>(); // expected-error{{no viable conversion from 'A<decltype(1 + 2)>' (aka 'A<int>') to 'int'}}
+int a2 = A<A<decltype(1 + 2)>>(); // expected-error{{no viable conversion from 'A<A<decltype(1 + 2)> >' (aka 'A<A<int> >') to 'int'}}
+int a3 = A<__typeof(1 + 2)>(); // expected-error{{no viable conversion from 'A<typeof (1 + 2)>' (aka 'A<int>') to 'int'}}
+int a4 = A<A<__typeof(1 + 2)>>(); // expected-error{{no viable conversion from 'A<A<typeof (1 + 2)> >' (aka 'A<A<int> >') to 'int'}}
+
+using B = A<decltype(1+2)>;
+int a5 = B(); // expected-error{{no viable conversion from 'B' (aka 'A<int>') to 'int'}}
+
+decltype(void()) (&f1)() = 0; // expected-error{{non-const lvalue reference to type 'decltype(void()) ()' (aka 'void ()') cannot bind to a temporary of type 'int'}}
+decltype(void()) (&f2)(int) = 0; // expected-error{{non-const lvalue reference to type 'decltype(void()) (int)' (aka 'void (int)') cannot bind to a temporary of type 'int'}}
+void (&f3)(decltype(1 + 2)) = 0; // expected-error{{non-const lvalue reference to type 'void (decltype(1 + 2))' (aka 'void (int)') cannot bind to a temporary of type 'int'}}
+decltype(1+2) (&f4)(double, decltype(1 + 2)) = 0; // expected-error{{non-const lvalue reference to type 'decltype(1 + 2) (double, decltype(1 + 2))' (aka 'int (double, int)') cannot bind to a temporary of type 'int'}}
+auto (&f5)() -> decltype(1+2) = 0; // expected-error{{non-const lvalue reference to type 'auto () -> decltype(1 + 2)' (aka 'auto () -> int') cannot bind to a temporary of type 'int'}}

test/Sema/pointer-addition.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -std=c11
 
 typedef struct S S; // expected-note 4 {{forward declaration of 'struct S'}}
 extern _Atomic(S*) e;
 void a(S* b, void* c) {
   void (*fp)(int) = 0;
   b++;       // expected-error {{arithmetic on a pointer to an incomplete type}}
   b += 1;    // expected-error {{arithmetic on a pointer to an incomplete type}}
   c++;       // expected-warning {{arithmetic on a pointer to void is a GNU extension}}
   c += 1;    // expected-warning {{arithmetic on a pointer to void is a GNU extension}}
   c--;       // expected-warning {{arithmetic on a pointer to void is a GNU extension}}
   c -= 1;    // expected-warning {{arithmetic on a pointer to void is a GNU extension}}
   (void) c[1]; // expected-warning {{subscript of a pointer to void is a GNU extension}}
   b = 1+b;   // expected-error {{arithmetic on a pointer to an incomplete type}}
   /* The next couple tests are only pedantic warnings in gcc */
   void (*d)(S*,void*) = a;
-  d += 1;    // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}}
-  d++;       // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}}
-  d--;       // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}}
-  d -= 1;    // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}}
-  (void)(1 + d); // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' is a GNU extension}}
+  d += 1;    // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' (aka 'void (struct S *, void *)') is a GNU extension}}
+  d++;       // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' (aka 'void (struct S *, void *)') is a GNU extension}}
+  d--;       // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' (aka 'void (struct S *, void *)') is a GNU extension}}
+  d -= 1;    // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' (aka 'void (struct S *, void *)') is a GNU extension}}
+  (void)(1 + d); // expected-warning {{arithmetic on a pointer to the function type 'void (S *, void *)' (aka 'void (struct S *, void *)') is a GNU extension}}
   e++;       // expected-error {{arithmetic on a pointer to an incomplete type}}
 }

test/SemaTemplate/class-template-id.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 template<typename T, typename U = float> struct A { };
 
 typedef A<int> A_int;
 
 typedef float FLOAT;
 
 A<int, FLOAT> *foo(A<int> *ptr, A<int> const *ptr2, A<int, double> *ptr3) {
   if (ptr)
     return ptr; // okay
   else if (ptr2)
-    return ptr2; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' with an lvalue of type 'const A<int> *'}}
+    return ptr2; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'const A<int> *'}}
   else {
-    return ptr3; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' with an lvalue of type 'A<int, double> *'}}
+    return ptr3; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'A<int, double> *'}}
   }
 }
 
 template<int I> struct B;
 
 const int value = 12;
 B<17 + 2> *bar(B<(19)> *ptr1, B< (::value + 7) > *ptr2, B<19 - 3> *ptr3) {
   if (ptr1)