Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/backend/commands/explain.c`:
- Around line 815-880: The TEXT branch that iterates pstmt->withFuncDefs should
mirror the non-TEXT verbose behavior: before the foreach loop emit a header line
like "WITH Functions:" (use appendStringInfo(es->str, "WITH Functions:\n"); and
ExplainIndentText/es->str for indentation), and inside the loop after printing
the signature (where sig is appended and printed) add a check if (es->verbose &&
ifd->src) to emit the body (e.g. call ExplainIndentText(es);
appendStringInfo(es->str, "Body: %s\n", ifd->src);) so the inline function body
(ifd->src) is shown in TEXT VERBOSE; use the existing symbols ifd->src,
es->verbose, ExplainIndentText and appendStringInfo(es->str, ...) so the output
matches the non-TEXT branch and provides context for each function.

In `@src/backend/parser/parse_clause.c`:
- Around line 4066-4070: Replace the silent "continue" for
FUNC_FROM_WITH_CLAUSE: instead of skipping validation, explicitly handle
WITH-clause routines by either (A) rejecting them if they contain OUT or INOUT
parameters or (B) resolving their argument modes and letting the existing
validation path run; implement (A) by checking the function's arg-mode array
(e.g. proargmodes / argmodes) when func->function_from == FUNC_FROM_WITH_CLAUSE
and raising an error if any mode is OUT or INOUT, or implement (B) by removing
the continue and falling through so the existing argument-mode
resolution/validation code executes for FUNC_FROM_WITH_CLAUSE as it does for
catalog PL/pgsql functions and subprocs. Ensure you reference
FUNC_FROM_WITH_CLAUSE and func->function_from in your change and preserve
existing validation logic for arg modes.

In `@src/backend/parser/parse_cte.c`:
- Around line 126-134: The error hint currently references internal symbols
compatible_db and ORA_PARSER; update the errmsg/errhint in the WITH
FUNCTION/PROCEDURE check (the block that tests withClause->plsql_defs and calls
transformWithFuncDefs(pstate, withClause->plsql_defs)) so the user-facing hint
instructs how to set the GUC: e.g., tell users to set ivorysql.compatible_mode
to "oracle" (or use the equivalent ALTER SYSTEM/SET command) instead of
mentioning compatible_db or ORA_PARSER.

In `@src/backend/parser/parse_func.c`:
- Around line 906-923: The code that syncs actual_arg_types from fargs can write
past the fixed-size actual_arg_types[FUNC_MAX_ARGS] if withFuncLookupHook
appended defaults; add a defensive bound check when computing new_nargs (use
FUNC_MAX_ARGS) and reject or truncate with the same error path used elsewhere
(e.g., increment nargs handling that checks FUNC_MAX_ARGS and reports an error
via ereport/elog). Specifically, in the block that sets new_nargs and loops over
fargs (the code that updates actual_arg_types and variables
nargs/nargsplusdefs), ensure new_nargs <= FUNC_MAX_ARGS before writing into
actual_arg_types (and raise the same error when exceeded), mirroring the guard
used in the surrounding default-handling block that references FUNC_MAX_ARGS.

In `@src/backend/parser/parse_with_plsql.c`:
- Line 145: The bug is that funcindex is initialized to 0 in
transformWithFuncDefs so the first inline WITH function gets FuncExpr.funcid ==
0 (InvalidOid); change the initialization in transformWithFuncDefs so funcindex
starts at 1 (or alternatively add and use a dedicated field for the
inline-function index instead of casting a zero-based index to Oid) so that
entry->funcindex and subsequently FuncExpr.funcid are never 0; update any code
that assigns or casts entry->funcindex to Oid (e.g. where *funcid is set) to
rely on the new 1-based scheme.

In `@src/include/nodes/primnodes.h`:
- Around line 780-783: The change to FUNC_EXPR_FROM_PG_PROC causes
!FUNC_EXPR_FROM_PG_PROC to be true for FUNC_FROM_WITH_CLAUSE, so update
init_sexpr to first check for FUNC_FROM_WITH_CLAUSE before treating a function
as a subprocedure: in init_sexpr, replace the unguarded "if
(!FUNC_EXPR_FROM_PG_PROC(funcexpr->function_from)) is_subproc_func = true" with
a two-way check that sets is_with_func when funcexpr->function_from ==
FUNC_FROM_WITH_CLAUSE else sets is_subproc_func when
!FUNC_EXPR_FROM_PG_PROC(...); ensure callers that invoke
fmgr_subproc_info_cxt(foid, &(sexpr->func), sexprCxt) only run when
is_subproc_func is true, and audit other unguarded uses of
!FUNC_EXPR_FROM_PG_PROC (e.g., dependency.c) to apply the same guard pattern.

In `@src/oracle_test/regress/sql/with_function.sql`:
- Around line 131-133: The test currently calls _wf_scope_test without ever
defining it, producing a false-positive; update the test to first declare the
WITH FUNCTION _wf_scope_test(...) and use it inside the same statement (a
positive in-statement call to _wf_scope_test) and then, in a separate statement
afterwards, call _wf_scope_test(1) from outside to assert the out-of-scope
failure; ensure the in-statement call and the external call are separate
statements so the second triggers the expected scope error.

In `@src/pl/plisql/src/pl_comp.c`:
- Around line 1627-1634: Only assign pstate->p_with_func_list when the current
ParseState belongs to the same WITH-function execution context: check that
plisql_active_with_func_entries is non-NIL AND that the current pstate's
execution context matches the saved plisql_active_with_func_estate (e.g. compare
pstate->p_estate or equivalent field against plisql_active_with_func_estate)
before setting p_with_func_list; this ensures only parses running in the owning
WITH-call can see those WITH-function entries (references: p_with_func_list,
plisql_active_with_func_entries, plisql_active_with_func_estate, pstate).

In `@src/pl/plisql/src/pl_handler.c`:
- Around line 317-322: The WITH-function path only copies the parameter type OID
into ParamExternData (paramLI->params[i].ptype) but not the parsed typmod, so
declarations like varchar2(10) lose their modifier; update the code that fills
ParamListInfo in pl_handler.c to also copy the parsed typmod into each
ParamExternData (set paramLI->params[i].ptypmod = fp->argtypmod or the
corresponding parsed typmod field on the formal parameter), since
plisql_compile_inline() expects both param->ptype and param->ptypmod when
rebuilding parameter variables.
- Around line 473-489: The error-context callback (errcallback) is pushed onto
error_context_stack before calling buildParamListForFunc, typenameTypeId, and
plisql_compile_inline, but if any of those functions throws the final restore
(error_context_stack = errcallback.previous) is skipped; wrap the compilation
block that sets paramLI, rettype, calls plisql_compile_inline and
fixupCompiledReturnType in a PG_TRY / PG_FINALLY pair and in the PG_FINALLY
ensure error_context_stack is restored (pop errcallback) so the
with_func_compile_error_callback / errctx frame is always removed even on
errors.

---

Outside diff comments:
In `@src/backend/executor/execSRF.c`:
- Around line 739-776: init_sexpr currently treats any FuncExpr that is not from
pg_proc as a "subproc" (using FUNC_EXPR_FROM_PG_PROC), which after the macro
change will mark WITH-clause functions as subprocs and cause
fmgr_subproc_info_cxt to be called incorrectly; update init_sexpr to detect
FUNC_FROM_WITH_CLAUSE (e.g. add an is_with_func boolean alongside
is_subproc_func) and follow the same pattern used in execExpr.c: if is_with_func
call the regular fmgr lookup (fmgr_info_cxt) or a dedicated WITH-clause fmgr
lookup instead of fmgr_subproc_info_cxt, and only call fmgr_subproc_info_cxt
when the FuncExpr truly represents a PL/pgSQL subproc (is_subproc_func).

In `@src/oracle_fe_utils/ora_psqlscan.l`:
- Around line 1138-1142: The code unconditionally clears
cur_state->ora_plsql_expect_end_symbol to END_SYMBOL_INVALID on any identifier
which breaks labeled END (e.g., "END foo;") for WITH FUNCTION; change the logic
so that when cur_state->ora_plsql_expect_end_symbol == END_SYMBOL_SEMICOLON and
the identifier immediately follows an END token (i.e., the labeled-end pattern),
you do NOT reset ora_plsql_expect_end_symbol (leave END_SYMBOL_SEMICOLON so the
subsequent ';' clears cancel_semicolon_terminator and terminates the statement);
otherwise continue to clear to END_SYMBOL_INVALID as before—use the existing
parser state (previous token marker / begin_depth / token-type checks) to detect
the "identifier immediately after END" case and keep END_SYMBOL_SEMICOLON
intact.
- Around line 798-866: The current ';' handler resets identifiers and sets
skip_this_semi whenever ora_plsql_expect_end_symbol == END_SYMBOL_SEMICOLON and
identifiers[0] == 'w'/'e', which incorrectly fires for inner END; inside nested
BEGIN…END; blocks; change the branch to three-way based on
cur_state->begin_depth: if begin_depth == 0 keep the existing skip_this_semi
behavior (reset cancel_semicolon_terminator, clear ora_plsql_expect_end_symbol
and reset identifiers/identifier_count), if begin_depth > 0 DO NOT reset
identifiers or identifier_count—only clear ora_plsql_expect_end_symbol and
cancel_semicolon_terminator so inner END; doesn't dismantle the WITH/FUNCTION
tracking, and otherwise (the existing else) set ora_plsql_expect_end_symbol =
END_SYMBOL_SLASH; update the code around the ';' case that references
cur_state->ora_plsql_expect_end_symbol, cur_state->identifiers,
cur_state->identifier_count, cur_state->cancel_semicolon_terminator, and
cur_state->begin_depth accordingly.

---

Nitpick comments:
In `@src/backend/commands/explain.c`:
- Around line 770-881: The code duplicates signature-building logic in the TEXT
and non-TEXT branches when formatting InlineFunctionDef signatures; extract that
repeated logic into a helper (e.g., format_inline_function_signature(StringInfo
buf, InlineFunctionDef *ifd)) and replace the blocks in both branches with calls
to that helper; ensure the helper handles argument modes, names, types and
rettype exactly as in the original (use InlineFunctionDef, FunctionParameter,
fp->mode, fp->name, fp->argType, ifd->is_proc, ifd->rettype and
TypeNameToString), keep existing surrounding behavior (in the non-TEXT branch
call ExplainPropertyText("Signature", buf->data, es); in the TEXT branch write
buf->data into es->str after ExplainIndentText) and free any temporary buffer as
before.
- Line 776: Replace the raw cast usage of lfirst(lc) to extract
InlineFunctionDef nodes with the node-safe helper: use
lfirst_node(InlineFunctionDef, lc) wherever InlineFunctionDef is being extracted
(the two occurrences around the InlineFunctionDef handling, previously using
"InlineFunctionDef *ifd = (InlineFunctionDef *) lfirst(lc)"). This follows the
established pattern (e.g., lfirst_node(Query, ...) usage) and ensures an IsA
check in assert builds for runtime safety.

In `@src/backend/oracle_parser/ora_gram.y`:
- Around line 997-999: Add regression tests to lock down the precedence-based
DML vs CTE disambiguation implemented around the tokens DELETE_P, INSERT,
UPDATE, MERGE and the PLSQL_DEFS_END handling in ora_gram.y: create parser tests
that cover "WITH FUNCTION ... INSERT/UPDATE/DELETE/MERGE ..." (ensuring those
are parsed as DML following a WITH FUNCTION) and also tests for "WITH FUNCTION
... <cte_name> AS (...) ..." (ensuring the name is parsed as a CTE), include one
test per DML token plus positive and negative CTE cases, run them against the
parser so the ambiguity is exercised and fails if precedence regresses.

In `@src/backend/parser/parse_func.c`:
- Around line 319-406: There are three near-duplicate calls to
withFuncLookupHook (via p_subprocfunc_hook, a parent-chain loop, and a PL/iSQL
fallback) that pass the same large argument list; create a small static helper
like try_with_func_lookup(ParseState *state, List *funcname, List **fargs, List
*argnames, int nargs, Oid *actual_arg_types, bool func_variadic, bool proc_call,
Oid *funcid, Oid *rettype, bool *retset, int *nvargs, Oid *vatype, List
**declared_arg_types, List **argdefaults, void **pfunc) which encapsulates
calling withFuncLookupHook(state, ...) and returns the FUNCDETAIL_* result (and
when it finds a match sets function_from to FUNC_FROM_WITH_CLAUSE). Replace the
three direct invocations (the p_subprocfunc_hook branch that compares to
withFuncLookupHook, the ancestor loop call, and the p_with_func_list fallback)
with calls to this helper using the appropriate ParseState (pstate or ancestor);
remove the symbol-equality check against withFuncLookupHook and use the helper’s
return value to decide setting function_from, preserving all semantics and
argument order.

In `@src/backend/parser/parse_with_plsql.c`:
- Around line 287-310: The loop that appends default expressions uses
Assert(defexpr != NULL) which can be compiled out, so replace the assert with a
runtime check that raises an error when a NULL default is encountered beyond
nargs: inside the foreach over entry->analyzeddefaults, if defexpr == NULL and
skip > nargs then call the PostgreSQL error reporting (ereport/errmsg) to raise
a clear error (e.g., invalid function header/defaults) rather than allowing a
NULL to be appended to *fargs; keep the rest of the logic intact so provided
args are still skipped and non-NULL defaults are copied.
- Around line 92-114: The function checkDuplicateWithFunc currently calls
parser_errposition(NULL, newentry->def->location) which yields no caret; modify
checkDuplicateWithFunc to accept a ParseState *pstate parameter, and pass pstate
into parser_errposition(pstate, newentry->def->location) when reporting the
duplicate-function error; update the caller that builds func_list (the site that
invokes checkDuplicateWithFunc) to forward its ParseState pointer to the new
function signature so diagnostics point at the correct source location; ensure
function prototype and any declarations use the new ParseState *pstate
parameter.

In `@src/include/nodes/parsenodes.h`:
- Around line 1662-1663: The comment should be updated to state that while
WithClause historically did not propagate into Query, function definitions
contained in WithClause now do propagate via Query.withFuncDefs; change the note
referencing WithClause and CommonTableExpr in parsenodes.h so it mentions that
WithClause itself still isn't copied into Query but its inline function
definitions are carried over through the Query.withFuncDefs field (referencing
the WithClause struct and the Query.withFuncDefs member and keeping
CommonTableExpr behavior noted).

In `@src/include/nodes/primnodes.h`:
- Line 818: Update the stale inline comment for the struct field function_from
in primnodes.h to mention WITH clause inline functions as well as
proc/subproc/package funcs; locate the field named function_from in the struct
(char function_from) and change its comment text to something like "/* proc
func, subproc func, package func, WITH-clause inline func */" so the comment
accurately documents all possible sources.

In `@src/oracle_test/regress/sql/with_function.sql`:
- Around line 8-13: The test currently only parses WITH PROCEDURE do_nothing but
the SELECT 'procedure ok' result is independent; update the test so the SELECT
outcome depends on a side-effect of the WITH PROCEDURE named do_nothing (e.g.,
have do_nothing perform a visible side-effect such as inserting/updating a value
or setting a local variable reachable by the SELECT, then assert the SELECT
reads that value), so execution of do_nothing is required to produce the
expected result.