Code Conventions AnalysisCode Quality Analysis - February 2026 - Modern C++ Adoption Progress

[github-actions[bot]]

Code Conventions Analysis Report

Analysis Date: February 4, 2026
Run Number: 4
Files Examined: 2,009 files across key directories

Executive Summary

This run successfully implemented a major refactoring to modernize mk_concat call sites, eliminating 21 lines of boilerplate code and improving readability across 6 files. The analysis continues to track progress on modern C++ adoption and identifies remaining opportunities for code quality improvements.

Progress Tracking Summary

✅ RESOLVED Issues (This Run)

std::initializer_list for mk_concat - IMPLEMENTED 🎉

• Refactored 13 call sites across 6 files to use existing std::initializer_list(expr*) overload
• Files modified:
  • src/ast/rewriter/bv_rewriter.cpp (6 refactorings)
  • src/ast/rewriter/fpa_rewriter.cpp (1 refactoring)
  • src/ast/fpa/fpa2bv_converter.cpp (1 refactoring)
  • src/smt/theory_fpa.cpp (1 refactoring)
  • src/qe/mbp/mbp_solve_plugin.cpp (3 refactorings)
  • src/sat/smt/fpa_solver.cpp (1 refactoring)
• Impact: 21 lines removed, cleaner code, type-safe array passing
• Example: mk_concat(2, args) → mk_concat({arg1, arg2})
• Issue created: #conventions_mk_concat_init_list

✅ RESOLVED Issues (Previous Runs)

std::span migration for mk_or and mk_xor - IMPLEMENTED (Run 3)

• Added std::span overloads for mk_or and mk_xor APIs
• Updated 4 call sites for consistency with mk_and
• Achieved zero-overhead abstraction with cleaner, type-safe interfaces

❌ UNRESOLVED Issues (Still Present)

The following issues from previous analysis runs remain unresolved:

1. std::span migration to arithmetic utilities (Priority: Medium)

   • Functions: mk_add, mk_mul, mk_sub in arith_decl_plugin.h
   • Estimated impact: 15 files

2. std::span migration to bitvector utilities (Priority: Medium)

   • Functions: mk_bv_or, mk_bv_and, mk_bv_xor (unsigned + pointer versions)
   • Note: These already have std::initializer_list overloads
   • Estimated impact: 10 files

3. std::clamp opportunities (Priority: Low)

   • 5 instances of std::max(min, std::min(max, val)) pattern
   • Can be replaced with std::clamp(val, min, max) for clarity

4. NULL to nullptr (Priority: Low)

   • 2 remaining instances (98%+ already modernized)

5. Plain enum to enum class (Priority: Medium)

   • 15+ instances of plain enum that could be enum class
   • Would require significant refactoring across codebase
   • Examples: arith_sort_kind, arith_op_kind, array_sort_kind

6. Stream output optimization (Priority: Low)

   • 30+ instances of single-character strings that should use character literals
   • Example: buffer << ")" → buffer << ')'
   • Binary size and performance improvement

1. Coding Convention Consistency Findings

1.1 Modern C++ API Consistency

Current State: The codebase has excellent modern API coverage with std::span and std::initializer_list overloads

This Run's Achievement:

• Successfully refactored all mk_concat call sites to use the existing std::initializer_list overload
• Demonstrated that modern APIs exist but aren't always consistently used
• Established a pattern for future refactorings

Recommendation: Continue systematic review and refactoring of call sites to use modern overloads where they exist

1.2 Array Parameter Patterns

Observation: Z3 has transitioned well from old-style (unsigned n, T* args) to modern patterns

Evolution:

1. Old style: func(unsigned sz, expr* const* args) - requires temporary arrays
2. Modern: func(std::span(expr*)) - for runtime-sized arrays
3. Modern: func(std::initializer_list(expr*)) - for compile-time small arrays
4. Convenience: Individual parameter overloads for common cases

Status: The infrastructure is in place; remaining work is to refactor call sites

2. Modern C++ Feature Opportunities

2.1 std::initializer_list - COMPLETED ✅

Feature: std::initializer_list(T) for small, compile-time known arrays

Implementation: Successfully refactored mk_concat call sites

Example:

// Before
expr * args[2] = { m_mk_extract(sz - n - 1, 0, arg), m_mk_extract(sz - 1, sz - n, arg) };
result = m_util.mk_concat(2, args);

// After  
result = m_util.mk_concat({m_mk_extract(sz - n - 1, 0, arg), m_mk_extract(sz - 1, sz - n, arg)});

Impact: 21 lines removed, improved readability, type safety

Next Candidates: Similar opportunities may exist for mk_bv_or, mk_bv_and, mk_bv_xor if call sites create temporary arrays

2.2 std::span - IN PROGRESS 🔄

Feature: std::span(T) for array views (C++20)

Progress:

• mk_and, mk_or, mk_xor have std::span overloads ✅
• Arithmetic utilities (mk_add, mk_mul, mk_sub) - pending
• Bitvector utilities - pending

Benefit: Type-safe array passing without size/pointer mismatch

2.3 std::clamp - LOW HANGING FRUIT 🍎

Feature: std::clamp(val, min, max) for value clamping (C++17)

Current Pattern: std::max(min, std::min(max, val))

Opportunity: 5 verified instances

Example Location: src/ast/simplifiers/bound_propagator.cpp:394

Effort: Low - simple find and replace

Benefit: More readable and intention-revealing code

2.4 Character Literals - OPTIMIZATION 📉

Pattern: Using string literals for single characters

Impact: Binary size and runtime performance

Examples:

• src/api/api_ast_vector.cpp:133: buffer << ")" → buffer << ')'
• src/api/api_params.cpp:203: buffer << "(" → buffer << '('

Count: 30+ instances

Effort: Low

Benefit: Reduced code size, avoid unnecessary string overhead

2.5 Enum Class - LARGER REFACTORING 🏗️

Current: Plain enum declarations for sort kinds and operation kinds

Modern: enum class for type safety and scoping

Examples:

• arith_sort_kind, arith_op_kind in src/ast/arith_decl_plugin.h
• array_sort_kind, array_op_kind in src/ast/array_decl_plugin.h
• bv_sort_kind in src/ast/bv_decl_plugin.h

Count: 15+ enums

Challenge: Would require significant refactoring across 50+ files

Benefit: Type safety, prevents accidental conversions, clearer scoping

Recommendation: Plan as a larger, coordinated effort

3. Z3-Specific Code Quality Opportunities

3.1 Consistent Use of Existing Modern APIs

Discovery: Modern API overloads exist but aren't always used consistently

Example: Before this run, mk_concat had an initializer_list overload since the API was modernized, but 13 call sites still created temporary arrays

Lesson: API modernization requires two phases:

1. Add modern overloads ✅
2. Refactor existing call sites to use them ← This run focused here

Recommendation:

• Systematically search for similar patterns
• Prioritize refactoring call sites to use modern overloads that already exist
• This is lower risk than adding new APIs

3.2 Additional initializer_list Candidates

Potential Targets: Functions with existing std::initializer_list overloads that might have old-style call sites:

• mk_bv_or(std::initializer_list(expr*)) - line 509 in bv_decl_plugin.h
• mk_bv_and(std::initializer_list(expr*)) - line 511
• mk_bv_xor(std::initializer_list(expr*)) - line 513

Action: Search for call sites that create temporary arrays for these functions

Expected: Likely 0 or very few, but worth checking

3.3 Memory and Performance Patterns

Observation: The refactoring from temporary arrays to initializer_list is zero-overhead

Verification: Compiler will generate identical code for both patterns

Benefit: Pure improvement in readability and maintainability with no runtime cost

4. Priority Recommendations

Ranked by impact and effort:

1. Continue std::span migration - High Impact, Medium Effort

   • Apply to arithmetic utilities (mk_add, mk_mul, mk_sub)
   • Apply to remaining bitvector utilities
   • Follows established pattern from previous runs

2. Apply std::clamp refactoring - Low Impact, Low Effort 🍎

   • Only 5 instances
   • Clear improvement in readability
   • Simple find and replace
   • Good "quick win"

3. Fix remaining NULL usage - Low Impact, Low Effort 🍎

   • Only 2 instances
   • Trivial to fix
   • Completes the nullptr modernization

4. Stream output character literals - Low Impact, Low Effort 🍎

   • 30+ instances
   • Simple pattern to fix
   • Minor performance and binary size benefit

5. Search for additional initializer_list call sites - Unknown Impact, Low Effort

   • Check mk_bv_or, mk_bv_and, mk_bv_xor for temporary array usage
   • May find 0 or a few instances
   • Low-risk investigation

6. Plan enum class migration - Medium Impact, High Effort

   • 15+ enums to convert
   • 50+ files affected
   • Requires coordinated effort
   • Consider as a separate initiative

5. Sample Refactoring Examples

Example 1: mk_concat with initializer_list (COMPLETED)

Location: src/ast/rewriter/bv_rewriter.cpp:927

Before:

unsigned k = r2.get_unsigned();
expr * new_args[2] = { m_mk_extract(bv_size - k - 1, 0, arg1), mk_zero(k) };
result = m_util.mk_concat(2, new_args);

After:

unsigned k = r2.get_unsigned();
result = m_util.mk_concat({m_mk_extract(bv_size - k - 1, 0, arg1), mk_zero(k)});

Benefits:

• 2 lines → 1 line
• No temporary variable
• Type-safe size
• More readable

Example 2: std::clamp opportunity (PENDING)

Location: src/ast/simplifiers/bound_propagator.cpp:394

Current:

std::max(std::min(interval_size, abs_k), 1.0)

Recommended:

std::clamp(interval_size, 1.0, abs_k)

Benefits:

• More readable
• Clearly expresses "clamp to range"
• Standard algorithm

Example 3: Character literal (PENDING)

Location: src/api/api_ast_vector.cpp:133

Current:

buffer << ")";

Recommended:

buffer << ')';

Benefits:

• Smaller binary size
• Slightly faster (no string construction)
• More idiomatic

6. Next Steps

• Refactor mk_concat call sites to use std::initializer_list COMPLETED ✅
• Apply std::clamp refactoring (5 instances) - Quick win!
• Fix remaining NULL to nullptr (2 instances) - Quick win!
• Search for mk_bv_or/and/xor call sites with temporary arrays
• Continue std::span migration to arithmetic utilities
• Continue std::span migration to bitvector utilities
• Apply stream output character literal optimization (30+ instances)
• Plan enum class migration as coordinated effort

7. Metrics and Statistics

This Run (Run 4)

• Issue Created: 1 (mk_concat initializer_list refactoring)
• Files Modified: 6
• Call Sites Refactored: 13
• Lines Removed: 21
• Code Quality Improvement: High

Cumulative Progress

• Total Runs: 4
• Total Issues Resolved: 2 (std::span mk_or/xor, initializer_list mk_concat)
• Total Unresolved Issues: 6 categories
• Files Examined: 2,009
• Modernization Progress: Steady advancement

Code Quality Indicators

• nullptr Adoption: 98%+ (2 remaining)
• Modern API Coverage: Excellent (std::span, std::initializer_list overloads exist)
• Call Site Modernization: Improving (13 sites updated this run)
• std::clamp Opportunities: 5 instances
• Stream Output Efficiency: 30+ opportunities

Appendix: Areas Analyzed

Analyzed This Run

• src/ast/rewriter/bv_rewriter.cpp - Bitvector rewriting (modified)
• src/ast/rewriter/fpa_rewriter.cpp - Floating-point rewriting (modified)
• src/ast/fpa/fpa2bv_converter.cpp - FP to BV conversion (modified)
• src/smt/theory_fpa.cpp - FP theory solver (modified)
• src/qe/mbp/mbp_solve_plugin.cpp - Quantifier elimination (modified)
• src/sat/smt/fpa_solver.cpp - SAT FP solver (modified)
• src/ast/bv_decl_plugin.h - Verified initializer_list overloads

Previously Analyzed

• src/ast/*.h - AST headers and utilities
• src/ast/*.cpp - AST implementations
• src/util/*.h and *.cpp - Utility libraries
• src/api/*.cpp - Public API surface
• src/smt/*.cpp - SMT solver components (partial)
• src/ast/arith_decl_plugin.h - Arithmetic plugin
• src/ast/array_decl_plugin.h - Array plugin

Not Yet Deeply Analyzed

• src/solver/ - Solver implementations
• src/parsers/ - Input parsers
• src/model/ - Model generation
• src/nlsat/ - Nonlinear arithmetic
• src/muz/ - Most files (except spacer_context)
• src/tactic/ - Most tactical components

Conclusion

This analysis run successfully implemented a significant code modernization by refactoring 13 call sites to use std::initializer_list, demonstrating the value of systematic code quality improvements. The Z3 codebase continues to evolve toward modern C++ idioms while maintaining its robust functionality.

Key Takeaway: Modern APIs exist in Z3, but consistent adoption requires ongoing refactoring efforts. This run proved that such refactoring is safe, beneficial, and achievable in manageable increments.

Next Focus: Low-effort, high-readability improvements like std::clamp, nullptr fixes, and character literal optimizations offer quick wins for the next analysis run.

AI generated by Code Conventions Analyzer

• expires on Feb 11, 2026, 12:30 AM UTC

[github-actions[bot]]

This discussion was automatically closed because it expired on 2026-02-11T00:30:24.357Z.

Closed by Workflow