- rebase to main

- add release note for __is_deducible
- implement diagnostics for bad argument types for __is_deducible

Author: hokein

clang/docs/ReleaseNotes.rst

@@ -114,6 +114,10 @@ C++20 Feature Support
   to update the ``__cpp_concepts`` macro to `202002L`. This enables
   ``<expected>`` from libstdc++ to work correctly with Clang.
 
+- Implemented the `__is_deducible` builtin to check if the template arguments of
+  a class/alias template can be deduced from a specific type,
+  [over.match.class.deduct]p4.
+
 C++23 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9156,6 +9156,10 @@ def note_inequality_comparison_to_or_assign : Note<
 def err_incomplete_type_used_in_type_trait_expr : Error<
   "incomplete type %0 used in type trait expression">;
 
+def err_deducible_non_class_or_alias_types : Error<
+   "%0 is not a class or alias template; __is_deducible only supports class or "
+    "alias templates">;
+
 // C++20 constinit and require_constant_initialization attribute
 def warn_cxx20_compat_constinit : Warning<
   "'constinit' specifier is incompatible with C++ standards before C++20">,

clang/lib/Sema/SemaExprCXX.cpp

@@ -6109,7 +6109,9 @@ static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, const TypeSourceI
                  TSTToBeDeduced->getTemplateName().getAsTemplateDecl(), RhsT,
                  Info) == TemplateDeductionResult::Success;
     }
-    // FIXME: emit a diagnostic.
+    Self.Diag(Lhs->getTypeLoc().getBeginLoc(),
+              diag::err_deducible_non_class_or_alias_types)
+        << LhsT << Lhs->getTypeLoc().getSourceRange();
     return false;
   }
     default: llvm_unreachable("not a BTT");

clang/lib/Sema/SemaTemplate.cpp

@@ -3055,19 +3055,6 @@ void DeclareImplicitDeductionGuidesForTypeAlias(
           RequireClause);
 
       auto *GG = cast<CXXDeductionGuideDecl>(FPrime);
-      // Substitute new template parameters into requires-clause if present.
-      Expr *RequiresClause =
-          transformRequireClause(SemaRef, F, TemplateArgsForBuildingFPrime);
-      // FIXME: implement the is_deducible constraint per C++
-      // [over.match.class.deduct]p3.3:
-      //    ... and a constraint that is satisfied if and only if the arguments
-      //    of A are deducible (see below) from the return type.
-      auto *FPrimeTemplateParamList = TemplateParameterList::Create(
-          Context, AliasTemplate->getTemplateParameters()->getTemplateLoc(),
-          AliasTemplate->getTemplateParameters()->getLAngleLoc(),
-          FPrimeTemplateParams,
-          AliasTemplate->getTemplateParameters()->getRAngleLoc(),
-          /*RequiresClause=*/RequiresClause);
 
       buildDeductionGuide(SemaRef, AliasTemplate, FPrimeTemplateParamList,
                           GG->getCorrespondingConstructor(),

clang/lib/Sema/SemaTemplateDeduction.cpp

@@ -3256,8 +3256,7 @@ Sema::DeduceTemplateArgumentsFromType(TemplateDecl *TD, QualType FromType,
                 ->getUnderlyingType()
                 .getCanonicalType();
   } else {
-    // FIXME: emit a diagnostic, we only only support alias and class templates.
-    return TemplateDeductionResult::Invalid;
+    assert(false && "Expected a class or alias template");
   }
 
   // Unevaluated SFINAE context.

clang/test/SemaCXX/cxx20-ctad-type-alias.cpp

@@ -111,7 +111,7 @@ struct Foo {
 template <typename X, int Y>
 using Bar = Foo<X, sizeof(X)>; // expected-note {{candidate template ignored: couldn't infer template argument 'X'}} \
                                // expected-note {{candidate template ignored: constraints not satisfied [with X = int]}} \
-                               // expected-note {{because '__is_deducible(Bar, Foo<int, 4UL>)' evaluated to false}}
+                               // expected-note {{because '__is_deducible}}
 
 
 Bar s = {{1}}; // expected-error {{no viable constructor or deduction guide }}

clang/test/SemaCXX/type-traits-is-deducible.cpp

@@ -1,5 +1,4 @@
 // RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s 
-// expected-no-diagnostics
 
 template<typename T>
 struct Foo {};
@@ -45,3 +44,12 @@ template <class T, T N>
 using AArrary = int[N];
 static_assert (__is_deducible(AArrary, int[42]));
 static_assert (!__is_deducible(AArrary, double[42]));
+
+// error cases
+bool e1 = __is_deducible(int, int); // expected-error {{'int' is not a class or alias template; __is_deducible only supports class or alias templates}}
+template<typename T> T func();
+bool e2 = __is_deducible(func, int); // expected-error {{type name requires a specifier or qualifier}} \
+                                        expected-error {{type-id cannot have a name}}
+template<typename T> T var = 1;
+bool e3 = __is_deducible(var, int); // expected-error {{type name requires a specifier or qualifier}} \
+                                       expected-error {{type-id cannot have a name}}

clang/test/SemaTemplate/deduction-guide.cpp

@@ -275,11 +275,13 @@ using AFoo = Foo<G<U>>;
 // CHECK-LABEL: Dumping <deduction guide for AFoo>
 // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for AFoo>
 // CHECK-NEXT: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 0 U
-// CHECK-NEXT: |-ParenExpr {{.*}} 'bool'
-// CHECK-NEXT: | `-BinaryOperator {{.*}} 'bool' '=='
-// CHECK-NEXT: |   |-UnaryExprOrTypeTraitExpr {{.*}} 'G<type-parameter-0-0>'
-// CHECK-NEXT: |   `-ImplicitCastExpr {{.*}}
-// CHECK-NEXT: |     `-IntegerLiteral {{.*}}
+// CHECK-NEXT: |-BinaryOperator {{.*}} '&&'
+// CHECK-NEXT: | |-ParenExpr {{.*}} 'bool'
+// CHECK-NEXT: | | `-BinaryOperator {{.*}} 'bool' '=='
+// CHECK-NEXT: | |   |-UnaryExprOrTypeTraitExpr {{.*}} 'G<type-parameter-0-0>'
+// CHECK-NEXT: | |   `-ImplicitCastExpr {{.*}}
+// CHECK-NEXT: | |     `-IntegerLiteral {{.*}}
+// CHECK-NEXT: | `-TypeTraitExpr {{.*}} 'bool' __is_deducible
 // CHECK-NEXT: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for AFoo> 'auto (G<type-parameter-0-0>) -> Foo<G<type-parameter-0-0>>'
 // CHECK-NEXT: | `-ParmVarDecl {{.*}} 'G<type-parameter-0-0>'
 // CHECK-NEXT: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for AFoo> 'auto (G<int>) -> Foo<G<int>>' implicit_instantiation