LuaDecompClosure.inc

function TDecompiler.IsSelfRefClosure(Node: PSSANode): Boolean;
var
  SubProto: PProto;
  NUps, I, PseudoPC: Integer;
  Inst: TInstruction;
  Op: TOpCode;
  B: Integer;
begin
  Result := False;
  if (Node = nil) or (Node^.Kind <> SSA_CLOSURE) then Exit;
  if (Node^.ConstIdx < 0) or (Node^.ConstIdx >= Length(FProto^.P)) then Exit;

  SubProto := FProto^.P[Node^.ConstIdx];
  NUps := SubProto^.NUps;
  if NUps = 0 then Exit;

  if FProto^.LuaVersion >= $52 then begin
    { 5.2+: upvalue descriptors are in SubProto^.UpvalDescs }
    for I := 0 to NUps - 1 do begin
      if (I < Length(SubProto^.UpvalDescs)) and
         SubProto^.UpvalDescs[I].InStack and
         (SubProto^.UpvalDescs[I].Idx = Node^.Dest.Reg) then begin
        Result := True;
        Exit;
      end;
    end;
  end else begin
    { 5.1: scan pseudo-instructions after CLOSURE }
    for I := 0 to NUps - 1 do begin
      PseudoPC := Node^.PC + 1 + I;
      if PseudoPC >= Length(FProto^.Code) then Continue;
      Inst := FProto^.Code[PseudoPC];
      Op := GET_OPCODE(Inst);
      B := GETARG_B(Inst);
      { If a MOVE pseudo-instruction binds to the CLOSURE's own destination register }
      if (Op = OP_MOVE) and (B = Node^.Dest.Reg) then begin
        Result := True;
        Exit;
      end;
    end;
  end;
end;

{ ======================================================================
  ResolveUpvalNames - read pseudo-instructions after CLOSURE to map child
  upvalues to parent register/upvalue names (for stripped bytecode)
  ====================================================================== }

function TDecompiler.ResolveUpvalNames(ClosurePC, SubProtoIdx: Integer): TAnsiStringArray;
var
  SubProto: PProto;
  NUps, I, PseudoPC, B, ScanPC, J: Integer;
  Inst, ScanInst: TInstruction;
  Op, ScanOp: TOpCode;
  NameFromExpr: Boolean;
  Name: AnsiString;
  InStack: Boolean;

  function IsSafeUpvalueName(const S: AnsiString): Boolean;
  var
    P, StartPos: Integer;
    Part: AnsiString;
  begin
    Result := False;
    if S = '' then Exit;
    if IsValidLuaIdent(S) then begin
      Result := True;
      Exit;
    end;
    { Accept dotted identifier paths (module.field), but reject literals and
      general expressions. Upvalue names are emitted as lvalues/table bases;
      using a cached string literal like "pkg.mod" would generate invalid Lua
      when later field accesses append ".name". }
    StartPos := 1;
    P := 1;
    while P <= Length(S) + 1 do begin
      if (P > Length(S)) or (S[P] = '.') then begin
        Part := Copy(S, StartPos, P - StartPos);
        if not IsValidLuaIdent(Part) then Exit;
        StartPos := P + 1;
      end
      else if not (S[P] in ['A'..'Z', 'a'..'z', '0'..'9', '_', '.']) then
        Exit;
      Inc(P);
    end;
    Result := True;
  end;
begin
  SetLength(Result, 0);
  if (SubProtoIdx < 0) or (SubProtoIdx >= Length(FProto^.P)) then Exit;
  SubProto := FProto^.P[SubProtoIdx];
  NUps := SubProto^.NUps;
  if NUps = 0 then Exit;

  { 5.2+: upvalue descriptors are stored in the proto, no pseudo-instructions }
  if FProto^.LuaVersion >= $52 then begin
    SetLength(Result, NUps);
    for I := 0 to NUps - 1 do begin
      if I >= Length(SubProto^.UpvalDescs) then begin
        Result[I] := '_upval' + IntToStr(I);
        Continue;
      end;
      InStack := SubProto^.UpvalDescs[I].InStack;
      B := SubProto^.UpvalDescs[I].Idx;
      if InStack then begin
        { Upvalue captures parent register B }
        { Check for self-reference }
        if B = GETARG_A(FProto^.Code[ClosurePC]) then begin
          Result[I] := 'func_' + IntToStr(SubProtoIdx);
          Continue;
        end;
        Result[I] := LocalName(B, ClosurePC);
      end else begin
        { Upvalue copies parent upvalue B }
        Result[I] := UpvalName(B);
      end;
    end;
    Exit;
  end;

  { 5.1: scan pseudo-instructions after CLOSURE }
  SetLength(Result, NUps);
  for I := 0 to NUps - 1 do begin
    PseudoPC := ClosurePC + 1 + I;
    if PseudoPC >= Length(FProto^.Code) then begin
      Result[I] := '_upval' + IntToStr(I);
      Continue;
    end;
    Inst := FProto^.Code[PseudoPC];
    Op := GET_OPCODE(Inst);
    B := GETARG_B(Inst);

    if Op = OP_MOVE then begin
      { Check for self-reference: upvalue binds to the CLOSURE's own dest register }
      if B = GETARG_A(FProto^.Code[ClosurePC]) then begin
        { Self-referencing closure - use a generated function name }
        Name := 'func_' + IntToStr(SubProtoIdx);
        Result[I] := Name;
        Continue;
      end;

      { Upvalue I binds to parent register B.
        First check FExprStr: if the register was a closure that was cached
        as func_N or a local name, use that cached name.
        IMPORTANT: Only accept short identifier-like names (e.g., "func_N",
        "t50", local variable names).  Skip full expressions like function
        bodies or compound expressions that were cached by NodeExpr. }
      Name := '';
      { Find the SSA definition of register B at or before ClosurePC.
        Only look at REAL definitions (CLOSURE, NEWTABLE, GETTABLE, etc.),
        skip NOP pseudo-instructions (upvalue binding hints) as they create
        spurious SSA versions of R(A) that may have stale FExprStr.
        Also skip SETTABLE (writes to a table slot, not the register itself). }
      for J := 0 to High(FSF^.AllNodes) do begin
        if (FSF^.AllNodes[J]^.Kind <> SSA_NOP) and
           (FSF^.AllNodes[J]^.Kind <> SSA_SETTABLE) and
           (FSF^.AllNodes[J]^.Kind <> SSA_SETGLOBAL) and
           (FSF^.AllNodes[J]^.Kind <> SSA_SETUPVAL) and
           (FSF^.AllNodes[J]^.Dest.Reg = B) and
           (FSF^.AllNodes[J]^.PC <= ClosurePC) then begin
          ScanPC := NodeIdx(B, FSF^.AllNodes[J]^.Dest.Version);
          if (ScanPC >= 0) and (ScanPC < Length(FExprStr)) and
             (FExprStr[ScanPC] <> '') and (FExprStr[ScanPC] <> '__swap_temp__') and
             (Pos('function', FExprStr[ScanPC]) = 0) and  { skip full closure bodies }
             (Pos(#10, FExprStr[ScanPC]) = 0) and         { skip multi-line expressions }
             (Length(FExprStr[ScanPC]) < 80) and           { skip long expressions }
             IsSafeUpvalueName(FExprStr[ScanPC]) then
            Name := FExprStr[ScanPC];
        end;
      end;
      { If still unnamed and register B is a CLOSURE, try to find the table key
        this closure was assigned to (e.g. SETTABLE easing_tbl "outQuad" R_B).
        The key name then serves as the upvalue reference via the table. }
      if (Name = '') then begin
        for ScanPC := ClosurePC downto 0 do begin
          if GET_OPCODE(FProto^.Code[ScanPC]) = OP_CLOSURE then begin
            if GETARG_A(FProto^.Code[ScanPC]) = B then begin
              { Found the CLOSURE that defines register B.
                Now scan forward for a SETTABLE that uses B as a value. }
              for J := ScanPC + 1 to Length(FProto^.Code) - 1 do begin
                if GET_OPCODE(FProto^.Code[J]) = OP_SETTABLE then begin
                  { SETTABLE A B C: table[RK(B)] = RK(C).
                    If C = register B (our closure), extract the key name. }
                  if (not ISK(GETARG_C(FProto^.Code[J]))) and
                     (GETARG_C(FProto^.Code[J]) = B) then begin
                    { Key is RK(B) of SETTABLE }
                    if ISK(GETARG_B(FProto^.Code[J])) then begin
                      Name := ConstStr(INDEXRK(GETARG_B(FProto^.Code[J])));
                      { Strip quotes from string constants }
                      if (Length(Name) >= 2) and (Name[1] = '"') then
                        Name := Copy(Name, 2, Length(Name) - 2);
                      { Build table.field reference using the table's name }
                      Name := TempName(GETARG_A(FProto^.Code[J])) + '.' + Name;
                    end;
                    Break;
                  end;
                end;
                if GET_OPCODE(FProto^.Code[J]) = OP_RETURN then Break;
              end;
              Break;
            end;
          end;
        end;
      end;
      NameFromExpr := (Name <> '');
      if Name = '' then
        Name := LocalName(B, ClosurePC);

      { If the name is a temp (t<N>) and came from LocalName (not FExprStr),
        try to trace back through MOVE chains to find a parameter or meaningful
        source. Scan backwards from ClosurePC.
        NOTE: Only do this when FExprStr/SETTABLE didn't provide a name,
        because those names are authoritative (NEWTABLE/CLOSURE definitions). }
      if (not NameFromExpr) and
         (Length(Name) >= 2) and (Name[1] = 't') then begin
        for ScanPC := ClosurePC - 1 downto 0 do begin
          ScanInst := FProto^.Code[ScanPC];
          ScanOp := GET_OPCODE(ScanInst);
          if (ScanOp = OP_MOVE) and (GETARG_A(ScanInst) = B) then begin
            { Found: MOVE B = ScanB. Check if ScanB has a name }
            J := GETARG_B(ScanInst);
            Name := LocalName(J, ScanPC);
            if (Length(Name) >= 2) and (Name[1] = 't') then
              Continue  { still a temp, keep tracing }
            else
              Break;  { found a real name }
          end else if (ScanOp <> OP_MOVE) and (GETARG_A(ScanInst) = B) then
            Break;  { B redefined by non-MOVE, stop tracing }
        end;
      end;

      Result[I] := Name;
    end
    else if Op = OP_GETUPVAL then begin
      { Upvalue I binds to parent's upvalue B - chain through parent's upvalue names }
      Result[I] := UpvalName(B);
    end
    else
      Result[I] := '_upval' + IntToStr(I);
  end;
end;

{ ======================================================================
  BuildSubProtoParams - build parameter list for a sub-proto, avoiding
  name collisions with upvalue names by using 'arg<N>' for conflicts
  ====================================================================== }

function TDecompiler.BuildSubProtoParams(SubProto: PProto;
                                          const UpvalNames: TAnsiStringArray;
                                          SkipSelf: Boolean = False): AnsiString;
var
  I, J: Integer;
  PName: AnsiString;
  Collision: Boolean;
begin
  Result := '';
  for I := 0 to SubProto^.NumParams - 1 do begin
    if SkipSelf and (I = 0) then Continue;
    if Result <> '' then Result := Result + ', ';

    { Get the default parameter name }
    if I < Length(SubProto^.LocVars) then
      PName := SubProto^.LocVars[I].Name
    else
      PName := 'a' + IntToStr(I);

    { Check for collision with upvalue names }
    Collision := False;
    for J := 0 to High(UpvalNames) do begin
      if UpvalNames[J] = PName then begin
        Collision := True;
        Break;
      end;
    end;
    if Collision then
      PName := 'arg' + IntToStr(I);

    Result := Result + PName;
  end;
  { Lua 5.1: IsVarArg is a 3-bit field (bit 1 = VARARG_ISVARARG).
    Lua 5.2+: IsVarArg is a simple boolean (0 = no, 1 = yes). }
  if SubProto^.LuaVersion >= $52 then begin
    if SubProto^.IsVarArg <> 0 then begin
      if Result <> '' then Result := Result + ', ';
      Result := Result + '...';
    end;
  end else begin
    if (SubProto^.IsVarArg and 2) <> 0 then begin
      if Result <> '' then Result := Result + ', ';
      Result := Result + '...';
    end;
  end;
end;

{ ======================================================================
  DecompileSubProto - decompile a child proto into a function literal string
  ====================================================================== }

function TDecompiler.DecompileSubProto(SubProtoIdx: Integer; ClosurePC: Integer = -1): AnsiString;
var
  SubProto: PProto;
  SubOutput: AnsiString;
  D: TDecompiler;
  Params: AnsiString;
  P, LineStart: Integer;
  Line: AnsiString;
  Body: AnsiString;
  UVNames: TAnsiStringArray;
begin
  if (SubProtoIdx < 0) or (SubProtoIdx >= Length(FProto^.P)) then begin
    Result := '<closure:P' + IntToStr(SubProtoIdx) + '>'; Exit;
  end;
  SubProto := FProto^.P[SubProtoIdx];

  { Mark this sub-proto as inlined so DecompileProtoRec skips it }
  if SubProtoIdx < Length(FInlinedProtos) then
    FInlinedProtos[SubProtoIdx] := True;

  { Resolve upvalue names and build parameter list with collision avoidance }
  SetLength(UVNames, 0);
  if ClosurePC >= 0 then
    UVNames := ResolveUpvalNames(ClosurePC, SubProtoIdx);
  Params := BuildSubProtoParams(SubProto, UVNames);

  { Decompile the sub-proto body (rmBodyOnly: no function wrapper, indent 0) }
  if Length(UVNames) > 0 then
    D := TDecompiler.Create(SubProto, FOpts, UVNames)
  else
    D := TDecompiler.Create(SubProto, FOpts);
  try
    SubOutput := StripTrailingNewline(D.Run(rmBodyOnly));
  finally
    D.Free;
  end;

  { Single-line heuristic: use LineDefined as formatting hint when available.
    For stripped bytecode (LineDefined=LastLineDefined=0), allow single-line.
    For non-stripped multi-line (LineDefined<>LastLineDefined), force multi-line. }
  Line := Trim(SubOutput);
  if (SubProto^.LineDefined = SubProto^.LastLineDefined) and
     (Pos(#10, Line) = 0) and (Pos(#13, Line) = 0) and
     (Length(Line) + Length(Params) + 18 < 80) and
     (Line <> '') then
    Result := 'function(' + Params + ') ' + Line + ' end'
  else begin
    { Multi-line: iterate body lines, prepend 2 spaces for wrapper indent }
    Body := '';
    P := 1;
    while P <= Length(SubOutput) do begin
      LineStart := P;
      while (P <= Length(SubOutput)) and (SubOutput[P] <> #10) do Inc(P);
      Line := Copy(SubOutput, LineStart, P - LineStart);
      { Remove trailing CR if present }
      if (Length(Line) > 0) and (Line[Length(Line)] = #13) then
        Line := Copy(Line, 1, Length(Line) - 1);
      Inc(P); { skip the LF }
      if Body <> '' then Body := Body + LineEnding;
      Body := Body + '  ' + Line;
    end;
    if Body = '' then
      Result := 'function(' + Params + ') end'
    else
      Result := 'function(' + Params + ')' + LineEnding + Body + LineEnding + 'end';
  end;
end;

{ ======================================================================
  EmitClosureReturn - emit "return function(...) body end" with indentation
  ====================================================================== }

procedure TDecompiler.EmitClosureReturn(ClosureNode: PSSANode);
var
  SubProtoIdx: Integer;
  SubProto: PProto;
  Params: AnsiString;
  SubOutput, Line, Body: AnsiString;
  D: TDecompiler;
  UVNames: TAnsiStringArray;
  P, LineStart: Integer;
begin
  SubProtoIdx := ClosureNode^.ConstIdx;
  if (SubProtoIdx < 0) or (SubProtoIdx >= Length(FProto^.P)) then begin
    EmitLine('return <closure:P' + IntToStr(SubProtoIdx) + '>');
    Exit;
  end;
  SubProto := FProto^.P[SubProtoIdx];

  { Mark as inlined }
  if SubProtoIdx < Length(FInlinedProtos) then
    FInlinedProtos[SubProtoIdx] := True;

  { Resolve upvalue names and build parameter list with collision avoidance }
  UVNames := ResolveUpvalNames(ClosureNode^.PC, SubProtoIdx);
  Params := BuildSubProtoParams(SubProto, UVNames);

  { Decompile sub-proto body (rmBodyOnly: no wrapper, indent 0) }
  D := TDecompiler.Create(SubProto, FOpts, UVNames);
  try
    SubOutput := StripTrailingNewline(D.Run(rmBodyOnly));
  finally
    D.Free;
  end;

  { Single-line check: use LineDefined as formatting hint when available }
  Body := Trim(SubOutput);
  if (SubProto^.LineDefined = SubProto^.LastLineDefined) and
     (Pos(#10, Body) = 0) and (Pos(#13, Body) = 0) and
     (Length('return function(' + Params + ') ' + Body + ' end') + FIndent * 2 < 80) then begin
    if Body <> '' then
      EmitLine('return function(' + Params + ') ' + Body + ' end')
    else
      EmitLine('return function(' + Params + ') end');
    Exit;
  end;

  { Multi-line: return function(params)\n  body\nend }
  EmitStmt('return function(' + Params + ')');
  Indent;

  P := 1;
  while P <= Length(SubOutput) do begin
    LineStart := P;
    while (P <= Length(SubOutput)) and (SubOutput[P] <> #10) do
      Inc(P);
    Line := Copy(SubOutput, LineStart, P - LineStart);
    if (Length(Line) > 0) and (Line[Length(Line)] = #13) then
      Line := Copy(Line, 1, Length(Line) - 1);
    Inc(P);

    EmitEmbed(Line);
  end;

  Dedent;
  EmitStruct('end');
end;

{ ======================================================================
  TryEmitInlineFunction - detect SETGLOBAL of CLOSURE and emit inline
  ====================================================================== }

function TDecompiler.TryEmitInlineFunction(SetNode: PSSANode; const FuncName: AnsiString): Boolean;
var
  ClosureNode: PSSANode;
  SubProtoIdx: Integer;
  SubProto: PProto;
  SubOutput: AnsiString;
  D: TDecompiler;
  Line: AnsiString;
  P, LineStart: Integer;
  Params: AnsiString;
  I: Integer;
  UVNames: TAnsiStringArray;
begin
  Result := False;

  { Find the CLOSURE node that defines OpA }
  ClosureNode := nil;
  if SetNode^.OpA.Reg >= 0 then begin
    { Search for defining node of OpA }
    for I := 0 to High(FSF^.AllNodes) do begin
      if RefEqual(FSF^.AllNodes[I]^.Dest, SetNode^.OpA) then begin
        ClosureNode := FSF^.AllNodes[I];
        Break;
      end;
    end;
  end;

  if (ClosureNode = nil) or (ClosureNode^.Kind <> SSA_CLOSURE) then Exit;

  SubProtoIdx := ClosureNode^.ConstIdx;
  if (SubProtoIdx < 0) or (SubProtoIdx >= Length(FProto^.P)) then Exit;
  SubProto := FProto^.P[SubProtoIdx];

  { Mark this sub-proto as inlined so DecompileProtoRec skips it }
  if SubProtoIdx < Length(FInlinedProtos) then
    FInlinedProtos[SubProtoIdx] := True;

  { Resolve upvalue names and build parameter list with collision avoidance }
  UVNames := ResolveUpvalNames(ClosureNode^.PC, SubProtoIdx);
  Params := BuildSubProtoParams(SubProto, UVNames);

  { Decompile sub-proto body (rmBodyOnly: no wrapper, indent 0) }
  D := TDecompiler.Create(SubProto, FOpts, UVNames);
  try
    SubOutput := StripTrailingNewline(D.Run(rmBodyOnly));
  finally
    D.Free;
  end;

  { Choose between "function FuncName(params)" sugar form and
    "FuncName = function(params)" assignment form.
    Heuristic: if the SETGLOBAL's line < CLOSURE's line, the source used
    the sugar form (SETGLOBAL points to `function` keyword, CLOSURE to `end`).
    If SETGLOBAL's line >= CLOSURE's line, the assignment form was used. }
  if (SetNode^.PC >= 0) and (SetNode^.PC < Length(FProto^.LineInfo)) and
     (ClosureNode^.PC >= 0) and (ClosureNode^.PC < Length(FProto^.LineInfo)) and
     (FProto^.LineInfo[SetNode^.PC] >= FProto^.LineInfo[ClosureNode^.PC]) then
    EmitStmt(FuncName + ' = function(' + Params + ')')
  else
    EmitStmt('function ' + FuncName + '(' + Params + ')');
  Indent;

  { Emit body lines (rmBodyOnly output at indent 0, no stripping needed) }
  P := 1;
  while P <= Length(SubOutput) do begin
    LineStart := P;
    while (P <= Length(SubOutput)) and (SubOutput[P] <> #10) do
      Inc(P);
    Line := Copy(SubOutput, LineStart, P - LineStart);
    if (Length(Line) > 0) and (Line[Length(Line)] = #13) then
      Line := Copy(Line, 1, Length(Line) - 1);
    Inc(P);

    EmitEmbed(Line);
  end;

  Dedent;
  EmitStruct('end');

  Result := True;
end;

{ ======================================================================
  TryEmitLocalFunction - emit CLOSURE as "local function name()" form
  ====================================================================== }

function TDecompiler.TryEmitLocalFunction(ClosureNode: PSSANode;
  const FuncName: AnsiString; IsLocal: Boolean): Boolean;
var
  SubProtoIdx: Integer;
  SubProto: PProto;
  SubOutput: AnsiString;
  D: TDecompiler;
  Line: AnsiString;
  P, LineStart: Integer;
  Params: AnsiString;
  Prefix: AnsiString;
  UVNames: TAnsiStringArray;
  Body: AnsiString;
begin
  Result := False;

  if (ClosureNode = nil) or (ClosureNode^.Kind <> SSA_CLOSURE) then Exit;

  SubProtoIdx := ClosureNode^.ConstIdx;
  if (SubProtoIdx < 0) or (SubProtoIdx >= Length(FProto^.P)) then Exit;
  SubProto := FProto^.P[SubProtoIdx];

  { Mark this sub-proto as inlined so DecompileProtoRec skips it }
  if SubProtoIdx < Length(FInlinedProtos) then
    FInlinedProtos[SubProtoIdx] := True;

  { Resolve upvalue names and build parameter list with collision avoidance }
  UVNames := ResolveUpvalNames(ClosureNode^.PC, SubProtoIdx);
  Params := BuildSubProtoParams(SubProto, UVNames);

  { Decompile sub-proto body (rmBodyOnly: no wrapper, indent 0) }
  D := TDecompiler.Create(SubProto, FOpts, UVNames);
  try
    SubOutput := StripTrailingNewline(D.Run(rmBodyOnly));
  finally
    D.Free;
  end;

  { Single-line check: use LineDefined as formatting hint when available.
    For stripped (LineDefined=LastLineDefined=0), allow single-line.
    For non-stripped multi-line, force multi-line. }
  Body := Trim(SubOutput);
  if (SubProto^.LineDefined = SubProto^.LastLineDefined) and
     (Pos(#10, Body) = 0) and (Pos(#13, Body) = 0) then begin
    { Build prefix }
    if IsLocal then begin
      if IsSelfRefClosure(ClosureNode) then
        Prefix := 'local function ' + FuncName + '(' + Params + ')'
      else
        Prefix := 'local ' + FuncName + ' = function(' + Params + ')';
    end else
      Prefix := FuncName + ' = function(' + Params + ')';
    { Build single-line }
    if Body <> '' then
      Line := Prefix + ' ' + Body + ' end'
    else
      Line := Prefix + ' end';
    if Length(Line) < 80 then begin
      EmitLine(Line);
      Result := True;
      Exit;
    end;
  end;

  { Multi-line emit }
  if IsLocal then begin
    if IsSelfRefClosure(ClosureNode) then
      EmitStmt('local function ' + FuncName + '(' + Params + ')')
    else
      EmitStmt('local ' + FuncName + ' = function(' + Params + ')');
  end else
    EmitStmt(FuncName + ' = function(' + Params + ')');
  Indent;

  { Emit body lines (rmBodyOnly output at indent 0, no stripping needed) }
  P := 1;
  while P <= Length(SubOutput) do begin
    LineStart := P;
    while (P <= Length(SubOutput)) and (SubOutput[P] <> #10) do
      Inc(P);
    Line := Copy(SubOutput, LineStart, P - LineStart);
    if (Length(Line) > 0) and (Line[Length(Line)] = #13) then
      Line := Copy(Line, 1, Length(Line) - 1);
    Inc(P);

    EmitEmbed(Line);
  end;

  Dedent;
  EmitStruct('end');

  Result := True;
end;

{ ======================================================================
  TryEmitSettableFunction - detect SETTABLE of CLOSURE and emit inline
  ====================================================================== }

function TDecompiler.TryEmitSettableFunction(Node: PSSANode): Boolean;
var
  ClosureNode: PSSANode;
  SubProtoIdx: Integer;
  SubProto: PProto;
  TableExpr, KeyStr, FuncName, Params: AnsiString;
  I: Integer;
  IsColon: Boolean;
  SubOutput, Line: AnsiString;
  D: TDecompiler;
  P, LineStart: Integer;
  UVNames: TAnsiStringArray;

  function FirstParamLooksLikeReceiver(AProto: PProto): Boolean;
  var
    PC, A, B, C: Integer;
    Inst: TInstruction;
    Sem: TSemanticOp;
  begin
    Result := False;
    if (AProto = nil) or (AProto^.NumParams < 1) then Exit;

    for PC := 0 to High(AProto^.Code) do begin
      Inst := AProto^.Code[PC];

      if FOpts.OT <> nil then begin
        Sem := DecodeOp(FOpts.OT^, Inst);
        A := DecodeA(FOpts.OT^, Inst);
        B := DecodeB(FOpts.OT^, Inst);
        C := DecodeC(FOpts.OT^, Inst);
        if IsIvABCFormat(FOpts.OT^, Inst) then begin
          B := DecodeVB(FOpts.OT^, Inst);
          C := DecodeVC(FOpts.OT^, Inst);
        end;

        case Sem of
          semGETTABLE, semGETI, semGETFIELD, semSELF:
            if B = 0 then begin Result := True; Exit; end;
          semSETTABLE, semSETI, semSETFIELD:
            if A = 0 then begin Result := True; Exit; end;
        end;
      end else begin
        A := GETARG_A(Inst);
        B := GETARG_B(Inst);
        C := GETARG_C(Inst);
        case GET_OPCODE(Inst) of
          OP_GETTABLE, OP_SELF:
            if B = 0 then begin Result := True; Exit; end;
          OP_SETTABLE:
            if A = 0 then begin Result := True; Exit; end;
        end;
      end;
    end;
  end;
begin
  Result := False;

  { OpC is the value being assigned; find the CLOSURE node for it }
  ClosureNode := nil;
  if (Node^.OpC.Reg >= 0) and (Node^.OpC.Reg <> SSA_CONST_REG) then begin
    for I := 0 to High(FSF^.AllNodes) do
      if RefEqual(FSF^.AllNodes[I]^.Dest, Node^.OpC) then begin
        ClosureNode := FSF^.AllNodes[I]; Break;
      end;
  end;

  if (ClosureNode = nil) or (ClosureNode^.Kind <> SSA_CLOSURE) then Exit;

  SubProtoIdx := ClosureNode^.ConstIdx;
  if (SubProtoIdx < 0) or (SubProtoIdx >= Length(FProto^.P)) then Exit;
  SubProto := FProto^.P[SubProtoIdx];

  { If this sub-proto was already emitted elsewhere (e.g. as a local function),
    don't inline it again - let normal SETTABLE emit the variable reference }
  if (SubProtoIdx < Length(FInlinedProtos)) and FInlinedProtos[SubProtoIdx] then
    Exit;

  { Mark as inlined }
  if SubProtoIdx < Length(FInlinedProtos) then
    FInlinedProtos[SubProtoIdx] := True;

  { Build table.key or table:method name }
  { When OpA is SSA_NO_REF but UpvalIdx is set, this is an upvalue table
    write (SETTABUP with non-_ENV upvalue). Use the upvalue name. }
  if (Node^.OpA.Reg < 0) and (Node^.UpvalIdx >= 0) then
    TableExpr := UpvalName(Node^.UpvalIdx)
  else
    TableExpr := ExprOf(Node^.OpA, Node^.PC);
  KeyStr := ExprOf(Node^.OpB, Node^.PC);

  { String key --> dot/colon notation. Only valid for constant string keys.
    For non-string keys (variables, expressions), we cannot use
    "function name()" syntax - must use "table[key] = function() ... end" }
  if (Length(KeyStr) >= 2) and (KeyStr[1] = '"') then begin
    { _ENV table --> emit as plain global function (e.g. function print() instead of function _ENV.print()) }
    if TableExpr = '_ENV' then
      FuncName := Copy(KeyStr, 2, Length(KeyStr) - 2)
    else
      FuncName := TableExpr + '.' + Copy(KeyStr, 2, Length(KeyStr) - 2);
  end else begin
    { Non-string key --> cannot use "function t[k]()" syntax, bail out }
    Exit;
  end;

  { Detect colon syntax: first LocVar is "self".
    Stripped chunks have no LocVars, so recover the common method form when a
    dotted table-field closure uses parameter register 0 as a receiver. }
  IsColon := (SubProto^.NumParams >= 1) and
             (Length(SubProto^.LocVars) > 0) and
             (SubProto^.LocVars[0].Name = 'self');
  if (not IsColon) and (SubProto^.NumParams >= 1) and
     (Length(SubProto^.LocVars) = 0) and (Pos('.', FuncName) > 0) then
    IsColon := FirstParamLooksLikeReceiver(SubProto);

  if IsColon then begin
    { Replace the final dot with colon.  For nested method fields,
      "self.converters.name" should become "self.converters:name",
      not "self:converters.name". }
    I := Length(FuncName);
    while (I > 0) and (FuncName[I] <> '.') do
      Dec(I);
    if I > 0 then
      FuncName[I] := ':';
  end;

  { Resolve upvalue names and build parameter list with collision avoidance }
  UVNames := ResolveUpvalNames(ClosureNode^.PC, SubProtoIdx);
  Params := BuildSubProtoParams(SubProto, UVNames, IsColon);

  { Decompile sub-proto body only (no function wrapper, indent 0) }
  D := TDecompiler.Create(SubProto, FOpts, UVNames);
  try
    if IsColon and (Length(SubProto^.LocVars) = 0) and
       (SubProto^.NumParams >= 1) then begin
      if Length(D.FParamOverrides) < SubProto^.NumParams then
        SetLength(D.FParamOverrides, SubProto^.NumParams);
      D.FParamOverrides[0] := 'self';
    end;
    SubOutput := StripTrailingNewline(D.Run(rmBodyOnly));
  finally
    D.Free;
  end;

  { Emit: function table:method(params) body end }
  EmitStmt('function ' + FuncName + '(' + Params + ')');
  Indent;

  { Emit body lines (rmBodyOnly output at indent 0, no stripping needed) }
  P := 1;
  while P <= Length(SubOutput) do begin
    LineStart := P;
    while (P <= Length(SubOutput)) and (SubOutput[P] <> #10) do
      Inc(P);
    Line := Copy(SubOutput, LineStart, P - LineStart);
    if (Length(Line) > 0) and (Line[Length(Line)] = #13) then
      Line := Copy(Line, 1, Length(Line) - 1);
    Inc(P);

    EmitEmbed(Line);
  end;

  Dedent;
  EmitStruct('end');

  Result := True;
end;