Don't ask for the size of dependent integral types in template diffing

[rnk]

Summary

In the following example, we end up diffing 'A<int, 0>' against 'A<>'.

template <typename SizeType = int, SizeType = 0> struct A {};
template <typename R = A<>> R bar();
A<> &foo() { return bar(); }

It appears that we end up comparing the default argument of
'SizeType = 0' against the instantiated argument of 'int = 0'. The type
of the default argument is still dependent at this point, and this patch
bails out of the comparison at that point.

The diagnostic we ultimately give is not that great, but maybe we can
live with it:

error: non-const lvalue reference to type 'A<[...], (no argument)>'
       cannot bind to a temporary of type 'A<[...], 0>'

[rnk]

Digging back through more history, I see that Richard added the call to getTypeSize in rL230603.

[rtrieu]

So there's three or four semi-related failures around this part template diffing. I'm investigating the best way to handle these bugs.

[rtrieu]

I've fixed this issue as part of the template type diffing refactoring. r257870 was the last of the refactoring, and includes your test case in it.

[rnk]

Thanks!

lib/AST/ASTDiagnostic.cpp

static bool GetInt(ASTContext &Context, const TSTiterator &Iter,
     // from the desugared TemplateArgument, otherwise expression needs to
     // be evaluatable.
     if (Iter.isEnd() && ArgExpr->isValueDependent()) {
       switch (Iter.getDesugar().getKind()) {
         case TemplateArgument::Integral:
           Int = Iter.getDesugar().getAsIntegral();
           return true;
         case TemplateArgument::Expression:
+          // Fail if we can't extend or truncate.
+          if (IntegerType->isDependentType())
+            return false;
           ArgExpr = Iter.getDesugar().getAsExpr();
           Int = ArgExpr->EvaluateKnownConstInt(Context);
           Int = Int.extOrTrunc(Context.getTypeSize(IntegerType));
           return true;
         default:
           llvm_unreachable("Unexpected template argument kind");
       }
     } else if (ArgExpr->isEvaluatable(Context)) {
+      // Fail if we can't extend or truncate.
+      if (IntegerType->isDependentType())
+        return false;
       Int = ArgExpr->EvaluateKnownConstInt(Context);
       Int = Int.extOrTrunc(Context.getTypeSize(IntegerType));
       return true;
     }
 
     return false;
   }
 

test/Misc/diag-template-diffing.cpp

 void test() {
   BoolT<false> X;
   foo<BoolT<true>>(X);
 }
 // CHECK-ELIDE-NOTREE: no matching function for call to 'foo'
 // CHECK-ELIDE-NOTREE: candidate function [with T = BoolArgumentBitExtended::BoolT<true>] not viable: no known conversion from 'BoolT<0>' to 'BoolT<1>' for 1st argument
 }
 
+namespace DefaultNonTypeArgWithDependentType {
+// We used to crash diffing integer template arguments when the argument type
+// is dependent and default arguments were used.
+template <typename SizeType = int, SizeType = 0> struct A {};
+template <typename R = A<>> R bar();
+A<> &foo() { return bar(); }
+// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<[...], (no argument)>' cannot bind to a temporary of type 'A<[...], 0>'
+// CHECK-NOELIDE-NOTREE: error: non-const lvalue reference to type 'A<int, (no argument)>' cannot bind to a temporary of type 'A<int, 0>'
+}
+
 // CHECK-ELIDE-NOTREE: {{[0-9]*}} errors generated.
 // CHECK-NOELIDE-NOTREE: {{[0-9]*}} errors generated.
 // CHECK-ELIDE-TREE: {{[0-9]*}} errors generated.
 // CHECK-NOELIDE-TREE: {{[0-9]*}} errors generated.