diagnose auto deduction from void more specifically. [GH #27]

Author: mohitmishra786

src/Changes

@@ -11,6 +11,18 @@ example, with --clang_version 230100:
   #pragma clang diagnostic push
 
 was previously recorded as "clangdiagnostic push".  That is now fixed.
+10/4/26  [GH #27]
+Clearer diagnostic when auto is deduced from void
+
+Deducing "auto" from a void expression failed with the generic message
+"cannot deduce \"auto\" type".  The diagnostic now says that the type is
+void.  For example:
+
+  void g();
+  auto x = g();
+
+decltype(auto) is unchanged: deduction succeeds and the incomplete-type
+diagnostic is issued.
 
 
 10/1/26  [GH #197]

src/error_msg.txt

@@ -3679,5 +3679,6 @@ ec_exp_interpolator;;"expected an interpolator (\"\\[\", \"\\[:\", \"\\{\", \"\\
 ec_interpolated_id_is_not_identifier;;"%sq does not spell an identifier"
 ec_interpolated_operand_is_not_token_sequence;;"the operand of a \"\\{...}\" interpolator is not a token sequence"
 ec_tag_redefined_differently;;"this declaration of %n does not declare the same type as the declaration %p"
+ec_cannot_deduce_auto_from_void;;"cannot deduce \"auto\" type from type \"void\""
  ###############################################################################
 

src/expr.c

@@ -937,6 +937,31 @@ initializer lists can have their braces ignored.
 }  /* ignore_braces_for_placeholder_deduction */
 
 
+static an_error_code error_for_failed_auto_deduction(
+                                           a_boolean  is_decltype_auto,
+                                           a_type_ptr initializer_type)
+/*
+Return the diagnostic for a failed placeholder-type deduction.
+is_decltype_auto is TRUE when the placeholder is decltype(auto).
+initializer_type is the type of the initializer, or NULL when that type is
+not available (for example, a braced-init-list).
+*/
+{
+  an_error_code result;
+
+  if (is_decltype_auto) {
+    result = ec_cannot_deduce_decltype_auto_type;
+  } else if (initializer_type != NULL && is_void_type(initializer_type)) {
+    /* void is not an object type, so deduction cannot succeed.  Name that
+       type instead of using the generic message. */
+    result = ec_cannot_deduce_auto_from_void;
+  } else {
+    result = ec_cannot_deduce_auto_type;
+  }  /* if */
+  return result;
+}  /* error_for_failed_auto_deduction */
+
+
 void prescan_initializer_for_auto_type_deduction(
                                          a_decl_parse_state *dps,
                                          a_boolean          parenthesized_init)
@@ -1178,12 +1203,20 @@ swallowed); otherwise, it's "="-form or "{...}" form.
         dps->deduced_auto_type = unknown_type();
       } else {
         /* Deduction failed. */
-        expr_pos_error(dps->has_deducible_class_templ_args ?
-                         ec_cannot_deduce_class_template_arguments :
-                       (an_error_code)(dps->decltype_auto_specifier_seen ?
-                         ec_cannot_deduce_decltype_auto_type :
-                         ec_cannot_deduce_auto_type),
-                       &dps->auto_pos);
+        { an_error_code  err_code;
+          a_type_ptr     init_type = NULL;
+
+          if (dps->has_deducible_class_templ_args) {
+            err_code = ec_cannot_deduce_class_template_arguments;
+          } else {
+            if (icp != NULL && is_expression_component(icp)) {
+              init_type = operand_of_arg_list_elem(icp)->type;
+            }  /* if */
+            err_code = error_for_failed_auto_deduction(
+                                 dps->decltype_auto_specifier_seen, init_type);
+          }  /* if */
+          expr_pos_error(err_code, &dps->auto_pos);
+        }
         dps->specifiers_type = dps->deduced_auto_type = dps->type =
                                                                  error_type();
         dps->has_deduced_type = FALSE;
@@ -48752,9 +48785,9 @@ the type of element_operand and sets the variable type to the deduced type.
          type as it is. */
     } else {
       /* Deduction failed. */
-      pos_error(iterator->declared_with_decltype_auto ?
-                  ec_cannot_deduce_decltype_auto_type :
-                  ec_cannot_deduce_auto_type,
+      pos_error(error_for_failed_auto_deduction(
+                                       iterator->declared_with_decltype_auto,
+                                       element_operand->type),
                 &iterator->source_corresp.decl_position);
       iterator->type = error_type();
     }  /* if */
@@ -52389,7 +52422,9 @@ are left unaffected).
         is_decltype_auto_case = TRUE;
       }  /* if */
     } else {
-      pos_error(ec_cannot_deduce_auto_type, diag_pos);
+      /* The declared type is not a plain "auto" (for example, "auto *").
+         void still cannot be used to deduce it. */
+      pos_error(ec_cannot_deduce_auto_from_void, diag_pos);
       deduced_return_type = error_type();
     }  /* if */
     if (keep_placeholder) {
@@ -52489,8 +52524,8 @@ type with the type of return_op.
     /* The type is still dependent, so leave the return type as it is. */
   } else {
     /* Deduction failed. */
-    pos_error(is_decltype_auto ? ec_cannot_deduce_decltype_auto_type
-                               : ec_cannot_deduce_auto_type,
+    pos_error(error_for_failed_auto_deduction(is_decltype_auto,
+                                              return_op->type),
               &return_op->position);
     *return_type = error_type();
     rout_type->variant.routine.return_type = *return_type;

tests/tests/changes/.GH27.rto/default.1.1.txt

@@ -0,0 +1,38 @@
+fe_only -DTEST_NUMBER=1 --c++23 Test_name.c
+"Test_name.c", line 22: error: cannot deduce "auto" type from type "void"
+    auto opts = Args{}.parse();
+    ^
+
+"Test_name.c", line 23: error: cannot deduce "auto" type from type "void"
+    auto x = g();
+    ^
+
+"Test_name.c", line 24: error: cannot deduce "auto" type from type "void"
+    auto &&r = g();
+    ^
+
+"Test_name.c", line 25: error: cannot deduce "auto" type from type "void"
+    const auto c = g();
+          ^
+
+"Test_name.c", line 26: error: cannot deduce "auto" type from type "void"
+    auto *p = g();
+    ^
+
+"Test_name.c", line 27: error: cannot deduce "auto" type from type "void"
+    auto *q = new auto(g());
+                  ^
+
+"Test_name.c", line 27: error: cannot deduce "auto" type
+    auto *q = new auto(g());
+    ^
+
+"Test_name.c", line 28: error: incomplete type "void" is not allowed
+    decltype(auto) d = g();
+                   ^
+
+"Test_name.c", line 33: error: cannot deduce "auto" type from type "void"
+    return g();
+           ^
+
+9 errors detected in the compilation of "Test_name.c".

tests/tests/changes/GH27.sft.cpp

@@ -0,0 +1,34 @@
+//type:fn
+//options_all:--c++23
+//remark:[GH #27] Clearer diagnostic when auto deduces to void
+// 10/4/26  [GH #27]
+//
+// Deducing auto from a void initializer used to say only
+// "cannot deduce \"auto\" type".
+
+struct Clap {
+  template <typename Spec>
+  auto parse(this Spec const& spec) {
+  }
+};
+
+struct Args : Clap {
+};
+
+void g();
+
+void f()
+{
+  auto opts = Args{}.parse();
+  auto x = g();
+  auto &&r = g();
+  const auto c = g();
+  auto *p = g();
+  auto *q = new auto(g());
+  decltype(auto) d = g();
+}
+
+auto *h()
+{
+  return g();
+}