diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c
index 39768fa22b..f127f20fd8 100644
--- a/src/backend/catalog/dependency.c
+++ b/src/backend/catalog/dependency.c
@@ -206,8 +206,7 @@ static void reportDependentObjects(const ObjectAddresses *targetObjects,
 static void deleteOneObject(const ObjectAddress *object,
 							Relation *depRel, int32 flags);
 static void doDeletion(const ObjectAddress *object, int flags);
-static bool find_expr_references_walker(Node *node,
-										find_expr_references_context *context);
+static bool find_expr_references_walker(Node *node, void *ctx);
 static void process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum,
 									 find_expr_references_context *context);
 static void eliminate_duplicate_dependencies(ObjectAddresses *addrs);
@@ -1738,9 +1737,10 @@ recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
  * the collation is being freshly introduced to the expression.
  */
 static bool
-find_expr_references_walker(Node *node,
-							find_expr_references_context *context)
+find_expr_references_walker(Node *node, void *ctx)
 {
+	find_expr_references_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -2283,7 +2283,7 @@ find_expr_references_walker(Node *node,
 		context->rtables = lcons(query->rtable, context->rtables);
 		result = query_tree_walker(query,
 								   find_expr_references_walker,
-								   (void *) context,
+								   ctx,
 								   QTW_IGNORE_JOINALIASES |
 								   QTW_EXAMINE_SORTGROUP);
 		context->rtables = list_delete_first(context->rtables);
@@ -2352,8 +2352,7 @@ find_expr_references_walker(Node *node,
 		/* fall through to examine arguments */
 	}
 
-	return expression_tree_walker(node, find_expr_references_walker,
-								  (void *) context);
+	return expression_tree_walker(node, find_expr_references_walker, ctx);
 }
 
 /*
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 053d2ca5ae..671a41d3b6 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -63,7 +63,7 @@ static void ExplainPrintJIT(ExplainState *es, int jit_flags,
 static void report_triggers(ResultRelInfo *rInfo, bool show_relname,
 							ExplainState *es);
 static double elapsed_time(instr_time *starttime);
-static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used);
+static bool ExplainPreScanNode(PlanState *planstate, void *ctx);
 static void ExplainNode(PlanState *planstate, List *ancestors,
 						const char *relationship, const char *plan_name,
 						ExplainState *es);
@@ -1089,8 +1089,9 @@ elapsed_time(instr_time *starttime)
  * that never appear in the EXPLAIN output (such as inheritance parents).
  */
 static bool
-ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
+ExplainPreScanNode(PlanState *planstate, void *ctx)
 {
+	Bitmapset **rels_used = ctx;
 	Plan	   *plan = planstate->plan;
 
 	switch (nodeTag(plan))
@@ -1139,7 +1140,7 @@ ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
 			break;
 	}
 
-	return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used);
+	return planstate_tree_walker(planstate, ExplainPreScanNode, ctx);
 }
 
 /*
diff --git a/src/backend/commands/lockcmds.c b/src/backend/commands/lockcmds.c
index b97b8b0435..adaad13310 100644
--- a/src/backend/commands/lockcmds.c
+++ b/src/backend/commands/lockcmds.c
@@ -175,8 +175,10 @@ typedef struct
 } LockViewRecurse_context;
 
 static bool
-LockViewRecurse_walker(Node *node, LockViewRecurse_context *context)
+LockViewRecurse_walker(Node *node, void *ctx)
 {
+	LockViewRecurse_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 
@@ -242,13 +244,11 @@ LockViewRecurse_walker(Node *node, LockViewRecurse_context *context)
 
 		return query_tree_walker(query,
 								 LockViewRecurse_walker,
-								 context,
+								 ctx,
 								 QTW_IGNORE_JOINALIASES);
 	}
 
-	return expression_tree_walker(node,
-								  LockViewRecurse_walker,
-								  context);
+	return expression_tree_walker(node, LockViewRecurse_walker, ctx);
 }
 
 static void
diff --git a/src/backend/commands/publicationcmds.c b/src/backend/commands/publicationcmds.c
index 8b574b86c4..b84e841291 100644
--- a/src/backend/commands/publicationcmds.c
+++ b/src/backend/commands/publicationcmds.c
@@ -257,8 +257,10 @@ CheckObjSchemaNotAlreadyInPublication(List *rels, List *schemaidlist,
  * not part of REPLICA IDENTITY, false otherwise.
  */
 static bool
-contain_invalid_rfcolumn_walker(Node *node, rf_context *context)
+contain_invalid_rfcolumn_walker(Node *node, void *ctx)
 {
+	rf_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 
@@ -285,8 +287,7 @@ contain_invalid_rfcolumn_walker(Node *node, rf_context *context)
 			return true;
 	}
 
-	return expression_tree_walker(node, contain_invalid_rfcolumn_walker,
-								  (void *) context);
+	return expression_tree_walker(node, contain_invalid_rfcolumn_walker, ctx);
 }
 
 /*
@@ -549,8 +550,9 @@ expr_allowed_in_node(Node *node, ParseState *pstate, char **errdetail_msg)
  * We can allow other node types after more analysis and testing.
  */
 static bool
-check_simple_rowfilter_expr_walker(Node *node, ParseState *pstate)
+check_simple_rowfilter_expr_walker(Node *node, void *ctx)
 {
+	ParseState *pstate = ctx;
 	char	   *errdetail_msg = NULL;
 
 	if (node == NULL)
@@ -632,8 +634,7 @@ check_simple_rowfilter_expr_walker(Node *node, ParseState *pstate)
 				 errdetail("%s", errdetail_msg),
 				 parser_errposition(pstate, exprLocation(node))));
 
-	return expression_tree_walker(node, check_simple_rowfilter_expr_walker,
-								  (void *) pstate);
+	return expression_tree_walker(node, check_simple_rowfilter_expr_walker, ctx);
 }
 
 /*
diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index 25a94bbaaa..b4a6f360c1 100644
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -66,7 +66,7 @@ static void ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args,
 						 ExprState *state);
 static void ExecInitExprSlots(ExprState *state, Node *node);
 static void ExecPushExprSlots(ExprState *state, LastAttnumInfo *info);
-static bool get_last_attnums_walker(Node *node, LastAttnumInfo *info);
+static bool get_last_attnums_walker(Node *node, void *ctx);
 static bool ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op);
 static void ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable,
 								ExprState *state);
@@ -2618,8 +2618,10 @@ ExecPushExprSlots(ExprState *state, LastAttnumInfo *info)
  * get_last_attnums_walker: expression walker for ExecInitExprSlots
  */
 static bool
-get_last_attnums_walker(Node *node, LastAttnumInfo *info)
+get_last_attnums_walker(Node *node, void *ctx)
 {
+	LastAttnumInfo *info = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -2658,8 +2660,7 @@ get_last_attnums_walker(Node *node, LastAttnumInfo *info)
 		return false;
 	if (IsA(node, GroupingFunc))
 		return false;
-	return expression_tree_walker(node, get_last_attnums_walker,
-								  (void *) info);
+	return expression_tree_walker(node, get_last_attnums_walker, ctx);
 }
 
 /*
diff --git a/src/backend/executor/execIndexing.c b/src/backend/executor/execIndexing.c
index 6a8735edf7..b6ea05f13a 100644
--- a/src/backend/executor/execIndexing.c
+++ b/src/backend/executor/execIndexing.c
@@ -139,8 +139,8 @@ static bool index_recheck_constraint(Relation index, Oid *constr_procs,
 static bool index_unchanged_by_update(ResultRelInfo *resultRelInfo,
 									  EState *estate, IndexInfo *indexInfo,
 									  Relation indexRelation);
-static bool index_expression_changed_walker(Node *node,
-											Bitmapset *allUpdatedCols);
+static bool index_expression_changed_walker(Node *node, void *ctx);
+
 
 /* ----------------------------------------------------------------
  *		ExecOpenIndices
@@ -1052,8 +1052,10 @@ index_unchanged_by_update(ResultRelInfo *resultRelInfo, EState *estate,
  * Returns true when Var that appears within allUpdatedCols located.
  */
 static bool
-index_expression_changed_walker(Node *node, Bitmapset *allUpdatedCols)
+index_expression_changed_walker(Node *node, void *ctx)
 {
+	Bitmapset  *allUpdatedCols = ctx;
+
 	if (node == NULL)
 		return false;
 
@@ -1072,6 +1074,5 @@ index_expression_changed_walker(Node *node, Bitmapset *allUpdatedCols)
 		return false;
 	}
 
-	return expression_tree_walker(node, index_expression_changed_walker,
-								  (void *) allUpdatedCols);
+	return expression_tree_walker(node, index_expression_changed_walker, ctx);
 }
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index ef2fd46092..e0b73da435 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1691,7 +1691,7 @@ ExecutePlan(EState *estate,
 	 * point.
 	 */
 	if (!(estate->es_top_eflags & EXEC_FLAG_BACKWARD))
-		(void) ExecShutdownNode(planstate);
+		(void) ExecShutdownNode(planstate, NULL);
 
 	if (use_parallel_mode)
 		ExitParallelMode();
diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c
index f1fd7f7e8b..d7f402091f 100644
--- a/src/backend/executor/execParallel.c
+++ b/src/backend/executor/execParallel.c
@@ -126,16 +126,12 @@ typedef struct ExecParallelInitializeDSMContext
 
 /* Helper functions that run in the parallel leader. */
 static char *ExecSerializePlan(Plan *plan, EState *estate);
-static bool ExecParallelEstimate(PlanState *node,
-								 ExecParallelEstimateContext *e);
-static bool ExecParallelInitializeDSM(PlanState *node,
-									  ExecParallelInitializeDSMContext *d);
+static bool ExecParallelEstimate(PlanState *node, void *ctx);
+static bool ExecParallelInitializeDSM(PlanState *node, void *ctx);
 static shm_mq_handle **ExecParallelSetupTupleQueues(ParallelContext *pcxt,
 													bool reinitialize);
-static bool ExecParallelReInitializeDSM(PlanState *planstate,
-										ParallelContext *pcxt);
-static bool ExecParallelRetrieveInstrumentation(PlanState *planstate,
-												SharedExecutorInstrumentation *instrumentation);
+static bool ExecParallelReInitializeDSM(PlanState *planstate, void *ctx);
+static bool ExecParallelRetrieveInstrumentation(PlanState *planstate, void *ctx);
 
 /* Helper function that runs in the parallel worker. */
 static DestReceiver *ExecParallelGetReceiver(dsm_segment *seg, shm_toc *toc);
@@ -227,8 +223,10 @@ ExecSerializePlan(Plan *plan, EState *estate)
  * we know how many Instrumentation structures we need.
  */
 static bool
-ExecParallelEstimate(PlanState *planstate, ExecParallelEstimateContext *e)
+ExecParallelEstimate(PlanState *planstate, void *ctx)
 {
+	ExecParallelEstimateContext *e = ctx;
+
 	if (planstate == NULL)
 		return false;
 
@@ -301,7 +299,7 @@ ExecParallelEstimate(PlanState *planstate, ExecParallelEstimateContext *e)
 			break;
 	}
 
-	return planstate_tree_walker(planstate, ExecParallelEstimate, e);
+	return planstate_tree_walker(planstate, ExecParallelEstimate, ctx);
 }
 
 /*
@@ -436,9 +434,10 @@ RestoreParamExecParams(char *start_address, EState *estate)
  * parallel execution.
  */
 static bool
-ExecParallelInitializeDSM(PlanState *planstate,
-						  ExecParallelInitializeDSMContext *d)
+ExecParallelInitializeDSM(PlanState *planstate, void *ctx)
 {
+	ExecParallelInitializeDSMContext *d = ctx;
+
 	if (planstate == NULL)
 		return false;
 
@@ -525,7 +524,7 @@ ExecParallelInitializeDSM(PlanState *planstate,
 			break;
 	}
 
-	return planstate_tree_walker(planstate, ExecParallelInitializeDSM, d);
+	return planstate_tree_walker(planstate, ExecParallelInitializeDSM, ctx);
 }
 
 /*
@@ -944,9 +943,10 @@ ExecParallelReinitialize(PlanState *planstate,
  * Traverse plan tree to reinitialize per-node dynamic shared memory state
  */
 static bool
-ExecParallelReInitializeDSM(PlanState *planstate,
-							ParallelContext *pcxt)
+ExecParallelReInitializeDSM(PlanState *planstate, void *ctx)
 {
+	ParallelContext *pcxt = ctx;
+
 	if (planstate == NULL)
 		return false;
 
@@ -1005,7 +1005,7 @@ ExecParallelReInitializeDSM(PlanState *planstate,
 			break;
 	}
 
-	return planstate_tree_walker(planstate, ExecParallelReInitializeDSM, pcxt);
+	return planstate_tree_walker(planstate, ExecParallelReInitializeDSM, ctx);
 }
 
 /*
@@ -1013,9 +1013,9 @@ ExecParallelReInitializeDSM(PlanState *planstate,
  * dynamic shared memory.
  */
 static bool
-ExecParallelRetrieveInstrumentation(PlanState *planstate,
-									SharedExecutorInstrumentation *instrumentation)
+ExecParallelRetrieveInstrumentation(PlanState *planstate, void *ctx)
 {
+	SharedExecutorInstrumentation *instrumentation = ctx;
 	Instrumentation *instrument;
 	int			i;
 	int			n;
@@ -1075,7 +1075,7 @@ ExecParallelRetrieveInstrumentation(PlanState *planstate,
 	}
 
 	return planstate_tree_walker(planstate, ExecParallelRetrieveInstrumentation,
-								 instrumentation);
+								 ctx);
 }
 
 /*
@@ -1259,12 +1259,12 @@ ExecParallelGetQueryDesc(shm_toc *toc, DestReceiver *receiver,
  * dynamic shared memory, so that the parallel leader can retrieve it.
  */
 static bool
-ExecParallelReportInstrumentation(PlanState *planstate,
-								  SharedExecutorInstrumentation *instrumentation)
+ExecParallelReportInstrumentation(PlanState *planstate, void *ctx)
 {
-	int			i;
+	SharedExecutorInstrumentation *instrumentation = ctx;
 	int			plan_node_id = planstate->plan->plan_node_id;
 	Instrumentation *instrument;
+	int			i;
 
 	InstrEndLoop(planstate->instrument);
 
@@ -1291,7 +1291,7 @@ ExecParallelReportInstrumentation(PlanState *planstate,
 	InstrAggNode(&instrument[ParallelWorkerNumber], planstate->instrument);
 
 	return planstate_tree_walker(planstate, ExecParallelReportInstrumentation,
-								 instrumentation);
+								 ctx);
 }
 
 /*
@@ -1300,8 +1300,10 @@ ExecParallelReportInstrumentation(PlanState *planstate,
  * is allocated and initialized by executor; that is, after ExecutorStart().
  */
 static bool
-ExecParallelInitializeWorker(PlanState *planstate, ParallelWorkerContext *pwcxt)
+ExecParallelInitializeWorker(PlanState *planstate, void *ctx)
 {
+	ParallelWorkerContext *pwcxt = ctx;
+
 	if (planstate == NULL)
 		return false;
 
@@ -1370,8 +1372,7 @@ ExecParallelInitializeWorker(PlanState *planstate, ParallelWorkerContext *pwcxt)
 			break;
 	}
 
-	return planstate_tree_walker(planstate, ExecParallelInitializeWorker,
-								 pwcxt);
+	return planstate_tree_walker(planstate, ExecParallelInitializeWorker, ctx);
 }
 
 /*
diff --git a/src/backend/executor/execProcnode.c b/src/backend/executor/execProcnode.c
index b5667e53e5..18d9096be0 100644
--- a/src/backend/executor/execProcnode.c
+++ b/src/backend/executor/execProcnode.c
@@ -769,7 +769,7 @@ ExecEndNode(PlanState *node)
  * and release any resources still held.
  */
 bool
-ExecShutdownNode(PlanState *node)
+ExecShutdownNode(PlanState *node, void *ctx)
 {
 	if (node == NULL)
 		return false;
@@ -789,7 +789,7 @@ ExecShutdownNode(PlanState *node)
 	if (node->instrument && node->instrument->running)
 		InstrStartNode(node->instrument);
 
-	planstate_tree_walker(node, ExecShutdownNode, NULL);
+	planstate_tree_walker(node, ExecShutdownNode, ctx);
 
 	switch (nodeTag(node))
 	{
diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index 933c304901..1e31fe74e9 100644
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -401,7 +401,7 @@ static void finalize_aggregates(AggState *aggstate,
 static TupleTableSlot *project_aggregates(AggState *aggstate);
 static void find_cols(AggState *aggstate, Bitmapset **aggregated,
 					  Bitmapset **unaggregated);
-static bool find_cols_walker(Node *node, FindColsContext *context);
+static bool find_cols_walker(Node *node, void *ctx);
 static void build_hash_tables(AggState *aggstate);
 static void build_hash_table(AggState *aggstate, int setno, long nbuckets);
 static void hashagg_recompile_expressions(AggState *aggstate, bool minslot,
@@ -1414,8 +1414,10 @@ find_cols(AggState *aggstate, Bitmapset **aggregated, Bitmapset **unaggregated)
 }
 
 static bool
-find_cols_walker(Node *node, FindColsContext *context)
+find_cols_walker(Node *node, void *ctx)
 {
+	FindColsContext *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -1437,12 +1439,11 @@ find_cols_walker(Node *node, FindColsContext *context)
 	{
 		Assert(!context->is_aggref);
 		context->is_aggref = true;
-		expression_tree_walker(node, find_cols_walker, (void *) context);
+		expression_tree_walker(node, find_cols_walker, ctx);
 		context->is_aggref = false;
 		return false;
 	}
-	return expression_tree_walker(node, find_cols_walker,
-								  (void *) context);
+	return expression_tree_walker(node, find_cols_walker, ctx);
 }
 
 /*
diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index 3bac350bf5..06363dab40 100644
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -27,10 +27,12 @@
 static bool expression_returns_set_walker(Node *node, void *context);
 static int	leftmostLoc(int loc1, int loc2);
 static bool fix_opfuncids_walker(Node *node, void *context);
-static bool planstate_walk_subplans(List *plans, bool (*walker) (),
+static bool planstate_walk_subplans(List *plans,
+									planstate_tree_walker_callback walker,
 									void *context);
 static bool planstate_walk_members(PlanState **planstates, int nplans,
-								   bool (*walker) (), void *context);
+								   planstate_tree_walker_callback walker,
+								   void *context);
 
 
 /*
@@ -1836,7 +1838,7 @@ check_functions_in_node(Node *node, check_function_callback checker,
  * that modify nodes in-place but never add/delete/replace nodes).
  * A walker routine should look like this:
  *
- * bool my_walker (Node *node, my_struct *context)
+ * bool my_walker (Node *node, void *context)
  * {
  *		if (node == NULL)
  *			return false;
@@ -1850,7 +1852,7 @@ check_functions_in_node(Node *node, check_function_callback checker,
  *			... do special actions for other node types
  *		}
  *		// for any node type not specially processed, do:
- *		return expression_tree_walker(node, my_walker, (void *) context);
+ *		return expression_tree_walker(node, my_walker, context);
  * }
  *
  * The "context" argument points to a struct that holds whatever context
@@ -1910,7 +1912,7 @@ check_functions_in_node(Node *node, check_function_callback checker,
 
 bool
 expression_tree_walker(Node *node,
-					   bool (*walker) (),
+					   tree_walker_callback walker,
 					   void *context)
 {
 	ListCell   *temp;
@@ -1923,6 +1925,10 @@ expression_tree_walker(Node *node,
 	 * when we expect a List we just recurse directly to self without
 	 * bothering to call the walker.
 	 */
+#define WALK(n) walker((Node *) (n), context)
+
+#define LIST_WALK(l) expression_tree_walker((Node *) (l), walker, context)
+
 	if (node == NULL)
 		return false;
 
@@ -1946,25 +1952,21 @@ expression_tree_walker(Node *node,
 			/* primitive node types with no expression subnodes */
 			break;
 		case T_WithCheckOption:
-			return walker(((WithCheckOption *) node)->qual, context);
+			return WALK(((WithCheckOption *) node)->qual);
 		case T_Aggref:
 			{
 				Aggref	   *expr = (Aggref *) node;
 
-				/* recurse directly on List */
-				if (expression_tree_walker((Node *) expr->aggdirectargs,
-										   walker, context))
+				/* recurse directly on Lists */
+				if (LIST_WALK(expr->aggdirectargs))
 					return true;
-				if (expression_tree_walker((Node *) expr->args,
-										   walker, context))
+				if (LIST_WALK(expr->args))
 					return true;
-				if (expression_tree_walker((Node *) expr->aggorder,
-										   walker, context))
+				if (LIST_WALK(expr->aggorder))
 					return true;
-				if (expression_tree_walker((Node *) expr->aggdistinct,
-										   walker, context))
+				if (LIST_WALK(expr->aggdistinct))
 					return true;
-				if (walker((Node *) expr->aggfilter, context))
+				if (WALK(expr->aggfilter))
 					return true;
 			}
 			break;
@@ -1972,8 +1974,7 @@ expression_tree_walker(Node *node,
 			{
 				GroupingFunc *grouping = (GroupingFunc *) node;
 
-				if (expression_tree_walker((Node *) grouping->args,
-										   walker, context))
+				if (LIST_WALK(grouping->args))
 					return true;
 			}
 			break;
@@ -1982,10 +1983,9 @@ expression_tree_walker(Node *node,
 				WindowFunc *expr = (WindowFunc *) node;
 
 				/* recurse directly on List */
-				if (expression_tree_walker((Node *) expr->args,
-										   walker, context))
+				if (LIST_WALK(expr->args))
 					return true;
-				if (walker((Node *) expr->aggfilter, context))
+				if (WALK(expr->aggfilter))
 					return true;
 			}
 			break;
@@ -1994,17 +1994,15 @@ expression_tree_walker(Node *node,
 				SubscriptingRef *sbsref = (SubscriptingRef *) node;
 
 				/* recurse directly for upper/lower container index lists */
-				if (expression_tree_walker((Node *) sbsref->refupperindexpr,
-										   walker, context))
+				if (LIST_WALK(sbsref->refupperindexpr))
 					return true;
-				if (expression_tree_walker((Node *) sbsref->reflowerindexpr,
-										   walker, context))
+				if (LIST_WALK(sbsref->reflowerindexpr))
 					return true;
 				/* walker must see the refexpr and refassgnexpr, however */
-				if (walker(sbsref->refexpr, context))
+				if (WALK(sbsref->refexpr))
 					return true;
 
-				if (walker(sbsref->refassgnexpr, context))
+				if (WALK(sbsref->refassgnexpr))
 					return true;
 			}
 			break;
@@ -2012,21 +2010,19 @@ expression_tree_walker(Node *node,
 			{
 				FuncExpr   *expr = (FuncExpr *) node;
 
-				if (expression_tree_walker((Node *) expr->args,
-										   walker, context))
+				if (LIST_WALK(expr->args))
 					return true;
 			}
 			break;
 		case T_NamedArgExpr:
-			return walker(((NamedArgExpr *) node)->arg, context);
+			return WALK(((NamedArgExpr *) node)->arg);
 		case T_OpExpr:
 		case T_DistinctExpr:	/* struct-equivalent to OpExpr */
 		case T_NullIfExpr:		/* struct-equivalent to OpExpr */
 			{
 				OpExpr	   *expr = (OpExpr *) node;
 
-				if (expression_tree_walker((Node *) expr->args,
-										   walker, context))
+				if (LIST_WALK(expr->args))
 					return true;
 			}
 			break;
@@ -2034,8 +2030,7 @@ expression_tree_walker(Node *node,
 			{
 				ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
 
-				if (expression_tree_walker((Node *) expr->args,
-										   walker, context))
+				if (LIST_WALK(expr->args))
 					return true;
 			}
 			break;
@@ -2043,8 +2038,7 @@ expression_tree_walker(Node *node,
 			{
 				BoolExpr   *expr = (BoolExpr *) node;
 
-				if (expression_tree_walker((Node *) expr->args,
-										   walker, context))
+				if (LIST_WALK(expr->args))
 					return true;
 			}
 			break;
@@ -2052,14 +2046,14 @@ expression_tree_walker(Node *node,
 			{
 				SubLink    *sublink = (SubLink *) node;
 
-				if (walker(sublink->testexpr, context))
+				if (WALK(sublink->testexpr))
 					return true;
 
 				/*
 				 * Also invoke the walker on the sublink's Query node, so it
 				 * can recurse into the sub-query if it wants to.
 				 */
-				return walker(sublink->subselect, context);
+				return WALK(sublink->subselect);
 			}
 			break;
 		case T_SubPlan:
@@ -2067,104 +2061,103 @@ expression_tree_walker(Node *node,
 				SubPlan    *subplan = (SubPlan *) node;
 
 				/* recurse into the testexpr, but not into the Plan */
-				if (walker(subplan->testexpr, context))
+				if (WALK(subplan->testexpr))
 					return true;
 				/* also examine args list */
-				if (expression_tree_walker((Node *) subplan->args,
-										   walker, context))
+				if (LIST_WALK(subplan->args))
 					return true;
 			}
 			break;
 		case T_AlternativeSubPlan:
-			return walker(((AlternativeSubPlan *) node)->subplans, context);
+			return LIST_WALK(((AlternativeSubPlan *) node)->subplans);
 		case T_FieldSelect:
-			return walker(((FieldSelect *) node)->arg, context);
+			return WALK(((FieldSelect *) node)->arg);
 		case T_FieldStore:
 			{
 				FieldStore *fstore = (FieldStore *) node;
 
-				if (walker(fstore->arg, context))
+				if (WALK(fstore->arg))
 					return true;
-				if (walker(fstore->newvals, context))
+				if (WALK(fstore->newvals))
 					return true;
 			}
 			break;
 		case T_RelabelType:
-			return walker(((RelabelType *) node)->arg, context);
+			return WALK(((RelabelType *) node)->arg);
 		case T_CoerceViaIO:
-			return walker(((CoerceViaIO *) node)->arg, context);
+			return WALK(((CoerceViaIO *) node)->arg);
 		case T_ArrayCoerceExpr:
 			{
 				ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
 
-				if (walker(acoerce->arg, context))
+				if (WALK(acoerce->arg))
 					return true;
-				if (walker(acoerce->elemexpr, context))
+				if (WALK(acoerce->elemexpr))
 					return true;
 			}
 			break;
 		case T_ConvertRowtypeExpr:
-			return walker(((ConvertRowtypeExpr *) node)->arg, context);
+			return WALK(((ConvertRowtypeExpr *) node)->arg);
 		case T_CollateExpr:
-			return walker(((CollateExpr *) node)->arg, context);
+			return WALK(((CollateExpr *) node)->arg);
 		case T_CaseExpr:
 			{
 				CaseExpr   *caseexpr = (CaseExpr *) node;
 
-				if (walker(caseexpr->arg, context))
+				if (WALK(caseexpr->arg))
 					return true;
 				/* we assume walker doesn't care about CaseWhens, either */
 				foreach(temp, caseexpr->args)
 				{
 					CaseWhen   *when = lfirst_node(CaseWhen, temp);
 
-					if (walker(when->expr, context))
+					if (WALK(when->expr))
 						return true;
-					if (walker(when->result, context))
+					if (WALK(when->result))
 						return true;
 				}
-				if (walker(caseexpr->defresult, context))
+				if (WALK(caseexpr->defresult))
 					return true;
 			}
 			break;
 		case T_ArrayExpr:
-			return walker(((ArrayExpr *) node)->elements, context);
+			return WALK(((ArrayExpr *) node)->elements);
 		case T_RowExpr:
 			/* Assume colnames isn't interesting */
-			return walker(((RowExpr *) node)->args, context);
+			return WALK(((RowExpr *) node)->args);
 		case T_RowCompareExpr:
 			{
 				RowCompareExpr *rcexpr = (RowCompareExpr *) node;
 
-				if (walker(rcexpr->largs, context))
+				if (WALK(rcexpr->largs))
 					return true;
-				if (walker(rcexpr->rargs, context))
+				if (WALK(rcexpr->rargs))
 					return true;
 			}
 			break;
 		case T_CoalesceExpr:
-			return walker(((CoalesceExpr *) node)->args, context);
+			return WALK(((CoalesceExpr *) node)->args);
 		case T_MinMaxExpr:
-			return walker(((MinMaxExpr *) node)->args, context);
+			return WALK(((MinMaxExpr *) node)->args);
 		case T_XmlExpr:
 			{
 				XmlExpr    *xexpr = (XmlExpr *) node;
 
-				if (walker(xexpr->named_args, context))
+				if (WALK(xexpr->named_args))
 					return true;
 				/* we assume walker doesn't care about arg_names */
-				if (walker(xexpr->args, context))
+				if (WALK(xexpr->args))
 					return true;
 			}
 			break;
 		case T_NullTest:
-			return walker(((NullTest *) node)->arg, context);
+			return WALK(((NullTest *) node)->arg);
 		case T_BooleanTest:
-			return walker(((BooleanTest *) node)->arg, context);
+			return WALK(((BooleanTest *) node)->arg);
 		case T_CoerceToDomain:
-			return walker(((CoerceToDomain *) node)->arg, context);
+			return WALK(((CoerceToDomain *) node)->arg);
 		case T_TargetEntry:
-			return walker(((TargetEntry *) node)->expr, context);
+			return WALK(((TargetEntry *) node)->expr);
 		case T_Query:
 			/* Do nothing with a sub-Query, per discussion above */
 			break;
@@ -2172,13 +2165,13 @@ expression_tree_walker(Node *node,
 			{
 				WindowClause *wc = (WindowClause *) node;
 
-				if (walker(wc->partitionClause, context))
+				if (WALK(wc->partitionClause))
 					return true;
-				if (walker(wc->orderClause, context))
+				if (WALK(wc->orderClause))
 					return true;
-				if (walker(wc->startOffset, context))
+				if (WALK(wc->startOffset))
 					return true;
-				if (walker(wc->endOffset, context))
+				if (WALK(wc->endOffset))
 					return true;
 			}
 			break;
@@ -2186,9 +2179,9 @@ expression_tree_walker(Node *node,
 			{
 				CTECycleClause *cc = (CTECycleClause *) node;
 
-				if (walker(cc->cycle_mark_value, context))
+				if (WALK(cc->cycle_mark_value))
 					return true;
-				if (walker(cc->cycle_mark_default, context))
+				if (WALK(cc->cycle_mark_default))
 					return true;
 			}
 			break;
@@ -2200,12 +2193,12 @@ expression_tree_walker(Node *node,
 				 * Invoke the walker on the CTE's Query node, so it can
 				 * recurse into the sub-query if it wants to.
 				 */
-				if (walker(cte->ctequery, context))
+				if (WALK(cte->ctequery))
 					return true;
 
-				if (walker(cte->search_clause, context))
+				if (WALK(cte->search_clause))
 					return true;
-				if (walker(cte->cycle_clause, context))
+				if (WALK(cte->cycle_clause))
 					return true;
 			}
 			break;
@@ -2213,11 +2206,11 @@ expression_tree_walker(Node *node,
 			{
 				PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
 
-				if (walker(pbs->listdatums, context))
+				if (WALK(pbs->listdatums))
 					return true;
-				if (walker(pbs->lowerdatums, context))
+				if (WALK(pbs->lowerdatums))
 					return true;
-				if (walker(pbs->upperdatums, context))
+				if (WALK(pbs->upperdatums))
 					return true;
 			}
 			break;
@@ -2225,14 +2218,14 @@ expression_tree_walker(Node *node,
 			{
 				PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
 
-				if (walker(prd->value, context))
+				if (WALK(prd->value))
 					return true;
 			}
 			break;
 		case T_List:
 			foreach(temp, (List *) node)
 			{
-				if (walker((Node *) lfirst(temp), context))
+				if (WALK(lfirst(temp)))
 					return true;
 			}
 			break;
@@ -2240,9 +2233,9 @@ expression_tree_walker(Node *node,
 			{
 				FromExpr   *from = (FromExpr *) node;
 
-				if (walker(from->fromlist, context))
+				if (LIST_WALK(from->fromlist))
 					return true;
-				if (walker(from->quals, context))
+				if (WALK(from->quals))
 					return true;
 			}
 			break;
@@ -2250,15 +2243,15 @@ expression_tree_walker(Node *node,
 			{
 				OnConflictExpr *onconflict = (OnConflictExpr *) node;
 
-				if (walker((Node *) onconflict->arbiterElems, context))
+				if (WALK(onconflict->arbiterElems))
 					return true;
-				if (walker(onconflict->arbiterWhere, context))
+				if (WALK(onconflict->arbiterWhere))
 					return true;
-				if (walker(onconflict->onConflictSet, context))
+				if (WALK(onconflict->onConflictSet))
 					return true;
-				if (walker(onconflict->onConflictWhere, context))
+				if (WALK(onconflict->onConflictWhere))
 					return true;
-				if (walker(onconflict->exclRelTlist, context))
+				if (WALK(onconflict->exclRelTlist))
 					return true;
 			}
 			break;
@@ -2266,9 +2259,9 @@ expression_tree_walker(Node *node,
 			{
 				MergeAction *action = (MergeAction *) node;
 
-				if (walker(action->targetList, context))
+				if (WALK(action->targetList))
 					return true;
-				if (walker(action->qual, context))
+				if (WALK(action->qual))
 					return true;
 			}
 			break;
@@ -2276,7 +2269,7 @@ expression_tree_walker(Node *node,
 			{
 				PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
 
-				if (walker((Node *) opstep->exprs, context))
+				if (WALK(opstep->exprs))
 					return true;
 			}
 			break;
@@ -2287,11 +2280,11 @@ expression_tree_walker(Node *node,
 			{
 				JoinExpr   *join = (JoinExpr *) node;
 
-				if (walker(join->larg, context))
+				if (WALK(join->larg))
 					return true;
-				if (walker(join->rarg, context))
+				if (WALK(join->rarg))
 					return true;
-				if (walker(join->quals, context))
+				if (WALK(join->quals))
 					return true;
 
 				/*
@@ -2303,9 +2296,9 @@ expression_tree_walker(Node *node,
 			{
 				SetOperationStmt *setop = (SetOperationStmt *) node;
 
-				if (walker(setop->larg, context))
+				if (WALK(setop->larg))
 					return true;
-				if (walker(setop->rarg, context))
+				if (WALK(setop->rarg))
 					return true;
 
 				/* groupClauses are deemed uninteresting */
@@ -2315,38 +2308,35 @@ expression_tree_walker(Node *node,
 			{
 				IndexClause *iclause = (IndexClause *) node;
 
-				if (walker(iclause->rinfo, context))
+				if (WALK(iclause->rinfo))
 					return true;
-				if (expression_tree_walker((Node *) iclause->indexquals,
-										   walker, context))
+				if (LIST_WALK(iclause->indexquals))
 					return true;
 			}
 			break;
 		case T_PlaceHolderVar:
-			return walker(((PlaceHolderVar *) node)->phexpr, context);
+			return WALK(((PlaceHolderVar *) node)->phexpr);
 		case T_InferenceElem:
-			return walker(((InferenceElem *) node)->expr, context);
+			return WALK(((InferenceElem *) node)->expr);
 		case T_AppendRelInfo:
 			{
 				AppendRelInfo *appinfo = (AppendRelInfo *) node;
 
-				if (expression_tree_walker((Node *) appinfo->translated_vars,
-										   walker, context))
+				if (LIST_WALK(appinfo->translated_vars))
 					return true;
 			}
 			break;
 		case T_PlaceHolderInfo:
-			return walker(((PlaceHolderInfo *) node)->ph_var, context);
+			return WALK(((PlaceHolderInfo *) node)->ph_var);
 		case T_RangeTblFunction:
-			return walker(((RangeTblFunction *) node)->funcexpr, context);
+			return WALK(((RangeTblFunction *) node)->funcexpr);
 		case T_TableSampleClause:
 			{
 				TableSampleClause *tsc = (TableSampleClause *) node;
 
-				if (expression_tree_walker((Node *) tsc->args,
-										   walker, context))
+				if (LIST_WALK(tsc->args))
 					return true;
-				if (walker((Node *) tsc->repeatable, context))
+				if (WALK(tsc->repeatable))
 					return true;
 			}
 			break;
@@ -2354,15 +2344,15 @@ expression_tree_walker(Node *node,
 			{
 				TableFunc  *tf = (TableFunc *) node;
 
-				if (walker(tf->ns_uris, context))
+				if (WALK(tf->ns_uris))
 					return true;
-				if (walker(tf->docexpr, context))
+				if (WALK(tf->docexpr))
 					return true;
-				if (walker(tf->rowexpr, context))
+				if (WALK(tf->rowexpr))
 					return true;
-				if (walker(tf->colexprs, context))
+				if (WALK(tf->colexprs))
 					return true;
-				if (walker(tf->coldefexprs, context))
+				if (WALK(tf->coldefexprs))
 					return true;
 			}
 			break;
@@ -2372,6 +2362,9 @@ expression_tree_walker(Node *node,
 			break;
 	}
 	return false;
+
+	/* The WALK() macro can be re-used below, but LIST_WALK() not so much */
+#undef LIST_WALK
 }
 
 /*
@@ -2391,7 +2384,7 @@ expression_tree_walker(Node *node,
  */
 bool
 query_tree_walker(Query *query,
-				  bool (*walker) (),
+				  tree_walker_callback walker,
 				  void *context,
 				  int flags)
 {
@@ -2404,25 +2397,25 @@ query_tree_walker(Query *query,
 	 * in a rule action.
 	 */
 
-	if (walker((Node *) query->targetList, context))
+	if (WALK(query->targetList))
 		return true;
-	if (walker((Node *) query->withCheckOptions, context))
+	if (WALK(query->withCheckOptions))
 		return true;
-	if (walker((Node *) query->onConflict, context))
+	if (WALK(query->onConflict))
 		return true;
-	if (walker((Node *) query->mergeActionList, context))
+	if (WALK(query->mergeActionList))
 		return true;
-	if (walker((Node *) query->returningList, context))
+	if (WALK(query->returningList))
 		return true;
-	if (walker((Node *) query->jointree, context))
+	if (WALK(query->jointree))
 		return true;
-	if (walker(query->setOperations, context))
+	if (WALK(query->setOperations))
 		return true;
-	if (walker(query->havingQual, context))
+	if (WALK(query->havingQual))
 		return true;
-	if (walker(query->limitOffset, context))
+	if (WALK(query->limitOffset))
 		return true;
-	if (walker(query->limitCount, context))
+	if (WALK(query->limitCount))
 		return true;
 
 	/*
@@ -2432,13 +2425,13 @@ query_tree_walker(Query *query,
 	 */
 	if ((flags & QTW_EXAMINE_SORTGROUP))
 	{
-		if (walker((Node *) query->groupClause, context))
+		if (WALK(query->groupClause))
 			return true;
-		if (walker((Node *) query->windowClause, context))
+		if (WALK(query->windowClause))
 			return true;
-		if (walker((Node *) query->sortClause, context))
+		if (WALK(query->sortClause))
 			return true;
-		if (walker((Node *) query->distinctClause, context))
+		if (WALK(query->distinctClause))
 			return true;
 	}
 	else
@@ -2453,9 +2446,9 @@ query_tree_walker(Query *query,
 		{
 			WindowClause *wc = lfirst_node(WindowClause, lc);
 
-			if (walker(wc->startOffset, context))
+			if (WALK(wc->startOffset))
 				return true;
-			if (walker(wc->endOffset, context))
+			if (WALK(wc->endOffset))
 				return true;
 		}
 	}
@@ -2474,7 +2467,7 @@ query_tree_walker(Query *query,
 
 	if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
 	{
-		if (walker((Node *) query->cteList, context))
+		if (WALK(query->cteList))
 			return true;
 	}
 	if (!(flags & QTW_IGNORE_RANGE_TABLE))
@@ -2492,7 +2485,7 @@ query_tree_walker(Query *query,
  */
 bool
 range_table_walker(List *rtable,
-				   bool (*walker) (),
+				   tree_walker_callback walker,
 				   void *context,
 				   int flags)
 {
@@ -2513,7 +2506,7 @@ range_table_walker(List *rtable,
  */
 bool
 range_table_entry_walker(RangeTblEntry *rte,
-						 bool (*walker) (),
+						 tree_walker_callback walker,
 						 void *context,
 						 int flags)
 {
@@ -2523,35 +2516,35 @@ range_table_entry_walker(RangeTblEntry *rte,
 	 * specify neither flag, the walker won't be called on the RTE at all.
 	 */
 	if (flags & QTW_EXAMINE_RTES_BEFORE)
-		if (walker(rte, context))
+		if (WALK(rte))
 			return true;
 
 	switch (rte->rtekind)
 	{
 		case RTE_RELATION:
-			if (walker(rte->tablesample, context))
+			if (WALK(rte->tablesample))
 				return true;
 			break;
 		case RTE_SUBQUERY:
 			if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
-				if (walker(rte->subquery, context))
+				if (WALK(rte->subquery))
 					return true;
 			break;
 		case RTE_JOIN:
 			if (!(flags & QTW_IGNORE_JOINALIASES))
-				if (walker(rte->joinaliasvars, context))
+				if (WALK(rte->joinaliasvars))
 					return true;
 			break;
 		case RTE_FUNCTION:
-			if (walker(rte->functions, context))
+			if (WALK(rte->functions))
 				return true;
 			break;
 		case RTE_TABLEFUNC:
-			if (walker(rte->tablefunc, context))
+			if (WALK(rte->tablefunc))
 				return true;
 			break;
 		case RTE_VALUES:
-			if (walker(rte->values_lists, context))
+			if (WALK(rte->values_lists))
 				return true;
 			break;
 		case RTE_CTE:
@@ -2561,11 +2554,11 @@ range_table_entry_walker(RangeTblEntry *rte,
 			break;
 	}
 
-	if (walker(rte->securityQuals, context))
+	if (WALK(rte->securityQuals))
 		return true;
 
 	if (flags & QTW_EXAMINE_RTES_AFTER)
-		if (walker(rte, context))
+		if (WALK(rte))
 			return true;
 
 	return false;
@@ -2580,7 +2573,7 @@ range_table_entry_walker(RangeTblEntry *rte,
  * (or appropriately modified substitute for) the subtree it is handed.
  * A mutator routine should look like this:
  *
- * Node * my_mutator (Node *node, my_struct *context)
+ * Node * my_mutator (Node *node, void *context)
  * {
  *		if (node == NULL)
  *			return NULL;
@@ -2594,7 +2587,7 @@ range_table_entry_walker(RangeTblEntry *rte,
  *			... do special transformations of other node types
  *		}
  *		// for any node type not specially processed, do:
- *		return expression_tree_mutator(node, my_mutator, (void *) context);
+ *		return expression_tree_mutator(node, my_mutator, context);
  * }
  *
  * The "context" argument points to a struct that holds whatever context
@@ -2636,7 +2629,7 @@ range_table_entry_walker(RangeTblEntry *rte,
 
 Node *
 expression_tree_mutator(Node *node,
-						Node *(*mutator) (),
+						tree_mutator_callback mutator,
 						void *context)
 {
 	/*
@@ -3367,7 +3360,7 @@ expression_tree_mutator(Node *node,
  */
 Query *
 query_tree_mutator(Query *query,
-				   Node *(*mutator) (),
+				   tree_mutator_callback mutator,
 				   void *context,
 				   int flags)
 {
@@ -3457,7 +3450,7 @@ query_tree_mutator(Query *query,
  */
 List *
 range_table_mutator(List *rtable,
-					Node *(*mutator) (),
+					tree_mutator_callback mutator,
 					void *context,
 					int flags)
 {
@@ -3526,7 +3519,7 @@ range_table_mutator(List *rtable,
  */
 bool
 query_or_expression_tree_walker(Node *node,
-								bool (*walker) (),
+								tree_walker_callback walker,
 								void *context,
 								int flags)
 {
@@ -3536,7 +3529,7 @@ query_or_expression_tree_walker(Node *node,
 								 context,
 								 flags);
 	else
-		return walker(node, context);
+		return WALK(node);
 }
 
 /*
@@ -3549,7 +3542,7 @@ query_or_expression_tree_walker(Node *node,
  */
 Node *
 query_or_expression_tree_mutator(Node *node,
-								 Node *(*mutator) (),
+								 tree_mutator_callback mutator,
 								 void *context,
 								 int flags)
 {
@@ -3580,7 +3573,7 @@ query_or_expression_tree_mutator(Node *node,
  */
 bool
 raw_expression_tree_walker(Node *node,
-						   bool (*walker) (),
+						   tree_walker_callback walker,
 						   void *context)
 {
 	ListCell   *temp;
@@ -3614,17 +3607,17 @@ raw_expression_tree_walker(Node *node,
 			/* we assume the colnames list isn't interesting */
 			break;
 		case T_RangeVar:
-			return walker(((RangeVar *) node)->alias, context);
+			return WALK(((RangeVar *) node)->alias);
 		case T_GroupingFunc:
-			return walker(((GroupingFunc *) node)->args, context);
+			return WALK(((GroupingFunc *) node)->args);
 		case T_SubLink:
 			{
 				SubLink    *sublink = (SubLink *) node;
 
-				if (walker(sublink->testexpr, context))
+				if (WALK(sublink->testexpr))
 					return true;
 				/* we assume the operName is not interesting */
-				if (walker(sublink->subselect, context))
+				if (WALK(sublink->subselect))
 					return true;
 			}
 			break;
@@ -3632,55 +3625,55 @@ raw_expression_tree_walker(Node *node,
 			{
 				CaseExpr   *caseexpr = (CaseExpr *) node;
 
-				if (walker(caseexpr->arg, context))
+				if (WALK(caseexpr->arg))
 					return true;
 				/* we assume walker doesn't care about CaseWhens, either */
 				foreach(temp, caseexpr->args)
 				{
 					CaseWhen   *when = lfirst_node(CaseWhen, temp);
 
-					if (walker(when->expr, context))
+					if (WALK(when->expr))
 						return true;
-					if (walker(when->result, context))
+					if (WALK(when->result))
 						return true;
 				}
-				if (walker(caseexpr->defresult, context))
+				if (WALK(caseexpr->defresult))
 					return true;
 			}
 			break;
 		case T_RowExpr:
 			/* Assume colnames isn't interesting */
-			return walker(((RowExpr *) node)->args, context);
+			return WALK(((RowExpr *) node)->args);
 		case T_CoalesceExpr:
-			return walker(((CoalesceExpr *) node)->args, context);
+			return WALK(((CoalesceExpr *) node)->args);
 		case T_MinMaxExpr:
-			return walker(((MinMaxExpr *) node)->args, context);
+			return WALK(((MinMaxExpr *) node)->args);
 		case T_XmlExpr:
 			{
 				XmlExpr    *xexpr = (XmlExpr *) node;
 
-				if (walker(xexpr->named_args, context))
+				if (WALK(xexpr->named_args))
 					return true;
 				/* we assume walker doesn't care about arg_names */
-				if (walker(xexpr->args, context))
+				if (WALK(xexpr->args))
 					return true;
 			}
 			break;
 		case T_NullTest:
-			return walker(((NullTest *) node)->arg, context);
+			return WALK(((NullTest *) node)->arg);
 		case T_BooleanTest:
-			return walker(((BooleanTest *) node)->arg, context);
+			return WALK(((BooleanTest *) node)->arg);
 		case T_JoinExpr:
 			{
 				JoinExpr   *join = (JoinExpr *) node;
 
-				if (walker(join->larg, context))
+				if (WALK(join->larg))
 					return true;
-				if (walker(join->rarg, context))
+				if (WALK(join->rarg))
 					return true;
-				if (walker(join->quals, context))
+				if (WALK(join->quals))
 					return true;
-				if (walker(join->alias, context))
+				if (WALK(join->alias))
 					return true;
 				/* using list is deemed uninteresting */
 			}
@@ -3689,18 +3682,18 @@ raw_expression_tree_walker(Node *node,
 			{
 				IntoClause *into = (IntoClause *) node;
 
-				if (walker(into->rel, context))
+				if (WALK(into->rel))
 					return true;
 				/* colNames, options are deemed uninteresting */
 				/* viewQuery should be null in raw parsetree, but check it */
-				if (walker(into->viewQuery, context))
+				if (WALK(into->viewQuery))
 					return true;
 			}
 			break;
 		case T_List:
 			foreach(temp, (List *) node)
 			{
-				if (walker((Node *) lfirst(temp), context))
+				if (WALK((Node *) lfirst(temp)))
 					return true;
 			}
 			break;
@@ -3708,17 +3701,17 @@ raw_expression_tree_walker(Node *node,
 			{
 				InsertStmt *stmt = (InsertStmt *) node;
 
-				if (walker(stmt->relation, context))
+				if (WALK(stmt->relation))
 					return true;
-				if (walker(stmt->cols, context))
+				if (WALK(stmt->cols))
 					return true;
-				if (walker(stmt->selectStmt, context))
+				if (WALK(stmt->selectStmt))
 					return true;
-				if (walker(stmt->onConflictClause, context))
+				if (WALK(stmt->onConflictClause))
 					return true;
-				if (walker(stmt->returningList, context))
+				if (WALK(stmt->returningList))
 					return true;
-				if (walker(stmt->withClause, context))
+				if (WALK(stmt->withClause))
 					return true;
 			}
 			break;
@@ -3726,15 +3719,15 @@ raw_expression_tree_walker(Node *node,
 			{
 				DeleteStmt *stmt = (DeleteStmt *) node;
 
-				if (walker(stmt->relation, context))
+				if (WALK(stmt->relation))
 					return true;
-				if (walker(stmt->usingClause, context))
+				if (WALK(stmt->usingClause))
 					return true;
-				if (walker(stmt->whereClause, context))
+				if (WALK(stmt->whereClause))
 					return true;
-				if (walker(stmt->returningList, context))
+				if (WALK(stmt->returningList))
 					return true;
-				if (walker(stmt->withClause, context))
+				if (WALK(stmt->withClause))
 					return true;
 			}
 			break;
@@ -3742,17 +3735,17 @@ raw_expression_tree_walker(Node *node,
 			{
 				UpdateStmt *stmt = (UpdateStmt *) node;
 
-				if (walker(stmt->relation, context))
+				if (WALK(stmt->relation))
 					return true;
-				if (walker(stmt->targetList, context))
+				if (WALK(stmt->targetList))
 					return true;
-				if (walker(stmt->whereClause, context))
+				if (WALK(stmt->whereClause))
 					return true;
-				if (walker(stmt->fromClause, context))
+				if (WALK(stmt->fromClause))
 					return true;
-				if (walker(stmt->returningList, context))
+				if (WALK(stmt->returningList))
 					return true;
-				if (walker(stmt->withClause, context))
+				if (WALK(stmt->withClause))
 					return true;
 			}
 			break;
@@ -3760,15 +3753,15 @@ raw_expression_tree_walker(Node *node,
 			{
 				MergeStmt  *stmt = (MergeStmt *) node;
 
-				if (walker(stmt->relation, context))
+				if (WALK(stmt->relation))
 					return true;
-				if (walker(stmt->sourceRelation, context))
+				if (WALK(stmt->sourceRelation))
 					return true;
-				if (walker(stmt->joinCondition, context))
+				if (WALK(stmt->joinCondition))
 					return true;
-				if (walker(stmt->mergeWhenClauses, context))
+				if (WALK(stmt->mergeWhenClauses))
 					return true;
-				if (walker(stmt->withClause, context))
+				if (WALK(stmt->withClause))
 					return true;
 			}
 			break;
@@ -3776,11 +3769,11 @@ raw_expression_tree_walker(Node *node,
 			{
 				MergeWhenClause *mergeWhenClause = (MergeWhenClause *) node;
 
-				if (walker(mergeWhenClause->condition, context))
+				if (WALK(mergeWhenClause->condition))
 					return true;
-				if (walker(mergeWhenClause->targetList, context))
+				if (WALK(mergeWhenClause->targetList))
 					return true;
-				if (walker(mergeWhenClause->values, context))
+				if (WALK(mergeWhenClause->values))
 					return true;
 			}
 			break;
@@ -3788,37 +3781,37 @@ raw_expression_tree_walker(Node *node,
 			{
 				SelectStmt *stmt = (SelectStmt *) node;
 
-				if (walker(stmt->distinctClause, context))
+				if (WALK(stmt->distinctClause))
 					return true;
-				if (walker(stmt->intoClause, context))
+				if (WALK(stmt->intoClause))
 					return true;
-				if (walker(stmt->targetList, context))
+				if (WALK(stmt->targetList))
 					return true;
-				if (walker(stmt->fromClause, context))
+				if (WALK(stmt->fromClause))
 					return true;
-				if (walker(stmt->whereClause, context))
+				if (WALK(stmt->whereClause))
 					return true;
-				if (walker(stmt->groupClause, context))
+				if (WALK(stmt->groupClause))
 					return true;
-				if (walker(stmt->havingClause, context))
+				if (WALK(stmt->havingClause))
 					return true;
-				if (walker(stmt->windowClause, context))
+				if (WALK(stmt->windowClause))
 					return true;
-				if (walker(stmt->valuesLists, context))
+				if (WALK(stmt->valuesLists))
 					return true;
-				if (walker(stmt->sortClause, context))
+				if (WALK(stmt->sortClause))
 					return true;
-				if (walker(stmt->limitOffset, context))
+				if (WALK(stmt->limitOffset))
 					return true;
-				if (walker(stmt->limitCount, context))
+				if (WALK(stmt->limitCount))
 					return true;
-				if (walker(stmt->lockingClause, context))
+				if (WALK(stmt->lockingClause))
 					return true;
-				if (walker(stmt->withClause, context))
+				if (WALK(stmt->withClause))
 					return true;
-				if (walker(stmt->larg, context))
+				if (WALK(stmt->larg))
 					return true;
-				if (walker(stmt->rarg, context))
+				if (WALK(stmt->rarg))
 					return true;
 			}
 			break;
@@ -3826,9 +3819,9 @@ raw_expression_tree_walker(Node *node,
 			{
 				PLAssignStmt *stmt = (PLAssignStmt *) node;
 
-				if (walker(stmt->indirection, context))
+				if (WALK(stmt->indirection))
 					return true;
-				if (walker(stmt->val, context))
+				if (WALK(stmt->val))
 					return true;
 			}
 			break;
@@ -3836,9 +3829,9 @@ raw_expression_tree_walker(Node *node,
 			{
 				A_Expr	   *expr = (A_Expr *) node;
 
-				if (walker(expr->lexpr, context))
+				if (WALK(expr->lexpr))
 					return true;
-				if (walker(expr->rexpr, context))
+				if (WALK(expr->rexpr))
 					return true;
 				/* operator name is deemed uninteresting */
 			}
@@ -3847,7 +3840,7 @@ raw_expression_tree_walker(Node *node,
 			{
 				BoolExpr   *expr = (BoolExpr *) node;
 
-				if (walker(expr->args, context))
+				if (WALK(expr->args))
 					return true;
 			}
 			break;
@@ -3858,26 +3851,26 @@ raw_expression_tree_walker(Node *node,
 			{
 				FuncCall   *fcall = (FuncCall *) node;
 
-				if (walker(fcall->args, context))
+				if (WALK(fcall->args))
 					return true;
-				if (walker(fcall->agg_order, context))
+				if (WALK(fcall->agg_order))
 					return true;
-				if (walker(fcall->agg_filter, context))
+				if (WALK(fcall->agg_filter))
 					return true;
-				if (walker(fcall->over, context))
+				if (WALK(fcall->over))
 					return true;
 				/* function name is deemed uninteresting */
 			}
 			break;
 		case T_NamedArgExpr:
-			return walker(((NamedArgExpr *) node)->arg, context);
+			return WALK(((NamedArgExpr *) node)->arg);
 		case T_A_Indices:
 			{
 				A_Indices  *indices = (A_Indices *) node;
 
-				if (walker(indices->lidx, context))
+				if (WALK(indices->lidx))
 					return true;
-				if (walker(indices->uidx, context))
+				if (WALK(indices->uidx))
 					return true;
 			}
 			break;
@@ -3885,51 +3878,51 @@ raw_expression_tree_walker(Node *node,
 			{
 				A_Indirection *indir = (A_Indirection *) node;
 
-				if (walker(indir->arg, context))
+				if (WALK(indir->arg))
 					return true;
-				if (walker(indir->indirection, context))
+				if (WALK(indir->indirection))
 					return true;
 			}
 			break;
 		case T_A_ArrayExpr:
-			return walker(((A_ArrayExpr *) node)->elements, context);
+			return WALK(((A_ArrayExpr *) node)->elements);
 		case T_ResTarget:
 			{
 				ResTarget  *rt = (ResTarget *) node;
 
-				if (walker(rt->indirection, context))
+				if (WALK(rt->indirection))
 					return true;
-				if (walker(rt->val, context))
+				if (WALK(rt->val))
 					return true;
 			}
 			break;
 		case T_MultiAssignRef:
-			return walker(((MultiAssignRef *) node)->source, context);
+			return WALK(((MultiAssignRef *) node)->source);
 		case T_TypeCast:
 			{
 				TypeCast   *tc = (TypeCast *) node;
 
-				if (walker(tc->arg, context))
+				if (WALK(tc->arg))
 					return true;
-				if (walker(tc->typeName, context))
+				if (WALK(tc->typeName))
 					return true;
 			}
 			break;
 		case T_CollateClause:
-			return walker(((CollateClause *) node)->arg, context);
+			return WALK(((CollateClause *) node)->arg);
 		case T_SortBy:
-			return walker(((SortBy *) node)->node, context);
+			return WALK(((SortBy *) node)->node);
 		case T_WindowDef:
 			{
 				WindowDef  *wd = (WindowDef *) node;
 
-				if (walker(wd->partitionClause, context))
+				if (WALK(wd->partitionClause))
 					return true;
-				if (walker(wd->orderClause, context))
+				if (WALK(wd->orderClause))
 					return true;
-				if (walker(wd->startOffset, context))
+				if (WALK(wd->startOffset))
 					return true;
-				if (walker(wd->endOffset, context))
+				if (WALK(wd->endOffset))
 					return true;
 			}
 			break;
@@ -3937,9 +3930,9 @@ raw_expression_tree_walker(Node *node,
 			{
 				RangeSubselect *rs = (RangeSubselect *) node;
 
-				if (walker(rs->subquery, context))
+				if (WALK(rs->subquery))
 					return true;
-				if (walker(rs->alias, context))
+				if (WALK(rs->alias))
 					return true;
 			}
 			break;
@@ -3947,11 +3940,11 @@ raw_expression_tree_walker(Node *node,
 			{
 				RangeFunction *rf = (RangeFunction *) node;
 
-				if (walker(rf->functions, context))
+				if (WALK(rf->functions))
 					return true;
-				if (walker(rf->alias, context))
+				if (WALK(rf->alias))
 					return true;
-				if (walker(rf->coldeflist, context))
+				if (WALK(rf->coldeflist))
 					return true;
 			}
 			break;
@@ -3959,12 +3952,12 @@ raw_expression_tree_walker(Node *node,
 			{
 				RangeTableSample *rts = (RangeTableSample *) node;
 
-				if (walker(rts->relation, context))
+				if (WALK(rts->relation))
 					return true;
 				/* method name is deemed uninteresting */
-				if (walker(rts->args, context))
+				if (WALK(rts->args))
 					return true;
-				if (walker(rts->repeatable, context))
+				if (WALK(rts->repeatable))
 					return true;
 			}
 			break;
@@ -3972,15 +3965,15 @@ raw_expression_tree_walker(Node *node,
 			{
 				RangeTableFunc *rtf = (RangeTableFunc *) node;
 
-				if (walker(rtf->docexpr, context))
+				if (WALK(rtf->docexpr))
 					return true;
-				if (walker(rtf->rowexpr, context))
+				if (WALK(rtf->rowexpr))
 					return true;
-				if (walker(rtf->namespaces, context))
+				if (WALK(rtf->namespaces))
 					return true;
-				if (walker(rtf->columns, context))
+				if (WALK(rtf->columns))
 					return true;
-				if (walker(rtf->alias, context))
+				if (WALK(rtf->alias))
 					return true;
 			}
 			break;
@@ -3988,9 +3981,9 @@ raw_expression_tree_walker(Node *node,
 			{
 				RangeTableFuncCol *rtfc = (RangeTableFuncCol *) node;
 
-				if (walker(rtfc->colexpr, context))
+				if (WALK(rtfc->colexpr))
 					return true;
-				if (walker(rtfc->coldefexpr, context))
+				if (WALK(rtfc->coldefexpr))
 					return true;
 			}
 			break;
@@ -3998,9 +3991,9 @@ raw_expression_tree_walker(Node *node,
 			{
 				TypeName   *tn = (TypeName *) node;
 
-				if (walker(tn->typmods, context))
+				if (WALK(tn->typmods))
 					return true;
-				if (walker(tn->arrayBounds, context))
+				if (WALK(tn->arrayBounds))
 					return true;
 				/* type name itself is deemed uninteresting */
 			}
@@ -4009,13 +4002,13 @@ raw_expression_tree_walker(Node *node,
 			{
 				ColumnDef  *coldef = (ColumnDef *) node;
 
-				if (walker(coldef->typeName, context))
+				if (WALK(coldef->typeName))
 					return true;
-				if (walker(coldef->compression, context))
+				if (WALK(coldef->compression))
 					return true;
-				if (walker(coldef->raw_default, context))
+				if (WALK(coldef->raw_default))
 					return true;
-				if (walker(coldef->collClause, context))
+				if (WALK(coldef->collClause))
 					return true;
 				/* for now, constraints are ignored */
 			}
@@ -4024,34 +4017,34 @@ raw_expression_tree_walker(Node *node,
 			{
 				IndexElem  *indelem = (IndexElem *) node;
 
-				if (walker(indelem->expr, context))
+				if (WALK(indelem->expr))
 					return true;
 				/* collation and opclass names are deemed uninteresting */
 			}
 			break;
 		case T_GroupingSet:
-			return walker(((GroupingSet *) node)->content, context);
+			return WALK(((GroupingSet *) node)->content);
 		case T_LockingClause:
-			return walker(((LockingClause *) node)->lockedRels, context);
+			return WALK(((LockingClause *) node)->lockedRels);
 		case T_XmlSerialize:
 			{
 				XmlSerialize *xs = (XmlSerialize *) node;
 
-				if (walker(xs->expr, context))
+				if (WALK(xs->expr))
 					return true;
-				if (walker(xs->typeName, context))
+				if (WALK(xs->typeName))
 					return true;
 			}
 			break;
 		case T_WithClause:
-			return walker(((WithClause *) node)->ctes, context);
+			return WALK(((WithClause *) node)->ctes);
 		case T_InferClause:
 			{
 				InferClause *stmt = (InferClause *) node;
 
-				if (walker(stmt->indexElems, context))
+				if (WALK(stmt->indexElems))
 					return true;
-				if (walker(stmt->whereClause, context))
+				if (WALK(stmt->whereClause))
 					return true;
 			}
 			break;
@@ -4059,17 +4052,17 @@ raw_expression_tree_walker(Node *node,
 			{
 				OnConflictClause *stmt = (OnConflictClause *) node;
 
-				if (walker(stmt->infer, context))
+				if (WALK(stmt->infer))
 					return true;
-				if (walker(stmt->targetList, context))
+				if (WALK(stmt->targetList))
 					return true;
-				if (walker(stmt->whereClause, context))
+				if (WALK(stmt->whereClause))
 					return true;
 			}
 			break;
 		case T_CommonTableExpr:
 			/* search_clause and cycle_clause are not interesting here */
-			return walker(((CommonTableExpr *) node)->ctequery, context);
+			return WALK(((CommonTableExpr *) node)->ctequery);
 		default:
 			elog(ERROR, "unrecognized node type: %d",
 				 (int) nodeTag(node));
@@ -4086,12 +4079,15 @@ raw_expression_tree_walker(Node *node,
  */
 bool
 planstate_tree_walker(PlanState *planstate,
-					  bool (*walker) (),
+					  planstate_tree_walker_callback walker,
 					  void *context)
 {
 	Plan	   *plan = planstate->plan;
 	ListCell   *lc;
 
+	/* We don't need implicit coercions to Node here */
+#define PSWALK(n) walker(n, context)
+
 	/* Guard against stack overflow due to overly complex plan trees */
 	check_stack_depth();
 
@@ -4102,14 +4098,14 @@ planstate_tree_walker(PlanState *planstate,
 	/* lefttree */
 	if (outerPlanState(planstate))
 	{
-		if (walker(outerPlanState(planstate), context))
+		if (PSWALK(outerPlanState(planstate)))
 			return true;
 	}
 
 	/* righttree */
 	if (innerPlanState(planstate))
 	{
-		if (walker(innerPlanState(planstate), context))
+		if (PSWALK(innerPlanState(planstate)))
 			return true;
 	}
 
@@ -4141,13 +4137,13 @@ planstate_tree_walker(PlanState *planstate,
 				return true;
 			break;
 		case T_SubqueryScan:
-			if (walker(((SubqueryScanState *) planstate)->subplan, context))
+			if (PSWALK(((SubqueryScanState *) planstate)->subplan))
 				return true;
 			break;
 		case T_CustomScan:
 			foreach(lc, ((CustomScanState *) planstate)->custom_ps)
 			{
-				if (walker((PlanState *) lfirst(lc), context))
+				if (PSWALK(lfirst(lc)))
 					return true;
 			}
 			break;
@@ -4167,7 +4163,7 @@ planstate_tree_walker(PlanState *planstate,
  */
 static bool
 planstate_walk_subplans(List *plans,
-						bool (*walker) (),
+						planstate_tree_walker_callback walker,
 						void *context)
 {
 	ListCell   *lc;
@@ -4176,7 +4172,7 @@ planstate_walk_subplans(List *plans,
 	{
 		SubPlanState *sps = lfirst_node(SubPlanState, lc);
 
-		if (walker(sps->planstate, context))
+		if (PSWALK(sps->planstate))
 			return true;
 	}
 
@@ -4189,13 +4185,14 @@ planstate_walk_subplans(List *plans,
  */
 static bool
 planstate_walk_members(PlanState **planstates, int nplans,
-					   bool (*walker) (), void *context)
+					   planstate_tree_walker_callback walker,
+					   void *context)
 {
 	int			j;
 
 	for (j = 0; j < nplans; j++)
 	{
-		if (walker(planstates[j], context))
+		if (PSWALK(planstates[j]))
 			return true;
 	}
 
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index f486d42441..1e0d43b183 100644
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -165,7 +165,7 @@ static MergeScanSelCache *cached_scansel(PlannerInfo *root,
 										 PathKey *pathkey);
 static void cost_rescan(PlannerInfo *root, Path *path,
 						Cost *rescan_startup_cost, Cost *rescan_total_cost);
-static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context);
+static bool cost_qual_eval_walker(Node *node, void *ctx);
 static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
 									  ParamPathInfo *param_info,
 									  QualCost *qpqual_cost);
@@ -4722,8 +4722,10 @@ cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
 }
 
 static bool
-cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
+cost_qual_eval_walker(Node *node, void *ctx)
 {
+	cost_qual_eval_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 
@@ -4986,8 +4988,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
 	}
 
 	/* recurse into children */
-	return expression_tree_walker(node, cost_qual_eval_walker,
-								  (void *) context);
+	return expression_tree_walker(node, cost_qual_eval_walker, ctx);
 }
 
 /*
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index cd8a3ef7cb..ed1f25d84b 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -162,7 +162,7 @@ static NestLoop *create_nestloop_plan(PlannerInfo *root, NestPath *best_path);
 static MergeJoin *create_mergejoin_plan(PlannerInfo *root, MergePath *best_path);
 static HashJoin *create_hashjoin_plan(PlannerInfo *root, HashPath *best_path);
 static Node *replace_nestloop_params(PlannerInfo *root, Node *expr);
-static Node *replace_nestloop_params_mutator(Node *node, PlannerInfo *root);
+static Node *replace_nestloop_params_mutator(Node *node, void *ctx);
 static void fix_indexqual_references(PlannerInfo *root, IndexPath *index_path,
 									 List **stripped_indexquals_p,
 									 List **fixed_indexquals_p);
@@ -4891,8 +4891,10 @@ replace_nestloop_params(PlannerInfo *root, Node *expr)
 }
 
 static Node *
-replace_nestloop_params_mutator(Node *node, PlannerInfo *root)
+replace_nestloop_params_mutator(Node *node, void *ctx)
 {
+	PlannerInfo *root = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Var))
@@ -4938,16 +4940,13 @@ replace_nestloop_params_mutator(Node *node, PlannerInfo *root)
 
 			memcpy(newphv, phv, sizeof(PlaceHolderVar));
 			newphv->phexpr = (Expr *)
-				replace_nestloop_params_mutator((Node *) phv->phexpr,
-												root);
+				replace_nestloop_params_mutator((Node *) phv->phexpr, ctx);
 			return (Node *) newphv;
 		}
 		/* Replace the PlaceHolderVar with a nestloop Param */
 		return (Node *) replace_nestloop_param_placeholdervar(root, phv);
 	}
-	return expression_tree_mutator(node,
-								   replace_nestloop_params_mutator,
-								   (void *) root);
+	return expression_tree_mutator(node, replace_nestloop_params_mutator, ctx);
 }
 
 /*
diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index 1cb0abdbc1..228c15f6e6 100644
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -113,7 +113,7 @@ typedef struct
 
 static void add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing);
 static void flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte);
-static bool flatten_rtes_walker(Node *node, PlannerGlobal *glob);
+static bool flatten_rtes_walker(Node *node, void *ctx);
 static void add_rte_to_flat_rtable(PlannerGlobal *glob, RangeTblEntry *rte);
 static Plan *set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset);
 static Plan *set_indexonlyscan_references(PlannerInfo *root,
@@ -139,8 +139,8 @@ static void set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset);
 static Relids offset_relid_set(Relids relids, int rtoffset);
 static Node *fix_scan_expr(PlannerInfo *root, Node *node,
 						   int rtoffset, double num_exec);
-static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);
-static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);
+static Node *fix_scan_expr_mutator(Node *node, void *ctx);
+static bool fix_scan_expr_walker(Node *node, void *ctx);
 static void set_join_references(PlannerInfo *root, Join *join, int rtoffset);
 static void set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset);
 static void set_param_references(PlannerInfo *root, Plan *plan);
@@ -164,15 +164,13 @@ static List *fix_join_expr(PlannerInfo *root,
 						   indexed_tlist *inner_itlist,
 						   Index acceptable_rel,
 						   int rtoffset, double num_exec);
-static Node *fix_join_expr_mutator(Node *node,
-								   fix_join_expr_context *context);
+static Node *fix_join_expr_mutator(Node *node, void *ctx);
 static Node *fix_upper_expr(PlannerInfo *root,
 							Node *node,
 							indexed_tlist *subplan_itlist,
 							int newvarno,
 							int rtoffset, double num_exec);
-static Node *fix_upper_expr_mutator(Node *node,
-									fix_upper_expr_context *context);
+static Node *fix_upper_expr_mutator(Node *node, void *ctx);
 static List *set_returning_clause_references(PlannerInfo *root,
 											 List *rlist,
 											 Plan *topplan,
@@ -453,8 +451,10 @@ flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte)
 }
 
 static bool
-flatten_rtes_walker(Node *node, PlannerGlobal *glob)
+flatten_rtes_walker(Node *node, void *ctx)
 {
+	PlannerGlobal *glob = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, RangeTblEntry))
@@ -471,11 +471,10 @@ flatten_rtes_walker(Node *node, PlannerGlobal *glob)
 		/* Recurse into subselects */
 		return query_tree_walker((Query *) node,
 								 flatten_rtes_walker,
-								 (void *) glob,
+								 ctx,
 								 QTW_EXAMINE_RTES_BEFORE);
 	}
-	return expression_tree_walker(node, flatten_rtes_walker,
-								  (void *) glob);
+	return expression_tree_walker(node, flatten_rtes_walker, ctx);
 }
 
 /*
@@ -2055,8 +2054,10 @@ fix_scan_expr(PlannerInfo *root, Node *node, int rtoffset, double num_exec)
 }
 
 static Node *
-fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context)
+fix_scan_expr_mutator(Node *node, void *ctx)
 {
+	fix_scan_expr_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Var))
@@ -2115,29 +2116,29 @@ fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context)
 		/* At scan level, we should always just evaluate the contained expr */
 		PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
-		return fix_scan_expr_mutator((Node *) phv->phexpr, context);
+		return fix_scan_expr_mutator((Node *) phv->phexpr, ctx);
 	}
 	if (IsA(node, AlternativeSubPlan))
 		return fix_scan_expr_mutator(fix_alternative_subplan(context->root,
 															 (AlternativeSubPlan *) node,
 															 context->num_exec),
-									 context);
+									 ctx);
 	fix_expr_common(context->root, node);
-	return expression_tree_mutator(node, fix_scan_expr_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, fix_scan_expr_mutator, ctx);
 }
 
 static bool
-fix_scan_expr_walker(Node *node, fix_scan_expr_context *context)
+fix_scan_expr_walker(Node *node, void *ctx)
 {
+	fix_scan_expr_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	Assert(!(IsA(node, Var) && ((Var *) node)->varno == ROWID_VAR));
 	Assert(!IsA(node, PlaceHolderVar));
 	Assert(!IsA(node, AlternativeSubPlan));
 	fix_expr_common(context->root, node);
-	return expression_tree_walker(node, fix_scan_expr_walker,
-								  (void *) context);
+	return expression_tree_walker(node, fix_scan_expr_walker, ctx);
 }
 
 /*
@@ -2825,8 +2826,9 @@ fix_join_expr(PlannerInfo *root,
 }
 
 static Node *
-fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
+fix_join_expr_mutator(Node *node, void *ctx)
 {
+	fix_join_expr_context *context = ctx;
 	Var		   *newvar;
 
 	if (node == NULL)
@@ -2893,7 +2895,7 @@ fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
 		}
 
 		/* If not supplied by input plans, evaluate the contained expr */
-		return fix_join_expr_mutator((Node *) phv->phexpr, context);
+		return fix_join_expr_mutator((Node *) phv->phexpr, ctx);
 	}
 	/* Try matching more complex expressions too, if tlists have any */
 	if (context->outer_itlist && context->outer_itlist->has_non_vars)
@@ -2919,11 +2921,9 @@ fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
 		return fix_join_expr_mutator(fix_alternative_subplan(context->root,
 															 (AlternativeSubPlan *) node,
 															 context->num_exec),
-									 context);
+									 ctx);
 	fix_expr_common(context->root, node);
-	return expression_tree_mutator(node,
-								   fix_join_expr_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, fix_join_expr_mutator, ctx);
 }
 
 /*
@@ -2976,8 +2976,9 @@ fix_upper_expr(PlannerInfo *root,
 }
 
 static Node *
-fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
+fix_upper_expr_mutator(Node *node, void *ctx)
 {
+	fix_upper_expr_context *context = ctx;
 	Var		   *newvar;
 
 	if (node == NULL)
@@ -3008,7 +3009,7 @@ fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
 				return (Node *) newvar;
 		}
 		/* If not supplied by input plan, evaluate the contained expr */
-		return fix_upper_expr_mutator((Node *) phv->phexpr, context);
+		return fix_upper_expr_mutator((Node *) phv->phexpr, ctx);
 	}
 	/* Try matching more complex expressions too, if tlist has any */
 	if (context->subplan_itlist->has_non_vars)
@@ -3048,11 +3049,9 @@ fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
 		return fix_upper_expr_mutator(fix_alternative_subplan(context->root,
 															  (AlternativeSubPlan *) node,
 															  context->num_exec),
-									  context);
+									  ctx);
 	fix_expr_common(context->root, node);
-	return expression_tree_mutator(node,
-								   fix_upper_expr_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, fix_upper_expr_mutator, ctx);
 }
 
 /*
@@ -3127,9 +3126,10 @@ set_returning_clause_references(PlannerInfo *root,
  *		in the targetlist which references that WindowFunc.
  */
 static Node *
-fix_windowagg_condition_expr_mutator(Node *node,
-									 fix_windowagg_cond_context *context)
+fix_windowagg_condition_expr_mutator(Node *node, void *ctx)
 {
+	fix_windowagg_cond_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 
@@ -3145,9 +3145,8 @@ fix_windowagg_condition_expr_mutator(Node *node,
 		elog(ERROR, "WindowFunc not found in subplan target lists");
 	}
 
-	return expression_tree_mutator(node,
-								   fix_windowagg_condition_expr_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, fix_windowagg_condition_expr_mutator,
+								   ctx);
 }
 
 /*
@@ -3323,8 +3322,10 @@ extract_query_dependencies(Node *query,
  * and invalItems lists are added to as needed.
  */
 bool
-extract_query_dependencies_walker(Node *node, PlannerInfo *context)
+extract_query_dependencies_walker(Node *node, void *ctx)
 {
+	PlannerInfo *context = ctx;
+
 	if (node == NULL)
 		return false;
 	Assert(!IsA(node, PlaceHolderVar));
@@ -3365,10 +3366,9 @@ extract_query_dependencies_walker(Node *node, PlannerInfo *context)
 
 		/* And recurse into the query's subexpressions */
 		return query_tree_walker(query, extract_query_dependencies_walker,
-								 (void *) context, 0);
+								 ctx, 0);
 	}
 	/* Extract function dependencies and check for regclass Consts */
 	fix_expr_common(context, node);
-	return expression_tree_walker(node, extract_query_dependencies_walker,
-								  (void *) context);
+	return expression_tree_walker(node, extract_query_dependencies_walker, ctx);
 }
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index 92e3338584..e2785b1fde 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -77,8 +77,7 @@ static List *generate_subquery_vars(PlannerInfo *root, List *tlist,
 static Node *convert_testexpr(PlannerInfo *root,
 							  Node *testexpr,
 							  List *subst_nodes);
-static Node *convert_testexpr_mutator(Node *node,
-									  convert_testexpr_context *context);
+static Node *convert_testexpr_mutator(Node *node, void *ctx);
 static bool subplan_is_hashable(Plan *plan);
 static bool subpath_is_hashable(Path *path);
 static bool testexpr_is_hashable(Node *testexpr, List *param_ids);
@@ -87,22 +86,21 @@ static bool hash_ok_operator(OpExpr *expr);
 static bool contain_dml(Node *node);
 static bool contain_dml_walker(Node *node, void *context);
 static bool contain_outer_selfref(Node *node);
-static bool contain_outer_selfref_walker(Node *node, Index *depth);
+static bool contain_outer_selfref_walker(Node *node, void *ctx);
 static void inline_cte(PlannerInfo *root, CommonTableExpr *cte);
-static bool inline_cte_walker(Node *node, inline_cte_walker_context *context);
+static bool inline_cte_walker(Node *node, void *ctx);
 static bool simplify_EXISTS_query(PlannerInfo *root, Query *query);
 static Query *convert_EXISTS_to_ANY(PlannerInfo *root, Query *subselect,
 									Node **testexpr, List **paramIds);
-static Node *replace_correlation_vars_mutator(Node *node, PlannerInfo *root);
-static Node *process_sublinks_mutator(Node *node,
-									  process_sublinks_context *context);
+static Node *replace_correlation_vars_mutator(Node *node, void *ctx);
+static Node *process_sublinks_mutator(Node *node, void *ctx);
 static Bitmapset *finalize_plan(PlannerInfo *root,
 								Plan *plan,
 								int gather_param,
 								Bitmapset *valid_params,
 								Bitmapset *scan_params);
-static bool finalize_primnode(Node *node, finalize_primnode_context *context);
-static bool finalize_agg_primnode(Node *node, finalize_primnode_context *context);
+static bool finalize_primnode(Node *node, void *ctx);
+static bool finalize_agg_primnode(Node *node, void *ctx);
 
 
 /*
@@ -664,9 +662,10 @@ convert_testexpr(PlannerInfo *root,
 }
 
 static Node *
-convert_testexpr_mutator(Node *node,
-						 convert_testexpr_context *context)
+convert_testexpr_mutator(Node *node, void *ctx)
 {
+	convert_testexpr_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Param))
@@ -710,9 +709,7 @@ convert_testexpr_mutator(Node *node,
 		 */
 		return node;
 	}
-	return expression_tree_mutator(node,
-								   convert_testexpr_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, convert_testexpr_mutator, ctx);
 }
 
 /*
@@ -1108,8 +1105,10 @@ contain_outer_selfref(Node *node)
 }
 
 static bool
-contain_outer_selfref_walker(Node *node, Index *depth)
+contain_outer_selfref_walker(Node *node, void *ctx)
 {
+	Index	   *depth = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, RangeTblEntry))
@@ -1135,14 +1134,13 @@ contain_outer_selfref_walker(Node *node, Index *depth)
 		(*depth)++;
 
 		result = query_tree_walker(query, contain_outer_selfref_walker,
-								   (void *) depth, QTW_EXAMINE_RTES_BEFORE);
+								   ctx, QTW_EXAMINE_RTES_BEFORE);
 
 		(*depth)--;
 
 		return result;
 	}
-	return expression_tree_walker(node, contain_outer_selfref_walker,
-								  (void *) depth);
+	return expression_tree_walker(node, contain_outer_selfref_walker, ctx);
 }
 
 /*
@@ -1162,8 +1160,10 @@ inline_cte(PlannerInfo *root, CommonTableExpr *cte)
 }
 
 static bool
-inline_cte_walker(Node *node, inline_cte_walker_context *context)
+inline_cte_walker(Node *node, void *ctx)
 {
+	inline_cte_walker_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Query))
@@ -1226,7 +1226,7 @@ inline_cte_walker(Node *node, inline_cte_walker_context *context)
 		return false;
 	}
 
-	return expression_tree_walker(node, inline_cte_walker, context);
+	return expression_tree_walker(node, inline_cte_walker, ctx);
 }
 
 
@@ -1871,8 +1871,10 @@ SS_replace_correlation_vars(PlannerInfo *root, Node *expr)
 }
 
 static Node *
-replace_correlation_vars_mutator(Node *node, PlannerInfo *root)
+replace_correlation_vars_mutator(Node *node, void *ctx)
 {
+	PlannerInfo *root = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Var))
@@ -1896,9 +1898,7 @@ replace_correlation_vars_mutator(Node *node, PlannerInfo *root)
 		if (((GroupingFunc *) node)->agglevelsup > 0)
 			return (Node *) replace_outer_grouping(root, (GroupingFunc *) node);
 	}
-	return expression_tree_mutator(node,
-								   replace_correlation_vars_mutator,
-								   (void *) root);
+	return expression_tree_mutator(node, replace_correlation_vars_mutator, ctx);
 }
 
 /*
@@ -1919,8 +1919,9 @@ SS_process_sublinks(PlannerInfo *root, Node *expr, bool isQual)
 }
 
 static Node *
-process_sublinks_mutator(Node *node, process_sublinks_context *context)
+process_sublinks_mutator(Node *node, void *ctx)
 {
+	process_sublinks_context *context = ctx;
 	process_sublinks_context locContext;
 
 	locContext.root = context->root;
@@ -2837,8 +2838,10 @@ finalize_plan(PlannerInfo *root, Plan *plan,
  * expression tree to the result set.
  */
 static bool
-finalize_primnode(Node *node, finalize_primnode_context *context)
+finalize_primnode(Node *node, void *ctx)
 {
+	finalize_primnode_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Param))
@@ -2892,8 +2895,7 @@ finalize_primnode(Node *node, finalize_primnode_context *context)
 
 		return false;			/* no more to do here */
 	}
-	return expression_tree_walker(node, finalize_primnode,
-								  (void *) context);
+	return expression_tree_walker(node, finalize_primnode, ctx);
 }
 
 /*
@@ -2902,8 +2904,10 @@ finalize_primnode(Node *node, finalize_primnode_context *context)
  * arguments to the result set.
  */
 static bool
-finalize_agg_primnode(Node *node, finalize_primnode_context *context)
+finalize_agg_primnode(Node *node, void *ctx)
 {
+	finalize_primnode_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Aggref))
@@ -2915,8 +2919,7 @@ finalize_agg_primnode(Node *node, finalize_primnode_context *context)
 		finalize_primnode((Node *) agg->aggfilter, context);
 		return false;			/* there can't be any Aggrefs below here */
 	}
-	return expression_tree_walker(node, finalize_agg_primnode,
-								  (void *) context);
+	return expression_tree_walker(node, finalize_agg_primnode, ctx);
 }
 
 /*
diff --git a/src/backend/optimizer/prep/prepagg.c b/src/backend/optimizer/prep/prepagg.c
index da89b55402..d3fa4897a7 100644
--- a/src/backend/optimizer/prep/prepagg.c
+++ b/src/backend/optimizer/prep/prepagg.c
@@ -52,7 +52,7 @@
 #include "utils/memutils.h"
 #include "utils/syscache.h"
 
-static bool preprocess_aggrefs_walker(Node *node, PlannerInfo *root);
+static bool preprocess_aggrefs_walker(Node *node, void *ctx);
 static int	find_compatible_agg(PlannerInfo *root, Aggref *newagg,
 								List **same_input_transnos);
 static int	find_compatible_trans(PlannerInfo *root, Aggref *newagg,
@@ -322,8 +322,10 @@ preprocess_aggref(Aggref *aggref, PlannerInfo *root)
 }
 
 static bool
-preprocess_aggrefs_walker(Node *node, PlannerInfo *root)
+preprocess_aggrefs_walker(Node *node, void *ctx)
 {
+	PlannerInfo *root = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Aggref))
@@ -340,8 +342,7 @@ preprocess_aggrefs_walker(Node *node, PlannerInfo *root)
 		return false;
 	}
 	Assert(!IsA(node, SubLink));
-	return expression_tree_walker(node, preprocess_aggrefs_walker,
-								  (void *) root);
+	return expression_tree_walker(node, preprocess_aggrefs_walker, ctx);
 }
 
 
diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index 41c7066d90..f6eb7eef25 100644
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -3399,9 +3399,10 @@ typedef struct
 } find_dependent_phvs_context;
 
 static bool
-find_dependent_phvs_walker(Node *node,
-						   find_dependent_phvs_context *context)
+find_dependent_phvs_walker(Node *node, void *ctx)
 {
+	find_dependent_phvs_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, PlaceHolderVar))
@@ -3421,7 +3422,7 @@ find_dependent_phvs_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   find_dependent_phvs_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
@@ -3431,8 +3432,7 @@ find_dependent_phvs_walker(Node *node,
 	Assert(!IsA(node, PlaceHolderInfo));
 	Assert(!IsA(node, MinMaxAggInfo));
 
-	return expression_tree_walker(node, find_dependent_phvs_walker,
-								  (void *) context);
+	return expression_tree_walker(node, find_dependent_phvs_walker, ctx);
 }
 
 static bool
@@ -3518,9 +3518,10 @@ typedef struct
 } substitute_phv_relids_context;
 
 static bool
-substitute_phv_relids_walker(Node *node,
-							 substitute_phv_relids_context *context)
+substitute_phv_relids_walker(Node *node, void *ctx)
 {
+	substitute_phv_relids_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, PlaceHolderVar))
@@ -3547,7 +3548,7 @@ substitute_phv_relids_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   substitute_phv_relids_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
@@ -3557,8 +3558,7 @@ substitute_phv_relids_walker(Node *node,
 	Assert(!IsA(node, PlaceHolderInfo));
 	Assert(!IsA(node, MinMaxAggInfo));
 
-	return expression_tree_walker(node, substitute_phv_relids_walker,
-								  (void *) context);
+	return expression_tree_walker(node, substitute_phv_relids_walker, ctx);
 }
 
 static void
diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c
index 62cccf9d87..923aafd1f2 100644
--- a/src/backend/optimizer/util/appendinfo.c
+++ b/src/backend/optimizer/util/appendinfo.c
@@ -38,8 +38,7 @@ static void make_inh_translation_list(Relation oldrelation,
 									  Relation newrelation,
 									  Index newvarno,
 									  AppendRelInfo *appinfo);
-static Node *adjust_appendrel_attrs_mutator(Node *node,
-											adjust_appendrel_attrs_context *context);
+static Node *adjust_appendrel_attrs_mutator(Node *node, void *ctx);
 
 
 /*
@@ -211,9 +210,9 @@ adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
 }
 
 static Node *
-adjust_appendrel_attrs_mutator(Node *node,
-							   adjust_appendrel_attrs_context *context)
+adjust_appendrel_attrs_mutator(Node *node, void *ctx)
 {
+	adjust_appendrel_attrs_context *context = ctx;
 	AppendRelInfo **appinfos = context->appinfos;
 	int			nappinfos = context->nappinfos;
 	int			cnt;
@@ -389,7 +388,7 @@ adjust_appendrel_attrs_mutator(Node *node,
 
 		phv = (PlaceHolderVar *) expression_tree_mutator(node,
 														 adjust_appendrel_attrs_mutator,
-														 (void *) context);
+														 ctx);
 		/* now fix PlaceHolderVar's relid sets */
 		if (phv->phlevelsup == 0)
 			phv->phrels = adjust_child_relids(phv->phrels, context->nappinfos,
@@ -417,11 +416,11 @@ adjust_appendrel_attrs_mutator(Node *node,
 
 		/* Recursively fix the clause itself */
 		newinfo->clause = (Expr *)
-			adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context);
+			adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, ctx);
 
 		/* and the modified version, if an OR clause */
 		newinfo->orclause = (Expr *)
-			adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context);
+			adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, ctx);
 
 		/* adjust relid sets too */
 		newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids,
@@ -473,8 +472,7 @@ adjust_appendrel_attrs_mutator(Node *node,
 	Assert(!IsA(node, RangeTblRef));
 	Assert(!IsA(node, JoinExpr));
 
-	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, adjust_appendrel_attrs_mutator, ctx);
 }
 
 /*
diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index bf3a7cae60..91867e4e01 100644
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -92,24 +92,22 @@ typedef struct
 } max_parallel_hazard_context;
 
 static bool contain_agg_clause_walker(Node *node, void *context);
-static bool find_window_functions_walker(Node *node, WindowFuncLists *lists);
+static bool find_window_functions_walker(Node *node, void *ctx);
 static bool contain_subplans_walker(Node *node, void *context);
 static bool contain_mutable_functions_walker(Node *node, void *context);
 static bool contain_volatile_functions_walker(Node *node, void *context);
 static bool contain_volatile_functions_not_nextval_walker(Node *node, void *context);
-static bool max_parallel_hazard_walker(Node *node,
-									   max_parallel_hazard_context *context);
+static bool max_parallel_hazard_walker(Node *node, void *ctx);
 static bool contain_nonstrict_functions_walker(Node *node, void *context);
-static bool contain_exec_param_walker(Node *node, List *param_ids);
+static bool contain_exec_param_walker(Node *node, void *ctx);
 static bool contain_context_dependent_node(Node *clause);
-static bool contain_context_dependent_node_walker(Node *node, int *flags);
+static bool contain_context_dependent_node_walker(Node *node, void *ctx);
 static bool contain_leaked_vars_walker(Node *node, void *context);
 static Relids find_nonnullable_rels_walker(Node *node, bool top_level);
 static List *find_nonnullable_vars_walker(Node *node, bool top_level);
 static bool is_strict_saop(ScalarArrayOpExpr *expr, bool falseOK);
 static bool convert_saop_to_hashed_saop_walker(Node *node, void *context);
-static Node *eval_const_expressions_mutator(Node *node,
-											eval_const_expressions_context *context);
+static Node *eval_const_expressions_mutator(Node *node, void *ctx);
 static bool contain_non_const_walker(Node *node, void *context);
 static bool ece_function_is_safe(Oid funcid,
 								 eval_const_expressions_context *context);
@@ -145,14 +143,12 @@ static Expr *inline_function(Oid funcid, Oid result_type, Oid result_collid,
 							 eval_const_expressions_context *context);
 static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
 										  int *usecounts);
-static Node *substitute_actual_parameters_mutator(Node *node,
-												  substitute_actual_parameters_context *context);
+static Node *substitute_actual_parameters_mutator(Node *node, void *ctx);
 static void sql_inline_error_callback(void *arg);
 static Query *substitute_actual_srf_parameters(Query *expr,
 											   int nargs, List *args);
-static Node *substitute_actual_srf_parameters_mutator(Node *node,
-													  substitute_actual_srf_parameters_context *context);
-static bool pull_paramids_walker(Node *node, Bitmapset **context);
+static Node *substitute_actual_srf_parameters_mutator(Node *node, void *ctx);
+static bool pull_paramids_walker(Node *node, void *ctx);
 
 
 /*****************************************************************************
@@ -235,8 +231,10 @@ find_window_functions(Node *clause, Index maxWinRef)
 }
 
 static bool
-find_window_functions_walker(Node *node, WindowFuncLists *lists)
+find_window_functions_walker(Node *node, void *ctx)
 {
+	WindowFuncLists *lists = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, WindowFunc))
@@ -264,8 +262,7 @@ find_window_functions_walker(Node *node, WindowFuncLists *lists)
 		return false;
 	}
 	Assert(!IsA(node, SubLink));
-	return expression_tree_walker(node, find_window_functions_walker,
-								  (void *) lists);
+	return expression_tree_walker(node, find_window_functions_walker, ctx);
 }
 
 
@@ -713,8 +710,10 @@ max_parallel_hazard_checker(Oid func_id, void *context)
 }
 
 static bool
-max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
+max_parallel_hazard_walker(Node *node, void *ctx)
 {
+	max_parallel_hazard_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 
@@ -850,13 +849,11 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
 		/* Recurse into subselects */
 		return query_tree_walker(query,
 								 max_parallel_hazard_walker,
-								 context, 0);
+								 ctx, 0);
 	}
 
 	/* Recurse to check arguments */
-	return expression_tree_walker(node,
-								  max_parallel_hazard_walker,
-								  context);
+	return expression_tree_walker(node, max_parallel_hazard_walker, ctx);
 }
 
 
@@ -1027,8 +1024,10 @@ contain_exec_param(Node *clause, List *param_ids)
 }
 
 static bool
-contain_exec_param_walker(Node *node, List *param_ids)
+contain_exec_param_walker(Node *node, void *ctx)
 {
+	List	   *param_ids = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Param))
@@ -1073,8 +1072,10 @@ contain_context_dependent_node(Node *clause)
 #define CCDN_CASETESTEXPR_OK	0x0001	/* CaseTestExpr okay here? */
 
 static bool
-contain_context_dependent_node_walker(Node *node, int *flags)
+contain_context_dependent_node_walker(Node *node, void *ctx)
 {
+	int		   *flags = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, CaseTestExpr))
@@ -1104,7 +1105,7 @@ contain_context_dependent_node_walker(Node *node, int *flags)
 			*flags |= CCDN_CASETESTEXPR_OK;
 			res = expression_tree_walker(node,
 										 contain_context_dependent_node_walker,
-										 (void *) flags);
+										 ctx);
 			*flags = save_flags;
 			return res;
 		}
@@ -1128,7 +1129,7 @@ contain_context_dependent_node_walker(Node *node, int *flags)
 		return res;
 	}
 	return expression_tree_walker(node, contain_context_dependent_node_walker,
-								  (void *) flags);
+								  ctx);
 }
 
 /*****************************************************************************
@@ -2278,9 +2279,10 @@ estimate_expression_value(PlannerInfo *root, Node *node)
  * Recursive guts of eval_const_expressions/estimate_expression_value
  */
 static Node *
-eval_const_expressions_mutator(Node *node,
-							   eval_const_expressions_context *context)
+eval_const_expressions_mutator(Node *node, void *ctx)
 {
+	eval_const_expressions_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	switch (nodeTag(node))
@@ -4731,9 +4733,10 @@ substitute_actual_parameters(Node *expr, int nargs, List *args,
 }
 
 static Node *
-substitute_actual_parameters_mutator(Node *node,
-									 substitute_actual_parameters_context *context)
+substitute_actual_parameters_mutator(Node *node, void *ctx)
 {
+	substitute_actual_parameters_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Param))
@@ -4753,7 +4756,7 @@ substitute_actual_parameters_mutator(Node *node,
 		return list_nth(context->args, param->paramid - 1);
 	}
 	return expression_tree_mutator(node, substitute_actual_parameters_mutator,
-								   (void *) context);
+								   ctx);
 }
 
 /*
@@ -5177,9 +5180,9 @@ substitute_actual_srf_parameters(Query *expr, int nargs, List *args)
 }
 
 static Node *
-substitute_actual_srf_parameters_mutator(Node *node,
-										 substitute_actual_srf_parameters_context *context)
+substitute_actual_srf_parameters_mutator(Node *node, void *ctx)
 {
+	substitute_actual_srf_parameters_context *context = ctx;
 	Node	   *result;
 
 	if (node == NULL)
@@ -5189,7 +5192,7 @@ substitute_actual_srf_parameters_mutator(Node *node,
 		context->sublevels_up++;
 		result = (Node *) query_tree_mutator((Query *) node,
 											 substitute_actual_srf_parameters_mutator,
-											 (void *) context,
+											 ctx,
 											 0);
 		context->sublevels_up--;
 		return result;
@@ -5214,7 +5217,7 @@ substitute_actual_srf_parameters_mutator(Node *node,
 	}
 	return expression_tree_mutator(node,
 								   substitute_actual_srf_parameters_mutator,
-								   (void *) context);
+								   ctx);
 }
 
 /*
@@ -5232,8 +5235,10 @@ pull_paramids(Expr *expr)
 }
 
 static bool
-pull_paramids_walker(Node *node, Bitmapset **context)
+pull_paramids_walker(Node *node, void *ctx)
 {
+	Bitmapset **context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Param))
@@ -5243,6 +5248,5 @@ pull_paramids_walker(Node *node, Bitmapset **context)
 		*context = bms_add_member(*context, param->paramid);
 		return false;
 	}
-	return expression_tree_walker(node, pull_paramids_walker,
-								  (void *) context);
+	return expression_tree_walker(node, pull_paramids_walker, ctx);
 }
diff --git a/src/backend/optimizer/util/tlist.c b/src/backend/optimizer/util/tlist.c
index 784a1af82d..6feb248f56 100644
--- a/src/backend/optimizer/util/tlist.c
+++ b/src/backend/optimizer/util/tlist.c
@@ -59,8 +59,7 @@ typedef struct
 	Index		current_sgref;	/* current subexpr's sortgroupref, or 0 */
 } split_pathtarget_context;
 
-static bool split_pathtarget_walker(Node *node,
-									split_pathtarget_context *context);
+static bool split_pathtarget_walker(Node *node, void *ctx);
 static void add_sp_item_to_pathtarget(PathTarget *target,
 									  split_pathtarget_item *item);
 static void add_sp_items_to_pathtarget(PathTarget *target, List *items);
@@ -1074,8 +1073,10 @@ split_pathtarget_at_srfs(PlannerInfo *root,
  * lists.  Duplicates will be gotten rid of later.
  */
 static bool
-split_pathtarget_walker(Node *node, split_pathtarget_context *context)
+split_pathtarget_walker(Node *node, void *ctx)
 {
+	split_pathtarget_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 
@@ -1181,8 +1182,7 @@ split_pathtarget_walker(Node *node, split_pathtarget_context *context)
 	 * examine its inputs.
 	 */
 	context->current_sgref = 0; /* subexpressions are not sortgroup items */
-	return expression_tree_walker(node, split_pathtarget_walker,
-								  (void *) context);
+	return expression_tree_walker(node, split_pathtarget_walker, ctx);
 }
 
 /*
diff --git a/src/backend/optimizer/util/var.c b/src/backend/optimizer/util/var.c
index 7db86c39ef..e528e754fe 100644
--- a/src/backend/optimizer/util/var.c
+++ b/src/backend/optimizer/util/var.c
@@ -68,18 +68,14 @@ typedef struct
 	bool		inserted_sublink;	/* have we inserted a SubLink? */
 } flatten_join_alias_vars_context;
 
-static bool pull_varnos_walker(Node *node,
-							   pull_varnos_context *context);
-static bool pull_varattnos_walker(Node *node, pull_varattnos_context *context);
-static bool pull_vars_walker(Node *node, pull_vars_context *context);
+static bool pull_varnos_walker(Node *node, void *ctx);
+static bool pull_varattnos_walker(Node *node, void *ctx);
+static bool pull_vars_walker(Node *node, void *ctx);
 static bool contain_var_clause_walker(Node *node, void *context);
-static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
-static bool locate_var_of_level_walker(Node *node,
-									   locate_var_of_level_context *context);
-static bool pull_var_clause_walker(Node *node,
-								   pull_var_clause_context *context);
-static Node *flatten_join_alias_vars_mutator(Node *node,
-											 flatten_join_alias_vars_context *context);
+static bool contain_vars_of_level_walker(Node *node, void *ctx);
+static bool locate_var_of_level_walker(Node *node, void *ctx);
+static bool pull_var_clause_walker(Node *node, void *ctx);
+static Node *flatten_join_alias_vars_mutator(Node *node, void *ctx);
 static Relids alias_relid_set(Query *query, Relids relids);
 
 
@@ -144,8 +140,10 @@ pull_varnos_of_level(PlannerInfo *root, Node *node, int levelsup)
 }
 
 static bool
-pull_varnos_walker(Node *node, pull_varnos_context *context)
+pull_varnos_walker(Node *node, void *ctx)
 {
+	pull_varnos_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -254,12 +252,11 @@ pull_varnos_walker(Node *node, pull_varnos_context *context)
 
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node, pull_varnos_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, pull_varnos_walker,
-								  (void *) context);
+	return expression_tree_walker(node, pull_varnos_walker, ctx);
 }
 
 
@@ -291,8 +288,10 @@ pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)
 }
 
 static bool
-pull_varattnos_walker(Node *node, pull_varattnos_context *context)
+pull_varattnos_walker(Node *node, void *ctx)
 {
+	pull_varattnos_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -309,8 +308,7 @@ pull_varattnos_walker(Node *node, pull_varattnos_context *context)
 	/* Should not find an unplanned subquery */
 	Assert(!IsA(node, Query));
 
-	return expression_tree_walker(node, pull_varattnos_walker,
-								  (void *) context);
+	return expression_tree_walker(node, pull_varattnos_walker, ctx);
 }
 
 
@@ -342,8 +340,10 @@ pull_vars_of_level(Node *node, int levelsup)
 }
 
 static bool
-pull_vars_walker(Node *node, pull_vars_context *context)
+pull_vars_walker(Node *node, void *ctx)
 {
+	pull_vars_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -370,12 +370,11 @@ pull_vars_walker(Node *node, pull_vars_context *context)
 
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node, pull_vars_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, pull_vars_walker,
-								  (void *) context);
+	return expression_tree_walker(node, pull_vars_walker, ctx);
 }
 
 
@@ -439,8 +438,10 @@ contain_vars_of_level(Node *node, int levelsup)
 }
 
 static bool
-contain_vars_of_level_walker(Node *node, int *sublevels_up)
+contain_vars_of_level_walker(Node *node, void *ctx)
 {
+	int		   *sublevels_up = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -469,14 +470,12 @@ contain_vars_of_level_walker(Node *node, int *sublevels_up)
 		(*sublevels_up)++;
 		result = query_tree_walker((Query *) node,
 								   contain_vars_of_level_walker,
-								   (void *) sublevels_up,
+								   ctx,
 								   0);
 		(*sublevels_up)--;
 		return result;
 	}
-	return expression_tree_walker(node,
-								  contain_vars_of_level_walker,
-								  (void *) sublevels_up);
+	return expression_tree_walker(node, contain_vars_of_level_walker, ctx);
 }
 
 
@@ -512,9 +511,10 @@ locate_var_of_level(Node *node, int levelsup)
 }
 
 static bool
-locate_var_of_level_walker(Node *node,
-						   locate_var_of_level_context *context)
+locate_var_of_level_walker(Node *node, void *ctx)
 {
+	locate_var_of_level_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -543,14 +543,12 @@ locate_var_of_level_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   locate_var_of_level_walker,
-								   (void *) context,
+								   ctx,
 								   0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node,
-								  locate_var_of_level_walker,
-								  (void *) context);
+	return expression_tree_walker(node, locate_var_of_level_walker, ctx);
 }
 
 
@@ -614,8 +612,10 @@ pull_var_clause(Node *node, int flags)
 }
 
 static bool
-pull_var_clause_walker(Node *node, pull_var_clause_context *context)
+pull_var_clause_walker(Node *node, void *ctx)
 {
+	pull_var_clause_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -692,8 +692,7 @@ pull_var_clause_walker(Node *node, pull_var_clause_context *context)
 		else
 			elog(ERROR, "PlaceHolderVar found where not expected");
 	}
-	return expression_tree_walker(node, pull_var_clause_walker,
-								  (void *) context);
+	return expression_tree_walker(node, pull_var_clause_walker, ctx);
 }
 
 
@@ -738,9 +737,10 @@ flatten_join_alias_vars(Query *query, Node *node)
 }
 
 static Node *
-flatten_join_alias_vars_mutator(Node *node,
-								flatten_join_alias_vars_context *context)
+flatten_join_alias_vars_mutator(Node *node, void *ctx)
 {
+	flatten_join_alias_vars_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Var))
@@ -868,8 +868,7 @@ flatten_join_alias_vars_mutator(Node *node,
 	Assert(!IsA(node, PlaceHolderInfo));
 	Assert(!IsA(node, MinMaxAggInfo));
 
-	return expression_tree_mutator(node, flatten_join_alias_vars_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, flatten_join_alias_vars_mutator, ctx);
 }
 
 /*
diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c
index 3ef9e8ee5e..1a40a5d7f2 100644
--- a/src/backend/parser/parse_agg.c
+++ b/src/backend/parser/parse_agg.c
@@ -55,19 +55,16 @@ static int	check_agg_arguments(ParseState *pstate,
 								List *directargs,
 								List *args,
 								Expr *filter);
-static bool check_agg_arguments_walker(Node *node,
-									   check_agg_arguments_context *context);
+static bool check_agg_arguments_walker(Node *node, void *ctx);
 static void check_ungrouped_columns(Node *node, ParseState *pstate, Query *qry,
 									List *groupClauses, List *groupClauseCommonVars,
 									bool have_non_var_grouping,
 									List **func_grouped_rels);
-static bool check_ungrouped_columns_walker(Node *node,
-										   check_ungrouped_columns_context *context);
+static bool check_ungrouped_columns_walker(Node *node, void *ctx);
 static void finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
 									List *groupClauses, bool hasJoinRTEs,
 									bool have_non_var_grouping);
-static bool finalize_grouping_exprs_walker(Node *node,
-										   check_ungrouped_columns_context *context);
+static bool finalize_grouping_exprs_walker(Node *node, void *ctx);
 static void check_agglevels_and_constraints(ParseState *pstate, Node *expr);
 static List *expand_groupingset_node(GroupingSet *gs);
 static Node *make_agg_arg(Oid argtype, Oid argcollation);
@@ -702,9 +699,10 @@ check_agg_arguments(ParseState *pstate,
 }
 
 static bool
-check_agg_arguments_walker(Node *node,
-						   check_agg_arguments_context *context)
+check_agg_arguments_walker(Node *node, void *ctx)
 {
+	check_agg_arguments_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -783,15 +781,13 @@ check_agg_arguments_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   check_agg_arguments_walker,
-								   (void *) context,
+								   ctx,
 								   0);
 		context->sublevels_up--;
 		return result;
 	}
 
-	return expression_tree_walker(node,
-								  check_agg_arguments_walker,
-								  (void *) context);
+	return expression_tree_walker(node, check_agg_arguments_walker, ctx);
 }
 
 /*
@@ -1276,9 +1272,9 @@ check_ungrouped_columns(Node *node, ParseState *pstate, Query *qry,
 }
 
 static bool
-check_ungrouped_columns_walker(Node *node,
-							   check_ungrouped_columns_context *context)
+check_ungrouped_columns_walker(Node *node, void *ctx)
 {
+	check_ungrouped_columns_context *context = ctx;
 	ListCell   *gl;
 
 	if (node == NULL)
@@ -1443,13 +1439,13 @@ check_ungrouped_columns_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   check_ungrouped_columns_walker,
-								   (void *) context,
+								   ctx,
 								   0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, check_ungrouped_columns_walker,
-								  (void *) context);
+
+	return expression_tree_walker(node, check_ungrouped_columns_walker, ctx);
 }
 
 /*
@@ -1483,9 +1479,9 @@ finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry,
 }
 
 static bool
-finalize_grouping_exprs_walker(Node *node,
-							   check_ungrouped_columns_context *context)
+finalize_grouping_exprs_walker(Node *node, void *ctx)
 {
+	check_ungrouped_columns_context *context = ctx;
 	ListCell   *gl;
 
 	if (node == NULL)
@@ -1616,13 +1612,13 @@ finalize_grouping_exprs_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   finalize_grouping_exprs_walker,
-								   (void *) context,
+								   ctx,
 								   0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, finalize_grouping_exprs_walker,
-								  (void *) context);
+
+	return expression_tree_walker(node, finalize_grouping_exprs_walker, ctx);
 }
 
 
diff --git a/src/backend/parser/parse_collate.c b/src/backend/parser/parse_collate.c
index 7582faabb3..921caa9de6 100644
--- a/src/backend/parser/parse_collate.c
+++ b/src/backend/parser/parse_collate.c
@@ -72,9 +72,8 @@ typedef struct
 	int			location2;		/* location of expr that set collation2 */
 } assign_collations_context;
 
-static bool assign_query_collations_walker(Node *node, ParseState *pstate);
-static bool assign_collations_walker(Node *node,
-									 assign_collations_context *context);
+static bool assign_query_collations_walker(Node *node, void *ctx);
+static bool assign_collations_walker(Node *node, void *ctx);
 static void merge_collation_state(Oid collation,
 								  CollateStrength strength,
 								  int location,
@@ -123,8 +122,10 @@ assign_query_collations(ParseState *pstate, Query *query)
  * have different collations.
  */
 static bool
-assign_query_collations_walker(Node *node, ParseState *pstate)
+assign_query_collations_walker(Node *node, void *ctx)
 {
+	ParseState *pstate = ctx;
+
 	/* Need do nothing for empty subexpressions */
 	if (node == NULL)
 		return false;
@@ -252,8 +253,9 @@ select_common_collation(ParseState *pstate, List *exprs, bool none_ok)
  * error if there are conflicting explicit collations for different members.
  */
 static bool
-assign_collations_walker(Node *node, assign_collations_context *context)
+assign_collations_walker(Node *node, void *ctx)
 {
+	assign_collations_context *context = ctx;
 	assign_collations_context loccontext;
 	Oid			collation;
 	CollateStrength strength;
diff --git a/src/backend/parser/parse_cte.c b/src/backend/parser/parse_cte.c
index 8fc8658608..5f43ccef1b 100644
--- a/src/backend/parser/parse_cte.c
+++ b/src/backend/parser/parse_cte.c
@@ -87,12 +87,12 @@ static void analyzeCTE(ParseState *pstate, CommonTableExpr *cte);
 
 /* Dependency processing functions */
 static void makeDependencyGraph(CteState *cstate);
-static bool makeDependencyGraphWalker(Node *node, CteState *cstate);
+static bool makeDependencyGraphWalker(Node *node, void *ctx);
 static void TopologicalSort(ParseState *pstate, CteItem *items, int numitems);
 
 /* Recursion validity checker functions */
 static void checkWellFormedRecursion(CteState *cstate);
-static bool checkWellFormedRecursionWalker(Node *node, CteState *cstate);
+static bool checkWellFormedRecursionWalker(Node *node, void *ctx);
 static void checkWellFormedSelectStmt(SelectStmt *stmt, CteState *cstate);
 
 
@@ -648,8 +648,10 @@ makeDependencyGraph(CteState *cstate)
  * CTEs in a WITH RECURSIVE list.
  */
 static bool
-makeDependencyGraphWalker(Node *node, CteState *cstate)
+makeDependencyGraphWalker(Node *node, void *ctx)
 {
+	CteState   *cstate = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, RangeVar))
@@ -767,9 +769,7 @@ makeDependencyGraphWalker(Node *node, CteState *cstate)
 		 */
 		return false;
 	}
-	return raw_expression_tree_walker(node,
-									  makeDependencyGraphWalker,
-									  (void *) cstate);
+	return raw_expression_tree_walker(node, makeDependencyGraphWalker, ctx);
 }
 
 /*
@@ -927,8 +927,9 @@ checkWellFormedRecursion(CteState *cstate)
  * Tree walker function to detect invalid self-references in a recursive query.
  */
 static bool
-checkWellFormedRecursionWalker(Node *node, CteState *cstate)
+checkWellFormedRecursionWalker(Node *node, void *ctx)
 {
+	CteState   *cstate = ctx;
 	RecursionContext save_context = cstate->context;
 
 	if (node == NULL)
@@ -1097,9 +1098,7 @@ checkWellFormedRecursionWalker(Node *node, CteState *cstate)
 		checkWellFormedRecursionWalker(sl->testexpr, cstate);
 		return false;
 	}
-	return raw_expression_tree_walker(node,
-									  checkWellFormedRecursionWalker,
-									  (void *) cstate);
+	return raw_expression_tree_walker(node, checkWellFormedRecursionWalker, ctx);
 }
 
 /*
diff --git a/src/backend/parser/parse_param.c b/src/backend/parser/parse_param.c
index f668abfcb3..536357326f 100644
--- a/src/backend/parser/parse_param.c
+++ b/src/backend/parser/parse_param.c
@@ -56,7 +56,7 @@ static Node *variable_paramref_hook(ParseState *pstate, ParamRef *pref);
 static Node *variable_coerce_param_hook(ParseState *pstate, Param *param,
 										Oid targetTypeId, int32 targetTypeMod,
 										int location);
-static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
+static bool check_parameter_resolution_walker(Node *node, void *ctx);
 static bool query_contains_extern_params_walker(Node *node, void *context);
 
 
@@ -287,8 +287,10 @@ check_variable_parameters(ParseState *pstate, Query *query)
  * and yet other instances seen later might have gotten coerced.
  */
 static bool
-check_parameter_resolution_walker(Node *node, ParseState *pstate)
+check_parameter_resolution_walker(Node *node, void *ctx)
 {
+	ParseState *pstate = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Param))
@@ -321,10 +323,9 @@ check_parameter_resolution_walker(Node *node, ParseState *pstate)
 		/* Recurse into RTE subquery or not-yet-planned sublink subquery */
 		return query_tree_walker((Query *) node,
 								 check_parameter_resolution_walker,
-								 (void *) pstate, 0);
+								 ctx, 0);
 	}
-	return expression_tree_walker(node, check_parameter_resolution_walker,
-								  (void *) pstate);
+	return expression_tree_walker(node, check_parameter_resolution_walker, ctx);
 }
 
 /*
diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 5ab4612367..fd5609e740 100644
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -191,7 +191,7 @@ static PruneStepResult *get_matching_range_bounds(PartitionPruneContext *context
 												  StrategyNumber opstrategy, Datum *values, int nvalues,
 												  FmgrInfo *partsupfunc, Bitmapset *nullkeys);
 static Bitmapset *pull_exec_paramids(Expr *expr);
-static bool pull_exec_paramids_walker(Node *node, Bitmapset **context);
+static bool pull_exec_paramids_walker(Node *node, void *ctx);
 static Bitmapset *get_partkey_exec_paramids(List *steps);
 static PruneStepResult *perform_pruning_base_step(PartitionPruneContext *context,
 												  PartitionPruneStepOp *opstep);
@@ -3274,8 +3274,10 @@ pull_exec_paramids(Expr *expr)
 }
 
 static bool
-pull_exec_paramids_walker(Node *node, Bitmapset **context)
+pull_exec_paramids_walker(Node *node, void *ctx)
 {
+	Bitmapset **context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Param))
@@ -3286,8 +3288,7 @@ pull_exec_paramids_walker(Node *node, Bitmapset **context)
 			*context = bms_add_member(*context, param->paramid);
 		return false;
 	}
-	return expression_tree_walker(node, pull_exec_paramids_walker,
-								  (void *) context);
+	return expression_tree_walker(node, pull_exec_paramids_walker, ctx);
 }
 
 /*
diff --git a/src/backend/rewrite/rewriteDefine.c b/src/backend/rewrite/rewriteDefine.c
index 213eabfbb9..244aae8048 100644
--- a/src/backend/rewrite/rewriteDefine.c
+++ b/src/backend/rewrite/rewriteDefine.c
@@ -46,7 +46,7 @@
 
 static void checkRuleResultList(List *targetList, TupleDesc resultDesc,
 								bool isSelect, bool requireColumnNameMatch);
-static bool setRuleCheckAsUser_walker(Node *node, Oid *context);
+static bool setRuleCheckAsUser_walker(Node *node, void *ctx);
 static void setRuleCheckAsUser_Query(Query *qry, Oid userid);
 
 
@@ -801,8 +801,10 @@ setRuleCheckAsUser(Node *node, Oid userid)
 }
 
 static bool
-setRuleCheckAsUser_walker(Node *node, Oid *context)
+setRuleCheckAsUser_walker(Node *node, void *ctx)
 {
+	Oid		   *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Query))
@@ -810,8 +812,7 @@ setRuleCheckAsUser_walker(Node *node, Oid *context)
 		setRuleCheckAsUser_Query((Query *) node, *context);
 		return false;
 	}
-	return expression_tree_walker(node, setRuleCheckAsUser_walker,
-								  (void *) context);
+	return expression_tree_walker(node, setRuleCheckAsUser_walker, ctx);
 }
 
 static void
diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index d02fd83c0a..3294e31141 100644
--- a/src/backend/rewrite/rewriteHandler.c
+++ b/src/backend/rewrite/rewriteHandler.c
@@ -57,8 +57,7 @@ typedef struct acquireLocksOnSubLinks_context
 	bool		for_execute;	/* AcquireRewriteLocks' forExecute param */
 } acquireLocksOnSubLinks_context;
 
-static bool acquireLocksOnSubLinks(Node *node,
-								   acquireLocksOnSubLinks_context *context);
+static bool acquireLocksOnSubLinks(Node *node, void *ctx);
 static Query *rewriteRuleAction(Query *parsetree,
 								Query *rule_action,
 								Node *rule_qual,
@@ -298,8 +297,10 @@ AcquireRewriteLocks(Query *parsetree,
  * Walker to find sublink subqueries for AcquireRewriteLocks
  */
 static bool
-acquireLocksOnSubLinks(Node *node, acquireLocksOnSubLinks_context *context)
+acquireLocksOnSubLinks(Node *node, void *ctx)
 {
+	acquireLocksOnSubLinks_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, SubLink))
@@ -317,7 +318,7 @@ acquireLocksOnSubLinks(Node *node, acquireLocksOnSubLinks_context *context)
 	 * Do NOT recurse into Query nodes, because AcquireRewriteLocks already
 	 * processed subselects of subselects for us.
 	 */
-	return expression_tree_walker(node, acquireLocksOnSubLinks, context);
+	return expression_tree_walker(node, acquireLocksOnSubLinks, ctx);
 }
 
 
@@ -1944,8 +1945,10 @@ markQueryForLocking(Query *qry, Node *jtnode,
  * the SubLink's subselect link with the possibly-rewritten subquery.
  */
 static bool
-fireRIRonSubLink(Node *node, List *activeRIRs)
+fireRIRonSubLink(Node *node, void *ctx)
 {
+	List	   *activeRIRs = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, SubLink))
@@ -1962,8 +1965,7 @@ fireRIRonSubLink(Node *node, List *activeRIRs)
 	 * Do NOT recurse into Query nodes, because fireRIRrules already processed
 	 * subselects of subselects for us.
 	 */
-	return expression_tree_walker(node, fireRIRonSubLink,
-								  (void *) activeRIRs);
+	return expression_tree_walker(node, fireRIRonSubLink, ctx);
 }
 
 
diff --git a/src/backend/rewrite/rewriteManip.c b/src/backend/rewrite/rewriteManip.c
index 101c39553a..2e449c4c3b 100644
--- a/src/backend/rewrite/rewriteManip.c
+++ b/src/backend/rewrite/rewriteManip.c
@@ -40,13 +40,10 @@ typedef struct
 	int			win_location;
 } locate_windowfunc_context;
 
-static bool contain_aggs_of_level_walker(Node *node,
-										 contain_aggs_of_level_context *context);
-static bool locate_agg_of_level_walker(Node *node,
-									   locate_agg_of_level_context *context);
+static bool contain_aggs_of_level_walker(Node *node, void *ctx);
+static bool locate_agg_of_level_walker(Node *node, void *ctx);
 static bool contain_windowfuncs_walker(Node *node, void *context);
-static bool locate_windowfunc_walker(Node *node,
-									 locate_windowfunc_context *context);
+static bool locate_windowfunc_walker(Node *node, void *ctx);
 static bool checkExprHasSubLink_walker(Node *node, void *context);
 static Relids offset_relid_set(Relids relids, int offset);
 static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
@@ -81,9 +78,10 @@ contain_aggs_of_level(Node *node, int levelsup)
 }
 
 static bool
-contain_aggs_of_level_walker(Node *node,
-							 contain_aggs_of_level_context *context)
+contain_aggs_of_level_walker(Node *node, void *ctx)
 {
+	contain_aggs_of_level_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Aggref))
@@ -106,12 +104,11 @@ contain_aggs_of_level_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   contain_aggs_of_level_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, contain_aggs_of_level_walker,
-								  (void *) context);
+	return expression_tree_walker(node, contain_aggs_of_level_walker, ctx);
 }
 
 /*
@@ -148,9 +145,10 @@ locate_agg_of_level(Node *node, int levelsup)
 }
 
 static bool
-locate_agg_of_level_walker(Node *node,
-						   locate_agg_of_level_context *context)
+locate_agg_of_level_walker(Node *node, void *ctx)
 {
+	locate_agg_of_level_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Aggref))
@@ -180,12 +178,11 @@ locate_agg_of_level_walker(Node *node,
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   locate_agg_of_level_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, locate_agg_of_level_walker,
-								  (void *) context);
+	return expression_tree_walker(node, locate_agg_of_level_walker, ctx);
 }
 
 /*
@@ -251,8 +248,10 @@ locate_windowfunc(Node *node)
 }
 
 static bool
-locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
+locate_windowfunc_walker(Node *node, void *ctx)
 {
+	locate_windowfunc_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, WindowFunc))
@@ -265,8 +264,7 @@ locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
 		/* else fall through to examine argument */
 	}
 	/* Mustn't recurse into subselects */
-	return expression_tree_walker(node, locate_windowfunc_walker,
-								  (void *) context);
+	return expression_tree_walker(node, locate_windowfunc_walker, ctx);
 }
 
 /*
@@ -337,8 +335,10 @@ typedef struct
 } OffsetVarNodes_context;
 
 static bool
-OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
+OffsetVarNodes_walker(Node *node, void *ctx)
 {
+	OffsetVarNodes_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -413,12 +413,11 @@ OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
 
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, OffsetVarNodes_walker,
-								  (void *) context);
+	return expression_tree_walker(node, OffsetVarNodes_walker, ctx);
 }
 
 void
@@ -502,8 +501,10 @@ typedef struct
 } ChangeVarNodes_context;
 
 static bool
-ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
+ChangeVarNodes_walker(Node *node, void *ctx)
 {
+	ChangeVarNodes_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -598,12 +599,11 @@ ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
 
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, ChangeVarNodes_walker,
-								  (void *) context);
+	return expression_tree_walker(node, ChangeVarNodes_walker, ctx);
 }
 
 void
@@ -700,9 +700,10 @@ typedef struct
 } IncrementVarSublevelsUp_context;
 
 static bool
-IncrementVarSublevelsUp_walker(Node *node,
-							   IncrementVarSublevelsUp_context *context)
+IncrementVarSublevelsUp_walker(Node *node, void *ctx)
 {
+	IncrementVarSublevelsUp_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -763,13 +764,12 @@ IncrementVarSublevelsUp_walker(Node *node,
 		context->min_sublevels_up++;
 		result = query_tree_walker((Query *) node,
 								   IncrementVarSublevelsUp_walker,
-								   (void *) context,
+								   ctx,
 								   QTW_EXAMINE_RTES_BEFORE);
 		context->min_sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, IncrementVarSublevelsUp_walker,
-								  (void *) context);
+	return expression_tree_walker(node, IncrementVarSublevelsUp_walker, ctx);
 }
 
 void
@@ -823,9 +823,10 @@ typedef struct
 } rangeTableEntry_used_context;
 
 static bool
-rangeTableEntry_used_walker(Node *node,
-							rangeTableEntry_used_context *context)
+rangeTableEntry_used_walker(Node *node, void *ctx)
 {
+	rangeTableEntry_used_context *context = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, Var))
@@ -880,12 +881,11 @@ rangeTableEntry_used_walker(Node *node,
 
 		context->sublevels_up++;
 		result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
-								   (void *) context, 0);
+								   ctx, 0);
 		context->sublevels_up--;
 		return result;
 	}
-	return expression_tree_walker(node, rangeTableEntry_used_walker,
-								  (void *) context);
+	return expression_tree_walker(node, rangeTableEntry_used_walker, ctx);
 }
 
 bool
@@ -1131,9 +1131,10 @@ replace_rte_variables(Node *node, int target_varno, int sublevels_up,
 }
 
 Node *
-replace_rte_variables_mutator(Node *node,
-							  replace_rte_variables_context *context)
+replace_rte_variables_mutator(Node *node, void *ctx)
 {
+	replace_rte_variables_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Var))
@@ -1184,15 +1185,14 @@ replace_rte_variables_mutator(Node *node,
 		context->inserted_sublink = ((Query *) node)->hasSubLinks;
 		newnode = query_tree_mutator((Query *) node,
 									 replace_rte_variables_mutator,
-									 (void *) context,
+									 ctx,
 									 0);
 		newnode->hasSubLinks |= context->inserted_sublink;
 		context->inserted_sublink = save_inserted_sublink;
 		context->sublevels_up--;
 		return (Node *) newnode;
 	}
-	return expression_tree_mutator(node, replace_rte_variables_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, replace_rte_variables_mutator, ctx);
 }
 
 
@@ -1230,9 +1230,10 @@ typedef struct
 } map_variable_attnos_context;
 
 static Node *
-map_variable_attnos_mutator(Node *node,
-							map_variable_attnos_context *context)
+map_variable_attnos_mutator(Node *node, void *ctx)
 {
+	map_variable_attnos_context *context = ctx;
+
 	if (node == NULL)
 		return NULL;
 	if (IsA(node, Var))
@@ -1343,13 +1344,12 @@ map_variable_attnos_mutator(Node *node,
 		context->sublevels_up++;
 		newnode = query_tree_mutator((Query *) node,
 									 map_variable_attnos_mutator,
-									 (void *) context,
+									 ctx,
 									 0);
 		context->sublevels_up--;
 		return (Node *) newnode;
 	}
-	return expression_tree_mutator(node, map_variable_attnos_mutator,
-								   (void *) context);
+	return expression_tree_mutator(node, map_variable_attnos_mutator, ctx);
 }
 
 Node *
diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c
index 0d6a295674..e72bf06a3c 100644
--- a/src/backend/utils/cache/plancache.c
+++ b/src/backend/utils/cache/plancache.c
@@ -109,7 +109,7 @@ static Query *QueryListGetPrimaryStmt(List *stmts);
 static void AcquireExecutorLocks(List *stmt_list, bool acquire);
 static void AcquirePlannerLocks(List *stmt_list, bool acquire);
 static void ScanQueryForLocks(Query *parsetree, bool acquire);
-static bool ScanQueryWalker(Node *node, bool *acquire);
+static bool ScanQueryWalker(Node *node, void *ctx);
 static TupleDesc PlanCacheComputeResultDesc(List *stmt_list);
 static void PlanCacheRelCallback(Datum arg, Oid relid);
 static void PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue);
@@ -1879,8 +1879,10 @@ ScanQueryForLocks(Query *parsetree, bool acquire)
  * Walker to find sublink subqueries for ScanQueryForLocks
  */
 static bool
-ScanQueryWalker(Node *node, bool *acquire)
+ScanQueryWalker(Node *node, void *ctx)
 {
+	bool	   *acquire = ctx;
+
 	if (node == NULL)
 		return false;
 	if (IsA(node, SubLink))
@@ -1896,8 +1898,7 @@ ScanQueryWalker(Node *node, bool *acquire)
 	 * Do NOT recurse into Query nodes, because ScanQueryForLocks already
 	 * processed subselects of subselects for us.
 	 */
-	return expression_tree_walker(node, ScanQueryWalker,
-								  (void *) acquire);
+	return expression_tree_walker(node, ScanQueryWalker, ctx);
 }
 
 /*
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 82925b4b63..6c88f4b7ed 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -239,7 +239,7 @@ extern PlanState *ExecInitNode(Plan *node, EState *estate, int eflags);
 extern void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function);
 extern Node *MultiExecProcNode(PlanState *node);
 extern void ExecEndNode(PlanState *node);
-extern bool ExecShutdownNode(PlanState *node);
+extern bool ExecShutdownNode(PlanState *node, void *ctx);
 extern void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node);
 
 
diff --git a/src/include/nodes/nodeFuncs.h b/src/include/nodes/nodeFuncs.h
index 93c60bde66..d0fcf6c0a3 100644
--- a/src/include/nodes/nodeFuncs.h
+++ b/src/include/nodes/nodeFuncs.h
@@ -15,6 +15,8 @@
 
 #include "nodes/parsenodes.h"
 
+struct PlanState;				/* avoid including execnodes.h too */
+
 
 /* flags bits for query_tree_walker and query_tree_mutator */
 #define QTW_IGNORE_RT_SUBQUERIES	0x01	/* subqueries in rtable */
@@ -32,6 +34,14 @@
 /* callback function for check_functions_in_node */
 typedef bool (*check_function_callback) (Oid func_id, void *context);
 
+/* callback functions for tree walkers */
+typedef bool (*tree_walker_callback) (Node *node, void *context);
+typedef bool (*planstate_tree_walker_callback) (struct PlanState *planstate,
+												void *context);
+
+/* callback functions for tree mutators */
+typedef Node *(*tree_mutator_callback) (Node *node, void *context);
+
 
 extern Oid	exprType(const Node *expr);
 extern int32 exprTypmod(const Node *expr);
@@ -129,34 +139,38 @@ get_notclausearg(const void *notclause)
 extern bool check_functions_in_node(Node *node, check_function_callback checker,
 									void *context);
 
-extern bool expression_tree_walker(Node *node, bool (*walker) (),
+extern bool expression_tree_walker(Node *node, tree_walker_callback walker,
 								   void *context);
-extern Node *expression_tree_mutator(Node *node, Node *(*mutator) (),
+extern Node *expression_tree_mutator(Node *node, tree_mutator_callback mutator,
 									 void *context);
 
-extern bool query_tree_walker(Query *query, bool (*walker) (),
+extern bool query_tree_walker(Query *query, tree_walker_callback walker,
 							  void *context, int flags);
-extern Query *query_tree_mutator(Query *query, Node *(*mutator) (),
+extern Query *query_tree_mutator(Query *query, tree_mutator_callback mutator,
 								 void *context, int flags);
 
-extern bool range_table_walker(List *rtable, bool (*walker) (),
+extern bool range_table_walker(List *rtable, tree_walker_callback walker,
 							   void *context, int flags);
-extern List *range_table_mutator(List *rtable, Node *(*mutator) (),
+extern List *range_table_mutator(List *rtable, tree_mutator_callback mutator,
 								 void *context, int flags);
 
-extern bool range_table_entry_walker(RangeTblEntry *rte, bool (*walker) (),
+extern bool range_table_entry_walker(RangeTblEntry *rte,
+									 tree_walker_callback walker,
 									 void *context, int flags);
 
-extern bool query_or_expression_tree_walker(Node *node, bool (*walker) (),
+extern bool query_or_expression_tree_walker(Node *node,
+											tree_walker_callback walker,
 											void *context, int flags);
-extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (),
+extern Node *query_or_expression_tree_mutator(Node *node,
+											  tree_mutator_callback mutator,
 											  void *context, int flags);
 
-extern bool raw_expression_tree_walker(Node *node, bool (*walker) (),
+extern bool raw_expression_tree_walker(Node *node,
+									   tree_walker_callback walker,
 									   void *context);
 
-struct PlanState;
-extern bool planstate_tree_walker(struct PlanState *planstate, bool (*walker) (),
+extern bool planstate_tree_walker(struct PlanState *planstate,
+								  planstate_tree_walker_callback walker,
 								  void *context);
 
 #endif							/* NODEFUNCS_H */
diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h
index 1566f435b3..f62fa440f8 100644
--- a/src/include/optimizer/planmain.h
+++ b/src/include/optimizer/planmain.h
@@ -115,6 +115,6 @@ extern Plan *set_plan_references(PlannerInfo *root, Plan *plan);
 extern bool trivial_subqueryscan(SubqueryScan *plan);
 extern void record_plan_function_dependency(PlannerInfo *root, Oid funcid);
 extern void record_plan_type_dependency(PlannerInfo *root, Oid typid);
-extern bool extract_query_dependencies_walker(Node *node, PlannerInfo *root);
+extern bool extract_query_dependencies_walker(Node *node, void *ctx);
 
 #endif							/* PLANMAIN_H */
diff --git a/src/include/rewrite/rewriteManip.h b/src/include/rewrite/rewriteManip.h
index 98b9b3a288..f57eeef801 100644
--- a/src/include/rewrite/rewriteManip.h
+++ b/src/include/rewrite/rewriteManip.h
@@ -68,8 +68,7 @@ extern Node *replace_rte_variables(Node *node,
 								   replace_rte_variables_callback callback,
 								   void *callback_arg,
 								   bool *outer_hasSubLinks);
-extern Node *replace_rte_variables_mutator(Node *node,
-										   replace_rte_variables_context *context);
+extern Node *replace_rte_variables_mutator(Node *node, void *ctx);
 
 extern Node *map_variable_attnos(Node *node,
 								 int target_varno, int sublevels_up,
