ExplainState *es);
 static void overexplain_bitmapset(const char *qlabel, Bitmapset *bms,
                                  ExplainState *es);
-static void overexplain_intlist(const char *qlabel, List *intlist,
+static void overexplain_intlist(const char *qlabel, List *list,
                                ExplainState *es);
 
 static int es_extension_id;
 
                                              double retrieved_rows,
                                              double width,
                                              double limit_tuples,
-                                             int *disabled_nodes,
+                                             int *p_disabled_nodes,
                                              Cost *p_startup_cost,
                                              Cost *p_run_cost);
 static bool ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
 
                                bool isconcurrent, int request);
 static void _gin_end_parallel(GinLeader *ginleader, GinBuildState *state);
 static Size _gin_parallel_estimate_shared(Relation heap, Snapshot snapshot);
-static double _gin_parallel_heapscan(GinBuildState *buildstate);
-static double _gin_parallel_merge(GinBuildState *buildstate);
+static double _gin_parallel_heapscan(GinBuildState *state);
+static double _gin_parallel_merge(GinBuildState *state);
 static void _gin_leader_participate_as_worker(GinBuildState *buildstate,
                                              Relation heap, Relation index);
-static void _gin_parallel_scan_and_build(GinBuildState *buildstate,
+static void _gin_parallel_scan_and_build(GinBuildState *state,
                                         GinBuildShared *ginshared,
                                         Sharedsort *sharedsort,
                                         Relation heap, Relation index,
 
                                          bool recurse, LOCKMODE lockmode);
 static bool ATExecAlterConstrEnforceability(List **wqueue, ATAlterConstraint *cmdcon,
                                            Relation conrel, Relation tgrel,
-                                           const Oid fkrelid, const Oid pkrelid,
+                                           Oid fkrelid, Oid pkrelid,
                                            HeapTuple contuple, LOCKMODE lockmode,
                                            Oid ReferencedParentDelTrigger,
                                            Oid ReferencedParentUpdTrigger,
                                            List **otherrelids);
 static void AlterConstrEnforceabilityRecurse(List **wqueue, ATAlterConstraint *cmdcon,
                                             Relation conrel, Relation tgrel,
-                                            const Oid fkrelid, const Oid pkrelid,
+                                            Oid fkrelid, Oid pkrelid,
                                             HeapTuple contuple, LOCKMODE lockmode,
                                             Oid ReferencedParentDelTrigger,
                                             Oid ReferencedParentUpdTrigger,
 static void set_attnotnull(List **wqueue, Relation rel, AttrNumber attnum,
                           bool is_valid, bool queue_validation);
 static ObjectAddress ATExecSetNotNull(List **wqueue, Relation rel,
-                                     char *constrname, char *colName,
+                                     char *conName, char *colName,
                                      bool recurse, bool recursing,
                                      LOCKMODE lockmode);
 static bool NotNullImpliedByRelConstraints(Relation rel, Form_pg_attribute attr);
 static void validatePartitionedIndex(Relation partedIdx, Relation partedTbl);
 static void refuseDupeIndexAttach(Relation parentIdx, Relation partIdx,
                                  Relation partitionTbl);
-static void verifyPartitionIndexNotNull(IndexInfo *iinfo, Relation partIdx);
+static void verifyPartitionIndexNotNull(IndexInfo *iinfo, Relation partition);
 static List *GetParentedForeignKeyRefs(Relation partition);
 static void ATDetachCheckNoForeignKeyRefs(Relation partition);
 static char GetAttributeCompression(Oid atttypid, const char *compression);
 
                                      PartitionKey partkey,
                                      PlanState *planstate,
                                      ExprContext *econtext);
-static void InitExecPartitionPruneContexts(PartitionPruneState *prunstate,
+static void InitExecPartitionPruneContexts(PartitionPruneState *prunestate,
                                           PlanState *parent_plan,
                                           Bitmapset *initially_valid_subplans,
                                           int n_total_subplans);
 
 static JumbleState *InitJumble(void);
 static uint64 DoJumble(JumbleState *jstate, Node *node);
 static void AppendJumble(JumbleState *jstate,
-                        const unsigned char *item, Size size);
+                        const unsigned char *value, Size size);
 static void FlushPendingNulls(JumbleState *jstate);
 static void RecordConstLocation(JumbleState *jstate,
-                               int location, bool merged);
+                               int location, bool squashed);
 static void _jumbleNode(JumbleState *jstate, Node *node);
 static void _jumbleElements(JumbleState *jstate, List *elements);
 static void _jumbleA_Const(JumbleState *jstate, Node *node);
 
                                      BlockNumber blockNum,
                                      BufferAccessStrategy strategy,
                                      bool *foundPtr, IOContext io_context);
-static bool AsyncReadBuffers(ReadBuffersOperation *operation, int *nblocks);
+static bool AsyncReadBuffers(ReadBuffersOperation *operation, int *nblocks_progress);
 static void CheckReadBuffersOperation(ReadBuffersOperation *operation, bool is_complete);
 static Buffer GetVictimBuffer(BufferAccessStrategy strategy, IOContext io_context);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln,
 
                              MdfdVec *seg);
 
 static PgAioResult md_readv_complete(PgAioHandle *ioh, PgAioResult prior_result, uint8 cb_data);
-static void md_readv_report(PgAioResult result, const PgAioTargetData *target_data, int elevel);
+static void md_readv_report(PgAioResult result, const PgAioTargetData *td, int elevel);
 
 const PgAioHandleCallbacks aio_md_readv_cb = {
    .complete_shared = md_readv_complete,
 
 static Oid convert_type_name(text *typename);
 static AclMode convert_type_priv_string(text *priv_type_text);
 static AclMode convert_parameter_priv_string(text *priv_text);
-static AclMode convert_largeobject_priv_string(text *priv_text);
+static AclMode convert_largeobject_priv_string(text *priv_type_text);
 static AclMode convert_role_priv_string(text *priv_type_text);
 static AclResult pg_role_aclcheck(Oid role_oid, Oid roleid, AclMode mode);
 
 
 extern pg_locale_t create_pg_locale_builtin(Oid collid,
                                            MemoryContext context);
 extern char *get_collation_actual_version_builtin(const char *collcollate);
-extern size_t strlower_builtin(char *dst, size_t dstsize, const char *src,
+extern size_t strlower_builtin(char *dest, size_t destsize, const char *src,
                               ssize_t srclen, pg_locale_t locale);
-extern size_t strtitle_builtin(char *dst, size_t dstsize, const char *src,
+extern size_t strtitle_builtin(char *dest, size_t destsize, const char *src,
                               ssize_t srclen, pg_locale_t locale);
-extern size_t strupper_builtin(char *dst, size_t dstsize, const char *src,
+extern size_t strupper_builtin(char *dest, size_t destsize, const char *src,
                               ssize_t srclen, pg_locale_t locale);
-extern size_t strfold_builtin(char *dst, size_t dstsize, const char *src,
+extern size_t strfold_builtin(char *dest, size_t destsize, const char *src,
                              ssize_t srclen, pg_locale_t locale);
 
 
 
 #define        TEXTBUFLEN          1024
 
 extern pg_locale_t create_pg_locale_icu(Oid collid, MemoryContext context);
-extern size_t strlower_icu(char *dst, size_t dstsize, const char *src,
+extern size_t strlower_icu(char *dest, size_t destsize, const char *src,
                           ssize_t srclen, pg_locale_t locale);
-extern size_t strtitle_icu(char *dst, size_t dstsize, const char *src,
+extern size_t strtitle_icu(char *dest, size_t destsize, const char *src,
                           ssize_t srclen, pg_locale_t locale);
-extern size_t strupper_icu(char *dst, size_t dstsize, const char *src,
+extern size_t strupper_icu(char *dest, size_t destsize, const char *src,
                           ssize_t srclen, pg_locale_t locale);
-extern size_t strfold_icu(char *dst, size_t dstsize, const char *src,
+extern size_t strfold_icu(char *dest, size_t destsize, const char *src,
                          ssize_t srclen, pg_locale_t locale);
 
 #ifdef USE_ICU
 
 extern UCollator *pg_ucol_open(const char *loc_str);
 
-static int strncoll_icu(const char *arg1, ssize_t len1,
-                        const char *arg2, ssize_t len2,
-                        pg_locale_t locale);
 static size_t strnxfrm_icu(char *dest, size_t destsize,
                           const char *src, ssize_t srclen,
                           pg_locale_t locale);
-static size_t strnxfrm_prefix_icu(char *dest, size_t destsize,
-                                 const char *src, ssize_t srclen,
-                                 pg_locale_t locale);
 extern char *get_collation_actual_version_icu(const char *collcollate);
 
 typedef int32_t (*ICU_Convert_Func) (UChar *dest, int32_t destCapacity,
 
 static void MemoryContextStatsPrint(MemoryContext context, void *passthru,
                                    const char *stats_string,
                                    bool print_to_stderr);
-static void PublishMemoryContext(MemoryStatsEntry *memcxt_infos,
+static void PublishMemoryContext(MemoryStatsEntry *memcxt_info,
                                 int curr_id, MemoryContext context,
                                 List *path,
                                 MemoryContextCounters stat,
 
                                PQExpBufferData *sql);
 static void run_reindex_command(PGconn *conn, ReindexType type,
                                const char *name, bool echo,
-                               PQExpBufferData *sq);
+                               PQExpBufferData *sql);
 
 static void help(const char *progname);
 
 
                           void *wbstate);
 static enum CaseMapResult casemap(pg_wchar u1, CaseKind casekind, bool full,
                                  const char *src, size_t srclen, size_t srcoff,
-                                 pg_wchar *u2, const pg_wchar **special);
+                                 pg_wchar *simple, const pg_wchar **special);
 
 pg_wchar
 unicode_lowercase_simple(pg_wchar code)
 
                              ParamListInfo params);
 
 extern void ExplainOnePlan(PlannedStmt *plannedstmt, CachedPlan *cplan,
-                          CachedPlanSource *plansource, int plan_index,
+                          CachedPlanSource *plansource, int query_index,
                           IntoClause *into, struct ExplainState *es,
                           const char *queryString,
                           ParamListInfo params, QueryEnvironment *queryEnv,
 
 /*
  * Ensure a validator named in the HBA is permitted by the configuration.
  */
-extern bool check_oauth_validator(HbaLine *hba, int elevel, char **err_msg);
+extern bool check_oauth_validator(HbaLine *hbaline, int elevel, char **err_msg);
 
 #endif                         /* PG_OAUTH_H */
 
                            RelOptInfo *baserel, ParamPathInfo *param_info);
 extern void cost_recursive_union(Path *runion, Path *nrterm, Path *rterm);
 extern void cost_sort(Path *path, PlannerInfo *root,
-                     List *pathkeys, int disabled_nodes,
+                     List *pathkeys, int input_disabled_nodes,
                      Cost input_cost, double tuples, int width,
                      Cost comparison_cost, int sort_mem,
                      double limit_tuples);
                     AggStrategy aggstrategy, const AggClauseCosts *aggcosts,
                     int numGroupCols, double numGroups,
                     List *quals,
-                    int input_disabled_nodes,
+                    int disabled_nodes,
                     Cost input_startup_cost, Cost input_total_cost,
                     double input_tuples, double input_width);
 extern void cost_windowagg(Path *path, PlannerInfo *root,
 
 extern bool innerrel_is_unique_ext(PlannerInfo *root, Relids joinrelids,
                                   Relids outerrelids, RelOptInfo *innerrel,
                                   JoinType jointype, List *restrictlist,
-                                  bool force_cache, List **uclauses);
-extern List *remove_useless_self_joins(PlannerInfo *root, List *jointree);
+                                  bool force_cache, List **extra_clauses);
+extern List *remove_useless_self_joins(PlannerInfo *root, List *joinlist);
 
 /*
  * prototypes for plan/setrefs.c
 
 extern PGDLLIMPORT pg_crc32c (*pg_comp_crc32c) (pg_crc32c crc, const void *data, size_t len);
 extern pg_crc32c pg_comp_crc32c_sse42(pg_crc32c crc, const void *data, size_t len);
 #ifdef USE_AVX512_CRC32C_WITH_RUNTIME_CHECK
-extern pg_crc32c pg_comp_crc32c_avx512(pg_crc32c crc, const void *data, size_t len);
+extern pg_crc32c pg_comp_crc32c_avx512(pg_crc32c crc, const void *data, size_t length);
 #endif
 
 #elif defined(USE_ARMV8_CRC32C)
 
 extern void CheckSlotRequirements(void);
 extern void CheckSlotPermissions(void);
 extern ReplicationSlotInvalidationCause
-           GetSlotInvalidationCause(const char *invalidation_reason);
+           GetSlotInvalidationCause(const char *cause_name);
 extern const char *GetSlotInvalidationCauseName(ReplicationSlotInvalidationCause cause);
 
 extern bool SlotExistsInSyncStandbySlots(const char *slot_name);
 
 extern void LWLockRelease(LWLock *lock);
 extern void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val);
 extern void LWLockReleaseAll(void);
-extern void LWLockDisown(LWLock *l);
-extern void LWLockReleaseDisowned(LWLock *l, LWLockMode mode);
+extern void LWLockDisown(LWLock *lock);
+extern void LWLockReleaseDisowned(LWLock *lock, LWLockMode mode);
 extern bool LWLockHeldByMe(LWLock *lock);
 extern bool LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride);
 extern bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode);
 
                        BlockNumber blocknum, BlockNumber nblocks);
 extern BlockNumber mdnblocks(SMgrRelation reln, ForkNumber forknum);
 extern void mdtruncate(SMgrRelation reln, ForkNumber forknum,
-                      BlockNumber old_blocks, BlockNumber nblocks);
+                      BlockNumber curnblk, BlockNumber nblocks);
 extern void mdimmedsync(SMgrRelation reln, ForkNumber forknum);
 extern void mdregistersync(SMgrRelation reln, ForkNumber forknum);
 extern int mdfd(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, uint32 *off);
 
 extern pg_locale_t pg_newlocale_from_collation(Oid collid);
 
 extern char *get_collation_actual_version(char collprovider, const char *collcollate);
-extern size_t pg_strlower(char *dest, size_t destsize,
+extern size_t pg_strlower(char *dst, size_t dstsize,
                          const char *src, ssize_t srclen,
                          pg_locale_t locale);
-extern size_t pg_strtitle(char *dest, size_t destsize,
+extern size_t pg_strtitle(char *dst, size_t dstsize,
                          const char *src, ssize_t srclen,
                          pg_locale_t locale);
-extern size_t pg_strupper(char *dest, size_t destsize,
+extern size_t pg_strupper(char *dst, size_t dstsize,
                          const char *src, ssize_t srclen,
                          pg_locale_t locale);
-extern size_t pg_strfold(char *dest, size_t destsize,
+extern size_t pg_strfold(char *dst, size_t dstsize,
                         const char *src, ssize_t srclen,
                         pg_locale_t locale);
 extern int pg_strcoll(const char *arg1, const char *arg2, pg_locale_t locale);
 
 
 extern void tuplestore_trim(Tuplestorestate *state);
 
-extern void tuplestore_get_stats(Tuplestorestate *state, char **storage_type,
+extern void tuplestore_get_stats(Tuplestorestate *state, char **max_storage_type,
                                 int64 *max_space);
 
 extern bool tuplestore_in_memory(Tuplestorestate *state);
 
 static bool fail_token(const ValidatorModuleState *state,
                       const char *token,
                       const char *role,
-                      ValidatorModuleResult *result);
+                      ValidatorModuleResult *res);
 
 /* Callback implementations (we only need the main one) */
 static const OAuthValidatorCallbacks validator_callbacks = {
 
 static bool validate_token(const ValidatorModuleState *state,
                           const char *token,
                           const char *role,
-                          ValidatorModuleResult *result);
+                          ValidatorModuleResult *res);
 
 /* Callback implementations (we only need the main one) */
 static const OAuthValidatorCallbacks validator_callbacks = {
 
 static bool validate_token(const ValidatorModuleState *state,
                           const char *token,
                           const char *role,
-                          ValidatorModuleResult *result);
+                          ValidatorModuleResult *res);
 
 /* Callback implementations (exercise all three) */
 static const OAuthValidatorCallbacks validator_callbacks = {