fix: resolve OUT-param varno by signature names for bare RETURN

Author: pyramation

__fixtures__/plpgsql-generated/generated.json

@@ -158,6 +158,8 @@
   "plpgsql_deparser_fixes-58.sql": "CREATE FUNCTION test_return_next_var() RETURNS SETOF integer\nLANGUAGE plpgsql AS $$\nDECLARE\n  r integer;\nBEGIN\n  FOR r IN SELECT g FROM generate_series(1, 3) g LOOP\n    RETURN NEXT r;\n  END LOOP;\nEND$$",
   "plpgsql_deparser_fixes-59.sql": "CREATE FUNCTION test_toplevel_exception(a numeric, b numeric) RETURNS numeric\nLANGUAGE plpgsql AS $$\nDECLARE\n  v_result numeric;\nBEGIN\n  v_result := a / b;\n  RETURN v_result;\nEXCEPTION\n  WHEN division_by_zero THEN\n    RETURN NULL;\nEND$$",
   "plpgsql_deparser_fixes-60.sql": "CREATE FUNCTION test_explicit_nested_exception(p_id integer) RETURNS text\nLANGUAGE plpgsql AS $$\nDECLARE\n  v_result text;\nBEGIN\n  v_result := 'unknown';\n  BEGIN\n    SELECT status INTO v_result FROM items WHERE id = p_id;\n  EXCEPTION\n    WHEN no_data_found THEN\n      v_result := 'not_found';\n  END;\n  RETURN v_result;\nEND$$",
+  "plpgsql_deparser_fixes-61.sql": "CREATE FUNCTION test_out_param_bare_return(\n  IN a text,\n  IN b uuid,\n  OUT result uuid\n) RETURNS uuid\nLANGUAGE plpgsql AS $$\nDECLARE\n  v_id uuid;\nBEGIN\n  v_id := b;\n  SELECT v_id INTO result;\n  RETURN;\nEND$$",
+  "plpgsql_deparser_fixes-62.sql": "CREATE FUNCTION test_multi_out_bare_return(\n  IN a integer,\n  OUT x integer,\n  OUT y text\n)\nLANGUAGE plpgsql AS $$\nBEGIN\n  x := a;\n  y := 'ok';\n  RETURN;\nEND$$",
   "plpgsql_control-1.sql": "do $$\nbegin\n  -- basic case\n  for i in 1..3 loop\n    raise notice '1..3: i = %', i;\n  end loop;\n  -- with BY, end matches exactly\n  for i in 1..10 by 3 loop\n    raise notice '1..10 by 3: i = %', i;\n  end loop;\n  -- with BY, end does not match\n  for i in 1..11 by 3 loop\n    raise notice '1..11 by 3: i = %', i;\n  end loop;\n  -- zero iterations\n  for i in 1..0 by 3 loop\n    raise notice '1..0 by 3: i = %', i;\n  end loop;\n  -- REVERSE\n  for i in reverse 10..0 by 3 loop\n    raise notice 'reverse 10..0 by 3: i = %', i;\n  end loop;\n  -- potential overflow\n  for i in 2147483620..2147483647 by 10 loop\n    raise notice '2147483620..2147483647 by 10: i = %', i;\n  end loop;\n  -- potential overflow, reverse direction\n  for i in reverse -2147483620..-2147483647 by 10 loop\n    raise notice 'reverse -2147483620..-2147483647 by 10: i = %', i;\n  end loop;\nend$$",
   "plpgsql_control-2.sql": "do $$\nbegin\n  for i in 1..3 by 0 loop\n    raise notice '1..3 by 0: i = %', i;\n  end loop;\nend$$",
   "plpgsql_control-3.sql": "do $$\nbegin\n  for i in 1..3 by -1 loop\n    raise notice '1..3 by -1: i = %', i;\n  end loop;\nend$$",

__fixtures__/plpgsql/plpgsql_deparser_fixes.sql

@@ -754,3 +754,32 @@ BEGIN
   END;
   RETURN v_result;
 END$$;
+
+-- Test 61: Bare RETURN in function whose single OUT param is not the first datum
+-- (libpg-query 18 omits out_param_varno, so the OUT datum must be resolved by name)
+CREATE FUNCTION test_out_param_bare_return(
+  IN a text,
+  IN b uuid,
+  OUT result uuid
+) RETURNS uuid
+LANGUAGE plpgsql AS $$
+DECLARE
+  v_id uuid;
+BEGIN
+  v_id := b;
+  SELECT v_id INTO result;
+  RETURN;
+END$$;
+
+-- Test 62: Bare RETURN with multiple OUT params (unnamed-row OUT datum)
+CREATE FUNCTION test_multi_out_bare_return(
+  IN a integer,
+  OUT x integer,
+  OUT y text
+)
+LANGUAGE plpgsql AS $$
+BEGIN
+  x := a;
+  y := 'ok';
+  RETURN;
+END$$;

packages/plpgsql-deparser/src/plpgsql-deparser.ts

@@ -75,6 +75,8 @@ export type ReturnInfoKind = 'void' | 'setof' | 'trigger' | 'scalar' | 'out_para
 
 export interface ReturnInfo {
   kind: ReturnInfoKind;
+  /** Names of OUT/INOUT/TABLE parameters, used to locate the OUT-param datum */
+  outParamNames?: string[];
 }
 
 export interface PLpgSQLDeparserContext {
@@ -2077,6 +2079,26 @@ export class PLpgSQLDeparser {
       return func.out_param_varno;
     }
     if (func.datums) {
+      const outNames = returnInfo?.outParamNames;
+      if (returnInfo?.kind === 'out_params' && outNames && outNames.length === 1) {
+        const varIdx = func.datums.findIndex(
+          d => 'PLpgSQL_var' in d && d.PLpgSQL_var.refname === outNames[0]
+        );
+        if (varIdx >= 0) {
+          return varIdx;
+        }
+      }
+      if (returnInfo?.kind === 'out_params' && outNames && outNames.length > 1) {
+        const rowIdx = func.datums.findIndex(d => {
+          if (!('PLpgSQL_row' in d) || d.PLpgSQL_row.refname !== '(unnamed row)') return false;
+          const fields = d.PLpgSQL_row.fields || [];
+          return fields.length === outNames.length &&
+            fields.every((f, i) => f.name === outNames[i]);
+        });
+        if (rowIdx >= 0) {
+          return rowIdx;
+        }
+      }
       const rowIdx = func.datums.findIndex(
         d => 'PLpgSQL_row' in d && d.PLpgSQL_row.refname === '(unnamed row)' && d.PLpgSQL_row.lineno === -1
       );

packages/plpgsql-deparser/test-utils/index.ts

@@ -1,5 +1,5 @@
-import { parsePlPgSQL, parsePlPgSQLSync } from 'libpg-query';
-import { deparseSync, PLpgSQLParseResult } from '../src';
+import { parsePlPgSQL, parsePlPgSQLSync, parseSync } from 'libpg-query';
+import { deparseSync, PLpgSQLParseResult, ReturnInfo } from '../src';
 import { readFileSync, readdirSync, existsSync } from 'fs';
 import * as path from 'path';
 import { diff } from 'jest-diff';
@@ -13,6 +13,39 @@ export interface PLpgSQLTestCase {
   functionBody: string;
 }
 
+/**
+ * Derive ReturnInfo from a CREATE FUNCTION/PROCEDURE statement's signature
+ * so the deparser can distinguish bare RETURN (OUT params) from RETURN <expr>.
+ */
+export function deriveReturnInfo(sql: string): ReturnInfo | undefined {
+  let stmts: any[];
+  try {
+    stmts = (parseSync(sql) as any).stmts || [];
+  } catch {
+    return undefined;
+  }
+  for (const s of stmts) {
+    const fn = s?.stmt?.CreateFunctionStmt;
+    if (!fn) continue;
+    if (fn.is_procedure) return { kind: 'void' };
+    const outParamNames: string[] = (fn.parameters || [])
+      .map((p: any) => p?.FunctionParameter)
+      .filter((fp: any) => fp && (fp.mode === 'FUNC_PARAM_OUT' || fp.mode === 'FUNC_PARAM_INOUT' || fp.mode === 'FUNC_PARAM_TABLE'))
+      .map((fp: any) => fp.name)
+      .filter((n: any): n is string => typeof n === 'string');
+    if (outParamNames.length > 0) return { kind: 'out_params', outParamNames };
+    const names = (fn.returnType?.names || [])
+      .map((n: any) => n?.String?.sval)
+      .filter((v: any): v is string => typeof v === 'string');
+    const typeName = (names[names.length - 1] || '').toLowerCase();
+    if (fn.returnType?.setof) return { kind: 'setof' };
+    if (typeName === 'void' || !fn.returnType) return { kind: 'void' };
+    if (typeName === 'trigger') return { kind: 'trigger' };
+    return { kind: 'scalar' };
+  }
+  return undefined;
+}
+
 export function extractFunctionBodies(sql: string): string[] {
   const bodies: string[] = [];
   const dollarQuoteRegex = /\$\$([^]*?)\$\$/g;
@@ -368,7 +401,7 @@ export class PLpgSQLTestUtils {
         throw createParseError('PARSE_FAILED', testName, sql);
       }
 
-      const deparsedBody = deparseSync(originalAst);
+      const deparsedBody = deparseSync(originalAst, undefined, deriveReturnInfo(sql));
 
       if (!deparsedBody || deparsedBody.trim().length === 0) {
         throw createParseError('DEPARSE_FAILED', testName, sql, deparsedBody);

packages/plpgsql-parser/__tests__/return-info.test.ts

@@ -64,23 +64,23 @@ describe('getReturnInfo', () => {
         CREATE FUNCTION test_out(IN x integer, OUT result integer)
         LANGUAGE plpgsql AS $$ BEGIN result := x * 2; END; $$
       `);
-      expect(getReturnInfo(stmt)).toEqual({ kind: 'out_params' });
+      expect(getReturnInfo(stmt)).toEqual({ kind: 'out_params', outParamNames: ['result'] });
     });
 
     it('should return out_params for INOUT parameters', () => {
       const stmt = parseCreateFunction(`
         CREATE FUNCTION test_inout(INOUT x integer)
         LANGUAGE plpgsql AS $$ BEGIN x := x * 2; END; $$
       `);
-      expect(getReturnInfo(stmt)).toEqual({ kind: 'out_params' });
+      expect(getReturnInfo(stmt)).toEqual({ kind: 'out_params', outParamNames: ['x'] });
     });
 
     it('should return out_params for RETURNS TABLE', () => {
       const stmt = parseCreateFunction(`
         CREATE FUNCTION test_table() RETURNS TABLE (id integer, name text)
         LANGUAGE plpgsql AS $$ BEGIN RETURN QUERY SELECT 1, 'test'; END; $$
       `);
-      expect(getReturnInfo(stmt)).toEqual({ kind: 'out_params' });
+      expect(getReturnInfo(stmt)).toEqual({ kind: 'out_params', outParamNames: ['id', 'name'] });
     });
   });
 

packages/plpgsql-parser/src/return-info.ts

@@ -21,16 +21,27 @@ export function getReturnInfo(createFunctionStmt: any): ReturnInfo {
 
   // Check for OUT/INOUT/TABLE parameters - these indicate out_params return type
   if (createFunctionStmt.parameters && Array.isArray(createFunctionStmt.parameters)) {
+    const outParamNames = createFunctionStmt.parameters
+      .map((param: any) => param?.FunctionParameter)
+      .filter((fp: any) => {
+        if (!fp) return false;
+        const mode = fp.mode;
+        return mode === 'FUNC_PARAM_OUT' ||
+               mode === 'FUNC_PARAM_INOUT' ||
+               mode === 'FUNC_PARAM_TABLE';
+      })
+      .map((fp: any) => fp.name)
+      .filter((name: string | undefined): name is string => typeof name === 'string');
     const hasOutParams = createFunctionStmt.parameters.some((param: any) => {
       const fp = param?.FunctionParameter;
       if (!fp) return false;
       const mode = fp.mode;
-      return mode === 'FUNC_PARAM_OUT' || 
-             mode === 'FUNC_PARAM_INOUT' || 
+      return mode === 'FUNC_PARAM_OUT' ||
+             mode === 'FUNC_PARAM_INOUT' ||
              mode === 'FUNC_PARAM_TABLE';
     });
     if (hasOutParams) {
-      return { kind: 'out_params' };
+      return { kind: 'out_params', outParamNames };
     }
   }