Add NO_INIT middle-declarator test and re-add declarator_no_init with typedef guard

Co-authored-by: michael-schwarz <13812333+michael-schwarz@users.noreply.github.com>

Author: Copilot

src/frontc/cparser.mly

@@ -78,6 +78,10 @@ let smooth_expression lst =
 
 let currentFunctionName = ref "<outside any function>"
 
+(* Set to true while parsing a typedef declaration's declarator list, so that
+   declarator_no_init knows not to call add_identifier for typedef names. *)
+let is_typedef_decl = ref false
+
 let announceFunctionName ((n, decl, _, _):name) =
   !Lexerhack.add_identifier n;
   (* Start a context that includes the parameter names and the whole body.
@@ -115,6 +119,7 @@ let applyPointer (ptspecs: attribute list list) (dt: decl_type)
   loop ptspecs
 
 let doDeclaration (loc: cabsloc) (specs: spec_elem list) (nl: init_name list) : definition =
+  is_typedef_decl := false;
   if isTypedef specs then begin
     (* Tell the lexer about the new type names *)
     List.iter (fun ((n, _, _, _), _) -> !Lexerhack.add_type n) nl;
@@ -123,14 +128,8 @@ let doDeclaration (loc: cabsloc) (specs: spec_elem list) (nl: init_name list) :
     if nl = [] then
       ONLYTYPEDEF (specs, loc)
     else begin
-      (* For NO_INIT declarators, add_identifier is called here after parsing.
-         For initialized declarators, it was already called in declarator_init_start
-         before the initializer was parsed (C11 6.2.1.7). *)
-      List.iter (fun ((n, _, _, _), init) ->
-        match init with
-        | NO_INIT -> !Lexerhack.add_identifier n
-        | _ -> ()
-      ) nl;
+      (* add_identifier is called in declarator_no_init / declarator_init_start as each
+         declarator is parsed (C11 6.2.1.7), so nothing to do here. *)
       DECDEF ((specs, nl), loc)
     end
 
@@ -394,7 +393,7 @@ let transformOffsetOf (speclist, dtype) member =
 
 %type <Cabs.init_name> init_declarator
 %type <Cabs.init_name list> init_declarator_list
-%type <Cabs.name> declarator declarator_init_start
+%type <Cabs.name> declarator declarator_no_init declarator_init_start
 %type <Cabs.name * expression option> field_decl
 %type <(Cabs.name * expression option) list> field_decl_list
 %type <string * Cabs.decl_type> direct_decl
@@ -1042,11 +1041,23 @@ init_declarator_attr:
 
 ;
 init_declarator:                             /* ISO 6.7 */
-    declarator                          { ($1, NO_INIT) }
+    declarator_no_init                  { ($1, NO_INIT) }
 |   declarator_init_start init_expression location
                                         { let (n, d, a, l) = $1 in ((n, d, a, joinLoc l $3), $2) }
 ;
 
+/* (* Parses "declarator" (without initializer) and immediately adds the declared name
+      as a variable identifier in the lexer hack, for non-typedef declarations only,
+      so that subsequent declarators in the same declaration see the name as an
+      identifier, not as a type (C11 6.2.1.7: scope begins just after the completion
+      of its declarator). For typedef declarations (is_typedef_decl = true), the name
+      is registered later via add_type in doDeclaration. *) */
+declarator_no_init:
+    declarator                          { let (n, _, _, _) = $1 in
+                                          if not !is_typedef_decl then !Lexerhack.add_identifier n;
+                                          $1 }
+;
+
 /* (* Parses "declarator =" and adds the declared name as a variable identifier
       in the lexer hack, so that in the initializer the name shadows any typedef
       with the same name (C11 6.2.1.7: scope begins just after the completion of the
@@ -1057,7 +1068,7 @@ declarator_init_start:
 
 decl_spec_list_common:                  /* ISO 6.7 */
                                         /* ISO 6.7.1 */
-|   TYPEDEF decl_spec_list_opt          { SpecTypedef :: $2, $1  }
+|   TYPEDEF decl_spec_list_opt          { is_typedef_decl := true; SpecTypedef :: $2, $1  }
 |   EXTERN decl_spec_list_opt           { SpecStorage EXTERN :: $2, $1 }
 |   STATIC  decl_spec_list_opt          { SpecStorage STATIC :: $2, $1 }
 |   AUTO   decl_spec_list_opt           { SpecStorage AUTO :: $2, $1 }

test/small1/typedef_varname.c

@@ -2,6 +2,7 @@
    A variable with the same name as a typedef should shadow it in its initializer,
    per C11 6.2.1.7: "Any other identifier has scope that begins just after the
    completion of its declarator." */
+#include "testharness.h"
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -19,7 +20,24 @@ typedef struct rax {
     uint64_t numnodes;
 } rax;
 
+typedef int mytype;
+
 int main() {
   rax *rax = malloc(sizeof(*rax)); /* variable rax shadows typedef rax in initializer */
-  return rax == 0;
+  if (rax == 0) E(1);
+  free(rax);
+
+  /* NO_INIT variable in the middle of a declaration list shadows a typedef.
+     After "mytype a = 1, mytype", the name "mytype" is an identifier (variable).
+     So "b = sizeof mytype" (without parens) is only valid when mytype is a variable
+     (types require parens: "sizeof(type)").  This fails to parse without the fix. */
+  {
+    mytype a = 1, mytype, b = sizeof mytype;
+    mytype = 5;
+    if (a != 1) E(2);
+    if (mytype != 5) E(3);
+    if (b != sizeof(int)) E(4);
+  }
+
+  SUCCESS;
 }