report an incomplete type when plain auto is deduced from void. [GH #27]

Author: mohitmishra786

src/Changes

@@ -1,15 +1,16 @@
-10/4/26  [GH #27]
-Clearer diagnostic when auto is deduced from void
+10/6/26  [GH #27]
+Clearer diagnostic when auto is deduced from an incomplete type
 
-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:
+Deducing a plain "auto" (including cv-qualified "auto") from void or another
+incomplete type used to fail with "cannot deduce \"auto\" type".  The type
+is now deduced, and the usual incomplete-type diagnostic is issued, as it
+already is for decltype(auto).  For example:
 
   void g();
-  auto x = g();
+  auto x = g();          // incomplete type "void" is not allowed
+  auto *p = g();         // cannot deduce "auto" type
 
-decltype(auto) is unchanged: deduction succeeds and the incomplete-type
-diagnostic is issued.
+Forms that are not a plain "auto", such as "auto *", still fail deduction.
 
 
 10/1/26  [GH #197]

src/error_msg.txt

@@ -3679,6 +3679,5 @@ 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,31 +937,6 @@ 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)
@@ -1203,20 +1178,12 @@ swallowed); otherwise, it's "="-form or "{...}" form.
         dps->deduced_auto_type = unknown_type();
       } else {
         /* Deduction failed. */
-        { 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);
-        }
+        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);
         dps->specifiers_type = dps->deduced_auto_type = dps->type =
                                                                  error_type();
         dps->has_deduced_type = FALSE;
@@ -48785,9 +48752,9 @@ the type of element_operand and sets the variable type to the deduced type.
          type as it is. */
     } else {
       /* Deduction failed. */
-      pos_error(error_for_failed_auto_deduction(
-                                       iterator->declared_with_decltype_auto,
-                                       element_operand->type),
+      pos_error(iterator->declared_with_decltype_auto ?
+                  ec_cannot_deduce_decltype_auto_type :
+                  ec_cannot_deduce_auto_type,
                 &iterator->source_corresp.decl_position);
       iterator->type = error_type();
     }  /* if */
@@ -52422,9 +52389,7 @@ are left unaffected).
         is_decltype_auto_case = TRUE;
       }  /* if */
     } else {
-      /* 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);
+      pos_error(ec_cannot_deduce_auto_type, diag_pos);
       deduced_return_type = error_type();
     }  /* if */
     if (keep_placeholder) {
@@ -52524,8 +52489,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(error_for_failed_auto_deduction(is_decltype_auto,
-                                              return_op->type),
+    pos_error(is_decltype_auto ? ec_cannot_deduce_decltype_auto_type
+                               : ec_cannot_deduce_auto_type,
               &return_op->position);
     *return_type = error_type();
     rout_type->variant.routine.return_type = *return_type;

src/overload.c

@@ -65,7 +65,8 @@ static a_boolean adjust_deduction_pair(
                                     a_template_arg_ptr   template_arg_list,
                                     a_type_ptr           *qc_param_type,
                                     a_type_ptr           *qc_arg_type,
-                                    a_boolean            *consider_nondeduced);
+                                    a_boolean            *consider_nondeduced,
+                                    a_boolean            allow_incomplete_arg);
 static a_boolean check_narrowing_conversion(an_operand  *source_operand,
                                             a_type_ptr  dest_type,
                                             a_boolean   check_enum_target,
@@ -1485,7 +1486,8 @@ from previous arguments; in the standard case, it is always NULL.
                                   (an_operand *)NULL, templ_params,
                                   (a_template_arg *)NULL,
                                   (a_type_ptr*)NULL, (a_type_ptr*)NULL,
-                                  (a_boolean *)NULL) &&
+                                  (a_boolean *)NULL,
+                                  /*allow_incomplete_arg=*/FALSE) &&
             tentatively_matches_template_type(local_arg_type,
                                               local_param_type,
                                               templ_params,
@@ -4272,7 +4274,8 @@ static a_boolean adjust_deduction_pair(
                                      a_template_arg_ptr   template_arg_list,
                                      a_type_ptr           *qc_param_type,
                                      a_type_ptr           *qc_arg_type,
-                                     a_boolean            *consider_nondeduced)
+                                     a_boolean            *consider_nondeduced,
+                                     a_boolean            allow_incomplete_arg)
 /*
 Adjust the types *p_param_type (a parameter type of a function template or a
 type involving the "auto" type specifier) and *p_arg_type (the type of the
@@ -4295,7 +4298,10 @@ are not removed.  If consider_nondeduced is non-NULL and the reason for
 failure is that an indefinite function matches several ways, return
 *consider_nondeduced TRUE.  template_arg_list is used in some nonstandard
 modes to introduce knowledge from previous arguments; in the standard case,
-it is always NULL.
+it is always NULL.  allow_incomplete_arg is TRUE when deducing a plain
+"auto" (not, for example, "auto *").  In that case an incomplete argument
+type, including void, is left for deduction so the caller can diagnose the
+incomplete type instead of reporting a deduction failure.
 */
 {
   a_boolean   adjustment_okay = FALSE, indefinite_function_designator = FALSE;
@@ -4402,8 +4408,13 @@ it is always NULL.
     if (is_incomplete_type(arg_type) && !is_managed_nullptr_type(arg_type)) {
       /* Although the managed (C++/CLI) nullptr type is incomplete and
          cannot be used as the type of an object, for example, the Microsoft
-         compiler allows it as a template argument. */
-      goto done;
+         compiler allows it as a template argument.  A plain "auto" variable
+         is also allowed through: the type is deduced, and the incomplete-type
+         diagnostic is issued for the variable (the same diagnostic as for
+         decltype(auto)).  "auto *" and similar forms still fail deduction. */
+      if (!(allow_incomplete_arg && is_template_param_type(param_type))) {
+        goto done;
+      }  /* if */
     }  /* if */
   }  /* if */
   /* Return the adjusted types at this point as the types that can be used to
@@ -4621,7 +4632,8 @@ deduction was successful: some cases are treated as "nondeduced contexts").
                                elem_operand,
                                templ_params, *template_arg_list,
                                &qc_param_type, &qc_arg_type,
-                               &consider_nondeduced)) {
+                               &consider_nondeduced,
+                               /*allow_incomplete_arg=*/FALSE)) {
       if (consider_nondeduced) continue;
       deduction_okay = FALSE;
       break;
@@ -4775,7 +4787,8 @@ deduction succeeds, FALSE if it fails.
     if (!adjust_deduction_pair(&param_type, &arg_type, operand,
                                templ_params, *template_arg_list,
                                &qc_param_type, &qc_arg_type,
-                               &consider_nondeduced)) {
+                               &consider_nondeduced,
+                               /*allow_incomplete_arg=*/FALSE)) {
       if (consider_nondeduced) {
         /* The argument is an indefinite function that can match in more than
            one way.  Keep going without adding anything to the template
@@ -31238,7 +31251,8 @@ TRUE and FALSE is returned.
       if (!adjust_deduction_pair(&type, &arg_type, initializer_operand,
                                  templ_param, (a_template_arg *)NULL,
                                  &qc_param_type, &qc_arg_type,
-                                 (a_boolean *)NULL)) {
+                                 (a_boolean *)NULL,
+                                 /*allow_incomplete_arg=*/TRUE)) {
         okay = FALSE;
       } else if (!deduce_from_one_pair(type, arg_type,
                                        qc_param_type, qc_arg_type,

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

@@ -1,38 +1,30 @@
 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 27: error: incomplete type "void" is not allowed
+    auto v1 = void();
+         ^
 
-"Test_name.c", line 23: error: cannot deduce "auto" type from type "void"
-    auto x = g();
-    ^
+"Test_name.c", line 28: error: incomplete type "void" is not allowed
+    decltype(auto) v2 = void();
+                   ^
 
-"Test_name.c", line 24: error: cannot deduce "auto" type from type "void"
-    auto &&r = g();
-    ^
+"Test_name.c", line 29: error: incomplete type "Incomplete" is not allowed
+    auto v3 = getIncomplete();
+         ^
 
-"Test_name.c", line 25: error: cannot deduce "auto" type from type "void"
-    const auto c = g();
-          ^
+"Test_name.c", line 30: error: incomplete type "void" is not allowed
+    auto opts = Args{}.parse();
+         ^
 
-"Test_name.c", line 26: error: cannot deduce "auto" type from type "void"
-    auto *p = g();
+"Test_name.c", line 32: error: cannot deduce "auto" type
+    auto *v4 = void();
     ^
 
-"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 33: error: cannot deduce "auto" type
+    auto *v5 = 1;
     ^
 
-"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();
-           ^
+"Test_name.c", line 34: error: cannot deduce "auto" type
+    auto *p = g();
+    ^
 
-9 errors detected in the compilation of "Test_name.c".
+7 errors detected in the compilation of "Test_name.c".

tests/tests/changes/GH27.sft.cpp

@@ -1,10 +1,15 @@
 //type:fn
 //options_all:--c++23
 //remark:[GH #27] Clearer diagnostic when auto deduces to void
-// 10/4/26  [GH #27]
+// 10/6/26  [GH #27]
 //
-// Deducing auto from a void initializer used to say only
-// "cannot deduce \"auto\" type".
+// A plain auto deduced from void or another incomplete type gets the
+// incomplete-type diagnostic, matching decltype(auto).  auto * still
+// fails deduction.
+
+struct Incomplete;
+
+struct Incomplete &getIncomplete();
 
 struct Clap {
   template <typename Spec>
@@ -19,16 +24,12 @@ void g();
 
 void f()
 {
+  auto v1 = void();
+  decltype(auto) v2 = void();
+  auto v3 = getIncomplete();
   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();
+  auto *v4 = void();
+  auto *v5 = 1;
+  auto *p = g();
 }

tests/tests/imported/clang/cpp/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/.p2-1z.rto/default.1.1.txt

@@ -12,8 +12,8 @@ fe_only -DTEST_NUMBER=1 --clang -tused -e 200 --no_wrap_diagnostics --clang_vers
     ^
           detected during instantiation of "auto d<k>() [with k=0]" at line 41
 
-"Test_name.c", line 46: error: cannot deduce "auto" type
+"Test_name.c", line 46: error: incomplete type "void" is not allowed
   auto e = []{ if constexpr (false) return 0; }(); // expected-error {{variable has incomplete type 'void'}}
-  ^
+       ^
 
 2 errors detected in the compilation of "Test_name.c".

tests/tests/imported/clang/cpp/CXX/expr/expr.prim/expr.prim.lambda/.p11-1y.rto/default.1.1.txt

@@ -31,7 +31,7 @@ fe_only -DTEST_NUMBER=1 --clang -tused -e 200 --no_wrap_diagnostics --clang_vers
   auto bad_init_3 = [&a(void_fn())] {}; // expected-error {{cannot form a reference to 'void'}}
                       ^
 
-"Test_name.c", line 51: error: cannot deduce "auto" type
+"Test_name.c", line 51: error: incomplete type "void" is not allowed
   auto bad_init_4 = [a(void_fn())] {}; // expected-error {{has incomplete type 'void'}}
                      ^
 

tests/tests/imported/clang/cpp/CXX/stmt.stmt/stmt.iter/stmt.ranged/.p1.rto/default.1.1.txt

@@ -127,10 +127,6 @@ fe_only -DTEST_NUMBER=1 --clang -tused -e 200 --no_wrap_diagnostics --clang_vers
     for (auto u : NoEnd()) { // expected-error {{no viable 'end' function available}}
                   ^
 
-"Test_name.c", line 180: error: cannot deduce "auto" type
-    for (auto u : NoIncr()) { // expected-error {{arithmetic on a pointer to void}}\
-              ^
-
 "Test_name.c", line 180: error: incomplete type "void" is not allowed
     for (auto u : NoIncr()) { // expected-error {{arithmetic on a pointer to void}}\
                           ^
@@ -305,4 +301,4 @@ fe_only -DTEST_NUMBER=1 --clang -tused -e 200 --no_wrap_diagnostics --clang_vers
                 ^
           detected during instantiation of "void rdar13712739::foo(const T &) [with T=int]" at line 290
 
-55 errors detected in the compilation of "Test_name.c".
+54 errors detected in the compilation of "Test_name.c".

tests/tests/imported/clang/cpp/CXX/stmt.stmt/stmt.iter/stmt.ranged/.p1.rto/default.2.1.txt

@@ -127,10 +127,6 @@ fe_only -DTEST_NUMBER=2 --clang -tused -e 200 --no_wrap_diagnostics --clang_vers
     for (auto u : NoEnd()) { // expected-error {{no viable 'end' function available}}
                   ^
 
-"Test_name.c", line 180: error: cannot deduce "auto" type
-    for (auto u : NoIncr()) { // expected-error {{arithmetic on a pointer to void}}\
-              ^
-
 "Test_name.c", line 180: error: incomplete type "void" is not allowed
     for (auto u : NoIncr()) { // expected-error {{arithmetic on a pointer to void}}\
                           ^
@@ -305,4 +301,4 @@ fe_only -DTEST_NUMBER=2 --clang -tused -e 200 --no_wrap_diagnostics --clang_vers
                 ^
           detected during instantiation of "void rdar13712739::foo(const T &) [with T=int]" at line 290
 
-55 errors detected in the compilation of "Test_name.c".
+54 errors detected in the compilation of "Test_name.c".