scope with var NAME : TYPE := EXPR do to the with-body

The inline holder var was inserted into `procdef.localst`, so it lived
for the whole routine and a sibling `with var p ...` collided on `p`.
Push a dedicated `tblocksymtable` for the lifetime form, hand it to the
procdef on exit, and attach it to the wrapping `newblock` for debug
scoping. The simple-load detection further down already covers
localst/parast/static/global; add `blocksymtable` so the holder still
takes the direct-ref path.

`make_mangledname` walked localsymtable/parasymtable/object/recordsymtable
but bailed on `blocksymtable`, hitting IE 200204175 for an anonymous
record type declared inside `with var q : record ... end := ...`. Peel
blocksymtable layers via `blockparentst` at the top of the walk - they
are transparent for mangling.

Suffix the hidden tcsym with the line number so two consecutive
`with var p : T := (a; b) do ...` in the same routine produce distinct
asm labels.

Author: fibodevy

compiler/pstatmnt.pas

@@ -1630,6 +1630,8 @@       twithshadowcand = class
          lifetime_name : TIDString;
          lifetime_filepos : tfileposinfo;
          lifetime_tcsym : tstaticvarsym;
+         lifetime_name_suffix : string[16];
+         withblockst : tblocksymtable;
 
          procedure pushobjchild(withdef,obj:tobjectdef);
          var
@@ -1669,11 +1671,20 @@       twithshadowcand = class
          lifetime_autofree := false;
          lifetime_init := nil;
          lifetime_tcsym := nil;
+         withblockst := nil;
          hdef := nil;
          if (m_autofree in current_settings.modeswitches) and
             (current_scanner.token in [_VAR,_AUTOFREE]) then
            begin
              lifetime_filepos := current_filepos;
+             { scope the inline var (and any hidden tcsym) to the with-body
+               via a dedicated block symtable, so the same name can appear
+               in a later sibling `with var NAME` in the same routine }
+             if assigned(current_procinfo) then
+               begin
+                 withblockst := tblocksymtable.create(symtablestack.top);
+                 symtablestack.push(withblockst);
+               end;
              if current_scanner.token = _VAR then
                begin
                  { Form C:  with var NAME := [autofree] EXPR do BODY
@@ -1682,6 +1693,11 @@       twithshadowcand = class
                  if current_scanner.token <> _ID then
                    begin
                      consume(_ID);   { trigger expected-identifier error }
+                     if assigned(withblockst) then
+                       begin
+                         symtablestack.pop(withblockst);
+                         withblockst.free;
+                       end;
                      result := cerrornode.create;
                      exit;
                    end;
@@ -1711,8 +1727,13 @@       twithshadowcand = class
                          else if (current_scanner.token = _LKLAMMER) and
                                  ((hdef.typ = arraydef) or (hdef.typ = recorddef)) then
                            begin
+                             { suffix with line number so multiple sibling
+                               `with var NAME : TYPE := (...)` in the same
+                               routine don't share an asm label }
+                             system.str(lifetime_filepos.line, lifetime_name_suffix);
                              lifetime_tcsym := cstaticvarsym.create(
-                               '$with_tc_' + lifetime_name, vs_const, hdef, []);
+                               '$with_tc_' + lifetime_name + '_' + lifetime_name_suffix,
+                               vs_const, hdef, []);
                              include(lifetime_tcsym.symoptions, sp_internal);
                              symtablestack.top.insertsym(lifetime_tcsym);
                              read_typed_const(current_asmdata.asmlists[al_typedconsts],
@@ -1758,6 +1779,11 @@                                  ((hdef.typ = arraydef) or (hdef.typ = recorddef
              if not assigned(hdef) or (hdef = generrordef) then
                begin
                  if assigned(lifetime_init) then lifetime_init.free;
+                 if assigned(withblockst) then
+                   begin
+                     symtablestack.pop(withblockst);
+                     withblockst.free;
+                   end;
                  result := cerrornode.create;
                  exit;
                end;
@@ -1766,18 +1792,23 @@                                  ((hdef.typ = arraydef) or (hdef.typ = recorddef
                begin
                  Message(parser_e_autofree_requires_class);
                  if assigned(lifetime_init) then lifetime_init.free;
+                 if assigned(withblockst) then
+                   begin
+                     symtablestack.pop(withblockst);
+                     withblockst.free;
+                   end;
                  result := cerrornode.create;
                  exit;
                end;
-             { create the holder variable in the enclosing routine scope
-               (skip past any with-symtables already on the stack from
-               earlier multi-with entries). }
-             if assigned(current_procinfo) and
-                assigned(current_procinfo.procdef.localst) then
+             { create the holder variable scoped to the with-body. With
+               `withblockst` pushed, symtablestack.top is the block symtable
+               that gets popped at the end of `with`, so a sibling `with var
+               NAME` can reuse the same name. }
+             if assigned(withblockst) then
                begin
                  lifetime_var := clocalvarsym.create(lifetime_name, vs_value, hdef, []);
                  lifetime_var.register_sym;
-                 current_procinfo.procdef.localst.insertsym(lifetime_var);
+                 symtablestack.top.insertsym(lifetime_var);
                end
              else
                begin
@@ -1904,7 +1935,7 @@                                  ((hdef.typ = arraydef) or (hdef.typ = recorddef
                (
                 (tloadnode(hp).symtable=current_procinfo.procdef.localst) or
                 (tloadnode(hp).symtable=current_procinfo.procdef.parast) or
-                (tloadnode(hp).symtable.symtabletype in [staticsymtable,globalsymtable])
+                (tloadnode(hp).symtable.symtabletype in [staticsymtable,globalsymtable,blocksymtable])
                ) and
                { MacPas objects are mapped to classes, and the MacPas compilers
                  interpret with-statements with MacPas objects the same way
@@ -2097,6 +2128,19 @@                       ((p.resultdef.typ=recorddef) or
             withsymtablelist.free;
             withsymtablelist := nil;
 
+            { pop the with-var block symtable (if any) and hand it to the
+              procdef so its locals get stack space allocated; the wrapping
+              newblock keeps a reference for debug-info scoping }
+            if assigned(withblockst) then
+              begin
+                symtablestack.pop(withblockst);
+                if not assigned(current_procinfo.procdef.blocklocalsymtables) then
+                  current_procinfo.procdef.blocklocalsymtables := tfpobjectlist.create(true);
+                current_procinfo.procdef.blocklocalsymtables.add(withblockst);
+                if assigned(newblock) then
+                  tblocknode(newblock).blocksymtable := withblockst;
+              end;
+
             { FPC Unleashed: scoped-with -- rewrite any defers the body
               registered (e.g. `with X do defer Foo;` or stray defers in
               a begin..end body that wasn't already a defer-scope) so they

compiler/symdef.pas

@@ -1672,6 +1672,10 @@ implementation
         if not assigned(st) then
          internalerror(200204212);
         repeat
+          { peel transparent block-scope layers - they don't contribute
+            to the mangled name (Delphi-style inline-var scopes) }
+          while st.symtabletype=blocksymtable do
+            st:=tblocksymtable(st).blockparentst;
           { sub procedures }
           while (st.symtabletype in [localsymtable,parasymtable]) do
            begin

tests/tbs/tb9003.pp

@@ -0,0 +1,45 @@
+{ scoped-with: `with var NAME : TYPE := EXPR do` ends the var's scope at the
+  end of the with-body, so the same name can be reused in a sibling with }
+program tb9003;
+
+{$mode unleashed}
+
+uses
+  sysutils;
+
+type
+  TPoint = record
+    x, y: integer;
+  end;
+
+var
+  log: string;
+
+procedure run;
+var
+  src: TPoint;
+begin
+  with var p: TPoint := (x: 1; y: 2) do
+    log := log + IntToStr(x) + ',' + IntToStr(y) + ';';
+
+  src.x := 100;
+  src.y := 200;
+  with var p: TPoint := src do
+    log := log + IntToStr(p.x) + ',' + IntToStr(p.y) + ';';
+
+  with var q: record x, y: integer; end := (x: 5; y: 6) do
+    log := log + IntToStr(x) + ',' + IntToStr(y) + ';';
+
+  with var p: TPoint := (x: 7; y: 8) do
+    log := log + IntToStr(p.x) + ',' + IntToStr(p.y) + ';';
+end;
+
+begin
+  log := '';
+  run;
+  if log <> '1,2;100,200;5,6;7,8;' then
+    begin
+      WriteLn('FAIL: ', log);
+      Halt(1);
+    end;
+end.