Capture compiler updates and formatting sweep

Status	File	+	-
M	`afs-as`	1	1
M	`afs-ld`	1	1
M	`runtime/src/array.rs`	407	138
M	`runtime/src/descriptor.rs`	16	4
M	`runtime/src/format.rs`	474	111
M	`runtime/src/io_system.rs`	1146	410
M	`runtime/src/lib.rs`	5	5
M	`runtime/src/mem.rs`	9	14
M	`runtime/src/system.rs`	169	45
M	`src/ast/decl.rs`	19	31
M	`src/ast/expr.rs`	70	72
M	`src/ast/mod.rs`	1	1
M	`src/ast/stmt.rs`	132	37
M	`src/ast/unit.rs`	5	5
M	`src/codegen/linearscan.rs`	147	54
M	`src/codegen/liveness.rs`	54	22
M	`src/codegen/mod.rs`	4	4
M	`src/codegen/peephole.rs`	125	33
M	`src/codegen/regalloc.rs`	40	22
M	`src/codegen/tailcall.rs`	69	45
M	`src/driver/dep_scan.rs`	84	19
M	`src/driver/diag.rs`	16	9
M	`src/driver/mod.rs`	105	48
M	`src/ir/builder.rs`	143	39
M	`src/ir/inst.rs`	90	41
M	`src/ir/mod.rs`	3	3
M	`src/ir/printer.rs`	141	36
M	`src/ir/types.rs`	24	7
M	`src/ir/verify.rs`	130	54
M	`src/ir/walk.rs`	268	122
M	`src/lexer/mod.rs`	644	211
M	`src/opt/alias.rs`	103	32
M	`src/opt/audit_tests.rs`	835	228
M	`src/opt/bce.rs`	106	48
M	`src/opt/call_resolve.rs`	9	5
M	`src/opt/callgraph.rs`	37	17
M	`src/opt/const_arg.rs`	81	17
M	`src/opt/const_fold.rs`	217	74
M	`src/opt/const_prop.rs`	42	11
M	`src/opt/cse.rs`	123	45
M	`src/opt/dce.rs`	125	42
M	`src/opt/dead_arg.rs`	31	9
M	`src/opt/dead_func.rs`	25	10
M	`src/opt/dep_analysis.rs`	139	49
M	`src/opt/dse.rs`	75	41
M	`src/opt/fast_math.rs`	35	14
M	`src/opt/fission.rs`	78	29
M	`src/opt/fusion.rs`	123	52
M	`src/opt/global_lsf.rs`	35	19
M	`src/opt/gvn.rs`	324	113
M	`src/opt/inline.rs`	148	137
M	`src/opt/interchange.rs`	128	43
M	`src/opt/licm.rs`	173	62
M	`src/opt/loop_tree.rs`	128	53
M	`src/opt/loop_utils.rs`	85	68
M	`src/opt/lsf.rs`	236	76
M	`src/opt/mem2reg.rs`	802	308
M	`src/opt/mod.rs`	28	28
M	`src/opt/pass.rs`	23	10
M	`src/opt/peel.rs`	97	38
M	`src/opt/pipeline.rs`	39	26
M	`src/opt/preheader.rs`	81	36
M	`src/opt/return_prop.rs`	68	19
M	`src/opt/simplify_cfg.rs`	58	20
M	`src/opt/sroa.rs`	69	25
M	`src/opt/strength_reduce.rs`	194	54
M	`src/opt/unroll.rs`	343	185
M	`src/opt/unswitch.rs`	121	51
M	`src/opt/util.rs`	4	14
M	`src/opt/vectorize.rs`	170	51
M	`src/parser/decl.rs`	449	124
M	`src/parser/expr.rs`	255	105
M	`src/parser/mod.rs`	22	7
M	`src/parser/stmt.rs`	13	6
M	`src/preprocess/mod.rs`	278	76
M	`src/sema/intrinsic_modules.rs`	118	48
M	`src/sema/mod.rs`	4	4
M	`src/sema/symtab.rs`	79	23
M	`src/sema/type_layout.rs`	190	93
M	`src/sema/types.rs`	779	302
M	`src/sema/validate.rs`	606	273
M	`src/testing.rs`	29	20
M	`tests/artifact_audit_29_10.rs`	10	2
M	`tests/claims_audit_29_11.rs`	11	3
M	`tests/determinism_sweep.rs`	23	9
M	`tests/fortran_alias_licm.rs`	8	6
M	`tests/fuzz_smoke.rs`	14	6
M	`tests/gvn_dse_audit_29_11.rs`	2	8
M	`tests/i128_cross_object.rs`	35	9
M	`tests/i128_formatted_read.rs`	64	13
M	`tests/i128_gates.rs`	15	3
M	`tests/i128_high_opt.rs`	5	1
M	`tests/i128_internal_io.rs`	94	20
M	`tests/i128_memory_backend.rs`	15	3
M	`tests/i128_o1.rs`	10	2
M	`tests/i128_o2.rs`	5	1
M	`tests/i128_runtime_io.rs`	24	7
M	`tests/i128_runtime_read.rs`	9	3
M	`tests/i128_stack_args.rs`	23	4
M	`tests/incremental.rs`	23	10
M	`tests/ipo_const_arg.rs`	25	11
M	`tests/ipo_dead_arg.rs`	31	12
M	`tests/ipo_return_prop.rs`	13	9
M	`tests/licm_lsf_audit_29_11.rs`	7	6
M	`tests/multifile.rs`	44	17
M	`tests/multifile_gen.rs`	55	18
M	`tests/ofast_fast_math.rs`	17	4
M	`tests/opt_audit_29_11.rs`	5	4
M	`tests/program_entry_audit.rs`	4	1
M	`tests/pure_call_reuse.rs`	5	5
M	`tests/pure_dead_call_elim.rs`	3	1
M	`tests/vectorize_do_loop.rs`	4	1

afs-asmodified

2 lines changed — click to load

`@@ -1,1 +1,1 @@`
1		-Subproject commit 67061bd8688fcbe3a633c87557913bed9eeddba6
	1	+Subproject commit 36a2e46e175f530b8884242fed09c8b2b79bfda8

afs-ldmodified

2 lines changed — click to load

`@@ -1,1 +1,1 @@`
1		-Subproject commit 5e99aa0c7b24dd10a3ad09de3d11823e07bc4839
	1	+Subproject commit 20d5047b0a9875d243f48f48b5ecfd70cc5d046a

runtime/src/array.rsmodified

1060 lines changed — click to load

      if len == 0 {
          return;
+     }
 -    unsafe { fill_i32_impl(dest, len, value); }
 +    unsafe {
 +        fill_i32_impl(dest, len, value);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { fill_f32_impl(dest, len, value); }
 +    unsafe {
 +        fill_f32_impl(dest, len, value);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { fill_f64_impl(dest, len, value); }
 +    unsafe {
 +        fill_f64_impl(dest, len, value);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { add_i32_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        add_i32_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { add_f32_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        add_f32_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { add_f64_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        add_f64_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { sub_i32_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        sub_i32_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { sub_f32_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        sub_f32_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { sub_f64_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        sub_f64_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { mul_i32_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        mul_i32_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { mul_f32_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        mul_f32_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { mul_f64_impl(dest, lhs, rhs, len); }
 +    unsafe {
 +        mul_f64_impl(dest, lhs, rhs, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { add_scalar_i32_impl(dest, src, scalar, len); }
 +    unsafe {
 +        add_scalar_i32_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { add_scalar_f32_impl(dest, src, scalar, len); }
 +    unsafe {
 +        add_scalar_f32_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { add_scalar_f64_impl(dest, src, scalar, len); }
 +    unsafe {
 +        add_scalar_f64_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { sub_scalar_i32_impl(dest, src, scalar, len); }
 +    unsafe {
 +        sub_scalar_i32_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { sub_scalar_f32_impl(dest, src, scalar, len); }
 +    unsafe {
 +        sub_scalar_f32_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { sub_scalar_f64_impl(dest, src, scalar, len); }
 +    unsafe {
 +        sub_scalar_f64_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { scalar_sub_i32_impl(dest, scalar, src, len); }
 +    unsafe {
 +        scalar_sub_i32_impl(dest, scalar, src, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { scalar_sub_f32_impl(dest, scalar, src, len); }
 +    unsafe {
 +        scalar_sub_f32_impl(dest, scalar, src, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { scalar_sub_f64_impl(dest, scalar, src, len); }
 +    unsafe {
 +        scalar_sub_f64_impl(dest, scalar, src, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { mul_scalar_i32_impl(dest, src, scalar, len); }
 +    unsafe {
 +        mul_scalar_i32_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { mul_scalar_f32_impl(dest, src, scalar, len); }
 +    unsafe {
 +        mul_scalar_f32_impl(dest, src, scalar, len);
 +    }
+ }
  #[no_mangle]
      if len == 0 {
          return;
+     }
 -    unsafe { mul_scalar_f64_impl(dest, src, scalar, len); }
 +    unsafe {
 +        mul_scalar_f64_impl(dest, src, scalar, len);
 +    }
+ }
  // ---- ALLOCATE ----
      stat: *mut i32,
  ) {
      if desc.is_null() {
 -        if !stat.is_null() { unsafe { *stat = 1; } }
 +        if !stat.is_null() {
 +            unsafe {
 +                *stat = 1;
 +            }
 +        }
          return;
+     }
      // Check if already allocated.
      if desc.is_allocated() {
          if !stat.is_null() {
 -            unsafe { *stat = 2; } // already allocated
 +            unsafe {
 +                *stat = 2;
 +            } // already allocated
              return;
+         }
          eprintln!("ALLOCATE: array is already allocated");
          // Zero-size allocation: valid but produces a null/empty array.
          desc.base_addr = ptr::null_mut();
          desc.flags = DESC_ALLOCATED | DESC_CONTIGUOUS;
 -        if !stat.is_null() { unsafe { *stat = 0; } }
 +        if !stat.is_null() {
 +            unsafe {
 +                *stat = 0;
 +            }
 +        }
          return;
+     }
      let ptr = unsafe { libc_malloc(bytes as usize) };
      if ptr.is_null() {
          if !stat.is_null() {
 -            unsafe { *stat = 3; } // allocation failed
 +            unsafe {
 +                *stat = 3;
 +            } // allocation failed
              return;
+         }
          eprintln!("ALLOCATE: out of memory ({} bytes)", bytes);
+     }
      // Zero-initialize (Fortran doesn't require this, but it's safer).
 -    unsafe { ptr::write_bytes(ptr, 0, bytes as usize); }
 +    unsafe {
 +        ptr::write_bytes(ptr, 0, bytes as usize);
 +    }
      desc.base_addr = ptr;
      desc.flags = DESC_ALLOCATED | DESC_CONTIGUOUS;
 -    if !stat.is_null() { unsafe { *stat = 0; } }
 +    if !stat.is_null() {
 +        unsafe {
 +            *stat = 0;
 +        }
 +    }
+ }
  /// Simplified allocate for a 1D array with given element count.
  /// Used by generated code for simple `allocate(a(n))` patterns.
  #[no_mangle]
 -pub extern "C" fn afs_allocate_1d(
 -    desc: *mut ArrayDescriptor,
 -    elem_size: i64,
 -    n: i64,
 -) {
 -    let dim = DimDescriptor { lower_bound: 1, upper_bound: n, stride: 1 };
 -    afs_allocate_array(desc, elem_size, 1, &dim as *const DimDescriptor, ptr::null_mut());
 +pub extern "C" fn afs_allocate_1d(desc: *mut ArrayDescriptor, elem_size: i64, n: i64) {
 +    let dim = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: n,
 +        stride: 1,
 +    };
 +    afs_allocate_array(
 +        desc,
 +        elem_size,
 +        1,
 +        &dim as *const DimDescriptor,
 +        ptr::null_mut(),
 +    );
+ }
  // ---- DEALLOCATE ----
  ///
  /// Safe to call on an already-deallocated descriptor (no-op with stat=0).
  #[no_mangle]
 -pub extern "C" fn afs_deallocate_array(
 -    desc: *mut ArrayDescriptor,
 -    stat: *mut i32,
 -) {
 +pub extern "C" fn afs_deallocate_array(desc: *mut ArrayDescriptor, stat: *mut i32) {
      if desc.is_null() {
 -        if !stat.is_null() { unsafe { *stat = 1; } }
 +        if !stat.is_null() {
 +            unsafe {
 +                *stat = 1;
 +            }
 +        }
          return;
+     }
      if !desc.is_allocated() {
          // Not allocated — not an error with STAT, abort without STAT.
          if !stat.is_null() {
 -            unsafe { *stat = 0; }
 +            unsafe {
 +                *stat = 0;
 +            }
              return;
+         }
          // Without STAT, deallocating an unallocated array is an error.
      // Free the data.
      if !desc.base_addr.is_null() {
 -        unsafe { libc_free(desc.base_addr); }
 +        unsafe {
 +            libc_free(desc.base_addr);
 +        }
+     }
      // Clear the descriptor.
      desc.flags &= !DESC_ALLOCATED;
      // Leave rank, elem_size, dims intact (they describe the shape for future allocate).
 -    if !stat.is_null() { unsafe { *stat = 0; } }
 +    if !stat.is_null() {
 +        unsafe {
 +            *stat = 0;
 +        }
 +    }
+ }
  // ---- ALLOCATABLE ASSIGNMENT ----
      dest: *mut ArrayDescriptor,
      source: *const ArrayDescriptor,
  ) {
 -    if dest.is_null() || source.is_null() { return; }
 +    if dest.is_null() || source.is_null() {
 +        return;
 +    }
      let dest = unsafe { &mut *dest };
      let source = unsafe { &*source };
      // Check if shapes match.
      let shapes_match = dest.rank == source.rank && {
 -        (0..dest.rank as usize).all(|i| {
 -            dest.dims[i].extent() == source.dims[i].extent()
 -        })
 +        (0..dest.rank as usize).all(|i| dest.dims[i].extent() == source.dims[i].extent())
      };
      if !shapes_match || !dest.is_allocated() {
          // Deallocate dest if allocated.
          if dest.is_allocated() && !dest.base_addr.is_null() {
 -            unsafe { libc_free(dest.base_addr); }
 +            unsafe {
 +                libc_free(dest.base_addr);
 +            }
              dest.base_addr = ptr::null_mut();
              dest.flags &= !DESC_ALLOCATED;
+         }
  /// `to` is deallocated if allocated, then receives `from`'s descriptor.
  /// `from` is cleared (becomes unallocated).
  #[no_mangle]
 -pub extern "C" fn afs_move_alloc(
 -    from: *mut ArrayDescriptor,
 -    to: *mut ArrayDescriptor,
 -) {
 -    if from.is_null() || to.is_null() { return; }
 +pub extern "C" fn afs_move_alloc(from: *mut ArrayDescriptor, to: *mut ArrayDescriptor) {
 +    if from.is_null() || to.is_null() {
 +        return;
 +    }
      let from_desc = unsafe { &mut *from };
      let to_desc = unsafe { &mut *to };
      // Deallocate `to` if allocated.
      if to_desc.is_allocated() && !to_desc.base_addr.is_null() {
 -        unsafe { libc_free(to_desc.base_addr); }
 +        unsafe {
 +            libc_free(to_desc.base_addr);
 +        }
+     }
      // Copy descriptor from `from` to `to`.
  /// Check if an array is allocated. Returns 1 (true) or 0 (false).
  #[no_mangle]
  pub extern "C" fn afs_allocated(desc: *const ArrayDescriptor) -> i32 {
 -    if desc.is_null() { return 0; }
 +    if desc.is_null() {
 +        return 0;
 +    }
      unsafe { (*desc).is_allocated() as i32 }
+ }
      specs: *const SectionSpec,
      n_dims: i32,
  ) {
 -    if source.is_null() || result.is_null() || specs.is_null() { return; }
 +    if source.is_null() || result.is_null() || specs.is_null() {
 +        return;
 +    }
      let source = unsafe { &*source };
      let result = unsafe { &mut *result };
      result.elem_size = source.elem_size;
      result.rank = n_dims;
      result.flags = DESC_CONTIGUOUS; // sections may not be contiguous
 -    // Don't set DESC_ALLOCATED — section doesn't own the data.
 +                                    // Don't set DESC_ALLOCATED — section doesn't own the data.
      // Compute base address offset and new dims.
      let mut byte_offset: i64 = 0;
          let extent = if spec.stride == 0 {
          } else if (spec.stride > 0 && spec.start > spec.end)
 -            || (spec.stride < 0 && spec.start < spec.end) {
 +            || (spec.stride < 0 && spec.start < spec.end)
 +        {
 // empty section
          } else {
              (spec.end - spec.start) / spec.stride + 1
      fn allocate_2d() {
          let mut desc = ArrayDescriptor::zeroed();
          let dims = [
 -            DimDescriptor { lower_bound: 1, upper_bound: 3, stride: 1 },
 -            DimDescriptor { lower_bound: 1, upper_bound: 4, stride: 1 },
 +            DimDescriptor {
 +                lower_bound: 1,
 +                upper_bound: 3,
 +                stride: 1,
 +            },
 +            DimDescriptor {
 +                lower_bound: 1,
 +                upper_bound: 4,
 +                stride: 1,
 +            },
          ];
          afs_allocate_array(&mut desc, 8, 2, dims.as_ptr(), ptr::null_mut());
          assert!(desc.is_allocated());
          let mut stat: i32 = -1;
          afs_allocate_1d(&mut desc, 4, 10);
          // Allocating again should fail with stat.
 -        let dim = DimDescriptor { lower_bound: 1, upper_bound: 10, stride: 1 };
 +        let dim = DimDescriptor {
 +            lower_bound: 1,
 +            upper_bound: 10,
 +            stride: 1,
 +        };
          afs_allocate_array(&mut desc, 4, 1, &dim, &mut stat);
          assert_eq!(stat, 2); // already allocated
          afs_deallocate_array(&mut desc, ptr::null_mut());
          let lhs = [1_i32, 2, 3, 4, 5, 6, 7, 8];
          let rhs = [10_i32, 20, 30, 40, 50, 60, 70, 80];
          let mut out = [0_i32; 8];
 -        afs_array_add_i32(out.as_mut_ptr(), lhs.as_ptr(), rhs.as_ptr(), out.len() as i64);
 +        afs_array_add_i32(
 +            out.as_mut_ptr(),
 +            lhs.as_ptr(),
 +            rhs.as_ptr(),
 +            out.len() as i64,
 +        );
          assert_eq!(out, [11, 22, 33, 44, 55, 66, 77, 88]);
+     }
          let lhs = [1.5_f64, 2.5, 3.5, 4.5];
          let rhs = [10.0_f64, 20.0, 30.0, 40.0];
          let mut out = [0.0_f64; 4];
 -        afs_array_add_f64(out.as_mut_ptr(), lhs.as_ptr(), rhs.as_ptr(), out.len() as i64);
 +        afs_array_add_f64(
 +            out.as_mut_ptr(),
 +            lhs.as_ptr(),
 +            rhs.as_ptr(),
 +            out.len() as i64,
 +        );
          assert_eq!(out, [11.5, 22.5, 33.5, 44.5]);
+     }
          let lhs = [11_i32, 22, 33, 44, 55, 66, 77, 88];
          let rhs = [1_i32, 2, 3, 4, 5, 6, 7, 8];
          let mut out = [0_i32; 8];
 -        afs_array_sub_i32(out.as_mut_ptr(), lhs.as_ptr(), rhs.as_ptr(), out.len() as i64);
 +        afs_array_sub_i32(
 +            out.as_mut_ptr(),
 +            lhs.as_ptr(),
 +            rhs.as_ptr(),
 +            out.len() as i64,
 +        );
          assert_eq!(out, [10, 20, 30, 40, 50, 60, 70, 80]);
+     }
          let lhs = [1.0_f32, 2.0, 3.0, 4.0];
          let rhs = [2.0_f32, 3.0, 4.0, 5.0];
          let mut out = [0.0_f32; 4];
 -        afs_array_mul_f32(out.as_mut_ptr(), lhs.as_ptr(), rhs.as_ptr(), out.len() as i64);
 +        afs_array_mul_f32(
 +            out.as_mut_ptr(),
 +            lhs.as_ptr(),
 +            rhs.as_ptr(),
 +            out.len() as i64,
 +        );
          assert_eq!(out, [2.0, 6.0, 12.0, 20.0]);
+     }
  /// SIZE(array) — total number of elements.
  #[no_mangle]
  pub extern "C" fn afs_array_size(desc: *const ArrayDescriptor) -> i64 {
 -    if desc.is_null() { return 0; }
 +    if desc.is_null() {
 +        return 0;
 +    }
      unsafe { (*desc).total_elements() }
+ }
  /// SIZE(array, dim) — number of elements along dimension `dim` (1-based).
  #[no_mangle]
  pub extern "C" fn afs_array_size_dim(desc: *const ArrayDescriptor, dim: i32) -> i64 {
 -    if desc.is_null() || dim < 1 { return 0; }
 +    if desc.is_null() || dim < 1 {
 +        return 0;
 +    }
      let d = unsafe { &*desc };
      let idx = (dim - 1) as usize;
      if idx < d.rank as usize {
          d.dims[idx].extent()
 -    } else { 0 }
 +    } else {
 +        0
 +    }
+ }
  /// LBOUND(array, dim) — lower bound along dimension `dim` (1-based).
  #[no_mangle]
  pub extern "C" fn afs_array_lbound(desc: *const ArrayDescriptor, dim: i32) -> i64 {
 -    if desc.is_null() || dim < 1 { return 1; }
 +    if desc.is_null() || dim < 1 {
 +        return 1;
 +    }
      let d = unsafe { &*desc };
      let idx = (dim - 1) as usize;
 -    if idx < d.rank as usize { d.dims[idx].lower_bound } else { 1 }
 +    if idx < d.rank as usize {
 +        d.dims[idx].lower_bound
 +    } else {
 +        1
 +    }
+ }
  /// UBOUND(array, dim) — upper bound along dimension `dim` (1-based).
  #[no_mangle]
  pub extern "C" fn afs_array_ubound(desc: *const ArrayDescriptor, dim: i32) -> i64 {
 -    if desc.is_null() || dim < 1 { return 0; }
 +    if desc.is_null() || dim < 1 {
 +        return 0;
 +    }
      let d = unsafe { &*desc };
      let idx = (dim - 1) as usize;
 -    if idx < d.rank as usize { d.dims[idx].upper_bound } else { 0 }
 +    if idx < d.rank as usize {
 +        d.dims[idx].upper_bound
 +    } else {
 +        0
 +    }
+ }
  /// ALLOCATED(array) — check if array is allocated (returns 1 or 0).
  #[no_mangle]
  pub extern "C" fn afs_array_allocated(desc: *const ArrayDescriptor) -> i32 {
 -    if desc.is_null() { return 0; }
 +    if desc.is_null() {
 +        return 0;
 +    }
      unsafe { (*desc).is_allocated() as i32 }
+ }
  /// Respects strides for non-contiguous sections.
  #[no_mangle]
  pub extern "C" fn afs_array_sum_real8(desc: *const ArrayDescriptor) -> f64 {
 -    if desc.is_null() { return 0.0; }
 +    if desc.is_null() {
 +        return 0.0;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return 0.0; }
 +    if d.base_addr.is_null() {
 +        return 0.0;
 +    }
      let n = d.total_elements() as usize;
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const f64;
  /// Respects strides for non-contiguous sections.
  #[no_mangle]
  pub extern "C" fn afs_array_sum_int(desc: *const ArrayDescriptor) -> i64 {
 -    if desc.is_null() { return 0; }
 +    if desc.is_null() {
 +        return 0;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return 0; }
 +    if d.base_addr.is_null() {
 +        return 0;
 +    }
      let n = d.total_elements() as usize;
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const i32;
  /// PRODUCT(array) — product of all elements (real(8) version).
  #[no_mangle]
  pub extern "C" fn afs_array_product_real8(desc: *const ArrayDescriptor) -> f64 {
 -    if desc.is_null() { return 1.0; }
 +    if desc.is_null() {
 +        return 1.0;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return 1.0; }
 +    if d.base_addr.is_null() {
 +        return 1.0;
 +    }
      let n = d.total_elements() as usize;
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const f64;
  /// PRODUCT(array) — product of all elements (integer(4) version).
  #[no_mangle]
  pub extern "C" fn afs_array_product_int(desc: *const ArrayDescriptor) -> i64 {
 -    if desc.is_null() { return 1; }
 +    if desc.is_null() {
 +        return 1;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return 1; }
 +    if d.base_addr.is_null() {
 +        return 1;
 +    }
      let n = d.total_elements() as usize;
 -    if n == 0 { return 1; }
 +    if n == 0 {
 +        return 1;
 +    }
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const i32;
      let mut prod: i64 = 1;
  /// MAXVAL(array) — maximum element (real(8) version). Respects strides.
  #[no_mangle]
  pub extern "C" fn afs_array_maxval_real8(desc: *const ArrayDescriptor) -> f64 {
 -    if desc.is_null() { return f64::NEG_INFINITY; }
 +    if desc.is_null() {
 +        return f64::NEG_INFINITY;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return f64::NEG_INFINITY; }
 +    if d.base_addr.is_null() {
 +        return f64::NEG_INFINITY;
 +    }
      let n = d.total_elements() as usize;
 -    if n == 0 { return f64::NEG_INFINITY; }
 +    if n == 0 {
 +        return f64::NEG_INFINITY;
 +    }
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const f64;
      let mut max = unsafe { *ptr };
      for i in 1..n {
          let v = unsafe { *ptr.add(i * stride) };
 -        if v > max { max = v; }
 +        if v > max {
 +            max = v;
 +        }
+     }
      max
+ }
  /// MINVAL(array) — minimum element (real(8) version). Respects strides.
  #[no_mangle]
  pub extern "C" fn afs_array_minval_real8(desc: *const ArrayDescriptor) -> f64 {
 -    if desc.is_null() { return f64::INFINITY; }
 +    if desc.is_null() {
 +        return f64::INFINITY;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return f64::INFINITY; }
 +    if d.base_addr.is_null() {
 +        return f64::INFINITY;
 +    }
      let n = d.total_elements() as usize;
 -    if n == 0 { return f64::INFINITY; }
 +    if n == 0 {
 +        return f64::INFINITY;
 +    }
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const f64;
      let mut min = unsafe { *ptr };
      for i in 1..n {
          let v = unsafe { *ptr.add(i * stride) };
 -        if v < min { min = v; }
 +        if v < min {
 +            min = v;
 +        }
+     }
      min
+ }
  /// MAXVAL(array) — maximum element (integer(4) version). Respects strides.
  #[no_mangle]
  pub extern "C" fn afs_array_maxval_int(desc: *const ArrayDescriptor) -> i32 {
 -    if desc.is_null() { return i32::MIN; }
 +    if desc.is_null() {
 +        return i32::MIN;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return i32::MIN; }
 +    if d.base_addr.is_null() {
 +        return i32::MIN;
 +    }
      let n = d.total_elements() as usize;
 -    if n == 0 { return i32::MIN; }
 +    if n == 0 {
 +        return i32::MIN;
 +    }
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const i32;
      let mut max = unsafe { *ptr };
      for i in 1..n {
          let v = unsafe { *ptr.add(i * stride) };
 -        if v > max { max = v; }
 +        if v > max {
 +            max = v;
 +        }
+     }
      max
+ }
  /// MINVAL(array) — minimum element (integer(4) version). Respects strides.
  #[no_mangle]
  pub extern "C" fn afs_array_minval_int(desc: *const ArrayDescriptor) -> i32 {
 -    if desc.is_null() { return i32::MAX; }
 +    if desc.is_null() {
 +        return i32::MAX;
 +    }
      let d = unsafe { &*desc };
 -    if d.base_addr.is_null() { return i32::MAX; }
 +    if d.base_addr.is_null() {
 +        return i32::MAX;
 +    }
      let n = d.total_elements() as usize;
 -    if n == 0 { return i32::MAX; }
 +    if n == 0 {
 +        return i32::MAX;
 +    }
      let stride = d.dims[0].stride.max(1) as usize;
      let ptr = d.base_addr as *const i32;
      let mut min = unsafe { *ptr };
      for i in 1..n {
          let v = unsafe { *ptr.add(i * stride) };
 -        if v < min { min = v; }
 +        if v < min {
 +            min = v;
 +        }
+     }
      min
+ }
      source: *const ArrayDescriptor,
      result: *mut ArrayDescriptor,
  ) {
 -    if source.is_null() || result.is_null() { return; }
 +    if source.is_null() || result.is_null() {
 +        return;
 +    }
      let src = unsafe { &*source };
 -    if src.rank < 2 || src.base_addr.is_null() { return; }
 +    if src.rank < 2 || src.base_addr.is_null() {
 +        return;
 +    }
      let m = src.dims[0].extent() as usize;
      let n = src.dims[1].extent() as usize;
      afs_allocate_1d(result, 8, (n * m) as i64);
      let res = unsafe { &mut *result };
      res.rank = 2;
 -    res.dims[0] = DimDescriptor { lower_bound: 1, upper_bound: n as i64, stride: 1 };
 -    res.dims[1] = DimDescriptor { lower_bound: 1, upper_bound: m as i64, stride: 1 };
 +    res.dims[0] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: n as i64,
 +        stride: 1,
 +    };
 +    res.dims[1] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: m as i64,
 +        stride: 1,
 +    };
      let rp = res.base_addr as *mut f64;
      for i in 0..m {
          for j in 0..n {
 -            unsafe { *rp.add(j * m + i) = *sp.add(i * n + j); }
 +            unsafe {
 +                *rp.add(j * m + i) = *sp.add(i * n + j);
 +            }
+         }
+     }
+ }
      b: *const ArrayDescriptor,
      result: *mut ArrayDescriptor,
  ) {
 -    if a.is_null() || b.is_null() || result.is_null() { return; }
 +    if a.is_null() || b.is_null() || result.is_null() {
 +        return;
 +    }
      let da = unsafe { &*a };
      let db = unsafe { &*b };
 -    if da.base_addr.is_null() || db.base_addr.is_null() { return; }
 +    if da.base_addr.is_null() || db.base_addr.is_null() {
 +        return;
 +    }
      let m = da.dims[0].extent() as usize;
 -    let k = if da.rank >= 2 { da.dims[1].extent() as usize } else { 1 };
 -    let n = if db.rank >= 2 { db.dims[1].extent() as usize } else { db.dims[0].extent() as usize };
 +    let k = if da.rank >= 2 {
 +        da.dims[1].extent() as usize
 +    } else {
 +        1
 +    };
 +    let n = if db.rank >= 2 {
 +        db.dims[1].extent() as usize
 +    } else {
 +        db.dims[0].extent() as usize
 +    };
      // For vector * matrix or matrix * vector, adjust dimensions.
      let ap = da.base_addr as *const f64;
      afs_allocate_1d(result, 8, (m * n) as i64);
      let res = unsafe { &mut *result };
      res.rank = 2;
 -    res.dims[0] = DimDescriptor { lower_bound: 1, upper_bound: m as i64, stride: 1 };
 -    res.dims[1] = DimDescriptor { lower_bound: 1, upper_bound: n as i64, stride: 1 };
 +    res.dims[0] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: m as i64,
 +        stride: 1,
 +    };
 +    res.dims[1] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: n as i64,
 +        stride: 1,
 +    };
      let rp = res.base_addr as *mut f64;
      // Triple loop: C(i,j) = sum_l A(i,l) * B(l,j)
                  let b_val = unsafe { *bp.add(l * n + j) };
                  sum += a_val * b_val;
+             }
 -            unsafe { *rp.add(i * n + j) = sum; }
 +            unsafe {
 +                *rp.add(i * n + j) = sum;
 +            }
+         }
+     }
+ }
      b: *const ArrayDescriptor,
      result: *mut ArrayDescriptor,
  ) {
 -    if a.is_null() || b.is_null() || result.is_null() { return; }
 +    if a.is_null() || b.is_null() || result.is_null() {
 +        return;
 +    }
      let da = unsafe { &*a };
      let db = unsafe { &*b };
 -    if da.base_addr.is_null() || db.base_addr.is_null() { return; }
 +    if da.base_addr.is_null() || db.base_addr.is_null() {
 +        return;
 +    }
      let m = da.dims[0].extent() as usize;
 -    let k = if da.rank >= 2 { da.dims[1].extent() as usize } else { 1 };
 -    let n = if db.rank >= 2 { db.dims[1].extent() as usize } else { db.dims[0].extent() as usize };
 +    let k = if da.rank >= 2 {
 +        da.dims[1].extent() as usize
 +    } else {
 +        1
 +    };
 +    let n = if db.rank >= 2 {
 +        db.dims[1].extent() as usize
 +    } else {
 +        db.dims[0].extent() as usize
 +    };
      let ap = da.base_addr as *const i32;
      let bp = db.base_addr as *const i32;
      afs_allocate_1d(result, 4, (m * n) as i64);
      let res = unsafe { &mut *result };
      res.rank = 2;
 -    res.dims[0] = DimDescriptor { lower_bound: 1, upper_bound: m as i64, stride: 1 };
 -    res.dims[1] = DimDescriptor { lower_bound: 1, upper_bound: n as i64, stride: 1 };
 +    res.dims[0] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: m as i64,
 +        stride: 1,
 +    };
 +    res.dims[1] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: n as i64,
 +        stride: 1,
 +    };
      let rp = res.base_addr as *mut i32;
      for i in 0..m {
                  let b_val = unsafe { *bp.add(l * n + j) as i64 };
                  sum += a_val * b_val;
+             }
 -            unsafe { *rp.add(i * n + j) = sum as i32; }
 +            unsafe {
 +                *rp.add(i * n + j) = sum as i32;
 +            }
+         }
+     }
+ }
  /// TRANSPOSE(source, result) — matrix transpose (integer(4) version).
  #[no_mangle]
 -pub extern "C" fn afs_transpose_int(
 -    source: *const ArrayDescriptor,
 -    result: *mut ArrayDescriptor,
 -) {
 -    if source.is_null() || result.is_null() { return; }
 +pub extern "C" fn afs_transpose_int(source: *const ArrayDescriptor, result: *mut ArrayDescriptor) {
 +    if source.is_null() || result.is_null() {
 +        return;
 +    }
      let src = unsafe { &*source };
 -    if src.rank < 2 || src.base_addr.is_null() { return; }
 +    if src.rank < 2 || src.base_addr.is_null() {
 +        return;
 +    }
      let m = src.dims[0].extent() as usize;
      let n = src.dims[1].extent() as usize;
      afs_allocate_1d(result, 4, (n * m) as i64);
      let res = unsafe { &mut *result };
      res.rank = 2;
 -    res.dims[0] = DimDescriptor { lower_bound: 1, upper_bound: n as i64, stride: 1 };
 -    res.dims[1] = DimDescriptor { lower_bound: 1, upper_bound: m as i64, stride: 1 };
 +    res.dims[0] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: n as i64,
 +        stride: 1,
 +    };
 +    res.dims[1] = DimDescriptor {
 +        lower_bound: 1,
 +        upper_bound: m as i64,
 +        stride: 1,
 +    };
      let rp = res.base_addr as *mut i32;
      for i in 0..m {
          for j in 0..n {
 -            unsafe { *rp.add(j * m + i) = *sp.add(i * n + j); }
 +            unsafe {
 +                *rp.add(j * m + i) = *sp.add(i * n + j);
 +            }
+         }
+     }
+ }
      a: *const ArrayDescriptor,
      b: *const ArrayDescriptor,
  ) -> f64 {
 -    if a.is_null() || b.is_null() { return 0.0; }
 +    if a.is_null() || b.is_null() {
 +        return 0.0;
 +    }
      let da = unsafe { &*a };
      let db = unsafe { &*b };
 -    if da.base_addr.is_null() || db.base_addr.is_null() { return 0.0; }
 +    if da.base_addr.is_null() || db.base_addr.is_null() {
 +        return 0.0;
 +    }
      let n = da.dims[0].extent().min(db.dims[0].extent()) as usize;
      let stride_a = da.dims[0].stride.max(1) as usize;
      let stride_b = db.dims[0].stride.max(1) as usize;
      a: *const ArrayDescriptor,
      b: *const ArrayDescriptor,
  ) -> f32 {
 -    if a.is_null() || b.is_null() { return 0.0; }
 +    if a.is_null() || b.is_null() {
 +        return 0.0;
 +    }
      let da = unsafe { &*a };
      let db = unsafe { &*b };
 -    if da.base_addr.is_null() || db.base_addr.is_null() { return 0.0; }
 +    if da.base_addr.is_null() || db.base_addr.is_null() {
 +        return 0.0;
 +    }
      let n = da.dims[0].extent().min(db.dims[0].extent()) as usize;
      let stride_a = da.dims[0].stride.max(1) as usize;
      let stride_b = db.dims[0].stride.max(1) as usize;
  /// DOT_PRODUCT(a, b) — vector dot product (integer(4) version).
  #[no_mangle]
 -pub extern "C" fn afs_dot_product_int(
 -    a: *const ArrayDescriptor,
 -    b: *const ArrayDescriptor,
 -) -> i64 {
 -    if a.is_null() || b.is_null() { return 0; }
 +pub extern "C" fn afs_dot_product_int(a: *const ArrayDescriptor, b: *const ArrayDescriptor) -> i64 {
 +    if a.is_null() || b.is_null() {
 +        return 0;
 +    }
      let da = unsafe { &*a };
      let db = unsafe { &*b };
 -    if da.base_addr.is_null() || db.base_addr.is_null() { return 0; }
 +    if da.base_addr.is_null() || db.base_addr.is_null() {
 +        return 0;
 +    }
      let n = da.dims[0].extent().min(db.dims[0].extent()) as usize;
      let stride_a = da.dims[0].stride.max(1) as usize;
      let stride_b = db.dims[0].stride.max(1) as usize;

runtime/src/descriptor.rsmodified

36 lines changed — click to load

      #[test]
      fn dim_extent() {
 -        let dim = DimDescriptor { lower_bound: 1, upper_bound: 10, stride: 1 };
 +        let dim = DimDescriptor {
 +            lower_bound: 1,
 +            upper_bound: 10,
 +            stride: 1,
 +        };
          assert_eq!(dim.extent(), 10);
 -        let dim2 = DimDescriptor { lower_bound: 1, upper_bound: 10, stride: 2 };
 +        let dim2 = DimDescriptor {
 +            lower_bound: 1,
 +            upper_bound: 10,
 +            stride: 2,
 +        };
          assert_eq!(dim2.extent(), 5);
 -        let dim3 = DimDescriptor { lower_bound: 5, upper_bound: 3, stride: 1 };
 +        let dim3 = DimDescriptor {
 +            lower_bound: 5,
 +            upper_bound: 3,
 +            stride: 1,
 +        };
          assert_eq!(dim3.extent(), 0); // empty
+     }
          let mut d = ArrayDescriptor::zeroed();
          d.elem_size = 8; // f64
          d.set_bounds(&[(1, 3), (1, 4)]); // 3x4 matrix
 -        // Column-major: a(1,1)=0, a(2,1)=8, a(3,1)=16, a(1,2)=24
 +                                         // Column-major: a(1,1)=0, a(2,1)=8, a(3,1)=16, a(1,2)=24
          assert_eq!(d.element_offset(&[1, 1]), 0);
          assert_eq!(d.element_offset(&[2, 1]), 8);
          assert_eq!(d.element_offset(&[3, 1]), 16);

runtime/src/format.rsmodified

888 lines changed — click to load

  //! Fortran standard set including repeat counts, group repeat,
  //! unlimited repeat, scale factors, and all data/control descriptors.
+-
  /// A parsed format descriptor.
  #[derive(Debug, Clone)]
  pub enum FormatDesc {
      // ---- Data edit descriptors ----
      /// I: integer. Iw or Iw.m (w=width, m=minimum digits).
 -    IntegerI { width: usize, min_digits: Option<usize> },
 +    IntegerI {
 +        width: usize,
 +        min_digits: Option<usize>,
 +    },
      /// B: binary integer. Bw or Bw.m.
 -    IntegerB { width: usize, min_digits: Option<usize> },
 +    IntegerB {
 +        width: usize,
 +        min_digits: Option<usize>,
 +    },
      /// O: octal integer. Ow or Ow.m.
 -    IntegerO { width: usize, min_digits: Option<usize> },
 +    IntegerO {
 +        width: usize,
 +        min_digits: Option<usize>,
 +    },
      /// Z: hexadecimal integer. Zw or Zw.m.
 -    IntegerZ { width: usize, min_digits: Option<usize> },
 +    IntegerZ {
 +        width: usize,
 +        min_digits: Option<usize>,
 +    },
      /// F: fixed-point real. Fw.d.
      RealF { width: usize, decimals: usize },
      /// E: exponential real. Ew.d or Ew.dEe.
 -    RealE { width: usize, decimals: usize, exp_width: Option<usize> },
 +    RealE {
 +        width: usize,
 +        decimals: usize,
 +        exp_width: Option<usize>,
 +    },
      /// EN: engineering notation. ENw.d or ENw.dEe.
 -    RealEN { width: usize, decimals: usize, exp_width: Option<usize> },
 +    RealEN {
 +        width: usize,
 +        decimals: usize,
 +        exp_width: Option<usize>,
 +    },
      /// ES: scientific notation (1.0-9.999 mantissa). ESw.d or ESw.dEe.
 -    RealES { width: usize, decimals: usize, exp_width: Option<usize> },
 +    RealES {
 +        width: usize,
 +        decimals: usize,
 +        exp_width: Option<usize>,
 +    },
      /// EX: hexadecimal-significand real. EXw.d or EXw.dEe. (F2018)
 -    RealEX { width: usize, decimals: usize, exp_width: Option<usize> },
 +    RealEX {
 +        width: usize,
 +        decimals: usize,
 +        exp_width: Option<usize>,
 +    },
      /// D: double-precision exponential. Dw.d (same as Ew.d with D exponent letter).
      RealD { width: usize, decimals: usize },
      /// G: generalized real. Gw.d or Gw.dEe. Chooses F or E format automatically.
 -    RealG { width: usize, decimals: usize, exp_width: Option<usize> },
 +    RealG {
 +        width: usize,
 +        decimals: usize,
 +        exp_width: Option<usize>,
 +    },
      /// L: logical. Lw.
      Logical { width: usize },
      /// A: character. A or Aw.
      // ---- Grouping ----
      /// Repeated group: n(...).
 -    Group { repeat: usize, descriptors: Vec<FormatDesc> },
 +    Group {
 +        repeat: usize,
 +        descriptors: Vec<FormatDesc>,
 +    },
      /// Unlimited repeat: *(...).
      UnlimitedRepeat { descriptors: Vec<FormatDesc> },
+ }
  #[derive(Debug, Clone, Copy)]
  pub enum RoundMode {
 -    Up,          // RU
 -    Down,        // RD
 -    Zero,        // RZ
 -    Nearest,     // RN
 -    Compatible,  // RC
 +    Up,               // RU
 +    Down,             // RD
 +    Zero,             // RZ
 +    Nearest,          // RN
 +    Compatible,       // RC
      ProcessorDefined, // RP
+ }
  #[derive(Debug, Clone, Copy)]
  pub enum DecimalSep {
 -    Comma,  // DC
 -    Point,  // DP
 +    Comma, // DC
 +    Point, // DP
+ }
  /// Parse a Fortran format string (the part inside parentheses) into descriptors.
      let trimmed = fmt.trim();
      // Strip outer parens if present.
      let inner = if trimmed.starts_with('(') && trimmed.ends_with(')') {
 -        &trimmed[1..trimmed.len()-1]
 +        &trimmed[1..trimmed.len() - 1]
      } else {
          trimmed
      };
      while chars.peek().is_some() {
          skip_spaces(&mut chars);
 -        if chars.peek().is_none() { break; }
 +        if chars.peek().is_none() {
 +            break;
 +        }
          // Check for comma separator.
          if chars.peek() == Some(&',') {
          let repeat = parse_number(&mut chars);
          skip_spaces(&mut chars);
 -        if chars.peek().is_none() { break; }
 +        if chars.peek().is_none() {
 +            break;
 +        }
          let c = chars.peek().copied().unwrap_or(' ');
                      // *(...) unlimited repeat — not representable with 0.
                      result.push(FormatDesc::UnlimitedRepeat { descriptors });
                  } else {
 -                    result.push(FormatDesc::Group { repeat: n, descriptors });
 +                    result.push(FormatDesc::Group {
 +                        repeat: n,
 +                        descriptors,
 +                    });
+                 }
+             }
                  let desc = parse_edit_descriptor(&mut chars, repeat, negative);
                  if let Some(d) = desc {
                      if let Some(n) = repeat {
 -                        if n > 1 && !matches!(d, FormatDesc::Skip { .. } | FormatDesc::ScaleFactor(_)) {
 +                        if n > 1
 +                            && !matches!(d, FormatDesc::Skip { .. } | FormatDesc::ScaleFactor(_))
 +                        {
                              // Repeat count on a data descriptor: wrap in a group.
 -                            result.push(FormatDesc::Group { repeat: n, descriptors: vec![d] });
 +                            result.push(FormatDesc::Group {
 +                                repeat: n,
 +                                descriptors: vec![d],
 +                            });
                          } else {
                              result.push(d);
+                         }
      match letter {
          'I' => {
              let w = parse_number(chars).unwrap_or(0);
 -            let m = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars) } else { None };
 -            Some(FormatDesc::IntegerI { width: w, min_digits: m })
 +            let m = if chars.peek() == Some(&'.') {
 +                chars.next();
 +                parse_number(chars)
 +            } else {
 +                None
 +            };
 +            Some(FormatDesc::IntegerI {
 +                width: w,
 +                min_digits: m,
 +            })
+         }
 -        'B' if chars.peek().map(|c| c.is_ascii_digit() || *c == '\'').unwrap_or(false) => {
 +        'B' if chars
 +            .peek()
 +            .map(|c| c.is_ascii_digit() || *c == '\'')
 +            .unwrap_or(false) =>
 +        {
              // B followed by digit → binary integer format.
              // B followed by quote → BOZ literal (not handled here).
              let w = parse_number(chars).unwrap_or(0);
 -            let m = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars) } else { None };
 -            Some(FormatDesc::IntegerB { width: w, min_digits: m })
 +            let m = if chars.peek() == Some(&'.') {
 +                chars.next();
 +                parse_number(chars)
 +            } else {
 +                None
 +            };
 +            Some(FormatDesc::IntegerB {
 +                width: w,
 +                min_digits: m,
 +            })
+         }
          'O' => {
              let w = parse_number(chars).unwrap_or(0);
 -            let m = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars) } else { None };
 -            Some(FormatDesc::IntegerO { width: w, min_digits: m })
 +            let m = if chars.peek() == Some(&'.') {
 +                chars.next();
 +                parse_number(chars)
 +            } else {
 +                None
 +            };
 +            Some(FormatDesc::IntegerO {
 +                width: w,
 +                min_digits: m,
 +            })
+         }
          'Z' => {
              let w = parse_number(chars).unwrap_or(0);
 -            let m = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars) } else { None };
 -            Some(FormatDesc::IntegerZ { width: w, min_digits: m })
 +            let m = if chars.peek() == Some(&'.') {
 +                chars.next();
 +                parse_number(chars)
 +            } else {
 +                None
 +            };
 +            Some(FormatDesc::IntegerZ {
 +                width: w,
 +                min_digits: m,
 +            })
+         }
          'F' => {
              let w = parse_number(chars).unwrap_or(0);
 -            let d = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars).unwrap_or(0) } else { 0 };
 -            Some(FormatDesc::RealF { width: w, decimals: d })
 +            let d = if chars.peek() == Some(&'.') {
 +                chars.next();
 +                parse_number(chars).unwrap_or(0)
 +            } else {
 +                0
 +            };
 +            Some(FormatDesc::RealF {
 +                width: w,
 +                decimals: d,
 +            })
+         }
          'E' => {
              // Check for EN, ES, EX.
              let next = chars.peek().copied().unwrap_or(' ').to_ascii_uppercase();
              match next {
 -                'N' => { chars.next(); parse_real_desc(chars, |w, d, e| FormatDesc::RealEN { width: w, decimals: d, exp_width: e }) }
 -                'S' => { chars.next(); parse_real_desc(chars, |w, d, e| FormatDesc::RealES { width: w, decimals: d, exp_width: e }) }
 -                'X' => { chars.next(); parse_real_desc(chars, |w, d, e| FormatDesc::RealEX { width: w, decimals: d, exp_width: e }) }
 -                _ => parse_real_desc(chars, |w, d, e| FormatDesc::RealE { width: w, decimals: d, exp_width: e }),
 +                'N' => {
 +                    chars.next();
 +                    parse_real_desc(chars, |w, d, e| FormatDesc::RealEN {
 +                        width: w,
 +                        decimals: d,
 +                        exp_width: e,
 +                    })
 +                }
 +                'S' => {
 +                    chars.next();
 +                    parse_real_desc(chars, |w, d, e| FormatDesc::RealES {
 +                        width: w,
 +                        decimals: d,
 +                        exp_width: e,
 +                    })
 +                }
 +                'X' => {
 +                    chars.next();
 +                    parse_real_desc(chars, |w, d, e| FormatDesc::RealEX {
 +                        width: w,
 +                        decimals: d,
 +                        exp_width: e,
 +                    })
 +                }
 +                _ => parse_real_desc(chars, |w, d, e| FormatDesc::RealE {
 +                    width: w,
 +                    decimals: d,
 +                    exp_width: e,
 +                }),
+             }
+         }
          'D' => {
              // DC/DP (decimal mode) vs DT (derived type) vs Dw.d (real format).
              let next = chars.peek().copied().unwrap_or(' ').to_ascii_uppercase();
              match next {
 -                'C' => { chars.next(); Some(FormatDesc::DecimalMode(DecimalSep::Comma)) }
 -                'P' => { chars.next(); Some(FormatDesc::DecimalMode(DecimalSep::Point)) }
 +                'C' => {
 +                    chars.next();
 +                    Some(FormatDesc::DecimalMode(DecimalSep::Comma))
 +                }
 +                'P' => {
 +                    chars.next();
 +                    Some(FormatDesc::DecimalMode(DecimalSep::Point))
 +                }
                  'T' => {
                      chars.next();
                      // DT optionally followed by 'typename'.
+                 }
                  _ => {
                      let w = parse_number(chars).unwrap_or(0);
 -                    let d = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars).unwrap_or(0) } else { 0 };
 -                    Some(FormatDesc::RealD { width: w, decimals: d })
 +                    let d = if chars.peek() == Some(&'.') {
 +                        chars.next();
 +                        parse_number(chars).unwrap_or(0)
 +                    } else {
 +                        0
 +                    };
 +                    Some(FormatDesc::RealD {
 +                        width: w,
 +                        decimals: d,
 +                    })
+                 }
+             }
+         }
 -        'G' => {
 -            parse_real_desc(chars, |w, d, e| FormatDesc::RealG { width: w, decimals: d, exp_width: e })
 -        }
 +        'G' => parse_real_desc(chars, |w, d, e| FormatDesc::RealG {
 +            width: w,
 +            decimals: d,
 +            exp_width: e,
 +        }),
          'L' => {
              let w = parse_number(chars).unwrap_or(1);
              Some(FormatDesc::Logical { width: w })
              let w = parse_number(chars);
              Some(FormatDesc::Character { width: w })
+         }
 -        'X' => {
 -            Some(FormatDesc::Skip { count: repeat.unwrap_or(1) })
 -        }
 +        'X' => Some(FormatDesc::Skip {
 +            count: repeat.unwrap_or(1),
 +        }),
          'T' => {
              let next = chars.peek().copied().unwrap_or(' ').to_ascii_uppercase();
              match next {
 -                'L' => { chars.next(); let n = parse_number(chars).unwrap_or(1); Some(FormatDesc::TabLeft { count: n }) }
 -                'R' => { chars.next(); let n = parse_number(chars).unwrap_or(1); Some(FormatDesc::TabRight { count: n }) }
 -                _ => { let n = parse_number(chars).unwrap_or(1); Some(FormatDesc::TabTo { position: n }) }
 +                'L' => {
 +                    chars.next();
 +                    let n = parse_number(chars).unwrap_or(1);
 +                    Some(FormatDesc::TabLeft { count: n })
 +                }
 +                'R' => {
 +                    chars.next();
 +                    let n = parse_number(chars).unwrap_or(1);
 +                    Some(FormatDesc::TabRight { count: n })
 +                }
 +                _ => {
 +                    let n = parse_number(chars).unwrap_or(1);
 +                    Some(FormatDesc::TabTo { position: n })
 +                }
+             }
+         }
          'S' => {
              let next = chars.peek().copied().unwrap_or(' ').to_ascii_uppercase();
              match next {
 -                'P' => { chars.next(); Some(FormatDesc::Sign(SignMode::Plus)) }
 -                'S' => { chars.next(); Some(FormatDesc::Sign(SignMode::Suppress)) }
 +                'P' => {
 +                    chars.next();
 +                    Some(FormatDesc::Sign(SignMode::Plus))
 +                }
 +                'S' => {
 +                    chars.next();
 +                    Some(FormatDesc::Sign(SignMode::Suppress))
 +                }
                  _ => Some(FormatDesc::Sign(SignMode::Default)),
+             }
+         }
              // Rounding modes: RU, RD, RZ, RN, RC, RP.
              let next = chars.peek().copied().unwrap_or(' ').to_ascii_uppercase();
              let mode = match next {
 -                'U' => { chars.next(); Some(RoundMode::Up) }
 -                'D' => { chars.next(); Some(RoundMode::Down) }
 -                'Z' => { chars.next(); Some(RoundMode::Zero) }
 -                'N' => { chars.next(); Some(RoundMode::Nearest) }
 -                'C' => { chars.next(); Some(RoundMode::Compatible) }
 -                'P' => { chars.next(); Some(RoundMode::ProcessorDefined) }
 +                'U' => {
 +                    chars.next();
 +                    Some(RoundMode::Up)
 +                }
 +                'D' => {
 +                    chars.next();
 +                    Some(RoundMode::Down)
 +                }
 +                'Z' => {
 +                    chars.next();
 +                    Some(RoundMode::Zero)
 +                }
 +                'N' => {
 +                    chars.next();
 +                    Some(RoundMode::Nearest)
 +                }
 +                'C' => {
 +                    chars.next();
 +                    Some(RoundMode::Compatible)
 +                }
 +                'P' => {
 +                    chars.next();
 +                    Some(RoundMode::ProcessorDefined)
 +                }
                  _ => None,
              };
              mode.map(FormatDesc::RoundingMode)
              // BN or BZ.
              let next = chars.peek().copied().unwrap_or(' ').to_ascii_uppercase();
              match next {
 -                'N' => { chars.next(); Some(FormatDesc::BlankMode(BlankInterpretation::Null)) }
 -                'Z' => { chars.next(); Some(FormatDesc::BlankMode(BlankInterpretation::Zero)) }
 +                'N' => {
 +                    chars.next();
 +                    Some(FormatDesc::BlankMode(BlankInterpretation::Null))
 +                }
 +                'Z' => {
 +                    chars.next();
 +                    Some(FormatDesc::BlankMode(BlankInterpretation::Zero))
 +                }
                  _ => None,
+             }
+         }
      constructor: impl Fn(usize, usize, Option<usize>) -> FormatDesc,
  ) -> Option<FormatDesc> {
      let w = parse_number(chars).unwrap_or(0);
 -    let d = if chars.peek() == Some(&'.') { chars.next(); parse_number(chars).unwrap_or(0) } else { 0 };
 -    let e = if chars.peek().map(|c| c.eq_ignore_ascii_case(&'E')).unwrap_or(false) {
 +    let d = if chars.peek() == Some(&'.') {
 +        chars.next();
 +        parse_number(chars).unwrap_or(0)
 +    } else {
 +        0
 +    };
 +    let e = if chars
 +        .peek()
 +        .map(|c| c.eq_ignore_ascii_case(&'E'))
 +        .unwrap_or(false)
 +    {
          chars.next();
          parse_number(chars)
 -    } else { None };
 +    } else {
 +        None
 +    };
      Some(constructor(w, d, e))
+ }
              match desc {
                  // ---- Control descriptors ----
                  FormatDesc::Skip { count } => {
 -                    for _ in 0..*count { output.push(' '); }
 +                    for _ in 0..*count {
 +                        output.push(' ');
 +                    }
 +                }
 +                FormatDesc::Newline => {
 +                    output.push('\n');
+                 }
 -                FormatDesc::Newline => { output.push('\n'); }
                  FormatDesc::Colon => {
 -                    if *val_idx >= values.len() { return; }
 +                    if *val_idx >= values.len() {
 +                        return;
 +                    }
 +                }
 +                FormatDesc::Sign(mode) => {
 +                    self.sign_mode = *mode;
 +                }
 +                FormatDesc::ScaleFactor(k) => {
 +                    self.scale_factor = *k;
+                 }
 -                FormatDesc::Sign(mode) => { self.sign_mode = *mode; }
 -                FormatDesc::ScaleFactor(k) => { self.scale_factor = *k; }
                  FormatDesc::BlankMode(_) => {} // input only
 -                FormatDesc::RoundingMode(mode) => { self.round_mode = *mode; }
 -                FormatDesc::DecimalMode(sep) => { self.decimal_sep = *sep; }
 +                FormatDesc::RoundingMode(mode) => {
 +                    self.round_mode = *mode;
 +                }
 +                FormatDesc::DecimalMode(sep) => {
 +                    self.decimal_sep = *sep;
 +                }
                  FormatDesc::DerivedType { .. } => {} // requires user-defined I/O — no-op for now
                  FormatDesc::TabTo { position } => {
                      let cur_col = output.lines().last().map(|l| l.len()).unwrap_or(0);
                      if *position > cur_col + 1 {
 -                        for _ in 0..(*position - cur_col - 1) { output.push(' '); }
 +                        for _ in 0..(*position - cur_col - 1) {
 +                            output.push(' ');
 +                        }
+                     }
+                 }
                  FormatDesc::TabLeft { count } => {
                      output.truncate(new_len);
+                 }
                  FormatDesc::TabRight { count } => {
 -                    for _ in 0..*count { output.push(' '); }
 +                    for _ in 0..*count {
 +                        output.push(' ');
 +                    }
 +                }
 +                FormatDesc::LiteralString(s) => {
 +                    output.push_str(s);
+                 }
 -                FormatDesc::LiteralString(s) => { output.push_str(s); }
                  // ---- Group repeat ----
 -                FormatDesc::Group { repeat, descriptors } => {
 +                FormatDesc::Group {
 +                    repeat,
 +                    descriptors,
 +                } => {
                      for _ in 0..*repeat {
                          self.apply_descriptors(descriptors, values, val_idx, output);
+                     }
                  // ---- Data descriptors ----
                  _ => {
 -                    if *val_idx >= values.len() { return; }
 +                    if *val_idx >= values.len() {
 +                        return;
 +                    }
                      let val = &values[*val_idx];
                      *val_idx += 1;
                      let formatted = self.format_value(desc, val);
                  let s = if let Some(m) = min_digits {
                      let abs_s = format!("{}", v.unsigned_abs());
                      let padded = format!("{:0>width$}", abs_s, width = *m);
 -                    if *v < 0 { format!("-{}", padded) } else { self.apply_sign(&padded, *v >= 0) }
 +                    if *v < 0 {
 +                        format!("-{}", padded)
 +                    } else {
 +                        self.apply_sign(&padded, *v >= 0)
 +                    }
                  } else {
                      self.apply_sign(&format!("{}", v.unsigned_abs()), *v >= 0)
                  };
                  let s = self.format_fixed(rounded, *decimals);
                  self.apply_decimal_sep(&format!("{:>width$}", s, width = *width))
+             }
 -            (FormatDesc::RealE { width, decimals, exp_width }, IoValue::Real(v)) => {
 +            (
 +                FormatDesc::RealE {
 +                    width,
 +                    decimals,
 +                    exp_width,
 +                },
 +                IoValue::Real(v),
 +            ) => {
                  let s = self.format_e_style(*v, *decimals, *exp_width, 'E');
                  self.apply_decimal_sep(&format!("{:>width$}", s, width = *width))
+             }
 -            (FormatDesc::RealES { width, decimals, exp_width }, IoValue::Real(v)) => {
 +            (
 +                FormatDesc::RealES {
 +                    width,
 +                    decimals,
 +                    exp_width,
 +                },
 +                IoValue::Real(v),
 +            ) => {
                  // Scientific: mantissa in [1.0, 10.0). Equivalent to 1P,E.
                  let s = self.format_es_style(*v, *decimals, *exp_width);
                  self.apply_decimal_sep(&format!("{:>width$}", s, width = *width))
+             }
 -            (FormatDesc::RealEN { width, decimals, .. }, IoValue::Real(v)) => {
 +            (
 +                FormatDesc::RealEN {
 +                    width, decimals, ..
 +                },
 +                IoValue::Real(v),
 +            ) => {
                  // Engineering: exponent is multiple of 3.
                  let (mantissa, exp) = to_engineering(*v);
                  let rounded = self.apply_rounding(mantissa, *decimals);
                  let s = self.format_e_style(*v, *decimals, None, 'D');
                  self.apply_decimal_sep(&format!("{:>width$}", s, width = *width))
+             }
 -            (FormatDesc::RealG { width, decimals, exp_width }, IoValue::Real(v)) => {
 +            (
 +                FormatDesc::RealG {
 +                    width,
 +                    decimals,
 +                    exp_width,
 +                },
 +                IoValue::Real(v),
 +            ) => {
                  // G format: use F if magnitude fits, else E.
                  let abs_v = v.abs();
                  if abs_v == 0.0 || (abs_v >= 0.1 && abs_v < 10f64.powi(*decimals as i32)) {
                      self.apply_decimal_sep(&format!("{:>width$}", s, width = *width))
+                 }
+             }
 -            (FormatDesc::RealEX { width, decimals, .. }, IoValue::Real(v)) => {
 +            (
 +                FormatDesc::RealEX {
 +                    width, decimals, ..
 +                },
 +                IoValue::Real(v),
 +            ) => {
                  // Hex-significand: use %a-like format. Rust doesn't have this natively.
                  let s = format!("{:.*E}", *decimals, v); // fallback to E format
                  self.apply_decimal_sep(&format!("{:>width$}", s, width = *width))
      /// Fortran kP with E format: the mantissa is multiplied by 10^k,
      /// and the exponent is decreased by k. With 0P (default), the mantissa
      /// is in [0.1, 1.0) — Fortran's convention, not C's.
 -    fn format_e_style(&self, v: f64, decimals: usize, exp_width: Option<usize>, exp_char: char) -> String {
 +    fn format_e_style(
 +        &self,
 +        v: f64,
 +        decimals: usize,
 +        exp_width: Option<usize>,
 +        exp_char: char,
 +    ) -> String {
          if v == 0.0 {
              let ew = exp_width.unwrap_or(2);
 -            return format!("0.{:0>d$}{}{:+0ew$}", "", exp_char, 0, d = decimals, ew = ew + 1);
 +            return format!(
 +                "0.{:0>d$}{}{:+0ew$}",
 +                "",
 +                exp_char,
 +                0,
 +                d = decimals,
 +                ew = ew + 1
 +            );
+         }
          let abs_v = v.abs();
          let rounded = self.apply_rounding(mantissa, decimals);
          let ew = exp_width.unwrap_or(2);
 -        let sign = if v < 0.0 { "-" } else if matches!(self.sign_mode, SignMode::Plus) { "+" } else { "" };
 -        format!("{}{:.*}{}{:+0ew$}", sign, decimals, rounded, exp_char, fort_exp, ew = ew + 1)
 +        let sign = if v < 0.0 {
 +            "-"
 +        } else if matches!(self.sign_mode, SignMode::Plus) {
 +            "+"
 +        } else {
 +            ""
 +        };
 +        format!(
 +            "{}{:.*}{}{:+0ew$}",
 +            sign,
 +            decimals,
 +            rounded,
 +            exp_char,
 +            fort_exp,
 +            ew = ew + 1
 +        )
+     }
      /// Format in ES style (scientific): mantissa in [1.0, 10.0).
          let rounded = self.apply_rounding(mantissa, decimals);
          let ew = exp_width.unwrap_or(2);
 -        let sign = if v < 0.0 { "-" } else if matches!(self.sign_mode, SignMode::Plus) { "+" } else { "" };
 -        format!("{}{:.*}E{:+0ew$}", sign, decimals, rounded, base_exp, ew = ew + 1)
 +        let sign = if v < 0.0 {
 +            "-"
 +        } else if matches!(self.sign_mode, SignMode::Plus) {
 +            "+"
 +        } else {
 +            ""
 +        };
 +        format!(
 +            "{}{:.*}E{:+0ew$}",
 +            sign,
 +            decimals,
 +            rounded,
 +            base_exp,
 +            ew = ew + 1
 +        )
+     }
      /// Replace '.' with ',' when decimal mode is DC (comma).
  // ---- Helpers ----
  fn to_engineering(v: f64) -> (f64, i32) {
 -    if v == 0.0 { return (0.0, 0); }
 +    if v == 0.0 {
 +        return (0.0, 0);
 +    }
      let exp = (v.abs().log10().floor() as i32) / 3 * 3;
      let mantissa = v / 10f64.powi(exp);
      (mantissa, exp)
+ }
  fn skip_spaces(chars: &mut std::iter::Peekable<std::str::Chars>) {
 -    while chars.peek() == Some(&' ') { chars.next(); }
 +    while chars.peek() == Some(&' ') {
 +        chars.next();
 +    }
+ }
  fn parse_number(chars: &mut std::iter::Peekable<std::str::Chars>) -> Option<usize> {
              break;
+         }
+     }
 -    if digits.is_empty() { None } else { digits.parse().ok() }
 +    if digits.is_empty() {
 +        None
 +    } else {
 +        digits.parse().ok()
 +    }
+ }
  fn parse_string_literal(chars: &mut std::iter::Peekable<std::str::Chars>, quote: char) -> String {
      let mut inner = String::new();
      while let Some(&c) = chars.peek() {
          chars.next();
 -        if c == '(' { depth += 1; }
 +        if c == '(' {
 +            depth += 1;
 +        }
          if c == ')' {
              depth -= 1;
 -            if depth == 0 { break; }
 +            if depth == 0 {
 +                break;
 +            }
+         }
          inner.push(c);
+     }
      fn parse_simple_format() {
          let descs = parse_format("(I5, F10.3, A)");
          assert_eq!(descs.len(), 3);
 -        assert!(matches!(descs[0], FormatDesc::IntegerI { width: 5, min_digits: None }));
 -        assert!(matches!(descs[1], FormatDesc::RealF { width: 10, decimals: 3 }));
 +        assert!(matches!(
 +            descs[0],
 +            FormatDesc::IntegerI {
 +                width: 5,
 +                min_digits: None
 +            }
 +        ));
 +        assert!(matches!(
 +            descs[1],
 +            FormatDesc::RealF {
 +                width: 10,
 +                decimals: 3
 +            }
 +        ));
          assert!(matches!(descs[2], FormatDesc::Character { width: None }));
+     }
          assert_eq!(descs.len(), 2);
          if let FormatDesc::LiteralString(s) = &descs[0] {
              assert_eq!(s, "hello");
 -        } else { panic!("expected literal"); }
 +        } else {
 +            panic!("expected literal");
 +        }
+     }
      #[test]
      fn parse_es_en_format() {
          let descs = parse_format("(ES15.8, EN12.3)");
 -        assert!(matches!(descs[0], FormatDesc::RealES { width: 15, decimals: 8, .. }));
 -        assert!(matches!(descs[1], FormatDesc::RealEN { width: 12, decimals: 3, .. }));
 +        assert!(matches!(
 +            descs[0],
 +            FormatDesc::RealES {
 +                width: 15,
 +                decimals: 8,
 +                ..
 +            }
 +        ));
 +        assert!(matches!(
 +            descs[1],
 +            FormatDesc::RealEN {
 +                width: 12,
 +                decimals: 3,
 +                ..
 +            }
 +        ));
+     }
      #[test]
          let descs = parse_format("(*(I3, ','))");
          let mut engine = FormatEngine::new(descs);
          let out = engine.format_values(&[
 -            IoValue::Integer(1), IoValue::Integer(2), IoValue::Integer(3)
 +            IoValue::Integer(1),
 +            IoValue::Integer(2),
 +            IoValue::Integer(3),
          ]);
          assert_eq!(out, "  1,  2,  3,");
+     }
      fn parse_dc_dp_decimal_mode() {
          let descs = parse_format("(DC, F8.3, DP, F8.3)");
          assert_eq!(descs.len(), 4);
 -        assert!(matches!(descs[0], FormatDesc::DecimalMode(DecimalSep::Comma)));
 -        assert!(matches!(descs[2], FormatDesc::DecimalMode(DecimalSep::Point)));
 +        assert!(matches!(
 +            descs[0],
 +            FormatDesc::DecimalMode(DecimalSep::Comma)
 +        ));
 +        assert!(matches!(
 +            descs[2],
 +            FormatDesc::DecimalMode(DecimalSep::Point)
 +        ));
+     }
      #[test]
      fn parse_rounding_modes() {
          let descs = parse_format("(RU, F8.3, RD, F8.3, RZ, F8.3, RN, F8.3, RC, F8.3, RP, F8.3)");
          assert!(matches!(descs[0], FormatDesc::RoundingMode(RoundMode::Up)));
 -        assert!(matches!(descs[2], FormatDesc::RoundingMode(RoundMode::Down)));
 -        assert!(matches!(descs[4], FormatDesc::RoundingMode(RoundMode::Zero)));
 -        assert!(matches!(descs[6], FormatDesc::RoundingMode(RoundMode::Nearest)));
 -        assert!(matches!(descs[8], FormatDesc::RoundingMode(RoundMode::Compatible)));
 -        assert!(matches!(descs[10], FormatDesc::RoundingMode(RoundMode::ProcessorDefined)));
 +        assert!(matches!(
 +            descs[2],
 +            FormatDesc::RoundingMode(RoundMode::Down)
 +        ));
 +        assert!(matches!(
 +            descs[4],
 +            FormatDesc::RoundingMode(RoundMode::Zero)
 +        ));
 +        assert!(matches!(
 +            descs[6],
 +            FormatDesc::RoundingMode(RoundMode::Nearest)
 +        ));
 +        assert!(matches!(
 +            descs[8],
 +            FormatDesc::RoundingMode(RoundMode::Compatible)
 +        ));
 +        assert!(matches!(
 +            descs[10],
 +            FormatDesc::RoundingMode(RoundMode::ProcessorDefined)
 +        ));
+     }
      #[test]
      #[test]
      fn format_d_descriptor() {
          let descs = parse_format("(D12.5)");
 -        assert!(matches!(descs[0], FormatDesc::RealD { width: 12, decimals: 5 }));
 +        assert!(matches!(
 +            descs[0],
 +            FormatDesc::RealD {
 +                width: 12,
 +                decimals: 5
 +            }
 +        ));
+     }
      #[test]
      fn format_d_vs_dc() {
          // D12.5 is a real descriptor; DC is decimal comma mode.
          let descs = parse_format("(DC, D12.5)");
 -        assert!(matches!(descs[0], FormatDesc::DecimalMode(DecimalSep::Comma)));
 -        assert!(matches!(descs[1], FormatDesc::RealD { width: 12, decimals: 5 }));
 +        assert!(matches!(
 +            descs[0],
 +            FormatDesc::DecimalMode(DecimalSep::Comma)
 +        ));
 +        assert!(matches!(
 +            descs[1],
 +            FormatDesc::RealD {
 +                width: 12,
 +                decimals: 5
 +            }
 +        ));
+     }
      #[test]
      fn format_integer16_full_width() {
          let descs = parse_format("(I40)");
          let mut engine = FormatEngine::new(descs);
 -        let out = engine.format_values(&[IoValue::Integer(170141183460469231731687303715884105727i128)]);
 +        let out = engine.format_values(&[IoValue::Integer(
 +            170141183460469231731687303715884105727i128,
 +        )]);
          assert_eq!(out, " 170141183460469231731687303715884105727");
+     }
+ }

runtime/src/io_system.rsmodified

2387 lines changed — click to load

  use std::collections::HashMap;
  use std::fs::{File, OpenOptions};
 -use std::io::{self, Read, Write, BufRead, BufReader, BufWriter, Seek, SeekFrom};
 +use std::io::{self, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write};
  use std::sync::Mutex;
  // ---- Global I/O state ----
      Open,
+ }
+-
  #[derive(Debug, Clone, Copy, PartialEq)]
  enum Access {
      Sequential,
              UnitStream::FileRaw(f) => {
                  f.write_all(data)?;
+             }
 -            _ => return Err(io::Error::new(io::ErrorKind::PermissionDenied, "unit not open for writing")),
 +            _ => {
 +                return Err(io::Error::new(
 +                    io::ErrorKind::PermissionDenied,
 +                    "unit not open for writing",
 +                ))
 +            }
+         }
          Ok(())
+     }
+                     }
+                 }
+             }
 -            _ => return Err(io::Error::new(io::ErrorKind::PermissionDenied, "unit not open for reading")),
 +            _ => {
 +                return Err(io::Error::new(
 +                    io::ErrorKind::PermissionDenied,
 +                    "unit not open for reading",
 +                ))
 +            }
+         }
          Ok(line)
+     }
          let mut units = HashMap::new();
          // Preconnected units.
 -        units.insert(5, Unit {
 -            _number: 5,
 -            stream: UnitStream::Stdin,
 -            filename: "stdin".into(),
 -            _status: UnitStatus::Open,
 -            access: Access::Sequential,
 -            form: Form::Formatted,
 -            action: Action::Read,
 -            recl: None,
 -            read_tokens: Vec::new(),
 -            formatted_read_record: None,
 -        });
 -        units.insert(6, Unit {
 -            _number: 6,
 -            stream: UnitStream::Stdout,
 -            filename: "stdout".into(),
 -            _status: UnitStatus::Open,
 -            access: Access::Sequential,
 -            form: Form::Formatted,
 -            action: Action::Write,
 -            recl: None,
 -            read_tokens: Vec::new(),
 -            formatted_read_record: None,
 -        });
 -        units.insert(0, Unit {
 -            _number: 0,
 -            stream: UnitStream::Stderr,
 -            filename: "stderr".into(),
 -            _status: UnitStatus::Open,
 -            access: Access::Sequential,
 -            form: Form::Formatted,
 -            action: Action::Write,
 -            recl: None,
 -            read_tokens: Vec::new(),
 -            formatted_read_record: None,
 -        });
 +        units.insert(
 +            5,
 +            Unit {
 +                _number: 5,
 +                stream: UnitStream::Stdin,
 +                filename: "stdin".into(),
 +                _status: UnitStatus::Open,
 +                access: Access::Sequential,
 +                form: Form::Formatted,
 +                action: Action::Read,
 +                recl: None,
 +                read_tokens: Vec::new(),
 +                formatted_read_record: None,
 +            },
 +        );
 +        units.insert(
 +            6,
 +            Unit {
 +                _number: 6,
 +                stream: UnitStream::Stdout,
 +                filename: "stdout".into(),
 +                _status: UnitStatus::Open,
 +                access: Access::Sequential,
 +                form: Form::Formatted,
 +                action: Action::Write,
 +                recl: None,
 +                read_tokens: Vec::new(),
 +                formatted_read_record: None,
 +            },
 +        );
 +        units.insert(
 +            0,
 +            Unit {
 +                _number: 0,
 +                stream: UnitStream::Stderr,
 +                filename: "stderr".into(),
 +                _status: UnitStatus::Open,
 +                access: Access::Sequential,
 +                form: Form::Formatted,
 +                action: Action::Write,
 +                recl: None,
 +                read_tokens: Vec::new(),
 +                formatted_read_record: None,
 +            },
 +        );
 -        Self { units, next_newunit: -10 }
 +        Self {
 +            units,
 +            next_newunit: -10,
 +        }
+     }
      fn get_unit(&mut self, unit_num: i32) -> Option<&mut Unit> {
  #[no_mangle]
  pub extern "C" fn afs_open_simple(
      unit: i32,
 -    filename: *const u8, filename_len: i64,
 -    status: *const u8, status_len: i64,
 -    action: *const u8, action_len: i64,
 +    filename: *const u8,
 +    filename_len: i64,
 +    status: *const u8,
 +    status_len: i64,
 +    action: *const u8,
 +    action_len: i64,
  ) {
      let cb = OpenControlBlock {
 -        unit, filename, filename_len,
 -        status, status_len,
 -        action, action_len,
 -        access: std::ptr::null(), access_len: 0,
 -        form: std::ptr::null(), form_len: 0,
 +        unit,
 +        filename,
 +        filename_len,
 +        status,
 +        status_len,
 +        action,
 +        action_len,
 +        access: std::ptr::null(),
 +        access_len: 0,
 +        form: std::ptr::null(),
 +        form_len: 0,
          recl: 0,
          iostat: std::ptr::null_mut(),
          newunit: std::ptr::null_mut(),
 -        position: std::ptr::null(), position_len: 0,
 +        position: std::ptr::null(),
 +        position_len: 0,
      };
      afs_open(&cb);
+ }
  /// exceeding the 8-register ARM64 calling convention limit.
  #[no_mangle]
  pub extern "C" fn afs_open(cb: *const OpenControlBlock) {
 -    if cb.is_null() { return; }
 +    if cb.is_null() {
 +        return;
 +    }
      let cb = unsafe { &*cb };
      let unit = cb.unit;
      let fname = unsafe_str(cb.filename, cb.filename_len);
      // NEWUNIT: allocate a new unit number.
      let actual_unit = if !newunit.is_null() {
          let u = state.alloc_newunit();
 -        unsafe { *newunit = u; }
 +        unsafe {
 +            *newunit = u;
 +        }
+         u
      } else {
          unit
      // Build OpenOptions based on status/action.
      let mut opts = OpenOptions::new();
      match status_str.trim() {
 -        "old" => { opts.read(true); }
 -        "new" => { opts.write(true).create_new(true); }
 -        "replace" => { opts.write(true).create(true).truncate(true); }
 -        "scratch" | "unknown" | "" => { opts.read(true).write(true).create(true); }
 -        _ => { opts.read(true).write(true).create(true); }
 +        "old" => {
 +            opts.read(true);
 +        }
 +        "new" => {
 +            opts.write(true).create_new(true);
 +        }
 +        "replace" => {
 +            opts.write(true).create(true).truncate(true);
 +        }
 +        "scratch" | "unknown" | "" => {
 +            opts.read(true).write(true).create(true);
 +        }
 +        _ => {
 +            opts.read(true).write(true).create(true);
 +        }
+     }
      // Determine action. Default depends on status:
      };
      match effective_action {
 -        "read" => { opts.read(true); }
 -        "write" => { opts.write(true).create(true); }
 -        _ => { opts.read(true).write(true).create(true); }
 +        "read" => {
 +            opts.read(true);
 +        }
 +        "write" => {
 +            opts.write(true).create(true);
 +        }
 +        _ => {
 +            opts.read(true).write(true).create(true);
 +        }
+     }
      // Flush and close existing unit if re-opening.
                      Action::ReadWrite => UnitStream::FileRaw(file),
                  },
              };
 -            state.units.insert(actual_unit, Unit {
 -                _number: actual_unit,
 -                stream,
 -                filename: fname,
 -                _status: UnitStatus::Open,
 -                access: file_access,
 -                form: file_form,
 -                action: file_action,
 -                recl: if recl > 0 { Some(recl) } else { None },
 -                read_tokens: Vec::new(),
 -                formatted_read_record: None,
 -            });
 +            state.units.insert(
 +                actual_unit,
 +                Unit {
 +                    _number: actual_unit,
 +                    stream,
 +                    filename: fname,
 +                    _status: UnitStatus::Open,
 +                    access: file_access,
 +                    form: file_form,
 +                    action: file_action,
 +                    recl: if recl > 0 { Some(recl) } else { None },
 +                    read_tokens: Vec::new(),
 +                    formatted_read_record: None,
 +                },
 +            );
              // Apply POSITION specifier.
              // Default: REWIND for sequential, ASIS for direct/stream.
              if let Some(seek) = pos {
                  if let Some(u) = state.get_unit(actual_unit) {
                      match &mut u.stream {
 -                        UnitStream::FileRaw(f) => { let _ = f.seek(seek); }
 -                        UnitStream::FileRead(r) => { let _ = r.seek(seek); }
 -                        UnitStream::FileWrite(w) => { let _ = w.seek(seek); }
 +                        UnitStream::FileRaw(f) => {
 +                            let _ = f.seek(seek);
 +                        }
 +                        UnitStream::FileRead(r) => {
 +                            let _ = r.seek(seek);
 +                        }
 +                        UnitStream::FileWrite(w) => {
 +                            let _ = w.seek(seek);
 +                        }
                          _ => {}
+                     }
+                 }
+             }
 -            if !iostat.is_null() { unsafe { *iostat = 0; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 0;
 +                }
 +            }
+         }
          Err(e) => {
              if !iostat.is_null() {
 -                unsafe { *iostat = e.raw_os_error().unwrap_or(1); }
 +                unsafe {
 +                    *iostat = e.raw_os_error().unwrap_or(1);
 +                }
              } else {
                  eprintln!("OPEN: {}: {}", fname, e);
                  std::process::exit(1);
      if let Some(mut u) = state.units.remove(&unit) {
          let _ = u.flush();
          // File is dropped here, closing the handle.
 -        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        }
      } else {
 -        if !iostat.is_null() { unsafe { *iostat = 0; } } // closing unopen unit is not an error
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        } // closing unopen unit is not an error
+     }
+ }
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          match u.next_read_token() {
 -            Ok(Some(token)) => {
 -                match token.parse::<i32>() {
 -                    Ok(v) => {
 -                        if !val.is_null() { unsafe { *val = v; } }
 -                        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +            Ok(Some(token)) => match token.parse::<i32>() {
 +                Ok(v) => {
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
+                     }
 -                    Err(_) => {
 -                        if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                        else { eprintln!("READ: cannot parse integer from '{}'", token); std::process::exit(1); }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
+                     }
+                 }
 -            }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    } else {
 +                        eprintln!("READ: cannot parse integer from '{}'", token);
 +                        std::process::exit(1);
 +                    }
 +                }
 +            },
              Ok(None) => {
 -                if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 -                else { eprintln!("READ: end of file"); std::process::exit(1); }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = IOSTAT_END;
 +                    }
 +                } else {
 +                    eprintln!("READ: end of file");
 +                    std::process::exit(1);
 +                }
+             }
              Err(e) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                else { eprintln!("READ: {}", e); std::process::exit(1); }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                } else {
 +                    eprintln!("READ: {}", e);
 +                    std::process::exit(1);
 +                }
+             }
+         }
+     }
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          match u.next_read_token() {
 -            Ok(Some(token)) => {
 -                match token.parse::<i64>() {
 -                    Ok(v) => {
 -                        if !val.is_null() { unsafe { *val = v; } }
 -                        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +            Ok(Some(token)) => match token.parse::<i64>() {
 +                Ok(v) => {
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
+                     }
 -                    Err(_) => {
 -                        if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                        else { eprintln!("READ: cannot parse integer from '{}'", token); std::process::exit(1); }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
+                     }
+                 }
 -            }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    } else {
 +                        eprintln!("READ: cannot parse integer from '{}'", token);
 +                        std::process::exit(1);
 +                    }
 +                }
 +            },
              Ok(None) => {
 -                if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = IOSTAT_END;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
+     }
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          match u.next_read_token() {
 -            Ok(Some(token)) => {
 -                match token.parse::<i128>() {
 -                    Ok(v) => {
 -                        write_i128_ptr(val, v);
 -                        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +            Ok(Some(token)) => match token.parse::<i128>() {
 +                Ok(v) => {
 +                    write_i128_ptr(val, v);
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
+                     }
 -                    Err(_) => {
 -                        if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                        else { eprintln!("READ: cannot parse integer from '{}'", token); std::process::exit(1); }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    } else {
 +                        eprintln!("READ: cannot parse integer from '{}'", token);
 +                        std::process::exit(1);
+                     }
+                 }
 -            }
 +            },
              Ok(None) => {
 -                if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = IOSTAT_END;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
+     }
                  let normalized = token.replace('d', "e").replace('D', "E");
                  match normalized.parse::<f32>() {
                      Ok(v) => {
 -                        if !val.is_null() { unsafe { *val = v; } }
 -                        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                        if !val.is_null() {
 +                            unsafe {
 +                                *val = v;
 +                            }
 +                        }
 +                        if !iostat.is_null() {
 +                            unsafe {
 +                                *iostat = 0;
 +                            }
 +                        }
+                     }
                      Err(_) => {
 -                        if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                        else { eprintln!("READ: cannot parse real from '{}'", token); std::process::exit(1); }
 +                        if !iostat.is_null() {
 +                            unsafe {
 +                                *iostat = 1;
 +                            }
 +                        } else {
 +                            eprintln!("READ: cannot parse real from '{}'", token);
 +                            std::process::exit(1);
 +                        }
+                     }
+                 }
+             }
              Ok(None) => {
 -                if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 -                else { eprintln!("READ: end of file"); std::process::exit(1); }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = IOSTAT_END;
 +                    }
 +                } else {
 +                    eprintln!("READ: end of file");
 +                    std::process::exit(1);
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
+     }
                  let normalized = token.replace('d', "e").replace('D', "E");
                  match normalized.parse::<f64>() {
                      Ok(v) => {
 -                        if !val.is_null() { unsafe { *val = v; } }
 -                        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                        if !val.is_null() {
 +                            unsafe {
 +                                *val = v;
 +                            }
 +                        }
 +                        if !iostat.is_null() {
 +                            unsafe {
 +                                *iostat = 0;
 +                            }
 +                        }
+                     }
                      Err(_) => {
 -                        if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                        else { eprintln!("READ: cannot parse real from '{}'", token); std::process::exit(1); }
 +                        if !iostat.is_null() {
 +                            unsafe {
 +                                *iostat = 1;
 +                            }
 +                        } else {
 +                            eprintln!("READ: cannot parse real from '{}'", token);
 +                            std::process::exit(1);
 +                        }
+                     }
+                 }
+             }
              Ok(None) => {
 -                if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = IOSTAT_END;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
+     }
      /// Record numbers are 1-based. Returns Ok(()) or Err on failure.
      fn seek_to_record(&mut self, rec: i64) -> io::Result<()> {
          if rec < 1 {
 -            return Err(io::Error::new(io::ErrorKind::InvalidInput,
 -                "direct access record number must be >= 1"));
 -        }
 -        let recl = self.recl.ok_or_else(||
 -            io::Error::new(io::ErrorKind::InvalidInput, "direct access requires RECL"))?;
 -        let offset = (rec - 1).checked_mul(recl).ok_or_else(||
 -            io::Error::new(io::ErrorKind::InvalidInput, "record offset overflow"))?;
 +            return Err(io::Error::new(
 +                io::ErrorKind::InvalidInput,
 +                "direct access record number must be >= 1",
 +            ));
 +        }
 +        let recl = self.recl.ok_or_else(|| {
 +            io::Error::new(io::ErrorKind::InvalidInput, "direct access requires RECL")
 +        })?;
 +        let offset = (rec - 1)
 +            .checked_mul(recl)
 +            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "record offset overflow"))?;
          if offset < 0 {
 -            return Err(io::Error::new(io::ErrorKind::InvalidInput, "negative record offset"));
 +            return Err(io::Error::new(
 +                io::ErrorKind::InvalidInput,
 +                "negative record offset",
 +            ));
+         }
          match &mut self.stream {
              UnitStream::FileRaw(f) => {
                  f.seek(SeekFrom::Start(offset as u64))?;
                  Ok(())
+             }
 -            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "unit not opened for direct access")),
 +            _ => Err(io::Error::new(
 +                io::ErrorKind::InvalidInput,
 +                "unit not opened for direct access",
 +            )),
+         }
+     }
          match &mut self.stream {
              UnitStream::FileRaw(f) => f.write_all(data),
              UnitStream::FileWrite(w) => w.write_all(data),
 -            _ => Err(io::Error::new(io::ErrorKind::PermissionDenied, "unit not open for writing")),
 +            _ => Err(io::Error::new(
 +                io::ErrorKind::PermissionDenied,
 +                "unit not open for writing",
 +            )),
+         }
+     }
          match &mut self.stream {
              UnitStream::FileRaw(f) => f.read(buf),
              UnitStream::FileRead(r) => r.read(buf),
 -            _ => Err(io::Error::new(io::ErrorKind::PermissionDenied, "unit not open for reading")),
 +            _ => Err(io::Error::new(
 +                io::ErrorKind::PermissionDenied,
 +                "unit not open for reading",
 +            )),
+         }
+     }
+ }
  /// Write a direct-access record (formatted string padded to recl).
  #[no_mangle]
  pub extern "C" fn afs_write_direct(
 -    unit: i32, rec: i64,
 -    data: *const u8, data_len: i64,
 +    unit: i32,
 +    rec: i64,
 +    data: *const u8,
 +    data_len: i64,
      iostat: *mut i32,
  ) {
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          if let Err(e) = u.seek_to_record(rec) {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 -            else { eprintln!("WRITE direct: {}", e); std::process::exit(1); }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            } else {
 +                eprintln!("WRITE direct: {}", e);
 +                std::process::exit(1);
 +            }
              return;
+         }
          let recl = u.recl.unwrap_or(0) as usize;
          let mut record = vec![b' '; recl]; // space-padded
          let copy_len = (data_len as usize).min(recl);
          if !data.is_null() && copy_len > 0 {
 -            unsafe { std::ptr::copy_nonoverlapping(data, record.as_mut_ptr(), copy_len); }
 +            unsafe {
 +                std::ptr::copy_nonoverlapping(data, record.as_mut_ptr(), copy_len);
 +            }
+         }
          if let Err(e) = u.write_raw(&record) {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 -            else { eprintln!("WRITE direct: {}", e); std::process::exit(1); }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            } else {
 +                eprintln!("WRITE direct: {}", e);
 +                std::process::exit(1);
 +            }
              return;
+         }
 -        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        }
+     }
+ }
  /// Read a direct-access record.
  #[no_mangle]
  pub extern "C" fn afs_read_direct(
 -    unit: i32, rec: i64,
 -    data: *mut u8, data_len: i64,
 +    unit: i32,
 +    rec: i64,
 +    data: *mut u8,
 +    data_len: i64,
      iostat: *mut i32,
  ) {
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          if let Err(e) = u.seek_to_record(rec) {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 -            else { eprintln!("READ direct: {}", e); std::process::exit(1); }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            } else {
 +                eprintln!("READ direct: {}", e);
 +                std::process::exit(1);
 +            }
              return;
+         }
          let recl = u.recl.unwrap_or(0) as usize;
              Ok(n) => {
                  let copy_len = n.min(data_len as usize);
                  if !data.is_null() && copy_len > 0 {
 -                    unsafe { std::ptr::copy_nonoverlapping(record.as_ptr(), data, copy_len); }
 +                    unsafe {
 +                        std::ptr::copy_nonoverlapping(record.as_ptr(), data, copy_len);
 +                    }
+                 }
                  // Pad remainder with spaces.
                  if copy_len < data_len as usize {
 -                    unsafe { std::ptr::write_bytes(data.add(copy_len), b' ', data_len as usize - copy_len); }
 +                    unsafe {
 +                        std::ptr::write_bytes(
 +                            data.add(copy_len),
 +                            b' ',
 +                            data_len as usize - copy_len,
 +                        );
 +                    }
 +                }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
+                 }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
+             }
              Err(e) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 -                else { eprintln!("READ direct: {}", e); std::process::exit(1); }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                } else {
 +                    eprintln!("READ direct: {}", e);
 +                    std::process::exit(1);
 +                }
+             }
+         }
+     }
  #[no_mangle]
  pub extern "C" fn afs_write_unformatted(
      unit: i32,
 -    data: *const u8, data_len: i64,
 +    data: *const u8,
 +    data_len: i64,
      iostat: *mut i32,
  ) {
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          if data_len < 0 || data_len > u32::MAX as i64 {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 -            else { eprintln!("WRITE unformatted: record length {} exceeds 4GB limit", data_len); std::process::exit(1); }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            } else {
 +                eprintln!(
 +                    "WRITE unformatted: record length {} exceeds 4GB limit",
 +                    data_len
 +                );
 +                std::process::exit(1);
 +            }
              return;
+         }
          let len_bytes = (data_len as u32).to_ne_bytes();
          let r2 = if !data.is_null() && data_len > 0 {
              let slice = unsafe { std::slice::from_raw_parts(data, data_len as usize) };
              u.write_raw(slice)
 -        } else { Ok(()) };
 +        } else {
 +            Ok(())
 +        };
          let r3 = u.write_raw(&len_bytes);
          if r1.is_err() || r2.is_err() || r3.is_err() {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
          } else {
 -            if !iostat.is_null() { unsafe { *iostat = 0; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 0;
 +                }
 +            }
+         }
+     }
+ }
  #[no_mangle]
  pub extern "C" fn afs_read_unformatted(
      unit: i32,
 -    data: *mut u8, max_len: i64,
 +    data: *mut u8,
 +    max_len: i64,
      actual_len: *mut i64,
      iostat: *mut i32,
  ) {
          match u.read_raw(&mut len_buf) {
              Ok(4) => {}
              Ok(0) => {
 -                if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = IOSTAT_END;
 +                    }
 +                }
                  return;
+             }
              _ => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
                  return;
+             }
+         }
          let record_len = u32::from_ne_bytes(len_buf) as usize;
 -        if !actual_len.is_null() { unsafe { *actual_len = record_len as i64; } }
 +        if !actual_len.is_null() {
 +            unsafe {
 +                *actual_len = record_len as i64;
 +            }
 +        }
          // Read record data.
          let read_len = record_len.min(max_len as usize);
          // Read trailing length marker (and discard).
          let _ = u.read_raw(&mut len_buf);
 -        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        }
+     }
+ }
  /// Write raw bytes at the current stream position.
  #[no_mangle]
 -pub extern "C" fn afs_write_stream(
 -    unit: i32,
 -    data: *const u8, data_len: i64,
 -    iostat: *mut i32,
 -) {
 +pub extern "C" fn afs_write_stream(unit: i32, data: *const u8, data_len: i64, iostat: *mut i32) {
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          if !data.is_null() && data_len > 0 {
              let slice = unsafe { std::slice::from_raw_parts(data, data_len as usize) };
              match u.write_raw(slice) {
 -                Ok(()) => { if !iostat.is_null() { unsafe { *iostat = 0; } } }
 -                Err(_) => { if !iostat.is_null() { unsafe { *iostat = 1; } } }
 +                Ok(()) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
+         }
+     }
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          match &mut u.stream {
 -            UnitStream::FileRaw(f) => {
 -                match f.seek(SeekFrom::Start(pos as u64)) {
 -                    Ok(_) => { if !iostat.is_null() { unsafe { *iostat = 0; } } }
 -                    Err(_) => { if !iostat.is_null() { unsafe { *iostat = 1; } } }
 +            UnitStream::FileRaw(f) => match f.seek(SeekFrom::Start(pos as u64)) {
 +                Ok(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
 +            },
 +            _ => {
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
+                 }
+             }
 -            _ => { if !iostat.is_null() { unsafe { *iostat = 1; } } }
+         }
+     }
+ }
      pub name: *const u8,
      pub name_len: i64,
      pub data: *mut u8,
 -    pub data_type: i32,  // 0=int, 1=real, 2=string, 3=logical
 -    pub data_len: i64,   // string length for type 2
 +    pub data_type: i32, // 0=int, 1=real, 2=string, 3=logical
 +    pub data_len: i64,  // string length for type 2
+ }
  /// Write a NAMELIST group to a unit.
  #[no_mangle]
  pub extern "C" fn afs_write_namelist(
      unit: i32,
 -    group_name: *const u8, group_name_len: i64,
 -    entries: *const NamelistEntry, n_entries: i32,
 +    group_name: *const u8,
 +    group_name_len: i64,
 +    entries: *const NamelistEntry,
 +    n_entries: i32,
  ) {
      let gname = unsafe_str(group_name, group_name_len);
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
                  let name = unsafe_str(entry.name, entry.name_len);
                  let sep = if i > 0 { "," } else { "" };
                  let val_str = match entry.data_type {
 -                    0 => { // integer
 +                    0 => {
 +                        // integer
                          let v = unsafe { *(entry.data as *const i32) };
                          format!("{}", v)
+                     }
 -                    1 => { // real
 +                    1 => {
 +                        // real
                          let v = unsafe { *(entry.data as *const f64) };
                          format!("{}", v)
+                     }
 -                    2 => { // string
 +                    2 => {
 +                        // string
                          let s = unsafe_str(entry.data, entry.data_len);
                          format!("'{}'", s.trim_end())
+                     }
 -                    3 => { // logical
 +                    3 => {
 +                        // logical
                          let v = unsafe { *(entry.data as *const i32) };
                          (if v != 0 { ".TRUE." } else { ".FALSE." }).to_string()
+                     }
  #[no_mangle]
  pub extern "C" fn afs_read_namelist(
      unit: i32,
 -    group_name: *const u8, group_name_len: i64,
 -    entries: *const NamelistEntry, n_entries: i32,
 +    group_name: *const u8,
 +    group_name_len: i64,
 +    entries: *const NamelistEntry,
 +    n_entries: i32,
      iostat: *mut i32,
  ) {
      let gname = unsafe_str(group_name, group_name_len).to_lowercase();
+                     }
+                 }
                  Err(_) => {
 -                    if !iostat.is_null() { unsafe { *iostat = IOSTAT_END; } }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = IOSTAT_END;
 +                        }
 +                    }
                      return;
+                 }
+             }
                  let after_name = &all_lines[start + gname.len()..];
                  if let Some(end) = after_name.find('/') {
                      &after_name[..end]
 -                } else { after_name }
 -            } else { "" };
 +                } else {
 +                    after_name
 +                }
 +            } else {
 +                ""
 +            };
              // Parse var=val pairs. Supports:
              //   var=val            — simple scalar assignment
                  let pair = pair.trim();
                  if let Some(eq_pos) = pair.find('=') {
                      let lhs = pair[..eq_pos].trim().to_lowercase();
 -                    let val_str = pair[eq_pos+1..].trim();
 +                    let val_str = pair[eq_pos + 1..].trim();
                      // Parse array index from "var(idx)" syntax.
                      let (var_name, array_index) = if let Some(paren) = lhs.find('(') {
                          let name = lhs[..paren].trim();
 -                        let idx_str = lhs[paren+1..].trim_end_matches(')').trim();
 +                        let idx_str = lhs[paren + 1..].trim_end_matches(')').trim();
                          let idx = idx_str.parse::<usize>().unwrap_or(1);
                          (name.to_string(), Some(idx))
                      } else {
                          // Make sure * is preceded by digits (not part of a number like 1.5E*).
                          let before = val_str[..star].trim();
                          if let Ok(n) = before.parse::<usize>() {
 -                            (n, val_str[star+1..].trim())
 +                            (n, val_str[star + 1..].trim())
                          } else {
                              (1, val_str)
+                         }
                      // Find the matching entry.
                      for entry in entries_slice {
 -                        if entry.data.is_null() { continue; }
 +                        if entry.data.is_null() {
 +                            continue;
 +                        }
                          let ename = unsafe_str(entry.name, entry.name_len).to_lowercase();
                          if ename == var_name {
                              namelist_assign_value(entry, actual_val, array_index, repeat_count);
+                 }
+             }
+         }
 -        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        }
+     }
+ }
  /// Assign a parsed NAMELIST value to an entry, handling array indexing and repeat.
 -fn namelist_assign_value(entry: &NamelistEntry, val_str: &str, index: Option<usize>, repeat: usize) {
 +fn namelist_assign_value(
 +    entry: &NamelistEntry,
 +    val_str: &str,
 +    index: Option<usize>,
 +    repeat: usize,
 +) {
      // For array elements, compute byte offset from 1-based index.
      let elem_size = match entry.data_type {
 -        0 => 4,  // integer (i32)
 -        1 => 8,  // real (f64)
 -        3 => 4,  // logical (i32)
 -        _ => 1,  // string
 +        0 => 4, // integer (i32)
 +        1 => 8, // real (f64)
 +        3 => 4, // logical (i32)
 +        _ => 1, // string
      };
 -    let base_offset = index.map(|i| (i.saturating_sub(1)) * elem_size).unwrap_or(0);
 +    let base_offset = index
 +        .map(|i| (i.saturating_sub(1)) * elem_size)
 +        .unwrap_or(0);
      for r in 0..repeat {
          let offset = base_offset + r * elem_size;
          let ptr = unsafe { entry.data.add(offset) };
          match entry.data_type {
 -            0 => { // integer
 +            0 => {
 +                // integer
                  if let Ok(v) = val_str.parse::<i32>() {
 -                    unsafe { *(ptr as *mut i32) = v; }
 +                    unsafe {
 +                        *(ptr as *mut i32) = v;
 +                    }
+                 }
+             }
 -            1 => { // real
 +            1 => {
 +                // real
                  let normalized = val_str.replace('d', "e").replace('D', "E");
                  if let Ok(v) = normalized.parse::<f64>() {
 -                    unsafe { *(ptr as *mut f64) = v; }
 +                    unsafe {
 +                        *(ptr as *mut f64) = v;
 +                    }
+                 }
+             }
 -            2 => { // string (only first element for repeat, no array stride for strings)
 +            2 => {
 +                // string (only first element for repeat, no array stride for strings)
                  let s = val_str.trim_matches('\'').trim_matches('"');
                  let bytes = s.as_bytes();
                  let copy_len = bytes.len().min(entry.data_len as usize);
                      unsafe {
                          std::ptr::copy_nonoverlapping(bytes.as_ptr(), entry.data, copy_len);
                          if copy_len < entry.data_len as usize {
 -                            std::ptr::write_bytes(entry.data.add(copy_len), b' ',
 -                                entry.data_len as usize - copy_len);
 +                            std::ptr::write_bytes(
 +                                entry.data.add(copy_len),
 +                                b' ',
 +                                entry.data_len as usize - copy_len,
 +                            );
+                         }
+                     }
+                 }
                  return; // string repeat doesn't make sense
+             }
 -            3 => { // logical
 +            3 => {
 +                // logical
                  let lower = val_str.to_lowercase();
                  let v = lower.starts_with(".t") || lower.starts_with("t");
 -                unsafe { *(ptr as *mut i32) = v as i32; }
 +                unsafe {
 +                    *(ptr as *mut i32) = v as i32;
 +                }
+             }
              _ => {}
+         }
  /// Write a formatted integer to a character buffer (internal I/O).
  #[no_mangle]
  pub extern "C" fn afs_write_internal_int(
 -    buf: *mut u8, buf_len: i64,
 +    buf: *mut u8,
 +    buf_len: i64,
      val: i32,
      pos: *mut i64, // current write position, updated after write
  ) {
 -    if buf.is_null() || buf_len <= 0 { return; }
 +    if buf.is_null() || buf_len <= 0 {
 +        return;
 +    }
      let s = format!(" {}", val);
 -    let start = if !pos.is_null() { (unsafe { *pos }) as usize } else { 0 };
 +    let start = if !pos.is_null() {
 +        (unsafe { *pos }) as usize
 +    } else {
 +        0
 +    };
      write_to_buffer(buf, buf_len as usize, start, s.as_bytes(), pos);
+ }
  /// Write a formatted i64 to a character buffer (internal I/O).
  #[no_mangle]
 -pub extern "C" fn afs_write_internal_int64(
 -    buf: *mut u8, buf_len: i64,
 -    val: i64,
 -    pos: *mut i64,
 -) {
 -    if buf.is_null() || buf_len <= 0 { return; }
 +pub extern "C" fn afs_write_internal_int64(buf: *mut u8, buf_len: i64, val: i64, pos: *mut i64) {
 +    if buf.is_null() || buf_len <= 0 {
 +        return;
 +    }
      let s = format!(" {}", val);
 -    let start = if !pos.is_null() { (unsafe { *pos }) as usize } else { 0 };
 +    let start = if !pos.is_null() {
 +        (unsafe { *pos }) as usize
 +    } else {
 +        0
 +    };
      write_to_buffer(buf, buf_len as usize, start, s.as_bytes(), pos);
+ }
  /// Write a formatted integer(16) to a character buffer (internal I/O).
  #[no_mangle]
 -pub extern "C" fn afs_write_internal_int128(
 -    buf: *mut u8, buf_len: i64,
 -    val: i128,
 -    pos: *mut i64,
 -) {
 -    if buf.is_null() || buf_len <= 0 { return; }
 +pub extern "C" fn afs_write_internal_int128(buf: *mut u8, buf_len: i64, val: i128, pos: *mut i64) {
 +    if buf.is_null() || buf_len <= 0 {
 +        return;
 +    }
      let s = format!(" {}", val);
 -    let start = if !pos.is_null() { (unsafe { *pos }) as usize } else { 0 };
 +    let start = if !pos.is_null() {
 +        (unsafe { *pos }) as usize
 +    } else {
 +        0
 +    };
      write_to_buffer(buf, buf_len as usize, start, s.as_bytes(), pos);
+ }
  /// Write a formatted real to a character buffer (internal I/O).
  #[no_mangle]
 -pub extern "C" fn afs_write_internal_real64(
 -    buf: *mut u8, buf_len: i64,
 -    val: f64,
 -    pos: *mut i64,
 -) {
 -    if buf.is_null() || buf_len <= 0 { return; }
 +pub extern "C" fn afs_write_internal_real64(buf: *mut u8, buf_len: i64, val: f64, pos: *mut i64) {
 +    if buf.is_null() || buf_len <= 0 {
 +        return;
 +    }
      let s = format!(" {}", val);
 -    let start = if !pos.is_null() { (unsafe { *pos }) as usize } else { 0 };
 +    let start = if !pos.is_null() {
 +        (unsafe { *pos }) as usize
 +    } else {
 +        0
 +    };
      write_to_buffer(buf, buf_len as usize, start, s.as_bytes(), pos);
+ }
  /// Write a formatted string to a character buffer (internal I/O).
  #[no_mangle]
  pub extern "C" fn afs_write_internal_string(
 -    buf: *mut u8, buf_len: i64,
 -    src: *const u8, src_len: i64,
 +    buf: *mut u8,
 +    buf_len: i64,
 +    src: *const u8,
 +    src_len: i64,
      pos: *mut i64,
  ) {
 -    if buf.is_null() || buf_len <= 0 { return; }
 -    let start = if !pos.is_null() { (unsafe { *pos }) as usize } else { 0 };
 +    if buf.is_null() || buf_len <= 0 {
 +        return;
 +    }
 +    let start = if !pos.is_null() {
 +        (unsafe { *pos }) as usize
 +    } else {
 +        0
 +    };
      let mut data = vec![b' '];
      if !src.is_null() && src_len > 0 {
          let slice = unsafe { std::slice::from_raw_parts(src, src_len as usize) };
      if idx >= slice.len() {
          if !pos.is_null() {
 -            unsafe { *pos = idx as i64; }
 +            unsafe {
 +                *pos = idx as i64;
 +            }
+         }
          return None;
+     }
+     }
      if !pos.is_null() {
 -        unsafe { *pos = idx as i64; }
 +        unsafe {
 +            *pos = idx as i64;
 +        }
+     }
      Some(String::from_utf8_lossy(&slice[start..idx]).into_owned())
  /// Read an integer from a character buffer (internal I/O).
  #[no_mangle]
  pub extern "C" fn afs_read_internal_int(
 -    buf: *const u8, buf_len: i64,
 +    buf: *const u8,
 +    buf_len: i64,
      pos: *mut i64,
      val: *mut i32,
      iostat: *mut i32,
      if let Some(token) = next_internal_token(buf, buf_len, pos) {
          match token.replace(',', "").parse::<i32>() {
              Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                if !val.is_null() {
 +                    unsafe {
 +                        *val = v;
 +                    }
 +                }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
      } else {
 -        if !iostat.is_null() { unsafe { *iostat = -1; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = -1;
 +            }
 +        }
+     }
+ }
  /// Read an i64 from a character buffer (internal I/O).
  #[no_mangle]
  pub extern "C" fn afs_read_internal_int64(
 -    buf: *const u8, buf_len: i64,
 +    buf: *const u8,
 +    buf_len: i64,
      pos: *mut i64,
      val: *mut i64,
      iostat: *mut i32,
      if let Some(token) = next_internal_token(buf, buf_len, pos) {
          match token.replace(',', "").parse::<i64>() {
              Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                if !val.is_null() {
 +                    unsafe {
 +                        *val = v;
 +                    }
 +                }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
      } else {
 -        if !iostat.is_null() { unsafe { *iostat = -1; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = -1;
 +            }
 +        }
+     }
+ }
  /// Read an integer(16) from a character buffer (internal I/O).
  #[no_mangle]
  pub extern "C" fn afs_read_internal_int128(
 -    buf: *const u8, buf_len: i64,
 +    buf: *const u8,
 +    buf_len: i64,
      pos: *mut i64,
      val: *mut i128,
      iostat: *mut i32,
          match token.replace(',', "").parse::<i128>() {
              Ok(v) => {
                  write_i128_ptr(val, v);
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
      } else {
 -        if !iostat.is_null() { unsafe { *iostat = -1; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = -1;
 +            }
 +        }
+     }
+ }
  /// Read a real from a character buffer (internal I/O).
  #[no_mangle]
  pub extern "C" fn afs_read_internal_real(
 -    buf: *const u8, buf_len: i64,
 +    buf: *const u8,
 +    buf_len: i64,
      pos: *mut i64,
      val: *mut f64,
      iostat: *mut i32,
          let normalized = token.replace('d', "e").replace('D', "E").replace(',', "");
          match normalized.parse::<f64>() {
              Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                if !val.is_null() {
 +                    unsafe {
 +                        *val = v;
 +                    }
 +                }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 1;
 +                    }
 +                }
+             }
+         }
      } else {
 -        if !iostat.is_null() { unsafe { *iostat = -1; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = -1;
 +            }
 +        }
+     }
+ }
      // Space-pad remaining buffer.
      let end = start + copy_len;
      if end < buf_len {
 -        unsafe { std::ptr::write_bytes(buf.add(end), b' ', buf_len - end); }
 +        unsafe {
 +            std::ptr::write_bytes(buf.add(end), b' ', buf_len - end);
 +        }
+     }
      if !pos.is_null() {
 -        unsafe { *pos = end as i64; }
 +        unsafe {
 +            *pos = end as i64;
 +        }
+     }
+ }
                  let pos = f.stream_position().unwrap_or(0);
                  if pos <= 1 {
                      let _ = f.seek(SeekFrom::Start(0));
 -                    if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
                      // Clear stale read tokens.
                      u.read_tokens.clear();
                      return;
                  loop {
                      f.seek(SeekFrom::Start(search_pos)).ok();
                      let mut byte = [0u8; 1];
 -                    if f.read(&mut byte).unwrap_or(0) == 0 { break; }
 +                    if f.read(&mut byte).unwrap_or(0) == 0 {
 +                        break;
 +                    }
                      if byte[0] == b'\n' {
                          f.seek(SeekFrom::Start(search_pos + 1)).ok();
                          break;
+                 }
                  // Clear stale read tokens after repositioning.
                  u.read_tokens.clear();
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
+             }
              _ => {
                  // Sequential buffered files: backspace is not well-supported.
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
+             }
+         }
+     }
              let pos = f.stream_position().unwrap_or(0);
              let _ = f.set_len(pos); // truncate at current position
+         }
 -        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        }
+     }
+ }
  /// Write a Fortran-style string result into a caller-provided buffer.
  /// Pads with spaces to buf_len (Fortran CHARACTER semantics).
  fn write_inquire_string(buf: *mut u8, buf_len: i64, value: &str) {
 -    if buf.is_null() || buf_len <= 0 { return; }
 +    if buf.is_null() || buf_len <= 0 {
 +        return;
 +    }
      let n = buf_len as usize;
      let val_bytes = value.as_bytes();
      let copy_len = val_bytes.len().min(n);
  /// INQUIRE by file: check if a file exists, report its properties.
  #[no_mangle]
  pub extern "C" fn afs_inquire_file(
 -    filename: *const u8, filename_len: i64,
 +    filename: *const u8,
 +    filename_len: i64,
      exist: *mut i32,
      opened: *mut i32,
      iostat: *mut i32,
      // Extended specifiers — pass null for any not needed.
 -    name_buf: *mut u8, name_buf_len: i64,
 -    access_buf: *mut u8, access_buf_len: i64,
 -    form_buf: *mut u8, form_buf_len: i64,
 -    action_buf: *mut u8, action_buf_len: i64,
 +    name_buf: *mut u8,
 +    name_buf_len: i64,
 +    access_buf: *mut u8,
 +    access_buf_len: i64,
 +    form_buf: *mut u8,
 +    form_buf_len: i64,
 +    action_buf: *mut u8,
 +    action_buf_len: i64,
      recl_out: *mut i64,
      size_out: *mut i64,
  ) {
      let file_exists = std::path::Path::new(&fname).exists();
      if !exist.is_null() {
 -        unsafe { *exist = file_exists as i32; }
 +        unsafe {
 +            *exist = file_exists as i32;
 +        }
+     }
      // Find unit connected to this file (if any).
      let connected_unit = state.units.values().find(|u| u.filename == fname);
      if !opened.is_null() {
 -        unsafe { *opened = connected_unit.is_some() as i32; }
 +        unsafe {
 +            *opened = connected_unit.is_some() as i32;
 +        }
+     }
      write_inquire_string(name_buf, name_buf_len, &fname);
      if let Some(u) = connected_unit {
 -        write_unit_properties(u, access_buf, access_buf_len, form_buf, form_buf_len,
 -                              action_buf, action_buf_len, recl_out);
 +        write_unit_properties(
 +            u,
 +            access_buf,
 +            access_buf_len,
 +            form_buf,
 +            form_buf_len,
 +            action_buf,
 +            action_buf_len,
 +            recl_out,
 +        );
      } else {
          write_inquire_string(access_buf, access_buf_len, "UNDEFINED");
          write_inquire_string(form_buf, form_buf_len, "UNDEFINED");
      // File size via metadata.
      if !size_out.is_null() {
 -        let sz = std::fs::metadata(&fname).map(|m| m.len() as i64).unwrap_or(-1);
 -        unsafe { *size_out = sz; }
 +        let sz = std::fs::metadata(&fname)
 +            .map(|m| m.len() as i64)
 +            .unwrap_or(-1);
 +        unsafe {
 +            *size_out = sz;
 +        }
+     }
      if !iostat.is_null() {
 -        unsafe { *iostat = 0; }
 +        unsafe {
 +            *iostat = 0;
 +        }
+     }
+ }
      opened: *mut i32,
      iostat: *mut i32,
      // Extended specifiers.
 -    name_buf: *mut u8, name_buf_len: i64,
 -    access_buf: *mut u8, access_buf_len: i64,
 -    form_buf: *mut u8, form_buf_len: i64,
 -    action_buf: *mut u8, action_buf_len: i64,
 +    name_buf: *mut u8,
 +    name_buf_len: i64,
 +    access_buf: *mut u8,
 +    access_buf_len: i64,
 +    form_buf: *mut u8,
 +    form_buf_len: i64,
 +    action_buf: *mut u8,
 +    action_buf_len: i64,
      recl_out: *mut i64,
      size_out: *mut i64,
  ) {
      let unit_entry = state.units.get(&unit);
      if !exist.is_null() {
 -        unsafe { *exist = unit_entry.is_some() as i32; }
 +        unsafe {
 +            *exist = unit_entry.is_some() as i32;
 +        }
+     }
      if !opened.is_null() {
 -        unsafe { *opened = unit_entry.is_some() as i32; }
 +        unsafe {
 +            *opened = unit_entry.is_some() as i32;
 +        }
+     }
      if let Some(u) = unit_entry {
          write_inquire_string(name_buf, name_buf_len, &u.filename);
 -        write_unit_properties(u, access_buf, access_buf_len, form_buf, form_buf_len,
 -                              action_buf, action_buf_len, recl_out);
 +        write_unit_properties(
 +            u,
 +            access_buf,
 +            access_buf_len,
 +            form_buf,
 +            form_buf_len,
 +            action_buf,
 +            action_buf_len,
 +            recl_out,
 +        );
          if !size_out.is_null() {
              let sz = if !u.filename.is_empty() {
 -                std::fs::metadata(&u.filename).map(|m| m.len() as i64).unwrap_or(-1)
 -            } else { -1 };
 -            unsafe { *size_out = sz; }
 +                std::fs::metadata(&u.filename)
 +                    .map(|m| m.len() as i64)
 +                    .unwrap_or(-1)
 +            } else {
 +                -1
 +            };
 +            unsafe {
 +                *size_out = sz;
 +            }
+         }
      } else {
          write_inquire_string(name_buf, name_buf_len, "");
          write_inquire_string(access_buf, access_buf_len, "UNDEFINED");
          write_inquire_string(form_buf, form_buf_len, "UNDEFINED");
          write_inquire_string(action_buf, action_buf_len, "UNDEFINED");
 -        if !size_out.is_null() { unsafe { *size_out = -1; } }
 +        if !size_out.is_null() {
 +            unsafe {
 +                *size_out = -1;
 +            }
 +        }
+     }
      if !iostat.is_null() {
 -        unsafe { *iostat = 0; }
 +        unsafe {
 +            *iostat = 0;
 +        }
+     }
+ }
  /// Write ACCESS, FORM, ACTION, RECL for a connected unit.
  fn write_unit_properties(
      u: &Unit,
 -    access_buf: *mut u8, access_buf_len: i64,
 -    form_buf: *mut u8, form_buf_len: i64,
 -    action_buf: *mut u8, action_buf_len: i64,
 +    access_buf: *mut u8,
 +    access_buf_len: i64,
 +    form_buf: *mut u8,
 +    form_buf_len: i64,
 +    action_buf: *mut u8,
 +    action_buf_len: i64,
      recl_out: *mut i64,
  ) {
      let access_str = match u.access {
      write_inquire_string(action_buf, action_buf_len, action_str);
      if !recl_out.is_null() {
 -        unsafe { *recl_out = u.recl.unwrap_or(-1); }
 +        unsafe {
 +            *recl_out = u.recl.unwrap_or(-1);
 +        }
+     }
+ }
      let mut state = io_state().lock().unwrap_or_else(|e| e.into_inner());
      if let Some(u) = state.get_unit(unit) {
          match u.flush() {
 -            Ok(()) => { if !iostat.is_null() { unsafe { *iostat = 0; } } }
 +            Ok(()) => {
 +                if !iostat.is_null() {
 +                    unsafe {
 +                        *iostat = 0;
 +                    }
 +                }
 +            }
              Err(e) => {
                  if !iostat.is_null() {
 -                    unsafe { *iostat = e.raw_os_error().unwrap_or(1); }
 +                    unsafe {
 +                        *iostat = e.raw_os_error().unwrap_or(1);
 +                    }
+                 }
+             }
+         }
+         }
          // Clear stale read tokens so subsequent reads come from file start.
          u.read_tokens.clear();
 -        if !iostat.is_null() { unsafe { *iostat = 0; } }
 +        if !iostat.is_null() {
 +            unsafe {
 +                *iostat = 0;
 +            }
 +        }
+     }
+ }
  //   afs_fmt_push_int(val) / afs_fmt_push_int128(&val) / afs_fmt_push_real(val) / ...
  //   afs_fmt_end()
 -use std::cell::RefCell;
  use crate::format::{parse_format, FormatDesc, FormatEngine, IoValue};
 +use std::cell::RefCell;
  enum FmtSink {
      Unit(i32),
  ) -> Option<(FormatDesc, String)> {
      for desc in descs {
          match desc {
 -            FormatDesc::Group { repeat, descriptors } => {
 +            FormatDesc::Group {
 +                repeat,
 +                descriptors,
 +            } => {
                  for _ in 0..*repeat {
                      if let Some(found) = extract_nth_formatted_field(
                          descriptors,
      match formatted_read_record_for_unit(unit, data_index)
          .and_then(|line| parse_nth_formatted_record(line.as_bytes(), fmt_str, fmt_len, data_index))
+     {
 -        Ok((FormatDesc::IntegerI { .. }, field)) => match field.trim().replace(',', "").parse::<i32>() {
 -            Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 -            }
 -            Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +        Ok((FormatDesc::IntegerI { .. }, field)) => {
 +            match field.trim().replace(',', "").parse::<i32>() {
 +                Ok(v) => {
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
 +                    }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
 -        },
 +        }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
      match formatted_read_record_for_unit(unit, data_index)
          .and_then(|line| parse_nth_formatted_record(line.as_bytes(), fmt_str, fmt_len, data_index))
+     {
 -        Ok((FormatDesc::IntegerI { .. }, field)) => match field.trim().replace(',', "").parse::<i64>() {
 -            Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 -            }
 -            Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +        Ok((FormatDesc::IntegerI { .. }, field)) => {
 +            match field.trim().replace(',', "").parse::<i64>() {
 +                Ok(v) => {
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
 +                    }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
 -        },
 +        }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
      match formatted_read_record_for_unit(unit, data_index)
          .and_then(|line| parse_nth_formatted_record(line.as_bytes(), fmt_str, fmt_len, data_index))
+     {
 -        Ok((FormatDesc::IntegerI { .. }, field)) => match field.trim().replace(',', "").parse::<i128>() {
 -            Ok(v) => {
 -                write_i128_ptr(val, v);
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 -            }
 -            Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +        Ok((FormatDesc::IntegerI { .. }, field)) => {
 +            match field.trim().replace(',', "").parse::<i128>() {
 +                Ok(v) => {
 +                    write_i128_ptr(val, v);
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
 -        },
 +        }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
          | Ok((FormatDesc::RealEX { .. }, field))
          | Ok((FormatDesc::RealD { .. }, field))
          | Ok((FormatDesc::RealG { .. }, field)) => {
 -            let normalized = field.trim().replace('d', "e").replace('D', "E").replace(',', "");
 +            let normalized = field
 +                .trim()
 +                .replace('d', "e")
 +                .replace('D', "E")
 +                .replace(',', "");
              match normalized.parse::<f64>() {
                  Ok(v) => {
 -                    if !val.is_null() { unsafe { *val = v; } }
 -                    if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
 +                    }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
+                 }
                  Err(_) => {
 -                    if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
+                 }
+             }
+         }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
      iostat: *mut i32,
  ) {
      match parse_nth_formatted_internal_field(buf, buf_len, fmt_str, fmt_len, data_index) {
 -        Ok((FormatDesc::IntegerI { .. }, field)) => match field.trim().replace(',', "").parse::<i32>() {
 -            Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 -            }
 -            Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +        Ok((FormatDesc::IntegerI { .. }, field)) => {
 +            match field.trim().replace(',', "").parse::<i32>() {
 +                Ok(v) => {
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
 +                    }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
 -        },
 +        }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
      iostat: *mut i32,
  ) {
      match parse_nth_formatted_internal_field(buf, buf_len, fmt_str, fmt_len, data_index) {
 -        Ok((FormatDesc::IntegerI { .. }, field)) => match field.trim().replace(',', "").parse::<i64>() {
 -            Ok(v) => {
 -                if !val.is_null() { unsafe { *val = v; } }
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 -            }
 -            Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +        Ok((FormatDesc::IntegerI { .. }, field)) => {
 +            match field.trim().replace(',', "").parse::<i64>() {
 +                Ok(v) => {
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
 +                    }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
 -        },
 +        }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
      iostat: *mut i32,
  ) {
      match parse_nth_formatted_internal_field(buf, buf_len, fmt_str, fmt_len, data_index) {
 -        Ok((FormatDesc::IntegerI { .. }, field)) => match field.trim().replace(',', "").parse::<i128>() {
 -            Ok(v) => {
 -                write_i128_ptr(val, v);
 -                if !iostat.is_null() { unsafe { *iostat = 0; } }
 -            }
 -            Err(_) => {
 -                if !iostat.is_null() { unsafe { *iostat = 1; } }
 +        Ok((FormatDesc::IntegerI { .. }, field)) => {
 +            match field.trim().replace(',', "").parse::<i128>() {
 +                Ok(v) => {
 +                    write_i128_ptr(val, v);
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
 +                }
 +                Err(_) => {
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
 +                }
+             }
 -        },
 +        }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
          | Ok((FormatDesc::RealEX { .. }, field))
          | Ok((FormatDesc::RealD { .. }, field))
          | Ok((FormatDesc::RealG { .. }, field)) => {
 -            let normalized = field.trim().replace('d', "e").replace('D', "E").replace(',', "");
 +            let normalized = field
 +                .trim()
 +                .replace('d', "e")
 +                .replace('D', "E")
 +                .replace(',', "");
              match normalized.parse::<f64>() {
                  Ok(v) => {
 -                    if !val.is_null() { unsafe { *val = v; } }
 -                    if !iostat.is_null() { unsafe { *iostat = 0; } }
 +                    if !val.is_null() {
 +                        unsafe {
 +                            *val = v;
 +                        }
 +                    }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 0;
 +                        }
 +                    }
+                 }
                  Err(_) => {
 -                    if !iostat.is_null() { unsafe { *iostat = 1; } }
 +                    if !iostat.is_null() {
 +                        unsafe {
 +                            *iostat = 1;
 +                        }
 +                    }
+                 }
+             }
+         }
          Ok(_) => {
 -            if !iostat.is_null() { unsafe { *iostat = 1; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = 1;
 +                }
 +            }
+         }
          Err(code) => {
 -            if !iostat.is_null() { unsafe { *iostat = code; } }
 +            if !iostat.is_null() {
 +                unsafe {
 +                    *iostat = code;
 +                }
 +            }
+         }
+     }
+ }
          let path = "/tmp/afs_write_i128_test.dat";
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "replace".as_ptr(), 7,
 -            std::ptr::null(), 0,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "replace".as_ptr(),
 +            7,
 +            std::ptr::null(),
 +            0,
          );
          afs_write_int128(97, 170141183460469231731687303715884105727i128);
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "old".as_ptr(), 3,
 -            "read".as_ptr(), 4,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "old".as_ptr(),
 +            3,
 +            "read".as_ptr(),
 +            4,
          );
          let mut value = 0i128;
          let ptr = unsafe { raw.as_mut_ptr().add(1) as *mut i128 };
          let mut iostat = -99i32;
 -        afs_read_internal_int128(
 -            buf.as_ptr(),
 -            buf.len() as i64,
 -            &mut pos,
 -            ptr,
 -            &mut iostat,
 -        );
 +        afs_read_internal_int128(buf.as_ptr(), buf.len() as i64, &mut pos, ptr, &mut iostat);
          assert_eq!(iostat, 0, "expected internal i128 read to succeed");
          let value = unsafe { std::ptr::read_unaligned(ptr) };
          let path = "/tmp/afs_fmt_test.dat";
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "replace".as_ptr(), 7,
 -            std::ptr::null(), 0,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "replace".as_ptr(),
 +            7,
 +            std::ptr::null(),
 +            0,
          );
          afs_fmt_begin(99, "(I5, F8.2)".as_ptr(), 10);
          let wide = 170141183460469231731687303715884105727i128;
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "replace".as_ptr(), 7,
 -            std::ptr::null(), 0,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "replace".as_ptr(),
 +            7,
 +            std::ptr::null(),
 +            0,
          );
          afs_fmt_begin(96, "(I40)".as_ptr(), 5);
          unsafe { std::ptr::write_unaligned(ptr, wide) };
 -        afs_fmt_begin_internal(rendered.as_mut_ptr(), rendered.len() as i64, "(I40)".as_ptr(), 5);
 +        afs_fmt_begin_internal(
 +            rendered.as_mut_ptr(),
 +            rendered.len() as i64,
 +            "(I40)".as_ptr(),
 +            5,
 +        );
          afs_fmt_push_int128(ptr);
          afs_fmt_end(0);
              &mut iostat,
          );
 -        assert_eq!(iostat, 0, "expected formatted internal i128 read to succeed");
 +        assert_eq!(
 +            iostat, 0,
 +            "expected formatted internal i128 read to succeed"
 +        );
          assert_eq!(value, 170141183460469231731687303715884105727i128);
+     }
              &mut iostat,
          );
 -        assert_eq!(iostat, 0, "expected formatted internal i128 read to succeed");
 +        assert_eq!(
 +            iostat, 0,
 +            "expected formatted internal i128 read to succeed"
 +        );
          let value = unsafe { std::ptr::read_unaligned(ptr) };
          assert_eq!(value, 170141183460469231731687303715884105727i128);
+     }
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "old".as_ptr(), 3,
 -            "read".as_ptr(), 4,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "old".as_ptr(),
 +            3,
 +            "read".as_ptr(),
 +            4,
          );
          let mut value = 0i128;
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "old".as_ptr(), 3,
 -            "read".as_ptr(), 4,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "old".as_ptr(),
 +            3,
 +            "read".as_ptr(),
 +            4,
          );
          let mut first = 0i128;
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "old".as_ptr(), 3,
 -            "readwrite".as_ptr(), 9,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "old".as_ptr(),
 +            3,
 +            "readwrite".as_ptr(),
 +            9,
          );
          let mut first = 0i128;
          let mut iostat = -99i32;
          afs_fmt_read_int128(92, "(I40)".as_ptr(), 5, 0, &mut first, &mut iostat);
 -        assert_eq!(iostat, 0, "expected first formatted readwrite-unit read to succeed");
 +        assert_eq!(
 +            iostat, 0,
 +            "expected first formatted readwrite-unit read to succeed"
 +        );
          afs_fmt_read_int128(92, "(I40)".as_ptr(), 5, 0, &mut second, &mut iostat);
          afs_close(92, std::ptr::null_mut());
 -        assert_eq!(iostat, 0, "expected second formatted readwrite-unit read to succeed");
 +        assert_eq!(
 +            iostat, 0,
 +            "expected second formatted readwrite-unit read to succeed"
 +        );
          assert_eq!(first, 170141183460469231731687303715884105727i128);
          assert_eq!(second, -170141183460469231731687303715884105727i128);
+     }
          let path = "/tmp/afs_fmt_noadv_test.dat";
          afs_open_simple(
 ,
 -            path.as_ptr(), path.len() as i64,
 -            "replace".as_ptr(), 7,
 -            std::ptr::null(), 0,
 +            path.as_ptr(),
 +            path.len() as i64,
 +            "replace".as_ptr(),
 +            7,
 +            std::ptr::null(),
 +            0,
          );
          afs_fmt_begin(98, "('hello')".as_ptr(), 9);

runtime/src/lib.rsmodified

17 lines changed — click to load

  #![allow(clippy::not_unsafe_ptr_arg_deref)]
  #![allow(clippy::missing_safety_doc)]
 -pub mod descriptor;
  pub mod array;
 -pub mod string;
 +pub mod descriptor;
  pub mod format;
 -pub mod io_system;
 -pub mod system;
  mod io;
 -mod mem;
 +pub mod io_system;
  mod lifecycle;
 +mod mem;
 +pub mod string;
 +pub mod system;

runtime/src/mem.rsmodified

44 lines changed — click to load

  /// Concatenate two strings. Returns a newly allocated string.
  /// Caller is responsible for freeing the result.
  #[no_mangle]
 -pub extern "C" fn afs_string_concat(
 -    a: *const u8, alen: i64,
 -    b: *const u8, blen: i64,
 -) -> *mut u8 {
 +pub extern "C" fn afs_string_concat(a: *const u8, alen: i64, b: *const u8, blen: i64) -> *mut u8 {
      let total = (alen + blen) as usize;
      let result = afs_allocate(total as i64);
      if !a.is_null() && alen > 0 {
  /// Copy a string into a fixed-length buffer, padding with spaces.
  /// Used for character assignment to fixed-length variables.
  #[no_mangle]
 -pub extern "C" fn afs_string_copy(
 -    dest: *mut u8, dest_len: i64,
 -    src: *const u8, src_len: i64,
 -) {
 +pub extern "C" fn afs_string_copy(dest: *mut u8, dest_len: i64, src: *const u8, src_len: i64) {
      if dest.is_null() || dest_len <= 0 {
          return;
+     }
  /// Compare two strings lexicographically.
  /// Returns negative, zero, or positive (like strcmp but for counted strings).
  #[no_mangle]
 -pub extern "C" fn afs_string_compare(
 -    a: *const u8, alen: i64,
 -    b: *const u8, blen: i64,
 -) -> i32 {
 +pub extern "C" fn afs_string_compare(a: *const u8, alen: i64, b: *const u8, blen: i64) -> i32 {
      let sa = if !a.is_null() && alen > 0 {
          unsafe { std::slice::from_raw_parts(a, alen as usize) }
 -    } else { &[] };
 +    } else {
 +        &[]
 +    };
      let sb = if !b.is_null() && blen > 0 {
          unsafe { std::slice::from_raw_parts(b, blen as usize) }
 -    } else { &[] };
 +    } else {
 +        &[]
 +    };
      sa.cmp(sb) as i32
+ }

runtime/src/system.rsmodified

370 lines changed — click to load

          .unwrap_or_default();
      let nanos = now.as_nanos() as i64;
 -    if !count.is_null() { unsafe { *count = nanos; } }
 -    if !count_rate.is_null() { unsafe { *count_rate = 1_000_000_000; } }
 -    if !count_max.is_null() { unsafe { *count_max = i64::MAX; } }
 +    if !count.is_null() {
 +        unsafe {
 +            *count = nanos;
 +        }
 +    }
 +    if !count_rate.is_null() {
 +        unsafe {
 +            *count_rate = 1_000_000_000;
 +        }
 +    }
 +    if !count_max.is_null() {
 +        unsafe {
 +            *count_max = i64::MAX;
 +        }
 +    }
+ }
  /// CPU_TIME: returns processor time in seconds.
  #[no_mangle]
  pub extern "C" fn afs_cpu_time(time: *mut f64) {
 -    if time.is_null() { return; }
 -    extern "C" { fn clock() -> i64; }
 +    if time.is_null() {
 +        return;
 +    }
 +    extern "C" {
 +        fn clock() -> i64;
 +    }
      const CLOCKS_PER_SEC: i64 = 1_000_000; // POSIX value on macOS
      let ticks = unsafe { clock() };
 -    unsafe { *time = ticks as f64 / CLOCKS_PER_SEC as f64; }
 +    unsafe {
 +        *time = ticks as f64 / CLOCKS_PER_SEC as f64;
 +    }
+ }
  /// DATE_AND_TIME: returns date, time, timezone, and 8-element values array.
  #[no_mangle]
  pub extern "C" fn afs_date_and_time(
 -    date_buf: *mut u8, date_len: i64,
 -    time_buf: *mut u8, time_len: i64,
 -    zone_buf: *mut u8, zone_len: i64,
 +    date_buf: *mut u8,
 +    date_len: i64,
 +    time_buf: *mut u8,
 +    time_len: i64,
 +    zone_buf: *mut u8,
 +    zone_len: i64,
      values: *mut i32,
  ) {
      use std::time::SystemTime;
      // Use POSIX localtime_r to decompose.
      #[repr(C)]
      struct Tm {
 -        tm_sec: i32, tm_min: i32, tm_hour: i32, tm_mday: i32,
 -        tm_mon: i32, tm_year: i32, tm_wday: i32, tm_yday: i32,
 +        tm_sec: i32,
 +        tm_min: i32,
 +        tm_hour: i32,
 +        tm_mday: i32,
 +        tm_mon: i32,
 +        tm_year: i32,
 +        tm_wday: i32,
 +        tm_yday: i32,
          tm_isdst: i32,
 -        tm_gmtoff: i64,  // macOS: long (8 bytes on ARM64)
 +        tm_gmtoff: i64, // macOS: long (8 bytes on ARM64)
          tm_zone: *const u8,
+     }
      extern "C" {
+     }
      let mut tm = unsafe { std::mem::zeroed::<Tm>() };
      let time_t = secs;
 -    unsafe { localtime_r(&time_t, &mut tm); }
 +    unsafe {
 +        localtime_r(&time_t, &mut tm);
 +    }
      let year = tm.tm_year + 1900;
      let month = tm.tm_mon + 1;
          let s = format!("{:04}{:02}{:02}", year, month, day);
          let bytes = s.as_bytes();
          let n = bytes.len().min(date_len as usize);
 -        unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), date_buf, n); }
 +        unsafe {
 +            std::ptr::copy_nonoverlapping(bytes.as_ptr(), date_buf, n);
 +        }
          if n < date_len as usize {
 -            unsafe { std::ptr::write_bytes(date_buf.add(n), b' ', date_len as usize - n); }
 +            unsafe {
 +                std::ptr::write_bytes(date_buf.add(n), b' ', date_len as usize - n);
 +            }
+         }
+     }
          let s = format!("{:02}{:02}{:02}.{:03}", hour, minute, second, millis);
          let bytes = s.as_bytes();
          let n = bytes.len().min(time_len as usize);
 -        unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), time_buf, n); }
 +        unsafe {
 +            std::ptr::copy_nonoverlapping(bytes.as_ptr(), time_buf, n);
 +        }
          if n < time_len as usize {
 -            unsafe { std::ptr::write_bytes(time_buf.add(n), b' ', time_len as usize - n); }
 +            unsafe {
 +                std::ptr::write_bytes(time_buf.add(n), b' ', time_len as usize - n);
 +            }
+         }
+     }
          let s = format!("{}{:02}{:02}", sign, abs_min / 60, abs_min % 60);
          let bytes = s.as_bytes();
          let n = bytes.len().min(zone_len as usize);
 -        unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), zone_buf, n); }
 +        unsafe {
 +            std::ptr::copy_nonoverlapping(bytes.as_ptr(), zone_buf, n);
 +        }
          if n < zone_len as usize {
 -            unsafe { std::ptr::write_bytes(zone_buf.add(n), b' ', zone_len as usize - n); }
 +            unsafe {
 +                std::ptr::write_bytes(zone_buf.add(n), b' ', zone_len as usize - n);
 +            }
+         }
+     }
  #[no_mangle]
  pub extern "C" fn afs_get_command_argument(
      number: i32,
 -    value: *mut u8, value_len: i64,
 +    value: *mut u8,
 +    value_len: i64,
      length: *mut i32,
      status: *mut i32,
  ) {
      let args: Vec<String> = std::env::args().collect();
      if number < 0 || number as usize >= args.len() {
 -        if !status.is_null() { unsafe { *status = 1; } }
 -        if !length.is_null() { unsafe { *length = 0; } }
 +        if !status.is_null() {
 +            unsafe {
 +                *status = 1;
 +            }
 +        }
 +        if !length.is_null() {
 +            unsafe {
 +                *length = 0;
 +            }
 +        }
          return;
+     }
      let bytes = arg.as_bytes();
      if !length.is_null() {
 -        unsafe { *length = bytes.len() as i32; }
 +        unsafe {
 +            *length = bytes.len() as i32;
 +        }
+     }
      if !value.is_null() && value_len > 0 {
+         }
+     }
 -    if !status.is_null() { unsafe { *status = 0; } }
 +    if !status.is_null() {
 +        unsafe {
 +            *status = 0;
 +        }
 +    }
+ }
  /// GET_COMMAND: retrieve the full command line.
  #[no_mangle]
  pub extern "C" fn afs_get_command(
 -    command: *mut u8, cmd_len: i64,
 +    command: *mut u8,
 +    cmd_len: i64,
      length: *mut i32,
      status: *mut i32,
  ) {
      let full: String = std::env::args().collect::<Vec<_>>().join(" ");
      let bytes = full.as_bytes();
 -    if !length.is_null() { unsafe { *length = bytes.len() as i32; } }
 +    if !length.is_null() {
 +        unsafe {
 +            *length = bytes.len() as i32;
 +        }
 +    }
      if !command.is_null() && cmd_len > 0 {
          let n = bytes.len().min(cmd_len as usize);
          unsafe {
+             }
+         }
+     }
 -    if !status.is_null() { unsafe { *status = 0; } }
 +    if !status.is_null() {
 +        unsafe {
 +            *status = 0;
 +        }
 +    }
+ }
  /// GET_ENVIRONMENT_VARIABLE: retrieve an environment variable by name.
  #[no_mangle]
  pub extern "C" fn afs_get_environment_variable(
 -    name: *const u8, name_len: i64,
 -    value: *mut u8, value_len: i64,
 +    name: *const u8,
 +    name_len: i64,
 +    value: *mut u8,
 +    value_len: i64,
      length: *mut i32,
      status: *mut i32,
  ) {
          let slice = unsafe { std::slice::from_raw_parts(name, name_len as usize) };
          String::from_utf8_lossy(slice).trim().to_string()
      } else {
 -        if !status.is_null() { unsafe { *status = 1; } }
 +        if !status.is_null() {
 +            unsafe {
 +                *status = 1;
 +            }
 +        }
          return;
      };
      match std::env::var(&var_name) {
          Ok(val) => {
              let bytes = val.as_bytes();
 -            if !length.is_null() { unsafe { *length = bytes.len() as i32; } }
 +            if !length.is_null() {
 +                unsafe {
 +                    *length = bytes.len() as i32;
 +                }
 +            }
              if !value.is_null() && value_len > 0 {
                  let n = bytes.len().min(value_len as usize);
                  unsafe {
+                     }
+                 }
+             }
 -            if !status.is_null() { unsafe { *status = 0; } }
 +            if !status.is_null() {
 +                unsafe {
 +                    *status = 0;
 +                }
 +            }
+         }
          Err(_) => {
 -            if !length.is_null() { unsafe { *length = 0; } }
 -            if !status.is_null() { unsafe { *status = 1; } }
 +            if !length.is_null() {
 +                unsafe {
 +                    *length = 0;
 +                }
 +            }
 +            if !status.is_null() {
 +                unsafe {
 +                    *status = 1;
 +                }
 +            }
+         }
+     }
+ }
  /// EXECUTE_COMMAND_LINE: run a shell command.
  #[no_mangle]
  pub extern "C" fn afs_execute_command_line(
 -    command: *const u8, cmd_len: i64,
 +    command: *const u8,
 +    cmd_len: i64,
      wait: i32,
      exitstat: *mut i32,
      cmdstat: *mut i32,
          let slice = unsafe { std::slice::from_raw_parts(command, cmd_len as usize) };
          String::from_utf8_lossy(slice).trim().to_string()
      } else {
 -        if !cmdstat.is_null() { unsafe { *cmdstat = 1; } }
 +        if !cmdstat.is_null() {
 +            unsafe {
 +                *cmdstat = 1;
 +            }
 +        }
          return;
      };
      if wait != 0 {
          match Command::new("sh").arg("-c").arg(&cmd).status() {
              Ok(status) => {
 -                if !exitstat.is_null() { unsafe { *exitstat = status.code().unwrap_or(-1); } }
 -                if !cmdstat.is_null() { unsafe { *cmdstat = 0; } }
 +                if !exitstat.is_null() {
 +                    unsafe {
 +                        *exitstat = status.code().unwrap_or(-1);
 +                    }
 +                }
 +                if !cmdstat.is_null() {
 +                    unsafe {
 +                        *cmdstat = 0;
 +                    }
 +                }
+             }
              Err(_) => {
 -                if !cmdstat.is_null() { unsafe { *cmdstat = -1; } }
 +                if !cmdstat.is_null() {
 +                    unsafe {
 +                        *cmdstat = -1;
 +                    }
 +                }
+             }
+         }
      } else {
          match Command::new("sh").arg("-c").arg(&cmd).spawn() {
 -            Ok(_) => { if !cmdstat.is_null() { unsafe { *cmdstat = 0; } } }
 -            Err(_) => { if !cmdstat.is_null() { unsafe { *cmdstat = -1; } } }
 +            Ok(_) => {
 +                if !cmdstat.is_null() {
 +                    unsafe {
 +                        *cmdstat = 0;
 +                    }
 +                }
 +            }
 +            Err(_) => {
 +                if !cmdstat.is_null() {
 +                    unsafe {
 +                        *cmdstat = -1;
 +                    }
 +                }
 +            }
+         }
+     }
+ }
  /// RANDOM_NUMBER: fill a scalar with a random value in [0, 1).
  #[no_mangle]
  pub extern "C" fn afs_random_number_f64(harvest: *mut f64) {
 -    if harvest.is_null() { return; }
 +    if harvest.is_null() {
 +        return;
 +    }
      RNG_SEED.with(|s| {
          let mut x = s.get();
 -        x = x.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
 +        x = x
 +            .wrapping_mul(6364136223846793005)
 +            .wrapping_add(1442695040888963407);
          s.set(x);
 -        unsafe { *harvest = (x >> 11) as f64 / (1u64 << 53) as f64; }
 +        unsafe {
 +            *harvest = (x >> 11) as f64 / (1u64 << 53) as f64;
 +        }
      });
+ }
          afs_system_clock(&mut c1, &mut rate, std::ptr::null_mut());
          // Busy loop to ensure time passes.
          let mut sum = 0u64;
 -        for i in 0..100000 { sum = sum.wrapping_add(i); }
 +        for i in 0..100000 {
 +            sum = sum.wrapping_add(i);
 +        }
          let _ = sum;
          afs_system_clock(&mut c2, std::ptr::null_mut(), std::ptr::null_mut());
          assert!(c2 >= c1, "clock should not go backwards: {} vs {}", c1, c2);

src/ast/decl.rsmodified

106 lines changed — click to load

  //! Types, attributes, entity declarations, USE statements, IMPLICIT,
  //! derived type definitions, and legacy declaration forms.
 -use super::Spanned;
  use super::expr::SpannedExpr;
 +use super::Spanned;
  /// A spanned declaration.
  pub type SpannedDecl = Spanned<Decl>;
      /// `PUBLIC :: name1, name2` or `PRIVATE :: name1, name2` — sets
      /// access on specific names.
 -    AccessList { access: Attribute, names: Vec<String> },
 +    AccessList {
 +        access: Attribute,
 +        names: Vec<String>,
 +    },
      /// `implicit none` or `implicit none(type, external)`
 -    ImplicitNone {
 -        external: bool,
 -        type_: bool,
 -    },
 +    ImplicitNone { external: bool, type_: bool },
      /// `implicit double precision (a-h, o-z)`
 -    ImplicitStmt {
 -        specs: Vec<ImplicitSpec>,
 -    },
 +    ImplicitStmt { specs: Vec<ImplicitSpec> },
      /// Derived type definition
      DerivedTypeDef {
      },
      /// `parameter (pi = 3.14159, e = 2.71828)`
 -    ParameterStmt {
 -        pairs: Vec<(String, SpannedExpr)>,
 -    },
 +    ParameterStmt { pairs: Vec<(String, SpannedExpr)> },
      /// `common /block_name/ x, y, z`
      CommonBlock {
      },
      /// `equivalence (a, b), (c, d)`
 -    EquivalenceStmt {
 -        groups: Vec<Vec<SpannedExpr>>,
 -    },
 +    EquivalenceStmt { groups: Vec<Vec<SpannedExpr>> },
      /// `data x /1.0/, y /2.0/`
 -    DataStmt {
 -        sets: Vec<DataSet>,
 -    },
 +    DataStmt { sets: Vec<DataSet> },
      /// `enum, bind(c)`
      EnumDef {
  #[derive(Debug, Clone, PartialEq)]
  pub enum LenSpec {
      Expr(SpannedExpr),
 -    Star,   // len=* (assumed length)
 -    Colon,  // len=: (deferred length)
 +    Star,  // len=* (assumed length)
 +    Colon, // len=: (deferred length)
+ }
  // ---- Attributes ----
          upper: SpannedExpr,
      },
      /// `(:)` — assumed shape (for dummy arguments)
 -    AssumedShape {
 -        lower: Option<SpannedExpr>,
 -    },
 +    AssumedShape { lower: Option<SpannedExpr> },
      /// `(*)` — assumed size (last dimension only)
 -    AssumedSize {
 -        lower: Option<SpannedExpr>,
 -    },
 +    AssumedSize { lower: Option<SpannedExpr> },
      /// `(:)` with allocatable/pointer — deferred shape
      Deferred,
      /// `(..)` — assumed rank (F2018)
  pub struct EntityDecl {
      pub name: String,
      pub array_spec: Option<Vec<ArraySpec>>,
 -    pub char_len: Option<LenSpec>,      // character entity-specific length
 -    pub init: Option<SpannedExpr>,      // = expr
 -    pub ptr_init: Option<SpannedExpr>,  // => expr
 +    pub char_len: Option<LenSpec>, // character entity-specific length
 +    pub init: Option<SpannedExpr>, // = expr
 +    pub ptr_init: Option<SpannedExpr>, // => expr
+ }
  // ---- Derived type parts ----
  #[derive(Debug, Clone, PartialEq)]
  pub struct TypeBoundProc {
      pub name: String,
 -    pub binding: Option<String>,  // procedure :: name => binding
 -    pub attrs: Vec<String>,       // pass, nopass, deferred, etc.
 +    pub binding: Option<String>, // procedure :: name => binding
 +    pub attrs: Vec<String>,      // pass, nopass, deferred, etc.
      pub is_generic: bool,
+ }

src/ast/expr.rsmodified

224 lines changed — click to load

  //! Represents all Fortran expression forms: literals, names, operators,
  //! function calls, array constructors, component access, and more.
+-
  /// A Fortran expression.
  #[derive(Debug, Clone, PartialEq)]
  #[allow(clippy::enum_variant_names)]
  pub enum Expr {
      // ---- Literals ----
+-
      /// Integer literal: `42`, `42_8`, `42_int64`
 -    IntegerLiteral {
 -        text: String,
 -        kind: Option<String>,
 -    },
 +    IntegerLiteral { text: String, kind: Option<String> },
      /// Real literal: `3.14`, `1.0d0`, `6.022e23`, `1.0_8`, `.5`, `5.`
 -    RealLiteral {
 -        text: String,
 -        kind: Option<String>,
 -    },
 +    RealLiteral { text: String, kind: Option<String> },
      /// String literal: `'hello'`, `"hello"`, `'it''s'`
 -    StringLiteral {
 -        value: String,
 -        kind: Option<String>,
 -    },
 +    StringLiteral { value: String, kind: Option<String> },
      /// Logical literal: `.true.`, `.false.`, `.true._4`
 -    LogicalLiteral {
 -        value: bool,
 -        kind: Option<String>,
 -    },
 +    LogicalLiteral { value: bool, kind: Option<String> },
      /// Complex literal: `(1.0, 2.0)`
      ComplexLiteral {
          real: Box<SpannedExpr>,
          imag: Box<SpannedExpr>,
      },
      /// BOZ literal: `B'1010'`, `O'777'`, `Z'FF'`
 -    BozLiteral {
 -        text: String,
 -        base: BozBase,
 -    },
 +    BozLiteral { text: String, base: BozBase },
      // ---- Names and access ----
+-
      /// Simple name (variable, function, type, etc.)
 -    Name {
 -        name: String,
 -    },
 +    Name { name: String },
      /// Component access: `x%field`, `x%inner%deep`
      ComponentAccess {
          base: Box<SpannedExpr>,
      },
      // ---- Operations ----
+-
      /// Unary operation: `-x`, `.not. x`, `+x`
      UnaryOp {
          op: UnaryOp,
      // ---- Calls and subscripts ----
      // Note: A(I) is ambiguous — could be array access, function call, or substring.
      // The parser produces FunctionCall for all of them; sema disambiguates.
+-
      /// Function call or array access: `sin(x)`, `a(i,j)`, `s(1:5)`
      FunctionCall {
          callee: Box<SpannedExpr>,
      },
      // ---- Array constructors ----
+-
      /// Array constructor: `[1, 2, 3]` or `(/ 1, 2, 3 /)`
      ArrayConstructor {
 -        type_spec: Option<String>,  // [integer :: 1, 2, 3]
 +        type_spec: Option<String>, // [integer :: 1, 2, 3]
          values: Vec<AcValue>,
      },
      // ---- Parenthesized ----
+-
      /// Parenthesized expression: `(x + y)`
 -    ParenExpr {
 -        inner: Box<SpannedExpr>,
 -    },
 +    ParenExpr { inner: Box<SpannedExpr> },
+ }
  /// An expression with source location.
              Expr::RealLiteral { text, .. } => text.clone(),
              Expr::StringLiteral { value, .. } => format!("'{}'", value),
              Expr::LogicalLiteral { value, .. } => {
 -                if *value { ".true.".into() } else { ".false.".into() }
 +                if *value {
 +                    ".true.".into()
 +                } else {
 +                    ".false.".into()
 +                }
+             }
              Expr::ComplexLiteral { real, imag } => {
                  format!("({}, {})", real.to_sexpr(), imag.to_sexpr())
                  format!("({} {} {})", left.to_sexpr(), op, right.to_sexpr())
+             }
              Expr::FunctionCall { callee, args } => {
 -                let args_str: Vec<String> = args.iter().map(|a| {
 -                    if let Some(kw) = &a.keyword {
 -                        format!("{}={}", kw, a.value.to_sexpr())
 -                    } else {
 -                        a.value.to_sexpr()
 -                    }
 -                }).collect();
 +                let args_str: Vec<String> = args
 +                    .iter()
 +                    .map(|a| {
 +                        if let Some(kw) = &a.keyword {
 +                            format!("{}={}", kw, a.value.to_sexpr())
 +                        } else {
 +                            a.value.to_sexpr()
 +                        }
 +                    })
 +                    .collect();
                  format!("{}({})", callee.to_sexpr(), args_str.join(", "))
+             }
              Expr::ArrayConstructor { values, type_spec } => {
 -                let vals: Vec<String> = values.iter().map(|v| match v {
 -                    AcValue::Expr(e) => e.to_sexpr(),
 -                    AcValue::ImpliedDo(ido) => {
 -                        let vals: Vec<String> = ido.values.iter().map(|v| match v {
 -                            AcValue::Expr(e) => e.to_sexpr(),
 -                            AcValue::ImpliedDo(_) => "(nested-implied-do)".into(),
 -                        }).collect();
 -                        let step_str = ido.step.as_ref().map_or(String::new(), |s| format!(", {}", s.to_sexpr()));
 -                        format!("({}, {}={}, {}{})", vals.join(", "), ido.var, ido.start.to_sexpr(), ido.end.to_sexpr(), step_str)
 -                    }
 -                }).collect();
 +                let vals: Vec<String> = values
 +                    .iter()
 +                    .map(|v| match v {
 +                        AcValue::Expr(e) => e.to_sexpr(),
 +                        AcValue::ImpliedDo(ido) => {
 +                            let vals: Vec<String> = ido
 +                                .values
 +                                .iter()
 +                                .map(|v| match v {
 +                                    AcValue::Expr(e) => e.to_sexpr(),
 +                                    AcValue::ImpliedDo(_) => "(nested-implied-do)".into(),
 +                                })
 +                                .collect();
 +                            let step_str = ido
 +                                .step
 +                                .as_ref()
 +                                .map_or(String::new(), |s| format!(", {}", s.to_sexpr()));
 +                            format!(
 +                                "({}, {}={}, {}{})",
 +                                vals.join(", "),
 +                                ido.var,
 +                                ido.start.to_sexpr(),
 +                                ido.end.to_sexpr(),
 +                                step_str
 +                            )
 +                        }
 +                    })
 +                    .collect();
                  if let Some(ts) = type_spec {
                      format!("[{} :: {}]", ts, vals.join(", "))
                  } else {
  /// Unary operators.
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum UnaryOp {
 -    Plus,       // +
 -    Minus,      // -
 -    Not,        // .not.
 +    Plus,            // +
 +    Minus,           // -
 +    Not,             // .not.
      Defined(String), // .myop.
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum BinaryOp {
      // Arithmetic
 -    Add,        // +
 -    Sub,        // -
 -    Mul,        // *
 -    Div,        // /
 -    Pow,        // **
 +    Add, // +
 +    Sub, // -
 +    Mul, // *
 +    Div, // /
 +    Pow, // **
      // String
 -    Concat,     // //
 +    Concat, // //
      // Comparison
 -    Eq,         // == or .eq.
 -    Ne,         // /= or .ne.
 -    Lt,         // < or .lt.
 -    Le,         // <= or .le.
 -    Gt,         // > or .gt.
 -    Ge,         // >= or .ge.
 +    Eq, // == or .eq.
 +    Ne, // /= or .ne.
 +    Lt, // < or .lt.
 +    Le, // <= or .le.
 +    Gt, // > or .gt.
 +    Ge, // >= or .ge.
      // Logical
 -    And,        // .and.
 -    Or,         // .or.
 -    Eqv,        // .eqv.
 -    Neqv,       // .neqv.
 +    And,  // .and.
 +    Or,   // .or.
 +    Eqv,  // .eqv.
 +    Neqv, // .neqv.
      // User-defined
      Defined(String), // .myop.

src/ast/mod.rsmodified

9 lines changed — click to load

  //! program units, and all Fortran constructs. Every node
  //! carries a Span for source location tracking.
 -pub mod expr;
  pub mod decl;
 +pub mod expr;
  pub mod stmt;
  pub mod unit;

src/ast/stmt.rsmodified

229 lines changed — click to load

  //!
  //! Control flow, assignments, calls, and all executable Fortran statements.
 -use super::Spanned;
 -use super::expr::SpannedExpr;
  use super::decl::SpannedDecl;
 +use super::expr::SpannedExpr;
 +use super::Spanned;
  /// A spanned statement.
  pub type SpannedStmt = Spanned<Stmt>;
  #[allow(clippy::enum_variant_names)]
  pub enum Stmt {
      // ---- Assignment ----
 -    Assignment { target: SpannedExpr, value: SpannedExpr },
 -    PointerAssignment { target: SpannedExpr, value: SpannedExpr },
 +    Assignment {
 +        target: SpannedExpr,
 +        value: SpannedExpr,
 +    },
 +    PointerAssignment {
 +        target: SpannedExpr,
 +        value: SpannedExpr,
 +    },
      // ---- IF ----
      IfConstruct {
          else_ifs: Vec<(SpannedExpr, Vec<SpannedStmt>)>,
          else_body: Option<Vec<SpannedStmt>>,
      },
 -    IfStmt { condition: SpannedExpr, action: Box<SpannedStmt> },
 +    IfStmt {
 +        condition: SpannedExpr,
 +        action: Box<SpannedStmt>,
 +    },
      // ---- DO loops ----
      DoLoop {
          body: Vec<SpannedStmt>,
          elsewhere: Vec<(Option<SpannedExpr>, Vec<SpannedStmt>)>,
      },
 -    WhereStmt { mask: SpannedExpr, stmt: Box<SpannedStmt> },
 +    WhereStmt {
 +        mask: SpannedExpr,
 +        stmt: Box<SpannedStmt>,
 +    },
      ForallConstruct {
          name: Option<String>,
          specs: Vec<ForallSpec>,
          mask: Option<SpannedExpr>,
          body: Vec<SpannedStmt>,
      },
 -    ForallStmt { specs: Vec<ForallSpec>, mask: Option<SpannedExpr>, stmt: Box<SpannedStmt> },
 +    ForallStmt {
 +        specs: Vec<ForallSpec>,
 +        mask: Option<SpannedExpr>,
 +        stmt: Box<SpannedStmt>,
 +    },
      // ---- BLOCK / ASSOCIATE ----
      Block {
          decls: Vec<super::decl::SpannedDecl>,
          body: Vec<SpannedStmt>,
      },
 -    Associate { name: Option<String>, assocs: Vec<(String, SpannedExpr)>, body: Vec<SpannedStmt> },
 +    Associate {
 +        name: Option<String>,
 +        assocs: Vec<(String, SpannedExpr)>,
 +        body: Vec<SpannedStmt>,
 +    },
      // ---- Branch/transfer ----
 -    Exit { name: Option<String> },
 -    Cycle { name: Option<String> },
 -    Stop { code: Option<SpannedExpr>, quiet: bool },
 -    ErrorStop { code: Option<SpannedExpr>, quiet: bool },
 -    Return { value: Option<SpannedExpr> },
 -    Goto { label: u64 },
 -    ComputedGoto { labels: Vec<u64>, selector: SpannedExpr },
 -    ArithmeticIf { expr: SpannedExpr, neg: u64, zero: u64, pos: u64 },
 +    Exit {
 +        name: Option<String>,
 +    },
 +    Cycle {
 +        name: Option<String>,
 +    },
 +    Stop {
 +        code: Option<SpannedExpr>,
 +        quiet: bool,
 +    },
 +    ErrorStop {
 +        code: Option<SpannedExpr>,
 +        quiet: bool,
 +    },
 +    Return {
 +        value: Option<SpannedExpr>,
 +    },
 +    Goto {
 +        label: u64,
 +    },
 +    ComputedGoto {
 +        labels: Vec<u64>,
 +        selector: SpannedExpr,
 +    },
 +    ArithmeticIf {
 +        expr: SpannedExpr,
 +        neg: u64,
 +        zero: u64,
 +        pos: u64,
 +    },
      /// Statement label on any executable statement: `10 i = i + 1`.
      /// The parser emits this when it sees an integer literal at statement start.
 -    Labeled { label: u64, stmt: Box<SpannedStmt> },
 +    Labeled {
 +        label: u64,
 +        stmt: Box<SpannedStmt>,
 +    },
      // ---- I/O ----
 -    Write { controls: Vec<IoControl>, items: Vec<SpannedExpr> },
 -    Read { controls: Vec<IoControl>, items: Vec<SpannedExpr> },
 -    Open { specs: Vec<IoControl> },
 -    Close { specs: Vec<IoControl> },
 -    Inquire { specs: Vec<IoControl>, items: Vec<SpannedExpr> },
 -    Rewind { specs: Vec<IoControl> },
 -    Backspace { specs: Vec<IoControl> },
 -    Endfile { specs: Vec<IoControl> },
 -    Flush { specs: Vec<IoControl> },
 -    Wait { specs: Vec<IoControl> },
 +    Write {
 +        controls: Vec<IoControl>,
 +        items: Vec<SpannedExpr>,
 +    },
 +    Read {
 +        controls: Vec<IoControl>,
 +        items: Vec<SpannedExpr>,
 +    },
 +    Open {
 +        specs: Vec<IoControl>,
 +    },
 +    Close {
 +        specs: Vec<IoControl>,
 +    },
 +    Inquire {
 +        specs: Vec<IoControl>,
 +        items: Vec<SpannedExpr>,
 +    },
 +    Rewind {
 +        specs: Vec<IoControl>,
 +    },
 +    Backspace {
 +        specs: Vec<IoControl>,
 +    },
 +    Endfile {
 +        specs: Vec<IoControl>,
 +    },
 +    Flush {
 +        specs: Vec<IoControl>,
 +    },
 +    Wait {
 +        specs: Vec<IoControl>,
 +    },
      // ---- Memory ----
 -    Allocate { items: Vec<SpannedExpr>, opts: Vec<IoControl> },
 -    Deallocate { items: Vec<SpannedExpr>, opts: Vec<IoControl> },
 -    Nullify { items: Vec<SpannedExpr> },
 +    Allocate {
 +        items: Vec<SpannedExpr>,
 +        opts: Vec<IoControl>,
 +    },
 +    Deallocate {
 +        items: Vec<SpannedExpr>,
 +        opts: Vec<IoControl>,
 +    },
 +    Nullify {
 +        items: Vec<SpannedExpr>,
 +    },
      // ---- Other executable ----
 -    Continue { label: Option<u64> },
 -    Call { callee: SpannedExpr, args: Vec<crate::ast::expr::Argument> },
 -    Print { format: SpannedExpr, items: Vec<SpannedExpr> },
 -    Namelist { groups: Vec<(String, Vec<String>)> },
 +    Continue {
 +        label: Option<u64>,
 +    },
 +    Call {
 +        callee: SpannedExpr,
 +        args: Vec<crate::ast::expr::Argument>,
 +    },
 +    Print {
 +        format: SpannedExpr,
 +        items: Vec<SpannedExpr>,
 +    },
 +    Namelist {
 +        groups: Vec<(String, Vec<String>)>,
 +    },
      // ---- Declaration (embedded in statement context) ----
      Declaration(SpannedDecl),
  #[derive(Debug, Clone, PartialEq)]
  pub enum TypeGuard {
      /// TYPE IS (type_name) — exact type match.
 -    TypeIs { type_name: String, body: Vec<SpannedStmt> },
 +    TypeIs {
 +        type_name: String,
 +        body: Vec<SpannedStmt>,
 +    },
      /// CLASS IS (type_name) — matches type or any extension.
 -    ClassIs { type_name: String, body: Vec<SpannedStmt> },
 +    ClassIs {
 +        type_name: String,
 +        body: Vec<SpannedStmt>,
 +    },
      /// CLASS DEFAULT — fallback.
      ClassDefault { body: Vec<SpannedStmt> },
+ }
  #[derive(Debug, Clone, PartialEq)]
  pub enum CaseSelector {
      Value(SpannedExpr),
 -    Range { low: Option<SpannedExpr>, high: Option<SpannedExpr> },
 +    Range {
 +        low: Option<SpannedExpr>,
 +        high: Option<SpannedExpr>,
 +    },
      Default,
+ }

src/ast/unit.rsmodified

22 lines changed — click to load

  //! Top-level compilation units: programs, modules, submodules,
  //! subroutines, functions, block data, and interface blocks.
 -use super::Spanned;
  use super::decl::{SpannedDecl, TypeSpec};
  use super::stmt::SpannedStmt;
 +use super::Spanned;
  /// A spanned program unit.
  pub type SpannedUnit = Spanned<ProgramUnit>;
  /// IMPORT statement.
  #[derive(Debug, Clone, PartialEq)]
  pub enum ImportStmt {
 -    Default(Vec<String>),    // import :: name1, name2
 -    All,                      // import, all
 -    None,                     // import, none
 -    Only(Vec<String>),        // import, only: name1, name2
 +    Default(Vec<String>), // import :: name1, name2
 +    All,                  // import, all
 +    None,                 // import, none
 +    Only(Vec<String>),    // import, only: name1, name2
+ }

src/codegen/linearscan.rsmodified

334 lines changed — click to load

  //! Callee-saved registers (x19-x28, d8-d15) are tracked — if used, the function
  //! prologue/epilogue must save/restore them.
 -use std::collections::{HashMap, HashSet};
 -use super::mir::*;
  use super::liveness::compute_liveness;
 +use super::mir::*;
 +use std::collections::{HashMap, HashSet};
  /// GP registers available for allocation (excludes x18, x29, x30, x31/sp).
  /// Ordered: caller-saved first (prefer these to avoid save/restore overhead),
  /// of pressure and guarantees reloads never clash.
  const GP_ALLOC_ORDER: [u8; 22] = [
      // Caller-saved (temporary, no save needed)
 -    12, 13, 14, 15,              // x12-x15
 -    0, 1, 2, 3, 4, 5, 6, 7,      // x0-x7 (args, but available between calls)
 +    12, 13, 14, 15, // x12-x15
 +    0, 1, 2, 3, 4, 5, 6, 7, // x0-x7 (args, but available between calls)
      // Callee-saved (must save/restore if used)
 , 20, 21, 22, 23, 24, 25, 26, 27, 28,
  ];
  /// d29, d30, d31 are reserved exclusively as spill reload scratch.
  const FP_ALLOC_ORDER: [u8; 29] = [
      // Caller-saved
 -    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
 -    0, 1, 2, 3, 4, 5, 6, 7,
 +    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 0, 1, 2, 3, 4, 5, 6, 7,
      // Callee-saved
 , 9, 10, 11, 12, 13, 14, 15,
  ];
          let reg_opt = if interval.crosses_call {
              // Must use callee-saved. Find one in the free list.
 -            let callee_range = if is_fp { &FP_CALLEE_SAVED } else { &GP_CALLEE_SAVED };
 +            let callee_range = if is_fp {
 +                &FP_CALLEE_SAVED
 +            } else {
 +                &GP_CALLEE_SAVED
 +            };
              let idx = free.iter().position(|r| callee_range.contains(r));
              idx.map(|i| free.remove(i))
          } else if let Some(hint) = interval.hint {
          _ => 200,
      });
 -    AllocResult { assignments, spills, callee_saved_used: callee_saved }
 +    AllocResult {
 +        assignments,
 +        spills,
 +        callee_saved_used: callee_saved,
 +    }
+ }
  /// Apply allocation result: rewrite VReg operands to PhysReg, insert spill code.
  /// For spilled operands, borrows a temporarily-free register from the allocation
  /// pool rather than using dedicated scratch registers. This avoids wasting
  /// registers in the pool and follows standard linear scan practice.
 -pub fn apply_allocation(mf: &mut MachineFunction, result: &AllocResult, liveness: &super::liveness::LivenessResult) {
 -    let vreg_classes: HashMap<VRegId, RegClass> = mf.vregs.iter()
 -        .map(|v| (v.id, v.class))
 -        .collect();
 +pub fn apply_allocation(
 +    mf: &mut MachineFunction,
 +    result: &AllocResult,
 +    liveness: &super::liveness::LivenessResult,
 +) {
 +    let vreg_classes: HashMap<VRegId, RegClass> =
 +        mf.vregs.iter().map(|v| (v.id, v.class)).collect();
      // Build interval lookup: for each vreg, its live range.
 -    let intervals: HashMap<VRegId, (u32, u32)> = liveness.intervals.iter()
 +    let intervals: HashMap<VRegId, (u32, u32)> = liveness
 +        .intervals
 +        .iter()
          .map(|i| (i.vreg, (i.start, i.end)))
          .collect();
              // index, so their order is load-bearing.
              let mut gp_temps: Vec<u8> = Vec::new();
              let mut fp_temps: Vec<u8> = Vec::new();
 -            let mut sorted_assignments: Vec<(VRegId, PhysReg)> = result.assignments
 -                .iter().map(|(&v, &p)| (v, p)).collect();
 +            let mut sorted_assignments: Vec<(VRegId, PhysReg)> =
 +                result.assignments.iter().map(|(&v, &p)| (v, p)).collect();
              sorted_assignments.sort_by_key(|(v, _)| v.0);
              for (vreg, phys) in &sorted_assignments {
                  if let Some(&(start, end)) = intervals.get(vreg) {
+                 }
+             }
              // Also include the dedicated fallback scratches in case no free regs found.
 -            for &s in &GP_SPILL_SCRATCH { if !gp_temps.contains(&s) { gp_temps.push(s); } }
 -            for &s in &FP_SPILL_SCRATCH { if !fp_temps.contains(&s) { fp_temps.push(s); } }
 +            for &s in &GP_SPILL_SCRATCH {
 +                if !gp_temps.contains(&s) {
 +                    gp_temps.push(s);
 +                }
 +            }
 +            for &s in &FP_SPILL_SCRATCH {
 +                if !fp_temps.contains(&s) {
 +                    fp_temps.push(s);
 +                }
 +            }
              // For spilled vregs used as inputs: borrow a temp register.
              let mut loads = Vec::new();
                  if let MachineOperand::VReg(vid) = op {
                      if let Some(&offset) = result.spills.get(vid) {
                          let class = vreg_classes.get(vid).copied().unwrap_or(RegClass::Gp64);
 -                        let (temp_reg, load_op) = if matches!(class, RegClass::Fp32 | RegClass::Fp64) {
 -                            let r = fp_temps.get(fp_temp_idx).copied().unwrap_or(FP_SPILL_SCRATCH[0]);
 -                            fp_temp_idx += 1;
 -                            let phys = if matches!(class, RegClass::Fp32) { PhysReg::Fp32(r) } else { PhysReg::Fp(r) };
 -                            (phys, ArmOpcode::LdrFpImm)
 -                        } else {
 -                            let r = gp_temps.get(gp_temp_idx).copied().unwrap_or(GP_SPILL_SCRATCH[0]);
 -                            gp_temp_idx += 1;
 -                            let phys = if matches!(class, RegClass::Gp32) { PhysReg::Gp32(r) } else { PhysReg::Gp(r) };
 -                            (phys, ArmOpcode::LdrImm)
 -                        };
 +                        let (temp_reg, load_op) =
 +                            if matches!(class, RegClass::Fp32 | RegClass::Fp64) {
 +                                let r = fp_temps
 +                                    .get(fp_temp_idx)
 +                                    .copied()
 +                                    .unwrap_or(FP_SPILL_SCRATCH[0]);
 +                                fp_temp_idx += 1;
 +                                let phys = if matches!(class, RegClass::Fp32) {
 +                                    PhysReg::Fp32(r)
 +                                } else {
 +                                    PhysReg::Fp(r)
 +                                };
 +                                (phys, ArmOpcode::LdrFpImm)
 +                            } else {
 +                                let r = gp_temps
 +                                    .get(gp_temp_idx)
 +                                    .copied()
 +                                    .unwrap_or(GP_SPILL_SCRATCH[0]);
 +                                gp_temp_idx += 1;
 +                                let phys = if matches!(class, RegClass::Gp32) {
 +                                    PhysReg::Gp32(r)
 +                                } else {
 +                                    PhysReg::Gp(r)
 +                                };
 +                                (phys, ArmOpcode::LdrImm)
 +                            };
                          loads.push((i, temp_reg, load_op, offset));
+                     }
+                 }
+             }
              for (op_idx, scratch, load_op, offset) in &loads {
 -                if *op_idx == 0 && inst.def.as_ref().map(|d| result.spills.contains_key(d)).unwrap_or(false) {
 +                if *op_idx == 0
 +                    && inst
 +                        .def
 +                        .as_ref()
 +                        .map(|d| result.spills.contains_key(d))
 +                        .unwrap_or(false)
 +                {
                      continue;
+                 }
                  new_insts.push(MachineInst {
                  if let Some(&offset) = result.spills.get(def_vid) {
                      let class = vreg_classes.get(def_vid).copied().unwrap_or(RegClass::Gp64);
                      let temp_reg = if matches!(class, RegClass::Fp32 | RegClass::Fp64) {
 -                        let r = fp_temps.get(def_temp_idx).copied().unwrap_or(FP_SPILL_SCRATCH[0]);
 -                        if matches!(class, RegClass::Fp32) { PhysReg::Fp32(r) } else { PhysReg::Fp(r) }
 +                        let r = fp_temps
 +                            .get(def_temp_idx)
 +                            .copied()
 +                            .unwrap_or(FP_SPILL_SCRATCH[0]);
 +                        if matches!(class, RegClass::Fp32) {
 +                            PhysReg::Fp32(r)
 +                        } else {
 +                            PhysReg::Fp(r)
 +                        }
                      } else {
 -                        let r = gp_temps.get(def_temp_idx).copied().unwrap_or(GP_SPILL_SCRATCH[0]);
 -                        if matches!(class, RegClass::Gp32) { PhysReg::Gp32(r) } else { PhysReg::Gp(r) }
 +                        let r = gp_temps
 +                            .get(def_temp_idx)
 +                            .copied()
 +                            .unwrap_or(GP_SPILL_SCRATCH[0]);
 +                        if matches!(class, RegClass::Gp32) {
 +                            PhysReg::Gp32(r)
 +                        } else {
 +                            PhysReg::Gp(r)
 +                        }
                      };
                      let scratch = temp_reg;
                      // Replace def operand with scratch.
+                         }
+                     }
                      Some((scratch, offset, class))
 -                } else { None }
 -            } else { None };
 +                } else {
 +                    None
 +                }
 +            } else {
 +                None
 +            };
              rewritten.def = None;
              new_insts.push(rewritten);
      // Insert saves at the start of the entry block (after prologue setup).
      // Find the insertion point: after the STP + ADD (prologue) instructions.
 -    let prologue_end = mf.blocks[0].insts.iter().position(|i| {
 -        // The prologue is StpPre followed by AddImm. Insert after those.
 -        !matches!(i.opcode, ArmOpcode::StpPre | ArmOpcode::AddImm)
 -    }).unwrap_or(0);
 +    let prologue_end = mf.blocks[0]
 +        .insts
 +        .iter()
 +        .position(|i| {
 +            // The prologue is StpPre followed by AddImm. Insert after those.
 +            !matches!(i.opcode, ArmOpcode::StpPre | ArmOpcode::AddImm)
 +        })
 +        .unwrap_or(0);
      // Emit saves, pairing consecutive same-class registers into STP.
      // save_slots are ordered by increasing register number; slots are
  /// STP Xt1, Xt2, [Xn, #off] → Xt1 at off, Xt2 at off+8.
  /// We pair as: STP slots[i+1].reg, slots[i].reg, [FP, #slots[i+1].offset]
  /// because slots[i+1] has the lower (more negative) offset.
 -fn emit_callee_store_pairs(
 -    save_slots: &[(PhysReg, i32)],
 -    restore: bool,
 -) -> Vec<MachineInst> {
 +fn emit_callee_store_pairs(save_slots: &[(PhysReg, i32)], restore: bool) -> Vec<MachineInst> {
      let mut result = Vec::new();
      let mut i = 0;
      while i < save_slots.len() {
              // STP offset must fit in 7-bit signed × 8: range -512..504.
              let in_range = (-512..=504).contains(&off2);
              if same_class && adjacent && in_range {
 -                let opcode = if restore { ArmOpcode::LdpOffset } else { ArmOpcode::StpOffset };
 +                let opcode = if restore {
 +                    ArmOpcode::LdpOffset
 +                } else {
 +                    ArmOpcode::StpOffset
 +                };
                  let (low_reg, high_reg) = (reg2, reg1);
                  result.push(MachineInst {
                      opcode,
          // Emit individual STR/LDR.
          let (op, is_fp) = match reg1 {
              PhysReg::Fp(_) | PhysReg::Fp32(_) => {
 -                if restore { (ArmOpcode::LdrFpImm, true) } else { (ArmOpcode::StrFpImm, true) }
 +                if restore {
 +                    (ArmOpcode::LdrFpImm, true)
 +                } else {
 +                    (ArmOpcode::StrFpImm, true)
 +                }
+             }
              _ => {
 -                if restore { (ArmOpcode::LdrImm, false) } else { (ArmOpcode::StrImm, false) }
 +                if restore {
 +                    (ArmOpcode::LdrImm, false)
 +                } else {
 +                    (ArmOpcode::StrImm, false)
 +                }
+             }
          };
          let _ = is_fp;
                  MachineOperand::PhysReg(PhysReg::FP),
                  MachineOperand::Imm(off1 as i64),
              ],
 -            def: if restore { Some(match reg1 { PhysReg::Gp(n) | PhysReg::Gp32(n) => crate::codegen::mir::VRegId(n.into()), PhysReg::Fp(n) | PhysReg::Fp32(n) => crate::codegen::mir::VRegId(n.into()), _ => crate::codegen::mir::VRegId(0) }) } else { None },
 +            def: if restore {
 +                Some(match reg1 {
 +                    PhysReg::Gp(n) | PhysReg::Gp32(n) => crate::codegen::mir::VRegId(n.into()),
 +                    PhysReg::Fp(n) | PhysReg::Fp32(n) => crate::codegen::mir::VRegId(n.into()),
 +                    _ => crate::codegen::mir::VRegId(0),
 +                })
 +            } else {
 +                None
 +            },
          });
          i += 1;
+     }
  fn spill_scratch(class: RegClass, idx: usize) -> (PhysReg, ArmOpcode) {
      match class {
          RegClass::Fp64 => (PhysReg::Fp(FP_SPILL_SCRATCH[idx % 3]), ArmOpcode::LdrFpImm),
 -        RegClass::Fp32 => (PhysReg::Fp32(FP_SPILL_SCRATCH[idx % 3]), ArmOpcode::LdrFpImm),
 +        RegClass::Fp32 => (
 +            PhysReg::Fp32(FP_SPILL_SCRATCH[idx % 3]),
 +            ArmOpcode::LdrFpImm,
 +        ),
          RegClass::Gp32 => (PhysReg::Gp32(GP_SPILL_SCRATCH[idx % 3]), ArmOpcode::LdrImm),
          RegClass::Gp64 => (PhysReg::Gp(GP_SPILL_SCRATCH[idx % 3]), ArmOpcode::LdrImm),
+     }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::*;
 -    use crate::ir::inst::*;
 -    use crate::ir::builder::FuncBuilder;
      use crate::codegen::isel::select_function;
 +    use crate::ir::builder::FuncBuilder;
 +    use crate::ir::inst::*;
 +    use crate::ir::types::*;
      #[test]
      fn linear_scan_assigns_registers() {
          let mut mf = select_function(&func);
          let result = linear_scan(&mut mf);
          // Should have assignments for the vregs.
 -        assert!(!result.assignments.is_empty(), "should have register assignments");
 +        assert!(
 +            !result.assignments.is_empty(),
 +            "should have register assignments"
 +        );
          // No spills needed for 3 vregs.
 -        assert!(result.spills.is_empty(), "should not spill with only 3 vregs");
 +        assert!(
 +            result.spills.is_empty(),
 +            "should not spill with only 3 vregs"
 +        );
+     }
      #[test]
          });
          assert_eq!(mf.blocks[0].insts.len(), 2);
          coalesce_moves(&mut mf);
 -        assert_eq!(mf.blocks[0].insts.len(), 1, "self-move should be eliminated");
 +        assert_eq!(
 +            mf.blocks[0].insts.len(),
 +            1,
 +            "self-move should be eliminated"
 +        );
+     }
+ }

src/codegen/liveness.rsmodified

140 lines changed — click to load

  //! Computes live intervals for each virtual register using backward
  //! dataflow. Used by the linear scan register allocator.
 -use std::collections::{HashMap, BTreeSet};
  use super::mir::*;
 +use std::collections::{BTreeSet, HashMap};
  /// A live interval: the range of instruction positions where a vreg is live.
  #[derive(Debug, Clone)]
  pub struct LiveInterval {
      pub vreg: VRegId,
      pub class: RegClass,
 -    pub start: u32,   // first instruction position (definition)
 -    pub end: u32,     // last instruction position (final use)
 +    pub start: u32,         // first instruction position (definition)
 +    pub end: u32,           // last instruction position (final use)
      pub crosses_call: bool, // true if a BL instruction falls within [start, end]
      /// Preferred physical register (hint). If set, the allocator tries this register first.
      /// Used to avoid unnecessary moves (e.g., arg values prefer xN, return values prefer x0).
          // Vregs live-in to this block: extend their interval to block start.
          if let Some(lin) = live_in.get(&block.id) {
              for &vreg in lin {
 -                ends.entry(vreg).and_modify(|e| *e = (*e).max(b_end)).or_insert(b_end);
 -                starts.entry(vreg).and_modify(|s| *s = (*s).min(b_start)).or_insert(b_start);
 +                ends.entry(vreg)
 +                    .and_modify(|e| *e = (*e).max(b_end))
 +                    .or_insert(b_end);
 +                starts
 +                    .entry(vreg)
 +                    .and_modify(|s| *s = (*s).min(b_start))
 +                    .or_insert(b_start);
+             }
+         }
          // Vregs live-out of this block: extend their interval to block end.
          if let Some(lout) = live_out.get(&block.id) {
              for &vreg in lout {
 -                ends.entry(vreg).and_modify(|e| *e = (*e).max(b_end)).or_insert(b_end);
 -                starts.entry(vreg).and_modify(|s| *s = (*s).min(b_start)).or_insert(b_start);
 +                ends.entry(vreg)
 +                    .and_modify(|e| *e = (*e).max(b_end))
 +                    .or_insert(b_end);
 +                starts
 +                    .entry(vreg)
 +                    .and_modify(|s| *s = (*s).min(b_start))
 +                    .or_insert(b_start);
+             }
+         }
          for (i, inst) in block.insts.iter().enumerate() {
              let p = position_map[&(block.id, i)];
              if let Some(def) = &inst.def {
 -                starts.entry(*def).and_modify(|s| *s = (*s).min(p)).or_insert(p);
 -                ends.entry(*def).and_modify(|e| *e = (*e).max(p)).or_insert(p);
 +                starts
 +                    .entry(*def)
 +                    .and_modify(|s| *s = (*s).min(p))
 +                    .or_insert(p);
 +                ends.entry(*def)
 +                    .and_modify(|e| *e = (*e).max(p))
 +                    .or_insert(p);
+             }
              for op in &inst.operands {
                  if let MachineOperand::VReg(vid) = op {
 -                    ends.entry(*vid).and_modify(|e| *e = (*e).max(p)).or_insert(p);
 -                    starts.entry(*vid).and_modify(|s| *s = (*s).min(p)).or_insert(p);
 +                    ends.entry(*vid)
 +                        .and_modify(|e| *e = (*e).max(p))
 +                        .or_insert(p);
 +                    starts
 +                        .entry(*vid)
 +                        .and_modify(|s| *s = (*s).min(p))
 +                        .or_insert(p);
+                 }
+             }
+         }
      call_positions.sort();
      // Build intervals.
 -    let vreg_classes: HashMap<VRegId, RegClass> = mf.vregs.iter()
 -        .map(|v| (v.id, v.class))
 -        .collect();
 +    let vreg_classes: HashMap<VRegId, RegClass> =
 +        mf.vregs.iter().map(|v| (v.id, v.class)).collect();
 -    let mut intervals: Vec<LiveInterval> = starts.iter()
 +    let mut intervals: Vec<LiveInterval> = starts
 +        .iter()
          .filter_map(|(&vreg, &start)| {
              let end = ends.get(&vreg).copied()?;
              let class = vreg_classes.get(&vreg).copied().unwrap_or(RegClass::Gp64);
              // Check if any call falls within [start, end].
              let crosses_call = call_positions.iter().any(|&cp| cp > start && cp < end);
 -            Some(LiveInterval { vreg, class, start, end, crosses_call, hint: None })
 +            Some(LiveInterval {
 +                vreg,
 +                class,
 +                start,
 +                end,
 +                crosses_call,
 +                hint: None,
 +            })
          })
          .collect();
      // exposed clearly when mem2reg started perturbing vreg counts.
      intervals.sort_by_key(|i| (i.start, i.vreg.0));
 -    LivenessResult { intervals, num_positions }
 +    LivenessResult {
 +        intervals,
 +        num_positions,
 +    }
+ }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::*;
 -    use crate::ir::inst::*;
 -    use crate::ir::builder::FuncBuilder;
      use crate::codegen::isel::select_function;
 +    use crate::ir::builder::FuncBuilder;
 +    use crate::ir::inst::*;
 +    use crate::ir::types::*;
      #[test]
      fn liveness_simple_function() {
          let mf = select_function(&func);
          let result = compute_liveness(&mf);
          // Should have some Fp64 intervals.
 -        assert!(result.intervals.iter().any(|i| i.class == RegClass::Fp64),
 -            "should have Fp64 intervals");
 +        assert!(
 +            result.intervals.iter().any(|i| i.class == RegClass::Fp64),
 +            "should have Fp64 intervals"
 +        );
+     }
      #[test]

src/codegen/mod.rsmodified

15 lines changed — click to load

  //! Instruction selection, register allocation, stack frame layout,
  //! and emission of machine instructions for the afs-as assembler.
 -pub mod mir;
 +pub mod emit;
  pub mod isel;
 -pub mod liveness;
 -pub mod regalloc;
  pub mod linearscan;
 -pub mod emit;
 +pub mod liveness;
 +pub mod mir;
  pub mod peephole;
 +pub mod regalloc;
  pub mod tailcall;

src/codegen/peephole.rsmodified

227 lines changed — click to load

  //! After fusion the FMUL instruction is removed and the FADD/FSUB is
  //! replaced by the three-source FMA instruction.
 -use super::mir::{MachineFunction, MachineInst, MachineOperand, ArmOpcode, VRegId};
 +use super::mir::{ArmOpcode, MachineFunction, MachineInst, MachineOperand, VRegId};
  use std::collections::HashMap;
  /// Run all peephole passes on a machine function.
      // Map: vreg defined by a fmul instruction → (block-instruction-index, precision)
      #[derive(Clone, Copy)]
 -    enum Prec { S, D }
 +    enum Prec {
 +        S,
 +        D,
 +    }
      let mut fmul_defs: HashMap<VRegId, (usize, Prec)> = HashMap::new();
      for (i, inst) in block.insts.iter().enumerate() {
              ArmOpcode::FsubD => (false, true, false),
              _ => continue,
          };
 -        if inst.operands.len() < 3 { continue; }
 +        if inst.operands.len() < 3 {
 +            continue;
 +        }
          // operands: [dest, src0, src1]
 -        let src0 = match &inst.operands[1] { MachineOperand::VReg(v) => *v, _ => continue };
 -        let src1 = match &inst.operands[2] { MachineOperand::VReg(v) => *v, _ => continue };
 +        let src0 = match &inst.operands[1] {
 +            MachineOperand::VReg(v) => *v,
 +            _ => continue,
 +        };
 +        let src1 = match &inst.operands[2] {
 +            MachineOperand::VReg(v) => *v,
 +            _ => continue,
 +        };
          // Check if src0 is a single-use fmul result.
 -        let try_fuse_src0 = fmul_defs.get(&src0)
 +        let try_fuse_src0 = fmul_defs
 +            .get(&src0)
              .filter(|_| use_count.get(&src0).copied().unwrap_or(0) == 1);
          // Check if src1 is a single-use fmul result.
          let try_fuse_src1 = if is_add {
 -            fmul_defs.get(&src1)
 +            fmul_defs
 +                .get(&src1)
                  .filter(|_| use_count.get(&src1).copied().unwrap_or(0) == 1)
          } else {
              None // fsub(c, fmul(a,b)): src0=c, src1=fmul → handled separately
              // fadd(fmul(a,b), c) → FMADD(a, b, c)
              if let Some(&(mul_idx, _)) = try_fuse_src0 {
                  let mul_inst = &block.insts[mul_idx];
 -                let n = match &mul_inst.operands[1] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let m = match &mul_inst.operands[2] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let opcode = if prec_s { ArmOpcode::FmaddS } else { ArmOpcode::FmaddD };
 -                plans.push(FusionPlan { add_idx: i, mul_idx, new_opcode: opcode, n, m, a: src1 });
 +                let n = match &mul_inst.operands[1] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let m = match &mul_inst.operands[2] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let opcode = if prec_s {
 +                    ArmOpcode::FmaddS
 +                } else {
 +                    ArmOpcode::FmaddD
 +                };
 +                plans.push(FusionPlan {
 +                    add_idx: i,
 +                    mul_idx,
 +                    new_opcode: opcode,
 +                    n,
 +                    m,
 +                    a: src1,
 +                });
              } else if let Some(&(mul_idx, _)) = try_fuse_src1 {
                  // fadd(c, fmul(a,b)) → FMADD(a, b, c)  [commuted]
                  let mul_inst = &block.insts[mul_idx];
 -                let n = match &mul_inst.operands[1] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let m = match &mul_inst.operands[2] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let opcode = if prec_s { ArmOpcode::FmaddS } else { ArmOpcode::FmaddD };
 -                plans.push(FusionPlan { add_idx: i, mul_idx, new_opcode: opcode, n, m, a: src0 });
 +                let n = match &mul_inst.operands[1] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let m = match &mul_inst.operands[2] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let opcode = if prec_s {
 +                    ArmOpcode::FmaddS
 +                } else {
 +                    ArmOpcode::FmaddD
 +                };
 +                plans.push(FusionPlan {
 +                    add_idx: i,
 +                    mul_idx,
 +                    new_opcode: opcode,
 +                    n,
 +                    m,
 +                    a: src0,
 +                });
+             }
          } else if is_sub {
              // fsub(fmul(a,b), c) → FNMSUB(a, b, c)  [result = a*b - c]
              if let Some(&(mul_idx, _)) = try_fuse_src0 {
                  let mul_inst = &block.insts[mul_idx];
 -                let n = match &mul_inst.operands[1] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let m = match &mul_inst.operands[2] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let opcode = if prec_s { ArmOpcode::FnmsubS } else { ArmOpcode::FnmsubD };
 -                plans.push(FusionPlan { add_idx: i, mul_idx, new_opcode: opcode, n, m, a: src1 });
 +                let n = match &mul_inst.operands[1] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let m = match &mul_inst.operands[2] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let opcode = if prec_s {
 +                    ArmOpcode::FnmsubS
 +                } else {
 +                    ArmOpcode::FnmsubD
 +                };
 +                plans.push(FusionPlan {
 +                    add_idx: i,
 +                    mul_idx,
 +                    new_opcode: opcode,
 +                    n,
 +                    m,
 +                    a: src1,
 +                });
+             }
              // fsub(c, fmul(a,b)) → FMSUB(a, b, c)  [result = c - a*b]
              // src0=c, src1=fmul_result
 -            let try_fuse_sub1 = fmul_defs.get(&src1)
 +            let try_fuse_sub1 = fmul_defs
 +                .get(&src1)
                  .filter(|_| use_count.get(&src1).copied().unwrap_or(0) == 1);
              if let Some(&(mul_idx, _)) = try_fuse_sub1 {
                  let mul_inst = &block.insts[mul_idx];
 -                let n = match &mul_inst.operands[1] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let m = match &mul_inst.operands[2] { MachineOperand::VReg(v) => *v, _ => continue };
 -                let opcode = if prec_s { ArmOpcode::FmsubS } else { ArmOpcode::FmsubD };
 -                plans.push(FusionPlan { add_idx: i, mul_idx, new_opcode: opcode, n, m, a: src0 });
 +                let n = match &mul_inst.operands[1] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let m = match &mul_inst.operands[2] {
 +                    MachineOperand::VReg(v) => *v,
 +                    _ => continue,
 +                };
 +                let opcode = if prec_s {
 +                    ArmOpcode::FmsubS
 +                } else {
 +                    ArmOpcode::FmsubD
 +                };
 +                plans.push(FusionPlan {
 +                    add_idx: i,
 +                    mul_idx,
 +                    new_opcode: opcode,
 +                    n,
 +                    m,
 +                    a: src0,
 +                });
+             }
+         }
+     }
 -    if plans.is_empty() { return; }
 +    if plans.is_empty() {
 +        return;
 +    }
      // Apply plans in reverse order of add_idx to keep indices stable.
      plans.sort_by(|a, b| b.add_idx.cmp(&a.add_idx));
      // Collect mul_idxs to remove.
 -    let mut remove_idxs: std::collections::HashSet<usize> = plans.iter()
 -        .map(|p| p.mul_idx)
 -        .collect();
 +    let mut remove_idxs: std::collections::HashSet<usize> =
 +        plans.iter().map(|p| p.mul_idx).collect();
      // Rewrite the block.
      let block = &mut mf.blocks[mb_idx];
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::codegen::mir::{MachineFunction, MachineBlock, MachineInst,
 -        MachineOperand, ArmOpcode, MBlockId, RegClass};
 +    use crate::codegen::mir::{
 +        ArmOpcode, MBlockId, MachineBlock, MachineFunction, MachineInst, MachineOperand, RegClass,
 +    };
      fn mf_with_insts(insts: Vec<MachineInst>) -> MachineFunction {
          let mut mf = MachineFunction::new("test".into());
              mf.new_vreg(RegClass::Fp32);
+         }
          let bid = MBlockId(0);
 -        mf.blocks = vec![MachineBlock { id: bid, label: "entry".into(), insts }];
 +        mf.blocks = vec![MachineBlock {
 +            id: bid,
 +            label: "entry".into(),
 +            insts,
 +        }];
          mf
+     }
 -    fn vreg(v: u32) -> MachineOperand { MachineOperand::VReg(VRegId(v)) }
 -    fn vid(v: u32) -> VRegId { VRegId(v) }
 +    fn vreg(v: u32) -> MachineOperand {
 +        MachineOperand::VReg(VRegId(v))
 +    }
 +    fn vid(v: u32) -> VRegId {
 +        VRegId(v)
 +    }
      /// fadd(fmul(v1, v2), v3) → fmadd(v1, v2, v3)
      #[test]

src/codegen/regalloc.rsmodified

113 lines changed — click to load

  //!
  //! This will be replaced by linear scan allocation in Sprint 21.
 -use std::collections::HashMap;
  use super::mir::*;
 +use std::collections::HashMap;
  /// Integer scratch registers (caller-saved, safe to clobber).
  const GP_SCRATCH: [u8; 3] = [9, 10, 11];
+     }
      // Build class map for quick lookup.
 -    let vreg_classes: HashMap<VRegId, RegClass> = mf.vregs.iter()
 -        .map(|v| (v.id, v.class))
 -        .collect();
 +    let vreg_classes: HashMap<VRegId, RegClass> =
 +        mf.vregs.iter().map(|v| (v.id, v.class)).collect();
      // Phase 2: rewrite each block's instructions.
      for block_idx in 0..mf.blocks.len() {
              // Replace the def operand (first operand if it matches def).
              let def_scratch = if let Some(def_vid) = def_vreg {
                  if let Some(&offset) = vreg_slots.get(&def_vid) {
 -                    let class = vreg_classes.get(&def_vid).copied().unwrap_or(RegClass::Gp64);
 +                    let class = vreg_classes
 +                        .get(&def_vid)
 +                        .copied()
 +                        .unwrap_or(RegClass::Gp64);
                      let scratch = match class {
                          RegClass::Fp64 => PhysReg::Fp(FP_SCRATCH[0]),
                          RegClass::Fp32 => PhysReg::Fp32(FP_SCRATCH[0]),
+                     }
                      Some((scratch, offset, class))
 -                } else { None }
 -            } else { None };
 +                } else {
 +                    None
 +                }
 +            } else {
 +                None
 +            };
              // Emit the rewritten instruction.
              rewritten.def = None; // physical regs don't track defs
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::*;
 -    use crate::ir::inst::*;
 -    use crate::ir::builder::FuncBuilder;
      use crate::codegen::isel::select_function;
 +    use crate::ir::builder::FuncBuilder;
 +    use crate::ir::inst::*;
 +    use crate::ir::types::*;
      #[test]
      fn regalloc_replaces_vregs() {
          for block in &mf.blocks {
              for inst in &block.insts {
                  for op in &inst.operands {
 -                    assert!(!matches!(op, MachineOperand::VReg(_)),
 -                        "vreg still present after regalloc: {:?}", inst);
 +                    assert!(
 +                        !matches!(op, MachineOperand::VReg(_)),
 +                        "vreg still present after regalloc: {:?}",
 +                        inst
 +                    );
+                 }
+             }
+         }
          let mut mf = select_function(&func);
          let before = mf.frame.size;
          regalloc_naive(&mut mf);
 -        assert!(mf.frame.size >= before, "frame should grow to accommodate spill slots");
 +        assert!(
 +            mf.frame.size >= before,
 +            "frame should grow to accommodate spill slots"
 +        );
+     }
      #[test]
          // Should use x9, x10, x11 as scratch registers.
          let uses_scratch = mf.blocks.iter().any(|b| {
              b.insts.iter().any(|i| {
 -                i.operands.iter().any(|op| matches!(op,
 -                    MachineOperand::PhysReg(PhysReg::Gp(9)) |
 -                    MachineOperand::PhysReg(PhysReg::Gp(10)) |
 -                    MachineOperand::PhysReg(PhysReg::Gp(11)) |
 -                    MachineOperand::PhysReg(PhysReg::Gp32(9)) |
 -                    MachineOperand::PhysReg(PhysReg::Gp32(10)) |
 -                    MachineOperand::PhysReg(PhysReg::Gp32(11))
 -                ))
 +                i.operands.iter().any(|op| {
 +                    matches!(
 +                        op,
 +                        MachineOperand::PhysReg(PhysReg::Gp(9))
 +                            | MachineOperand::PhysReg(PhysReg::Gp(10))
 +                            | MachineOperand::PhysReg(PhysReg::Gp(11))
 +                            | MachineOperand::PhysReg(PhysReg::Gp32(9))
 +                            | MachineOperand::PhysReg(PhysReg::Gp32(10))
 +                            | MachineOperand::PhysReg(PhysReg::Gp32(11))
 +                    )
 +                })
              })
          });
 -        assert!(uses_scratch, "should use scratch registers x9-x11 or w9-w11");
 +        assert!(
 +            uses_scratch,
 +            "should use scratch registers x9-x11 or w9-w11"
 +        );
+     }
+ }

src/codegen/tailcall.rsmodified

228 lines changed — click to load

  //! * Gate: we don't fire on non-void calls where a non-trivial result-capture
  //!   sequence remains (e.g., `MOV x1, x0`) — those are left alone.
 -use std::collections::HashSet;
  use super::mir::{ArmOpcode, MachineFunction, MachineInst, MachineOperand, PhysReg};
 +use std::collections::HashSet;
  /// Run tail call optimization on a single machine function.
  ///
  pub fn tail_call_opt(mf: &mut MachineFunction) {
      for block in &mut mf.blocks {
          let n = block.insts.len();
 -        if n < 2 { continue; }
 +        if n < 2 {
 +            continue;
 +        }
          // Epilogue is always `LdpPost; Ret` at the very end.
 -        if block.insts[n - 1].opcode != ArmOpcode::Ret { continue; }
 -        if block.insts[n - 2].opcode != ArmOpcode::LdpPost { continue; }
 +        if block.insts[n - 1].opcode != ArmOpcode::Ret {
 +            continue;
 +        }
 +        if block.insts[n - 2].opcode != ArmOpcode::LdpPost {
 +            continue;
 +        }
          let ldp_idx = n - 2;
          while bl_candidate > 0 {
              bl_candidate -= 1;
              match block.insts[bl_candidate].opcode {
 -                ArmOpcode::LdpOffset
 -                | ArmOpcode::LdrImm
 -                | ArmOpcode::LdrFpImm => {
 +                ArmOpcode::LdpOffset | ArmOpcode::LdrImm | ArmOpcode::LdrFpImm => {
                      // Callee-save restore — keep scanning backwards.
+                 }
                  ArmOpcode::Bl => {
+         }
          // Sentinel or scanned to index 0 without finding Bl.
 -        if bl_candidate == usize::MAX { continue; }
 -        if block.insts[bl_candidate].opcode != ArmOpcode::Bl { continue; }
 +        if bl_candidate == usize::MAX {
 +            continue;
 +        }
 +        if block.insts[bl_candidate].opcode != ArmOpcode::Bl {
 +            continue;
 +        }
          // SAFETY: reject TCO when any argument register (x0–x7) holds a value
          // derived from our frame pointer (e.g. a pointer to a stack-allocated
          // Extract the call target from the Bl operand.
          let label = match block.insts[bl_candidate].operands.first() {
              Some(MachineOperand::Extern(s)) => s.clone(),
 -            _ => continue,  // indirect call or unexpected operand — skip
 +            _ => continue, // indirect call or unexpected operand — skip
          };
          // Transform:
              // sub xN, x29, #imm  →  xN holds a frame-relative address.
              ArmOpcode::SubImm => {
                  if op_is_fp(inst, 1) {
 -                    if let Some(n) = op_gp(inst, 0) { tainted_regs.insert(n); }
 +                    if let Some(n) = op_gp(inst, 0) {
 +                        tainted_regs.insert(n);
 +                    }
+                 }
+             }
              // add xN, xM, xP  (GEP: propagate taint from either source)
                  if op_gp(inst, 1).is_some_and(|n| tainted_regs.contains(&n))
                      || op_gp(inst, 2).is_some_and(|n| tainted_regs.contains(&n))
+                 {
 -                    if let Some(n) = op_gp(inst, 0) { tainted_regs.insert(n); }
 +                    if let Some(n) = op_gp(inst, 0) {
 +                        tainted_regs.insert(n);
 +                    }
+                 }
+             }
              // add xN, xM, #imm  (GEP with constant offset / address arithmetic)
              ArmOpcode::AddImm => {
 -                if op_is_fp(inst, 1)
 -                    || op_gp(inst, 1).is_some_and(|n| tainted_regs.contains(&n))
 -                {
 -                    if let Some(n) = op_gp(inst, 0) { tainted_regs.insert(n); }
 +                if op_is_fp(inst, 1) || op_gp(inst, 1).is_some_and(|n| tainted_regs.contains(&n)) {
 +                    if let Some(n) = op_gp(inst, 0) {
 +                        tainted_regs.insert(n);
 +                    }
+                 }
+             }
              // mov xN, xM  (register copy — propagates taint to arg reg)
              ArmOpcode::MovReg => {
                  if op_gp(inst, 1).is_some_and(|n| tainted_regs.contains(&n)) {
 -                    if let Some(n) = op_gp(inst, 0) { tainted_regs.insert(n); }
 +                    if let Some(n) = op_gp(inst, 0) {
 +                        tainted_regs.insert(n);
 +                    }
+                 }
+             }
              // mul xN, xM, xP  (index computation in GEP; conservative)
                  if op_gp(inst, 1).is_some_and(|n| tainted_regs.contains(&n))
                      || op_gp(inst, 2).is_some_and(|n| tainted_regs.contains(&n))
+                 {
 -                    if let Some(n) = op_gp(inst, 0) { tainted_regs.insert(n); }
 +                    if let Some(n) = op_gp(inst, 0) {
 +                        tainted_regs.insert(n);
 +                    }
+                 }
+             }
              // str xN, [x29, #off] — if xN is tainted, the slot becomes tainted.
              ArmOpcode::StrImm => {
 -                if op_gp(inst, 0).is_some_and(|n| tainted_regs.contains(&n))
 -                    && op_is_fp(inst, 1)
 -                {
 -                    if let Some(off) = op_fp_offset(inst, 2) { tainted_slots.insert(off); }
 +                if op_gp(inst, 0).is_some_and(|n| tainted_regs.contains(&n)) && op_is_fp(inst, 1) {
 +                    if let Some(off) = op_fp_offset(inst, 2) {
 +                        tainted_slots.insert(off);
 +                    }
+                 }
+             }
              // ldr xN, [x29, #off] — if the slot is tainted, xN becomes tainted.
                  if op_is_fp(inst, 1) {
                      if let Some(off) = op_fp_offset(inst, 2) {
                          if tainted_slots.contains(&off) {
 -                            if let Some(n) = op_gp(inst, 0) { tainted_regs.insert(n); }
 +                            if let Some(n) = op_gp(inst, 0) {
 +                                tainted_regs.insert(n);
 +                            }
+                         }
+                     }
+                 }
      use crate::codegen::mir::*;
      fn make_block(insts: Vec<MachineInst>) -> MachineBlock {
 -        MachineBlock { label: "test".into(), insts, id: MBlockId(0) }
 +        MachineBlock {
 +            label: "test".into(),
 +            insts,
 +            id: MBlockId(0),
 +        }
+     }
      fn bl(label: &str) -> MachineInst {
+     }
      fn ret() -> MachineInst {
 -        MachineInst { opcode: ArmOpcode::Ret, operands: vec![], def: None }
 +        MachineInst {
 +            opcode: ArmOpcode::Ret,
 +            operands: vec![],
 +            def: None,
 +        }
+     }
      fn ldr_callee_restore() -> MachineInst {
      #[test]
      fn void_tail_call_no_callee_saves() {
          // Pattern: Bl; LdpPost; Ret → LdpPost; B
 -        let mut mf = build_mf(vec![
 -            vec![bl("_foo"), ldp_post(), ret()],
 -        ]);
 +        let mut mf = build_mf(vec![vec![bl("_foo"), ldp_post(), ret()]]);
          tail_call_opt(&mut mf);
          let insts = &mf.blocks[0].insts;
          // Should now be: LdpPost, B _foo
          assert_eq!(insts.len(), 2);
          assert_eq!(insts[0].opcode, ArmOpcode::LdpPost);
          assert_eq!(insts[1].opcode, ArmOpcode::B);
 -        assert_eq!(
 -            insts[1].operands[0],
 -            MachineOperand::Extern("_foo".into())
 -        );
 +        assert_eq!(insts[1].operands[0], MachineOperand::Extern("_foo".into()));
+     }
      #[test]
      fn void_tail_call_with_callee_restore() {
          // Pattern: Bl; LdrImm(restore); LdpPost; Ret → LdrImm; LdpPost; B
 -        let mut mf = build_mf(vec![
 -            vec![bl("_bar"), ldr_callee_restore(), ldp_post(), ret()],
 -        ]);
 +        let mut mf = build_mf(vec![vec![
 +            bl("_bar"),
 +            ldr_callee_restore(),
 +            ldp_post(),
 +            ret(),
 +        ]]);
          tail_call_opt(&mut mf);
          let insts = &mf.blocks[0].insts;
          assert_eq!(insts.len(), 3);
              ],
              def: None,
          };
 -        let mut mf = build_mf(vec![
 -            vec![bl("_baz"), mov_result, ldp_post(), ret()],
 -        ]);
 +        let mut mf = build_mf(vec![vec![bl("_baz"), mov_result, ldp_post(), ret()]]);
          tail_call_opt(&mut mf);
          let insts = &mf.blocks[0].insts;
          // No transformation — Bl should still be present.
 -        assert!(insts.iter().any(|i| i.opcode == ArmOpcode::Bl),
 -            "Bl should NOT be removed when result is captured in non-return register");
 -        assert!(insts.iter().any(|i| i.opcode == ArmOpcode::Ret),
 -            "Ret should still be present");
 +        assert!(
 +            insts.iter().any(|i| i.opcode == ArmOpcode::Bl),
 +            "Bl should NOT be removed when result is captured in non-return register"
 +        );
 +        assert!(
 +            insts.iter().any(|i| i.opcode == ArmOpcode::Ret),
 +            "Ret should still be present"
 +        );
+     }
      #[test]
              operands: vec![MachineOperand::BlockRef(MBlockId(1))],
              def: None,
          };
 -        let mut mf = build_mf(vec![
 -            vec![bl("_qux"), ldp_post(), b_inst],
 -        ]);
 +        let mut mf = build_mf(vec![vec![bl("_qux"), ldp_post(), b_inst]]);
          tail_call_opt(&mut mf);
          // Should still have Bl (TCO not fired because no Ret).
          assert!(mf.blocks[0].insts.iter().any(|i| i.opcode == ArmOpcode::Bl));

src/driver/dep_scan.rsmodified

159 lines changed — click to load

      for line in content.lines() {
          let trimmed = line.trim().to_lowercase();
          // Skip comments and empty lines.
 -        if trimmed.starts_with('!') || trimmed.is_empty() { continue; }
 +        if trimmed.starts_with('!') || trimmed.is_empty() {
 +            continue;
 +        }
          // MODULE <name> — but not "module procedure" or "module function"
          if let Some(rest) = trimmed.strip_prefix("module ") {
              let rest = rest.trim();
 -            if rest.starts_with("procedure") || rest.starts_with("function")
 +            if rest.starts_with("procedure")
 +                || rest.starts_with("function")
                  || rest.starts_with("subroutine")
+             {
                  continue;
              if rest.starts_with("::") {
                  rest = rest[2..].trim();
+             }
 -            if let Some(name) = rest.split(|c: char| c == ',' || c == ':' || c.is_whitespace()).next() {
 +            if let Some(name) = rest
 +                .split(|c: char| c == ',' || c == ':' || c.is_whitespace())
 +                .next()
 +            {
                  let clean = name.trim();
                  if !clean.is_empty() && clean != "only" {
                      // Skip intrinsic modules — they don't need .amod files.
      defines.sort();
      defines.dedup();
 -    Ok(FileDeps { path: path.to_path_buf(), defines, uses })
 +    Ok(FileDeps {
 +        path: path.to_path_buf(),
 +        defines,
 +        uses,
 +    })
+ }
  fn is_intrinsic_module(name: &str) -> bool {
 -    matches!(name,
 -        "iso_c_binding" | "iso_fortran_env" |
 -        "ieee_arithmetic" | "ieee_exceptions" | "ieee_features"
 +    matches!(
 +        name,
 +        "iso_c_binding"
 +            | "iso_fortran_env"
 +            | "ieee_arithmetic"
 +            | "ieee_exceptions"
 +            | "ieee_features"
+     )
+ }
          // Cycle detected — find the modules involved.
          let cycle_files: Vec<&str> = (0..n)
              .filter(|i| in_degree[*i] > 0)
 -            .map(|i| files[i].path.file_name().unwrap_or_default().to_str().unwrap_or("?"))
 +            .map(|i| {
 +                files[i]
 +                    .path
 +                    .file_name()
 +                    .unwrap_or_default()
 +                    .to_str()
 +                    .unwrap_or("?")
 +            })
              .collect();
          return Err(format!(
              "circular module dependency detected among: {}",
          let dir = std::env::temp_dir().join("dep_scan_test_1");
          std::fs::create_dir_all(&dir).unwrap();
          let f = dir.join("mod.f90");
 -        std::fs::write(&f, "module mymod\n  use other_mod\n  implicit none\nend module\n").unwrap();
 +        std::fs::write(
 +            &f,
 +            "module mymod\n  use other_mod\n  implicit none\nend module\n",
 +        )
 +        .unwrap();
          let deps = scan_file(&f).unwrap();
          assert_eq!(deps.defines, vec!["mymod"]);
          assert_eq!(deps.uses, vec!["other_mod"]);
      #[test]
      fn topo_sort_chain() {
          let files = vec![
 -            FileDeps { path: "c.f90".into(), defines: vec!["c".into()], uses: vec![] },
 -            FileDeps { path: "b.f90".into(), defines: vec!["b".into()], uses: vec!["c".into()] },
 -            FileDeps { path: "a.f90".into(), defines: vec!["a".into()], uses: vec!["b".into()] },
 +            FileDeps {
 +                path: "c.f90".into(),
 +                defines: vec!["c".into()],
 +                uses: vec![],
 +            },
 +            FileDeps {
 +                path: "b.f90".into(),
 +                defines: vec!["b".into()],
 +                uses: vec!["c".into()],
 +            },
 +            FileDeps {
 +                path: "a.f90".into(),
 +                defines: vec!["a".into()],
 +                uses: vec!["b".into()],
 +            },
          ];
          let order = resolve_compilation_order(&files).unwrap();
          // c must come before b, b before a.
      #[test]
      fn topo_sort_cycle() {
          let files = vec![
 -            FileDeps { path: "a.f90".into(), defines: vec!["a".into()], uses: vec!["b".into()] },
 -            FileDeps { path: "b.f90".into(), defines: vec!["b".into()], uses: vec!["a".into()] },
 +            FileDeps {
 +                path: "a.f90".into(),
 +                defines: vec!["a".into()],
 +                uses: vec!["b".into()],
 +            },
 +            FileDeps {
 +                path: "b.f90".into(),
 +                defines: vec!["b".into()],
 +                uses: vec!["a".into()],
 +            },
          ];
          let err = resolve_compilation_order(&files).unwrap_err();
 -        assert!(err.contains("circular"), "expected cycle error, got: {}", err);
 +        assert!(
 +            err.contains("circular"),
 +            "expected cycle error, got: {}",
 +            err
 +        );
+     }
      #[test]
      fn topo_sort_diamond() {
          let files = vec![
 -            FileDeps { path: "d.f90".into(), defines: vec!["d".into()], uses: vec![] },
 -            FileDeps { path: "b.f90".into(), defines: vec!["b".into()], uses: vec!["d".into()] },
 -            FileDeps { path: "c.f90".into(), defines: vec!["c".into()], uses: vec!["d".into()] },
 -            FileDeps { path: "a.f90".into(), defines: vec!["a".into()], uses: vec!["b".into(), "c".into()] },
 +            FileDeps {
 +                path: "d.f90".into(),
 +                defines: vec!["d".into()],
 +                uses: vec![],
 +            },
 +            FileDeps {
 +                path: "b.f90".into(),
 +                defines: vec!["b".into()],
 +                uses: vec!["d".into()],
 +            },
 +            FileDeps {
 +                path: "c.f90".into(),
 +                defines: vec!["c".into()],
 +                uses: vec!["d".into()],
 +            },
 +            FileDeps {
 +                path: "a.f90".into(),
 +                defines: vec!["a".into()],
 +                uses: vec!["b".into(), "c".into()],
 +            },
          ];
          let order = resolve_compilation_order(&files).unwrap();
          let pos_d = order.iter().position(|&i| i == 0).unwrap();

src/driver/diag.rsmodified

45 lines changed — click to load

          msg = message,
      );
 -    if let Some((gutter, line_text, caret_indent, caret_len)) =
 -        snippet_for(source, span, span_len)
 +    if let Some((gutter, line_text, caret_indent, caret_len)) = snippet_for(source, span, span_len)
+     {
          let blue = if color { "\x1b[34m" } else { "" };
 -        eprintln!("{blue}{gutter:>5} |{reset} {line}", gutter = gutter, reset = reset, blue = blue, line = line_text);
 +        eprintln!(
 +            "{blue}{gutter:>5} |{reset} {line}",
 +            gutter = gutter,
 +            reset = reset,
 +            blue = blue,
 +            line = line_text
 +        );
          let mut caret = String::new();
          for _ in 0..caret_indent {
              caret.push(' ');
          for _ in 0..caret_len.max(1) {
              caret.push('^');
+         }
 -        eprintln!("{blue}      |{reset} {col_start}{caret}{reset}", blue = blue, reset = reset, col_start = col_start, caret = caret);
 +        eprintln!(
 +            "{blue}      |{reset} {col_start}{caret}{reset}",
 +            blue = blue,
 +            reset = reset,
 +            col_start = col_start,
 +            caret = caret
 +        );
+     }
+ }
  /// Returns `(line_number, line_text, caret_indent, caret_len)`.
  /// caret_indent is in display columns assuming a tab is replaced by
  /// 4 spaces, matching how the line_text is emitted.
 -fn snippet_for(
 -    source: &str,
 -    span: Span,
 -    span_len: usize,
 -) -> Option<(u32, String, usize, usize)> {
 +fn snippet_for(source: &str, span: Span, span_len: usize) -> Option<(u32, String, usize, usize)> {
      if span.start.line == 0 {
          return None;
+     }

src/driver/mod.rsmodified

320 lines changed — click to load

  use std::process::Command;
  use std::time::SystemTime;
 -use crate::codegen::{emit, isel, linearscan, peephole};
  use crate::codegen::mir::MachineFunction;
 +use crate::codegen::{emit, isel, linearscan, peephole};
  use crate::ir::{lower, printer as ir_printer, verify};
  use crate::lexer::{detect_source_form, tokenize, SourceForm};
  use crate::parser::Parser;
              "-D" => {
                  i += 1;
                  let spec = args.get(i).ok_or("-D requires a macro name")?;
 -                opts.preprocessor_defines.push(parse_preprocessor_define(spec)?);
 +                opts.preprocessor_defines
 +                    .push(parse_preprocessor_define(spec)?);
+             }
              arg if arg.starts_with("-D") => {
                  opts.preprocessor_defines
                  opts.diagnostics_format = match val {
                      "text" => DiagnosticsFormat::Text,
                      "json" => DiagnosticsFormat::Json,
 -                    other => {
 -                        return Err(format!("unknown --diagnostics-format value: {}", other))
 -                    }
 +                    other => return Err(format!("unknown --diagnostics-format value: {}", other)),
                  };
+             }
          None => (spec, "1"),
      };
      if name.is_empty() {
 -        return Err(format!("invalid macro definition '{}': missing macro name", spec));
 +        return Err(format!(
 +            "invalid macro definition '{}': missing macro name",
 +            spec
 +        ));
+     }
      let mut chars = name.chars();
      let Some(first) = chars.next() else {
 -        return Err(format!("invalid macro definition '{}': missing macro name", spec));
 +        return Err(format!(
 +            "invalid macro definition '{}': missing macro name",
 +            spec
 +        ));
      };
      if !(first == '_' || first.is_ascii_alphabetic()) {
          return Err(format!(
          eprintln!("─────────────────────────────────");
          for (name, d) in &self.samples {
              let ms = d.as_secs_f64() * 1000.0;
 -            let pct = if total_ms > 0.0 { ms / total_ms * 100.0 } else { 0.0 };
 +            let pct = if total_ms > 0.0 {
 +                ms / total_ms * 100.0
 +            } else {
 +                0.0
 +            };
              eprintln!("{:<16} {:>8.2} {:>4.0}%", name, ms, pct);
+         }
          eprintln!("─────────────────────────────────");
          for t in &tokens {
              buf.push_str(&format!("{:?}\n", t));
+         }
 -        fs::write(&out, &buf)
 -            .map_err(|e| format!("cannot write '{}': {}", out.display(), e))?;
 +        fs::write(&out, &buf).map_err(|e| format!("cannot write '{}': {}", out.display(), e))?;
          return Ok(());
+     }
          for u in &units {
              buf.push_str(&format!("{:#?}\n", u));
+         }
 -        fs::write(&out, &buf)
 -            .map_err(|e| format!("cannot write '{}': {}", out.display(), e))?;
 +        fs::write(&out, &buf).map_err(|e| format!("cannot write '{}': {}", out.display(), e))?;
          return Ok(());
+     }
          };
          // span_len is best-effort: end.col >= start.col on the same
          // line gives a nice underline, otherwise default to 1.
 -        let span_len = if d.span.end.line == d.span.start.line
 -            && d.span.end.col > d.span.start.col
 +        let span_len = if d.span.end.line == d.span.start.line && d.span.end.col > d.span.start.col
+         {
              (d.span.end.col - d.span.start.col) as usize
          } else {
+         }
+     }
      if had_error {
 -        return Err(format!("aborting due to errors in {}", opts.input.display()));
 +        return Err(format!(
 +            "aborting due to errors in {}",
 +            opts.input.display()
 +        ));
+     }
      phase.end(&mut phases);
      if opts.verbose {
          external_char_len_star.extend(crate::sema::amod::extract_char_len_star_params(ext_mod));
+     }
 -    let (mut ir_module, module_globals) = lower::lower_file(&units, &st, &type_layouts, external_globals, external_char_len_star);
 +    let (mut ir_module, module_globals) = lower::lower_file(
 +        &units,
 +        &st,
 +        &type_layouts,
 +        external_globals,
 +        external_char_len_star,
 +    );
      let ir_errors = verify::verify_module(&ir_module);
      if !ir_errors.is_empty() {
          let msg = ir_errors
+     {
          use crate::opt::pipeline::OptLevel as IrOpt;
          let ir_opt = match opts.opt_level {
 -            OptLevel::O0    => IrOpt::O0,
 -            OptLevel::O1    => IrOpt::O1,
 -            OptLevel::O2    => IrOpt::O2,
 -            OptLevel::O3    => IrOpt::O3,
 -            OptLevel::Os    => IrOpt::Os,
 +            OptLevel::O0 => IrOpt::O0,
 +            OptLevel::O1 => IrOpt::O1,
 +            OptLevel::O2 => IrOpt::O2,
 +            OptLevel::O3 => IrOpt::O3,
 +            OptLevel::Os => IrOpt::Os,
              OptLevel::Ofast => IrOpt::Ofast,
          };
          let pm = if ir_module.contains_i128_outside_globals() && opts.opt_level != OptLevel::O0 {
      if module_has_i128 && !ir_module.i128_backend_o0_supported() {
          return Err(
 -            "backend does not yet support integer(16) / i128 codegen; use --emit-ir for now"
 -                .into(),
 +            "backend does not yet support integer(16) / i128 codegen; use --emit-ir for now".into(),
          );
+     }
                          &ir_module,
                          &std::collections::HashMap::new(), // char_len_star computed by writer from scope
                      );
 -                    let amod_dir: std::path::PathBuf = opts
 -                        .module_output_dir
 -                        .clone()
 -                        .unwrap_or_else(|| {
 +                    let amod_dir: std::path::PathBuf =
 +                        opts.module_output_dir.clone().unwrap_or_else(|| {
                              opts.output_path()
                                  .parent()
                                  .unwrap_or_else(|| std::path::Path::new("."))
      all_inputs.extend(opts.extra_inputs.iter().cloned());
      // Scan dependencies.
 -    let file_deps: Vec<dep_scan::FileDeps> = all_inputs.iter()
 +    let file_deps: Vec<dep_scan::FileDeps> = all_inputs
 +        .iter()
          .map(|p| dep_scan::scan_file(p))
          .collect::<Result<Vec<_>, _>>()?;
      // Compile each file in order.
      let tmp_dir = std::env::temp_dir().join(format!("afs_multi_{}", std::process::id()));
 -    fs::create_dir_all(&tmp_dir)
 -        .map_err(|e| format!("cannot create temp dir: {}", e))?;
 +    fs::create_dir_all(&tmp_dir).map_err(|e| format!("cannot create temp dir: {}", e))?;
      let mut object_files: Vec<PathBuf> = Vec::new();
      for &idx in &order {
          let src = &file_deps[idx].path;
 -        let stem = src.file_stem().unwrap_or_default().to_str().unwrap_or("out");
 +        let stem = src
 +            .file_stem()
 +            .unwrap_or_default()
 +            .to_str()
 +            .unwrap_or("out");
          let obj_path = tmp_dir.join(format!("{}.o", stem));
          // Build a single-file Options for this source by inheriting
+     }
      // Link all object files.
 -    let output = opts.output.clone().unwrap_or_else(|| PathBuf::from("a.out"));
 +    let output = opts
 +        .output
 +        .clone()
 +        .unwrap_or_else(|| PathBuf::from("a.out"));
      link_multi(&object_files, &output, opts)?;
      // Cleanup.
+         }
+     }
 -    Err(
 -        "cannot find libarmfortas_rt.a. Searched: \
 +    Err("cannot find libarmfortas_rt.a. Searched: \
           $AFS_RUNTIME_PATH, cargo workspace, next to the compiler \
           binary, and /usr/local/lib. Build with \
           'cargo build -p armfortas-rt' or set AFS_RUNTIME_PATH."
 -            .into(),
 -    )
 +        .into())
+ }
  fn maybe_refresh_runtime_lib(workspace_root: &Path) -> Result<(), String> {
          return Ok(());
      };
      let debug_archive = workspace_root.join("target/debug/libarmfortas_rt.a");
 -    let archive_mtime = fs::metadata(&debug_archive).ok().and_then(|meta| meta.modified().ok());
 +    let archive_mtime = fs::metadata(&debug_archive)
 +        .ok()
 +        .and_then(|meta| meta.modified().ok());
      if archive_mtime.is_some_and(|mtime| mtime >= source_mtime) {
          return Ok(());
      for base in bases {
          for ancestor in base.ancestors() {
 -            if ancestor.join("Cargo.toml").exists() && ancestor.join("runtime/Cargo.toml").exists() {
 +            if ancestor.join("Cargo.toml").exists() && ancestor.join("runtime/Cargo.toml").exists()
 +            {
                  return Some(ancestor.to_path_buf());
+             }
+         }
          compile(&opts).expect("O0 --emit-ir should support integer(16) staging");
          let ir = fs::read_to_string(&output).expect("missing emitted IR");
 -        assert!(ir.contains("i128"), "emitted IR should expose integer(16) as i128:\n{}", ir);
 +        assert!(
 +            ir.contains("i128"),
 +            "emitted IR should expose integer(16) as i128:\n{}",
 +            ir
 +        );
          let _ = fs::remove_file(output);
+     }
              ..Options::default()
          };
 -        let err = compile(&opts).expect_err("backend should reject integer(16) until i128 codegen lands");
 +        let err =
 +            compile(&opts).expect_err("backend should reject integer(16) until i128 codegen lands");
          assert!(
              err.contains("backend does not yet support integer(16) / i128 codegen"),
              "unexpected backend rejection:\n{}",
          compile(&opts).expect("simple integer(16) memory traffic should codegen at O0");
          let asm = fs::read_to_string(&output).expect("missing emitted assembly");
 -        assert!(asm.contains("stp x16, x17"), "expected paired i128 store in asm:\n{}", asm);
 +        assert!(
 +            asm.contains("stp x16, x17"),
 +            "expected paired i128 store in asm:\n{}",
 +            asm
 +        );
          let _ = fs::remove_file(output);
+     }
          compile(&opts).expect("simple integer(16) add should codegen at O0");
          let asm = fs::read_to_string(&output).expect("missing emitted assembly");
 -        assert!(asm.contains("adds x16, x16, x8"), "expected i128 add carry chain in asm:\n{}", asm);
 +        assert!(
 +            asm.contains("adds x16, x16, x8"),
 +            "expected i128 add carry chain in asm:\n{}",
 +            asm
 +        );
          let _ = fs::remove_file(output);
+     }
          compile(&opts).expect("internal integer(16) call should codegen at O0");
          let asm = fs::read_to_string(&output).expect("missing emitted assembly");
 -        assert!(asm.contains("bl _add_one"), "expected internal helper call in asm:\n{}", asm);
 -        assert!(asm.contains("stp x0, x1"), "expected pair-register i128 ABI spill in asm:\n{}", asm);
 +        assert!(
 +            asm.contains("bl _add_one"),
 +            "expected internal helper call in asm:\n{}",
 +            asm
 +        );
 +        assert!(
 +            asm.contains("stp x0, x1"),
 +            "expected pair-register i128 ABI spill in asm:\n{}",
 +            asm
 +        );
          let _ = fs::remove_file(output);
+     }
          compile(&opts).expect("external integer(16) call should codegen at O0");
          let asm = fs::read_to_string(&output).expect("missing emitted assembly");
 -        assert!(asm.contains("bl _add_ext"), "expected external helper call in asm:\n{}", asm);
 -        assert!(asm.contains("stp x0, x1"), "expected pair-register i128 ABI spill in asm:\n{}", asm);
 +        assert!(
 +            asm.contains("bl _add_ext"),
 +            "expected external helper call in asm:\n{}",
 +            asm
 +        );
 +        assert!(
 +            asm.contains("stp x0, x1"),
 +            "expected pair-register i128 ABI spill in asm:\n{}",
 +            asm
 +        );
          let _ = fs::remove_file(output);
+     }
          compile(&opts).expect("integer(16) multiply should codegen at O1 after const fold");
          let asm = fs::read_to_string(&output).expect("missing emitted assembly");
 -        assert!(asm.contains("movz x16, #42"), "expected folded i128 constant in asm:\n{}", asm);
 -        assert!(!asm.contains("mul "), "expected O1 i128 multiply to fold away before backend:\n{}", asm);
 +        assert!(
 +            asm.contains("movz x16, #42"),
 +            "expected folded i128 constant in asm:\n{}",
 +            asm
 +        );
 +        assert!(
 +            !asm.contains("mul "),
 +            "expected O1 i128 multiply to fold away before backend:\n{}",
 +            asm
 +        );
          let _ = fs::remove_file(output);
+     }

src/ir/builder.rsmodified

348 lines changed — click to load

  //! Used by the AST→IR lowering pass and by tests. Manages ValueId
  //! allocation, block insertion, and instruction emission.
 -use crate::lexer::{Span, Position};
 -use super::types::*;
  use super::inst::*;
 +use super::types::*;
 +use crate::lexer::{Position, Span};
  /// Builder for constructing a function's IR.
  pub struct FuncBuilder<'a> {
  impl<'a> FuncBuilder<'a> {
      pub fn new(func: &'a mut Function) -> Self {
          let entry = func.entry;
 -        Self { func, current_block: entry }
 +        Self {
 +            func,
 +            current_block: entry,
 +        }
+     }
      /// Switch to emitting into a different block.
      pub fn add_block_param(&mut self, block: BlockId, ty: IrType) -> ValueId {
          let id = self.func.next_value_id();
          self.func.register_type(id, ty.clone());
 -        self.func.block_mut(block).params.push(BlockParam { id, ty });
 +        self.func
 +            .block_mut(block)
 +            .params
 +            .push(BlockParam { id, ty });
          id
+     }
      /// Get the underlying function.
 -    pub fn func(&self) -> &Function { self.func }
 +    pub fn func(&self) -> &Function {
 +        self.func
 +    }
      // ---- Instruction emission ----
      fn emit(&mut self, kind: InstKind, ty: IrType) -> ValueId {
          let id = self.func.next_value_id();
          self.func.register_type(id, ty.clone());
 -        let inst = Inst { id, kind, ty, span: dummy_span() };
 +        let inst = Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        };
          self.func.block_mut(self.current_block).insts.push(inst);
          id
+     }
      // ---- Integer arithmetic ----
      pub fn iadd(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::IAdd(lhs, rhs), ty)
+     }
      pub fn isub(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::ISub(lhs, rhs), ty)
+     }
      pub fn imul(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::IMul(lhs, rhs), ty)
+     }
      pub fn idiv(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::IDiv(lhs, rhs), ty)
+     }
      pub fn imod(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::IMod(lhs, rhs), ty)
+     }
      pub fn ineg(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::INeg(val), ty)
+     }
      // ---- Float arithmetic ----
      pub fn fadd(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Float(FloatWidth::F32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Float(FloatWidth::F32));
          self.emit(InstKind::FAdd(lhs, rhs), ty)
+     }
      pub fn fsub(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Float(FloatWidth::F32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Float(FloatWidth::F32));
          self.emit(InstKind::FSub(lhs, rhs), ty)
+     }
      pub fn fmul(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Float(FloatWidth::F32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Float(FloatWidth::F32));
          self.emit(InstKind::FMul(lhs, rhs), ty)
+     }
      pub fn fdiv(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Float(FloatWidth::F32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Float(FloatWidth::F32));
          self.emit(InstKind::FDiv(lhs, rhs), ty)
+     }
      pub fn fneg(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Float(FloatWidth::F32));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Float(FloatWidth::F32));
          self.emit(InstKind::FNeg(val), ty)
+     }
      pub fn fabs(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Float(FloatWidth::F64));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Float(FloatWidth::F64));
          self.emit(InstKind::FAbs(val), ty)
+     }
      pub fn fsqrt(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Float(FloatWidth::F64));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Float(FloatWidth::F64));
          self.emit(InstKind::FSqrt(val), ty)
+     }
      pub fn fpow(&mut self, base: ValueId, exp: ValueId) -> ValueId {
 -        let ty = self.func.value_type(base).unwrap_or(IrType::Float(FloatWidth::F64));
 +        let ty = self
 +            .func
 +            .value_type(base)
 +            .unwrap_or(IrType::Float(FloatWidth::F64));
          self.emit(InstKind::FPow(base, exp), ty)
+     }
      /// Conditional select: cond ? true_val : false_val
      pub fn select(&mut self, cond: ValueId, true_val: ValueId, false_val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(true_val).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(true_val)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::Select(cond, true_val, false_val), ty)
+     }
      // ---- Bitwise ----
      pub fn bit_and(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::BitAnd(lhs, rhs), ty)
+     }
      pub fn bit_or(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::BitOr(lhs, rhs), ty)
+     }
      pub fn bit_xor(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::BitXor(lhs, rhs), ty)
+     }
      pub fn shl(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::Shl(lhs, rhs), ty)
+     }
      pub fn bit_not(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::BitNot(val), ty)
+     }
      pub fn lshr(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
 -        let ty = self.func.value_type(lhs).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(lhs)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::LShr(lhs, rhs), ty)
+     }
      pub fn clz(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::CountLeadingZeros(val), ty)
+     }
      pub fn ctz(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::CountTrailingZeros(val), ty)
+     }
      pub fn popcount(&mut self, val: ValueId) -> ValueId {
 -        let ty = self.func.value_type(val).unwrap_or(IrType::Int(IntWidth::I32));
 +        let ty = self
 +            .func
 +            .value_type(val)
 +            .unwrap_or(IrType::Int(IntWidth::I32));
          self.emit(InstKind::PopCount(val), ty)
+     }
+     }
      pub fn gep(&mut self, base: ValueId, indices: Vec<ValueId>, result_ty: IrType) -> ValueId {
 -        self.emit(InstKind::GetElementPtr(base, indices), IrType::Ptr(Box::new(result_ty)))
 +        self.emit(
 +            InstKind::GetElementPtr(base, indices),
 +            IrType::Ptr(Box::new(result_ty)),
 +        )
+     }
      // ---- Calls ----
          self.emit(InstKind::Call(func_ref, args), ret_ty)
+     }
 -    pub fn runtime_call(&mut self, func: RuntimeFunc, args: Vec<ValueId>, ret_ty: IrType) -> ValueId {
 +    pub fn runtime_call(
 +        &mut self,
 +        func: RuntimeFunc,
 +        args: Vec<ValueId>,
 +        ret_ty: IrType,
 +    ) -> ValueId {
          self.emit(InstKind::RuntimeCall(func, args), ret_ty)
+     }
+     }
      pub fn branch(&mut self, dest: BlockId, args: Vec<ValueId>) {
 -        self.func.block_mut(self.current_block).terminator =
 -            Some(Terminator::Branch(dest, args));
 +        self.func.block_mut(self.current_block).terminator = Some(Terminator::Branch(dest, args));
+     }
      pub fn cond_branch(
          false_dest: BlockId,
          false_args: Vec<ValueId>,
      ) {
 -        self.func.block_mut(self.current_block).terminator =
 -            Some(Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args });
 +        self.func.block_mut(self.current_block).terminator = Some(Terminator::CondBranch {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        });
+     }
      pub fn switch(&mut self, selector: ValueId, cases: Vec<(i64, BlockId)>, default: BlockId) {
 -        self.func.block_mut(self.current_block).terminator =
 -            Some(Terminator::Switch { selector, cases, default });
 +        self.func.block_mut(self.current_block).terminator = Some(Terminator::Switch {
 +            selector,
 +            cases,
 +            default,
 +        });
+     }
      pub fn unreachable(&mut self) {
+ }
  fn dummy_span() -> Span {
 -    Span { file_id: 0, start: Position { line: 0, col: 0 }, end: Position { line: 0, col: 0 } }
 +    Span {
 +        file_id: 0,
 +        start: Position { line: 0, col: 0 },
 +        end: Position { line: 0, col: 0 },
 +    }
+ }
  #[cfg(test)]

src/ir/inst.rsmodified

224 lines changed — click to load

  //! Every instruction produces a value (ValueId) in SSA form.
  //! Basic blocks end with exactly one Terminator.
 -use super::types::{IrType, IntWidth, FloatWidth};
 +use super::types::{FloatWidth, IntWidth, IrType};
  use crate::lexer::Span;
  use std::collections::HashMap;
      FloatToInt(ValueId, IntWidth),
      FloatExtend(ValueId, FloatWidth),
      FloatTrunc(ValueId, FloatWidth),
 -    IntExtend(ValueId, IntWidth, bool),   // bool = signed
 +    IntExtend(ValueId, IntWidth, bool), // bool = signed
      IntTrunc(ValueId, IntWidth),
      /// Convert a pointer to an integer (address as i64).
      PtrToInt(ValueId),
      /// Get a block by ID. Panics if the ID is not present — use
      /// `try_block` for graceful degradation.
      pub fn block(&self, id: BlockId) -> &BasicBlock {
 -        self.blocks.iter().find(|b| b.id == id).expect("block not found")
 +        self.blocks
 +            .iter()
 +            .find(|b| b.id == id)
 +            .expect("block not found")
+     }
      /// Get a mutable block by ID. Panics if the ID is not present.
      pub fn block_mut(&mut self, id: BlockId) -> &mut BasicBlock {
 -        self.blocks.iter_mut().find(|b| b.id == id).expect("block not found")
 +        self.blocks
 +            .iter_mut()
 +            .find(|b| b.id == id)
 +            .expect("block not found")
+     }
      /// Get a block by ID, returning `None` if the ID is not
          // pointer-type bugs for entire compilation units. Recompute
          // on-demand so consumers always get a consistent answer.
          for p in &self.params {
 -            if p.id == id { return Some(p.ty.clone()); }
 +            if p.id == id {
 +                return Some(p.ty.clone());
 +            }
+         }
          for block in &self.blocks {
              for bp in &block.params {
 -                if bp.id == id { return Some(bp.ty.clone()); }
 +                if bp.id == id {
 +                    return Some(bp.ty.clone());
 +                }
+             }
              for inst in &block.insts {
 -                if inst.id == id { return Some(inst.ty.clone()); }
 +                if inst.id == id {
 +                    return Some(inst.ty.clone());
 +                }
+             }
+         }
          None
      pub fn find_defining_inst(&self, id: ValueId) -> Option<&Inst> {
          for block in &self.blocks {
              for inst in &block.insts {
 -                if inst.id == id { return Some(inst); }
 +                if inst.id == id {
 +                    return Some(inst);
 +                }
+             }
+         }
          None
      /// True when any live IR surface in the module uses `i128`.
      pub fn contains_i128(&self) -> bool {
 -        self.globals.iter().any(|global| type_contains_i128(self, &global.ty))
 -            || self.extern_funcs.iter().any(|func| sig_contains_i128(self, &func.sig))
 +        self.globals
 +            .iter()
 +            .any(|global| type_contains_i128(self, &global.ty))
 +            || self
 +                .extern_funcs
 +                .iter()
 +                .any(|func| sig_contains_i128(self, &func.sig))
              || self.functions.iter().any(|func| {
                  type_contains_i128(self, &func.return_type)
 -                    || func.params.iter().any(|param| type_contains_i128(self, &param.ty))
 +                    || func
 +                        .params
 +                        .iter()
 +                        .any(|param| type_contains_i128(self, &param.ty))
                      || func.blocks.iter().any(|block| {
 -                        block.params.iter().any(|param| type_contains_i128(self, &param.ty))
 -                            || block.insts.iter().any(|inst| type_contains_i128(self, &inst.ty))
 +                        block
 +                            .params
 +                            .iter()
 +                            .any(|param| type_contains_i128(self, &param.ty))
 +                            || block
 +                                .insts
 +                                .iter()
 +                                .any(|inst| type_contains_i128(self, &inst.ty))
                      })
              })
+     }
      /// Parameters, returns, instruction results, block params, and extern
      /// signatures still imply unsupported ABI or codegen work.
      pub fn contains_i128_outside_globals(&self) -> bool {
 -        self.extern_funcs.iter().any(|func| sig_contains_i128(self, &func.sig))
 +        self.extern_funcs
 +            .iter()
 +            .any(|func| sig_contains_i128(self, &func.sig))
              || self.functions.iter().any(|func| {
                  type_contains_i128(self, &func.return_type)
 -                    || func.params.iter().any(|param| type_contains_i128(self, &param.ty))
 +                    || func
 +                        .params
 +                        .iter()
 +                        .any(|param| type_contains_i128(self, &param.ty))
                      || func.blocks.iter().any(|block| {
 -                        block.params.iter().any(|param| type_contains_i128(self, &param.ty))
 -                            || block.insts.iter().any(|inst| type_contains_i128(self, &inst.ty))
 +                        block
 +                            .params
 +                            .iter()
 +                            .any(|param| type_contains_i128(self, &param.ty))
 +                            || block
 +                                .insts
 +                                .iter()
 +                                .any(|inst| type_contains_i128(self, &inst.ty))
                      })
              })
+     }
          self.globals
              .iter()
              .all(|global| global_i128_backend_data_supported(self, global))
 -            && self
 -                .extern_funcs
 -                .iter()
 -                .all(|func| {
 -                    abi_type_i128_backend_o0_supported(self, &func.sig.ret, true)
 -                        && func
 -                            .sig
 -                            .params
 -                            .iter()
 -                            .all(|param| abi_type_i128_backend_o0_supported(self, param, true))
 -                })
 +            && self.extern_funcs.iter().all(|func| {
 +                abi_type_i128_backend_o0_supported(self, &func.sig.ret, true)
 +                    && func
 +                        .sig
 +                        .params
 +                        .iter()
 +                        .all(|param| abi_type_i128_backend_o0_supported(self, param, true))
 +            })
              && self
                  .functions
                  .iter()
  fn sig_contains_i128(module: &Module, sig: &super::types::FuncSig) -> bool {
      type_contains_i128(module, &sig.ret)
 -        || sig.params.iter().any(|param| type_contains_i128(module, param))
 +        || sig
 +            .params
 +            .iter()
 +            .any(|param| type_contains_i128(module, param))
+ }
  fn type_contains_i128(module: &Module, ty: &IrType) -> bool {
      match ty {
          IrType::Int(IntWidth::I128) => true,
          IrType::Ptr(inner) | IrType::Array(inner, _) => type_contains_i128(module, inner),
 -        IrType::Struct(id) => module
 -            .struct_defs
 -            .get(*id as usize)
 -            .is_some_and(|def| def.fields.iter().any(|(_, field_ty)| type_contains_i128(module, field_ty))),
 +        IrType::Struct(id) => module.struct_defs.get(*id as usize).is_some_and(|def| {
 +            def.fields
 +                .iter()
 +                .any(|(_, field_ty)| type_contains_i128(module, field_ty))
 +        }),
          IrType::FuncPtr(sig) => sig_contains_i128(module, sig),
          _ => false,
+     }
      result_ty: &IrType,
  ) -> bool {
      match rf {
 -        RuntimeFunc::PrintInt => matches!(result_ty, IrType::Void)
 -            && args.len() == 1
 -            && args
 -                .iter()
 -                .filter_map(|arg| func.value_type(*arg))
 -                .all(|ty| abi_type_i128_backend_o0_supported(module, &ty, true)),
 +        RuntimeFunc::PrintInt => {
 +            matches!(result_ty, IrType::Void)
 +                && args.len() == 1
 +                && args
 +                    .iter()
 +                    .filter_map(|arg| func.value_type(*arg))
 +                    .all(|ty| abi_type_i128_backend_o0_supported(module, &ty, true))
 +        }
          _ => false,
+     }
+ }
          // dereferencing an sret-style hidden result-buffer pointer.
          InstKind::Load(_) if matches!(inst.ty, IrType::Ptr(_)) => true,
          InstKind::IAdd(..) | InstKind::ISub(..) | InstKind::INeg(_)
 -            if matches!(inst.ty, IrType::Int(IntWidth::I128)) => true,
 +            if matches!(inst.ty, IrType::Int(IntWidth::I128)) =>
 +        {
 +            true
 +        }
          InstKind::ICmp(..) if uses_i128 => true,
          InstKind::Select(..) if matches!(inst.ty, IrType::Int(IntWidth::I128)) => true,
          InstKind::Call(callee, args) if inst_ty_has_i128 || uses_i128 => {
              .iter()
              .filter_map(|arg| func.value_type(*arg))
              .all(|ty| ssa_type_i128_backend_o0_supported(module, &ty)),
 -        Terminator::CondBranch { true_args, false_args, .. } => true_args
 +        Terminator::CondBranch {
 +            true_args,
 +            false_args,
 +            ..
 +        } => true_args
              .iter()
              .chain(false_args.iter())
              .filter_map(|arg| func.value_type(*arg))

src/ir/mod.rsmodified

13 lines changed — click to load

  //! Fortran-aware: understands array descriptors, string descriptors,
  //! and allocatable semantics.
 -pub mod types;
 -pub mod inst;
  pub mod builder;
 +pub mod inst;
 +pub mod lower;
  pub mod printer;
 +pub mod types;
  pub mod verify;
  pub mod walk;
 -pub mod lower;

src/ir/printer.rsmodified

293 lines changed — click to load

  //!
  //! Used by `-emit-ir` and in test assertions.
 -use std::fmt::Write;
  use super::inst::*;
 +use std::fmt::Write;
  /// Print a module to a string.
  pub fn print_module(module: &Module) -> String {
      for sd in &module.struct_defs {
          write!(out, "  struct {} {{ ", sd.name).unwrap();
          for (i, (name, ty)) in sd.fields.iter().enumerate() {
 -            if i > 0 { write!(out, ", ").unwrap(); }
 +            if i > 0 {
 +                write!(out, ", ").unwrap();
 +            }
              write!(out, "{}: {}", name, ty).unwrap();
+         }
          writeln!(out, " }}").unwrap();
                  GlobalInit::Zero => write!(out, " = zeroinit").unwrap(),
                  GlobalInit::Int(v) => write!(out, " = {}", v).unwrap(),
                  GlobalInit::Float(v) => write!(out, " = {}", v).unwrap(),
 -                GlobalInit::String(s) => write!(out, " = {:?}", String::from_utf8_lossy(s)).unwrap(),
 +                GlobalInit::String(s) => {
 +                    write!(out, " = {:?}", String::from_utf8_lossy(s)).unwrap()
 +                }
                  GlobalInit::IntArray(vs) => {
                      let s: Vec<String> = vs.iter().map(|v| v.to_string()).collect();
                      write!(out, " = [{}]", s.join(", ")).unwrap();
      for ef in &module.extern_funcs {
          write!(out, "  extern fn @{}(", ef.name).unwrap();
          for (i, p) in ef.sig.params.iter().enumerate() {
 -            if i > 0 { write!(out, ", ").unwrap(); }
 +            if i > 0 {
 +                write!(out, ", ").unwrap();
 +            }
              write!(out, "{}", p).unwrap();
+         }
          writeln!(out, ") -> {}", ef.sig.ret).unwrap();
      let mut out = String::new();
      // Print function attributes.
      let mut attrs = Vec::new();
 -    if func.is_pure { attrs.push("pure"); }
 -    if func.is_elemental { attrs.push("elemental"); }
 -    let attr_str = if attrs.is_empty() { String::new() } else { format!(" [{}]", attrs.join(", ")) };
 +    if func.is_pure {
 +        attrs.push("pure");
 +    }
 +    if func.is_elemental {
 +        attrs.push("elemental");
 +    }
 +    let attr_str = if attrs.is_empty() {
 +        String::new()
 +    } else {
 +        format!(" [{}]", attrs.join(", "))
 +    };
      write!(out, "  func @{}{}(", func.name, attr_str).unwrap();
      for (i, p) in func.params.iter().enumerate() {
 -        if i > 0 { write!(out, ", ").unwrap(); }
 +        if i > 0 {
 +            write!(out, ", ").unwrap();
 +        }
          write!(out, "%{}: {}", p.id.0, p.ty).unwrap();
+     }
      writeln!(out, ") -> {} {{", func.return_type).unwrap();
      print_block_with_module_opt(block, func, Some(module))
+ }
 -fn print_block_with_module_opt(block: &BasicBlock, func: &Function, module: Option<&Module>) -> String {
 +fn print_block_with_module_opt(
 +    block: &BasicBlock,
 +    func: &Function,
 +    module: Option<&Module>,
 +) -> String {
      let mut out = String::new();
      write!(out, "    {}(", block.name).unwrap();
      for (i, bp) in block.params.iter().enumerate() {
 -        if i > 0 { write!(out, ", ").unwrap(); }
 +        if i > 0 {
 +            write!(out, ", ").unwrap();
 +        }
          write!(out, "%{}: {}", bp.id.0, bp.ty).unwrap();
+     }
      writeln!(out, "):").unwrap();
      let mut out = String::new();
      write!(out, "    {}(", block.name).unwrap();
      for (i, bp) in block.params.iter().enumerate() {
 -        if i > 0 { write!(out, ", ").unwrap(); }
 +        if i > 0 {
 +            write!(out, ", ").unwrap();
 +        }
          write!(out, "%{}: {}", bp.id.0, bp.ty).unwrap();
+     }
      writeln!(out, "):").unwrap();
      let mut out = String::new();
      // Print function attributes.
      let mut attrs = Vec::new();
 -    if func.is_pure { attrs.push("pure"); }
 -    if func.is_elemental { attrs.push("elemental"); }
 -    let attr_str = if attrs.is_empty() { String::new() } else { format!(" [{}]", attrs.join(", ")) };
 +    if func.is_pure {
 +        attrs.push("pure");
 +    }
 +    if func.is_elemental {
 +        attrs.push("elemental");
 +    }
 +    let attr_str = if attrs.is_empty() {
 +        String::new()
 +    } else {
 +        format!(" [{}]", attrs.join(", "))
 +    };
      write!(out, "  func @{}{}(", func.name, attr_str).unwrap();
      for (i, p) in func.params.iter().enumerate() {
 -        if i > 0 { write!(out, ", ").unwrap(); }
 +        if i > 0 {
 +            write!(out, ", ").unwrap();
 +        }
          write!(out, "%{}: {}", p.id.0, p.ty).unwrap();
+     }
      writeln!(out, ") -> {} {{", func.return_type).unwrap();
          InstKind::FloatToInt(v, w) => format!("float_to_int %{} : {}", v.0, w),
          InstKind::FloatExtend(v, w) => format!("float_extend %{} : {}", v.0, w),
          InstKind::FloatTrunc(v, w) => format!("float_trunc %{} : {}", v.0, w),
 -        InstKind::IntExtend(v, w, s) => format!("int_extend %{} : {} {}", v.0, w, if *s { "signed" } else { "unsigned" }),
 +        InstKind::IntExtend(v, w, s) => format!(
 +            "int_extend %{} : {} {}",
 +            v.0,
 +            w,
 +            if *s { "signed" } else { "unsigned" }
 +        ),
          InstKind::IntTrunc(v, w) => format!("int_trunc %{} : {}", v.0, w),
          InstKind::PtrToInt(v) => format!("ptr_to_int %{}", v.0),
          InstKind::IntToPtr(v, ty) => format!("int_to_ptr %{} : {}", v.0, ty),
+         }
          InstKind::RuntimeCall(rf, args) => {
              let args_str: Vec<String> = args.iter().map(|a| format!("%{}", a.0)).collect();
 -            format!("rt_call @{}({})", runtime_func_name(rf), args_str.join(", "))
 +            format!(
 +                "rt_call @{}({})",
 +                runtime_func_name(rf),
 +                args_str.join(", ")
 +            )
+         }
          InstKind::ExtractField(agg, idx) => format!("extract_field %{}, {}", agg.0, idx),
 -        InstKind::InsertField(agg, idx, val) => format!("insert_field %{}, {}, %{}", agg.0, idx, val.0),
 +        InstKind::InsertField(agg, idx, val) => {
 +            format!("insert_field %{}, {}, %{}", agg.0, idx, val.0)
 +        }
      };
      if inst.ty == super::types::IrType::Void {
                  format!("br {}({})", bname(dest), args_str.join(", "))
+             }
+         }
 -        Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args } => {
 +        Terminator::CondBranch {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        } => {
              let ta: Vec<String> = true_args.iter().map(|a| format!("%{}", a.0)).collect();
              let fa: Vec<String> = false_args.iter().map(|a| format!("%{}", a.0)).collect();
 -            format!("cond_br %{}, {}({}), {}({})",
 -                cond.0, bname(true_dest), ta.join(", "), bname(false_dest), fa.join(", "))
 +            format!(
 +                "cond_br %{}, {}({}), {}({})",
 +                cond.0,
 +                bname(true_dest),
 +                ta.join(", "),
 +                bname(false_dest),
 +                fa.join(", ")
 +            )
+         }
 -        Terminator::Switch { selector, cases, default } => {
 -            let cases_str: Vec<String> = cases.iter()
 +        Terminator::Switch {
 +            selector,
 +            cases,
 +            default,
 +        } => {
 +            let cases_str: Vec<String> = cases
 +                .iter()
                  .map(|(v, b)| format!("{} -> {}", v, bname(b)))
                  .collect();
 -            format!("switch %{}, [{}], default {}", selector.0, cases_str.join(", "), bname(default))
 +            format!(
 +                "switch %{}, [{}], default {}",
 +                selector.0,
 +                cases_str.join(", "),
 +                bname(default)
 +            )
+         }
          Terminator::Unreachable => "unreachable".into(),
+     }
                  format!("br bb{}({})", dest.0, args_str.join(", "))
+             }
+         }
 -        Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args } => {
 +        Terminator::CondBranch {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        } => {
              let ta: Vec<String> = true_args.iter().map(|a| format!("%{}", a.0)).collect();
              let fa: Vec<String> = false_args.iter().map(|a| format!("%{}", a.0)).collect();
 -            format!("cond_br %{}, bb{}({}), bb{}({})",
 -                cond.0, true_dest.0, ta.join(", "), false_dest.0, fa.join(", "))
 +            format!(
 +                "cond_br %{}, bb{}({}), bb{}({})",
 +                cond.0,
 +                true_dest.0,
 +                ta.join(", "),
 +                false_dest.0,
 +                fa.join(", ")
 +            )
+         }
 -        Terminator::Switch { selector, cases, default } => {
 -            let cases_str: Vec<String> = cases.iter()
 +        Terminator::Switch {
 +            selector,
 +            cases,
 +            default,
 +        } => {
 +            let cases_str: Vec<String> = cases
 +                .iter()
                  .map(|(v, b)| format!("{} -> bb{}", v, b.0))
                  .collect();
 -            format!("switch %{}, [{}], default bb{}", selector.0, cases_str.join(", "), default.0)
 +            format!(
 +                "switch %{}, [{}], default bb{}",
 +                selector.0,
 +                cases_str.join(", "),
 +                default.0
 +            )
+         }
          Terminator::Unreachable => "unreachable".into(),
+     }
  #[cfg(test)]
  mod tests {
 -    use super::*;
 -    use super::super::types::*;
      use super::super::builder::FuncBuilder;
 +    use super::super::types::*;
 +    use super::*;
      #[test]
      fn print_simple_function() {
          let output = print_function(&func);
          assert!(output.contains("header_1(%"));
          assert!(output.contains(": i32)"));
 -        assert!(output.contains("br header_1("), "expected 'br header_1(' in:\n{}", output);
 +        assert!(
 +            output.contains("br header_1("),
 +            "expected 'br header_1(' in:\n{}",
 +            output
 +        );
+     }
      #[test]
+         {
              let mut b = FuncBuilder::new(&mut caller);
              let arg = b.const_i32(7);
 -            let _ = b.call(FuncRef::Internal(callee_idx), vec![arg], IrType::Int(IntWidth::I32));
 +            let _ = b.call(
 +                FuncRef::Internal(callee_idx),
 +                vec![arg],
 +                IrType::Int(IntWidth::I32),
 +            );
              b.ret_void();
+         }
          module.add_function(caller);
          let output = print_module(&module);
 -        assert!(output.contains("call @callee("), "expected named internal call in:\n{}", output);
 -        assert!(!output.contains("@func_0"), "unexpected fallback name in:\n{}", output);
 +        assert!(
 +            output.contains("call @callee("),
 +            "expected named internal call in:\n{}",
 +            output
 +        );
 +        assert!(
 +            !output.contains("@func_0"),
 +            "unexpected fallback name in:\n{}",
 +            output
 +        );
+     }
+ }

src/ir/types.rsmodified

62 lines changed — click to load

  impl FloatWidth {
      pub fn bits(self) -> u32 {
 -        match self { Self::F32 => 32, Self::F64 => 64 }
 +        match self {
 +            Self::F32 => 32,
 +            Self::F64 => 64,
 +        }
+     }
      pub fn bytes(self) -> u32 {
              Self::Float(w) => w.bytes() as u64,
              Self::Ptr(_) => 8, // 64-bit pointers
              Self::Array(elem, count) => elem.size_bytes() * count,
 -            Self::Struct(_) => panic!("Struct size requires struct_defs; use Module::struct_size()"),
 +            Self::Struct(_) => {
 +                panic!("Struct size requires struct_defs; use Module::struct_size()")
 +            }
              Self::FuncPtr(_) => 8,
+         }
+     }
      /// Extract the IntWidth if this is an integer type.
      pub fn int_width(&self) -> Option<IntWidth> {
 -        if let Self::Int(w) = self { Some(*w) } else { None }
 +        if let Self::Int(w) = self {
 +            Some(*w)
 +        } else {
 +            None
 +        }
+     }
      /// Is this an integer type?
 -    pub fn is_int(&self) -> bool { matches!(self, Self::Int(_)) }
 +    pub fn is_int(&self) -> bool {
 +        matches!(self, Self::Int(_))
 +    }
      /// Is this a float type?
 -    pub fn is_float(&self) -> bool { matches!(self, Self::Float(_)) }
 +    pub fn is_float(&self) -> bool {
 +        matches!(self, Self::Float(_))
 +    }
      /// Is this a pointer type?
 -    pub fn is_ptr(&self) -> bool { matches!(self, Self::Ptr(_)) }
 +    pub fn is_ptr(&self) -> bool {
 +        matches!(self, Self::Ptr(_))
 +    }
      /// Fortran integer(1) → i8, integer(2) → i16, integer(4) → i32,
      /// integer(8) → i64, integer(16) → i128.
              Self::FuncPtr(sig) => {
                  write!(f, "fn(")?;
                  for (i, p) in sig.params.iter().enumerate() {
 -                    if i > 0 { write!(f, ", ")?; }
 +                    if i > 0 {
 +                        write!(f, ", ")?;
 +                    }
                      write!(f, "{}", p)?;
+                 }
                  write!(f, ") -> {}", sig.ret)

src/ir/verify.rsmodified

347 lines changed — click to load

  //! Checks: SSA dominance, type consistency, block structure,
  //! terminator completeness, block param/branch arg matching.
 -use std::collections::{HashMap, HashSet};
  use super::inst::*;
 -use super::types::{IrType, IntWidth};
 -use super::walk::{inst_uses, terminator_uses, terminator_targets, compute_dominators};
 +use super::types::{IntWidth, IrType};
 +use super::walk::{compute_dominators, inst_uses, terminator_targets, terminator_uses};
 +use std::collections::{HashMap, HashSet};
  /// Verification error.
  #[derive(Debug, Clone)]
          });
+     }
      for block in &func.blocks {
 -        let Some(term) = &block.terminator else { continue; };
 +        let Some(term) = &block.terminator else {
 +            continue;
 +        };
          if terminator_targets(term).contains(&func.entry) {
              errors.push(VerifyError {
                  msg: format!(
              for used in inst_uses(&inst.kind) {
                  if !defined.contains(&used) {
                      errors.push(VerifyError {
 -                        msg: format!("value %{} used in block '{}' but not defined",
 -                            used.0, block.name),
 +                        msg: format!(
 +                            "value %{} used in block '{}' but not defined",
 +                            used.0, block.name
 +                        ),
                      });
+                 }
+             }
              for used in terminator_uses(term) {
                  if !defined.contains(&used) {
                      errors.push(VerifyError {
 -                        msg: format!("value %{} used in terminator of block '{}' but not defined",
 -                            used.0, block.name),
 +                        msg: format!(
 +                            "value %{} used in terminator of block '{}' but not defined",
 +                            used.0, block.name
 +                        ),
                      });
+                 }
+             }
              for target in terminator_targets(term) {
                  if !block_ids.contains(&target) {
                      errors.push(VerifyError {
 -                        msg: format!("block '{}' branches to undefined block {}",
 -                            block.name, target.0),
 +                        msg: format!(
 +                            "block '{}' branches to undefined block {}",
 +                            block.name, target.0
 +                        ),
                      });
+                 }
+             }
+ }
  /// Check that branch arguments match block parameters in count and type.
 -fn check_branch_args(func: &Function, term: &Terminator, from_block: &str, errors: &mut Vec<VerifyError>) {
 +fn check_branch_args(
 +    func: &Function,
 +    term: &Terminator,
 +    from_block: &str,
 +    errors: &mut Vec<VerifyError>,
 +) {
      let mut check = |dest: BlockId, args: &[ValueId]| {
          let target = func.block(dest);
          if target.params.len() != args.len() {
              errors.push(VerifyError {
                  msg: format!(
                      "branch from '{}' to '{}': expected {} args, got {}",
 -                    from_block, target.name, target.params.len(), args.len()
 +                    from_block,
 +                    target.name,
 +                    target.params.len(),
 +                    args.len()
                  ),
              });
          } else {
      match term {
          Terminator::Branch(dest, args) => check(*dest, args),
 -        Terminator::CondBranch { true_dest, true_args, false_dest, false_args, .. } => {
 +        Terminator::CondBranch {
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +            ..
 +        } => {
              check(*true_dest, true_args);
              check(*false_dest, false_args);
+         }
              let default_block = func.block(*default);
              if !default_block.params.is_empty() {
                  errors.push(VerifyError {
 -                    msg: format!("switch default target '{}' has block parameters", default_block.name),
 +                    msg: format!(
 +                        "switch default target '{}' has block parameters",
 +                        default_block.name
 +                    ),
                  });
+             }
              for (_, dest) in cases {
  /// Check type consistency for instructions.
  fn check_type_consistency(func: &Function, inst: &Inst, errors: &mut Vec<VerifyError>) {
      match &inst.kind {
 -        InstKind::IAdd(a, b) | InstKind::ISub(a, b) |
 -        InstKind::IMul(a, b) | InstKind::IDiv(a, b) |
 -        InstKind::IMod(a, b) => {
 +        InstKind::IAdd(a, b)
 +        | InstKind::ISub(a, b)
 +        | InstKind::IMul(a, b)
 +        | InstKind::IDiv(a, b)
 +        | InstKind::IMod(a, b) => {
              let ta = func.value_type(*a);
              let tb = func.value_type(*b);
              // Report missing types so the upstream cache-miss (already
              if let (Some(ta), Some(tb)) = (&ta, &tb) {
                  if !ta.is_int() {
                      errors.push(VerifyError {
 -                        msg: format!("integer op %{} has non-integer operand %{} : {}", inst.id.0, a.0, ta),
 +                        msg: format!(
 +                            "integer op %{} has non-integer operand %{} : {}",
 +                            inst.id.0, a.0, ta
 +                        ),
                      });
+                 }
                  if !tb.is_int() {
                      errors.push(VerifyError {
 -                        msg: format!("integer op %{} has non-integer operand %{} : {}", inst.id.0, b.0, tb),
 +                        msg: format!(
 +                            "integer op %{} has non-integer operand %{} : {}",
 +                            inst.id.0, b.0, tb
 +                        ),
                      });
+                 }
                  // Audit MAJOR-4: enforce exact width agreement.
+                 }
+             }
+         }
 -        InstKind::FAdd(a, b) | InstKind::FSub(a, b) |
 -        InstKind::FMul(a, b) | InstKind::FDiv(a, b) |
 -        InstKind::FPow(a, b) => {
 +        InstKind::FAdd(a, b)
 +        | InstKind::FSub(a, b)
 +        | InstKind::FMul(a, b)
 +        | InstKind::FDiv(a, b)
 +        | InstKind::FPow(a, b) => {
              let ta = func.value_type(*a);
              let tb = func.value_type(*b);
              if let (Some(ta), Some(tb)) = (&ta, &tb) {
                  if !ta.is_float() {
                      errors.push(VerifyError {
 -                        msg: format!("float op %{} has non-float operand %{} : {}", inst.id.0, a.0, ta),
 +                        msg: format!(
 +                            "float op %{} has non-float operand %{} : {}",
 +                            inst.id.0, a.0, ta
 +                        ),
                      });
+                 }
                  if !tb.is_float() {
                      errors.push(VerifyError {
 -                        msg: format!("float op %{} has non-float operand %{} : {}", inst.id.0, b.0, tb),
 +                        msg: format!(
 +                            "float op %{} has non-float operand %{} : {}",
 +                            inst.id.0, b.0, tb
 +                        ),
                      });
+                 }
                  // Same width-agreement rule for floats. Mixing
              // A Store(i64_val, ptr<i32>) would silently truncate
              // at codegen because isel picks the str width from
              // the value's reg class, not the pointer's pointee.
 -            if let (Some(IrType::Ptr(pointee)), Some(vty)) =
 -                (&addr_ty, func.value_type(*val))
 -            {
 +            if let (Some(IrType::Ptr(pointee)), Some(vty)) = (&addr_ty, func.value_type(*val)) {
                  let inner: &IrType = pointee.as_ref();
                  // Byte-level GEPs into derived-type layouts use
                  // `ptr<i8>` as a marker with arbitrary pointee on
          // Bitwise binary ops: both operands must be integers of
          // the same width. Audit Med-1.
 -        InstKind::BitAnd(a, b) | InstKind::BitOr(a, b) | InstKind::BitXor(a, b)
 -        | InstKind::Shl(a, b) | InstKind::LShr(a, b) | InstKind::AShr(a, b) => {
 +        InstKind::BitAnd(a, b)
 +        | InstKind::BitOr(a, b)
 +        | InstKind::BitXor(a, b)
 +        | InstKind::Shl(a, b)
 +        | InstKind::LShr(a, b)
 +        | InstKind::AShr(a, b) => {
              let ta = func.value_type(*a);
              let tb = func.value_type(*b);
              if let (Some(ta), Some(tb)) = (&ta, &tb) {
  #[cfg(test)]
  mod tests {
 -    use super::*;
 -    use super::super::types::*;
      use super::super::builder::FuncBuilder;
 +    use super::super::types::*;
 +    use super::*;
      #[test]
      fn valid_simple_function() {
          let mut func = Function::new("test".into(), vec![], IrType::Void);
          // Manually add a param to the entry block.
          func.blocks[0].params.push(BlockParam {
 -            id: ValueId(99), ty: IrType::Int(IntWidth::I32),
 +            id: ValueId(99),
 +            ty: IrType::Int(IntWidth::I32),
          });
          func.blocks[0].terminator = Some(Terminator::Return(None));
          let errs = verify_function(&func);
          let errs = verify_function(&func);
          assert!(
              errs.iter().any(|e| e.msg.contains("entry block")),
 -            "expected entry-back-edge error, got: {:?}", errs,
 +            "expected entry-back-edge error, got: {:?}",
 +            errs,
          );
+     }
              b.ret_void();
+         }
          let errs = verify_function(&func);
 -        assert!(errs.iter().any(|e| e.msg.contains("expected 1 args, got 0")));
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.msg.contains("expected 1 args, got 0")));
+     }
      #[test]
+         }
          let errs = verify_function(&func);
          assert!(
 -            errs.iter().any(|e| e.msg.contains("doesn't match pointee type")),
 +            errs.iter()
 +                .any(|e| e.msg.contains("doesn't match pointee type")),
              "expected pointee type mismatch error, got: {:?}",
              errs,
          );
              let mut b = FuncBuilder::new(&mut func);
              let val = b.const_i32(42);
              let not_ptr = b.const_i32(0); // not a pointer
 -            // Force a store to non-pointer.
 +                                          // Force a store to non-pointer.
              b.emit_bogus_store(val, not_ptr);
              b.ret_void();
+         }
              b.ret_void();
+         }
          // Manually inject the value definition in block B with the ID we referenced.
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 0, col: 0 }, end: Position { line: 0, col: 0 } };
 -        func.blocks[2].insts.insert(0, Inst {
 -            id: ValueId(100),
 -            kind: InstKind::ConstInt(99, IntWidth::I32),
 -            ty: IrType::Int(IntWidth::I32),
 -            span,
 -        });
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 0, col: 0 },
 +            end: Position { line: 0, col: 0 },
 +        };
 +        func.blocks[2].insts.insert(
 +            0,
 +            Inst {
 +                id: ValueId(100),
 +                kind: InstKind::ConstInt(99, IntWidth::I32),
 +                ty: IrType::Int(IntWidth::I32),
 +                span,
 +            },
 +        );
          let errs = verify_function(&func);
 -        assert!(errs.iter().any(|e| e.msg.contains("does not dominate")),
 -            "expected dominance error, got: {:?}", errs);
 +        assert!(
 +            errs.iter().any(|e| e.msg.contains("does not dominate")),
 +            "expected dominance error, got: {:?}",
 +            errs
 +        );
+     }
      #[test]
      fn dominance_same_block_order_violation() {
          // Use a value before it's defined in the same block.
          let mut func = Function::new("test".into(), vec![], IrType::Void);
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 0, col: 0 }, end: Position { line: 0, col: 0 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 0, col: 0 },
 +            end: Position { line: 0, col: 0 },
 +        };
          // Manually construct: %1 = iadd %0, %0 then %0 = const_int 42
          // (use of %0 before its definition)
          });
          func.blocks[0].terminator = Some(Terminator::Return(None));
          let errs = verify_function(&func);
 -        assert!(errs.iter().any(|e| e.msg.contains("used before its definition")),
 -            "expected same-block order error, got: {:?}", errs);
 +        assert!(
 +            errs.iter()
 +                .any(|e| e.msg.contains("used before its definition")),
 +            "expected same-block order error, got: {:?}",
 +            errs
 +        );
+     }
      #[test]
      fn duplicate_value_id_errors() {
          let mut func = Function::new("test".into(), vec![], IrType::Void);
          // Manually push two instructions with the same ID.
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 0, col: 0 }, end: Position { line: 0, col: 0 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 0, col: 0 },
 +            end: Position { line: 0, col: 0 },
 +        };
          func.blocks[0].insts.push(Inst {
 -            id: ValueId(0), kind: InstKind::ConstInt(1, IntWidth::I32), ty: IrType::Int(IntWidth::I32), span,
 +            id: ValueId(0),
 +            kind: InstKind::ConstInt(1, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span,
          });
          func.blocks[0].insts.push(Inst {
 -            id: ValueId(0), kind: InstKind::ConstInt(2, IntWidth::I32), ty: IrType::Int(IntWidth::I32), span,
 +            id: ValueId(0),
 +            kind: InstKind::ConstInt(2, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span,
          });
          func.blocks[0].terminator = Some(Terminator::Return(None));
          let errs = verify_function(&func);

src/ir/walk.rsmodified

616 lines changed — click to load

  /// All `ValueId`s consumed as operands by an instruction.
  pub fn inst_uses(kind: &InstKind) -> Vec<ValueId> {
      match kind {
 -        InstKind::ConstInt(..) | InstKind::ConstFloat(..) |
 -        InstKind::ConstBool(..) | InstKind::ConstString(..) |
 -        InstKind::Undef(..) | InstKind::Alloca(..) |
 -        InstKind::GlobalAddr(..) => vec![],
+-
 -        InstKind::IAdd(a, b) | InstKind::ISub(a, b) |
 -        InstKind::IMul(a, b) | InstKind::IDiv(a, b) |
 -        InstKind::IMod(a, b) => vec![*a, *b],
 +        InstKind::ConstInt(..)
 +        | InstKind::ConstFloat(..)
 +        | InstKind::ConstBool(..)
 +        | InstKind::ConstString(..)
 +        | InstKind::Undef(..)
 +        | InstKind::Alloca(..)
 +        | InstKind::GlobalAddr(..) => vec![],
++
 +        InstKind::IAdd(a, b)
 +        | InstKind::ISub(a, b)
 +        | InstKind::IMul(a, b)
 +        | InstKind::IDiv(a, b)
 +        | InstKind::IMod(a, b) => vec![*a, *b],
          InstKind::INeg(a) => vec![*a],
 -        InstKind::FAdd(a, b) | InstKind::FSub(a, b) |
 -        InstKind::FMul(a, b) | InstKind::FDiv(a, b) |
 -        InstKind::FPow(a, b) => vec![*a, *b],
 +        InstKind::FAdd(a, b)
 +        | InstKind::FSub(a, b)
 +        | InstKind::FMul(a, b)
 +        | InstKind::FDiv(a, b)
 +        | InstKind::FPow(a, b) => vec![*a, *b],
          InstKind::FNeg(a) | InstKind::FAbs(a) | InstKind::FSqrt(a) => vec![*a],
          InstKind::ICmp(_, a, b) | InstKind::FCmp(_, a, b) => vec![*a, *b],
          InstKind::Select(c, t, f) => vec![*c, *t, *f],
 -        InstKind::BitAnd(a, b) | InstKind::BitOr(a, b) |
 -        InstKind::BitXor(a, b) | InstKind::Shl(a, b) |
 -        InstKind::LShr(a, b) | InstKind::AShr(a, b) => vec![*a, *b],
 -        InstKind::BitNot(a) | InstKind::CountLeadingZeros(a) |
 -        InstKind::CountTrailingZeros(a) | InstKind::PopCount(a) => vec![*a],
+-
 -        InstKind::IntToFloat(v, _) | InstKind::FloatToInt(v, _) |
 -        InstKind::FloatExtend(v, _) | InstKind::FloatTrunc(v, _) |
 -        InstKind::IntExtend(v, _, _) | InstKind::IntTrunc(v, _) |
 -        InstKind::PtrToInt(v) | InstKind::IntToPtr(v, _) => vec![*v],
 +        InstKind::BitAnd(a, b)
 +        | InstKind::BitOr(a, b)
 +        | InstKind::BitXor(a, b)
 +        | InstKind::Shl(a, b)
 +        | InstKind::LShr(a, b)
 +        | InstKind::AShr(a, b) => vec![*a, *b],
 +        InstKind::BitNot(a)
 +        | InstKind::CountLeadingZeros(a)
 +        | InstKind::CountTrailingZeros(a)
 +        | InstKind::PopCount(a) => vec![*a],
++
 +        InstKind::IntToFloat(v, _)
 +        | InstKind::FloatToInt(v, _)
 +        | InstKind::FloatExtend(v, _)
 +        | InstKind::FloatTrunc(v, _)
 +        | InstKind::IntExtend(v, _, _)
 +        | InstKind::IntTrunc(v, _)
 +        | InstKind::PtrToInt(v)
 +        | InstKind::IntToPtr(v, _) => vec![*v],
          InstKind::Load(a) => vec![*a],
          InstKind::Store(v, a) => vec![*v, *a],
          Terminator::Return(None) | Terminator::Unreachable => vec![],
          Terminator::Return(Some(v)) => vec![*v],
          Terminator::Branch(_, args) => args.clone(),
 -        Terminator::CondBranch { cond, true_args, false_args, .. } => {
 +        Terminator::CondBranch {
 +            cond,
 +            true_args,
 +            false_args,
 +            ..
 +        } => {
              let mut uses = vec![*cond];
              uses.extend(true_args);
              uses.extend(false_args);
      match term {
          Terminator::Return(_) | Terminator::Unreachable => vec![],
          Terminator::Branch(d, _) => vec![*d],
 -        Terminator::CondBranch { true_dest, false_dest, .. } => vec![*true_dest, *false_dest],
 +        Terminator::CondBranch {
 +            true_dest,
 +            false_dest,
 +            ..
 +        } => vec![*true_dest, *false_dest],
          Terminator::Switch { cases, default, .. } => {
              let mut t: Vec<BlockId> = cases.iter().map(|(_, b)| *b).collect();
              t.push(*default);
  /// Apply a closure to every operand slot of an instruction in place.
  pub fn for_each_operand_mut(kind: &mut InstKind, mut r: impl FnMut(&mut ValueId)) {
      match kind {
 -        InstKind::ConstInt(..) | InstKind::ConstFloat(..) |
 -        InstKind::ConstBool(..) | InstKind::ConstString(..) |
 -        InstKind::Undef(..) | InstKind::Alloca(..) |
 -        InstKind::GlobalAddr(..) => {}
+-
 -        InstKind::IAdd(a, b) | InstKind::ISub(a, b) |
 -        InstKind::IMul(a, b) | InstKind::IDiv(a, b) |
 -        InstKind::IMod(a, b) => { r(a); r(b); }
 +        InstKind::ConstInt(..)
 +        | InstKind::ConstFloat(..)
 +        | InstKind::ConstBool(..)
 +        | InstKind::ConstString(..)
 +        | InstKind::Undef(..)
 +        | InstKind::Alloca(..)
 +        | InstKind::GlobalAddr(..) => {}
++
 +        InstKind::IAdd(a, b)
 +        | InstKind::ISub(a, b)
 +        | InstKind::IMul(a, b)
 +        | InstKind::IDiv(a, b)
 +        | InstKind::IMod(a, b) => {
 +            r(a);
 +            r(b);
 +        }
          InstKind::INeg(a) => r(a),
 -        InstKind::FAdd(a, b) | InstKind::FSub(a, b) |
 -        InstKind::FMul(a, b) | InstKind::FDiv(a, b) |
 -        InstKind::FPow(a, b) => { r(a); r(b); }
 +        InstKind::FAdd(a, b)
 +        | InstKind::FSub(a, b)
 +        | InstKind::FMul(a, b)
 +        | InstKind::FDiv(a, b)
 +        | InstKind::FPow(a, b) => {
 +            r(a);
 +            r(b);
 +        }
          InstKind::FNeg(a) | InstKind::FAbs(a) | InstKind::FSqrt(a) => r(a),
 -        InstKind::ICmp(_, a, b) | InstKind::FCmp(_, a, b) => { r(a); r(b); }
 +        InstKind::ICmp(_, a, b) | InstKind::FCmp(_, a, b) => {
 +            r(a);
 +            r(b);
 +        }
 -        InstKind::And(a, b) | InstKind::Or(a, b) => { r(a); r(b); }
 +        InstKind::And(a, b) | InstKind::Or(a, b) => {
 +            r(a);
 +            r(b);
 +        }
          InstKind::Not(a) => r(a),
 -        InstKind::Select(c, t, f) => { r(c); r(t); r(f); }
+-
 -        InstKind::BitAnd(a, b) | InstKind::BitOr(a, b) |
 -        InstKind::BitXor(a, b) | InstKind::Shl(a, b) |
 -        InstKind::LShr(a, b) | InstKind::AShr(a, b) => { r(a); r(b); }
 -        InstKind::BitNot(a) | InstKind::CountLeadingZeros(a) |
 -        InstKind::CountTrailingZeros(a) | InstKind::PopCount(a) => r(a),
 +        InstKind::Select(c, t, f) => {
 +            r(c);
 +            r(t);
 +            r(f);
 +        }
 -        InstKind::IntToFloat(v, _) | InstKind::FloatToInt(v, _) |
 -        InstKind::FloatExtend(v, _) | InstKind::FloatTrunc(v, _) |
 -        InstKind::IntExtend(v, _, _) | InstKind::IntTrunc(v, _) |
 -        InstKind::PtrToInt(v) | InstKind::IntToPtr(v, _) => r(v),
 +        InstKind::BitAnd(a, b)
 +        | InstKind::BitOr(a, b)
 +        | InstKind::BitXor(a, b)
 +        | InstKind::Shl(a, b)
 +        | InstKind::LShr(a, b)
 +        | InstKind::AShr(a, b) => {
 +            r(a);
 +            r(b);
 +        }
 +        InstKind::BitNot(a)
 +        | InstKind::CountLeadingZeros(a)
 +        | InstKind::CountTrailingZeros(a)
 +        | InstKind::PopCount(a) => r(a),
++
 +        InstKind::IntToFloat(v, _)
 +        | InstKind::FloatToInt(v, _)
 +        | InstKind::FloatExtend(v, _)
 +        | InstKind::FloatTrunc(v, _)
 +        | InstKind::IntExtend(v, _, _)
 +        | InstKind::IntTrunc(v, _)
 +        | InstKind::PtrToInt(v)
 +        | InstKind::IntToPtr(v, _) => r(v),
          InstKind::Load(a) => r(a),
 -        InstKind::Store(v, a) => { r(v); r(a); }
 +        InstKind::Store(v, a) => {
 +            r(v);
 +            r(a);
 +        }
          InstKind::GetElementPtr(base, idxs) => {
              r(base);
 -            for i in idxs { r(i); }
 +            for i in idxs {
 +                r(i);
 +            }
+         }
          InstKind::Call(FuncRef::Indirect(target), args) => {
              r(target);
 -            for a in args { r(a); }
 +            for a in args {
 +                r(a);
 +            }
+         }
          InstKind::Call(_, args) | InstKind::RuntimeCall(_, args) => {
 -            for a in args { r(a); }
 +            for a in args {
 +                r(a);
 +            }
+         }
          InstKind::ExtractField(agg, _) => r(agg),
 -        InstKind::InsertField(agg, _, val) => { r(agg); r(val); }
 +        InstKind::InsertField(agg, _, val) => {
 +            r(agg);
 +            r(val);
 +        }
+     }
+ }
  /// Apply a closure to every operand slot of a terminator in place.
 -pub fn for_each_terminator_operand_mut(
 -    term: &mut Terminator,
 -    mut r: impl FnMut(&mut ValueId),
 -) {
 +pub fn for_each_terminator_operand_mut(term: &mut Terminator, mut r: impl FnMut(&mut ValueId)) {
      match term {
          Terminator::Return(None) | Terminator::Unreachable => {}
          Terminator::Return(Some(v)) => r(v),
 -        Terminator::Branch(_, args) => for a in args { r(a); },
 -        Terminator::CondBranch { cond, true_args, false_args, .. } => {
 +        Terminator::Branch(_, args) => {
 +            for a in args {
 +                r(a);
 +            }
 +        }
 +        Terminator::CondBranch {
 +            cond,
 +            true_args,
 +            false_args,
 +            ..
 +        } => {
              r(cond);
 -            for a in true_args { r(a); }
 -            for a in false_args { r(a); }
 +            for a in true_args {
 +                r(a);
 +            }
 +            for a in false_args {
 +                r(a);
 +            }
+         }
          Terminator::Switch { selector, .. } => r(selector),
+     }
  /// Definitions are unaffected — only operand slots in instructions and
  /// terminators are rewritten.
  pub fn substitute_uses(func: &mut Function, old: ValueId, new: ValueId) {
 -    let r = |v: &mut ValueId| if *v == old { *v = new; };
 +    let r = |v: &mut ValueId| {
 +        if *v == old {
 +            *v = new;
 +        }
 +    };
      for block in &mut func.blocks {
          for inst in &mut block.insts {
              for_each_operand_mut(&mut inst.kind, r);
      // update them — they participate in no meaningful dominance
      // relationship.
      for block in &func.blocks {
 -        if block.id == func.entry { continue; }
 +        if block.id == func.entry {
 +            continue;
 +        }
          if reachable.contains(&block.id) {
              doms.insert(block.id, reachable.clone());
          } else {
      while changed {
          changed = false;
          for block in &func.blocks {
 -            if block.id == func.entry { continue; }
 -            if !reachable.contains(&block.id) { continue; }
 +            if block.id == func.entry {
 +                continue;
 +            }
 +            if !reachable.contains(&block.id) {
 +                continue;
 +            }
              let plist = preds.get(&block.id).cloned().unwrap_or_default();
              // Reachable-only predecessors — an edge from an
              // unreachable block doesn't contribute to dominance.
 -            let reachable_preds: Vec<BlockId> = plist.into_iter()
 +            let reachable_preds: Vec<BlockId> = plist
 +                .into_iter()
                  .filter(|p| reachable.contains(p))
                  .collect();
 -            if reachable_preds.is_empty() { continue; }
 +            if reachable_preds.is_empty() {
 +                continue;
 +            }
              let mut new_dom = reachable.clone();
              for p in &reachable_preds {
                  if let Some(pd) = doms.get(p) {
          // everything reachable from the entry, which both inflates
          // the body and makes `find_preheader` see no out-of-loop
          // predecessor for the header.
 -        let mut stack: Vec<BlockId> = latches.iter()
 -            .filter(|&&l| l != header)
 -            .copied()
 -            .collect();
 +        let mut stack: Vec<BlockId> = latches.iter().filter(|&&l| l != header).copied().collect();
          while let Some(b) = stack.pop() {
              if let Some(plist) = preds.get(&b) {
                  for &p in plist {
 -                    if p == header { continue; }
 +                    if p == header {
 +                        continue;
 +                    }
                      if body.insert(p) {
                          stack.push(p);
+                     }
+                 }
+             }
+         }
 -        loops.push(NaturalLoop { header, body, latches });
 +        loops.push(NaturalLoop {
 +            header,
 +            body,
 +            latches,
 +        });
+     }
      loops
+ }
      queue.push_back(func.entry);
      reachable.insert(func.entry);
      while let Some(bid) = queue.pop_front() {
 -        let Some(block) = func.try_block(bid) else { continue };
 +        let Some(block) = func.try_block(bid) else {
 +            continue;
 +        };
          if let Some(term) = &block.terminator {
              for tgt in terminator_targets(term) {
                  if reachable.insert(tgt) {
      let mut idoms: HashMap<BlockId, BlockId> = HashMap::new();
      for block in &func.blocks {
 -        if block.id == func.entry { continue; }
 -        let Some(my_doms) = doms.get(&block.id) else { continue };
 -        if my_doms.is_empty() { continue; } // unreachable
 +        if block.id == func.entry {
 +            continue;
 +        }
 +        let Some(my_doms) = doms.get(&block.id) else {
 +            continue;
 +        };
 +        if my_doms.is_empty() {
 +            continue;
 +        } // unreachable
          // The immediate dominator is the dominator (other than
          // self) that is dominated by every other dominator (other
          // than self). Equivalently: the dominator that has the
          // largest dominator set — all other dominators of `block`
          // also dominate the idom.
 -        let candidates: Vec<BlockId> = my_doms.iter()
 -            .copied()
 -            .filter(|&d| d != block.id)
 -            .collect();
 +        let candidates: Vec<BlockId> = my_doms.iter().copied().filter(|&d| d != block.id).collect();
          let idom = candidates.iter().copied().find(|&cand| {
              // cand is idom iff no other candidate strictly
              // dominates it (only cand itself and cand's own
              // dominators do).
              let cand_doms = doms.get(&cand).cloned().unwrap_or_default();
 -            candidates.iter().all(|&other| {
 -                other == cand || cand_doms.contains(&other)
 -            })
 +            candidates
 +                .iter()
 +                .all(|&other| other == cand || cand_doms.contains(&other))
          });
          if let Some(idom) = idom {
  /// `children[B]` is the set of blocks whose immediate dominator is
  /// `B`. A dominator-tree traversal visits `B` then recurses into
  /// `children[B]` in some order.
 -pub fn dominator_tree_children(idoms: &HashMap<BlockId, BlockId>)
 -    -> HashMap<BlockId, Vec<BlockId>>
 -{
 +pub fn dominator_tree_children(
 +    idoms: &HashMap<BlockId, BlockId>,
 +) -> HashMap<BlockId, Vec<BlockId>> {
      let mut children: HashMap<BlockId, Vec<BlockId>> = HashMap::new();
      for (&child, &parent) in idoms {
          children.entry(parent).or_default().push(child);
  /// for every join point `X` (block with ≥ 2 predecessors), walk
  /// each predecessor `P` upward in the dominator tree, adding `X`
  /// to `DF(runner)` until `runner == idom(X)`.
 -pub fn compute_dominance_frontiers(func: &Function)
 -    -> HashMap<BlockId, HashSet<BlockId>>
 -{
 +pub fn compute_dominance_frontiers(func: &Function) -> HashMap<BlockId, HashSet<BlockId>> {
      let idoms = compute_immediate_dominators(func);
      let preds = predecessors(func);
      // unreachable predecessors that downstream consumers (mem2reg's
      // iterated-DF closure in particular) must then defensively
      // ignore. Filtering at the source keeps the DF map clean.
 -    let reachable: HashSet<BlockId> = idoms.keys().copied()
 +    let reachable: HashSet<BlockId> = idoms
 +        .keys()
 +        .copied()
          .chain(std::iter::once(func.entry))
          .collect();
      for block in &func.blocks {
          let x = block.id;
 -        if !reachable.contains(&x) { continue; }
 +        if !reachable.contains(&x) {
 +            continue;
 +        }
          let plist = preds.get(&x).cloned().unwrap_or_default();
          // Drop unreachable predecessors before counting toward
          // "join point" status. An unreachable predecessor adds no
          // runtime control flow into x.
 -        let plist: Vec<BlockId> = plist.into_iter()
 +        let plist: Vec<BlockId> = plist
 +            .into_iter()
              .filter(|p| reachable.contains(p))
              .collect();
 -        if plist.len() < 2 { continue; }
 +        if plist.len() < 2 {
 +            continue;
 +        }
          // `x` is a join point. Walk each predecessor upward.
          let idom_x = idoms.get(&x).copied();
  #[cfg(test)]
  mod walk_tests {
 -    use super::*;
      use super::super::types::IrType;
 -    use crate::lexer::{Span, Position};
 +    use super::*;
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      /// Build a diamond CFG:
          let entry = f.entry;
          let c0 = f.next_value_id();
          f.block_mut(entry).insts.push(Inst {
 -            id: c0, kind: InstKind::ConstBool(true),
 -            ty: IrType::Bool, span: dummy_span(),
 +            id: c0,
 +            kind: InstKind::ConstBool(true),
 +            ty: IrType::Bool,
 +            span: dummy_span(),
          });
          f.block_mut(entry).terminator = Some(Terminator::CondBranch {
 -            cond: c0, true_dest: a, true_args: vec![],
 -            false_dest: b, false_args: vec![],
 +            cond: c0,
 +            true_dest: a,
 +            true_args: vec![],
 +            false_dest: b,
 +            false_args: vec![],
          });
          let c1 = f.next_value_id();
          f.block_mut(b).insts.push(Inst {
 -            id: c1, kind: InstKind::ConstBool(true),
 -            ty: IrType::Bool, span: dummy_span(),
 +            id: c1,
 +            kind: InstKind::ConstBool(true),
 +            ty: IrType::Bool,
 +            span: dummy_span(),
          });
          f.block_mut(b).terminator = Some(Terminator::CondBranch {
 -            cond: c1, true_dest: c, true_args: vec![],
 -            false_dest: d, false_args: vec![],
 +            cond: c1,
 +            true_dest: c,
 +            true_args: vec![],
 +            false_dest: d,
 +            false_args: vec![],
          });
          f.block_mut(c).terminator = Some(Terminator::Branch(m1, vec![]));
          f.block_mut(d).terminator = Some(Terminator::Branch(m1, vec![]));
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
          let idoms = compute_immediate_dominators(&f);
 -        assert!(idoms.is_empty(), "single-block function should have no idoms");
 +        assert!(
 +            idoms.is_empty(),
 +            "single-block function should have no idoms"
 +        );
          let df = compute_dominance_frontiers(&f);
          // Entry is reachable, so it has an entry in the DF map, but
          let exit = f.create_block("exit");
          f.block_mut(f.entry).terminator = Some(Terminator::CondBranch {
              cond,
 -            true_dest: f.entry, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: f.entry,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          f.block_mut(exit).terminator = Some(Terminator::Return(None));
          let idoms = compute_immediate_dominators(&f);
 -        assert!(!idoms.contains_key(&f.entry), "entry has no idom even with a self-edge");
 +        assert!(
 +            !idoms.contains_key(&f.entry),
 +            "entry has no idom even with a self-edge"
 +        );
          assert_eq!(idoms[&exit], f.entry);
          let df = compute_dominance_frontiers(&f);
          // the implicit "function entry edge" doesn't count, so entry
          // has 1 reachable pred. Not a join point — entry ∉ any DF.
          for (b, frontier) in &df {
 -            assert!(!frontier.contains(&f.entry),
 -                "entry should not appear in DF[{:?}]", b);
 +            assert!(
 +                !frontier.contains(&f.entry),
 +                "entry should not appear in DF[{:?}]",
 +                b
 +            );
+         }
+     }
          });
          f.block_mut(b).terminator = Some(Terminator::CondBranch {
              cond,
 -            true_dest: b, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: b,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          f.block_mut(exit).terminator = Some(Terminator::Return(None));
          let df = compute_dominance_frontiers(&f);
 -        assert_eq!(df[&b], HashSet::from([b]),
 -            "b's self-edge puts b in its own dominance frontier");
 +        assert_eq!(
 +            df[&b],
 +            HashSet::from([b]),
 +            "b's self-edge puts b in its own dominance frontier"
 +        );
          let idoms = compute_immediate_dominators(&f);
          assert_eq!(idoms[&b], f.entry);
          assert_eq!(idoms[&exit], b);
          // entry → cond ? a : b
          let c0 = f.next_value_id();
          f.block_mut(f.entry).insts.push(Inst {
 -            id: c0, kind: InstKind::ConstBool(true),
 -            ty: IrType::Bool, span: dummy_span(),
 +            id: c0,
 +            kind: InstKind::ConstBool(true),
 +            ty: IrType::Bool,
 +            span: dummy_span(),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::CondBranch {
              cond: c0,
 -            true_dest: a, true_args: vec![],
 -            false_dest: b, false_args: vec![],
 +            true_dest: a,
 +            true_args: vec![],
 +            false_dest: b,
 +            false_args: vec![],
          });
          // a → b
          //                      bypasses it).
          let c1 = f.next_value_id();
          f.block_mut(b).insts.push(Inst {
 -            id: c1, kind: InstKind::ConstBool(true),
 -            ty: IrType::Bool, span: dummy_span(),
 +            id: c1,
 +            kind: InstKind::ConstBool(true),
 +            ty: IrType::Bool,
 +            span: dummy_span(),
          });
          f.block_mut(b).terminator = Some(Terminator::CondBranch {
              cond: c1,
 -            true_dest: a, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: a,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          f.block_mut(exit).terminator = Some(Terminator::Return(None));

src/lexer/mod.rsmodified

1237 lines changed — click to load

      Identifier,
      // ---- Operators ----
 -    Plus,           // +
 -    Minus,          // -
 -    Star,           // *
 -    Slash,          // /
 -    Power,          // **
 -    Concat,         // //
 -    Eq,             // ==
 -    Ne,             // /=
 -    Lt,             // <
 -    Gt,             // >
 -    Le,             // <=
 -    Ge,             // >=
 +    Plus,   // +
 +    Minus,  // -
 +    Star,   // *
 +    Slash,  // /
 +    Power,  // **
 +    Concat, // //
 +    Eq,     // ==
 +    Ne,     // /=
 +    Lt,     // <
 +    Gt,     // >
 +    Le,     // <=
 +    Ge,     // >=
      /// .eq. .ne. .lt. .gt. .le. .ge. .and. .or. .not. .eqv. .neqv.
      DotOp(String),
      /// User-defined operator: .myop.
      DefinedOp(String),
      // ---- Punctuation ----
 -    LParen,         // (
 -    RParen,         // )
 -    LBracket,       // [
 -    RBracket,       // ]
 -    Comma,          // ,
 -    Colon,          // :
 -    ColonColon,     // ::
 -    Semicolon,      // ;
 -    Percent,        // %
 -    Arrow,          // =>
 -    Assign,         // =
 -    Ampersand,      // & (when not continuation)
 +    LParen,     // (
 +    RParen,     // )
 +    LBracket,   // [
 +    RBracket,   // ]
 +    Comma,      // ,
 +    Colon,      // :
 +    ColonColon, // ::
 +    Semicolon,  // ;
 +    Percent,    // %
 +    Arrow,      // =>
 +    Assign,     // =
 +    Ampersand,  // & (when not continuation)
      // ---- Special ----
      Newline,
  /// The lexer provides `is_keyword()` as a helper.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  pub enum Keyword {
 -    Program, EndProgram, Module, EndModule, Submodule, EndSubmodule,
 -    Subroutine, EndSubroutine, Function, EndFunction, BlockData, EndBlockData,
 -    Contains, Use, Only, Import,
 -    Implicit, None,
 -    Integer, Real, DoublePrecision, DoubleComplex, Complex, Character, Logical, Type, Class,
 -    Dimension, Allocatable, Pointer, Target, Intent, In, Out, InOut,
 -    Optional, Save, Parameter, Value, Volatile, Asynchronous, Protected,
 -    Contiguous, External, Intrinsic, Bind,
 -    Public, Private,
 -    If, Then, Else, ElseIf, EndIf,
 -    Do, EndDo, While, Concurrent,
 -    Select, Case, EndSelect, Default,
 -    Where, EndWhere, Elsewhere,
 -    Forall, EndForall,
 -    Block, EndBlock,
 -    Associate, EndAssociate,
 -    Critical, EndCritical,
 +    Program,
 +    EndProgram,
 +    Module,
 +    EndModule,
 +    Submodule,
 +    EndSubmodule,
 +    Subroutine,
 +    EndSubroutine,
 +    Function,
 +    EndFunction,
 +    BlockData,
 +    EndBlockData,
 +    Contains,
 +    Use,
 +    Only,
 +    Import,
 +    Implicit,
 +    None,
 +    Integer,
 +    Real,
 +    DoublePrecision,
 +    DoubleComplex,
 +    Complex,
 +    Character,
 +    Logical,
 +    Type,
 +    Class,
 +    Dimension,
 +    Allocatable,
 +    Pointer,
 +    Target,
 +    Intent,
 +    In,
 +    Out,
 +    InOut,
 +    Optional,
 +    Save,
 +    Parameter,
 +    Value,
 +    Volatile,
 +    Asynchronous,
 +    Protected,
 +    Contiguous,
 +    External,
 +    Intrinsic,
 +    Bind,
 +    Public,
 +    Private,
 +    If,
 +    Then,
 +    Else,
 +    ElseIf,
 +    EndIf,
 +    Do,
 +    EndDo,
 +    While,
 +    Concurrent,
 +    Select,
 +    Case,
 +    EndSelect,
 +    Default,
 +    Where,
 +    EndWhere,
 +    Elsewhere,
 +    Forall,
 +    EndForall,
 +    Block,
 +    EndBlock,
 +    Associate,
 +    EndAssociate,
 +    Critical,
 +    EndCritical,
      Continue,
 -    Exit, Cycle, Stop, ErrorStop, Return, GoTo,
 -    Call, Print, Write, Read, Open, Close, Inquire,
 -    Rewind, Backspace, Endfile, Flush, Wait,
 -    Allocate, Deallocate, Nullify,
 -    Data, Common, Equivalence, Namelist, Sequence,
 +    Exit,
 +    Cycle,
 +    Stop,
 +    ErrorStop,
 +    Return,
 +    GoTo,
 +    Call,
 +    Print,
 +    Write,
 +    Read,
 +    Open,
 +    Close,
 +    Inquire,
 +    Rewind,
 +    Backspace,
 +    Endfile,
 +    Flush,
 +    Wait,
 +    Allocate,
 +    Deallocate,
 +    Nullify,
 +    Data,
 +    Common,
 +    Equivalence,
 +    Namelist,
 +    Sequence,
      Format,
 -    Pure, Impure, Elemental, Recursive, NonRecursive,
 -    Abstract, Interface, EndInterface, Procedure, Generic, Operator, Assignment,
 -    Entry, Result,
 -    Enum, Enumerator, EndEnum,
 +    Pure,
 +    Impure,
 +    Elemental,
 +    Recursive,
 +    NonRecursive,
 +    Abstract,
 +    Interface,
 +    EndInterface,
 +    Procedure,
 +    Generic,
 +    Operator,
 +    Assignment,
 +    Entry,
 +    Result,
 +    Enum,
 +    Enumerator,
 +    EndEnum,
      End,
+ }
  // ---- Known dot-operators ----
  fn is_known_dot_op(name: &str) -> bool {
 -    matches!(name.to_lowercase().as_str(),
 -        "and" | "or" | "not" | "eqv" | "neqv" |
 -        "eq" | "ne" | "lt" | "gt" | "le" | "ge" |
 -        "true" | "false"
 +    matches!(
 +        name.to_lowercase().as_str(),
 +        "and"
 +            | "or"
 +            | "not"
 +            | "eqv"
 +            | "neqv"
 +            | "eq"
 +            | "ne"
 +            | "lt"
 +            | "gt"
 +            | "le"
 +            | "ge"
 +            | "true"
 +            | "false"
+     )
+ }
  impl fmt::Display for LexError {
      fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 -        write!(f, "{}:{}: error: {}", self.span.start.line, self.span.start.col, self.msg)
 +        write!(
 +            f,
 +            "{}:{}: error: {}",
 +            self.span.start.line, self.span.start.col, self.msg
 +        )
+     }
+ }
  impl<'a> Lexer<'a> {
      pub fn new(src: &'a str, file_id: u32) -> Self {
 -        Self { src: src.as_bytes(), pos: 0, line: 1, col: 1, file_id }
 +        Self {
 +            src: src.as_bytes(),
 +            pos: 0,
 +            line: 1,
 +            col: 1,
 +            file_id,
 +        }
+     }
      /// Tokenize the entire source into a Vec.
              let tok = lexer.next_token()?;
              let is_eof = tok.kind == TokenKind::Eof;
              tokens.push(tok);
 -            if is_eof { break; }
 +            if is_eof {
 +                break;
 +            }
+         }
          Ok(tokens)
+     }
      fn pos(&self) -> Position {
 -        Position { line: self.line, col: self.col }
 +        Position {
 +            line: self.line,
 +            col: self.col,
 +        }
+     }
      fn span_from(&self, start: Position) -> Span {
 -        Span { file_id: self.file_id, start, end: self.pos() }
 +        Span {
 +            file_id: self.file_id,
 +            start,
 +            end: self.pos(),
 +        }
+     }
      fn err(&self, start: Position, msg: String) -> LexError {
 -        LexError { span: self.span_from(start), msg }
 +        LexError {
 +            span: self.span_from(start),
 +            msg,
 +        }
+     }
      fn peek(&self) -> u8 {
 -        if self.pos < self.src.len() { self.src[self.pos] } else { 0 }
 +        if self.pos < self.src.len() {
 +            self.src[self.pos]
 +        } else {
 +            0
 +        }
+     }
      fn peek2(&self) -> u8 {
 -        if self.pos + 1 < self.src.len() { self.src[self.pos + 1] } else { 0 }
 +        if self.pos + 1 < self.src.len() {
 +            self.src[self.pos + 1]
 +        } else {
 +            0
 +        }
+     }
      fn advance(&mut self) -> u8 {
      /// Skip a continuation: & at end of line, optional comment, newline, optional leading &.
      /// Returns true if a continuation was consumed.
      fn try_continuation(&mut self) -> bool {
 -        if self.peek() != b'&' { return false; }
 +        if self.peek() != b'&' {
 +            return false;
 +        }
          // Save position in case this isn't a continuation.
          let save_pos = self.pos;
                  while !self.at_end() && self.peek() != b'\n' {
                      self.advance();
+                 }
 -                if !self.at_end() { self.advance(); }
 +                if !self.at_end() {
 +                    self.advance();
 +                }
                  continue;
+             }
              break;
                  let save_col = self.col;
                  self.advance(); // &
 -                // String-continuation check. A lone `&` ending the
 -                // current physical line (optionally with trailing
 -                // whitespace and/or a `!comment`) continues the
 -                // string on the next line. Anything else — notably a
 -                // closing quote before the newline — means the `&`
 -                // is a literal character of the string.
 -                //
 -                // Scan from the current pos without committing: find
 -                // the earliest of quote, `!`, or newline. Only newline
 -                // (possibly preceded by whitespace or a comment) keeps
 -                // is_cont true.
 +                                // String-continuation check. A lone `&` ending the
 +                                // current physical line (optionally with trailing
 +                                // whitespace and/or a `!comment`) continues the
 +                                // string on the next line. Anything else — notably a
 +                                // closing quote before the newline — means the `&`
 +                                // is a literal character of the string.
 +                                //
 +                                // Scan from the current pos without committing: find
 +                                // the earliest of quote, `!`, or newline. Only newline
 +                                // (possibly preceded by whitespace or a comment) keeps
 +                                // is_cont true.
                  let mut is_cont = false;
                  let mut scan = self.pos;
                  let src_bytes = self.src;
                  if is_cont && !self.at_end() {
                      self.advance(); // newline
                      self.skip_spaces();
 -                    if self.peek() == b'&' { self.advance(); }
 +                    if self.peek() == b'&' {
 +                        self.advance();
 +                    }
                      continue;
+                 }
                  // Not a continuation — restore and treat & as literal character.
                  // Could be 1.0e5 (exponent) or 1.eq.2 (dot-operator).
                  // Lookahead past the e/d: if next is digit or +/-, it's an exponent.
                  // If it's another letter (like 'q' in 'eq'), it's a dot-operator.
 -                let after_ed = if self.pos + 2 < self.src.len() { self.src[self.pos + 2] } else { 0 };
 +                let after_ed = if self.pos + 2 < self.src.len() {
 +                    self.src[self.pos + 2]
 +                } else {
 +                    0
 +                };
                  matches!(after_ed, b'0'..=b'9' | b'+' | b'-')
              } else if !next.is_ascii_alphabetic() {
                  // 5. followed by space/operator/newline/EOF — trailing dot real.
+         }
          Ok(Token {
 -            kind: if is_real { TokenKind::RealLiteral } else { TokenKind::IntegerLiteral },
 +            kind: if is_real {
 +                TokenKind::RealLiteral
 +            } else {
 +                TokenKind::IntegerLiteral
 +            },
              text,
              span: self.span_from(start),
          })
                  return Ok(Token {
                      kind: TokenKind::Identifier,
                      text: "..".into(),
 -                    span: Span { start, end: self.pos(), file_id: self.file_id },
 +                    span: Span {
 +                        start,
 +                        end: self.pos(),
 +                        file_id: self.file_id,
 +                    },
                  });
+             }
              return Err(self.err(start, "unexpected '.'".into()));
          let (kind, text) = match ch {
              b'+' => (TokenKind::Plus, "+"),
              b'-' => (TokenKind::Minus, "-"),
 -            b'*' if next == b'*' => { self.advance(); (TokenKind::Power, "**") }
 +            b'*' if next == b'*' => {
 +                self.advance();
 +                (TokenKind::Power, "**")
 +            }
              b'*' => (TokenKind::Star, "*"),
 -            b'/' if next == b'/' => { self.advance(); (TokenKind::Concat, "//") }
 -            b'/' if next == b'=' => { self.advance(); (TokenKind::Ne, "/=") }
 +            b'/' if next == b'/' => {
 +                self.advance();
 +                (TokenKind::Concat, "//")
 +            }
 +            b'/' if next == b'=' => {
 +                self.advance();
 +                (TokenKind::Ne, "/=")
 +            }
              b'/' => (TokenKind::Slash, "/"),
 -            b'=' if next == b'=' => { self.advance(); (TokenKind::Eq, "==") }
 -            b'=' if next == b'>' => { self.advance(); (TokenKind::Arrow, "=>") }
 +            b'=' if next == b'=' => {
 +                self.advance();
 +                (TokenKind::Eq, "==")
 +            }
 +            b'=' if next == b'>' => {
 +                self.advance();
 +                (TokenKind::Arrow, "=>")
 +            }
              b'=' => (TokenKind::Assign, "="),
 -            b'<' if next == b'=' => { self.advance(); (TokenKind::Le, "<=") }
 +            b'<' if next == b'=' => {
 +                self.advance();
 +                (TokenKind::Le, "<=")
 +            }
              b'<' => (TokenKind::Lt, "<"),
 -            b'>' if next == b'=' => { self.advance(); (TokenKind::Ge, ">=") }
 +            b'>' if next == b'=' => {
 +                self.advance();
 +                (TokenKind::Ge, ">=")
 +            }
              b'>' => (TokenKind::Gt, ">"),
              b'(' => (TokenKind::LParen, "("),
              b')' => (TokenKind::RParen, ")"),
              b'[' => (TokenKind::LBracket, "["),
              b']' => (TokenKind::RBracket, "]"),
              b',' => (TokenKind::Comma, ","),
 -            b':' if next == b':' => { self.advance(); (TokenKind::ColonColon, "::") }
 +            b':' if next == b':' => {
 +                self.advance();
 +                (TokenKind::ColonColon, "::")
 +            }
              b':' => (TokenKind::Colon, ":"),
              b';' => (TokenKind::Semicolon, ";"),
              b'%' => (TokenKind::Percent, "%"),
+     }
      fn kinds(src: &str) -> Vec<TokenKind> {
 -        toks(src).into_iter().map(|t| t.kind).filter(|k| !matches!(k, TokenKind::Eof)).collect()
 +        toks(src)
 +            .into_iter()
 +            .map(|t| t.kind)
 +            .filter(|k| !matches!(k, TokenKind::Eof))
 +            .collect()
+     }
      fn texts(src: &str) -> Vec<String> {
 -        toks(src).into_iter().map(|t| t.text).filter(|t| !t.is_empty()).collect()
 +        toks(src)
 +            .into_iter()
 +            .map(|t| t.text)
 +            .filter(|t| !t.is_empty())
 +            .collect()
+     }
      // ---- Identifiers ----
      fn keyword_is_identifier() {
          // Keywords are not reserved — lexed as identifiers.
          let toks = kinds("integer real do if");
 -        assert_eq!(toks, vec![
 -            TokenKind::Identifier, TokenKind::Identifier,
 -            TokenKind::Identifier, TokenKind::Identifier,
 -        ]);
 +        assert_eq!(
 +            toks,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Identifier,
 +                TokenKind::Identifier,
 +                TokenKind::Identifier,
 +            ]
 +        );
+     }
      #[test]
      #[test]
      fn arithmetic_operators() {
 -        assert_eq!(kinds("+ - * /"), vec![
 -            TokenKind::Plus, TokenKind::Minus, TokenKind::Star, TokenKind::Slash,
 -        ]);
 +        assert_eq!(
 +            kinds("+ - * /"),
 +            vec![
 +                TokenKind::Plus,
 +                TokenKind::Minus,
 +                TokenKind::Star,
 +                TokenKind::Slash,
 +            ]
 +        );
+     }
      #[test]
      #[test]
      fn comparison_operators() {
 -        assert_eq!(kinds("== /= < > <= >="), vec![
 -            TokenKind::Eq, TokenKind::Ne, TokenKind::Lt, TokenKind::Gt,
 -            TokenKind::Le, TokenKind::Ge,
 -        ]);
 +        assert_eq!(
 +            kinds("== /= < > <= >="),
 +            vec![
 +                TokenKind::Eq,
 +                TokenKind::Ne,
 +                TokenKind::Lt,
 +                TokenKind::Gt,
 +                TokenKind::Le,
 +                TokenKind::Ge,
 +            ]
 +        );
+     }
      #[test]
      fn dot_comparison_operators() {
 -        assert_eq!(kinds(".eq. .ne. .lt. .gt. .le. .ge."), vec![
 -            TokenKind::DotOp("eq".into()), TokenKind::DotOp("ne".into()),
 -            TokenKind::DotOp("lt".into()), TokenKind::DotOp("gt".into()),
 -            TokenKind::DotOp("le".into()), TokenKind::DotOp("ge".into()),
 -        ]);
 +        assert_eq!(
 +            kinds(".eq. .ne. .lt. .gt. .le. .ge."),
 +            vec![
 +                TokenKind::DotOp("eq".into()),
 +                TokenKind::DotOp("ne".into()),
 +                TokenKind::DotOp("lt".into()),
 +                TokenKind::DotOp("gt".into()),
 +                TokenKind::DotOp("le".into()),
 +                TokenKind::DotOp("ge".into()),
 +            ]
 +        );
+     }
      #[test]
      fn dot_logical_operators() {
 -        assert_eq!(kinds(".and. .or. .not."), vec![
 -            TokenKind::DotOp("and".into()), TokenKind::DotOp("or".into()),
 -            TokenKind::DotOp("not".into()),
 -        ]);
 +        assert_eq!(
 +            kinds(".and. .or. .not."),
 +            vec![
 +                TokenKind::DotOp("and".into()),
 +                TokenKind::DotOp("or".into()),
 +                TokenKind::DotOp("not".into()),
 +            ]
 +        );
+     }
      #[test]
      fn dot_eqv_neqv() {
 -        assert_eq!(kinds(".eqv. .neqv."), vec![
 -            TokenKind::DotOp("eqv".into()), TokenKind::DotOp("neqv".into()),
 -        ]);
 +        assert_eq!(
 +            kinds(".eqv. .neqv."),
 +            vec![
 +                TokenKind::DotOp("eqv".into()),
 +                TokenKind::DotOp("neqv".into()),
 +            ]
 +        );
+     }
      #[test]
      #[test]
      fn punctuation() {
 -        assert_eq!(kinds("( ) [ ] , : ; %"), vec![
 -            TokenKind::LParen, TokenKind::RParen,
 -            TokenKind::LBracket, TokenKind::RBracket,
 -            TokenKind::Comma, TokenKind::Colon, TokenKind::Semicolon, TokenKind::Percent,
 -        ]);
 +        assert_eq!(
 +            kinds("( ) [ ] , : ; %"),
 +            vec![
 +                TokenKind::LParen,
 +                TokenKind::RParen,
 +                TokenKind::LBracket,
 +                TokenKind::RBracket,
 +                TokenKind::Comma,
 +                TokenKind::Colon,
 +                TokenKind::Semicolon,
 +                TokenKind::Percent,
 +            ]
 +        );
+     }
      #[test]
      #[test]
      fn newline_is_statement_terminator() {
 -        assert_eq!(kinds("x\ny"), vec![
 -            TokenKind::Identifier, TokenKind::Newline, TokenKind::Identifier,
 -        ]);
 +        assert_eq!(
 +            kinds("x\ny"),
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Newline,
 +                TokenKind::Identifier,
 +            ]
 +        );
+     }
      #[test]
      fn semicolon_is_statement_separator() {
 -        assert_eq!(kinds("x; y"), vec![
 -            TokenKind::Identifier, TokenKind::Semicolon, TokenKind::Identifier,
 -        ]);
 +        assert_eq!(
 +            kinds("x; y"),
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Semicolon,
 +                TokenKind::Identifier,
 +            ]
 +        );
+     }
      // ---- Continuation lines ----
      #[test]
      fn continuation_joins_tokens() {
          let k = kinds("x + &\n  y");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Plus, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
      fn continuation_with_leading_ampersand() {
          let k = kinds("x + &\n  &y");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Plus, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
      fn continuation_with_comment() {
          let k = kinds("x + & ! comment\n  y");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Plus, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      // ---- Source locations ----
      #[test]
      fn complex_declaration() {
          let k = kinds("integer, allocatable :: x(:,:)");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::Comma, TokenKind::Identifier,
 -            TokenKind::ColonColon,
 -            TokenKind::Identifier, TokenKind::LParen, TokenKind::Colon,
 -            TokenKind::Comma, TokenKind::Colon, TokenKind::RParen,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Comma,
 +                TokenKind::Identifier,
 +                TokenKind::ColonColon,
 +                TokenKind::Identifier,
 +                TokenKind::LParen,
 +                TokenKind::Colon,
 +                TokenKind::Comma,
 +                TokenKind::Colon,
 +                TokenKind::RParen,
 +            ]
 +        );
+     }
      #[test]
      fn pointer_assignment() {
          let k = kinds("ptr => target");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Arrow, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Arrow,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
      fn component_access() {
          let k = kinds("obj%member");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Percent, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Percent,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
      fn array_constructor_bracket() {
          let k = kinds("[1, 2, 3]");
 -        assert_eq!(k, vec![
 -            TokenKind::LBracket, TokenKind::IntegerLiteral, TokenKind::Comma,
 -            TokenKind::IntegerLiteral, TokenKind::Comma, TokenKind::IntegerLiteral,
 -            TokenKind::RBracket,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::LBracket,
 +                TokenKind::IntegerLiteral,
 +                TokenKind::Comma,
 +                TokenKind::IntegerLiteral,
 +                TokenKind::Comma,
 +                TokenKind::IntegerLiteral,
 +                TokenKind::RBracket,
 +            ]
 +        );
+     }
      // ---- Ambiguity cases from spec ----
      #[test]
      fn integer_dot_and_with_spaces() {
          let k = kinds("a .and. b");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::DotOp("and".into()), TokenKind::Identifier,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::DotOp("and".into()),
 +                TokenKind::Identifier,
 +            ]
 +        );
+     }
      #[test]
          // Critical ambiguity: 1.eq.2 must NOT be parsed as a real with exponent.
          // It's: integer(1), .eq., integer(2)
          let k = kinds("1.eq.2");
 -        assert_eq!(k, vec![
 -            TokenKind::IntegerLiteral, TokenKind::DotOp("eq".into()), TokenKind::IntegerLiteral,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::IntegerLiteral,
 +                TokenKind::DotOp("eq".into()),
 +                TokenKind::IntegerLiteral,
 +            ]
 +        );
+     }
      #[test]
      fn integer_dot_and_no_spaces() {
          let k = kinds("1.and.2");
 -        assert_eq!(k, vec![
 -            TokenKind::IntegerLiteral, TokenKind::DotOp("and".into()), TokenKind::IntegerLiteral,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::IntegerLiteral,
 +                TokenKind::DotOp("and".into()),
 +                TokenKind::IntegerLiteral,
 +            ]
 +        );
+     }
      #[test]
      fn integer_dot_ne_no_spaces() {
          let k = kinds("x.ne.y");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::DotOp("ne".into()), TokenKind::Identifier,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::DotOp("ne".into()),
 +                TokenKind::Identifier,
 +            ]
 +        );
+     }
      #[test]
      fn five_dot_eq_three() {
          // 5.eq.3 — integer, .eq., integer (not a real)
          let k = kinds("5.eq.3");
 -        assert_eq!(k, vec![
 -            TokenKind::IntegerLiteral, TokenKind::DotOp("eq".into()), TokenKind::IntegerLiteral,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::IntegerLiteral,
 +                TokenKind::DotOp("eq".into()),
 +                TokenKind::IntegerLiteral,
 +            ]
 +        );
+     }
      // ---- Error cases ----
  end program hello
  ";
          let tokens = Lexer::tokenize(src, 0).unwrap();
 -        let ident_count = tokens.iter().filter(|t| t.kind == TokenKind::Identifier).count();
 -        assert!(ident_count >= 8, "expected 8+ identifiers, got {}", ident_count);
 -        let last_non_eof = tokens.iter().rev().find(|t| t.kind != TokenKind::Eof && t.kind != TokenKind::Newline).unwrap();
 +        let ident_count = tokens
 +            .iter()
 +            .filter(|t| t.kind == TokenKind::Identifier)
 +            .count();
 +        assert!(
 +            ident_count >= 8,
 +            "expected 8+ identifiers, got {}",
 +            ident_count
 +        );
 +        let last_non_eof = tokens
 +            .iter()
 +            .rev()
 +            .find(|t| t.kind != TokenKind::Eof && t.kind != TokenKind::Newline)
 +            .unwrap();
          assert_eq!(last_non_eof.text, "hello");
+     }
      /// Try to tokenize a fortsh source file. Strips preprocessor directives first.
      fn try_lex_fortsh_file(path: &str) -> Result<usize, String> {
 -        let src = std::fs::read_to_string(path)
 -            .map_err(|e| format!("{}: {}", path, e))?;
 +        let src = std::fs::read_to_string(path).map_err(|e| format!("{}: {}", path, e))?;
          // Strip preprocessor directives (lexer expects preprocessed input).
 -        let filtered: String = src.lines()
 -            .map(|line| if line.trim_start().starts_with('#') { "" } else { line })
 +        let filtered: String = src
 +            .lines()
 +            .map(|line| {
 +                if line.trim_start().starts_with('#') {
 +                    ""
 +                } else {
 +                    line
 +                }
 +            })
              .collect::<Vec<_>>()
              .join("\n");
 -        let tokens = Lexer::tokenize(&filtered, 0)
 -            .map_err(|e| format!("{}: {}", path, e))?;
 +        let tokens = Lexer::tokenize(&filtered, 0).map_err(|e| format!("{}: {}", path, e))?;
          Ok(tokens.len())
+     }
      #[test]
      fn multiple_continuations() {
          let k = kinds("x = a + &\n    b + &\n    c");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::Assign,
 -            TokenKind::Identifier, TokenKind::Plus,
 -            TokenKind::Identifier, TokenKind::Plus,
 -            TokenKind::Identifier,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Assign,
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier,
 +            ]
 +        );
+     }
      #[test]
      #[test]
      fn spec_ambiguity_real_function_call() {
          let k = kinds("x = real(i)");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::Assign,
 -            TokenKind::Identifier, TokenKind::LParen,
 -            TokenKind::Identifier, TokenKind::RParen,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Assign,
 +                TokenKind::Identifier,
 +                TokenKind::LParen,
 +                TokenKind::Identifier,
 +                TokenKind::RParen,
 +            ]
 +        );
+     }
      #[test]
          assert!(k.contains(&TokenKind::Comma));
          // "do" and "i" are both identifiers.
          let tokens = toks("do i = 1, 10");
 -        let idents: Vec<_> = tokens.iter()
 +        let idents: Vec<_> = tokens
 +            .iter()
              .filter(|t| t.kind == TokenKind::Identifier)
              .map(|t| t.text.as_str())
              .collect();
      #[test]
      fn spec_ambiguity_do_as_variable() {
          let k = kinds("do = 3.14");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::Assign, TokenKind::RealLiteral,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Assign,
 +                TokenKind::RealLiteral,
 +            ]
 +        );
          assert_eq!(toks("do = 3.14")[0].text, "do");
+     }
      #[test]
      fn semicolon_separates_statements() {
          let k = kinds("x = 1; y = 2");
 -        assert_eq!(k, vec![
 -            TokenKind::Identifier, TokenKind::Assign, TokenKind::IntegerLiteral,
 -            TokenKind::Semicolon,
 -            TokenKind::Identifier, TokenKind::Assign, TokenKind::IntegerLiteral,
 -        ]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Assign,
 +                TokenKind::IntegerLiteral,
 +                TokenKind::Semicolon,
 +                TokenKind::Identifier,
 +                TokenKind::Assign,
 +                TokenKind::IntegerLiteral,
 +            ]
 +        );
+     }
      // ---- Performance ----
      fn performance_fortsh_under_one_second() {
          let src_dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../fortsh/src");
          let root = std::path::Path::new(src_dir);
 -        if !root.exists() { return; }
 +        if !root.exists() {
 +            return;
 +        }
          // Collect all source.
          let mut all_source = String::new();
              if let Ok(entries) = std::fs::read_dir(dir) {
                  for entry in entries.flatten() {
                      let path = entry.path();
 -                    if path.is_dir() { collect(&path, buf); }
 -                    else if path.extension().map_or(false, |e| e == "f90") {
 +                    if path.is_dir() {
 +                        collect(&path, buf);
 +                    } else if path.extension().map_or(false, |e| e == "f90") {
                          if let Ok(src) = std::fs::read_to_string(&path) {
 -                            let filtered: String = src.lines()
 -                                .map(|l| if l.trim_start().starts_with('#') { "" } else { l })
 -                                .collect::<Vec<_>>().join("\n");
 +                            let filtered: String = src
 +                                .lines()
 +                                .map(|l| {
 +                                    if l.trim_start().starts_with('#') {
 +                                        ""
 +                                    } else {
 +                                        l
 +                                    }
 +                                })
 +                                .collect::<Vec<_>>()
 +                                .join("\n");
                              buf.push_str(&filtered);
                              buf.push('\n');
+                         }
          assert!(result.is_ok(), "failed to tokenize: {:?}", result.err());
          let tokens = result.unwrap();
 -        eprintln!("lexed {} tokens from ~{} lines in {:?}",
 -            tokens.len(), all_source.lines().count(), elapsed);
 -        assert!(elapsed.as_secs_f64() < 1.0,
 -            "too slow: {:?} (must be < 1s)", elapsed);
 +        eprintln!(
 +            "lexed {} tokens from ~{} lines in {:?}",
 +            tokens.len(),
 +            all_source.lines().count(),
 +            elapsed
 +        );
 +        assert!(
 +            elapsed.as_secs_f64() < 1.0,
 +            "too slow: {:?} (must be < 1s)",
 +            elapsed
 +        );
+     }
      // ======================================================================
      fn continuation_over_comment_line() {
          // Per F2018 6.3.2.4: comment lines between continued lines are allowed.
          let k = kinds("x + & \n! this is a comment\n  y");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Plus, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
      fn continuation_over_blank_line() {
          let k = kinds("x + &\n\n  y");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Plus, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
      fn continuation_over_multiple_comments_and_blanks() {
          let k = kinds("x + &\n! comment 1\n\n! comment 2\n  y");
 -        assert_eq!(k, vec![TokenKind::Identifier, TokenKind::Plus, TokenKind::Identifier]);
 +        assert_eq!(
 +            k,
 +            vec![
 +                TokenKind::Identifier,
 +                TokenKind::Plus,
 +                TokenKind::Identifier
 +            ]
 +        );
+     }
      #[test]
          // Round-trip: tokens -> text -> tokens should produce identical kinds.
          let src = "integer :: x = 42\n";
          let tokens1 = Lexer::tokenize(src, 0).unwrap();
 -        let reconstructed: String = tokens1.iter().map(|t| t.text.as_str()).collect::<Vec<_>>().join(" ");
 +        let reconstructed: String = tokens1
 +            .iter()
 +            .map(|t| t.text.as_str())
 +            .collect::<Vec<_>>()
 +            .join(" ");
          let tokens2 = Lexer::tokenize(&reconstructed, 0).unwrap();
          let kinds1: Vec<_> = tokens1.iter().map(|t| &t.kind).collect();
          let kinds2: Vec<_> = tokens2.iter().map(|t| &t.kind).collect();
 -        assert_eq!(kinds1, kinds2, "round-trip failed:\n  original: {:?}\n  reconstructed: {:?}", src, reconstructed);
 +        assert_eq!(
 +            kinds1, kinds2,
 +            "round-trip failed:\n  original: {:?}\n  reconstructed: {:?}",
 +            src, reconstructed
 +        );
+     }
      #[test]
      fn round_trip_operators() {
          let src = "x = a + b * c ** d // e\n";
          let tokens1 = Lexer::tokenize(src, 0).unwrap();
 -        let reconstructed: String = tokens1.iter().map(|t| t.text.as_str()).collect::<Vec<_>>().join(" ");
 +        let reconstructed: String = tokens1
 +            .iter()
 +            .map(|t| t.text.as_str())
 +            .collect::<Vec<_>>()
 +            .join(" ");
          let tokens2 = Lexer::tokenize(&reconstructed, 0).unwrap();
          let kinds1: Vec<_> = tokens1.iter().map(|t| &t.kind).collect();
      #[test]
      fn tokenize_fortsh_types() {
 -        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../fortsh/src/common/types.f90");
 +        let path = concat!(
 +            env!("CARGO_MANIFEST_DIR"),
 +            "/../fortsh/src/common/types.f90"
 +        );
          if !std::path::Path::new(path).exists() {
              // fortsh not available — skip gracefully.
              return;
+         }
          let count = try_lex_fortsh_file(path).unwrap();
 -        assert!(count > 100, "expected 100+ tokens from types.f90, got {}", count);
 +        assert!(
 +            count > 100,
 +            "expected 100+ tokens from types.f90, got {}",
 +            count
 +        );
+     }
      #[test]
      fn tokenize_fortsh_error_handling() {
 -        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../fortsh/src/common/error_handling.f90");
 -        if !std::path::Path::new(path).exists() { return; }
 +        let path = concat!(
 +            env!("CARGO_MANIFEST_DIR"),
 +            "/../fortsh/src/common/error_handling.f90"
 +        );
 +        if !std::path::Path::new(path).exists() {
 +            return;
 +        }
          let count = try_lex_fortsh_file(path).unwrap();
          assert!(count > 50, "expected 50+ tokens, got {}", count);
+     }
      fn tokenize_fortsh_all_common() {
          let common_dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../fortsh/src/common");
          let dir = std::path::Path::new(common_dir);
 -        if !dir.exists() { return; }
 +        if !dir.exists() {
 +            return;
 +        }
          let mut files_tested = 0;
          let mut total_tokens = 0;
+             }
+         }
          assert!(files_tested > 0, "no .f90 files found in fortsh/src/common");
 -        eprintln!("tokenized {} fortsh common/ files, {} total tokens", files_tested, total_tokens);
 +        eprintln!(
 +            "tokenized {} fortsh common/ files, {} total tokens",
 +            files_tested, total_tokens
 +        );
+     }
      #[test]
      fn tokenize_fortsh_all_sources() {
          let src_dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../fortsh/src");
          let root = std::path::Path::new(src_dir);
 -        if !root.exists() { return; }
 +        if !root.exists() {
 +            return;
 +        }
          let mut files_tested = 0;
          let mut total_tokens = 0;
          let mut failures = Vec::new();
 -        fn visit_dir(dir: &std::path::Path, files_tested: &mut usize, total_tokens: &mut usize, failures: &mut Vec<String>) {
 +        fn visit_dir(
 +            dir: &std::path::Path,
 +            files_tested: &mut usize,
 +            total_tokens: &mut usize,
 +            failures: &mut Vec<String>,
 +        ) {
              if let Ok(entries) = std::fs::read_dir(dir) {
                  for entry in entries.flatten() {
                      let path = entry.path();
          visit_dir(root, &mut files_tested, &mut total_tokens, &mut failures);
          if !failures.is_empty() {
 -            panic!("{} of {} files failed to tokenize:\n{}", failures.len(), files_tested + failures.len(),
 -                failures.join("\n"));
 +            panic!(
 +                "{} of {} files failed to tokenize:\n{}",
 +                failures.len(),
 +                files_tested + failures.len(),
 +                failures.join("\n")
 +            );
+         }
 -        assert!(files_tested > 40, "expected 40+ .f90 files, found {}", files_tested);
 -        eprintln!("tokenized ALL {} fortsh .f90 files, {} total tokens", files_tested, total_tokens);
 +        assert!(
 +            files_tested > 40,
 +            "expected 40+ .f90 files, found {}",
 +            files_tested
 +        );
 +        eprintln!(
 +            "tokenized ALL {} fortsh .f90 files, {} total tokens",
 +            files_tested, total_tokens
 +        );
+     }
+ }

src/opt/alias.rsmodified

276 lines changed — click to load

  //! Used by GVN (to determine if a store kills a prior load's value)
  //! cross-block load-store forwarding, and LICM load hoisting.
 +use super::loop_utils::resolve_const_int;
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
 -use super::loop_utils::resolve_const_int;
  /// Result of an alias query between two pointer values.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  /// GlobalAddr, GetElementPtr, or function parameters).
  pub fn query(func: &Function, a: ValueId, b: ValueId) -> AliasResult {
      // Same value → must alias.
 -    if a == b { return AliasResult::MustAlias; }
 +    if a == b {
 +        return AliasResult::MustAlias;
 +    }
      // Trace both pointers to their base + offset.
      let base_a = trace_base(func, a);
      // Different base pointers → no alias (Fortran guarantee).
      match (&base_a, &base_b) {
          (PtrBase::Alloca(id_a), PtrBase::Alloca(id_b)) => {
 -            if id_a != id_b { return AliasResult::NoAlias; }
 +            if id_a != id_b {
 +                return AliasResult::NoAlias;
 +            }
+         }
          (PtrBase::Global(name_a), PtrBase::Global(name_b)) => {
 -            if name_a != name_b { return AliasResult::NoAlias; }
 +            if name_a != name_b {
 +                return AliasResult::NoAlias;
 +            }
+         }
          (PtrBase::Param(id_a), PtrBase::Param(id_b)) => {
              if id_a != id_b
                  return AliasResult::NoAlias;
+             }
+         }
 -        (PtrBase::Alloca(_), PtrBase::Global(_)) |
 -        (PtrBase::Global(_), PtrBase::Alloca(_)) |
 -        (PtrBase::Alloca(_), PtrBase::Param(_)) |
 -        (PtrBase::Param(_), PtrBase::Alloca(_)) => {
 +        (PtrBase::Alloca(_), PtrBase::Global(_))
 +        | (PtrBase::Global(_), PtrBase::Alloca(_))
 +        | (PtrBase::Alloca(_), PtrBase::Param(_))
 +        | (PtrBase::Param(_), PtrBase::Alloca(_)) => {
              return AliasResult::NoAlias;
+         }
          _ => {}
  fn trace_base(func: &Function, ptr: ValueId) -> PtrBase {
      // Check if this is a function parameter (pointer arg).
      for param in &func.params {
 -        if param.id == ptr { return PtrBase::Param(ptr); }
 +        if param.id == ptr {
 +            return PtrBase::Param(ptr);
 +        }
+     }
      // Find the defining instruction.
          InstKind::Load(addr) => trace_param_wrapper(func, *addr).map(|_| 0),
          InstKind::GetElementPtr(base, indices) => {
              let base_offset = trace_offset(func, *base)?;
 -            if indices.len() != 1 { return None; }
 +            if indices.len() != 1 {
 +                return None;
 +            }
              let idx = resolve_const_int(func, indices[0])?;
              let step = match &inst.ty {
                  IrType::Ptr(inner) => inner.size_bytes() as i64,
  fn find_inst(func: &Function, vid: ValueId) -> Option<&Inst> {
      for block in &func.blocks {
          for inst in &block.insts {
 -            if inst.id == vid { return Some(inst); }
 +            if inst.id == vid {
 +                return Some(inst);
 +            }
+         }
+     }
      None
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      fn param(name: &str, id: u32, ty: IrType, fortran_noalias: bool) -> Param {
          let a = f.next_value_id();
          f.register_type(a, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: a, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: a,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Int(IntWidth::I32)),
          });
          let b = f.next_value_id();
          f.register_type(b, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: b, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: b,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Int(IntWidth::I32)),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
          let a = f.next_value_id();
          f.register_type(a, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: a, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: a,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Int(IntWidth::I32)),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
          let base = f.next_value_id();
          f.register_type(base, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: base, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: base,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 10)),
          });
          // GEP at offset 0
          let c0 = f.next_value_id();
          f.register_type(c0, IrType::Int(IntWidth::I64));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: c0, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: c0,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(0, IntWidth::I64),
          });
          let gep0 = f.next_value_id();
          f.register_type(gep0, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: gep0, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: gep0,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::GetElementPtr(base, vec![c0]),
          });
          // GEP at offset 1
          let c1 = f.next_value_id();
          f.register_type(c1, IrType::Int(IntWidth::I64));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: c1, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: c1,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I64),
          });
          let gep1 = f.next_value_id();
          f.register_type(gep1, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: gep1, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: gep1,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::GetElementPtr(base, vec![c1]),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
      fn aggregate_base_and_element_gep_may_alias() {
          let mut f = Function::new("test".into(), vec![], IrType::Void);
          let base = f.next_value_id();
 -        f.register_type(base, IrType::Ptr(Box::new(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 10))));
 +        f.register_type(
 +            base,
 +            IrType::Ptr(Box::new(IrType::Array(
 +                Box::new(IrType::Int(IntWidth::I32)),
 +                10,
 +            ))),
 +        );
          f.block_mut(f.entry).insts.push(Inst {
              id: base,
 -            ty: IrType::Ptr(Box::new(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 10))),
 +            ty: IrType::Ptr(Box::new(IrType::Array(
 +                Box::new(IrType::Int(IntWidth::I32)),
 +                10,
 +            ))),
              span: span(),
              kind: InstKind::Alloca(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 10)),
          });
          let ga = f.next_value_id();
          f.register_type(ga, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: ga, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: ga,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::GlobalAddr("array_a".into()),
          });
          let gb = f.next_value_id();
          f.register_type(gb, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: gb, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: gb,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::GlobalAddr("array_b".into()),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
      #[test]
      fn distinct_noalias_params_do_not_alias() {
          let params = vec![
 -            param("a", 0, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), true),
 -            param("b", 1, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), true),
 +            param(
 +                "a",
 +                0,
 +                IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +                true,
 +            ),
 +            param(
 +                "b",
 +                1,
 +                IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +                true,
 +            ),
          ];
          let mut f = Function::new("test".into(), params, IrType::Void);
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
      #[test]
      fn wrapper_loads_trace_back_to_noalias_params() {
          let params = vec![
 -            param("a", 0, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), true),
 -            param("b", 1, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), true),
 +            param(
 +                "a",
 +                0,
 +                IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +                true,
 +            ),
 +            param(
 +                "b",
 +                1,
 +                IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +                true,
 +            ),
          ];
          let mut f = Function::new("test".into(), params, IrType::Void);
          let slot_a = f.next_value_id();
 -        f.register_type(slot_a, IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))));
 +        f.register_type(
 +            slot_a,
 +            IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
 +        );
          f.block_mut(f.entry).insts.push(Inst {
              id: slot_a,
              ty: IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
              kind: InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
          });
          let slot_b = f.next_value_id();
 -        f.register_type(slot_b, IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))));
 +        f.register_type(
 +            slot_b,
 +            IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
 +        );
          f.block_mut(f.entry).insts.push(Inst {
              id: slot_b,
              ty: IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),

src/opt/audit_tests.rsmodified

1717 lines changed — click to load

  #![cfg(test)]
 -use crate::ir::inst::*;
 -use crate::ir::types::{IrType, IntWidth, FloatWidth};
 -use crate::lexer::{Span, Position};
 -use crate::ir::verify::verify_module;
 -use super::pass::Pass;
  use super::const_fold::ConstFold;
  use super::const_prop::ConstProp;
  use super::dce::Dce;
 -use super::strength_reduce::StrengthReduce;
  use super::licm::Licm;
 +use super::pass::Pass;
 +use super::strength_reduce::StrengthReduce;
 +use crate::ir::inst::*;
 +use crate::ir::types::{FloatWidth, IntWidth, IrType};
 +use crate::ir::verify::verify_module;
 +use crate::lexer::{Position, Span};
  fn dummy_span() -> Span {
      let p = Position { line: 1, col: 1 };
 -    Span { start: p, end: p, file_id: 0 }
 +    Span {
 +        start: p,
 +        end: p,
 +        file_id: 0,
 +    }
+ }
  fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
      let id = f.next_value_id();
      let entry = f.entry;
 -    f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +    f.block_mut(entry).insts.push(Inst {
 +        id,
 +        kind,
 +        ty,
 +        span: dummy_span(),
 +    });
      id
+ }
  fn audit_const_fold_int_to_f32_must_round() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Float(FloatWidth::F32));
 -    let i = push(&mut f, InstKind::ConstInt(16_777_217, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let cv = push(&mut f, InstKind::IntToFloat(i, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 +    let i = push(
 +        &mut f,
 +        InstKind::ConstInt(16_777_217, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let cv = push(
 +        &mut f,
 +        InstKind::IntToFloat(i, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(cv)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == cv).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == cv)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstFloat(v, FloatWidth::F32) => {
 -            assert_eq!(v, 16_777_216.0,
 -                "expected f32-precision result 16_777_216.0, got {}", v);
 +            assert_eq!(
 +                v, 16_777_216.0,
 +                "expected f32-precision result 16_777_216.0, got {}",
 +                v
 +            );
+         }
          ref other => panic!("expected ConstFloat, got {:?}", other),
+     }
  fn audit_const_fold_float_trunc_must_round() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Float(FloatWidth::F32));
 -    let d = push(&mut f, InstKind::ConstFloat(16_777_217.0, FloatWidth::F64), IrType::Float(FloatWidth::F64));
 -    let cv = push(&mut f, InstKind::FloatTrunc(d, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 +    let d = push(
 +        &mut f,
 +        InstKind::ConstFloat(16_777_217.0, FloatWidth::F64),
 +        IrType::Float(FloatWidth::F64),
 +    );
 +    let cv = push(
 +        &mut f,
 +        InstKind::FloatTrunc(d, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(cv)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == cv).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == cv)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstFloat(v, FloatWidth::F32) => {
              assert_eq!(v, 16_777_216.0, "expected f32-rounded value, got {}", v);
  fn audit_strength_reduce_chained_identities() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let x  = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let one1 = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let x = push(
 +        &mut f,
 +        InstKind::ConstInt(7, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let one1 = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let mul1 = push(&mut f, InstKind::IMul(x, one1), IrType::Int(IntWidth::I32));
 -    let one2 = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let mul2 = push(&mut f, InstKind::IMul(mul1, one2), IrType::Int(IntWidth::I32));
 -    let zero = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let add  = push(&mut f, InstKind::IAdd(mul2, zero), IrType::Int(IntWidth::I32));
 +    let one2 = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let mul2 = push(
 +        &mut f,
 +        InstKind::IMul(mul1, one2),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let zero = push(
 +        &mut f,
 +        InstKind::ConstInt(0, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let add = push(
 +        &mut f,
 +        InstKind::IAdd(mul2, zero),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(add)));
      m.add_function(f);
      // After three chained identities, the return must reference x.
      let term = m.functions[0].blocks[0].terminator.as_ref().unwrap();
      match term {
 -        Terminator::Return(Some(v)) => assert_eq!(*v, x,
 -            "expected return %{} (x), got %{}", x.0, v.0),
 +        Terminator::Return(Some(v)) => {
 +            assert_eq!(*v, x, "expected return %{} (x), got %{}", x.0, v.0)
 +        }
          other => panic!("expected Return(x), got {:?}", other),
+     }
      // And the IR must still verify.
      let errs = verify_module(&m);
 -    assert!(errs.is_empty(), "verifier errors after chained rewrites: {:?}", errs);
 +    assert!(
 +        errs.is_empty(),
 +        "verifier errors after chained rewrites: {:?}",
 +        errs
 +    );
+ }
  // =============================================================
      // ret %4
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let x = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let eight = push(&mut f, InstKind::ConstInt(8, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let x = push(
 +        &mut f,
 +        InstKind::ConstInt(7, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let eight = push(
 +        &mut f,
 +        InstKind::ConstInt(8, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let mul1 = push(&mut f, InstKind::IMul(x, eight), IrType::Int(IntWidth::I32));
 -    let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let mul2 = push(&mut f, InstKind::IMul(mul1, one), IrType::Int(IntWidth::I32));
 +    let one = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let mul2 = push(
 +        &mut f,
 +        InstKind::IMul(mul1, one),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(mul2)));
      m.add_function(f);
          _ => panic!(),
      };
      let term_kind = &block.insts.iter().find(|i| i.id == term_val).unwrap().kind;
 -    assert!(matches!(term_kind, InstKind::Shl(..)),
 -        "expected return value to define a Shl, got {:?}", term_kind);
 +    assert!(
 +        matches!(term_kind, InstKind::Shl(..)),
 +        "expected return value to define a Shl, got {:?}",
 +        term_kind
 +    );
+ }
  // =============================================================
  fn audit_const_fold_idiv_i8_min_neg_one() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I8));
 -    let a = push(&mut f, InstKind::ConstInt(-128, IntWidth::I8), IrType::Int(IntWidth::I8));
 -    let b = push(&mut f, InstKind::ConstInt(-1, IntWidth::I8), IrType::Int(IntWidth::I8));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(-128, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(-1, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
      let q = push(&mut f, InstKind::IDiv(a, b), IrType::Int(IntWidth::I8));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(q)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == q).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == q)
 +        .unwrap();
      // Either we fold to -128 (match hardware), or we leave the IDiv alone.
      // Anything else would be a divergence.
      match folded.kind {
 -        InstKind::ConstInt(v, IntWidth::I8) => assert_eq!(v, -128,
 -            "expected -128 (i8 wraparound), got {}", v),
 +        InstKind::ConstInt(v, IntWidth::I8) => {
 +            assert_eq!(v, -128, "expected -128 (i8 wraparound), got {}", v)
 +        }
          InstKind::IDiv(..) => { /* left alone, also acceptable */ }
          ref other => panic!("unexpected fold: {:?}", other),
+     }
          id: param_id,
          ty: IrType::Int(IntWidth::I32),
      });
 -    let init = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let init = push(
 +        &mut f,
 +        InstKind::ConstInt(0, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Branch(target, vec![init]));
      f.block_mut(target).terminator = Some(Terminator::Return(None));
      assert!(Dce.run(&mut m), "DCE should report change");
      let f = &m.functions[0];
 -    assert_eq!(f.block(target).params.len(), 0, "dead block param must be removed");
 +    assert_eq!(
 +        f.block(target).params.len(),
 +        0,
 +        "dead block param must be removed"
 +    );
      // The predecessor's branch arg list must shrink in lockstep.
      let entry_term = f.block(f.entry).terminator.as_ref().unwrap();
      match entry_term {
 -        Terminator::Branch(_, args) => assert_eq!(args.len(), 0,
 -            "predecessor branch arg must be dropped alongside the dead param"),
 +        Terminator::Branch(_, args) => assert_eq!(
 +            args.len(),
 +            0,
 +            "predecessor branch arg must be dropped alongside the dead param"
 +        ),
          _ => panic!(),
+     }
      // The const(0) inst is now unreferenced and should also be DCE'd.
 -    let const_remains = f.blocks.iter()
 +    let const_remains = f
 +        .blocks
 +        .iter()
          .flat_map(|b| b.insts.iter())
          .any(|i| matches!(i.kind, InstKind::ConstInt(0, _)));
 -    assert!(!const_remains, "const(0) should also be DCE'd after its only use disappears");
 +    assert!(
 +        !const_remains,
 +        "const(0) should also be DCE'd after its only use disappears"
 +    );
+ }
  #[test]
          id: param_id,
          ty: IrType::Int(IntWidth::I32),
      });
 -    let init = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let init = push(
 +        &mut f,
 +        InstKind::ConstInt(7, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Branch(target, vec![init]));
      f.block_mut(target).terminator = Some(Terminator::Return(Some(param_id)));
      Dce.run(&mut m);
      let f = &m.functions[0];
 -    assert_eq!(f.block(target).params.len(), 1, "live block param must survive");
 +    assert_eq!(
 +        f.block(target).params.len(),
 +        1,
 +        "live block param must survive"
 +    );
+ }
  #[test]
      let target = f.create_block("target");
      let p0 = f.next_value_id();
      let p1 = f.next_value_id();
 -    f.block_mut(target).params.push(BlockParam { id: p0, ty: IrType::Int(IntWidth::I32) });
 -    f.block_mut(target).params.push(BlockParam { id: p1, ty: IrType::Int(IntWidth::I32) });
 -    let c0 = push(&mut f, InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let c1 = push(&mut f, InstKind::ConstInt(20, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    f.block_mut(target).params.push(BlockParam {
 +        id: p0,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
 +    f.block_mut(target).params.push(BlockParam {
 +        id: p1,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
 +    let c0 = push(
 +        &mut f,
 +        InstKind::ConstInt(10, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let c1 = push(
 +        &mut f,
 +        InstKind::ConstInt(20, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Branch(target, vec![c0, c1]));
      f.block_mut(target).terminator = Some(Terminator::Return(Some(p1)));
      // Now const(10) is dead — should also be gone after the
      // outer-loop re-runs the inner DCE.
 -    let c0_remains = f.blocks.iter()
 +    let c0_remains = f
 +        .blocks
 +        .iter()
          .flat_map(|b| b.insts.iter())
          .any(|i| i.id == c0);
 -    assert!(!c0_remains, "const(10) should be DCE'd after its arg slot is gone");
 +    assert!(
 +        !c0_remains,
 +        "const(10) should be DCE'd after its arg slot is gone"
 +    );
+ }
  // =============================================================
      let mut f = Function::new("f".into(), vec![], IrType::Void);
      // entry: computes %c, branches to other
 -    let c = push(&mut f, InstKind::ConstInt(5, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let c = push(
 +        &mut f,
 +        InstKind::ConstInt(5, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      // other: has param p_other, computes %u = ineg p_other, branches to target
      let other = f.create_block("other");
      let p_other = f.next_value_id();
      f.block_mut(other).params.push(BlockParam {
 -        id: p_other, ty: IrType::Int(IntWidth::I32),
 +        id: p_other,
 +        ty: IrType::Int(IntWidth::I32),
      });
      let u = f.next_value_id();
      f.block_mut(other).insts.push(Inst {
 -        id: u, kind: InstKind::INeg(p_other),
 -        ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +        id: u,
 +        kind: InstKind::INeg(p_other),
 +        ty: IrType::Int(IntWidth::I32),
 +        span: dummy_span(),
      });
      // target: has param p_target, returns (p_target never used).
      let target = f.create_block("target");
      let p_target = f.next_value_id();
      f.block_mut(target).params.push(BlockParam {
 -        id: p_target, ty: IrType::Int(IntWidth::I32),
 +        id: p_target,
 +        ty: IrType::Int(IntWidth::I32),
      });
      f.block_mut(target).terminator = Some(Terminator::Return(None));
      let f = &m.functions[0];
      // Both block params must be gone.
 -    assert_eq!(f.block(target).params.len(), 0,
 -        "p_target should be removed in round 1");
 -    assert_eq!(f.block(other).params.len(), 0,
 -        "p_other should be removed in round 2 (cascading)");
 +    assert_eq!(
 +        f.block(target).params.len(),
 +        0,
 +        "p_target should be removed in round 1"
 +    );
 +    assert_eq!(
 +        f.block(other).params.len(),
 +        0,
 +        "p_other should be removed in round 2 (cascading)"
 +    );
      // Entry's branch arg list must be empty.
      match f.block(f.entry).terminator.as_ref().unwrap() {
 -        Terminator::Branch(_, args) => assert_eq!(args.len(), 0,
 -            "entry's branch to other should have no args after cascade"),
 +        Terminator::Branch(_, args) => assert_eq!(
 +            args.len(),
 +            0,
 +            "entry's branch to other should have no args after cascade"
 +        ),
          _ => panic!(),
+     }
      // other's branch to target must also have no args.
      match f.block(other).terminator.as_ref().unwrap() {
 -        Terminator::Branch(_, args) => assert_eq!(args.len(), 0,
 -            "other's branch to target should have no args"),
 +        Terminator::Branch(_, args) => assert_eq!(
 +            args.len(),
 +            0,
 +            "other's branch to target should have no args"
 +        ),
          _ => panic!(),
+     }
      // All formerly-live values should be DCE'd: %c, %u.
 -    let any_inst = f.blocks.iter()
 +    let any_inst = f
 +        .blocks
 +        .iter()
          .flat_map(|b| b.insts.iter())
          .any(|i| i.id == c || i.id == u);
 -    assert!(!any_inst,
 -        "dead instructions %c (const) and %u (ineg) should be DCE'd after the cascade");
 +    assert!(
 +        !any_inst,
 +        "dead instructions %c (const) and %u (ineg) should be DCE'd after the cascade"
 +    );
+ }
  // =============================================================
      assert_eq!(loops.len(), 2, "expected exactly two natural loops");
      // Find the inner and outer loops by their headers.
 -    let inner = loops.iter().find(|l| l.header == inner_header).expect("inner loop not found");
 -    let outer = loops.iter().find(|l| l.header == outer_header).expect("outer loop not found");
 +    let inner = loops
 +        .iter()
 +        .find(|l| l.header == inner_header)
 +        .expect("inner loop not found");
 +    let outer = loops
 +        .iter()
 +        .find(|l| l.header == outer_header)
 +        .expect("outer loop not found");
      // Inner loop body: {inner_header, inner_latch}.
 -    assert_eq!(inner.body.len(), 2,
 -        "inner body should be {{inner_header, inner_latch}}, got {:?}", inner.body);
 +    assert_eq!(
 +        inner.body.len(),
 +        2,
 +        "inner body should be {{inner_header, inner_latch}}, got {:?}",
 +        inner.body
 +    );
      assert!(inner.body.contains(&inner_header));
      assert!(inner.body.contains(&inner_latch));
      // Outer loop body: {outer_header, inner_header, inner_latch, outer_latch}.
      // MUST NOT contain entry or exit.
 -    assert_eq!(outer.body.len(), 4,
 +    assert_eq!(
 +        outer.body.len(),
 +        4,
          "outer body should be {{outer_header, inner_header, inner_latch, outer_latch}}, got {:?}",
 -        outer.body);
 +        outer.body
 +    );
      assert!(outer.body.contains(&outer_header));
      assert!(outer.body.contains(&inner_header));
      assert!(outer.body.contains(&inner_latch));
      assert!(outer.body.contains(&outer_latch));
 -    assert!(!outer.body.contains(&entry), "outer body must not include entry");
 -    assert!(!outer.body.contains(&exit), "outer body must not include exit");
 +    assert!(
 +        !outer.body.contains(&entry),
 +        "outer body must not include entry"
 +    );
 +    assert!(
 +        !outer.body.contains(&exit),
 +        "outer body must not include exit"
 +    );
+ }
  // =============================================================
      assert_eq!(lp.header, header);
      // Body must include header and other, NOT entry.
      assert!(lp.body.contains(&header), "body must include header");
 -    assert!(lp.body.contains(&other),  "body must include other");
 -    assert!(!lp.body.contains(&entry), "body must NOT include the preheader (entry)");
 -    assert!(!lp.body.contains(&exit),  "body must NOT include the exit block");
 +    assert!(lp.body.contains(&other), "body must include other");
 +    assert!(
 +        !lp.body.contains(&entry),
 +        "body must NOT include the preheader (entry)"
 +    );
 +    assert!(
 +        !lp.body.contains(&exit),
 +        "body must NOT include the exit block"
 +    );
      // Latches: both header (self-loop) and other (back edge).
      assert_eq!(lp.latches.len(), 2, "expected two latches");
      assert!(lp.latches.contains(&header));
  fn audit_licm_hoists_clean_alloca_load() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Void);
 -    let slot = push(&mut f,
 +    let slot = push(
 +        &mut f,
          InstKind::Alloca(IrType::Int(IntWidth::I32)),
 -        IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -    let init = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +    );
 +    let init = push(
 +        &mut f,
 +        InstKind::ConstInt(0, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      push(&mut f, InstKind::Store(init, slot), IrType::Void);
      let header = f.create_block("header");
      let i_param = f.next_value_id();
 -    f.block_mut(header).params.push(BlockParam { id: i_param, ty: IrType::Int(IntWidth::I32) });
 +    f.block_mut(header).params.push(BlockParam {
 +        id: i_param,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
      let v = f.next_value_id();
      f.block_mut(header).insts.push(Inst {
          id: v,
      // The const(1) inside the header IS loop-invariant — LICM should hoist it.
      Licm.run(&mut m);
      let entry_block = m.functions[0].block(m.functions[0].entry);
 -    let const1_in_entry = entry_block.insts.iter()
 +    let const1_in_entry = entry_block
 +        .insts
 +        .iter()
          .any(|i| matches!(i.kind, InstKind::ConstInt(1, IntWidth::I32)));
 -    assert!(const1_in_entry,
 -        "LICM should have hoisted const(1) into the preheader");
 +    assert!(
 +        const1_in_entry,
 +        "LICM should have hoisted const(1) into the preheader"
 +    );
      // The load is now loop-invariant too: no loop store/call can clobber it.
      let header_block = &m.functions[0].blocks[1];
 -    let load_still_in_header = header_block.insts.iter()
 +    let load_still_in_header = header_block
 +        .insts
 +        .iter()
          .any(|i| matches!(i.kind, InstKind::Load(_)));
 -    assert!(!load_still_in_header,
 -        "LICM should hoist a load when the loop is memory-clean");
 -    let load_in_entry = entry_block.insts.iter()
 +    assert!(
 +        !load_still_in_header,
 +        "LICM should hoist a load when the loop is memory-clean"
 +    );
 +    let load_in_entry = entry_block
 +        .insts
 +        .iter()
          .any(|i| matches!(i.kind, InstKind::Load(_)));
 -    assert!(load_in_entry,
 -        "LICM should move the memory-clean load into the preheader");
 +    assert!(
 +        load_in_entry,
 +        "LICM should move the memory-clean load into the preheader"
 +    );
+ }
  // =============================================================
      //                         %d=icmp ge %i, %lim; cbr %d, exit, latch(%i2) }
      //        latch(%i_in:i32) { %1=const 1; %n=iadd %i_in, %1; br header(%n) }
      //        exit { ret }
 -    let init = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let init = push(
 +        &mut f,
 +        InstKind::ConstInt(0, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let header = f.create_block("header");
      let i_param = f.next_value_id();
 -    f.block_mut(header).params.push(BlockParam { id: i_param, ty: IrType::Int(IntWidth::I32) });
 +    f.block_mut(header).params.push(BlockParam {
 +        id: i_param,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
      let k = f.next_value_id();
      f.block_mut(header).insts.push(Inst {
      let latch = f.create_block("latch");
      let i_in = f.next_value_id();
 -    f.block_mut(latch).params.push(BlockParam { id: i_in, ty: IrType::Int(IntWidth::I32) });
 +    f.block_mut(latch).params.push(BlockParam {
 +        id: i_in,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
      let one = f.next_value_id();
      f.block_mut(latch).insts.push(Inst {
          id: one,
      // Final IR must verify.
      let errs = verify_module(&m);
 -    assert!(errs.is_empty(), "O2 pipeline left an invalid module: {:?}", errs);
 +    assert!(
 +        errs.is_empty(),
 +        "O2 pipeline left an invalid module: {:?}",
 +        errs
 +    );
+ }
  // =============================================================
      let mut f = Function::new("f".into(), vec![], IrType::Void);
      let cond = push(&mut f, InstKind::ConstBool(true), IrType::Bool);
      // This constant is ONLY used in the about-to-be-dead else block.
 -    let dead_only = push(&mut f, InstKind::ConstInt(99, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let dead_only = push(
 +        &mut f,
 +        InstKind::ConstInt(99, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let then_b = f.create_block("then");
      let else_b = f.create_block("else");
      // After: else block gone, const(99) and ineg gone too.
      let f = &m.functions[0];
 -    assert!(!f.blocks.iter().any(|b| b.id == else_b), "else block should be pruned");
 -    let dead_remains = f.blocks.iter()
 +    assert!(
 +        !f.blocks.iter().any(|b| b.id == else_b),
 +        "else block should be pruned"
 +    );
 +    let dead_remains = f
 +        .blocks
 +        .iter()
          .flat_map(|b| b.insts.iter())
          .any(|i| matches!(i.kind, InstKind::ConstInt(99, _)));
 -    assert!(!dead_remains, "const(99) should be DCE'd after const_prop drops its only use");
 +    assert!(
 +        !dead_remains,
 +        "const(99) should be DCE'd after const_prop drops its only use"
 +    );
+ }
  // =============================================================
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let x = push(
 +        &mut f,
 +        InstKind::ConstInt(42, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let one = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let mul = push(&mut f, InstKind::IMul(x, one), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(mul)));
      assert_eq!(term_val, x, "expected return to be x directly");
      // The orphan placeholder should be gone.
 -    let extra_const = f.blocks[0].insts.iter()
 +    let extra_const = f.blocks[0]
 +        .insts
 +        .iter()
          .filter(|i| matches!(i.kind, InstKind::ConstInt(0, _)))
          .count();
 -    assert_eq!(extra_const, 0,
 -        "strength_reduce orphan placeholder Const(0) should be DCE'd");
 +    assert_eq!(
 +        extra_const, 0,
 +        "strength_reduce orphan placeholder Const(0) should be DCE'd"
 +    );
+ }
  // =============================================================
      // so the runtime answer is 1. The fold MUST NOT silently emit 0.
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let v = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let cnt = push(&mut f, InstKind::ConstInt(32, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let cnt = push(
 +        &mut f,
 +        InstKind::ConstInt(32, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let s = push(&mut f, InstKind::Shl(v, cnt), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(s)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == s).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == s)
 +        .unwrap();
      // Acceptable outcomes: leave the Shl alone, OR mask the count.
      // NOT acceptable: ConstInt(0, _).
      if let InstKind::ConstInt(0, _) = folded.kind {
  fn audit_const_fold_shl_negative_count_bails() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let v = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let cnt = push(&mut f, InstKind::ConstInt(-1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v = push(
 +        &mut f,
 +        InstKind::ConstInt(7, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let cnt = push(
 +        &mut f,
 +        InstKind::ConstInt(-1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let s = push(&mut f, InstKind::Shl(v, cnt), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(s)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == s).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == s)
 +        .unwrap();
      if let InstKind::ConstInt(0, _) = folded.kind {
          panic!("audit M-C: shl with negative count folded to 0 — wrong on AArch64");
+     }
  fn audit_const_fold_lshr_negative_count_bails() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let v = push(&mut f, InstKind::ConstInt(64, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let cnt = push(&mut f, InstKind::ConstInt(-2, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v = push(
 +        &mut f,
 +        InstKind::ConstInt(64, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let cnt = push(
 +        &mut f,
 +        InstKind::ConstInt(-2, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let s = push(&mut f, InstKind::LShr(v, cnt), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(s)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == s).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == s)
 +        .unwrap();
      if let InstKind::ConstInt(0, _) = folded.kind {
          panic!("audit M-C: lshr with negative count folded to 0");
+     }
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
      let a = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: a, kind: InstKind::ConstInt(255, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: a,
 +        kind: InstKind::ConstInt(255, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let b = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: b, kind: InstKind::ConstInt(2, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: b,
 +        kind: InstKind::ConstInt(2, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let sum = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: sum, kind: InstKind::IAdd(a, b),
 -        ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +        id: sum,
 +        kind: InstKind::IAdd(a, b),
 +        ty: IrType::Int(IntWidth::I32),
 +        span: dummy_span(),
      });
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(sum)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == sum).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == sum)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(1, IntWidth::I32) => { /* good */ }
          InstKind::ConstInt(v, w) => panic!(
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
      let a = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: a, kind: InstKind::ConstInt(250, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: a,
 +        kind: InstKind::ConstInt(250, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let b = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: b, kind: InstKind::ConstInt(1, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: b,
 +        kind: InstKind::ConstInt(1, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let diff = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: diff, kind: InstKind::ISub(a, b),
 -        ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +        id: diff,
 +        kind: InstKind::ISub(a, b),
 +        ty: IrType::Int(IntWidth::I32),
 +        span: dummy_span(),
      });
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(diff)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == diff).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == diff)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(-7, IntWidth::I32) => { /* good */ }
 -        ref other => panic!("audit N-1 ISub: expected ConstInt(-7, I32), got {:?}", other),
 +        ref other => panic!(
 +            "audit N-1 ISub: expected ConstInt(-7, I32), got {:?}",
 +            other
 +        ),
+     }
+ }
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
      let a = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: a, kind: InstKind::ConstInt(255, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: a,
 +        kind: InstKind::ConstInt(255, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let b = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: b, kind: InstKind::ConstInt(3, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: b,
 +        kind: InstKind::ConstInt(3, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let prod = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: prod, kind: InstKind::IMul(a, b),
 -        ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +        id: prod,
 +        kind: InstKind::IMul(a, b),
 +        ty: IrType::Int(IntWidth::I32),
 +        span: dummy_span(),
      });
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(prod)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == prod).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == prod)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(-3, IntWidth::I32) => { /* good */ }
 -        ref other => panic!("audit N-1 IMul: expected ConstInt(-3, I32), got {:?}", other),
 +        ref other => panic!(
 +            "audit N-1 IMul: expected ConstInt(-3, I32), got {:?}",
 +            other
 +        ),
+     }
+ }
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
      let a = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: a, kind: InstKind::ConstInt(255, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: a,
 +        kind: InstKind::ConstInt(255, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let b = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: b, kind: InstKind::ConstInt(2, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: b,
 +        kind: InstKind::ConstInt(2, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let q = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: q, kind: InstKind::IDiv(a, b),
 -        ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +        id: q,
 +        kind: InstKind::IDiv(a, b),
 +        ty: IrType::Int(IntWidth::I32),
 +        span: dummy_span(),
      });
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(q)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == q).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == q)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(0, IntWidth::I32) => { /* good */ }
          ref other => panic!("audit N-1 IDiv: expected ConstInt(0, I32), got {:?}", other),
      let mut f = Function::new("f".into(), vec![], IrType::Bool);
      let a = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: a, kind: InstKind::ConstInt(255, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: a,
 +        kind: InstKind::ConstInt(255, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let b = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: b, kind: InstKind::ConstInt(0, IntWidth::I8),
 -        ty: IrType::Int(IntWidth::I8), span: dummy_span(),
 +        id: b,
 +        kind: InstKind::ConstInt(0, IntWidth::I8),
 +        ty: IrType::Int(IntWidth::I8),
 +        span: dummy_span(),
      });
      let lt = f.next_value_id();
      f.block_mut(f.entry).insts.push(Inst {
 -        id: lt, kind: InstKind::ICmp(CmpOp::Lt, a, b),
 -        ty: IrType::Bool, span: dummy_span(),
 +        id: lt,
 +        kind: InstKind::ICmp(CmpOp::Lt, a, b),
 +        ty: IrType::Bool,
 +        span: dummy_span(),
      });
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(lt)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == lt).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == lt)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstBool(true) => { /* good */ }
          ref other => panic!("audit N-1 ICmp: expected ConstBool(true), got {:?}", other),
      use crate::opt::LocalCse;
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I8));
 -    let a = push(&mut f, InstKind::ConstInt(255, IntWidth::I8), IrType::Int(IntWidth::I8));
 -    let b = push(&mut f, InstKind::ConstInt(-1,  IntWidth::I8), IrType::Int(IntWidth::I8));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(255, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(-1, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
      // Use a in some op and b in another so neither is dead.
      let neg_a = push(&mut f, InstKind::INeg(a), IrType::Int(IntWidth::I8));
      let neg_b = push(&mut f, InstKind::INeg(b), IrType::Int(IntWidth::I8));
      // Add them so both are live to the terminator.
 -    let sum = push(&mut f, InstKind::IAdd(neg_a, neg_b), IrType::Int(IntWidth::I8));
 +    let sum = push(
 +        &mut f,
 +        InstKind::IAdd(neg_a, neg_b),
 +        IrType::Int(IntWidth::I8),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(sum)));
      m.add_function(f);
      let f = &m.functions[0];
      let neg_a_inst = f.blocks[0].insts.iter().find(|i| i.id == neg_a).unwrap();
      let neg_b_inst = f.blocks[0].insts.iter().find(|i| i.id == neg_b).unwrap();
 -    let neg_a_op = match &neg_a_inst.kind { InstKind::INeg(v) => *v, _ => panic!() };
 -    let neg_b_op = match &neg_b_inst.kind { InstKind::INeg(v) => *v, _ => panic!() };
 -    assert_eq!(neg_a_op, neg_b_op,
 +    let neg_a_op = match &neg_a_inst.kind {
 +        InstKind::INeg(v) => *v,
 +        _ => panic!(),
 +    };
 +    let neg_b_op = match &neg_b_inst.kind {
 +        InstKind::INeg(v) => *v,
 +        _ => panic!(),
 +    };
 +    assert_eq!(
 +        neg_a_op, neg_b_op,
          "audit B-8: ConstInt(255, I8) and ConstInt(-1, I8) should CSE-dedupe \
 -         (both represent -1 at i8 precision), but the INeg operands differ");
 +         (both represent -1 at i8 precision), but the INeg operands differ"
 +    );
+ }
  // =============================================================
  fn audit_const_fold_ashr_negative_count_bails() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let v = push(&mut f, InstKind::ConstInt(-128, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let cnt = push(&mut f, InstKind::ConstInt(-3, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v = push(
 +        &mut f,
 +        InstKind::ConstInt(-128, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let cnt = push(
 +        &mut f,
 +        InstKind::ConstInt(-3, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let s = push(&mut f, InstKind::AShr(v, cnt), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(s)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == s).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == s)
 +        .unwrap();
      if let InstKind::ConstInt(0, _) = folded.kind {
          panic!("audit M-C: ashr with negative count folded to 0 — wrong on AArch64");
+     }
      // skipped it (causing SIGFPE on b == 0).
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Void);
 -    let a = push(&mut f, InstKind::ConstInt(100, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let b = push(&mut f, InstKind::ConstInt(5,   IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let init = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(100, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(5, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let init = push(
 +        &mut f,
 +        InstKind::ConstInt(0, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let header = f.create_block("header");
      let i_param = f.next_value_id();
 -    f.block_mut(header).params.push(BlockParam { id: i_param, ty: IrType::Int(IntWidth::I32) });
 +    f.block_mut(header).params.push(BlockParam {
 +        id: i_param,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
      // Inside the body: %q = idiv a, b — both operands invariant.
      let q = f.next_value_id();
      Licm.run(&mut m);
      let f = &m.functions[0];
      // The IDiv must STILL be in the header block, not in entry.
 -    let header_block = f.blocks.iter().find(|b| b.name.starts_with("header")).unwrap();
 +    let header_block = f
 +        .blocks
 +        .iter()
 +        .find(|b| b.name.starts_with("header"))
 +        .unwrap();
      let entry_block = f.block(f.entry);
 -    let idiv_in_header = header_block.insts.iter().any(|i| matches!(i.kind, InstKind::IDiv(..)));
 -    let idiv_in_entry  = entry_block.insts.iter().any(|i| matches!(i.kind, InstKind::IDiv(..)));
 -    assert!(idiv_in_header, "audit Med-6: LICM should leave IDiv in body (trap-prone)");
 -    assert!(!idiv_in_entry, "audit Med-6: LICM must not hoist IDiv into preheader");
 +    let idiv_in_header = header_block
 +        .insts
 +        .iter()
 +        .any(|i| matches!(i.kind, InstKind::IDiv(..)));
 +    let idiv_in_entry = entry_block
 +        .insts
 +        .iter()
 +        .any(|i| matches!(i.kind, InstKind::IDiv(..)));
 +    assert!(
 +        idiv_in_header,
 +        "audit Med-6: LICM should leave IDiv in body (trap-prone)"
 +    );
 +    assert!(
 +        !idiv_in_entry,
 +        "audit Med-6: LICM must not hoist IDiv into preheader"
 +    );
+ }
  // =============================================================
  fn audit_const_fold_select_uses_declared_type() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let a = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let b = push(&mut f, InstKind::ConstInt(99, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(99, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let cond = push(&mut f, InstKind::ConstBool(true), IrType::Bool);
 -    let sel = push(&mut f, InstKind::Select(cond, a, b), IrType::Int(IntWidth::I32));
 +    let sel = push(
 +        &mut f,
 +        InstKind::Select(cond, a, b),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(sel)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == sel).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == sel)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(1, IntWidth::I32) => { /* good */ }
          ref other => panic!("expected ConstInt(1, I32), got {:?}", other),
          ty: IrType::Int(IntWidth::I8),
          span: dummy_span(),
      });
 -    let b = push(&mut f, InstKind::ConstInt(99, IntWidth::I64), IrType::Int(IntWidth::I64));
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(99, IntWidth::I64),
 +        IrType::Int(IntWidth::I64),
 +    );
      let cond = push(&mut f, InstKind::ConstBool(true), IrType::Bool);
      // Select declared as i64, chosen branch is i8 (255 → -1).
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == sel).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == sel)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(-1, IntWidth::I64) => { /* good — i8 -1 sign-extended to i64 */ }
          InstKind::ConstInt(v, w) => panic!(
  fn audit_strength_reduce_identity_does_not_write_placeholder() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let x = push(
 +        &mut f,
 +        InstKind::ConstInt(42, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let one = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let mul = push(&mut f, InstKind::IMul(x, one), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(mul)));
      // The orphan instruction at `mul`'s ID must still exist and
      // have its original kind. The earlier (broken) version would
      // have replaced its kind with ConstInt(0, _).
 -    let orphan = m.functions[0].blocks[0].insts.iter().find(|i| i.id == mul).unwrap();
 +    let orphan = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == mul)
 +        .unwrap();
      match orphan.kind {
          InstKind::IMul(_, _) => { /* good — original kind preserved */ }
          InstKind::ConstInt(0, _) => panic!(
  fn audit_strength_reduce_identity_reports_changed() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let x = push(
 +        &mut f,
 +        InstKind::ConstInt(42, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let one = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let mul = push(&mut f, InstKind::IMul(x, one), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(mul)));
      m.add_function(f);
      let changed = StrengthReduce.run(&mut m);
 -    assert!(changed, "strength_reduce must report `changed = true` after Identity rewrite");
 +    assert!(
 +        changed,
 +        "strength_reduce must report `changed = true` after Identity rewrite"
 +    );
      // The terminator now references x.
      match m.functions[0].blocks[0].terminator.as_ref().unwrap() {
      // be FALSE: 255 != -1.
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Bool);
 -    let a = push(&mut f, InstKind::ConstInt(255, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let b = push(&mut f, InstKind::ConstInt(255, IntWidth::I8),  IrType::Int(IntWidth::I8));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(255, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(255, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
      let eq = push(&mut f, InstKind::ICmp(CmpOp::Eq, a, b), IrType::Bool);
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(eq)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == eq).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == eq)
 +        .unwrap();
      match folded.kind {
          // After the M-D fix: bv sign-extended at i8 → -1; av at i32 → 255.
          // 255 == -1 → false.
      // ConstFloat(16777216.0, F32) should now return true.
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Bool);
 -    let i = push(&mut f, InstKind::ConstInt(16_777_217, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let fv_a = push(&mut f, InstKind::IntToFloat(i, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 -    let fv_b = push(&mut f, InstKind::ConstFloat(16_777_216.0, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 +    let i = push(
 +        &mut f,
 +        InstKind::ConstInt(16_777_217, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let fv_a = push(
 +        &mut f,
 +        InstKind::IntToFloat(i, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
 +    let fv_b = push(
 +        &mut f,
 +        InstKind::ConstFloat(16_777_216.0, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
      let eq = push(&mut f, InstKind::FCmp(CmpOp::Eq, fv_a, fv_b), IrType::Bool);
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(eq)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == eq).unwrap();
 -    assert!(matches!(folded.kind, InstKind::ConstBool(true)),
 -        "audit M-E: FCmp on f32-rounded values should return true, got {:?}", folded.kind);
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == eq)
 +        .unwrap();
 +    assert!(
 +        matches!(folded.kind, InstKind::ConstBool(true)),
 +        "audit M-E: FCmp on f32-rounded values should return true, got {:?}",
 +        folded.kind
 +    );
+ }
  // =============================================================
      // FloatToInt(_, I32) should produce 16777216, not 16777217.
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let i = push(&mut f, InstKind::ConstInt(16_777_217, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let fv = push(&mut f, InstKind::IntToFloat(i, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 -    let back = push(&mut f, InstKind::FloatToInt(fv, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let i = push(
 +        &mut f,
 +        InstKind::ConstInt(16_777_217, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let fv = push(
 +        &mut f,
 +        InstKind::IntToFloat(i, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
 +    let back = push(
 +        &mut f,
 +        InstKind::FloatToInt(fv, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(back)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == back).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == back)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(16_777_216, IntWidth::I32) => { /* good */ }
 -        ref other => panic!("audit M-F: expected ConstInt(16777216, I32), got {:?}", other),
 +        ref other => panic!(
 +            "audit M-F: expected ConstInt(16777216, I32), got {:?}",
 +            other
 +        ),
+     }
+ }
      // change makes the source carry a different width.
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let v = push(&mut f, InstKind::ConstInt(0xFF, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v = push(
 +        &mut f,
 +        InstKind::ConstInt(0xFF, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let pc = push(&mut f, InstKind::PopCount(v), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(pc)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == pc).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == pc)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(8, IntWidth::I32) => { /* good */ }
          ref other => panic!("expected ConstInt(8, I32), got {:?}", other),
  fn audit_int_to_f32_then_fsub_wrong_answer_today() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Float(FloatWidth::F32));
 -    let i_a = push(&mut f, InstKind::ConstInt(16_777_217, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let i_b = push(&mut f, InstKind::ConstInt(16_777_216, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let f_a = push(&mut f, InstKind::IntToFloat(i_a, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 -    let f_b = push(&mut f, InstKind::IntToFloat(i_b, FloatWidth::F32), IrType::Float(FloatWidth::F32));
 -    let diff = push(&mut f, InstKind::FSub(f_a, f_b), IrType::Float(FloatWidth::F32));
 +    let i_a = push(
 +        &mut f,
 +        InstKind::ConstInt(16_777_217, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let i_b = push(
 +        &mut f,
 +        InstKind::ConstInt(16_777_216, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let f_a = push(
 +        &mut f,
 +        InstKind::IntToFloat(i_a, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
 +    let f_b = push(
 +        &mut f,
 +        InstKind::IntToFloat(i_b, FloatWidth::F32),
 +        IrType::Float(FloatWidth::F32),
 +    );
 +    let diff = push(
 +        &mut f,
 +        InstKind::FSub(f_a, f_b),
 +        IrType::Float(FloatWidth::F32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(diff)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == diff).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == diff)
 +        .unwrap();
      match folded.kind {
          // Expected: 0.0 (after correct f32 rounding both inputs are 16777216).
          // Bug:      1.0 (without rounding 16777217.0 - 16777216.0 = 1.0).
 -        InstKind::ConstFloat(v, FloatWidth::F32) => assert_eq!(v, 0.0,
 -            "expected 0.0 (both inputs round to 16777216 in f32), got {}", v),
 +        InstKind::ConstFloat(v, FloatWidth::F32) => assert_eq!(
 +            v, 0.0,
 +            "expected 0.0 (both inputs round to 16777216 in f32), got {}",
 +            v
 +        ),
          ref other => panic!("expected ConstFloat, got {:?}", other),
+     }
+ }
  fn audit_const_fold_imul_i8_overflow_wraps() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I8));
 -    let a = push(&mut f, InstKind::ConstInt(100, IntWidth::I8), IrType::Int(IntWidth::I8));
 -    let b = push(&mut f, InstKind::ConstInt(100, IntWidth::I8), IrType::Int(IntWidth::I8));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(100, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(100, IntWidth::I8),
 +        IrType::Int(IntWidth::I8),
 +    );
      let p = push(&mut f, InstKind::IMul(a, b), IrType::Int(IntWidth::I8));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(p)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == p).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == p)
 +        .unwrap();
      match folded.kind {
          // 100 * 100 = 10000; low byte = 0x10 = 16; sext = 16
          InstKind::ConstInt(v, IntWidth::I8) => assert_eq!(v, 16, "expected i8 wrap, got {}", v),
      let a_block = f.create_block("a");
      let b_block = f.create_block("b");
 -    let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let one = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Branch(a_block, vec![]));
      pm.run(&mut m);
      let post = verify_module(&m);
 -    assert!(post.is_empty(), "non-RPO block order broke optimization: {:?}", post);
 +    assert!(
 +        post.is_empty(),
 +        "non-RPO block order broke optimization: {:?}",
 +        post
 +    );
      // The fold MUST have converged: the IAdd's defining instruction
      // (still carrying `sum_id`) should now be the constant `3`, or
      // the entire dead chain should have been DCE'd and the terminator
      // should reference a const(3) directly.
      let f = &m.functions[0];
 -    let terminator_val = f.blocks.iter()
 +    let terminator_val = f
 +        .blocks
 +        .iter()
          .find_map(|b| match &b.terminator {
              Some(Terminator::Return(Some(v))) => Some(*v),
              _ => None,
          })
          .expect("no Return terminator");
 -    let term_kind = f.blocks.iter()
 +    let term_kind = f
 +        .blocks
 +        .iter()
          .flat_map(|b| b.insts.iter())
          .find(|i| i.id == terminator_val)
          .map(|i| i.kind.clone())
      let a_sum = f.next_value_id();
      f.block_mut(a_block).insts.push(Inst {
          id: a_sum,
 -        kind: InstKind::IAdd(c1, c2),    // folds to const(30)
 +        kind: InstKind::IAdd(c1, c2), // folds to const(30)
          ty: IrType::Int(IntWidth::I32),
          span: dummy_span(),
      });
      });
      f.block_mut(b_block).insts.push(Inst {
          id: b_sum,
 -        kind: InstKind::IAdd(a_sum, seven),  // folds to const(37)
 +        kind: InstKind::IAdd(a_sum, seven), // folds to const(37)
          ty: IrType::Int(IntWidth::I32),
          span: dummy_span(),
      });
      // The fold MUST converge in a single `ConstFold.run()` call —
      // the terminator's value should now define ConstInt(37) (= 10+20+7).
      let f = &m.functions[0];
 -    let terminator_val = f.blocks.iter()
 +    let terminator_val = f
 +        .blocks
 +        .iter()
          .find_map(|blk| match &blk.terminator {
              Some(Terminator::Return(Some(v))) => Some(*v),
              _ => None,
          })
          .expect("no Return terminator");
 -    let term_kind = f.blocks.iter()
 +    let term_kind = f
 +        .blocks
 +        .iter()
          .flat_map(|b| b.insts.iter())
          .find(|i| i.id == terminator_val)
          .map(|i| i.kind.clone())
  fn audit_const_fold_shl_full_width_wrap() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -    let v = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let cnt = push(&mut f, InstKind::ConstInt(31, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v = push(
 +        &mut f,
 +        InstKind::ConstInt(1, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let cnt = push(
 +        &mut f,
 +        InstKind::ConstInt(31, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let s = push(&mut f, InstKind::Shl(v, cnt), IrType::Int(IntWidth::I32));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(s)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == s).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == s)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(v, IntWidth::I32) => {
              // 1 << 31 in i32 is INT_MIN = -2147483648.
  fn audit_const_fold_iadd_i16_overflow() {
      let mut m = Module::new("t".into());
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I16));
 -    let a = push(&mut f, InstKind::ConstInt(32000, IntWidth::I16), IrType::Int(IntWidth::I16));
 -    let b = push(&mut f, InstKind::ConstInt(1000,  IntWidth::I16), IrType::Int(IntWidth::I16));
 +    let a = push(
 +        &mut f,
 +        InstKind::ConstInt(32000, IntWidth::I16),
 +        IrType::Int(IntWidth::I16),
 +    );
 +    let b = push(
 +        &mut f,
 +        InstKind::ConstInt(1000, IntWidth::I16),
 +        IrType::Int(IntWidth::I16),
 +    );
      let s = push(&mut f, InstKind::IAdd(a, b), IrType::Int(IntWidth::I16));
      let entry = f.entry;
      f.block_mut(entry).terminator = Some(Terminator::Return(Some(s)));
      m.add_function(f);
      ConstFold.run(&mut m);
 -    let folded = m.functions[0].blocks[0].insts.iter().find(|i| i.id == s).unwrap();
 +    let folded = m.functions[0].blocks[0]
 +        .insts
 +        .iter()
 +        .find(|i| i.id == s)
 +        .unwrap();
      match folded.kind {
          InstKind::ConstInt(v, IntWidth::I16) => {
              // 32000 + 1000 = 33000, wraps in i16 to -32536
      let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
      let cond = push(&mut f, InstKind::ConstBool(true), IrType::Bool);
 -    let v_a = push(&mut f, InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32));
 -    let v_b = push(&mut f, InstKind::ConstInt(20, IntWidth::I32), IrType::Int(IntWidth::I32));
 +    let v_a = push(
 +        &mut f,
 +        InstKind::ConstInt(10, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
 +    let v_b = push(
 +        &mut f,
 +        InstKind::ConstInt(20, IntWidth::I32),
 +        IrType::Int(IntWidth::I32),
 +    );
      let a = f.create_block("a");
      let b = f.create_block("b");
      let merge = f.create_block("merge");
      let m_param = f.next_value_id();
 -    f.block_mut(merge).params.push(BlockParam { id: m_param, ty: IrType::Int(IntWidth::I32) });
 +    f.block_mut(merge).params.push(BlockParam {
 +        id: m_param,
 +        ty: IrType::Int(IntWidth::I32),
 +    });
      f.block_mut(a).terminator = Some(Terminator::Branch(merge, vec![v_a]));
      f.block_mut(b).terminator = Some(Terminator::Branch(merge, vec![v_b]));
      ConstProp.run(&mut m);
      let post = verify_module(&m);
 -    assert!(post.is_empty(),
 -        "const_prop produced an invalid module after dropping the false arm: {:?}", post);
 +    assert!(
 +        post.is_empty(),
 +        "const_prop produced an invalid module after dropping the false arm: {:?}",
 +        post
 +    );
      // After folding, B should be gone but merge should still exist.
      let f = &m.functions[0];
 -    assert!(!f.blocks.iter().any(|bk| bk.id == b), "block B should be pruned");
 -    assert!(f.blocks.iter().any(|bk| bk.id == merge), "merge should remain");
 +    assert!(
 +        !f.blocks.iter().any(|bk| bk.id == b),
 +        "block B should be pruned"
 +    );
 +    assert!(
 +        f.blocks.iter().any(|bk| bk.id == merge),
 +        "merge should remain"
 +    );
+ }

src/opt/bce.rsmodified

322 lines changed — click to load

  //! element accesses. This pass removes the checks when the index is
  //! provably safe.
 -use crate::ir::inst::*;
 -use crate::ir::walk::{find_natural_loops, predecessors};
  use super::loop_utils::{find_preheader, resolve_const_int};
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use crate::ir::walk::{find_natural_loops, predecessors};
  pub struct Bce;
  impl Pass for Bce {
 -    fn name(&self) -> &'static str { "bce" }
 +    fn name(&self) -> &'static str {
 +        "bce"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if bce_function(func) { changed = true; }
 +            if bce_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
+         }
+     }
 -    if to_remove.is_empty() { return false; }
 +    if to_remove.is_empty() {
 +        return false;
 +    }
      // Remove in reverse order to preserve indices.
      to_remove.sort_by(|a, b| b.1.cmp(&a.1));
      // Case 2: index is a canonical loop IV, and the loop's closed range
      // stays within the checked bounds.
 -    let Some(lo_const) = resolve_int_scalar(func, lower) else { return false; };
 -    let Some(hi_const) = resolve_int_scalar(func, upper) else { return false; };
 +    let Some(lo_const) = resolve_int_scalar(func, lower) else {
 +        return false;
 +    };
 +    let Some(hi_const) = resolve_int_scalar(func, upper) else {
 +        return false;
 +    };
      for lp in loops {
          let Some((range_lo, range_hi)) = loop_index_range(func, lp, preds, index) else {
              continue;
  ) -> Option<i64> {
      let preheader = find_preheader(func, lp, preds)?;
      match &func.block(preheader).terminator {
 -        Some(Terminator::Branch(dest, args))
 -            if *dest == lp.header && param_idx < args.len() =>
 -        {
 +        Some(Terminator::Branch(dest, args)) if *dest == lp.header && param_idx < args.len() => {
              resolve_int_scalar(func, args[param_idx])
+         }
          _ => None,
      Descending,
+ }
 -fn loop_bound_const(
 -    func: &Function,
 -    header: BlockId,
 -    index: ValueId,
 -) -> Option<(i64, LoopDir)> {
 +fn loop_bound_const(func: &Function, header: BlockId, index: ValueId) -> Option<(i64, LoopDir)> {
      for inst in &func.block(header).insts {
 -        let InstKind::ICmp(op, lhs, rhs) = &inst.kind else { continue };
 +        let InstKind::ICmp(op, lhs, rhs) = &inst.kind else {
 +            continue;
 +        };
          match op {
              CmpOp::Le => {
                  if *lhs == index {
 -                    return resolve_int_scalar(func, *rhs)
 -                        .map(|bound| (bound, LoopDir::Ascending));
 +                    return resolve_int_scalar(func, *rhs).map(|bound| (bound, LoopDir::Ascending));
+                 }
                  if *rhs == index {
                      return resolve_int_scalar(func, *lhs)
                          .map(|bound| (bound, LoopDir::Descending));
+                 }
                  if *rhs == index {
 -                    return resolve_int_scalar(func, *lhs)
 -                        .map(|bound| (bound, LoopDir::Ascending));
 +                    return resolve_int_scalar(func, *lhs).map(|bound| (bound, LoopDir::Ascending));
+                 }
+             }
              _ => {}
  ) -> Option<i64> {
      let mut step: Option<i64> = None;
      for &latch in &lp.latches {
 -        let next =
 -            edge_arg_value(func.block(latch).terminator.as_ref()?, lp.header, param_idx)?;
 +        let next = edge_arg_value(func.block(latch).terminator.as_ref()?, lp.header, param_idx)?;
          let latch_step = update_step_const(func, index, next)?;
          if latch_step == 0 {
              return None;
  fn strip_int_casts(func: &Function, mut value: ValueId) -> ValueId {
      loop {
 -        let Some(kind) = find_inst_kind(func, value) else { return value };
 +        let Some(kind) = find_inst_kind(func, value) else {
 +            return value;
 +        };
          match kind {
              InstKind::IntExtend(src, _, _) | InstKind::IntTrunc(src, _) => value = *src,
              _ => return value,
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::opt::pass::Pass;
      #[test]
          let idx = f.next_value_id();
          f.register_type(idx, IrType::Int(IntWidth::I32));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: idx, ty: IrType::Int(IntWidth::I32), span,
 +            id: idx,
 +            ty: IrType::Int(IntWidth::I32),
 +            span,
              kind: InstKind::ConstInt(3, IntWidth::I32),
          });
          let lo = f.next_value_id();
          f.register_type(lo, IrType::Int(IntWidth::I32));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: lo, ty: IrType::Int(IntWidth::I32), span,
 +            id: lo,
 +            ty: IrType::Int(IntWidth::I32),
 +            span,
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let hi = f.next_value_id();
          f.register_type(hi, IrType::Int(IntWidth::I32));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: hi, ty: IrType::Int(IntWidth::I32), span,
 +            id: hi,
 +            ty: IrType::Int(IntWidth::I32),
 +            span,
              kind: InstKind::ConstInt(10, IntWidth::I32),
          });
          let check = f.next_value_id();
          f.register_type(check, IrType::Void);
          f.block_mut(f.entry).insts.push(Inst {
 -            id: check, ty: IrType::Void, span,
 +            id: check,
 +            ty: IrType::Void,
 +            span,
              kind: InstKind::RuntimeCall(RuntimeFunc::CheckBounds, vec![idx, lo, hi]),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
          assert!(changed, "constant 3 in [1,10] should be eliminated");
          // Verify the CheckBounds call was removed.
 -        let has_check = m.functions[0].blocks[0].insts.iter()
 +        let has_check = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
              .any(|i| matches!(i.kind, InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _)));
          assert!(!has_check, "CheckBounds should be removed");
+     }
          f.register_type(iv, IrType::Int(IntWidth::I32));
          let sum = f.next_value_id();
          f.register_type(sum, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 -        f.block_mut(header).params.push(BlockParam { id: sum, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: sum,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let bound = f.next_value_id();
          f.register_type(bound, IrType::Int(IntWidth::I32));
              span,
              kind: InstKind::IAdd(sum, step),
          });
 -        f.block_mut(body).terminator =
 -            Some(Terminator::Branch(header, vec![next_iv, next_sum]));
 +        f.block_mut(body).terminator = Some(Terminator::Branch(header, vec![next_iv, next_sum]));
          f.block_mut(exit).terminator = Some(Terminator::Return(None));
          m.add_function(f);
          let pass = Bce;
 -        assert!(pass.run(&mut m), "canonical counted-loop bounds check should be removed");
 +        assert!(
 +            pass.run(&mut m),
 +            "canonical counted-loop bounds check should be removed"
 +        );
          let has_check = m.functions[0].block(body).insts.iter().any(|inst| {
 -            matches!(inst.kind, InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _))
 +            matches!(
 +                inst.kind,
 +                InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _)
 +            )
          });
          assert!(!has_check, "loop body should no longer contain CheckBounds");
+     }
          f.register_type(iv, IrType::Int(IntWidth::I32));
          let sum = f.next_value_id();
          f.register_type(sum, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 -        f.block_mut(header).params.push(BlockParam { id: sum, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: sum,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let bound = f.next_value_id();
          f.register_type(bound, IrType::Int(IntWidth::I32));
              span,
              kind: InstKind::IAdd(sum, step),
          });
 -        f.block_mut(body).terminator =
 -            Some(Terminator::Branch(header, vec![next_iv, next_sum]));
 +        f.block_mut(body).terminator = Some(Terminator::Branch(header, vec![next_iv, next_sum]));
          f.block_mut(exit).terminator = Some(Terminator::Return(None));
          m.add_function(f);
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let bound = f.next_value_id();
          f.register_type(bound, IrType::Int(IntWidth::I32));
          m.add_function(f);
          let pass = Bce;
 -        assert!(pass.run(&mut m), "iv+1 check should be removed for trip range 2..7 and checked bounds 1..8");
 +        assert!(
 +            pass.run(&mut m),
 +            "iv+1 check should be removed for trip range 2..7 and checked bounds 1..8"
 +        );
          let has_check = m.functions[0].block(body).insts.iter().any(|inst| {
 -            matches!(inst.kind, InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _))
 +            matches!(
 +                inst.kind,
 +                InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _)
 +            )
          });
          assert!(!has_check, "loop body should no longer contain CheckBounds");
+     }
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let bound = f.next_value_id();
          f.register_type(bound, IrType::Int(IntWidth::I32));
          m.add_function(f);
          let pass = Bce;
 -        assert!(pass.run(&mut m), "iv-1 check should be removed for trip range 2..7 and checked bounds 1..8");
 +        assert!(
 +            pass.run(&mut m),
 +            "iv-1 check should be removed for trip range 2..7 and checked bounds 1..8"
 +        );
          let has_check = m.functions[0].block(body).insts.iter().any(|inst| {
 -            matches!(inst.kind, InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _))
 +            matches!(
 +                inst.kind,
 +                InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _)
 +            )
          });
          assert!(!has_check, "loop body should no longer contain CheckBounds");
+     }
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let bound = f.next_value_id();
          f.register_type(bound, IrType::Int(IntWidth::I32));
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let bound = f.next_value_id();
          f.register_type(bound, IrType::Int(IntWidth::I32));
              "iv+5 check should be removed when the trip sequence is only 5 and checked bounds are 1..10"
          );
          let has_check = m.functions[0].block(body).insts.iter().any(|inst| {
 -            matches!(inst.kind, InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _))
 +            matches!(
 +                inst.kind,
 +                InstKind::RuntimeCall(RuntimeFunc::CheckBounds, _)
 +            )
          });
          assert!(!has_check, "loop body should no longer contain CheckBounds");
+     }

src/opt/call_resolve.rsmodified

35 lines changed — click to load

  //!
  //! Runs as the first pass at O1+ (before Mem2Reg).
 -use std::collections::HashMap;
 -use crate::ir::inst::*;
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use std::collections::HashMap;
  pub struct CallResolve;
  impl Pass for CallResolve {
 -    fn name(&self) -> &'static str { "call-resolve" }
 +    fn name(&self) -> &'static str {
 +        "call-resolve"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          // Build name → index mapping for all functions in the module.
 -        let name_to_idx: HashMap<String, u32> = module.functions.iter()
 +        let name_to_idx: HashMap<String, u32> = module
 +            .functions
 +            .iter()
              .enumerate()
              .map(|(i, f)| (f.name.clone(), i as u32))
              .collect();
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
      use crate::ir::inst::*;
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::opt::pass::Pass;
      #[test]

src/opt/callgraph.rsmodified

112 lines changed — click to load

  //! Detects recursive functions via DFS cycle detection. Provides
  //! reverse post-order iteration for bottom-up inlining (callees first).
 -use std::collections::HashSet;
  use crate::ir::inst::*;
  use crate::ir::walk::find_natural_loops;
 +use std::collections::HashSet;
  /// A node in the call graph — one per function in the module.
  #[derive(Debug)]
      /// Build the call graph from a module.
      pub fn build(module: &Module) -> Self {
          let n = module.functions.len();
 -        let mut nodes: Vec<CallNode> = (0..n).map(|i| CallNode {
 -            func_idx: i as u32,
 -            callees: Vec::new(),
 -            callers: Vec::new(),
 -            inst_count: 0,
 -            is_recursive: false,
 -        }).collect();
 +        let mut nodes: Vec<CallNode> = (0..n)
 +            .map(|i| CallNode {
 +                func_idx: i as u32,
 +                callees: Vec::new(),
 +                callers: Vec::new(),
 +                inst_count: 0,
 +                is_recursive: false,
 +            })
 +            .collect();
          // Scan each function for Call(Internal) instructions.
          for (i, func) in module.functions.iter().enumerate() {
+ }
  fn rpo_dfs(nodes: &[CallNode], idx: u32, visited: &mut [bool], order: &mut Vec<u32>) {
 -    if visited[idx as usize] { return; }
 +    if visited[idx as usize] {
 +        return;
 +    }
      visited[idx as usize] = true;
      for &callee in &nodes[idx as usize].callees {
          if (callee as usize) < nodes.len() {
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      #[test]
          let call_id = f.next_value_id();
          f.register_type(call_id, IrType::Int(IntWidth::I32));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: call_id, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: call_id,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::Call(FuncRef::Internal(0), vec![]),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(Some(call_id)));
          m.add_function(f);
          let cg = CallGraph::build(&m);
 -        assert!(cg.is_recursive(0), "self-calling function should be recursive");
 +        assert!(
 +            cg.is_recursive(0),
 +            "self-calling function should be recursive"
 +        );
+     }
      #[test]
          let call_id = caller.next_value_id();
          caller.register_type(call_id, IrType::Int(IntWidth::I32));
          caller.block_mut(caller.entry).insts.push(Inst {
 -            id: call_id, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: call_id,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::Call(FuncRef::Internal(0), vec![]),
          });
          caller.block_mut(caller.entry).terminator = Some(Terminator::Return(None));
          let cid = caller.next_value_id();
          caller.register_type(cid, IrType::Void);
          caller.block_mut(caller.entry).insts.push(Inst {
 -            id: cid, ty: IrType::Void, span: span(),
 +            id: cid,
 +            ty: IrType::Void,
 +            span: span(),
              kind: InstKind::Call(FuncRef::Internal(0), vec![]),
          });
          caller.block_mut(caller.entry).terminator = Some(Terminator::Return(None));
          // Callee should come before caller in RPO.
          let callee_pos = rpo.iter().position(|&i| i == 0).unwrap();
          let caller_pos = rpo.iter().position(|&i| i == 1).unwrap();
 -        assert!(callee_pos < caller_pos, "callee should come before caller in RPO");
 +        assert!(
 +            callee_pos < caller_pos,
 +            "callee should come before caller in RPO"
 +        );
+     }
+ }

src/opt/const_arg.rsmodified

167 lines changed — click to load

  pub struct ConstArgSpecialize;
  impl Pass for ConstArgSpecialize {
 -    fn name(&self) -> &'static str { "const-arg-specialize" }
 +    fn name(&self) -> &'static str {
 +        "const-arg-specialize"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let param_modes: Vec<Vec<Option<ParamMode>>> = module
              .functions
              .iter()
 -            .map(|func| func.params.iter().map(|param| classify_param(func, param)).collect())
 +            .map(|func| {
 +                func.params
 +                    .iter()
 +                    .map(|param| classify_param(func, param))
 +                    .collect()
 +            })
              .collect();
          let plans = specialization_plans(module, &param_modes);
          span
      } else {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
+ }
  mod tests {
      use super::*;
      use crate::ir::types::IrType;
 -    use crate::opt::dead_arg::DeadArgElim;
      use crate::lexer::{Position, Span};
 +    use crate::opt::dead_arg::DeadArgElim;
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty: ty.clone(), span: span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty: ty.clone(),
 +            span: span(),
 +        });
          f.register_type(id, ty);
          id
+     }
          module.add_function(callee);
          let mut caller = Function::new("main".into(), vec![], IrType::Int(IntWidth::I32));
 -        let x1 = push(&mut caller, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let step1 = push(&mut caller, InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x1 = push(
 +            &mut caller,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let step1 = push(
 +            &mut caller,
 +            InstKind::ConstInt(3, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let c1 = push(
              &mut caller,
              InstKind::Call(FuncRef::Internal(0), vec![x1, step1]),
              IrType::Int(IntWidth::I32),
          );
 -        let x2 = push(&mut caller, InstKind::ConstInt(9, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let step2 = push(&mut caller, InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x2 = push(
 +            &mut caller,
 +            InstKind::ConstInt(9, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let step2 = push(
 +            &mut caller,
 +            InstKind::ConstInt(3, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let c2 = push(
              &mut caller,
              InstKind::Call(FuncRef::Internal(0), vec![x2, step2]),
              IrType::Int(IntWidth::I32),
          );
 -        let total = push(&mut caller, InstKind::IAdd(c1, c2), IrType::Int(IntWidth::I32));
 +        let total = push(
 +            &mut caller,
 +            InstKind::IAdd(c1, c2),
 +            IrType::Int(IntWidth::I32),
 +        );
          let caller_entry = caller.entry;
          caller.block_mut(caller_entry).terminator = Some(Terminator::Return(Some(total)));
          module.add_function(caller);
          assert!(ConstArgSpecialize.run(&mut module));
          assert!(DeadArgElim.run(&mut module));
 -        assert_eq!(module.functions[0].params.len(), 1, "specialized helper should drop constant dummy");
 +        assert_eq!(
 +            module.functions[0].params.len(),
 +            1,
 +            "specialized helper should drop constant dummy"
 +        );
          let call_args_1 = match &module.functions[1].blocks[0].insts[2].kind {
              InstKind::Call(FuncRef::Internal(0), args) => args,
              other => panic!("expected call, got {:?}", other),
          };
 -        assert_eq!(call_args_1.len(), 1, "call site should drop specialized constant arg");
 +        assert_eq!(
 +            call_args_1.len(),
 +            1,
 +            "call site should drop specialized constant arg"
 +        );
+     }
      #[test]
          module.add_function(callee);
          let mut caller = Function::new("main".into(), vec![], IrType::Int(IntWidth::I32));
 -        let x1 = push(&mut caller, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let step1 = push(&mut caller, InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x1 = push(
 +            &mut caller,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let step1 = push(
 +            &mut caller,
 +            InstKind::ConstInt(3, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let _ = push(
              &mut caller,
              InstKind::Call(FuncRef::Internal(0), vec![x1, step1]),
              IrType::Int(IntWidth::I32),
          );
 -        let x2 = push(&mut caller, InstKind::ConstInt(9, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let step2 = push(&mut caller, InstKind::ConstInt(4, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x2 = push(
 +            &mut caller,
 +            InstKind::ConstInt(9, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let step2 = push(
 +            &mut caller,
 +            InstKind::ConstInt(4, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let call = push(
              &mut caller,
              InstKind::Call(FuncRef::Internal(0), vec![x2, step2]),

src/opt/const_fold.rsmodified

506 lines changed — click to load

  use super::pass::Pass;
  use crate::ir::inst::*;
 -use crate::ir::types::{IrType, IntWidth, FloatWidth};
 +use crate::ir::types::{FloatWidth, IntWidth, IrType};
  use std::collections::HashMap;
  /// Compile-time constant value, normalized for folding.
      ///    the producer-side guarantee from M-1.
      fn from_inst(kind: &InstKind) -> Option<Self> {
          match kind {
 -            InstKind::ConstInt(v, w) => {
 -                Some(Const::Int(sext(*v, w.bits()), *w))
 -            }
 -            InstKind::ConstFloat(v, w) => {
 -                Some(Const::Float(round_for_width(*v, *w), *w))
 -            }
 +            InstKind::ConstInt(v, w) => Some(Const::Int(sext(*v, w.bits()), *w)),
 +            InstKind::ConstFloat(v, w) => Some(Const::Float(round_for_width(*v, *w), *w)),
              InstKind::ConstBool(b) => Some(Const::Bool(*b)),
              _ => None,
+         }
  /// Sign-extend `v` from `bits` to a full i128. Used so that comparisons
  /// and arithmetic on narrower integer types match hardware behavior.
  fn sext(v: i128, bits: u32) -> i128 {
 -    if bits >= 128 { v }
 -    else {
 +    if bits >= 128 {
 +        v
 +    } else {
          let shift = 128 - bits;
          (v << shift) >> shift
+     }
  /// Mask `v` down to `bits` low bits. The IR stores integers as i128 but
  /// arithmetic must wrap at the declared width.
  fn mask(v: i128, bits: u32) -> i128 {
 -    if bits >= 128 { v }
 -    else { v & ((1i128 << bits) - 1) }
 +    if bits >= 128 {
 +        v
 +    } else {
 +        v & ((1i128 << bits) - 1)
 +    }
+ }
  /// Truncate-then-sign-extend a wide arithmetic result back to its
          InstKind::IDiv(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
                  if let IrType::Int(w) = ty {
 -                    if bv == 0 { return None; } // leave divide-by-zero to runtime
 -                    if av == signed_min(*w) && bv == -1 { return None; }
 +                    if bv == 0 {
 +                        return None;
 +                    } // leave divide-by-zero to runtime
 +                    if av == signed_min(*w) && bv == -1 {
 +                        return None;
 +                    }
                      return Some(InstKind::ConstInt(norm(av / bv, *w), *w));
+                 }
+             }
          InstKind::IMod(a, b) => {
              if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (get(a), get(b)) {
                  if let IrType::Int(w) = ty {
 -                    if bv == 0 { return None; }
 -                    if av == signed_min(*w) && bv == -1 { return None; }
 +                    if bv == 0 {
 +                        return None;
 +                    }
 +                    if av == signed_min(*w) && bv == -1 {
 +                        return None;
 +                    }
                      return Some(InstKind::ConstInt(norm(av % bv, *w), *w));
+                 }
+             }
          // Bitwise ---------------------------------------------------------
          InstKind::BitAnd(a, b) => fold_int_bin(get(a), get(b), ty, |x, y| x & y),
 -        InstKind::BitOr(a, b)  => fold_int_bin(get(a), get(b), ty, |x, y| x | y),
 +        InstKind::BitOr(a, b) => fold_int_bin(get(a), get(b), ty, |x, y| x | y),
          InstKind::BitXor(a, b) => fold_int_bin(get(a), get(b), ty, |x, y| x ^ y),
          InstKind::BitNot(a) => {
              if let Some(Const::Int(av, _)) = get(a) {
                  if let IrType::Int(w) = ty {
                      let bits = w.bits() as i128;
                      if (0..bits).contains(&bv) {
 -                        return Some(InstKind::ConstInt(
 -                            norm(av.wrapping_shl(bv as u32), *w),
 -                            *w,
 -                        ));
 +                        return Some(InstKind::ConstInt(norm(av.wrapping_shl(bv as u32), *w), *w));
+                     }
                      return None;
+                 }
          InstKind::PopCount(a) => {
              if let (Some(Const::Int(av, src_w)), IrType::Int(out_w)) = (get(a), ty) {
                  let val = mask(av, src_w.bits()) as u128;
 -                return Some(InstKind::ConstInt(norm(val.count_ones() as i128, *out_w), *out_w));
 +                return Some(InstKind::ConstInt(
 +                    norm(val.count_ones() as i128, *out_w),
 +                    *out_w,
 +                ));
+             }
              None
+         }
              if let (Some(Const::Int(av, src_w)), IrType::Int(out_w)) = (get(a), ty) {
                  let bits = src_w.bits();
                  let val = mask(av, bits) as u128;
 -                let tz = if val == 0 { bits as i128 } else { val.trailing_zeros() as i128 };
 +                let tz = if val == 0 {
 +                    bits as i128
 +                } else {
 +                    val.trailing_zeros() as i128
 +                };
                  return Some(InstKind::ConstInt(norm(tz, *out_w), *out_w));
+             }
              None
+         }
          InstKind::FloatToInt(a, w) => {
              if let Some(Const::Float(av, src_fw)) = get(a) {
 -                if av.is_nan() || av.is_infinite() { return None; }
 +                if av.is_nan() || av.is_infinite() {
 +                    return None;
 +                }
                  // Audit B-3 (defense in depth): re-round at the
                  // source float width before truncating. The M-1
                  // invariant says any f32-tagged Const::Float is
                  // Fortran INT() truncates toward zero. Match.
                  let truncd = av.trunc();
                  let lo = match w {
 -                    IntWidth::I8  => i8::MIN  as f64,
 +                    IntWidth::I8 => i8::MIN as f64,
                      IntWidth::I16 => i16::MIN as f64,
                      IntWidth::I32 => i32::MIN as f64,
                      IntWidth::I64 => i64::MIN as f64,
                      IntWidth::I128 => return None,
                  };
                  let hi = match w {
 -                    IntWidth::I8  => i8::MAX  as f64,
 +                    IntWidth::I8 => i8::MAX as f64,
                      IntWidth::I16 => i16::MAX as f64,
                      IntWidth::I32 => i32::MAX as f64,
                      IntWidth::I64 => i64::MAX as f64,
                      IntWidth::I128 => return None,
                  };
 -                if truncd < lo || truncd > hi { return None; }
 +                if truncd < lo || truncd > hi {
 +                    return None;
 +                }
                  return Some(InstKind::ConstInt(norm(truncd as i128, *w), *w));
+             }
              None
+         }
          InstKind::IntExtend(a, w, signed) => {
              if let Some(Const::Int(av, src_w)) = get(a) {
 -                let v = if *signed { sext(av, src_w.bits()) } else { mask(av, src_w.bits()) };
 +                let v = if *signed {
 +                    sext(av, src_w.bits())
 +                } else {
 +                    mask(av, src_w.bits())
 +                };
                  return Some(InstKind::ConstInt(norm(v, *w), *w));
+             }
              None
                          (IrType::Float(FloatWidth::F64), Const::Float(v, _)) => {
                              Some(InstKind::ConstFloat(v, FloatWidth::F64))
+                         }
 -                        (IrType::Bool, Const::Bool(b)) => {
 -                            Some(InstKind::ConstBool(b))
 -                        }
 +                        (IrType::Bool, Const::Bool(b)) => Some(InstKind::ConstBool(b)),
                          // Type categories disagree — bail rather than
                          // type-pun. The verifier doesn't catch the
                          // mismatch (it only checks `is_int`/`is_float`
  // f32 destinations because the op itself can produce a value
  // outside f32's representable range.
  fn fold_float_bin<F>(a: Option<Const>, b: Option<Const>, ty: &IrType, op: F) -> Option<InstKind>
 -where F: FnOnce(f64, f64) -> f64
 +where
 +    F: FnOnce(f64, f64) -> f64,
+ {
      if let (Some(Const::Float(av, _)), Some(Const::Float(bv, _))) = (a, b) {
          if let IrType::Float(w) = ty {
+ }
  fn fold_float_un<F>(a: Option<Const>, ty: &IrType, op: F) -> Option<InstKind>
 -where F: FnOnce(f64) -> f64
 +where
 +    F: FnOnce(f64) -> f64,
+ {
      if let Some(Const::Float(av, _)) = a {
          if let IrType::Float(w) = ty {
+ }
  fn fold_int_bin<F>(a: Option<Const>, b: Option<Const>, ty: &IrType, op: F) -> Option<InstKind>
 -where F: FnOnce(i128, i128) -> i128
 +where
 +    F: FnOnce(i128, i128) -> i128,
+ {
      if let (Some(Const::Int(av, _)), Some(Const::Int(bv, _))) = (a, b) {
          if let IrType::Int(w) = ty {
  pub struct ConstFold;
  impl Pass for ConstFold {
 -    fn name(&self) -> &'static str { "const-fold" }
 +    fn name(&self) -> &'static str {
 +        "const-fold"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
                  inner_changed = false;
                  for block in &mut func.blocks {
                      for inst in &mut block.insts {
 -                        if consts.contains_key(&inst.id) { continue; }
 +                        if consts.contains_key(&inst.id) {
 +                            continue;
 +                        }
                          if let Some(new_kind) = try_fold(&inst.kind, &inst.ty, &consts) {
                              if let Some(c) = Const::from_inst(&new_kind) {
                                  consts.insert(inst.id, c);
      fn dummy_span() -> crate::lexer::Span {
          let p = crate::lexer::Position { line: 1, col: 1 };
 -        crate::lexer::Span { start: p, end: p, file_id: 0 }
 +        crate::lexer::Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn make_module_with(insts: Vec<(InstKind, IrType)>) -> (Module, Vec<ValueId>) {
          for (kind, ty) in insts {
              let id = f.next_value_id();
              ids.push(id);
 -            f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +            f.block_mut(entry).insts.push(Inst {
 +                id,
 +                kind,
 +                ty,
 +                span: dummy_span(),
 +            });
+         }
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
+     }
      fn first_block_kinds(m: &Module) -> Vec<InstKind> {
 -        m.functions[0].blocks[0].insts.iter().map(|i| i.kind.clone()).collect()
 +        m.functions[0].blocks[0]
 +            .insts
 +            .iter()
 +            .map(|i| i.kind.clone())
 +            .collect()
+     }
      #[test]
      fn folds_iadd_i32() {
          let (mut m, ids) = make_module_with(vec![
 -            (InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(4, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::IAdd(ValueId(0), ValueId(1)), IrType::Int(IntWidth::I32)),
 +            (
 +                InstKind::ConstInt(3, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(4, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::IAdd(ValueId(0), ValueId(1)),
 +                IrType::Int(IntWidth::I32),
 +            ),
          ]);
          let _ = ids;
          assert!(ConstFold.run(&mut m));
      fn integer_overflow_wraps_at_width() {
          // i8: 100 + 50 = 150 → wraps to -106
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(100, IntWidth::I8), IrType::Int(IntWidth::I8)),
 -            (InstKind::ConstInt(50,  IntWidth::I8), IrType::Int(IntWidth::I8)),
 -            (InstKind::IAdd(ValueId(0), ValueId(1)), IrType::Int(IntWidth::I8)),
 +            (
 +                InstKind::ConstInt(100, IntWidth::I8),
 +                IrType::Int(IntWidth::I8),
 +            ),
 +            (
 +                InstKind::ConstInt(50, IntWidth::I8),
 +                IrType::Int(IntWidth::I8),
 +            ),
 +            (
 +                InstKind::IAdd(ValueId(0), ValueId(1)),
 +                IrType::Int(IntWidth::I8),
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
          let kinds = first_block_kinds(&m);
      #[test]
      fn idiv_by_zero_left_alone() {
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(0,  IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::IDiv(ValueId(0), ValueId(1)), IrType::Int(IntWidth::I32)),
 +            (
 +                InstKind::ConstInt(10, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(0, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::IDiv(ValueId(0), ValueId(1)),
 +                IrType::Int(IntWidth::I32),
 +            ),
          ]);
          assert!(!ConstFold.run(&mut m));
          let kinds = first_block_kinds(&m);
      #[test]
      fn fmul_f64() {
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstFloat(2.0, FloatWidth::F64), IrType::Float(FloatWidth::F64)),
 -            (InstKind::ConstFloat(3.14, FloatWidth::F64), IrType::Float(FloatWidth::F64)),
 -            (InstKind::FMul(ValueId(0), ValueId(1)), IrType::Float(FloatWidth::F64)),
 +            (
 +                InstKind::ConstFloat(2.0, FloatWidth::F64),
 +                IrType::Float(FloatWidth::F64),
 +            ),
 +            (
 +                InstKind::ConstFloat(3.14, FloatWidth::F64),
 +                IrType::Float(FloatWidth::F64),
 +            ),
 +            (
 +                InstKind::FMul(ValueId(0), ValueId(1)),
 +                IrType::Float(FloatWidth::F64),
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
          let kinds = first_block_kinds(&m);
      #[test]
      fn icmp_eq_true() {
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(5, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(5, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ICmp(CmpOp::Eq, ValueId(0), ValueId(1)), IrType::Bool),
 +            (
 +                InstKind::ConstInt(5, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(5, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ICmp(CmpOp::Eq, ValueId(0), ValueId(1)),
 +                IrType::Bool,
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
 -        assert!(matches!(first_block_kinds(&m)[2], InstKind::ConstBool(true)));
 +        assert!(matches!(
 +            first_block_kinds(&m)[2],
 +            InstKind::ConstBool(true)
 +        ));
+     }
      #[test]
          // i8 representation: -1 stored as 0xff (255). Without sign-extension,
          // a naive (av < bv) would compare 255 < 1 → false; correct is true.
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(-1, IntWidth::I8), IrType::Int(IntWidth::I8)),
 -            (InstKind::ConstInt(1,  IntWidth::I8), IrType::Int(IntWidth::I8)),
 -            (InstKind::ICmp(CmpOp::Lt, ValueId(0), ValueId(1)), IrType::Bool),
 +            (
 +                InstKind::ConstInt(-1, IntWidth::I8),
 +                IrType::Int(IntWidth::I8),
 +            ),
 +            (
 +                InstKind::ConstInt(1, IntWidth::I8),
 +                IrType::Int(IntWidth::I8),
 +            ),
 +            (
 +                InstKind::ICmp(CmpOp::Lt, ValueId(0), ValueId(1)),
 +                IrType::Bool,
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
 -        assert!(matches!(first_block_kinds(&m)[2], InstKind::ConstBool(true)));
 +        assert!(matches!(
 +            first_block_kinds(&m)[2],
 +            InstKind::ConstBool(true)
 +        ));
+     }
      #[test]
      fn shl_power_of_two() {
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::Shl(ValueId(0), ValueId(1)), IrType::Int(IntWidth::I32)),
 +            (
 +                InstKind::ConstInt(1, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(3, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::Shl(ValueId(0), ValueId(1)),
 +                IrType::Int(IntWidth::I32),
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
          match first_block_kinds(&m)[2] {
      fn int_to_float_chain() {
          // const(42:i32) → int_to_float → const(42.0:f64)
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::IntToFloat(ValueId(0), FloatWidth::F64), IrType::Float(FloatWidth::F64)),
 +            (
 +                InstKind::ConstInt(42, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::IntToFloat(ValueId(0), FloatWidth::F64),
 +                IrType::Float(FloatWidth::F64),
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
          match first_block_kinds(&m)[1] {
      fn select_on_known_cond_picks_branch() {
          let (mut m, _) = make_module_with(vec![
              (InstKind::ConstBool(true), IrType::Bool),
 -            (InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(20, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::Select(ValueId(0), ValueId(1), ValueId(2)), IrType::Int(IntWidth::I32)),
 +            (
 +                InstKind::ConstInt(10, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(20, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::Select(ValueId(0), ValueId(1), ValueId(2)),
 +                IrType::Int(IntWidth::I32),
 +            ),
          ]);
          assert!(ConstFold.run(&mut m));
          match first_block_kinds(&m)[3] {
      fn fixpoint_via_chained_constants() {
          // (3 + 4) * 2 = 14, where the inner add must fold first.
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(4, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::IAdd(ValueId(0), ValueId(1)), IrType::Int(IntWidth::I32)),
 -            (InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32)),
 -            (InstKind::IMul(ValueId(2), ValueId(3)), IrType::Int(IntWidth::I32)),
 +            (
 +                InstKind::ConstInt(3, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(4, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::IAdd(ValueId(0), ValueId(1)),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::ConstInt(2, IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
 +            (
 +                InstKind::IMul(ValueId(2), ValueId(3)),
 +                IrType::Int(IntWidth::I32),
 +            ),
          ]);
          // A single pass already handles this because we walk in order.
          assert!(ConstFold.run(&mut m));
          let kinds = first_block_kinds(&m);
 -        assert!(matches!(kinds[2], InstKind::ConstInt(7,  IntWidth::I32)));
 +        assert!(matches!(kinds[2], InstKind::ConstInt(7, IntWidth::I32)));
          assert!(matches!(kinds[4], InstKind::ConstInt(14, IntWidth::I32)));
+     }
      #[test]
      fn nan_float_to_int_left_alone() {
          let (mut m, _) = make_module_with(vec![
 -            (InstKind::ConstFloat(f64::NAN, FloatWidth::F64), IrType::Float(FloatWidth::F64)),
 -            (InstKind::FloatToInt(ValueId(0), IntWidth::I32), IrType::Int(IntWidth::I32)),
 +            (
 +                InstKind::ConstFloat(f64::NAN, FloatWidth::F64),
 +                IrType::Float(FloatWidth::F64),
 +            ),
 +            (
 +                InstKind::FloatToInt(ValueId(0), IntWidth::I32),
 +                IrType::Int(IntWidth::I32),
 +            ),
          ]);
          assert!(!ConstFold.run(&mut m));
          assert!(matches!(first_block_kinds(&m)[1], InstKind::FloatToInt(..)));

src/opt/const_prop.rsmodified

106 lines changed — click to load

  pub struct ConstProp;
  impl Pass for ConstProp {
 -    fn name(&self) -> &'static str { "const-prop" }
 +    fn name(&self) -> &'static str {
 +        "const-prop"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
              let consts = collect_consts(func);
              let mut local_changed = false;
              for block in &mut func.blocks {
 -                let Some(term) = block.terminator.take() else { continue };
 +                let Some(term) = block.terminator.take() else {
 +                    continue;
 +                };
                  let new_term = simplify_terminator(term, &consts, &mut local_changed);
                  block.terminator = Some(new_term);
+             }
      changed: &mut bool,
  ) -> Terminator {
      match term {
 -        Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args } => {
 +        Terminator::CondBranch {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        } => {
              if let Some(Const::Bool(c)) = consts.get(&cond).copied() {
                  *changed = true;
                  if c {
                      Terminator::Branch(false_dest, false_args)
+                 }
              } else {
 -                Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args }
 +                Terminator::CondBranch {
 +                    cond,
 +                    true_dest,
 +                    true_args,
 +                    false_dest,
 +                    false_args,
 +                }
+             }
+         }
 -        Terminator::Switch { selector, cases, default } => {
 +        Terminator::Switch {
 +            selector,
 +            cases,
 +            default,
 +        } => {
              if let Some(Const::Int(sv, w)) = consts.get(&selector).copied() {
                  // `sv` is already canonical (sign-extended at width)
                  // thanks to the M4-4 normalization in `Const::from_inst`.
                  // canonical, so we still normalize them before
                  // comparing.
                  *changed = true;
 -                let target = cases.iter().find(|(k, _)| sext(*k, w.bits()) == sv)
 +                let target = cases
 +                    .iter()
 +                    .find(|(k, _)| sext(*k, w.bits()) == sv)
                      .map(|(_, b)| *b)
                      .unwrap_or(default);
                  // Switch targets in our IR cannot have block params, so
                  // an empty arg vec is correct.
                  Terminator::Branch(target, vec![])
              } else {
 -                Terminator::Switch { selector, cases, default }
 +                Terminator::Switch {
 +                    selector,
 +                    cases,
 +                    default,
 +                }
+             }
+         }
          other => other,
+ }
  fn sext(v: i64, bits: u32) -> i64 {
 -    if bits >= 64 { v }
 -    else {
 +    if bits >= 64 {
 +        v
 +    } else {
          let shift = 64 - bits;
          (v << shift) >> shift
+     }
  mod tests {
      use super::*;
      use crate::ir::types::IrType;
 -    use crate::lexer::{Span, Position};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      #[test]

src/opt/cse.rsmodified

287 lines changed — click to load

  /// instruction is impure or otherwise not a CSE candidate.
  fn key_of(inst: &Inst) -> Option<Key> {
      let mk = |tag: u32, ops: Vec<ValueId>, aux: i128| -> Option<Key> {
 -        Some(Key { tag, operands: ops, aux, name: None, ty: inst.ty.clone() })
 +        Some(Key {
 +            tag,
 +            operands: ops,
 +            aux,
 +            name: None,
 +            ty: inst.ty.clone(),
 +        })
      };
      let mk_named = |tag: u32, name: String| -> Option<Key> {
 -        Some(Key { tag, operands: vec![], aux: 0, name: Some(name), ty: inst.ty.clone() })
 +        Some(Key {
 +            tag,
 +            operands: vec![],
 +            aux: 0,
 +            name: Some(name),
 +            ty: inst.ty.clone(),
 +        })
      };
      let canon = |a: ValueId, b: ValueId| -> Vec<ValueId> {
 -        if a.0 <= b.0 { vec![a, b] } else { vec![b, a] }
 +        if a.0 <= b.0 {
 +            vec![a, b]
 +        } else {
 +            vec![b, a]
 +        }
      };
      match &inst.kind {
          // at different bit patterns dedupe. Example: `ConstInt(255, I8)`
          // and `ConstInt(-1, I8)` both represent -1 in i8 — keying on
          // the raw `*v` fails to dedupe them.
 -        InstKind::ConstInt(v, w)   => {
 +        InstKind::ConstInt(v, w) => {
              let bits = w.bits();
              // Sign-extend at width: low `bits` bits → i64 sign-extended.
              let signed = if bits >= 128 {
              mk(1, vec![], signed)
+         }
          InstKind::ConstFloat(v, _) => mk(2, vec![], v.to_bits() as i128),
 -        InstKind::ConstBool(b)     => mk(3, vec![], if *b { 1 } else { 0 }),
 +        InstKind::ConstBool(b) => mk(3, vec![], if *b { 1 } else { 0 }),
          // Integer arithmetic --------------------------------------------
          InstKind::IAdd(a, b) => mk(10, canon(*a, *b), 0),
          InstKind::IMul(a, b) => mk(12, canon(*a, *b), 0),
          InstKind::IDiv(a, b) => mk(13, vec![*a, *b], 0),
          InstKind::IMod(a, b) => mk(14, vec![*a, *b], 0),
 -        InstKind::INeg(a)    => mk(15, vec![*a], 0),
 +        InstKind::INeg(a) => mk(15, vec![*a], 0),
          // Float arithmetic ----------------------------------------------
          InstKind::FAdd(a, b) => mk(20, canon(*a, *b), 0),
          InstKind::FSub(a, b) => mk(21, vec![*a, *b], 0),
          InstKind::FMul(a, b) => mk(22, canon(*a, *b), 0),
          InstKind::FDiv(a, b) => mk(23, vec![*a, *b], 0),
 -        InstKind::FNeg(a)    => mk(24, vec![*a], 0),
 -        InstKind::FAbs(a)    => mk(25, vec![*a], 0),
 -        InstKind::FSqrt(a)   => mk(26, vec![*a], 0),
 +        InstKind::FNeg(a) => mk(24, vec![*a], 0),
 +        InstKind::FAbs(a) => mk(25, vec![*a], 0),
 +        InstKind::FSqrt(a) => mk(26, vec![*a], 0),
          InstKind::FPow(a, b) => mk(27, vec![*a, *b], 0),
          // Comparisons ---------------------------------------------------
          InstKind::ICmp(op, a, b) => {
              let aux = *op as i128;
 -            let ops = match op { CmpOp::Eq | CmpOp::Ne => canon(*a, *b), _ => vec![*a, *b] };
 +            let ops = match op {
 +                CmpOp::Eq | CmpOp::Ne => canon(*a, *b),
 +                _ => vec![*a, *b],
 +            };
              mk(30, ops, aux)
+         }
          InstKind::FCmp(op, a, b) => {
              let aux = *op as i128;
 -            let ops = match op { CmpOp::Eq | CmpOp::Ne => canon(*a, *b), _ => vec![*a, *b] };
 +            let ops = match op {
 +                CmpOp::Eq | CmpOp::Ne => canon(*a, *b),
 +                _ => vec![*a, *b],
 +            };
              mk(31, ops, aux)
+         }
          // Logic ---------------------------------------------------------
          InstKind::And(a, b) => mk(40, canon(*a, *b), 0),
 -        InstKind::Or(a, b)  => mk(41, canon(*a, *b), 0),
 -        InstKind::Not(a)    => mk(42, vec![*a], 0),
 +        InstKind::Or(a, b) => mk(41, canon(*a, *b), 0),
 +        InstKind::Not(a) => mk(42, vec![*a], 0),
          InstKind::Select(c, t, f) => mk(43, vec![*c, *t, *f], 0),
          // Bitwise -------------------------------------------------------
          InstKind::BitAnd(a, b) => mk(50, canon(*a, *b), 0),
 -        InstKind::BitOr(a, b)  => mk(51, canon(*a, *b), 0),
 +        InstKind::BitOr(a, b) => mk(51, canon(*a, *b), 0),
          InstKind::BitXor(a, b) => mk(52, canon(*a, *b), 0),
 -        InstKind::BitNot(a)    => mk(53, vec![*a], 0),
 -        InstKind::Shl(a, b)    => mk(54, vec![*a, *b], 0),
 -        InstKind::LShr(a, b)   => mk(55, vec![*a, *b], 0),
 -        InstKind::AShr(a, b)   => mk(56, vec![*a, *b], 0),
 -        InstKind::CountLeadingZeros(a)  => mk(57, vec![*a], 0),
 +        InstKind::BitNot(a) => mk(53, vec![*a], 0),
 +        InstKind::Shl(a, b) => mk(54, vec![*a, *b], 0),
 +        InstKind::LShr(a, b) => mk(55, vec![*a, *b], 0),
 +        InstKind::AShr(a, b) => mk(56, vec![*a, *b], 0),
 +        InstKind::CountLeadingZeros(a) => mk(57, vec![*a], 0),
          InstKind::CountTrailingZeros(a) => mk(58, vec![*a], 0),
 -        InstKind::PopCount(a)           => mk(59, vec![*a], 0),
 +        InstKind::PopCount(a) => mk(59, vec![*a], 0),
          // Conversions ---------------------------------------------------
 -        InstKind::IntToFloat(v, fw)     => mk(60, vec![*v], fw.bits() as i128),
 -        InstKind::FloatToInt(v, w)      => mk(61, vec![*v], w.bits() as i128),
 -        InstKind::FloatExtend(v, fw)    => mk(62, vec![*v], fw.bits() as i128),
 -        InstKind::FloatTrunc(v, fw)     => mk(63, vec![*v], fw.bits() as i128),
 -        InstKind::IntExtend(v, w, sgn)  => mk(64, vec![*v], (w.bits() as i128) | ((*sgn as i128) << 32)),
 -        InstKind::IntTrunc(v, w)        => mk(65, vec![*v], w.bits() as i128),
 -        InstKind::PtrToInt(v)           => mk(66, vec![*v], 0),
 -        InstKind::IntToPtr(v, _)        => mk(67, vec![*v], 0),
 +        InstKind::IntToFloat(v, fw) => mk(60, vec![*v], fw.bits() as i128),
 +        InstKind::FloatToInt(v, w) => mk(61, vec![*v], w.bits() as i128),
 +        InstKind::FloatExtend(v, fw) => mk(62, vec![*v], fw.bits() as i128),
 +        InstKind::FloatTrunc(v, fw) => mk(63, vec![*v], fw.bits() as i128),
 +        InstKind::IntExtend(v, w, sgn) => {
 +            mk(64, vec![*v], (w.bits() as i128) | ((*sgn as i128) << 32))
 +        }
 +        InstKind::IntTrunc(v, w) => mk(65, vec![*v], w.bits() as i128),
 +        InstKind::PtrToInt(v) => mk(66, vec![*v], 0),
 +        InstKind::IntToPtr(v, _) => mk(67, vec![*v], 0),
          // Address arithmetic --------------------------------------------
          InstKind::GetElementPtr(base, idxs) => {
  pub struct LocalCse;
  impl Pass for LocalCse {
 -    fn name(&self) -> &'static str { "local-cse" }
 +    fn name(&self) -> &'static str {
 +        "local-cse"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
+                     }
+                 }
+             }
 -            if rewrite_map.is_empty() { continue; }
 +            if rewrite_map.is_empty() {
 +                continue;
 +            }
              // Audit B-7: in **local** CSE, every entry maps a later
              // duplicate to its block's *first* occurrence — and that
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth, FloatWidth};
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{FloatWidth, IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
          // ret %3 → after CSE → ret %2 (and %3 is dead)
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -        let a = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let b = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstInt(2, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let c1 = push(&mut f, InstKind::IAdd(a, b), IrType::Int(IntWidth::I32));
          let c2 = push(&mut f, InstKind::IAdd(a, b), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          // Should canonicalize to the same key.
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -        let a = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let b = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstInt(2, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let c1 = push(&mut f, InstKind::IAdd(a, b), IrType::Int(IntWidth::I32));
          let c2 = push(&mut f, InstKind::IAdd(b, a), IrType::Int(IntWidth::I32));
          let _ = c2;
      fn non_commutative_isub_does_not_dedupe_swapped() {
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -        let a = push(&mut f, InstKind::ConstInt(5, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let b = push(&mut f, InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstInt(5, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstInt(3, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let _c1 = push(&mut f, InstKind::ISub(a, b), IrType::Int(IntWidth::I32));
          let c2 = push(&mut f, InstKind::ISub(b, a), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          // Loads must NOT be deduplicated by local CSE.
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let addr = push(&mut f,
 +        let addr = push(
 +            &mut f,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
      fn fmul_dedupes() {
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Float(FloatWidth::F64));
 -        let a = push(&mut f, InstKind::ConstFloat(1.5, FloatWidth::F64), IrType::Float(FloatWidth::F64));
 -        let b = push(&mut f, InstKind::ConstFloat(2.5, FloatWidth::F64), IrType::Float(FloatWidth::F64));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstFloat(1.5, FloatWidth::F64),
 +            IrType::Float(FloatWidth::F64),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstFloat(2.5, FloatWidth::F64),
 +            IrType::Float(FloatWidth::F64),
 +        );
          let m1 = push(&mut f, InstKind::FMul(a, b), IrType::Float(FloatWidth::F64));
          let m2 = push(&mut f, InstKind::FMul(b, a), IrType::Float(FloatWidth::F64));
          let entry = f.entry;
          // Lt is not commutative — must not collapse.
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Bool);
 -        let a = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let b = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstInt(2, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let _c1 = push(&mut f, InstKind::ICmp(CmpOp::Lt, a, b), IrType::Bool);
          let c2 = push(&mut f, InstKind::ICmp(CmpOp::Lt, b, a), IrType::Bool);
          let entry = f.entry;

src/opt/dce.rsmodified

298 lines changed — click to load

  //! refine this.
  use super::pass::Pass;
 -use super::util::{inst_uses, terminator_uses, prune_unreachable};
 +use super::util::{inst_uses, prune_unreachable, terminator_uses};
  use crate::ir::inst::*;
  use std::collections::{HashMap, HashSet};
              // future store/call). Treat as side-effecting for safety.
              | InstKind::Alloca(..)
      ) || match kind {
 -        InstKind::Call(FuncRef::Internal(idx), _) => {
 -            !pure_internal_calls.get(*idx as usize).copied().unwrap_or(false)
 -        }
 +        InstKind::Call(FuncRef::Internal(idx), _) => !pure_internal_calls
 +            .get(*idx as usize)
 +            .copied()
 +            .unwrap_or(false),
          InstKind::Call(..) => true,
          _ => false,
+     }
              for block in &mut func.blocks {
                  let before = block.insts.len();
                  block.insts.retain(|inst| {
 -                    if has_side_effect(&inst.kind, pure_internal_calls) { return true; }
 -                    if live.contains(&inst.id) { return true; }
 +                    if has_side_effect(&inst.kind, pure_internal_calls) {
 +                        return true;
 +                    }
 +                    if live.contains(&inst.id) {
 +                        return true;
 +                    }
                      false
                  });
                  if block.insts.len() != before {
              outer_changed = true;
+         }
+     }
 -    if prune_unreachable(func) { any_change = true; }
 +    if prune_unreachable(func) {
 +        any_change = true;
 +    }
      any_change
+ }
      let mut by_block: HashMap<BlockId, Vec<usize>> = HashMap::new();
      for block in func.blocks.iter() {
 -        if block.id == func.entry { continue; }
 +        if block.id == func.entry {
 +            continue;
 +        }
          for (idx, p) in block.params.iter().enumerate() {
              if !live.contains(&p.id) {
                  by_block.entry(block.id).or_default().push(idx);
+             }
+         }
+     }
 -    if by_block.is_empty() { return false; }
 +    if by_block.is_empty() {
 +        return false;
 +    }
      // Map BlockId → vec index. LICM/DCE never structurally reorder
      // `func.blocks`; only the inst vectors change. So this stays
      // valid for the lifetime of this call.
 -    let block_index: HashMap<BlockId, usize> = func.blocks.iter()
 +    let block_index: HashMap<BlockId, usize> = func
 +        .blocks
 +        .iter()
          .enumerate()
          .map(|(i, b)| (b.id, i))
          .collect();
  fn drop_branch_arg(term: &mut Terminator, target: BlockId, idx: usize) {
      match term {
          Terminator::Branch(d, args) if *d == target => {
 -            debug_assert!(idx < args.len(),
 -                "drop_branch_arg: branch arg list out of sync with target params");
 -            if idx < args.len() { args.remove(idx); }
 +            debug_assert!(
 +                idx < args.len(),
 +                "drop_branch_arg: branch arg list out of sync with target params"
 +            );
 +            if idx < args.len() {
 +                args.remove(idx);
 +            }
+         }
 -        Terminator::CondBranch { true_dest, true_args, false_dest, false_args, .. } => {
 +        Terminator::CondBranch {
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +            ..
 +        } => {
              if *true_dest == target {
 -                debug_assert!(idx < true_args.len(),
 -                    "drop_branch_arg: cond_branch true_args out of sync");
 -                if idx < true_args.len() { true_args.remove(idx); }
 +                debug_assert!(
 +                    idx < true_args.len(),
 +                    "drop_branch_arg: cond_branch true_args out of sync"
 +                );
 +                if idx < true_args.len() {
 +                    true_args.remove(idx);
 +                }
+             }
              if *false_dest == target {
 -                debug_assert!(idx < false_args.len(),
 -                    "drop_branch_arg: cond_branch false_args out of sync");
 -                if idx < false_args.len() { false_args.remove(idx); }
 +                debug_assert!(
 +                    idx < false_args.len(),
 +                    "drop_branch_arg: cond_branch false_args out of sync"
 +                );
 +                if idx < false_args.len() {
 +                    false_args.remove(idx);
 +                }
+             }
+         }
          Terminator::Switch { cases, default, .. } => {
              // M-6: if we ever see a Switch that branches into a
              // block we're stripping params from, that's a real IR
              // validity bug. Assert instead of silently skipping.
 -            let touches_target = cases.iter().any(|(_, b)| *b == target)
 -                || *default == target;
 -            debug_assert!(!touches_target,
 +            let touches_target = cases.iter().any(|(_, b)| *b == target) || *default == target;
 +            debug_assert!(
 +                !touches_target,
                  "drop_branch_arg: Switch terminator branches to a block with params \
 -                 — verifier should reject this construction");
 +                 — verifier should reject this construction"
 +            );
+         }
          _ => {}
+     }
  pub struct Dce;
  impl Pass for Dce {
 -    fn name(&self) -> &'static str { "dce" }
 +    fn name(&self) -> &'static str {
 +        "dce"
 +    }
      fn run(&self, module: &mut Module) -> bool {
 -        let pure_internal_calls: Vec<bool> = module.functions.iter().map(|func| func.is_pure).collect();
 +        let pure_internal_calls: Vec<bool> =
 +            module.functions.iter().map(|func| func.is_pure).collect();
          let mut changed = false;
          for func in &mut module.functions {
 -            if dce_function(func, &pure_internal_calls) { changed = true; }
 +            if dce_function(func, &pure_internal_calls) {
 +                changed = true;
 +            }
+         }
          changed
+     }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth, FloatWidth};
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{FloatWidth, IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
      fn removes_unused_const() {
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        push(
 +            &mut f,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
      fn keeps_const_used_by_return() {
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
 -        let v = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let v = push(
 +            &mut f,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(v)));
          m.add_function(f);
          // Alloca + Store should both stay even though no one loads.
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let addr = push(&mut f,
 +        let addr = push(
 +            &mut f,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let v = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let v = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v, addr), IrType::Void);
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          // After DCE: only the terminator remains.
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let a = push(&mut f, InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let b = push(&mut f, InstKind::ConstInt(4, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstInt(3, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstInt(4, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let c = push(&mut f, InstKind::IAdd(a, b), IrType::Int(IntWidth::I32));
          let _d = push(&mut f, InstKind::INeg(c), IrType::Int(IntWidth::I32));
          let entry = f.entry;
      fn keeps_call_even_if_result_unused() {
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        push(&mut f,
 +        push(
 +            &mut f,
              InstKind::RuntimeCall(RuntimeFunc::PrintNewline, vec![]),
              IrType::Void,
          );
          let mut callee = Function::new("pure_fn".into(), vec![], IrType::Int(IntWidth::I32));
          callee.is_pure = true;
 -        let c = push(&mut callee, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c = push(
 +            &mut callee,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let callee_entry = callee.entry;
          callee.block_mut(callee_entry).terminator = Some(Terminator::Return(Some(c)));
          m.add_function(callee);
          m.add_function(caller);
          assert!(Dce.run(&mut m));
 -        assert!(m.functions[1].blocks[0].insts.is_empty(), "unused PURE call should be removed");
 +        assert!(
 +            m.functions[1].blocks[0].insts.is_empty(),
 +            "unused PURE call should be removed"
 +        );
+     }
      #[test]
      fn float_chain_is_dead() {
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let a = push(&mut f, InstKind::ConstFloat(1.5, FloatWidth::F64), IrType::Float(FloatWidth::F64));
 -        let b = push(&mut f, InstKind::ConstFloat(2.5, FloatWidth::F64), IrType::Float(FloatWidth::F64));
 +        let a = push(
 +            &mut f,
 +            InstKind::ConstFloat(1.5, FloatWidth::F64),
 +            IrType::Float(FloatWidth::F64),
 +        );
 +        let b = push(
 +            &mut f,
 +            InstKind::ConstFloat(2.5, FloatWidth::F64),
 +            IrType::Float(FloatWidth::F64),
 +        );
          let _ = push(&mut f, InstKind::FAdd(a, b), IrType::Float(FloatWidth::F64));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(None));

src/opt/dead_arg.rsmodified

73 lines changed — click to load

  pub struct DeadArgElim;
  impl Pass for DeadArgElim {
 -    fn name(&self) -> &'static str { "dead-arg-elim" }
 +    fn name(&self) -> &'static str {
 +        "dead-arg-elim"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut live_masks: Vec<Vec<bool>> = module
      match term {
          Some(Terminator::Return(Some(v))) => *v == param_id,
          Some(Terminator::Branch(_, args)) => args.contains(&param_id),
 -        Some(Terminator::CondBranch { cond, true_args, false_args, .. }) => {
 -            *cond == param_id || true_args.contains(&param_id) || false_args.contains(&param_id)
 -        }
 +        Some(Terminator::CondBranch {
 +            cond,
 +            true_args,
 +            false_args,
 +            ..
 +        }) => *cond == param_id || true_args.contains(&param_id) || false_args.contains(&param_id),
          Some(Terminator::Switch { selector, .. }) => *selector == param_id,
          _ => false,
+     }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::lexer::{Position, Span};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty: ty.clone(), span: span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty: ty.clone(),
 +            span: span(),
 +        });
          f.register_type(id, ty);
          id
+     }
          module.add_function(callee);
          let mut caller = Function::new("main".into(), vec![], IrType::Int(IntWidth::I32));
 -        let a = push(&mut caller, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let b = push(&mut caller, InstKind::ConstInt(9, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let a = push(
 +            &mut caller,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b = push(
 +            &mut caller,
 +            InstKind::ConstInt(9, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let call = push(
              &mut caller,
              InstKind::Call(FuncRef::Internal(0), vec![a, b]),

src/opt/dead_func.rsmodified

77 lines changed — click to load

  //! (runtime, external linkage) are also kept since the call might come
  //! from outside.
 -use std::collections::HashSet;
 -use crate::ir::inst::*;
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use std::collections::HashSet;
  pub struct DeadFuncElim;
  impl Pass for DeadFuncElim {
 -    fn name(&self) -> &'static str { "dead-func-elim" }
 +    fn name(&self) -> &'static str {
 +        "dead-func-elim"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let n = module.functions.len();
 -        if n <= 1 { return false; }
 +        if n <= 1 {
 +            return false;
 +        }
          // Collect all function indices that are referenced by Internal calls.
          let mut referenced: HashSet<u32> = HashSet::new();
              .filter(|i| !referenced.contains(&(*i as u32)))
              .collect();
 -        if dead.is_empty() { return false; }
 +        if dead.is_empty() {
 +            return false;
 +        }
          // Remove in reverse order so indices stay valid.
          for &idx in dead.iter().rev() {
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      use crate::opt::pass::Pass;
 -    use crate::lexer::{Span, Position};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      #[test]
          let cid = caller.next_value_id();
          caller.register_type(cid, IrType::Void);
          caller.block_mut(caller.entry).insts.push(Inst {
 -            id: cid, ty: IrType::Void, span: span(),
 +            id: cid,
 +            ty: IrType::Void,
 +            span: span(),
              kind: InstKind::Call(FuncRef::Internal(1), vec![]),
          });
          caller.block_mut(caller.entry).terminator = Some(Terminator::Return(None));
          let pass = DeadFuncElim;
          let changed = pass.run(&mut m);
 -        assert!(changed, "dead helper should be removed while keeping program body");
 +        assert!(
 +            changed,
 +            "dead helper should be removed while keeping program body"
 +        );
          assert_eq!(m.functions.len(), 1);
          assert_eq!(m.functions[0].name, "__prog_entry");
+     }

src/opt/dep_analysis.rsmodified

318 lines changed — click to load

  //! - Column-major strides are compile-time constants for fixed-shape arrays.
  //! - INTENT(IN) arguments cannot alias INTENT(OUT) arguments.
 -use std::collections::HashSet;
  use crate::ir::inst::*;
 +use std::collections::HashSet;
  // ---------------------------------------------------------------------------
  // Data structures
  #[derive(Debug, Clone)]
  pub struct AffineExpr {
      pub constant: i64,
 -    pub terms: Vec<(i64, ValueId)>,  // (coefficient, iv)
 +    pub terms: Vec<(i64, ValueId)>, // (coefficient, iv)
+ }
  impl AffineExpr {
 -    fn zero() -> Self { Self { constant: 0, terms: Vec::new() } }
 +    fn zero() -> Self {
 +        Self {
 +            constant: 0,
 +            terms: Vec::new(),
 +        }
 +    }
 -    fn from_const(c: i64) -> Self { Self { constant: c, terms: Vec::new() } }
 +    fn from_const(c: i64) -> Self {
 +        Self {
 +            constant: c,
 +            terms: Vec::new(),
 +        }
 +    }
      fn from_iv(iv: ValueId) -> Self {
 -        Self { constant: 0, terms: vec![(1, iv)] }
 +        Self {
 +            constant: 0,
 +            terms: vec![(1, iv)],
 +        }
+     }
      fn add(&self, other: &Self) -> Self {
  /// Extract an affine expression from a GEP index by walking backwards
  /// through arithmetic instructions. `ivs` is the set of known induction
  /// variables for the enclosing loop nest.
 -pub fn extract_affine(
 -    func: &Function,
 -    val: ValueId,
 -    ivs: &HashSet<ValueId>,
 -) -> Option<AffineExpr> {
 +pub fn extract_affine(func: &Function, val: ValueId, ivs: &HashSet<ValueId>) -> Option<AffineExpr> {
      // Is this an IV?
      if ivs.contains(&val) {
          return Some(AffineExpr::from_iv(val));
  fn resolve_const(func: &Function, vid: ValueId) -> Option<i64> {
      let inst = find_inst(func, vid)?;
 -    if let InstKind::ConstInt(c, _) = &inst.kind { i64::try_from(*c).ok() } else { None }
 +    if let InstKind::ConstInt(c, _) = &inst.kind {
 +        i64::try_from(*c).ok()
 +    } else {
 +        None
 +    }
+ }
  fn find_inst(func: &Function, vid: ValueId) -> Option<&Inst> {
      for block in &func.blocks {
          for inst in &block.insts {
 -            if inst.id == vid { return Some(inst); }
 +            if inst.id == vid {
 +                return Some(inst);
 +            }
+         }
+     }
      None
      // We work with the flat offset (single index for 1D GEP).
      let idx = indices.first()?;
      let subscript = extract_affine(func, *idx, ivs)?;
 -    Some(MemRef { inst_id, base, subscript, is_write })
 +    Some(MemRef {
 +        inst_id,
 +        base,
 +        subscript,
 +        is_write,
 +    })
+ }
  // ---------------------------------------------------------------------------
      // If the constant is 0, they access the same element (same iteration = ok
      // unless both are writes). If non-zero, they access different elements.
      if diff.terms.is_empty() {
 -        return DepResult { dependent: diff.constant == 0 };
 +        return DepResult {
 +            dependent: diff.constant == 0,
 +        };
+     }
      // GCD of all IV coefficients in the difference.
 -    let g = diff.terms.iter()
 +    let g = diff
 +        .terms
 +        .iter()
          .map(|(c, _)| c.unsigned_abs())
          .fold(0u64, gcd);
      if g == 0 {
          // All coefficients are zero — same as fixed-distance case.
 -        return DepResult { dependent: diff.constant == 0 };
 +        return DepResult {
 +            dependent: diff.constant == 0,
 +        };
+     }
      // GCD test: if gcd does not divide the constant difference,
+ }
  fn gcd(a: u64, b: u64) -> u64 {
 -    if b == 0 { a } else { gcd(b, a % b) }
 +    if b == 0 {
 +        a
 +    } else {
 +        gcd(b, a % b)
 +    }
+ }
  // ---------------------------------------------------------------------------
      let refs_b_raw = collect_mem_refs(func, body_b, &ivs_b);
      // Remap iv_b → iv_a in B's subscripts so the comparison works.
 -    let refs_b: Vec<MemRef> = refs_b_raw.into_iter().map(|mut r| {
 -        for term in &mut r.subscript.terms {
 -            if term.1 == iv_b { term.1 = iv_a; }
 -        }
 -        r
 -    }).collect();
 +    let refs_b: Vec<MemRef> = refs_b_raw
 +        .into_iter()
 +        .map(|mut r| {
 +            for term in &mut r.subscript.terms {
 +                if term.1 == iv_b {
 +                    term.1 = iv_a;
 +                }
 +            }
 +            r
 +        })
 +        .collect();
      for ra in &refs_a {
          for rb in &refs_b {
 -            if !ra.is_write && !rb.is_write { continue; }
 -            if ra.base != rb.base { continue; }
 +            if !ra.is_write && !rb.is_write {
 +                continue;
 +            }
 +            if ra.base != rb.base {
 +                continue;
 +            }
              let diff = rb.subscript.sub(&ra.subscript);
      // For each pair of refs where at least one is a write:
      for i in 0..refs.len() {
 -        for j in (i+1)..refs.len() {
 -            if !refs[i].is_write && !refs[j].is_write { continue; }
 -            if refs[i].base != refs[j].base { continue; }
 +        for j in (i + 1)..refs.len() {
 +            if !refs[i].is_write && !refs[j].is_write {
 +                continue;
 +            }
 +            if refs[i].base != refs[j].base {
 +                continue;
 +            }
              // Both refs share a base and at least one is a write.
              // Check if the subscript difference has non-zero
      #[test]
      fn affine_add_sub() {
          let iv = ValueId(100);
 -        let a = AffineExpr { constant: 3, terms: vec![(2, iv)] };
 -        let b = AffineExpr { constant: 1, terms: vec![(1, iv)] };
 +        let a = AffineExpr {
 +            constant: 3,
 +            terms: vec![(2, iv)],
 +        };
 +        let b = AffineExpr {
 +            constant: 1,
 +            terms: vec![(1, iv)],
 +        };
          let sum = a.add(&b);
          assert_eq!(sum.constant, 4);
          assert_eq!(sum.terms.len(), 1);
      #[test]
      fn affine_scale() {
          let iv = ValueId(100);
 -        let a = AffineExpr { constant: 2, terms: vec![(3, iv)] };
 +        let a = AffineExpr {
 +            constant: 2,
 +            terms: vec![(3, iv)],
 +        };
          let scaled = a.scale(4);
          assert_eq!(scaled.constant, 8);
          assert_eq!(scaled.terms[0], (12, iv));
          // constant = 1 ≠ 0 → independent.
          let iv = ValueId(100);
          let ref_a = MemRef {
 -            inst_id: ValueId(0), base: ValueId(50),
 -            subscript: AffineExpr { constant: 1, terms: vec![(2, iv)] },
 +            inst_id: ValueId(0),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 1,
 +                terms: vec![(2, iv)],
 +            },
              is_write: true,
          };
          let ref_b = MemRef {
 -            inst_id: ValueId(1), base: ValueId(50),
 -            subscript: AffineExpr { constant: 2, terms: vec![(2, iv)] },
 +            inst_id: ValueId(1),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 2,
 +                terms: vec![(2, iv)],
 +            },
              is_write: false,
          };
          let dep = test_dependence(&ref_a, &ref_b);
          // a(i) vs a(i): same subscript → always dependent.
          let iv = ValueId(100);
          let ref_a = MemRef {
 -            inst_id: ValueId(0), base: ValueId(50),
 -            subscript: AffineExpr { constant: 0, terms: vec![(1, iv)] },
 +            inst_id: ValueId(0),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 0,
 +                terms: vec![(1, iv)],
 +            },
              is_write: true,
          };
          let ref_b = MemRef {
 -            inst_id: ValueId(1), base: ValueId(50),
 -            subscript: AffineExpr { constant: 0, terms: vec![(1, iv)] },
 +            inst_id: ValueId(1),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 0,
 +                terms: vec![(1, iv)],
 +            },
              is_write: false,
          };
          let dep = test_dependence(&ref_a, &ref_b);
          // (they cancel: 3-3=0). So diff = constant 1, no terms → independent.
          let iv = ValueId(100);
          let ref_a = MemRef {
 -            inst_id: ValueId(0), base: ValueId(50),
 -            subscript: AffineExpr { constant: 0, terms: vec![(3, iv)] },
 +            inst_id: ValueId(0),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 0,
 +                terms: vec![(3, iv)],
 +            },
              is_write: true,
          };
          let ref_b = MemRef {
 -            inst_id: ValueId(1), base: ValueId(50),
 -            subscript: AffineExpr { constant: 1, terms: vec![(3, iv)] },
 +            inst_id: ValueId(1),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 1,
 +                terms: vec![(3, iv)],
 +            },
              is_write: false,
          };
          let dep = test_dependence(&ref_a, &ref_b);
 -        assert!(!dep.dependent, "a(3i) and a(3i+1) should be independent by GCD test");
 +        assert!(
 +            !dep.dependent,
 +            "a(3i) and a(3i+1) should be independent by GCD test"
 +        );
+     }
      #[test]
      fn distinct_bases_independent() {
          let iv = ValueId(100);
          let ref_a = MemRef {
 -            inst_id: ValueId(0), base: ValueId(50),
 -            subscript: AffineExpr { constant: 0, terms: vec![(1, iv)] },
 +            inst_id: ValueId(0),
 +            base: ValueId(50),
 +            subscript: AffineExpr {
 +                constant: 0,
 +                terms: vec![(1, iv)],
 +            },
              is_write: true,
          };
          let ref_b = MemRef {
 -            inst_id: ValueId(1), base: ValueId(60), // different base
 -            subscript: AffineExpr { constant: 0, terms: vec![(1, iv)] },
 +            inst_id: ValueId(1),
 +            base: ValueId(60), // different base
 +            subscript: AffineExpr {
 +                constant: 0,
 +                terms: vec![(1, iv)],
 +            },
              is_write: false,
          };
          let dep = test_dependence(&ref_a, &ref_b);
 -        assert!(!dep.dependent, "distinct bases should be independent (Fortran no-alias)");
 +        assert!(
 +            !dep.dependent,
 +            "distinct bases should be independent (Fortran no-alias)"
 +        );
+     }
+ }

src/opt/dse.rsmodified

209 lines changed — click to load

  //! initialization sequences where a variable is zeroed and then
  //! immediately written with the real value.
 -use super::pass::Pass;
  use super::alias::{self, AliasResult};
 +use super::pass::Pass;
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  use std::collections::HashSet;
+                         }
+                     }
+                 }
 -                next_pending.push(PendingStore { ptr: *ptr, inst_idx: i });
 +                next_pending.push(PendingStore {
 +                    ptr: *ptr,
 +                    inst_idx: i,
 +                });
                  pending = next_pending;
+             }
                  let pointer_args: Vec<ValueId> = args
                      .iter()
                      .copied()
 -                    .filter(|arg| {
 -                        matches!(
 -                            func.value_type(*arg),
 -                            Some(IrType::Ptr(_))
 -                        )
 -                    })
 +                    .filter(|arg| matches!(func.value_type(*arg), Some(IrType::Ptr(_))))
                      .collect();
                  if !pointer_args.is_empty() {
                      pending.retain(|entry| {
 -                        pointer_args.iter().all(|arg| {
 -                            !alias::may_reach_through_call_arg(func, entry.ptr, *arg)
 -                        })
 +                        pointer_args
 +                            .iter()
 +                            .all(|arg| !alias::may_reach_through_call_arg(func, entry.ptr, *arg))
                      });
+                 }
+             }
  pub struct Dse;
  impl Pass for Dse {
 -    fn name(&self) -> &'static str { "dse" }
 +    fn name(&self) -> &'static str {
 +        "dse"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if dse_function(func) { changed = true; }
 +            if dse_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
 -    fn ptr_ty() -> IrType { IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))) }
 -    fn alloca_ty() -> IrType { IrType::Int(IntWidth::I32) }
 -    fn i32_ty() -> IrType { IrType::Int(IntWidth::I32) }
 +    fn ptr_ty() -> IrType {
 +        IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))
 +    }
 +    fn alloca_ty() -> IrType {
 +        IrType::Int(IntWidth::I32)
 +    }
 +    fn i32_ty() -> IrType {
 +        IrType::Int(IntWidth::I32)
 +    }
      /// %ptr = alloca i32
      /// store 1, %ptr
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let ptr = push(&mut f, InstKind::Alloca(alloca_ty()), ptr_ty());
 -        let v1  = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), i32_ty());
 -        let v2  = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), i32_ty());
 -        push(&mut f, InstKind::Store(v1, ptr), IrType::Void);   // dead
 -        push(&mut f, InstKind::Store(v2, ptr), IrType::Void);   // live
 +        let v1 = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), i32_ty());
 +        let v2 = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), i32_ty());
 +        push(&mut f, InstKind::Store(v1, ptr), IrType::Void); // dead
 +        push(&mut f, InstKind::Store(v2, ptr), IrType::Void); // live
          let _loaded = push(&mut f, InstKind::Load(ptr), i32_ty());
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          let insts = &m.functions[0].blocks[0].insts;
          assert_eq!(insts.len(), 5, "first store should be eliminated");
          // The surviving Store should use v2.
 -        let stores: Vec<_> = insts.iter().filter(|i| matches!(i.kind, InstKind::Store(..))).collect();
 +        let stores: Vec<_> = insts
 +            .iter()
 +            .filter(|i| matches!(i.kind, InstKind::Store(..)))
 +            .collect();
          assert_eq!(stores.len(), 1);
          assert!(matches!(stores[0].kind, InstKind::Store(v, _) if v == v2));
+     }
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], i32_ty());
          let ptr = push(&mut f, InstKind::Alloca(alloca_ty()), ptr_ty());
 -        let v1  = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), i32_ty());
 +        let v1 = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), i32_ty());
          push(&mut f, InstKind::Store(v1, ptr), IrType::Void);
          let loaded = push(&mut f, InstKind::Load(ptr), i32_ty());
          let entry = f.entry;
          let ptr = push(&mut f, InstKind::Alloca(arr_ty), arr_ptr_ty);
          let off0 = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), i32_ty());
          let off1 = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), i32_ty());
 -        let gep0 = push(&mut f, InstKind::GetElementPtr(ptr, vec![off0]),
 -            IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))));
 -        let gep1 = push(&mut f, InstKind::GetElementPtr(ptr, vec![off1]),
 -            IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))));
 +        let gep0 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(ptr, vec![off0]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))),
 +        );
 +        let gep1 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(ptr, vec![off1]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))),
 +        );
          let v1 = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), i32_ty());
          let v2 = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), i32_ty());
 -        push(&mut f, InstKind::Store(v1, gep0), IrType::Void);  // dead
 -        push(&mut f, InstKind::Store(v2, gep1), IrType::Void);  // live
 +        push(&mut f, InstKind::Store(v1, gep0), IrType::Void); // dead
 +        push(&mut f, InstKind::Store(v2, gep1), IrType::Void); // live
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
          assert!(Dse.run(&mut m));
 -        let stores: Vec<_> = m.functions[0].blocks[0].insts.iter()
 +        let stores: Vec<_> = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
              .filter(|i| matches!(i.kind, InstKind::Store(..)))
              .collect();
 -        assert_eq!(stores.len(), 1, "must-alias GEP overwrite should kill the first store");
 +        assert_eq!(
 +            stores.len(),
 +            1,
 +            "must-alias GEP overwrite should kill the first store"
 +        );
          assert!(matches!(stores[0].kind, InstKind::Store(v, _) if v == v2));
+     }
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let ptr = push(&mut f, InstKind::Alloca(alloca_ty()), ptr_ty());
 -        let v1  = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), i32_ty());
 -        let v2  = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), i32_ty());
 -        let v3  = push(&mut f, InstKind::ConstInt(3, IntWidth::I32), i32_ty());
 -        push(&mut f, InstKind::Store(v1, ptr), IrType::Void);  // dead
 -        push(&mut f, InstKind::Store(v2, ptr), IrType::Void);  // dead
 -        push(&mut f, InstKind::Store(v3, ptr), IrType::Void);  // live (block exit)
 +        let v1 = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), i32_ty());
 +        let v2 = push(&mut f, InstKind::ConstInt(2, IntWidth::I32), i32_ty());
 +        let v3 = push(&mut f, InstKind::ConstInt(3, IntWidth::I32), i32_ty());
 +        push(&mut f, InstKind::Store(v1, ptr), IrType::Void); // dead
 +        push(&mut f, InstKind::Store(v2, ptr), IrType::Void); // dead
 +        push(&mut f, InstKind::Store(v3, ptr), IrType::Void); // live (block exit)
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
          // (stores of v1 and v2 are dead; store of v3 remains because it
          //  might be read in a successor — we don't do cross-block analysis)
          assert!(Dse.run(&mut m));
 -        let stores: Vec<_> = m.functions[0].blocks[0].insts.iter()
 +        let stores: Vec<_> = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
              .filter(|i| matches!(i.kind, InstKind::Store(..)))
              .collect();
          // Two dead stores removed, one survives.

src/opt/fast_math.rsmodified

96 lines changed — click to load

  pub struct FastMathReassoc;
  impl Pass for FastMathReassoc {
 -    fn name(&self) -> &'static str { "fast-math-reassoc" }
 +    fn name(&self) -> &'static str {
 +        "fast-math-reassoc"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
  impl SignedFloatConst {
      fn positive(constant: FloatConst) -> Self {
 -        Self { constant, negative: false }
 +        Self {
 +            constant,
 +            negative: false,
 +        }
+     }
      fn negated(self) -> Self {
          });
+     }
 -        let Some(inst) = defs.get(&value) else {
 -            return Some(AddChain {
 -                base: Some(value),
 -                terms: Vec::new(),
 -                additive_nodes: 0,
 -            });
 -        };
 +    let Some(inst) = defs.get(&value) else {
 +        return Some(AddChain {
 +            base: Some(value),
 +            terms: Vec::new(),
 +            additive_nodes: 0,
 +        });
 +    };
      match inst.kind {
          InstKind::FAdd(lhs, rhs) if inst.ty == IrType::Float(width) => {
              let lhs_chain = collect_chain(defs, lhs, width)?;
  ) -> Option<FloatConst> {
      let inst = defs.get(&value)?;
      match inst.kind {
 -        InstKind::ConstFloat(value, inst_width) if inst_width == width => FloatConst::from_value(value, width),
 +        InstKind::ConstFloat(value, inst_width) if inst_width == width => {
 +            FloatConst::from_value(value, width)
 +        }
          _ => None,
+     }
+ }
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty: ty.clone(), span: span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty: ty.clone(),
 +            span: span(),
 +        });
          f.register_type(id, ty);
          id
+     }
          let func = &module.functions[0];
          let insts = &func.blocks[0].insts;
          assert!(
 -            insts.iter().any(|inst| matches!(inst.kind, InstKind::ConstFloat(v, FloatWidth::F64) if v == 5.0)),
 +            insts.iter().any(
 +                |inst| matches!(inst.kind, InstKind::ConstFloat(v, FloatWidth::F64) if v == 5.0)
 +            ),
              "reassociated chain should materialize a combined constant:\n{:?}",
              insts
          );
              matches!(func.blocks[0].terminator, Some(Terminator::Return(Some(v))) if v == add2),
              "outer value should stay the return root"
          );
 -        let outer = insts.iter().find(|inst| inst.id == add2).expect("outer add should remain");
 +        let outer = insts
 +            .iter()
 +            .find(|inst| inst.id == add2)
 +            .expect("outer add should remain");
          assert!(
              matches!(outer.kind, InstKind::FAdd(ValueId(0), _)),
              "outer add should become x + const, got {:?}",

src/opt/fission.rsmodified

191 lines changed — click to load

  //!
  //! This avoids SSA domination bugs from selective instruction removal.
 -use std::collections::HashSet;
 -use crate::ir::inst::*;
 -use crate::ir::walk::{find_natural_loops, predecessors};
 -use super::loop_utils::{find_preheader, clone_loop};
  use super::dep_analysis::{collect_mem_refs, test_dependence};
 +use super::loop_utils::{clone_loop, find_preheader};
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use crate::ir::walk::{find_natural_loops, predecessors};
 +use std::collections::HashSet;
  const FISSION_MIN_BODY: usize = 4;
  pub struct LoopFission;
  impl Pass for LoopFission {
 -    fn name(&self) -> &'static str { "loop-fission" }
 +    fn name(&self) -> &'static str {
 +        "loop-fission"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if fission_in_function(func) { changed = true; }
 +            if fission_in_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
      let preds = predecessors(func);
      for lp in &loops {
 -        let Some(_ph_id) = find_preheader(func, lp, &preds) else { continue };
 -        if lp.latches.len() != 1 { continue; }
 +        let Some(_ph_id) = find_preheader(func, lp, &preds) else {
 +            continue;
 +        };
 +        if lp.latches.len() != 1 {
 +            continue;
 +        }
          let latch_id = lp.latches[0];
          let hdr = func.block(lp.header);
 -        if hdr.params.len() != 1 { continue; }
 +        if hdr.params.len() != 1 {
 +            continue;
 +        }
          let iv = hdr.params[0].id;
          // Find the single computation body block.
          let Some(body_bid) = body_block else { continue };
          let block = func.block(body_bid);
 -        if block.insts.len() < FISSION_MIN_BODY { continue; }
 +        if block.insts.len() < FISSION_MIN_BODY {
 +            continue;
 +        }
          // Need exactly 2 stores to different arrays.
 -        let stores: Vec<(usize, ValueId)> = block.insts.iter().enumerate()
 +        let stores: Vec<(usize, ValueId)> = block
 +            .insts
 +            .iter()
 +            .enumerate()
              .filter(|(_, i)| matches!(i.kind, InstKind::Store(..)))
              .map(|(idx, i)| (idx, i.id))
              .collect();
 -        if stores.len() != 2 { continue; }
 +        if stores.len() != 2 {
 +            continue;
 +        }
          // Check independence via dep analysis.
          let mut ivs = HashSet::new();
          ivs.insert(iv);
          let mem_refs = collect_mem_refs(func, &lp.body, &ivs);
          let writes: Vec<_> = mem_refs.iter().filter(|r| r.is_write).collect();
 -        if writes.len() != 2 { continue; }
 -        if writes[0].base == writes[1].base { continue; }
 +        if writes.len() != 2 {
 +            continue;
 +        }
 +        if writes[0].base == writes[1].base {
 +            continue;
 +        }
          let mut has_cross_dep = false;
          for i in 0..mem_refs.len() {
 -            for j in (i+1)..mem_refs.len() {
 -                if !mem_refs[i].is_write && !mem_refs[j].is_write { continue; }
 -                if mem_refs[i].base == mem_refs[j].base { continue; }
 +            for j in (i + 1)..mem_refs.len() {
 +                if !mem_refs[i].is_write && !mem_refs[j].is_write {
 +                    continue;
 +                }
 +                if mem_refs[i].base == mem_refs[j].base {
 +                    continue;
 +                }
                  let dep = test_dependence(&mem_refs[i], &mem_refs[j]);
 -                if dep.dependent { has_cross_dep = true; break; }
 +                if dep.dependent {
 +                    has_cross_dep = true;
 +                    break;
 +                }
 +            }
 +            if has_cross_dep {
 +                break;
+             }
 -            if has_cross_dep { break; }
+         }
 -        if has_cross_dep { continue; }
 +        if has_cross_dep {
 +            continue;
 +        }
          // Find the exit block.
          let exit_id = find_loop_exit(func, lp);
          };
          let bridge = func.create_block("fission_bridge");
 -        func.block_mut(bridge).terminator =
 -            Some(Terminator::Branch(clone_header, vec![init_val]));
 +        func.block_mut(bridge).terminator = Some(Terminator::Branch(clone_header, vec![init_val]));
          // Redirect original cmp's exit → bridge.
          for &bid in &lp.body {
  /// making it a dead store that DSE/DCE can clean up.
  fn neutralize_store(func: &mut Function, block_id: BlockId, store_idx: usize) {
      let block = func.block_mut(block_id);
 -    if store_idx >= block.insts.len() { return; }
 +    if store_idx >= block.insts.len() {
 +        return;
 +    }
      if let InstKind::Store(_, _) = block.insts[store_idx].kind {
          // Replace with a store of undef — the store is now dead.
          // We keep the store instruction (not remove it) to preserve
  ) -> Option<BlockId> {
      let mut comp = None;
      for &bid in &lp.body {
 -        if bid == lp.header || bid == latch_id { continue; }
 +        if bid == lp.header || bid == latch_id {
 +            continue;
 +        }
          let block = func.block(bid);
 -        if block.insts.iter().any(|i| matches!(i.kind, InstKind::Store(..))) {
 -            if comp.is_some() { return None; }
 +        if block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::Store(..)))
 +        {
 +            if comp.is_some() {
 +                return None;
 +            }
              comp = Some(bid);
+         }
+     }
      comp
+ }
 -fn backward_slice(func: &Function, root: ValueId, loop_defs: &HashSet<ValueId>) -> HashSet<ValueId> {
 +fn backward_slice(
 +    func: &Function,
 +    root: ValueId,
 +    loop_defs: &HashSet<ValueId>,
 +) -> HashSet<ValueId> {
      let mut slice = HashSet::new();
      let mut worklist = vec![root];
      while let Some(vid) = worklist.pop() {
 -        if !slice.insert(vid) { continue; }
 +        if !slice.insert(vid) {
 +            continue;
 +        }
          for block in &func.blocks {
              for inst in &block.insts {
                  if inst.id == vid {
      for &bid in &lp.body {
          let block = func.block(bid);
          if let Some(Terminator::CondBranch { false_dest, .. }) = &block.terminator {
 -            if !lp.body.contains(false_dest) { return Some(*false_dest); }
 +            if !lp.body.contains(false_dest) {
 +                return Some(*false_dest);
 +            }
+         }
+     }
      None

src/opt/fusion.rsmodified

301 lines changed — click to load

  //!
  //! This avoids splicing instructions between blocks entirely.
 -use std::collections::HashSet;
 -use crate::ir::inst::*;
 -use crate::ir::walk::{find_natural_loops, predecessors};
 +use super::dep_analysis;
  use super::loop_utils::remap_inst_kind;
  use super::loop_utils::{find_preheader, resolve_const_int};
 -use super::dep_analysis;
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use crate::ir::walk::{find_natural_loops, predecessors};
 +use std::collections::HashSet;
  pub struct LoopFusion;
  impl Pass for LoopFusion {
 -    fn name(&self) -> &'static str { "loop-fusion" }
 +    fn name(&self) -> &'static str {
 +        "loop-fusion"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if fusion_in_function(func) { changed = true; }
 +            if fusion_in_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
  fn fusion_in_function(func: &mut Function) -> bool {
      let loops = find_natural_loops(func);
 -    if loops.len() < 2 { return false; }
 +    if loops.len() < 2 {
 +        return false;
 +    }
      let preds = predecessors(func);
      for i in 0..loops.len() {
 -        for j in (i+1)..loops.len() {
 +        for j in (i + 1)..loops.len() {
              let lp_a = &loops[i];
              let lp_b = &loops[j];
              // Both need preheaders and single latches.
 -            let Some(_ph_a) = find_preheader(func, lp_a, &preds) else { continue };
 -            let Some(ph_b) = find_preheader(func, lp_b, &preds) else { continue };
 -            if lp_a.latches.len() != 1 || lp_b.latches.len() != 1 { continue; }
 +            let Some(_ph_a) = find_preheader(func, lp_a, &preds) else {
 +                continue;
 +            };
 +            let Some(ph_b) = find_preheader(func, lp_b, &preds) else {
 +                continue;
 +            };
 +            if lp_a.latches.len() != 1 || lp_b.latches.len() != 1 {
 +                continue;
 +            }
              let latch_a = lp_a.latches[0];
              let latch_b = lp_b.latches[0];
              // Both headers must have exactly 1 block param (IV).
              let hdr_a = func.block(lp_a.header);
              let hdr_b = func.block(lp_b.header);
 -            if hdr_a.params.len() != 1 || hdr_b.params.len() != 1 { continue; }
 +            if hdr_a.params.len() != 1 || hdr_b.params.len() != 1 {
 +                continue;
 +            }
              let iv_a = hdr_a.params[0].id;
              let iv_b = hdr_b.params[0].id;
              // Neither loop should be nested inside the other.
 -            if lp_a.body.iter().any(|b| lp_b.body.contains(b)) { continue; }
 -            if lp_b.body.iter().any(|b| lp_a.body.contains(b)) { continue; }
 +            if lp_a.body.iter().any(|b| lp_b.body.contains(b)) {
 +                continue;
 +            }
 +            if lp_b.body.iter().any(|b| lp_a.body.contains(b)) {
 +                continue;
 +            }
              // Neither loop should contain inner loops. Fusing loops
              // with nested inner loops requires more complex handling
              // (inner loop blocks need reparenting). V1: simple only.
 -            let has_inner_a = loops.iter().any(|other|
 -                other.header != lp_a.header && lp_a.body.is_superset(&other.body));
 -            let has_inner_b = loops.iter().any(|other|
 -                other.header != lp_b.header && lp_b.body.is_superset(&other.body));
 -            if has_inner_a || has_inner_b { continue; }
 +            let has_inner_a = loops
 +                .iter()
 +                .any(|other| other.header != lp_a.header && lp_a.body.is_superset(&other.body));
 +            let has_inner_b = loops
 +                .iter()
 +                .any(|other| other.header != lp_b.header && lp_b.body.is_superset(&other.body));
 +            if has_inner_a || has_inner_b {
 +                continue;
 +            }
              // Skip loops produced by fission in the same pipeline
              // iteration — they have clone/bridge blocks that fusion
              // can't handle safely.
 -            let has_clone_a = lp_a.body.iter().any(|&b|
 -                func.block(b).name.contains("clone") || func.block(b).name.contains("fission"));
 -            let has_clone_b = lp_b.body.iter().any(|&b|
 -                func.block(b).name.contains("clone") || func.block(b).name.contains("fission"));
 -            if has_clone_a || has_clone_b { continue; }
 +            let has_clone_a = lp_a.body.iter().any(|&b| {
 +                func.block(b).name.contains("clone") || func.block(b).name.contains("fission")
 +            });
 +            let has_clone_b = lp_b.body.iter().any(|&b| {
 +                func.block(b).name.contains("clone") || func.block(b).name.contains("fission")
 +            });
 +            if has_clone_a || has_clone_b {
 +                continue;
 +            }
              // Loop A's exit must be (or flow to) loop B's preheader.
              let exit_a = find_loop_exit(func, lp_a);
              let Some(exit_a) = exit_a else { continue };
 -            if exit_a != ph_b && !flows_to(func, exit_a, ph_b) { continue; }
 +            if exit_a != ph_b && !flows_to(func, exit_a, ph_b) {
 +                continue;
 +            }
              // Matching iteration spaces.
 -            let Some(init_a) = get_init_const(func, lp_a, &preds) else { continue };
 -            let Some(init_b) = get_init_const(func, lp_b, &preds) else { continue };
 -            if init_a != init_b { continue; }
 +            let Some(init_a) = get_init_const(func, lp_a, &preds) else {
 +                continue;
 +            };
 +            let Some(init_b) = get_init_const(func, lp_b, &preds) else {
 +                continue;
 +            };
 +            if init_a != init_b {
 +                continue;
 +            }
 -            let Some(bound_a) = find_bound_const(func, lp_a, iv_a) else { continue };
 -            let Some(bound_b) = find_bound_const(func, lp_b, iv_b) else { continue };
 -            if bound_a != bound_b { continue; }
 +            let Some(bound_a) = find_bound_const(func, lp_a, iv_a) else {
 +                continue;
 +            };
 +            let Some(bound_b) = find_bound_const(func, lp_b, iv_b) else {
 +                continue;
 +            };
 +            if bound_a != bound_b {
 +                continue;
 +            }
              // Dep analysis: fusion legal?
              if !dep_analysis::fusion_legal(func, &lp_a.body, &lp_b.body, iv_a, iv_b) {
              // ---- Perform fusion via latch redirect ----
              do_fusion_latch_redirect(
 -                func, lp_a, lp_b,
 -                latch_a, latch_b,
 -                iv_a, iv_b,
 -                body_b_id, cmp_b_id,
 -                exit_a, exit_b,
 +                func, lp_a, lp_b, latch_a, latch_b, iv_a, iv_b, body_b_id, cmp_b_id, exit_a, exit_b,
              );
              return true;
+         }
      sub_map.insert(iv_b, iv_a);
      for &bid in &lp_b.body {
          let old_insts: Vec<Inst> = func.block(bid).insts.clone();
 -        let new_insts: Vec<Inst> = old_insts.into_iter().map(|inst| {
 -            let new_kind = remap_inst_kind(&inst.kind, &sub_map);
 -            Inst { kind: new_kind, ..inst }
 -        }).collect();
 +        let new_insts: Vec<Inst> = old_insts
 +            .into_iter()
 +            .map(|inst| {
 +                let new_kind = remap_inst_kind(&inst.kind, &sub_map);
 +                Inst {
 +                    kind: new_kind,
 +                    ..inst
 +                }
 +            })
 +            .collect();
          func.block_mut(bid).insts = new_insts;
          // Also remap terminator operands.
          let old_term = func.block(bid).terminator.clone();
      // Find the block that branches to latch_a (A's body exit).
      let a_body_exit = find_branch_to(func, lp_a, latch_a);
 -    let Some(a_body_exit_id) = a_body_exit else { return };
 +    let Some(a_body_exit_id) = a_body_exit else {
 +        return;
 +    };
      // Redirect A's body exit → B's body.
      redirect_branch(func, a_body_exit_id, latch_a, body_b_id);
      // But B's latch's iv_next_b should be discarded — A's latch will
      // compute iv_next_a. So B's latch should just branch to A's latch
      // with no args.
 -    func.block_mut(latch_b).terminator =
 -        Some(Terminator::Branch(latch_a, vec![]));
 +    func.block_mut(latch_b).terminator = Some(Terminator::Branch(latch_a, vec![]));
      // Step 3: A's cmp exit (exit_a) should now go to B's exit (exit_b)
      // since B's header/cmp are bypassed. Copy B's exit block content
      func.block_mut(lp_b.header).terminator = Some(Terminator::Unreachable);
      // Mark B's cmp blocks too.
      for &bid in &lp_b.body {
 -        if bid == body_b_id || bid == latch_b { continue; }
 +        if bid == body_b_id || bid == latch_b {
 +            continue;
 +        }
          func.block_mut(bid).terminator = Some(Terminator::Unreachable);
+     }
      target: BlockId,
  ) -> Option<BlockId> {
      for &bid in &lp.body {
 -        if bid == target { continue; }
 +        if bid == target {
 +            continue;
 +        }
          let block = func.block(bid);
          match &block.terminator {
              Some(Terminator::Branch(dest, _)) if *dest == target => return Some(bid),
      for &bid in &lp.body {
          let block = func.block(bid);
          if let Some(Terminator::CondBranch { false_dest, .. }) = &block.terminator {
 -            if !lp.body.contains(false_dest) { return Some(*false_dest); }
 +            if !lp.body.contains(false_dest) {
 +                return Some(*false_dest);
 +            }
+         }
+     }
      None
      let block = func.block(from);
      match &block.terminator {
          Some(Terminator::Branch(dest, _)) => {
 -            if *dest == to { return true; }
 +            if *dest == to {
 +                return true;
 +            }
              let mid = func.block(*dest);
              if let Some(Terminator::Branch(dest2, _)) = &mid.terminator {
                  return *dest2 == to;
      resolve_const_int(func, init_val)
+ }
 -fn find_bound_const(func: &Function, lp: &crate::ir::walk::NaturalLoop, iv: ValueId) -> Option<i64> {
 +fn find_bound_const(
 +    func: &Function,
 +    lp: &crate::ir::walk::NaturalLoop,
 +    iv: ValueId,
 +) -> Option<i64> {
      for &bid in &lp.body {
          let block = func.block(bid);
          for inst in &block.insts {
              if let InstKind::ICmp(_, a, b) = &inst.kind {
 -                let bound_val = if *a == iv { *b } else if *b == iv { *a } else { continue };
 +                let bound_val = if *a == iv {
 +                    *b
 +                } else if *b == iv {
 +                    *a
 +                } else {
 +                    continue;
 +                };
                  return resolve_const_int(func, bound_val);
+             }
+         }
      latch_id: BlockId,
  ) -> Option<BlockId> {
      for &bid in &lp.body {
 -        if bid == lp.header || bid == latch_id { continue; }
 +        if bid == lp.header || bid == latch_id {
 +            continue;
 +        }
          let block = func.block(bid);
 -        if block.insts.iter().any(|i| matches!(i.kind, InstKind::Store(..))) {
 +        if block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::Store(..)))
 +        {
              return Some(bid);
+         }
+     }
  fn find_cmp_block(func: &Function, lp: &crate::ir::walk::NaturalLoop) -> Option<BlockId> {
      for &bid in &lp.body {
          let block = func.block(bid);
 -        if block.insts.iter().any(|i| matches!(i.kind, InstKind::ICmp(..))) {
 +        if block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::ICmp(..)))
 +        {
              return Some(bid);
+         }
+     }

src/opt/global_lsf.rsmodified

115 lines changed — click to load

  //!     %r = load %ptr        → %r = %val (forwarded)
  //! ```
 -use std::collections::{HashMap, HashSet, VecDeque};
 +use super::alias::{self, AliasResult};
 +use super::pass::Pass;
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  use crate::ir::walk::{compute_immediate_dominators, predecessors, terminator_targets};
 -use super::alias::{self, AliasResult};
 -use super::pass::Pass;
 +use std::collections::{HashMap, HashSet, VecDeque};
  pub struct GlobalLsf;
  impl Pass for GlobalLsf {
 -    fn name(&self) -> &'static str { "global-lsf" }
 +    fn name(&self) -> &'static str {
 +        "global-lsf"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if global_lsf_function(func) { changed = true; }
 +            if global_lsf_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
+         }
+     }
 -    if replacements.is_empty() { return false; }
 +    if replacements.is_empty() {
 +        return false;
 +    }
      // Apply replacements.
      for block in &mut func.blocks {
              inst.kind = super::loop_utils::remap_inst_kind(&inst.kind, &replacements);
+         }
          if let Some(ref mut term) = block.terminator {
 -            let new_term = super::loop_utils::remap_terminator(
 -                term,
 -                &HashMap::new(),
 -                &replacements,
 -            );
 +            let new_term =
 +                super::loop_utils::remap_terminator(term, &HashMap::new(), &replacements);
              *term = new_term;
+         }
+     }
      let mut current = load_block;
      while let Some(&idom) = idoms.get(&current) {
 -        if idom == current { break; } // entry
 +        if idom == current {
 +            break;
 +        } // entry
          current = idom;
          if !paths_to_load_are_clean(func, preds, current, load_block, load_ptr) {
                  .copied()
                  .filter(|arg| value_is_pointer(func, *arg))
                  .collect();
 -            if pointer_args.iter().any(|arg| {
 -                alias::may_reach_through_call_arg(func, load_ptr, *arg)
 -            }) {
 +            if pointer_args
 +                .iter()
 +                .any(|arg| alias::may_reach_through_call_arg(func, load_ptr, *arg))
 +            {
                  *last_store = None;
                  *clobbered = true;
+             }
      if matches!(func.value_type(value), Some(IrType::Ptr(_))) {
          return true;
+     }
 -    if func.params.iter().any(|param| param.id == value && matches!(param.ty, IrType::Ptr(_))) {
 +    if func
 +        .params
 +        .iter()
 +        .any(|param| param.id == value && matches!(param.ty, IrType::Ptr(_)))
 +    {
          return true;
+     }
 -    func.blocks.iter().flat_map(|block| block.insts.iter()).find(|inst| inst.id == value)
 +    func.blocks
 +        .iter()
 +        .flat_map(|block| block.insts.iter())
 +        .find(|inst| inst.id == value)
          .map(|inst| matches!(inst.ty, IrType::Ptr(_)))
          .unwrap_or(false)
+ }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::opt::pass::Pass;
      #[test]
          m.add_function(f);
          let pass = GlobalLsf;
 -        assert!(pass.run(&mut m), "straight-line dominated load should be forwarded");
 +        assert!(
 +            pass.run(&mut m),
 +            "straight-line dominated load should be forwarded"
 +        );
          let term = m.functions[0].block(load_block).terminator.clone().unwrap();
          assert!(
              matches!(term, Terminator::Return(Some(v)) if v == value),

src/opt/gvn.rsmodified

751 lines changed — click to load

  //!
  //! Uses the same canonical Key structure as local CSE (cse.rs).
 -use std::collections::HashMap;
 +use super::pass::Pass;
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  use crate::ir::walk::{compute_immediate_dominators, dominator_tree_children};
 -use super::pass::Pass;
 +use std::collections::HashMap;
  pub struct Gvn;
  impl Pass for Gvn {
 -    fn name(&self) -> &'static str { "gvn" }
 +    fn name(&self) -> &'static str {
 +        "gvn"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let pure_calls: Vec<PureCallPolicy> = module
              .collect();
          let mut changed = false;
          for func in &mut module.functions {
 -            if gvn_function(func, &pure_calls) { changed = true; }
 +            if gvn_function(func, &pure_calls) {
 +                changed = true;
 +            }
+         }
          changed
+     }
  impl PureCallPolicy {
      fn for_function(func: &Function) -> Self {
 -        let arg_policies = func.params.iter().map(|param| classify_pure_arg(func, param)).collect::<Vec<_>>();
 +        let arg_policies = func
 +            .params
 +            .iter()
 +            .map(|param| classify_pure_arg(func, param))
 +            .collect::<Vec<_>>();
          let reusable = func.is_pure
              && !matches!(func.return_type, IrType::Void)
              && !func.return_type.is_ptr()
 -            && arg_policies.iter().all(|policy| *policy != PureArgPolicy::Unsupported)
 +            && arg_policies
 +                .iter()
 +                .all(|policy| *policy != PureArgPolicy::Unsupported)
              && !reads_non_argument_memory(func);
          Self {
              reusable,
+                         }
                          let valid_arg = args.iter().enumerate().any(|(arg_idx, arg)| {
                              *arg == alloca_id
 -                                && policy
 -                                    .arg_policies
 -                                    .get(arg_idx)
 -                                    .copied()
 +                                && policy.arg_policies.get(arg_idx).copied()
                                      == Some(PureArgPolicy::ReadOnlyWrapperPtr)
                          });
                          if !valid_arg {
      wrapper_values: &HashMap<ValueId, ValueId>,
  ) -> Option<Key> {
      let mk = |tag: u32, ops: Vec<ValueId>, aux: i128| -> Option<Key> {
 -        Some(Key { tag, operands: ops, aux, name: None, ty: inst.ty.clone() })
 +        Some(Key {
 +            tag,
 +            operands: ops,
 +            aux,
 +            name: None,
 +            ty: inst.ty.clone(),
 +        })
      };
      let mk_named = |tag: u32, name: String| -> Option<Key> {
 -        Some(Key { tag, operands: vec![], aux: 0, name: Some(name), ty: inst.ty.clone() })
 +        Some(Key {
 +            tag,
 +            operands: vec![],
 +            aux: 0,
 +            name: Some(name),
 +            ty: inst.ty.clone(),
 +        })
      };
      let remap = |v: ValueId| resolve_value(replacements, v);
      fn canon(a: ValueId, b: ValueId) -> Vec<ValueId> {
 -        if a.0 <= b.0 { vec![a, b] } else { vec![b, a] }
 +        if a.0 <= b.0 {
 +            vec![a, b]
 +        } else {
 +            vec![b, a]
 +        }
+     }
      match &inst.kind {
          // Pure arithmetic — commutative ops get canonicalized operand order.
 -        InstKind::IAdd(a, b)  => mk(1, canon(remap(*a), remap(*b)), 0),
 -        InstKind::ISub(a, b)  => mk(2, vec![remap(*a), remap(*b)], 0),
 -        InstKind::IMul(a, b)  => mk(3, canon(remap(*a), remap(*b)), 0),
 -        InstKind::IDiv(a, b)  => mk(4, vec![remap(*a), remap(*b)], 0),
 -        InstKind::IMod(a, b)  => mk(5, vec![remap(*a), remap(*b)], 0),
 -        InstKind::INeg(a)     => mk(6, vec![remap(*a)], 0),
 -        InstKind::FAdd(a, b)  => mk(10, canon(remap(*a), remap(*b)), 0),
 -        InstKind::FSub(a, b)  => mk(11, vec![remap(*a), remap(*b)], 0),
 -        InstKind::FMul(a, b)  => mk(12, canon(remap(*a), remap(*b)), 0),
 -        InstKind::FDiv(a, b)  => mk(13, vec![remap(*a), remap(*b)], 0),
 -        InstKind::FNeg(a)     => mk(14, vec![remap(*a)], 0),
 -        InstKind::FAbs(a)     => mk(15, vec![remap(*a)], 0),
 -        InstKind::FSqrt(a)    => mk(16, vec![remap(*a)], 0),
 -        InstKind::FPow(a, b)  => mk(17, vec![remap(*a), remap(*b)], 0),
 +        InstKind::IAdd(a, b) => mk(1, canon(remap(*a), remap(*b)), 0),
 +        InstKind::ISub(a, b) => mk(2, vec![remap(*a), remap(*b)], 0),
 +        InstKind::IMul(a, b) => mk(3, canon(remap(*a), remap(*b)), 0),
 +        InstKind::IDiv(a, b) => mk(4, vec![remap(*a), remap(*b)], 0),
 +        InstKind::IMod(a, b) => mk(5, vec![remap(*a), remap(*b)], 0),
 +        InstKind::INeg(a) => mk(6, vec![remap(*a)], 0),
 +        InstKind::FAdd(a, b) => mk(10, canon(remap(*a), remap(*b)), 0),
 +        InstKind::FSub(a, b) => mk(11, vec![remap(*a), remap(*b)], 0),
 +        InstKind::FMul(a, b) => mk(12, canon(remap(*a), remap(*b)), 0),
 +        InstKind::FDiv(a, b) => mk(13, vec![remap(*a), remap(*b)], 0),
 +        InstKind::FNeg(a) => mk(14, vec![remap(*a)], 0),
 +        InstKind::FAbs(a) => mk(15, vec![remap(*a)], 0),
 +        InstKind::FSqrt(a) => mk(16, vec![remap(*a)], 0),
 +        InstKind::FPow(a, b) => mk(17, vec![remap(*a), remap(*b)], 0),
          InstKind::ICmp(op, a, b) => {
              let op_val = *op as i128;
              match op {
+         }
          InstKind::FCmp(op, a, b) => mk(21, vec![remap(*a), remap(*b)], *op as i128),
          InstKind::And(a, b) => mk(30, canon(remap(*a), remap(*b)), 0),
 -        InstKind::Or(a, b)  => mk(31, canon(remap(*a), remap(*b)), 0),
 -        InstKind::Not(a)    => mk(32, vec![remap(*a)], 0),
 +        InstKind::Or(a, b) => mk(31, canon(remap(*a), remap(*b)), 0),
 +        InstKind::Not(a) => mk(32, vec![remap(*a)], 0),
          InstKind::Select(c, t, f) => mk(33, vec![remap(*c), remap(*t), remap(*f)], 0),
 -        InstKind::BitAnd(a, b)  => mk(40, canon(remap(*a), remap(*b)), 0),
 -        InstKind::BitOr(a, b)   => mk(41, canon(remap(*a), remap(*b)), 0),
 -        InstKind::BitXor(a, b)  => mk(42, canon(remap(*a), remap(*b)), 0),
 -        InstKind::BitNot(a)     => mk(43, vec![remap(*a)], 0),
 -        InstKind::Shl(a, b)     => mk(44, vec![remap(*a), remap(*b)], 0),
 -        InstKind::LShr(a, b)    => mk(45, vec![remap(*a), remap(*b)], 0),
 -        InstKind::AShr(a, b)    => mk(46, vec![remap(*a), remap(*b)], 0),
 -        InstKind::CountLeadingZeros(a)  => mk(47, vec![remap(*a)], 0),
 +        InstKind::BitAnd(a, b) => mk(40, canon(remap(*a), remap(*b)), 0),
 +        InstKind::BitOr(a, b) => mk(41, canon(remap(*a), remap(*b)), 0),
 +        InstKind::BitXor(a, b) => mk(42, canon(remap(*a), remap(*b)), 0),
 +        InstKind::BitNot(a) => mk(43, vec![remap(*a)], 0),
 +        InstKind::Shl(a, b) => mk(44, vec![remap(*a), remap(*b)], 0),
 +        InstKind::LShr(a, b) => mk(45, vec![remap(*a), remap(*b)], 0),
 +        InstKind::AShr(a, b) => mk(46, vec![remap(*a), remap(*b)], 0),
 +        InstKind::CountLeadingZeros(a) => mk(47, vec![remap(*a)], 0),
          InstKind::CountTrailingZeros(a) => mk(48, vec![remap(*a)], 0),
 -        InstKind::PopCount(a)           => mk(49, vec![remap(*a)], 0),
 +        InstKind::PopCount(a) => mk(49, vec![remap(*a)], 0),
          // Conversions.
 -        InstKind::IntToFloat(a, w)   => mk(50, vec![remap(*a)], w.bits() as i128),
 -        InstKind::FloatToInt(a, w)   => mk(51, vec![remap(*a)], w.bits() as i128),
 -        InstKind::FloatExtend(a, w)  => mk(52, vec![remap(*a)], w.bits() as i128),
 -        InstKind::FloatTrunc(a, w)   => mk(53, vec![remap(*a)], w.bits() as i128),
 -        InstKind::IntExtend(a, w, s) => mk(54, vec![remap(*a)], (w.bits() as i128) * if *s { 1 } else { -1 }),
 -        InstKind::IntTrunc(a, w)     => mk(55, vec![remap(*a)], w.bits() as i128),
 -        InstKind::PtrToInt(a)        => mk(56, vec![remap(*a)], 0),
 -        InstKind::IntToPtr(a, _)     => mk(57, vec![remap(*a)], 0),
 +        InstKind::IntToFloat(a, w) => mk(50, vec![remap(*a)], w.bits() as i128),
 +        InstKind::FloatToInt(a, w) => mk(51, vec![remap(*a)], w.bits() as i128),
 +        InstKind::FloatExtend(a, w) => mk(52, vec![remap(*a)], w.bits() as i128),
 +        InstKind::FloatTrunc(a, w) => mk(53, vec![remap(*a)], w.bits() as i128),
 +        InstKind::IntExtend(a, w, s) => mk(
 +            54,
 +            vec![remap(*a)],
 +            (w.bits() as i128) * if *s { 1 } else { -1 },
 +        ),
 +        InstKind::IntTrunc(a, w) => mk(55, vec![remap(*a)], w.bits() as i128),
 +        InstKind::PtrToInt(a) => mk(56, vec![remap(*a)], 0),
 +        InstKind::IntToPtr(a, _) => mk(57, vec![remap(*a)], 0),
          // Constants.
 -        InstKind::ConstInt(v, w)   => {
 +        InstKind::ConstInt(v, w) => {
              let bits = w.bits();
              let signed = if bits >= 128 {
                  *v
              mk(60, vec![], signed)
+         }
          InstKind::ConstFloat(v, w) => mk(61, vec![], ((*v).to_bits() as i128) ^ (w.bits() as i128)),
 -        InstKind::ConstBool(v)     => mk(62, vec![], *v as i128),
 +        InstKind::ConstBool(v) => mk(62, vec![], *v as i128),
          // GlobalAddr.
          InstKind::GlobalAddr(name) => mk_named(70, name.clone()),
          // GEP.
              mk(90, ops, *idx as i128)
+         }
          // Impure: loads, stores, runtime calls, external calls, alloca — not GVN candidates.
 -        InstKind::Load(..) | InstKind::Store(..) | InstKind::Alloca(..)
 -        | InstKind::Call(..) | InstKind::RuntimeCall(..)
 -        | InstKind::ConstString(..) | InstKind::Undef(..)
 -        | InstKind::ExtractField(..) | InstKind::InsertField(..) => None,
 +        InstKind::Load(..)
 +        | InstKind::Store(..)
 +        | InstKind::Alloca(..)
 +        | InstKind::Call(..)
 +        | InstKind::RuntimeCall(..)
 +        | InstKind::ConstString(..)
 +        | InstKind::Undef(..)
 +        | InstKind::ExtractField(..)
 +        | InstKind::InsertField(..) => None,
+     }
+ }
+         }
+     }
 -    if replacements.is_empty() { return false; }
 +    if replacements.is_empty() {
 +        return false;
 +    }
      // Apply replacements: substitute all uses of redundant values, then
      // drop the now-dead duplicate instructions directly. This matters
          for inst in &mut block.insts {
              inst.kind = remap_operands(&inst.kind, &replacements);
+         }
 -        block.insts.retain(|inst| !replacements.contains_key(&inst.id));
 +        block
 +            .insts
 +            .retain(|inst| !replacements.contains_key(&inst.id));
          if let Some(ref mut term) = block.terminator {
              remap_terminator_operands(term, &replacements);
+         }
      match term {
          Terminator::Return(Some(v)) => *v = r(v),
          Terminator::Branch(_, args) => {
 -            for a in args.iter_mut() { *a = r(a); }
 +            for a in args.iter_mut() {
 +                *a = r(a);
 +            }
+         }
 -        Terminator::CondBranch { cond, true_args, false_args, .. } => {
 +        Terminator::CondBranch {
 +            cond,
 +            true_args,
 +            false_args,
 +            ..
 +        } => {
              *cond = r(cond);
 -            for a in true_args.iter_mut() { *a = r(a); }
 -            for a in false_args.iter_mut() { *a = r(a); }
 +            for a in true_args.iter_mut() {
 +                *a = r(a);
 +            }
 +            for a in false_args.iter_mut() {
 +                *a = r(a);
 +            }
+         }
          Terminator::Switch { selector, .. } => {
              *selector = r(selector);
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use std::fs;
 -    use std::path::PathBuf;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::lower;
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{tokenize, SourceForm};
 +    use crate::lexer::{Position, Span};
      use crate::opt::pass::Pass;
      use crate::opt::pass::PassManager;
 +    use crate::opt::pipeline::OptLevel;
      use crate::opt::{
          bce::Bce, call_resolve::CallResolve, const_fold::ConstFold, const_prop::ConstProp,
 -        dead_func::DeadFuncElim, dse::Dse, fusion::LoopFusion, global_lsf::GlobalLsf,
 -        interchange::LoopInterchange, inline::Inline, licm::Licm, lsf::LocalLsf,
 -        mem2reg::Mem2Reg, peel::LoopPeel, preheader::PreheaderInsert, simplify_cfg::SimplifyCfg,
 -        sroa::Sroa, strength_reduce::StrengthReduce, unroll::LoopUnroll, unswitch::LoopUnswitch,
 -        fission::LoopFission,
 +        dead_func::DeadFuncElim, dse::Dse, fission::LoopFission, fusion::LoopFusion,
 +        global_lsf::GlobalLsf, inline::Inline, interchange::LoopInterchange, licm::Licm,
 +        lsf::LocalLsf, mem2reg::Mem2Reg, peel::LoopPeel, preheader::PreheaderInsert,
 +        simplify_cfg::SimplifyCfg, sroa::Sroa, strength_reduce::StrengthReduce, unroll::LoopUnroll,
 +        unswitch::LoopUnswitch,
      };
 -    use crate::opt::pipeline::OptLevel;
 -    use crate::lexer::{Position, Span};
 -    use crate::lexer::{SourceForm, tokenize};
      use crate::parser::Parser;
      use crate::preprocess::PreprocConfig;
      use crate::sema::{resolve, validate};
 -    use crate::ir::lower;
 +    use std::fs;
 +    use std::path::PathBuf;
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      fn push_inst(func: &mut Function, block: BlockId, kind: InstKind, ty: IrType) -> ValueId {
          let id = func.next_value_id();
          func.register_type(id, ty.clone());
 -        func.block_mut(block).insts.push(Inst { id, kind, ty, span: span() });
 +        func.block_mut(block).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: span(),
 +        });
          id
+     }
          let tokens = tokenize(&pp.text, 0, SourceForm::FreeForm).expect("tokenize fixture");
          let mut parser = Parser::new(&tokens);
          let units = parser.parse_file().expect("parse fixture");
 -        let (st, type_layouts) = { let rr = resolve::resolve_file(&units, &[]).expect("resolve fixture"); (rr.st, rr.type_layouts) };
 +        let (st, type_layouts) = {
 +            let rr = resolve::resolve_file(&units, &[]).expect("resolve fixture");
 +            (rr.st, rr.type_layouts)
 +        };
          let diags = validate::validate_file(&units, &st);
          assert!(
 -            !diags.iter().any(|diag| diag.kind == validate::DiagKind::Error),
 +            !diags
 +                .iter()
 +                .any(|diag| diag.kind == validate::DiagKind::Error),
              "fixture should lower cleanly: {:?}",
              diags
          );
 -        lower::lower_file(&units, &st, &type_layouts, std::collections::HashMap::new(), std::collections::HashMap::new()).0
 +        lower::lower_file(
 +            &units,
 +            &st,
 +            &type_layouts,
 +            std::collections::HashMap::new(),
 +            std::collections::HashMap::new(),
 +        )
 +        .0
+     }
      fn build_pre_gvn_o2_pipeline() -> PassManager {
              .iter()
              .filter(|inst| matches!(inst.kind, InstKind::Call(..)))
              .count();
 -        assert_eq!(call_count, 1, "PURE call should reuse equivalent dominating args");
 +        assert_eq!(
 +            call_count, 1,
 +            "PURE call should reuse equivalent dominating args"
 +        );
 -        match caller.blocks[0].terminator.as_ref().expect("return terminator") {
 +        match caller.blocks[0]
 +            .terminator
 +            .as_ref()
 +            .expect("return terminator")
 +        {
              Terminator::Return(Some(v)) => assert_eq!(*v, call1),
              other => panic!("unexpected terminator: {:?}", other),
+         }
              id: ValueId(0),
              fortran_noalias: false,
          };
 -        let mut callee = Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
 +        let mut callee =
 +            Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
          callee.is_pure = true;
          let entry = callee.entry;
              InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
              IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
          );
 -        push_inst(&mut callee, entry, InstKind::Store(ValueId(0), slot), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            entry,
 +            InstKind::Store(ValueId(0), slot),
 +            IrType::Void,
 +        );
          let arg_ptr = push_inst(
              &mut callee,
              entry,
              id: ValueId(0),
              fortran_noalias: false,
          };
 -        let mut callee = Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
 +        let mut callee =
 +            Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
          callee.is_pure = true;
          let callee_entry = callee.entry;
          let slot = push_inst(
              InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
              IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
          );
 -        push_inst(&mut callee, callee_entry, InstKind::Store(ValueId(0), slot), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            callee_entry,
 +            InstKind::Store(ValueId(0), slot),
 +            IrType::Void,
 +        );
          let arg_ptr = push_inst(
              &mut callee,
              callee_entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        push_inst(&mut caller, entry, InstKind::Store(c, wrapper), IrType::Void);
 +        push_inst(
 +            &mut caller,
 +            entry,
 +            InstKind::Store(c, wrapper),
 +            IrType::Void,
 +        );
          let call = push_inst(
              &mut caller,
              entry,
              id: ValueId(0),
              fortran_noalias: false,
          };
 -        let mut callee = Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
 +        let mut callee =
 +            Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
          callee.is_pure = true;
          let callee_entry = callee.entry;
          let shadow = push_inst(
              InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
              IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
          );
 -        push_inst(&mut callee, callee_entry, InstKind::Store(ValueId(0), shadow), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            callee_entry,
 +            InstKind::Store(ValueId(0), shadow),
 +            IrType::Void,
 +        );
          let arg_ptr = push_inst(
              &mut callee,
              callee_entry,
              InstKind::Call(FuncRef::Internal(0), vec![wrap1]),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut caller, entry, InstKind::Store(call1, first), IrType::Void);
 +        push_inst(
 +            &mut caller,
 +            entry,
 +            InstKind::Store(call1, first),
 +            IrType::Void,
 +        );
          let c3 = push_inst(
              &mut caller,
              entry,
              InstKind::Call(FuncRef::Internal(0), vec![wrap2]),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut caller, entry, InstKind::Store(call2, second), IrType::Void);
 -        let left = push_inst(&mut caller, entry, InstKind::Load(first), IrType::Int(IntWidth::I32));
 -        let right = push_inst(&mut caller, entry, InstKind::Load(second), IrType::Int(IntWidth::I32));
 +        push_inst(
 +            &mut caller,
 +            entry,
 +            InstKind::Store(call2, second),
 +            IrType::Void,
 +        );
 +        let left = push_inst(
 +            &mut caller,
 +            entry,
 +            InstKind::Load(first),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let right = push_inst(
 +            &mut caller,
 +            entry,
 +            InstKind::Load(second),
 +            IrType::Int(IntWidth::I32),
 +        );
          let sum = push_inst(
              &mut caller,
              entry,
          caller.block_mut(entry).terminator = Some(Terminator::Return(Some(sum)));
          m.add_function(caller);
 -        let pure_calls: Vec<PureCallPolicy> = m.functions.iter().map(PureCallPolicy::for_function).collect();
 +        let pure_calls: Vec<PureCallPolicy> = m
 +            .functions
 +            .iter()
 +            .map(PureCallPolicy::for_function)
 +            .collect();
          assert!(pure_calls[0].reusable);
 -        assert_eq!(pure_calls[0].arg_policies, vec![PureArgPolicy::ReadOnlyWrapperPtr]);
 +        assert_eq!(
 +            pure_calls[0].arg_policies,
 +            vec![PureArgPolicy::ReadOnlyWrapperPtr]
 +        );
          let wrappers = wrapper_alloca_values(&m.functions[1], &pure_calls);
          assert_eq!(wrappers.get(&wrap1), Some(&c2));
          assert_eq!(wrappers.get(&wrap2), Some(&c4));
              .iter()
              .find(|inst| inst.id == call2)
              .expect("call2 inst");
 -        let key1 = key_of(call1_inst, &replacements, &pure_calls, &wrappers).expect("call1 should key");
 -        let key2 = key_of(call2_inst, &replacements, &pure_calls, &wrappers).expect("call2 should key");
 -        assert_eq!(key1, key2, "wrapper-based call keys should line up before the pass runs");
 +        let key1 =
 +            key_of(call1_inst, &replacements, &pure_calls, &wrappers).expect("call1 should key");
 +        let key2 =
 +            key_of(call2_inst, &replacements, &pure_calls, &wrappers).expect("call2 should key");
 +        assert_eq!(
 +            key1, key2,
 +            "wrapper-based call keys should line up before the pass runs"
 +        );
          let pass = Gvn;
          assert!(pass.run(&mut m));
              id: ValueId(0),
              fortran_noalias: false,
          };
 -        let mut callee = Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
 +        let mut callee =
 +            Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
          callee.is_pure = true;
          let entry = callee.entry;
          let if_end = callee.create_block("if_end");
              InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
              IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
          );
 -        push_inst(&mut callee, entry, InstKind::Store(ValueId(0), shadow), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            entry,
 +            InstKind::Store(ValueId(0), shadow),
 +            IrType::Void,
 +        );
          let result = push_inst(
              &mut callee,
              entry,
              InstKind::Load(shadow),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let n1 = push_inst(&mut callee, entry, InstKind::Load(p1), IrType::Int(IntWidth::I32));
 +        let n1 = push_inst(
 +            &mut callee,
 +            entry,
 +            InstKind::Load(p1),
 +            IrType::Int(IntWidth::I32),
 +        );
          let one = push_inst(
              &mut callee,
              entry,
              InstKind::ConstInt(1, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut callee, if_then, InstKind::Store(then_one, result), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            if_then,
 +            InstKind::Store(then_one, result),
 +            IrType::Void,
 +        );
          callee.block_mut(if_then).terminator = Some(Terminator::Branch(if_end, vec![]));
          let p2 = push_inst(
              InstKind::Load(shadow),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let n2 = push_inst(&mut callee, if_else, InstKind::Load(p2), IrType::Int(IntWidth::I32));
 +        let n2 = push_inst(
 +            &mut callee,
 +            if_else,
 +            InstKind::Load(p2),
 +            IrType::Int(IntWidth::I32),
 +        );
          let p3 = push_inst(
              &mut callee,
              if_else,
              InstKind::Load(shadow),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let n3 = push_inst(&mut callee, if_else, InstKind::Load(p3), IrType::Int(IntWidth::I32));
 +        let n3 = push_inst(
 +            &mut callee,
 +            if_else,
 +            InstKind::Load(p3),
 +            IrType::Int(IntWidth::I32),
 +        );
          let one2 = push_inst(
              &mut callee,
              if_else,
              InstKind::Load(shadow),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let n4 = push_inst(&mut callee, if_else, InstKind::Load(p4), IrType::Int(IntWidth::I32));
 +        let n4 = push_inst(
 +            &mut callee,
 +            if_else,
 +            InstKind::Load(p4),
 +            IrType::Int(IntWidth::I32),
 +        );
          let one3 = push_inst(
              &mut callee,
              if_else,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        push_inst(&mut callee, if_else, InstKind::Store(dec2, wrap), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            if_else,
 +            InstKind::Store(dec2, wrap),
 +            IrType::Void,
 +        );
          let rec = push_inst(
              &mut callee,
              if_else,
              InstKind::IMul(n2, rec),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut callee, if_else, InstKind::Store(prod, result), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            if_else,
 +            InstKind::Store(prod, result),
 +            IrType::Void,
 +        );
          callee.block_mut(if_else).terminator = Some(Terminator::Branch(if_end, vec![]));
 -        let final_val = push_inst(&mut callee, if_end, InstKind::Load(result), IrType::Int(IntWidth::I32));
 +        let final_val = push_inst(
 +            &mut callee,
 +            if_end,
 +            InstKind::Load(result),
 +            IrType::Int(IntWidth::I32),
 +        );
          callee.block_mut(if_end).terminator = Some(Terminator::Return(Some(final_val)));
          m.add_function(callee);
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        push_inst(&mut caller, caller_entry, InstKind::Store(unit2, wrap1), IrType::Void);
 +        push_inst(
 +            &mut caller,
 +            caller_entry,
 +            InstKind::Store(unit2, wrap1),
 +            IrType::Void,
 +        );
          let call1 = push_inst(
              &mut caller,
              caller_entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        push_inst(&mut caller, caller_entry, InstKind::Store(unit, wrap2), IrType::Void);
 +        push_inst(
 +            &mut caller,
 +            caller_entry,
 +            InstKind::Store(unit, wrap2),
 +            IrType::Void,
 +        );
          let call2 = push_inst(
              &mut caller,
              caller_entry,
              .iter()
              .filter(|inst| matches!(inst.kind, InstKind::Call(..)))
              .count();
 -        assert_eq!(call_count, 1, "recursive PURE factorial calls should dedupe");
 +        assert_eq!(
 +            call_count, 1,
 +            "recursive PURE factorial calls should dedupe"
 +        );
+     }
      #[test]
              id: ValueId(0),
              fortran_noalias: false,
          };
 -        let mut callee = Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
 +        let mut callee =
 +            Function::new("heavy_fact".into(), vec![param], IrType::Int(IntWidth::I32));
          callee.is_pure = true;
          let callee_entry = callee.entry;
          let shadow = push_inst(
              InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
              IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
          );
 -        push_inst(&mut callee, callee_entry, InstKind::Store(ValueId(0), shadow), IrType::Void);
 +        push_inst(
 +            &mut callee,
 +            callee_entry,
 +            InstKind::Store(ValueId(0), shadow),
 +            IrType::Void,
 +        );
          let arg_ptr = push_inst(
              &mut callee,
              callee_entry,
              .iter()
              .filter(|inst| matches!(inst.kind, InstKind::Call(..)))
              .count();
 -        assert_eq!(call_count, 1, "caller-before-callee ordering should still dedupe");
 +        assert_eq!(
 +            call_count, 1,
 +            "caller-before-callee ordering should still dedupe"
 +        );
+     }
      #[test]
          let pm = build_pre_gvn_o2_pipeline();
          pm.run(&mut module);
 -        let pure_calls: Vec<PureCallPolicy> = module.functions.iter().map(PureCallPolicy::for_function).collect();
 +        let pure_calls: Vec<PureCallPolicy> = module
 +            .functions
 +            .iter()
 +            .map(PureCallPolicy::for_function)
 +            .collect();
          assert!(
              pure_calls.iter().any(|policy| policy.reusable),
              "at least one function in the fixture should remain a reusable PURE callee:\n{}",
          );
          let pass = Gvn;
 -        assert!(pass.run(&mut module), "GVN should make progress on the real fixture");
 +        assert!(
 +            pass.run(&mut module),
 +            "GVN should make progress on the real fixture"
 +        );
          let caller = &module.functions[caller_idx];
          let call_count = caller.blocks[0]
              .iter()
              .filter(|inst| matches!(inst.kind, InstKind::Call(FuncRef::Internal(_), _)))
              .count();
 -        assert_eq!(call_count, 1, "real fixture caller should end with one PURE recursive call");
 +        assert_eq!(
 +            call_count, 1,
 +            "real fixture caller should end with one PURE recursive call"
 +        );
+     }
      #[test]
          m.add_function(caller);
          let pass = Gvn;
 -        assert!(!pass.run(&mut m), "pointer-arg PURE calls must stay distinct");
 +        assert!(
 +            !pass.run(&mut m),
 +            "pointer-arg PURE calls must stay distinct"
 +        );
          let caller = &m.functions[1];
          let call_count = caller.blocks[0]

src/opt/inline.rsmodified

350 lines changed — click to load

  //!   5. Split the call-containing block: pre-call instructions +
  //!      branch to cloned entry, post-call block receives return value
 -use std::collections::HashMap;
 -use crate::ir::inst::*;
 -use crate::ir::types::IrType;
 -use crate::ir::walk::prune_unreachable;
  use super::callgraph::CallGraph;
  use super::loop_utils::{remap_inst_kind, remap_terminator};
  use super::pass::Pass;
  use super::pipeline::OptLevel;
 +use crate::ir::inst::*;
 +use crate::ir::types::IrType;
 +use crate::ir::walk::prune_unreachable;
 +use std::collections::HashMap;
  /// Maximum callee instruction count for inlining.
  const INLINE_THRESHOLD_O1: usize = 20;
+ }
  impl Pass for Inline {
 -    fn name(&self) -> &'static str { "inline" }
 +    fn name(&self) -> &'static str {
 +        "inline"
 +    }
      fn run(&self, module: &mut Module) -> bool {
 -        if self.threshold == 0 { return false; }
 +        if self.threshold == 0 {
 +            return false;
 +        }
          let cg = CallGraph::build(module);
          let order = cg.bottom_up_order();
                  if let InstKind::Call(FuncRef::Internal(callee_idx), args) = &inst.kind {
                      let ci = *callee_idx;
                      // Don't inline recursive functions.
 -                    if cg.is_recursive(ci) { continue; }
 +                    if cg.is_recursive(ci) {
 +                        continue;
 +                    }
                      // Don't self-inline.
 -                    if ci == caller_idx { continue; }
 +                    if ci == caller_idx {
 +                        continue;
 +                    }
                      // Cost check.
 -                    if cg.inline_cost(ci) > threshold { continue; }
 +                    if cg.inline_cost(ci) > threshold {
 +                        continue;
 +                    }
                      // Argument/parameter type agreement.  When a
                      // Fortran OPTIONAL parameter is absent at a call
                      // site, the caller passes `const_i64 0` as a null
                      // callee param type exactly.  The same check also
                      // guards any future call-boundary coercion shims.
                      let callee = &module.functions[ci as usize];
 -                    if callee.params.len() != args.len() { continue; }
 -                    let mismatched = callee.params.iter().zip(args.iter()).any(|(p, a)| {
 -                        match caller.value_type(*a) {
 -                            Some(ty) => ty != p.ty,
 -                            None => true,
 -                        }
 -                    });
 -                    if mismatched { continue; }
 +                    if callee.params.len() != args.len() {
 +                        continue;
 +                    }
 +                    let mismatched =
 +                        callee.params.iter().zip(args.iter()).any(|(p, a)| {
 +                            match caller.value_type(*a) {
 +                                Some(ty) => ty != p.ty,
 +                                None => true,
 +                            }
 +                        });
 +                    if mismatched {
 +                        continue;
 +                    }
                      sites.push((block.id, inst_idx, ci, args.clone()));
+                 }
+             }
          sites
      };
 -    if call_sites.is_empty() { return false; }
 +    if call_sites.is_empty() {
 +        return false;
 +    }
      // Inline one call site, then return true to let the pass manager
      // re-run us. Processing multiple sites in one invocation is unsafe:
      // same block. The pass manager's fixpoint loop handles re-invocation.
      let (call_block_id, call_inst_idx, callee_idx, caller_args) = call_sites[0].clone();
+     {
 +        // Clone the callee's body into the caller.
 +        let callee = &module.functions[callee_idx as usize];
 +        let callee_entry = callee.entry;
 +        let callee_blocks: Vec<BasicBlock> = callee.blocks.clone();
 +        let callee_params: Vec<Param> = callee.params.clone();
 +        let callee_return_ty = callee.return_type.clone();
++
 +        let caller = &mut module.functions[caller_idx as usize];
++
 +        // Build value map: callee params → caller args.
 +        let mut val_map: HashMap<ValueId, ValueId> = HashMap::new();
 +        for (param, &arg) in callee_params.iter().zip(caller_args.iter()) {
 +            val_map.insert(param.id, arg);
 +        }
 -    // Clone the callee's body into the caller.
 -    let callee = &module.functions[callee_idx as usize];
 -    let callee_entry = callee.entry;
 -    let callee_blocks: Vec<BasicBlock> = callee.blocks.clone();
 -    let callee_params: Vec<Param> = callee.params.clone();
 -    let callee_return_ty = callee.return_type.clone();
+-
 -    let caller = &mut module.functions[caller_idx as usize];
+-
 -    // Build value map: callee params → caller args.
 -    let mut val_map: HashMap<ValueId, ValueId> = HashMap::new();
 -    for (param, &arg) in callee_params.iter().zip(caller_args.iter()) {
 -        val_map.insert(param.id, arg);
 -    }
+-
 -    // Allocate fresh IDs for all callee values.
 -    let mut block_map: HashMap<BlockId, BlockId> = HashMap::new();
 -    for cb in &callee_blocks {
 -        let new_bid = caller.create_block(&format!("inline_{}", cb.name));
 -        block_map.insert(cb.id, new_bid);
 -    }
+-
 -    // Create post-call block to receive the return value.
 -    let post_call = caller.create_block("inline_post");
 -    let has_return_val = !matches!(callee_return_ty, IrType::Void);
 +        // Allocate fresh IDs for all callee values.
 +        let mut block_map: HashMap<BlockId, BlockId> = HashMap::new();
 +        for cb in &callee_blocks {
 +            let new_bid = caller.create_block(&format!("inline_{}", cb.name));
 +            block_map.insert(cb.id, new_bid);
 +        }
 -    let result_param_id = if has_return_val {
 -        let pid = caller.next_value_id();
 -        caller.register_type(pid, callee_return_ty.clone());
 -        caller.block_mut(post_call).params.push(BlockParam {
 -            id: pid,
 -            ty: callee_return_ty.clone(),
 -        });
 -        Some(pid)
 -    } else {
 -        None
 -    };
 +        // Create post-call block to receive the return value.
 +        let post_call = caller.create_block("inline_post");
 +        let has_return_val = !matches!(callee_return_ty, IrType::Void);
 -    // Clone block params and instructions.
 -    for cb in &callee_blocks {
 -        let new_bid = block_map[&cb.id];
 -        // Clone block params.
 -        for bp in &cb.params {
 -            let new_id = caller.next_value_id();
 -            caller.register_type(new_id, bp.ty.clone());
 -            val_map.insert(bp.id, new_id);
 -            caller.block_mut(new_bid).params.push(BlockParam {
 -                id: new_id,
 -                ty: bp.ty.clone(),
 -            });
 -        }
 -        // Clone instructions.
 -        for inst in &cb.insts {
 -            let new_id = caller.next_value_id();
 -            caller.register_type(new_id, inst.ty.clone());
 -            val_map.insert(inst.id, new_id);
 -            let new_kind = remap_inst_kind(&inst.kind, &val_map);
 -            caller.block_mut(new_bid).insts.push(Inst {
 -                id: new_id,
 -                kind: new_kind,
 -                ty: inst.ty.clone(),
 -                span: inst.span,
 +        let result_param_id = if has_return_val {
 +            let pid = caller.next_value_id();
 +            caller.register_type(pid, callee_return_ty.clone());
 +            caller.block_mut(post_call).params.push(BlockParam {
 +                id: pid,
 +                ty: callee_return_ty.clone(),
              });
 -        }
 -    }
 +            Some(pid)
 +        } else {
 +            None
 +        };
 -    // Clone terminators, replacing Return with Branch to post_call.
 -    for cb in &callee_blocks {
 -        let new_bid = block_map[&cb.id];
 -        let new_term = match &cb.terminator {
 -            Some(Terminator::Return(Some(val))) => {
 -                let remapped = *val_map.get(val).unwrap_or(val);
 -                Terminator::Branch(post_call, vec![remapped])
 -            }
 -            Some(Terminator::Return(None)) => {
 -                Terminator::Branch(post_call, vec![])
 +        // Clone block params and instructions.
 +        for cb in &callee_blocks {
 +            let new_bid = block_map[&cb.id];
 +            // Clone block params.
 +            for bp in &cb.params {
 +                let new_id = caller.next_value_id();
 +                caller.register_type(new_id, bp.ty.clone());
 +                val_map.insert(bp.id, new_id);
 +                caller.block_mut(new_bid).params.push(BlockParam {
 +                    id: new_id,
 +                    ty: bp.ty.clone(),
 +                });
+             }
 -            Some(other) => {
 -                remap_terminator(other, &block_map, &val_map)
 +            // Clone instructions.
 +            for inst in &cb.insts {
 +                let new_id = caller.next_value_id();
 +                caller.register_type(new_id, inst.ty.clone());
 +                val_map.insert(inst.id, new_id);
 +                let new_kind = remap_inst_kind(&inst.kind, &val_map);
 +                caller.block_mut(new_bid).insts.push(Inst {
 +                    id: new_id,
 +                    kind: new_kind,
 +                    ty: inst.ty.clone(),
 +                    span: inst.span,
 +                });
+             }
 -            None => Terminator::Unreachable,
 -        };
 -        caller.block_mut(new_bid).terminator = Some(new_term);
 -    }
 +        }
 -    // Split the call-containing block: move instructions after the call
 -    // into the post-call block.
 -    let call_block = caller.block_mut(call_block_id);
 -    let call_result_id = call_block.insts[call_inst_idx].id;
 +        // Clone terminators, replacing Return with Branch to post_call.
 +        for cb in &callee_blocks {
 +            let new_bid = block_map[&cb.id];
 +            let new_term = match &cb.terminator {
 +                Some(Terminator::Return(Some(val))) => {
 +                    let remapped = *val_map.get(val).unwrap_or(val);
 +                    Terminator::Branch(post_call, vec![remapped])
 +                }
 +                Some(Terminator::Return(None)) => Terminator::Branch(post_call, vec![]),
 +                Some(other) => remap_terminator(other, &block_map, &val_map),
 +                None => Terminator::Unreachable,
 +            };
 +            caller.block_mut(new_bid).terminator = Some(new_term);
 +        }
 -    // Move post-call instructions to the new block.
 -    let post_insts: Vec<Inst> = call_block.insts.split_off(call_inst_idx + 1);
 -    let old_term = call_block.terminator.take();
 +        // Split the call-containing block: move instructions after the call
 +        // into the post-call block.
 +        let call_block = caller.block_mut(call_block_id);
 +        let call_result_id = call_block.insts[call_inst_idx].id;
 -    // Remove the call instruction itself.
 -    call_block.insts.pop(); // removes the call at call_inst_idx
 +        // Move post-call instructions to the new block.
 +        let post_insts: Vec<Inst> = call_block.insts.split_off(call_inst_idx + 1);
 +        let old_term = call_block.terminator.take();
 -    // Add branch from call block to inlined entry.
 -    let inlined_entry = block_map[&callee_entry];
 -    caller.block_mut(call_block_id).terminator =
 -        Some(Terminator::Branch(inlined_entry, vec![]));
 +        // Remove the call instruction itself.
 +        call_block.insts.pop(); // removes the call at call_inst_idx
 -    // Populate post-call block with remaining instructions and terminator.
 -    // Remap uses of the call result to the post-call block param.
 -    let mut post_remap: HashMap<ValueId, ValueId> = HashMap::new();
 -    if let Some(param_id) = result_param_id {
 -        post_remap.insert(call_result_id, param_id);
 -    }
 +        // Add branch from call block to inlined entry.
 +        let inlined_entry = block_map[&callee_entry];
 +        caller.block_mut(call_block_id).terminator =
 +            Some(Terminator::Branch(inlined_entry, vec![]));
 -    for inst in post_insts {
 -        let new_kind = if post_remap.is_empty() {
 -            inst.kind.clone()
 -        } else {
 -            remap_inst_kind(&inst.kind, &post_remap)
 -        };
 -        caller.block_mut(post_call).insts.push(Inst {
 -            id: inst.id,
 -            kind: new_kind,
 -            ty: inst.ty,
 -            span: inst.span,
 -        });
 -    }
 +        // Populate post-call block with remaining instructions and terminator.
 +        // Remap uses of the call result to the post-call block param.
 +        let mut post_remap: HashMap<ValueId, ValueId> = HashMap::new();
 +        if let Some(param_id) = result_param_id {
 +            post_remap.insert(call_result_id, param_id);
 +        }
 -    if let Some(term) = old_term {
 -        let new_term = if post_remap.is_empty() {
 -            term
 -        } else {
 -            remap_terminator(&term, &HashMap::new(), &post_remap)
 -        };
 -        caller.block_mut(post_call).terminator = Some(new_term);
 -    }
 +        for inst in post_insts {
 +            let new_kind = if post_remap.is_empty() {
 +                inst.kind.clone()
 +            } else {
 +                remap_inst_kind(&inst.kind, &post_remap)
 +            };
 +            caller.block_mut(post_call).insts.push(Inst {
 +                id: inst.id,
 +                kind: new_kind,
 +                ty: inst.ty,
 +                span: inst.span,
 +            });
 +        }
 +        if let Some(term) = old_term {
 +            let new_term = if post_remap.is_empty() {
 +                term
 +            } else {
 +                remap_terminator(&term, &HashMap::new(), &post_remap)
 +            };
 +            caller.block_mut(post_call).terminator = Some(new_term);
 +        }
      } // end single inline
      let caller = &mut module.functions[caller_idx as usize];
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::opt::pass::Pass;
      #[test]

src/opt/interchange.rsmodified

321 lines changed — click to load

  //! use both IVs as simple direct subscripts with no cross-iteration
  //! read-before-write. This avoids needing full dependence analysis.
 -use crate::ir::inst::*;
 -use crate::ir::walk::predecessors;
  use super::loop_tree::build_loop_tree;
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use crate::ir::walk::predecessors;
  pub struct LoopInterchange;
  impl Pass for LoopInterchange {
 -    fn name(&self) -> &'static str { "loop-interchange" }
 +    fn name(&self) -> &'static str {
 +        "loop-interchange"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if interchange_in_function(func) { changed = true; }
 +            if interchange_in_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
          // Both loops must have a recognized counted-loop structure:
          // header(%iv) → cmp_block(icmp, condBr) → body → latch(iadd, br header)
 -        let Some(outer_shape) = detect_loop_shape(func, outer, &preds) else { continue };
 -        let Some(inner_shape) = detect_loop_shape(func, inner, &preds) else { continue };
 +        let Some(outer_shape) = detect_loop_shape(func, outer, &preds) else {
 +            continue;
 +        };
 +        let Some(inner_shape) = detect_loop_shape(func, inner, &preds) else {
 +            continue;
 +        };
          // Check profitability: is the outer IV used as the first (fast)
          // subscript of a multi-dimensional array GEP?
  struct LoopShape {
      header: BlockId,
      cmp_block: BlockId,
 -    iv: ValueId,          // block param on header
 -    bound: ValueId,       // the upper-bound value in the comparison
 +    iv: ValueId,    // block param on header
 +    bound: ValueId, // the upper-bound value in the comparison
      latch: BlockId,
      /// The value passed to the header from the preheader (initial IV).
 -    init_arg_idx: usize,  // index in preheader's branch args
 +    init_arg_idx: usize, // index in preheader's branch args
+ }
  fn detect_loop_shape(
      let hdr = func.block(header);
      // Header must have exactly 1 block param (the IV).
 -    if hdr.params.len() != 1 { return None; }
 +    if hdr.params.len() != 1 {
 +        return None;
 +    }
      let iv = hdr.params[0].id;
      // Header must be a relay (0 instructions, branch to cmp_block).
 -    if !hdr.insts.is_empty() { return None; }
 +    if !hdr.insts.is_empty() {
 +        return None;
 +    }
      let cmp_block = match &hdr.terminator {
          Some(Terminator::Branch(t, args)) if args.is_empty() => *t,
          _ => return None,
      };
 -    if !node.body.contains(&cmp_block) { return None; }
 +    if !node.body.contains(&cmp_block) {
 +        return None;
 +    }
      // Cmp block must have icmp + condBr.
      let cmp_blk = func.block(cmp_block);
          for inst in &cmp_blk.insts {
              if let InstKind::ICmp(_, a, b) = &inst.kind {
                  // One operand should be the IV, the other is the bound.
 -                if *a == iv { found_bound = Some(*b); }
 -                else if *b == iv { found_bound = Some(*a); }
 +                if *a == iv {
 +                    found_bound = Some(*b);
 +                } else if *b == iv {
 +                    found_bound = Some(*a);
 +                }
+             }
+         }
          found_bound?
      };
      // Find the single latch.
 -    if node.latches.len() != 1 { return None; }
 +    if node.latches.len() != 1 {
 +        return None;
 +    }
      let latch = node.latches[0];
      Some(LoopShape {
      _inner_iv: ValueId,
  ) -> bool {
      // Find the instruction that produces `offset`.
 -    let Some(inst) = find_inst(func, offset) else { return false };
 +    let Some(inst) = find_inst(func, offset) else {
 +        return false;
 +    };
      // The offset should be an iadd of two parts.
      let (a, b) = match &inst.kind {
      let b_uses_mul = trace_involves_mul(func, b);
      // The fast part is the one WITHOUT multiplication.
 -    let fast_part = if !a_uses_mul && b_uses_mul { a }
 -                    else if a_uses_mul && !b_uses_mul { b }
 -                    else { return false };
 +    let fast_part = if !a_uses_mul && b_uses_mul {
 +        a
 +    } else if a_uses_mul && !b_uses_mul {
 +        b
 +    } else {
 +        return false;
 +    };
      // Does the fast part trace back to the outer IV?
      traces_to_iv(func, fast_part, outer_iv)
  /// Check if a value's computation involves an IMul somewhere.
  fn trace_involves_mul(func: &Function, val: ValueId) -> bool {
 -    let Some(inst) = find_inst(func, val) else { return false };
 +    let Some(inst) = find_inst(func, val) else {
 +        return false;
 +    };
      match &inst.kind {
          InstKind::IMul(..) => true,
 -        InstKind::IAdd(a, b) | InstKind::ISub(a, b) =>
 -            trace_involves_mul(func, *a) || trace_involves_mul(func, *b),
 +        InstKind::IAdd(a, b) | InstKind::ISub(a, b) => {
 +            trace_involves_mul(func, *a) || trace_involves_mul(func, *b)
 +        }
          InstKind::IntExtend(a, _, _) => trace_involves_mul(func, *a),
          _ => false,
+     }
  /// Check if a value traces back to a specific IV (through isub, int_extend).
  fn traces_to_iv(func: &Function, val: ValueId, iv: ValueId) -> bool {
 -    if val == iv { return true; }
 -    let Some(inst) = find_inst(func, val) else { return false };
 +    if val == iv {
 +        return true;
 +    }
 +    let Some(inst) = find_inst(func, val) else {
 +        return false;
 +    };
      match &inst.kind {
          InstKind::ISub(a, _) => traces_to_iv(func, *a, iv),
          InstKind::IntExtend(a, _, _) => traces_to_iv(func, *a, iv),
  fn find_inst(func: &Function, vid: ValueId) -> Option<&Inst> {
      for block in &func.blocks {
          for inst in &block.insts {
 -            if inst.id == vid { return Some(inst); }
 +            if inst.id == vid {
 +                return Some(inst);
 +            }
+         }
+     }
      None
  /// Trace through a GEP chain to find the base array pointer.
  fn trace_gep_base(func: &Function, ptr: ValueId) -> Option<ValueId> {
 -    let Some(inst) = find_inst(func, ptr) else { return Some(ptr); };
 +    let Some(inst) = find_inst(func, ptr) else {
 +        return Some(ptr);
 +    };
      match &inst.kind {
          InstKind::GetElementPtr(base, _) => Some(*base),
          _ => Some(ptr),
                      break;
+                 }
+             }
 -            if let Some(Terminator::CondBranch { true_dest, false_dest, .. }) = &block.terminator {
 +            if let Some(Terminator::CondBranch {
 +                true_dest,
 +                false_dest,
 +                ..
 +            }) = &block.terminator
 +            {
                  if *true_dest == outer.header || *false_dest == outer.header {
                      // Could be a condBr preheader from preheader insertion
                      // but we need the unconditional one.
+         }
          ph
      };
 -    let Some(outer_ph) = outer_preheader else { return; };
 +    let Some(outer_ph) = outer_preheader else {
 +        return;
 +    };
      // Find the block that branches to the inner header with the inner
      // IV init value (this is the outer loop's "body entry" block).
                      break;
+                 }
+             }
 -            if let Some(Terminator::CondBranch { true_dest, true_args, .. }) = &block.terminator {
 +            if let Some(Terminator::CondBranch {
 +                true_dest,
 +                true_args,
 +                ..
 +            }) = &block.terminator
 +            {
                  if *true_dest == inner.header && !true_args.is_empty() {
                      ie = Some(block.id);
                      break;
+         }
          ie
      };
 -    let Some(inner_entry_block) = inner_entry else { return; };
 +    let Some(inner_entry_block) = inner_entry else {
 +        return;
 +    };
      // Get current init values.
      let outer_init = get_branch_arg_to(func, outer_ph, outer.header, 0);
      let inner_init = get_branch_arg_to(func, inner_entry_block, inner.header, 0);
 -    let Some(outer_init_val) = outer_init else { return };
 -    let Some(inner_init_val) = inner_init else { return };
 +    let Some(outer_init_val) = outer_init else {
 +        return;
 +    };
 +    let Some(inner_init_val) = inner_init else {
 +        return;
 +    };
      // Swap init values: outer preheader now passes inner's init to
      // outer's header, and inner entry now passes outer's init to
      let block = func.block(from);
      match &block.terminator {
          Some(Terminator::Branch(dest, args)) if *dest == to => args.get(idx).copied(),
 -        Some(Terminator::CondBranch { true_dest, true_args, false_dest, false_args, .. }) => {
 -            if *true_dest == to { true_args.get(idx).copied() }
 -            else if *false_dest == to { false_args.get(idx).copied() }
 -            else { None }
 +        Some(Terminator::CondBranch {
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +            ..
 +        }) => {
 +            if *true_dest == to {
 +                true_args.get(idx).copied()
 +            } else if *false_dest == to {
 +                false_args.get(idx).copied()
 +            } else {
 +                None
 +            }
+         }
          _ => None,
+     }
      let block = func.block_mut(from);
      match &mut block.terminator {
          Some(Terminator::Branch(dest, args)) if *dest == to => {
 -            if idx < args.len() { args[idx] = val; }
 +            if idx < args.len() {
 +                args[idx] = val;
 +            }
+         }
 -        Some(Terminator::CondBranch { true_dest, true_args, false_dest, false_args, .. }) => {
 -            if *true_dest == to && idx < true_args.len() { true_args[idx] = val; }
 -            else if *false_dest == to && idx < false_args.len() { false_args[idx] = val; }
 +        Some(Terminator::CondBranch {
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +            ..
 +        }) => {
 +            if *true_dest == to && idx < true_args.len() {
 +                true_args[idx] = val;
 +            } else if *false_dest == to && idx < false_args.len() {
 +                false_args[idx] = val;
 +            }
+         }
          _ => {}
+     }
+ }
  /// Swap the bound value in a comparison block's ICmp instruction.
 -fn swap_bound(func: &mut Function, cmp_block: BlockId, iv: ValueId, old_bound: ValueId, new_bound: ValueId) {
 +fn swap_bound(
 +    func: &mut Function,
 +    cmp_block: BlockId,
 +    iv: ValueId,
 +    old_bound: ValueId,
 +    new_bound: ValueId,
 +) {
      let block = func.block_mut(cmp_block);
      for inst in &mut block.insts {
          if let InstKind::ICmp(_op, a, b) = &mut inst.kind {
  mod tests {
      use super::*;
      use crate::ir::types::IrType;
 +    use crate::lexer::{Position, Span};
      use crate::opt::pass::Pass;
 -    use crate::lexer::{Span, Position};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      #[test]

src/opt/licm.rsmodified

431 lines changed — click to load

  use super::alias::{self, AliasResult};
  use super::pass::Pass;
 -use super::util::{find_natural_loops, predecessors, inst_uses, NaturalLoop};
 +use super::util::{find_natural_loops, inst_uses, predecessors, NaturalLoop};
  use crate::ir::inst::*;
  use std::collections::{HashMap, HashSet};
      let pruned = super::util::prune_unreachable(func);
      let loops = find_natural_loops(func);
 -    if loops.is_empty() { return pruned; }
 +    if loops.is_empty() {
 +        return pruned;
 +    }
      let preds = predecessors(func);
      let mut any_hoisted = pruned;
      // we'd "rebuild per iteration" — that was always aspirational
      // and would only matter if a future variant of LICM started
      // mutating the block vector.
 -    let block_index: HashMap<BlockId, usize> = func.blocks.iter()
 +    let block_index: HashMap<BlockId, usize> = func
 +        .blocks
 +        .iter()
          .enumerate()
          .map(|(i, b)| (b.id, i))
          .collect();
      for lp in &loops {
          // Need a preheader to hoist into.
 -        let Some(ph_id) = find_preheader(func, lp, &preds) else { continue; };
 +        let Some(ph_id) = find_preheader(func, lp, &preds) else {
 +            continue;
 +        };
          // Iteratively find invariant instructions until a full pass
          // turns up nothing new. After each round we mark the hoisted
          loop {
              let mut hoists: Vec<Hoist> = Vec::new();
              for (bi, block) in func.blocks.iter().enumerate() {
 -                if !lp.body.contains(&block.id) { continue; }
 +                if !lp.body.contains(&block.id) {
 +                    continue;
 +                }
                  for (ii, inst) in block.insts.iter().enumerate() {
                      if !loop_defs.contains(&inst.id) {
                          // Already hoisted (we mark it removed from
                      // not in the loop_defs set (i.e., previously
                      // hoisted, or defined outside).
                      let operands = inst_uses(&inst.kind);
 -                    if operands.iter().any(|v| loop_defs.contains(v)) { continue; }
 +                    if operands.iter().any(|v| loop_defs.contains(v)) {
 +                        continue;
 +                    }
                      let hoistable = match &inst.kind {
                          InstKind::Load(ptr) => load_is_loop_invariant(func, lp, inst.id, *ptr),
                          _ => is_non_memory_hoist_candidate(&inst.kind),
                      };
 -                    if !hoistable { continue; }
 -                    hoists.push(Hoist { block_idx: bi, inst_idx: ii });
 +                    if !hoistable {
 +                        continue;
 +                    }
 +                    hoists.push(Hoist {
 +                        block_idx: bi,
 +                        inst_idx: ii,
 +                    });
+                 }
+             }
 -            if hoists.is_empty() { break; }
 +            if hoists.is_empty() {
 +                break;
 +            }
              // Apply hoists: remove from source blocks (in reverse
              // index order so earlier indices remain valid), then
  pub struct Licm;
  impl Pass for Licm {
 -    fn name(&self) -> &'static str { "licm" }
 +    fn name(&self) -> &'static str {
 +        "licm"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if licm_function(func) { changed = true; }
 +            if licm_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          // Header.
          let header = f.create_block("header");
          let i_param = f.next_value_id();
 -        f.block_mut(header).params.push(BlockParam { id: i_param, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: i_param,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let k = f.next_value_id();
          let tmp = f.next_value_id();
          let done = f.next_value_id();
          // Latch.
          let latch = f.create_block("latch");
          let i_in = f.next_value_id();
 -        f.block_mut(latch).params.push(BlockParam { id: i_in, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(latch).params.push(BlockParam {
 +            id: i_in,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let one = f.next_value_id();
          let next = f.next_value_id();
          f.block_mut(latch).insts.push(Inst {
          let entry_block = f.block(f.entry);
          // The const(5) should now live in the entry block (which is
          // the natural preheader), not the header.
 -        let in_entry_const5 = entry_block.insts.iter().any(|i| matches!(i.kind, InstKind::ConstInt(5, IntWidth::I32)));
 -        assert!(in_entry_const5, "const(5) should be hoisted into preheader (entry)");
 +        let in_entry_const5 = entry_block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::ConstInt(5, IntWidth::I32)));
 +        assert!(
 +            in_entry_const5,
 +            "const(5) should be hoisted into preheader (entry)"
 +        );
          let header_block = f.block(header);
 -        let in_header_const5 = header_block.insts.iter().any(|i| matches!(i.kind, InstKind::ConstInt(5, IntWidth::I32)));
 +        let in_header_const5 = header_block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::ConstInt(5, IntWidth::I32)));
          assert!(!in_header_const5, "const(5) should be removed from header");
+     }
          Licm.run(&mut m);
          let f = &m.functions[0];
          let header_block = f.block(header);
 -        let header_has_iadd = header_block.insts.iter().any(|i| matches!(i.kind, InstKind::IAdd(..)));
 -        assert!(header_has_iadd, "IAdd(i_param, k) must remain in the header");
 +        let header_has_iadd = header_block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::IAdd(..)));
 +        assert!(
 +            header_has_iadd,
 +            "IAdd(i_param, k) must remain in the header"
 +        );
+     }
      #[test]
          let header = f.create_block("header");
          let i_param = f.next_value_id();
 -        f.block_mut(header).params.push(BlockParam { id: i_param, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: i_param,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let v = f.next_value_id();
          f.block_mut(header).insts.push(Inst {
              id: v,
          // The Load must still be in the header after LICM.
          let f = &m.functions[0];
          let header_block = f.block(header);
 -        let load_in_header = header_block.insts.iter()
 +        let load_in_header = header_block
 +            .insts
 +            .iter()
              .any(|i| matches!(i.kind, InstKind::Load(_)));
 -        assert!(load_in_header, "ambiguous loop load should not have been hoisted");
 +        assert!(
 +            load_in_header,
 +            "ambiguous loop load should not have been hoisted"
 +        );
+     }
      #[test]
          let header = f.create_block("header");
          let i_param = f.next_value_id();
 -        f.block_mut(header).params.push(BlockParam { id: i_param, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: i_param,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let v = f.next_value_id();
          f.block_mut(header).insts.push(Inst {
              id: v,
          m.add_function(f);
 -        assert!(Licm.run(&mut m), "LICM should report that it hoisted the loop-invariant load");
 +        assert!(
 +            Licm.run(&mut m),
 +            "LICM should report that it hoisted the loop-invariant load"
 +        );
          // The Load must have moved out of the header — into the
          // preheader or the entry block (LICM hoists into the
              .insts
              .iter()
              .any(|i| matches!(i.kind, InstKind::Load(_)));
 -        assert!(!load_still_in_header, "invariant load should have left the header");
 +        assert!(
 +            !load_still_in_header,
 +            "invariant load should have left the header"
 +        );
          let load_somewhere_else = f
              .blocks
              .iter()
              .filter(|b| b.id != header)
              .flat_map(|b| b.insts.iter())
              .any(|i| matches!(i.kind, InstKind::Load(_)));
 -        assert!(load_somewhere_else, "invariant load should have been placed in a dominating block");
 +        assert!(
 +            load_somewhere_else,
 +            "invariant load should have been placed in a dominating block"
 +        );
+     }
      #[test]
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), params, IrType::Void);
 -        let init = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let limit = push(&mut f, InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let init = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let limit = push(
 +            &mut f,
 +            InstKind::ConstInt(10, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let header = f.create_block("header");
          let i_param = f.next_value_id();
          m.add_function(f);
 -        assert!(Licm.run(&mut m), "LICM should hoist the invariant dummy-arg load");
 +        assert!(
 +            Licm.run(&mut m),
 +            "LICM should hoist the invariant dummy-arg load"
 +        );
          let f = &m.functions[0];
          let entry_block = f.block(f.entry);
          let init = f.next_value_id();
          let entry = f.entry;
          f.block_mut(entry).insts.push(Inst {
 -            id: a, kind: InstKind::ConstInt(3, IntWidth::I32),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: a,
 +            kind: InstKind::ConstInt(3, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(entry).insts.push(Inst {
 -            id: bv, kind: InstKind::ConstInt(4, IntWidth::I32),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: bv,
 +            kind: InstKind::ConstInt(4, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(entry).insts.push(Inst {
 -            id: init, kind: InstKind::ConstInt(0, IntWidth::I32),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: init,
 +            kind: InstKind::ConstInt(0, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          // Header: i_param, then `prod = a * b` (invariant), then
          let header = f.create_block("header");
          let i_param = f.next_value_id();
          f.block_mut(header).params.push(BlockParam {
 -            id: i_param, ty: IrType::Int(IntWidth::I32),
 +            id: i_param,
 +            ty: IrType::Int(IntWidth::I32),
          });
          let prod = f.next_value_id();
          let tmp = f.next_value_id();
          let limit = f.next_value_id();
          let done = f.next_value_id();
          f.block_mut(header).insts.push(Inst {
 -            id: prod, kind: InstKind::IMul(a, bv),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: prod,
 +            kind: InstKind::IMul(a, bv),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(header).insts.push(Inst {
 -            id: tmp, kind: InstKind::IAdd(i_param, prod),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: tmp,
 +            kind: InstKind::IAdd(i_param, prod),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(header).insts.push(Inst {
 -            id: limit, kind: InstKind::ConstInt(10, IntWidth::I32),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: limit,
 +            kind: InstKind::ConstInt(10, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(header).insts.push(Inst {
 -            id: done, kind: InstKind::ICmp(CmpOp::Ge, i_param, limit),
 -            ty: IrType::Bool, span: dummy_span(),
 +            id: done,
 +            kind: InstKind::ICmp(CmpOp::Ge, i_param, limit),
 +            ty: IrType::Bool,
 +            span: dummy_span(),
          });
          // Latch: increment i and loop back.
          let latch = f.create_block("latch");
          let i_in = f.next_value_id();
          f.block_mut(latch).params.push(BlockParam {
 -            id: i_in, ty: IrType::Int(IntWidth::I32),
 +            id: i_in,
 +            ty: IrType::Int(IntWidth::I32),
          });
          let one = f.next_value_id();
          let next = f.next_value_id();
          f.block_mut(latch).insts.push(Inst {
 -            id: one, kind: InstKind::ConstInt(1, IntWidth::I32),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: one,
 +            kind: InstKind::ConstInt(1, IntWidth::I32),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(latch).insts.push(Inst {
 -            id: next, kind: InstKind::IAdd(i_in, one),
 -            ty: IrType::Int(IntWidth::I32), span: dummy_span(),
 +            id: next,
 +            kind: InstKind::IAdd(i_in, one),
 +            ty: IrType::Int(IntWidth::I32),
 +            span: dummy_span(),
          });
          f.block_mut(latch).terminator = Some(Terminator::Branch(header, vec![next]));
          f.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![init]));
          f.block_mut(header).terminator = Some(Terminator::CondBranch {
              cond: done,
 -            true_dest: exit, true_args: vec![],
 -            false_dest: latch, false_args: vec![i_param],
 +            true_dest: exit,
 +            true_args: vec![],
 +            false_dest: latch,
 +            false_args: vec![i_param],
          });
          m.add_function(f);
          // The IMul must have moved out of the header into the entry
          // (the natural preheader).
          let header_block = f.block(header);
 -        let imul_in_header = header_block.insts.iter()
 +        let imul_in_header = header_block
 +            .insts
 +            .iter()
              .any(|i| matches!(i.kind, InstKind::IMul(..)));
 -        assert!(!imul_in_header,
 +        assert!(
 +            !imul_in_header,
              "invariant IMul should be hoisted out of the header: {:?}",
 -            header_block.insts);
 +            header_block.insts
 +        );
          let entry_block = f.block(f.entry);
 -        let imul_in_entry = entry_block.insts.iter()
 +        let imul_in_entry = entry_block
 +            .insts
 +            .iter()
              .any(|i| matches!(i.kind, InstKind::IMul(..)));
 -        assert!(imul_in_entry,
 +        assert!(
 +            imul_in_entry,
              "invariant IMul should land in entry/preheader after hoist: {:?}",
 -            entry_block.insts);
 +            entry_block.insts
 +        );
          // The loop-dependent IAdd must NOT have moved.
 -        let iadd_in_header = header_block.insts.iter()
 +        let iadd_in_header = header_block
 +            .insts
 +            .iter()
              .any(|i| matches!(i.kind, InstKind::IAdd(_, _)));
 -        assert!(iadd_in_header,
 -            "loop-dependent IAdd(i_param, prod) should still be in the header");
 +        assert!(
 +            iadd_in_header,
 +            "loop-dependent IAdd(i_param, prod) should still be in the header"
 +        );
+     }
+ }

src/opt/loop_tree.rsmodified

368 lines changed — click to load

  //! parent, and children, so passes like interchange can find
  //! perfectly-nested pairs and unswitching can target innermost loops.
 -use std::collections::{HashMap, HashSet};
  use crate::ir::inst::{BlockId, Function};
  use crate::ir::walk::find_natural_loops;
 +use std::collections::{HashMap, HashSet};
  /// Unique identifier for a loop in the tree.
  #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  impl LoopTree {
      /// Return the IDs of all innermost (leaf) loops — loops with no children.
      pub fn innermost_loops(&self) -> Vec<LoopId> {
 -        self.nodes.iter()
 +        self.nodes
 +            .iter()
              .filter(|n| n.children.is_empty())
              .map(|n| n.id)
              .collect()
      /// Nesting depth of a block (0 if not in any loop).
      pub fn loop_depth(&self, block: BlockId) -> u32 {
 -        self.block_to_loop.get(&block)
 +        self.block_to_loop
 +            .get(&block)
              .map(|lid| self.node(*lid).depth)
              .unwrap_or(0)
+     }
      pub fn perfectly_nested_pairs(&self, func: &Function) -> Vec<(LoopId, LoopId)> {
          let mut pairs = Vec::new();
          for node in &self.nodes {
 -            if node.children.len() != 1 { continue; }
 +            if node.children.len() != 1 {
 +                continue;
 +            }
              let child_id = node.children[0];
              let child = self.node(child_id);
              // - the outer latch (increment + branch)
              // - the outer "body" block that just branches to the inner preheader
              // Everything else must be part of the inner loop.
 -            let outer_only: Vec<BlockId> = node.body.iter()
 +            let outer_only: Vec<BlockId> = node
 +                .body
 +                .iter()
                  .filter(|b| !child.body.contains(b))
                  .copied()
                  .collect();
              // Conservative check: outer-only blocks should have very few
              // instructions total (header relay + cmp + latch + body-entry).
 -            let total_outer_insts: usize = outer_only.iter()
 -                .map(|&b| func.block(b).insts.len())
 -                .sum();
 +            let total_outer_insts: usize =
 +                outer_only.iter().map(|&b| func.block(b).insts.len()).sum();
              // A typical Fortran DO nest has ~4-6 instructions in the
              // outer shell (const bound, icmp, iadd). Allow up to 10
      indexed.sort_by(|a, b| b.1.body.len().cmp(&a.1.body.len()));
      // Build nodes with stable IDs (original discovery order).
 -    let mut nodes: Vec<LoopTreeNode> = natural.iter().enumerate().map(|(i, nl)| {
 -        LoopTreeNode {
 +    let mut nodes: Vec<LoopTreeNode> = natural
 +        .iter()
 +        .enumerate()
 +        .map(|(i, nl)| LoopTreeNode {
              id: LoopId(i as u32),
              header: nl.header,
              body: nl.body.clone(),
              parent: None,
              children: Vec::new(),
              depth: 0,
 -        }
 -    }).collect();
 +        })
 +        .collect();
      // For each loop, find its parent = the smallest loop that strictly
      // contains it. We iterate in body-size order so we can check
          let mut best_parent: Option<LoopId> = None;
          let mut best_size = usize::MAX;
          for j in 0..n {
 -            if i == j { continue; }
 +            if i == j {
 +                continue;
 +            }
              // j is a candidate parent if j's body strictly contains i's body.
              if nodes[j].body.len() > nodes[i].body.len()
                  && nodes[i].body.is_subset(&nodes[j].body)
      // Sort children by header for determinism.
      // (Two-step to satisfy the borrow checker: collect sort keys, then sort.)
      for i in 0..n {
 -        let headers: Vec<(LoopId, u32)> = nodes[i].children.iter()
 +        let headers: Vec<(LoopId, u32)> = nodes[i]
 +            .children
 +            .iter()
              .map(|c| (*c, nodes[c.0 as usize].header.0))
              .collect();
          nodes[i].children.sort_by_key(|c| {
 -            headers.iter().find(|(id, _)| id == c).map(|(_, h)| *h).unwrap_or(0)
 +            headers
 +                .iter()
 +                .find(|(id, _)| id == c)
 +                .map(|(_, h)| *h)
 +                .unwrap_or(0)
          });
+     }
      // Build block → innermost loop mapping.
      // Process innermost (deepest) loops last so they overwrite parents.
      let mut block_to_loop: HashMap<BlockId, LoopId> = HashMap::new();
 -    let mut by_depth: Vec<(u32, LoopId)> = nodes.iter()
 -        .map(|n| (n.depth, n.id))
 -        .collect();
 +    let mut by_depth: Vec<(u32, LoopId)> = nodes.iter().map(|n| (n.depth, n.id)).collect();
      by_depth.sort_by_key(|(d, _)| *d);
      for (_, lid) in by_depth {
          for &block in &nodes[lid.0 as usize].body {
+         }
+     }
 -    LoopTree { nodes, block_to_loop }
 +    LoopTree {
 +        nodes,
 +        block_to_loop,
 +    }
+ }
  // ---------------------------------------------------------------------------
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
      use crate::ir::inst::*;
 -    use crate::lexer::{Span, Position};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      /// Build a function with 3-level nested DO loops:
          let mut f = Function::new("triple".into(), vec![], IrType::Void);
          // Create all blocks upfront.
 -        let outer_hdr   = f.create_block("outer_hdr");
 -        let outer_cmp   = f.create_block("outer_cmp");
 -        let inner_hdr   = f.create_block("inner_hdr");
 -        let inner_cmp   = f.create_block("inner_cmp");
 -        let deep_hdr    = f.create_block("deep_hdr");
 -        let deep_cmp    = f.create_block("deep_cmp");
 -        let body        = f.create_block("body");
 -        let deep_latch  = f.create_block("deep_latch");
 +        let outer_hdr = f.create_block("outer_hdr");
 +        let outer_cmp = f.create_block("outer_cmp");
 +        let inner_hdr = f.create_block("inner_hdr");
 +        let inner_cmp = f.create_block("inner_cmp");
 +        let deep_hdr = f.create_block("deep_hdr");
 +        let deep_cmp = f.create_block("deep_cmp");
 +        let body = f.create_block("body");
 +        let deep_latch = f.create_block("deep_latch");
          let inner_latch = f.create_block("inner_latch");
          let outer_latch = f.create_block("outer_latch");
 -        let exit        = f.create_block("exit");
 +        let exit = f.create_block("exit");
          let entry = f.entry;
          let one = f.next_value_id();
          f.register_type(one, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: one, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: one,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          f.block_mut(entry).terminator = Some(Terminator::Branch(outer_hdr, vec![one]));
          // Helper: add a simple loop level (header with param → cmp → condBr)
          fn add_loop_level(
 -            f: &mut Function, hdr: BlockId, cmp: BlockId,
 -            body_target: BlockId, exit_target: BlockId,
 -            latch: BlockId, init_src: ValueId,
 +            f: &mut Function,
 +            hdr: BlockId,
 +            cmp: BlockId,
 +            body_target: BlockId,
 +            exit_target: BlockId,
 +            latch: BlockId,
 +            init_src: ValueId,
          ) -> (ValueId, ValueId) {
              // Header: block param
              let iv = f.next_value_id();
              f.register_type(iv, IrType::Int(IntWidth::I32));
 -            f.block_mut(hdr).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +            f.block_mut(hdr).params.push(BlockParam {
 +                id: iv,
 +                ty: IrType::Int(IntWidth::I32),
 +            });
              f.block_mut(hdr).terminator = Some(Terminator::Branch(cmp, vec![]));
              // Cmp: icmp le iv, 10; condBr body, exit
              let bound = f.next_value_id();
              f.register_type(bound, IrType::Int(IntWidth::I32));
              f.block_mut(cmp).insts.push(Inst {
 -                id: bound, ty: IrType::Int(IntWidth::I32), span: span(),
 +                id: bound,
 +                ty: IrType::Int(IntWidth::I32),
 +                span: span(),
                  kind: InstKind::ConstInt(10, IntWidth::I32),
              });
              let cmp_val = f.next_value_id();
              f.register_type(cmp_val, IrType::Bool);
              f.block_mut(cmp).insts.push(Inst {
 -                id: cmp_val, ty: IrType::Bool, span: span(),
 +                id: cmp_val,
 +                ty: IrType::Bool,
 +                span: span(),
                  kind: InstKind::ICmp(CmpOp::Le, iv, bound),
              });
              f.block_mut(cmp).terminator = Some(Terminator::CondBranch {
                  cond: cmp_val,
 -                true_dest: body_target, true_args: vec![],
 -                false_dest: exit_target, false_args: vec![],
 +                true_dest: body_target,
 +                true_args: vec![],
 +                false_dest: exit_target,
 +                false_args: vec![],
              });
              // Latch: iadd iv, 1; br hdr(next)
              let one_l = f.next_value_id();
              f.register_type(one_l, IrType::Int(IntWidth::I32));
              f.block_mut(latch).insts.push(Inst {
 -                id: one_l, ty: IrType::Int(IntWidth::I32), span: span(),
 +                id: one_l,
 +                ty: IrType::Int(IntWidth::I32),
 +                span: span(),
                  kind: InstKind::ConstInt(1, IntWidth::I32),
              });
              let next = f.next_value_id();
              f.register_type(next, IrType::Int(IntWidth::I32));
              f.block_mut(latch).insts.push(Inst {
 -                id: next, ty: IrType::Int(IntWidth::I32), span: span(),
 +                id: next,
 +                ty: IrType::Int(IntWidth::I32),
 +                span: span(),
                  kind: InstKind::IAdd(iv, one_l),
              });
              f.block_mut(latch).terminator = Some(Terminator::Branch(hdr, vec![next]));
+         }
          // Outer loop: entry→outer_hdr(1)→outer_cmp→inner_hdr/exit
 -        let (_, _) = add_loop_level(&mut f, outer_hdr, outer_cmp, inner_hdr, exit, outer_latch, one);
 +        let (_, _) = add_loop_level(
 +            &mut f,
 +            outer_hdr,
 +            outer_cmp,
 +            inner_hdr,
 +            exit,
 +            outer_latch,
 +            one,
 +        );
          // Wire outer_cmp's true branch to pass `one` to inner_hdr
          // (inner loop starts at 1 each outer iteration)
 -        if let Some(Terminator::CondBranch { true_args, .. }) = &mut f.block_mut(outer_cmp).terminator {
 +        if let Some(Terminator::CondBranch { true_args, .. }) =
 +            &mut f.block_mut(outer_cmp).terminator
 +        {
              true_args.push(one);
+         }
          // Inner loop
 -        let (_, _) = add_loop_level(&mut f, inner_hdr, inner_cmp, deep_hdr, inner_latch, inner_latch, one);
 +        let (_, _) = add_loop_level(
 +            &mut f,
 +            inner_hdr,
 +            inner_cmp,
 +            deep_hdr,
 +            inner_latch,
 +            inner_latch,
 +            one,
 +        );
          // Inner latch needs to go to outer_latch after the inner loop exits...
          // Actually inner_latch IS the inner latch (iadd + br inner_hdr). The exit
          // of the inner loop goes to outer_latch. Let me fix: inner_cmp's false goes to outer_latch.
          let c1 = f.next_value_id();
          f.register_type(c1, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c1, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c1,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let c10 = f.next_value_id();
          f.register_type(c10, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c10, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c10,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(10, IntWidth::I32),
          });
          f.block_mut(entry).terminator = Some(Terminator::Branch(outer_hdr, vec![c1]));
              ($f:expr, $hdr:expr, $cmp:expr) => {{
                  let iv = $f.next_value_id();
                  $f.register_type(iv, IrType::Int(IntWidth::I32));
 -                $f.block_mut($hdr).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +                $f.block_mut($hdr).params.push(BlockParam {
 +                    id: iv,
 +                    ty: IrType::Int(IntWidth::I32),
 +                });
                  $f.block_mut($hdr).terminator = Some(Terminator::Branch($cmp, vec![]));
                  iv
              }};
                  let cv = $f.next_value_id();
                  $f.register_type(cv, IrType::Bool);
                  $f.block_mut($cmp).insts.push(Inst {
 -                    id: cv, ty: IrType::Bool, span: span(),
 +                    id: cv,
 +                    ty: IrType::Bool,
 +                    span: span(),
                      kind: InstKind::ICmp(CmpOp::Le, $iv, $bound),
                  });
                  $f.block_mut($cmp).terminator = Some(Terminator::CondBranch {
 -                    cond: cv, true_dest: $t, true_args: $t_args,
 -                    false_dest: $fal, false_args: vec![],
 +                    cond: cv,
 +                    true_dest: $t,
 +                    true_args: $t_args,
 +                    false_dest: $fal,
 +                    false_args: vec![],
                  });
              }};
+         }
                  let nxt = $f.next_value_id();
                  $f.register_type(nxt, IrType::Int(IntWidth::I32));
                  $f.block_mut($latch).insts.push(Inst {
 -                    id: nxt, ty: IrType::Int(IntWidth::I32), span: span(),
 +                    id: nxt,
 +                    ty: IrType::Int(IntWidth::I32),
 +                    span: span(),
                      kind: InstKind::IAdd($iv, $one),
                  });
                  $f.block_mut($latch).terminator = Some(Terminator::Branch($hdr, vec![nxt]));
          let tree = build_loop_tree(&f);
          // The body block should map to the innermost loop.
 -        let body_block = f.blocks.iter().find(|b| b.name.starts_with("body")).unwrap();
 +        let body_block = f
 +            .blocks
 +            .iter()
 +            .find(|b| b.name.starts_with("body"))
 +            .unwrap();
          let mapped = tree.block_to_loop.get(&body_block.id);
          assert!(mapped.is_some(), "body block should be in a loop");
          let mapped_node = tree.node(*mapped.unwrap());

src/opt/loop_utils.rsmodified

191 lines changed — click to load

  //! (from unroll.rs) into public shared functions so all loop passes
  //! use the same logic.
 -use std::collections::{HashMap, HashSet};
  use crate::ir::inst::*;
  use crate::ir::walk::NaturalLoop;
 +use std::collections::{HashMap, HashSet};
  /// Find the unique preheader for a natural loop, if one exists.
  ///
          .collect();
      outside.sort_by_key(|b| b.0);
      outside.dedup();
 -    if outside.len() != 1 { return None; }
 +    if outside.len() != 1 {
 +        return None;
 +    }
      let ph = outside[0];
 -    if ph == lp.header { return None; }
 +    if ph == lp.header {
 +        return None;
 +    }
      let ph_block = func.block(ph);
      match &ph_block.terminator {
          Some(Terminator::Branch(dest, _)) if *dest == lp.header => Some(ph),
      let mut defs = HashSet::new();
      for &bid in &lp.body {
          let block = func.block(bid);
 -        for bp in &block.params { defs.insert(bp.id); }
 -        for inst in &block.insts { defs.insert(inst.id); }
 +        for bp in &block.params {
 +            defs.insert(bp.id);
 +        }
 +        for inst in &block.insts {
 +            defs.insert(inst.id);
 +        }
+     }
      defs
+ }
  pub fn remap_inst_kind(kind: &InstKind, map: &HashMap<ValueId, ValueId>) -> InstKind {
      let r = |v: &ValueId| *map.get(v).unwrap_or(v);
      match kind {
 -        InstKind::ConstInt(v, w)     => InstKind::ConstInt(*v, *w),
 -        InstKind::ConstFloat(v, w)   => InstKind::ConstFloat(*v, *w),
 -        InstKind::ConstBool(v)       => InstKind::ConstBool(*v),
 -        InstKind::ConstString(v)     => InstKind::ConstString(v.clone()),
 -        InstKind::Undef(t)           => InstKind::Undef(t.clone()),
 -        InstKind::GlobalAddr(s)      => InstKind::GlobalAddr(s.clone()),
 -        InstKind::IAdd(a, b)  => InstKind::IAdd(r(a), r(b)),
 -        InstKind::ISub(a, b)  => InstKind::ISub(r(a), r(b)),
 -        InstKind::IMul(a, b)  => InstKind::IMul(r(a), r(b)),
 -        InstKind::IDiv(a, b)  => InstKind::IDiv(r(a), r(b)),
 -        InstKind::IMod(a, b)  => InstKind::IMod(r(a), r(b)),
 -        InstKind::INeg(a)     => InstKind::INeg(r(a)),
 -        InstKind::FAdd(a, b)  => InstKind::FAdd(r(a), r(b)),
 -        InstKind::FSub(a, b)  => InstKind::FSub(r(a), r(b)),
 -        InstKind::FMul(a, b)  => InstKind::FMul(r(a), r(b)),
 -        InstKind::FDiv(a, b)  => InstKind::FDiv(r(a), r(b)),
 -        InstKind::FNeg(a)     => InstKind::FNeg(r(a)),
 -        InstKind::FAbs(a)     => InstKind::FAbs(r(a)),
 -        InstKind::FSqrt(a)    => InstKind::FSqrt(r(a)),
 -        InstKind::FPow(a, b)  => InstKind::FPow(r(a), r(b)),
 +        InstKind::ConstInt(v, w) => InstKind::ConstInt(*v, *w),
 +        InstKind::ConstFloat(v, w) => InstKind::ConstFloat(*v, *w),
 +        InstKind::ConstBool(v) => InstKind::ConstBool(*v),
 +        InstKind::ConstString(v) => InstKind::ConstString(v.clone()),
 +        InstKind::Undef(t) => InstKind::Undef(t.clone()),
 +        InstKind::GlobalAddr(s) => InstKind::GlobalAddr(s.clone()),
 +        InstKind::IAdd(a, b) => InstKind::IAdd(r(a), r(b)),
 +        InstKind::ISub(a, b) => InstKind::ISub(r(a), r(b)),
 +        InstKind::IMul(a, b) => InstKind::IMul(r(a), r(b)),
 +        InstKind::IDiv(a, b) => InstKind::IDiv(r(a), r(b)),
 +        InstKind::IMod(a, b) => InstKind::IMod(r(a), r(b)),
 +        InstKind::INeg(a) => InstKind::INeg(r(a)),
 +        InstKind::FAdd(a, b) => InstKind::FAdd(r(a), r(b)),
 +        InstKind::FSub(a, b) => InstKind::FSub(r(a), r(b)),
 +        InstKind::FMul(a, b) => InstKind::FMul(r(a), r(b)),
 +        InstKind::FDiv(a, b) => InstKind::FDiv(r(a), r(b)),
 +        InstKind::FNeg(a) => InstKind::FNeg(r(a)),
 +        InstKind::FAbs(a) => InstKind::FAbs(r(a)),
 +        InstKind::FSqrt(a) => InstKind::FSqrt(r(a)),
 +        InstKind::FPow(a, b) => InstKind::FPow(r(a), r(b)),
          InstKind::ICmp(op, a, b) => InstKind::ICmp(*op, r(a), r(b)),
          InstKind::FCmp(op, a, b) => InstKind::FCmp(*op, r(a), r(b)),
          InstKind::And(a, b) => InstKind::And(r(a), r(b)),
 -        InstKind::Or(a, b)  => InstKind::Or(r(a), r(b)),
 -        InstKind::Not(a)    => InstKind::Not(r(a)),
 +        InstKind::Or(a, b) => InstKind::Or(r(a), r(b)),
 +        InstKind::Not(a) => InstKind::Not(r(a)),
          InstKind::Select(c, t, f) => InstKind::Select(r(c), r(t), r(f)),
 -        InstKind::BitAnd(a, b)           => InstKind::BitAnd(r(a), r(b)),
 -        InstKind::BitOr(a, b)            => InstKind::BitOr(r(a), r(b)),
 -        InstKind::BitXor(a, b)           => InstKind::BitXor(r(a), r(b)),
 -        InstKind::BitNot(a)              => InstKind::BitNot(r(a)),
 -        InstKind::Shl(a, b)              => InstKind::Shl(r(a), r(b)),
 -        InstKind::LShr(a, b)             => InstKind::LShr(r(a), r(b)),
 -        InstKind::AShr(a, b)             => InstKind::AShr(r(a), r(b)),
 -        InstKind::CountLeadingZeros(a)   => InstKind::CountLeadingZeros(r(a)),
 -        InstKind::CountTrailingZeros(a)  => InstKind::CountTrailingZeros(r(a)),
 -        InstKind::PopCount(a)            => InstKind::PopCount(r(a)),
 -        InstKind::IntToFloat(a, w)    => InstKind::IntToFloat(r(a), *w),
 -        InstKind::FloatToInt(a, w)    => InstKind::FloatToInt(r(a), *w),
 -        InstKind::FloatExtend(a, w)   => InstKind::FloatExtend(r(a), *w),
 -        InstKind::FloatTrunc(a, w)    => InstKind::FloatTrunc(r(a), *w),
 -        InstKind::IntExtend(a, w, s)  => InstKind::IntExtend(r(a), *w, *s),
 -        InstKind::IntTrunc(a, w)      => InstKind::IntTrunc(r(a), *w),
 -        InstKind::PtrToInt(a)         => InstKind::PtrToInt(r(a)),
 -        InstKind::IntToPtr(a, ty)     => InstKind::IntToPtr(r(a), ty.clone()),
 -        InstKind::Alloca(t)  => InstKind::Alloca(t.clone()),
 -        InstKind::Load(a)    => InstKind::Load(r(a)),
 +        InstKind::BitAnd(a, b) => InstKind::BitAnd(r(a), r(b)),
 +        InstKind::BitOr(a, b) => InstKind::BitOr(r(a), r(b)),
 +        InstKind::BitXor(a, b) => InstKind::BitXor(r(a), r(b)),
 +        InstKind::BitNot(a) => InstKind::BitNot(r(a)),
 +        InstKind::Shl(a, b) => InstKind::Shl(r(a), r(b)),
 +        InstKind::LShr(a, b) => InstKind::LShr(r(a), r(b)),
 +        InstKind::AShr(a, b) => InstKind::AShr(r(a), r(b)),
 +        InstKind::CountLeadingZeros(a) => InstKind::CountLeadingZeros(r(a)),
 +        InstKind::CountTrailingZeros(a) => InstKind::CountTrailingZeros(r(a)),
 +        InstKind::PopCount(a) => InstKind::PopCount(r(a)),
 +        InstKind::IntToFloat(a, w) => InstKind::IntToFloat(r(a), *w),
 +        InstKind::FloatToInt(a, w) => InstKind::FloatToInt(r(a), *w),
 +        InstKind::FloatExtend(a, w) => InstKind::FloatExtend(r(a), *w),
 +        InstKind::FloatTrunc(a, w) => InstKind::FloatTrunc(r(a), *w),
 +        InstKind::IntExtend(a, w, s) => InstKind::IntExtend(r(a), *w, *s),
 +        InstKind::IntTrunc(a, w) => InstKind::IntTrunc(r(a), *w),
 +        InstKind::PtrToInt(a) => InstKind::PtrToInt(r(a)),
 +        InstKind::IntToPtr(a, ty) => InstKind::IntToPtr(r(a), ty.clone()),
 +        InstKind::Alloca(t) => InstKind::Alloca(t.clone()),
 +        InstKind::Load(a) => InstKind::Load(r(a)),
          InstKind::Store(v, p) => InstKind::Store(r(v), r(p)),
 -        InstKind::GetElementPtr(base, idxs) =>
 -            InstKind::GetElementPtr(r(base), idxs.iter().map(&r).collect()),
 -        InstKind::Call(f, args) =>
 -            InstKind::Call(f.clone(), args.iter().map(&r).collect()),
 -        InstKind::RuntimeCall(f, args) =>
 -            InstKind::RuntimeCall(f.clone(), args.iter().map(&r).collect()),
 -        InstKind::ExtractField(v, idx)     => InstKind::ExtractField(r(v), *idx),
 +        InstKind::GetElementPtr(base, idxs) => {
 +            InstKind::GetElementPtr(r(base), idxs.iter().map(&r).collect())
 +        }
 +        InstKind::Call(f, args) => InstKind::Call(f.clone(), args.iter().map(&r).collect()),
 +        InstKind::RuntimeCall(f, args) => {
 +            InstKind::RuntimeCall(f.clone(), args.iter().map(&r).collect())
 +        }
 +        InstKind::ExtractField(v, idx) => InstKind::ExtractField(r(v), *idx),
          InstKind::InsertField(v, idx, fld) => InstKind::InsertField(r(v), *idx, r(fld)),
+     }
+ }
      match term {
          Terminator::Return(v) => Terminator::Return(v.map(|x| rv(&x))),
          Terminator::Branch(dest, args) => Terminator::Branch(rb(dest), rvs(args)),
 -        Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args } =>
 -            Terminator::CondBranch {
 -                cond: rv(cond),
 -                true_dest: rb(true_dest),
 -                true_args: rvs(true_args),
 -                false_dest: rb(false_dest),
 -                false_args: rvs(false_args),
 -            },
 -        Terminator::Switch { selector, default, cases } =>
 -            Terminator::Switch {
 -                selector: rv(selector),
 -                default: rb(default),
 -                cases: cases.iter().map(|(v, d)| (*v, rb(d))).collect(),
 -            },
 +        Terminator::CondBranch {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        } => Terminator::CondBranch {
 +            cond: rv(cond),
 +            true_dest: rb(true_dest),
 +            true_args: rvs(true_args),
 +            false_dest: rb(false_dest),
 +            false_args: rvs(false_args),
 +        },
 +        Terminator::Switch {
 +            selector,
 +            default,
 +            cases,
 +        } => Terminator::Switch {
 +            selector: rv(selector),
 +            default: rb(default),
 +            cases: cases.iter().map(|(v, d)| (*v, rb(d))).collect(),
 +        },
          Terminator::Unreachable => Terminator::Unreachable,
+     }
+ }

src/opt/lsf.rsmodified

475 lines changed — click to load

  //! %x = iadd %42, %1
  //! ```
 +use super::alias::{self, may_reach_through_call_arg, AliasResult};
  use super::pass::Pass;
 -use super::alias::{self, AliasResult, may_reach_through_call_arg};
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  use crate::ir::walk::{for_each_operand_mut, for_each_terminator_operand_mut};
  pub struct LocalLsf;
  impl Pass for LocalLsf {
 -    fn name(&self) -> &'static str { "load-store-fwd" }
 +    fn name(&self) -> &'static str {
 +        "load-store-fwd"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
                      available.retain(|entry| {
                          matches!(alias::query(func, entry.ptr, eff_ptr), AliasResult::NoAlias)
                      });
 -                    available.push(AvailableStore { ptr: eff_ptr, val: eff_val });
 +                    available.push(AvailableStore {
 +                        ptr: eff_ptr,
 +                        val: eff_val,
 +                    });
+                 }
                  InstKind::Load(ptr) => {
                      let eff_ptr = resolve(&all_rewrites, *ptr);
                      if let Some(entry) = available.iter().rev().find(|entry| {
 -                        matches!(alias::query(func, entry.ptr, eff_ptr), AliasResult::MustAlias)
 +                        matches!(
 +                            alias::query(func, entry.ptr, eff_ptr),
 +                            AliasResult::MustAlias
 +                        )
                      }) {
                          all_rewrites.insert(inst.id, entry.val);
                          changed = true;
                          // so a precise "different GEP offset →
                          // NoAlias" answer is unsound here.
                          available.retain(|entry| {
 -                            pointer_args.iter().all(|arg| {
 -                                !may_reach_through_call_arg(func, entry.ptr, *arg)
 -                            })
 +                            pointer_args
 +                                .iter()
 +                                .all(|arg| !may_reach_through_call_arg(func, entry.ptr, *arg))
                          });
+                     }
+                 }
      while let Some(&next) = rewrites.get(&v) {
          v = next;
          steps += 1;
 -        if steps > 64 { break; } // cycle guard (SSA has none, but be safe)
 +        if steps > 64 {
 +            break;
 +        } // cycle guard (SSA has none, but be safe)
+     }
+     v
+ }
      if matches!(func.value_type(value), Some(IrType::Ptr(_))) {
          return true;
+     }
 -    if func.params.iter().any(|param| param.id == value && matches!(param.ty, IrType::Ptr(_))) {
 +    if func
 +        .params
 +        .iter()
 +        .any(|param| param.id == value && matches!(param.ty, IrType::Ptr(_)))
 +    {
          return true;
+     }
 -    func.blocks.iter().flat_map(|block| block.insts.iter()).find(|inst| inst.id == value)
 +    func.blocks
 +        .iter()
 +        .flat_map(|block| block.insts.iter())
 +        .find(|inst| inst.id == value)
          .map(|inst| matches!(inst.ty, IrType::Ptr(_)))
          .unwrap_or(false)
+ }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 -    use crate::opt::pass::Pass;
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::lexer::{Position, Span};
 +    use crate::opt::pass::Pass;
      fn dummy_span() -> Span {
          let p = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: p, end: p }
 +        Span {
 +            file_id: 0,
 +            start: p,
 +            end: p,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
          let mut m = Module::new("test".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let alloca = push(&mut f, InstKind::Alloca(IrType::Int(IntWidth::I32)),
 -                          IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let val42  = push(&mut f, InstKind::ConstInt(42, IntWidth::I32),
 -                          IrType::Int(IntWidth::I32));
 -        let one    = push(&mut f, InstKind::ConstInt(1, IntWidth::I32),
 -                          IrType::Int(IntWidth::I32));
 +        let alloca = push(
 +            &mut f,
 +            InstKind::Alloca(IrType::Int(IntWidth::I32)),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let val42 = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let one = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(val42, alloca), IrType::Void);
 -        let load   = push(&mut f, InstKind::Load(alloca), IrType::Int(IntWidth::I32));
 -        let add    = push(&mut f, InstKind::IAdd(load, one), IrType::Int(IntWidth::I32));
 -        let entry  = f.entry;
 +        let load = push(&mut f, InstKind::Load(alloca), IrType::Int(IntWidth::I32));
 +        let add = push(
 +            &mut f,
 +            InstKind::IAdd(load, one),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(add)));
          m.add_function(f);
          let add_inst = insts.iter().find(|i| i.id == add).unwrap();
          assert!(
              matches!(&add_inst.kind, InstKind::IAdd(a, _) if *a == val42),
 -            "IAdd operand should be forwarded to val42, got {:?}", add_inst.kind
 +            "IAdd operand should be forwarded to val42, got {:?}",
 +            add_inst.kind
          );
+     }
          let mut m = Module::new("test".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let alloca = push(&mut f, InstKind::Alloca(IrType::Int(IntWidth::I32)),
 -                          IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let v42 = push(&mut f, InstKind::ConstInt(42, IntWidth::I32),
 -                       IrType::Int(IntWidth::I32));
 -        let v99 = push(&mut f, InstKind::ConstInt(99, IntWidth::I32),
 -                       IrType::Int(IntWidth::I32));
 +        let alloca = push(
 +            &mut f,
 +            InstKind::Alloca(IrType::Int(IntWidth::I32)),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let v42 = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let v99 = push(
 +            &mut f,
 +            InstKind::ConstInt(99, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v42, alloca), IrType::Void);
          push(&mut f, InstKind::Store(v99, alloca), IrType::Void);
          let load = push(&mut f, InstKind::Load(alloca), IrType::Int(IntWidth::I32));
          let term = func.block(func.entry).terminator.as_ref().unwrap();
          assert!(
              matches!(term, Terminator::Return(Some(v)) if *v == v99),
 -            "Return should use v99 (the latest store), got {:?}", term
 +            "Return should use v99 (the latest store), got {:?}",
 +            term
          );
+     }
          let mut m = Module::new("test".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let alloca = push(&mut f, InstKind::Alloca(IrType::Int(IntWidth::I32)),
 -                          IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let v42 = push(&mut f, InstKind::ConstInt(42, IntWidth::I32),
 -                       IrType::Int(IntWidth::I32));
 +        let alloca = push(
 +            &mut f,
 +            InstKind::Alloca(IrType::Int(IntWidth::I32)),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let v42 = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v42, alloca), IrType::Void);
          // A call that might write to the alloca.
 -        push(&mut f, InstKind::Call(
 -            FuncRef::External("ext".into()), vec![alloca]
 -        ), IrType::Void);
 +        push(
 +            &mut f,
 +            InstKind::Call(FuncRef::External("ext".into()), vec![alloca]),
 +            IrType::Void,
 +        );
          let load = push(&mut f, InstKind::Load(alloca), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(load)));
          let mut m = Module::new("test".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
 -        let alloca = push(&mut f, InstKind::Alloca(IrType::Int(IntWidth::I32)),
 -                          IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 +        let alloca = push(
 +            &mut f,
 +            InstKind::Alloca(IrType::Int(IntWidth::I32)),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
          let load = push(&mut f, InstKind::Load(alloca), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(load)));
          let arr_ty = IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 4);
          let arr_ptr_ty = IrType::Ptr(Box::new(arr_ty.clone()));
          let ptr = push(&mut f, InstKind::Alloca(arr_ty), arr_ptr_ty);
 -        let zero0 = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let zero1 = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let zero0 = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let zero1 = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let gep0 = push(
              &mut f,
              InstKind::GetElementPtr(ptr, vec![zero0]),
              InstKind::GetElementPtr(ptr, vec![zero1]),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))),
          );
 -        let v42 = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let v42 = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v42, gep0), IrType::Void);
          let load = push(&mut f, InstKind::Load(gep1), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(load)));
          m.add_function(f);
 -        assert!(LocalLsf.run(&mut m), "LSF should forward across must-alias GEPs");
 -        let term = m.functions[0].block(m.functions[0].entry).terminator.as_ref().unwrap();
 +        assert!(
 +            LocalLsf.run(&mut m),
 +            "LSF should forward across must-alias GEPs"
 +        );
 +        let term = m.functions[0]
 +            .block(m.functions[0].entry)
 +            .terminator
 +            .as_ref()
 +            .unwrap();
          assert!(
              matches!(term, Terminator::Return(Some(v)) if *v == v42),
              "return should use the stored value after forwarding, got {:?}",
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let arr_ty = IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 2);
 -        let alloca = push(&mut f, InstKind::Alloca(arr_ty.clone()),
 -                          IrType::Ptr(Box::new(arr_ty)));
 -        let c0 = push(&mut f, InstKind::ConstInt(0, IntWidth::I64), IrType::Int(IntWidth::I64));
 -        let c1 = push(&mut f, InstKind::ConstInt(1, IntWidth::I64), IrType::Int(IntWidth::I64));
 -        let g0 = push(&mut f, InstKind::GetElementPtr(alloca, vec![c0]),
 -                      IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let g1 = push(&mut f, InstKind::GetElementPtr(alloca, vec![c1]),
 -                      IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let v20 = push(&mut f, InstKind::ConstInt(20, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let alloca = push(
 +            &mut f,
 +            InstKind::Alloca(arr_ty.clone()),
 +            IrType::Ptr(Box::new(arr_ty)),
 +        );
 +        let c0 = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I64),
 +            IrType::Int(IntWidth::I64),
 +        );
 +        let c1 = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I64),
 +            IrType::Int(IntWidth::I64),
 +        );
 +        let g0 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(alloca, vec![c0]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let g1 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(alloca, vec![c1]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let v20 = push(
 +            &mut f,
 +            InstKind::ConstInt(20, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v20, g1), IrType::Void);
 -        push(&mut f, InstKind::Call(FuncRef::External("touch".into()), vec![g0]), IrType::Void);
 +        push(
 +            &mut f,
 +            InstKind::Call(FuncRef::External("touch".into()), vec![g0]),
 +            IrType::Void,
 +        );
          let load = push(&mut f, InstKind::Load(g1), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(load)));
          m.add_function(f);
          LocalLsf.run(&mut m);
 -        let term = m.functions[0].block(m.functions[0].entry).terminator.as_ref().unwrap();
 +        let term = m.functions[0]
 +            .block(m.functions[0].entry)
 +            .terminator
 +            .as_ref()
 +            .unwrap();
          if let Terminator::Return(Some(v)) = term {
              assert_ne!(*v, v20, "LSF forwarded arr[1] load to the caller's pre-call constant across a call that received arr[0]; callee could have walked to arr[1]");
          } else {
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let arr_ty = IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 2);
 -        let alloca = push(&mut f, InstKind::Alloca(arr_ty.clone()),
 -                          IrType::Ptr(Box::new(arr_ty)));
 -        let c0 = push(&mut f, InstKind::ConstInt(0, IntWidth::I64), IrType::Int(IntWidth::I64));
 -        let c1 = push(&mut f, InstKind::ConstInt(1, IntWidth::I64), IrType::Int(IntWidth::I64));
 -        let g0 = push(&mut f, InstKind::GetElementPtr(alloca, vec![c0]),
 -                      IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let g1 = push(&mut f, InstKind::GetElementPtr(alloca, vec![c1]),
 -                      IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
+-
 -        let v20 = push(&mut f, InstKind::ConstInt(20, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let alloca = push(
 +            &mut f,
 +            InstKind::Alloca(arr_ty.clone()),
 +            IrType::Ptr(Box::new(arr_ty)),
 +        );
 +        let c0 = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I64),
 +            IrType::Int(IntWidth::I64),
 +        );
 +        let c1 = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I64),
 +            IrType::Int(IntWidth::I64),
 +        );
 +        let g0 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(alloca, vec![c0]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let g1 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(alloca, vec![c1]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
++
 +        let v20 = push(
 +            &mut f,
 +            InstKind::ConstInt(20, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v20, g1), IrType::Void);
 -        let chain0 = push(&mut f, InstKind::GetElementPtr(g0, vec![c0]),
 -                          IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let v11 = push(&mut f, InstKind::ConstInt(11, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let chain0 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(g0, vec![c0]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let v11 = push(
 +            &mut f,
 +            InstKind::ConstInt(11, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v11, chain0), IrType::Void);
 -        let chain1 = push(&mut f, InstKind::GetElementPtr(g0, vec![c1]),
 -                          IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let v31 = push(&mut f, InstKind::ConstInt(31, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let chain1 = push(
 +            &mut f,
 +            InstKind::GetElementPtr(g0, vec![c1]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let v31 = push(
 +            &mut f,
 +            InstKind::ConstInt(31, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v31, chain1), IrType::Void);
          let load = push(&mut f, InstKind::Load(g1), IrType::Int(IntWidth::I32));
          m.add_function(f);
          LocalLsf.run(&mut m);
 -        let term = m.functions[0].block(m.functions[0].entry).terminator.as_ref().unwrap();
 +        let term = m.functions[0]
 +            .block(m.functions[0].entry)
 +            .terminator
 +            .as_ref()
 +            .unwrap();
          // The load must either remain or be forwarded to v31 — never
          // to v20.
          if let Terminator::Return(Some(v)) = term {
              IrType::Int(IntWidth::I32),
          );
 -        let v42 = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let v42 = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push(&mut f, InstKind::Store(v42, ValueId(0)), IrType::Void);
          push(
              &mut f,
              InstKind::Call(FuncRef::External("touch".into()), vec![ValueId(1)]),
              IrType::Void,
          );
 -        let load = push(&mut f, InstKind::Load(ValueId(0)), IrType::Int(IntWidth::I32));
 +        let load = push(
 +            &mut f,
 +            InstKind::Load(ValueId(0)),
 +            IrType::Int(IntWidth::I32),
 +        );
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(load)));
          m.add_function(f);
              LocalLsf.run(&mut m),
              "LSF should preserve the stored value across a noalias pointer call"
          );
 -        let term = m.functions[0].block(m.functions[0].entry).terminator.as_ref().unwrap();
 +        let term = m.functions[0]
 +            .block(m.functions[0].entry)
 +            .terminator
 +            .as_ref()
 +            .unwrap();
          assert!(
              matches!(term, Terminator::Return(Some(v)) if *v == v42),
              "return should use the forwarded value across the noalias call, got {:?}",

src/opt/mem2reg.rsmodified

1711 lines changed — click to load

  use super::pass::Pass;
  use super::util::{
 -    compute_dominance_frontiers,
 -    compute_immediate_dominators,
 -    dominator_tree_children,
 -    prune_unreachable,
 -    substitute_uses,
 +    compute_dominance_frontiers, compute_immediate_dominators, dominator_tree_children,
 +    prune_unreachable, substitute_uses,
  };
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  pub struct Mem2Reg;
  impl Pass for Mem2Reg {
 -    fn name(&self) -> &'static str { "mem2reg" }
 +    fn name(&self) -> &'static str {
 +        "mem2reg"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
      // ---- Phase 1: find promotable allocas -------------------------
      let promotable = find_promotable_allocas(func);
 -    if promotable.is_empty() { return pruned; }
 +    if promotable.is_empty() {
 +        return pruned;
 +    }
      // Map from alloca ValueId → index into `promotable`. We use the
      // index as a compact key throughout the rest of the pass.
 -    let alloca_index: HashMap<ValueId, usize> = promotable.iter()
 +    let alloca_index: HashMap<ValueId, usize> = promotable
 +        .iter()
          .enumerate()
          .map(|(i, p)| (p.alloca_id, i))
          .collect();
      let mut undef_values: Vec<ValueId> = Vec::with_capacity(promotable.len());
      // Grab a dummy span we can reuse for inserted insts.
 -    let span = func.block(func.entry).insts.first()
 +    let span = func
 +        .block(func.entry)
 +        .insts
 +        .first()
          .map(|i| i.span)
          .or_else(|| {
              func.block(func.entry).terminator.as_ref().map(|_t| {
                  // zero span — good enough for synthesized insts.
                  crate::lexer::Span {
                      start: crate::lexer::Position { line: 0, col: 0 },
 -                    end:   crate::lexer::Position { line: 0, col: 0 },
 +                    end: crate::lexer::Position { line: 0, col: 0 },
                      file_id: 0,
+                 }
              })
          })
          .unwrap_or(crate::lexer::Span {
              start: crate::lexer::Position { line: 0, col: 0 },
 -            end:   crate::lexer::Position { line: 0, col: 0 },
 +            end: crate::lexer::Position { line: 0, col: 0 },
              file_id: 0,
          });
          new_undefs.push((id, p.pointee_ty.clone()));
+     }
      for (id, ty) in new_undefs.iter().rev() {
 -        func.block_mut(entry).insts.insert(0, Inst {
 -            id: *id,
 -            kind: InstKind::Undef(ty.clone()),
 -            ty: ty.clone(),
 -            span,
 -        });
 +        func.block_mut(entry).insts.insert(
 +            0,
 +            Inst {
 +                id: *id,
 +                kind: InstKind::Undef(ty.clone()),
 +                ty: ty.clone(),
 +                span,
 +            },
 +        );
+     }
      // Now insert block params. Order within a block matters: we
      // Current value stack per alloca. Initialized with the entry
      // Undef for each alloca so that any Load before any Store on
      // this dom-tree path sees undef.
 -    let mut stacks: Vec<Vec<ValueId>> = undef_values.iter()
 -        .map(|&u| vec![u])
 -        .collect();
 +    let mut stacks: Vec<Vec<ValueId>> = undef_values.iter().map(|&u| vec![u]).collect();
      // (old_load_id, new_value_id) rewrites to apply at the end.
      let mut load_renames: HashMap<ValueId, ValueId> = HashMap::new();
              let raw: Vec<BlockId> = match &block.terminator {
                  Some(Terminator::Return(_)) | Some(Terminator::Unreachable) | None => vec![],
                  Some(Terminator::Branch(d, _)) => vec![*d],
 -                Some(Terminator::CondBranch { true_dest, false_dest, .. }) => {
 +                Some(Terminator::CondBranch {
 +                    true_dest,
 +                    false_dest,
 +                    ..
 +                }) => {
                      vec![*true_dest, *false_dest]
+                 }
                  Some(Terminator::Switch { cases, default, .. }) => {
                  // current stack top as a branch arg. The order
                  // matches the order the params were pushed onto
                  // `succ.params` during phase 3.
 -                let new_args: Vec<ValueId> = order.iter()
 -                    .map(|&idx| resolve_promoted_value(
 -                        *stacks[idx].last().expect("mem2reg: stack empty at branch"),
 -                        load_renames,
 -                    ))
 +                let new_args: Vec<ValueId> = order
 +                    .iter()
 +                    .map(|&idx| {
 +                        resolve_promoted_value(
 +                            *stacks[idx].last().expect("mem2reg: stack empty at branch"),
 +                            load_renames,
 +                        )
 +                    })
                      .collect();
                  // Locate the slots in the terminator's arg list.
                  let block_mut = func.block_mut(block_id);
          let kids: Vec<BlockId> = children.get(&block_id).cloned().unwrap_or_default();
          for kid in kids {
              rename_block(
 -                func, kid, promotable, alloca_index, phi_params,
 -                block_phi_order, children, stacks,
 -                load_renames, dead_loads, dead_stores,
 +                func,
 +                kid,
 +                promotable,
 +                alloca_index,
 +                phi_params,
 +                block_phi_order,
 +                children,
 +                stacks,
 +                load_renames,
 +                dead_loads,
 +                dead_stores,
              );
+         }
+     }
      rename_block(
 -        func, func.entry, &promotable, &alloca_index, &phi_params,
 -        &block_phi_order, &children, &mut stacks,
 -        &mut load_renames, &mut dead_loads, &mut dead_stores,
 +        func,
 +        func.entry,
 +        &promotable,
 +        &alloca_index,
 +        &phi_params,
 +        &block_phi_order,
 +        &children,
 +        &mut stacks,
 +        &mut load_renames,
 +        &mut dead_loads,
 +        &mut dead_stores,
      );
      // ---- Phase 5: apply load renames and delete dead insts --------
      let alloca_ids: HashSet<ValueId> = promotable.iter().map(|p| p.alloca_id).collect();
      for block in &mut func.blocks {
          block.insts.retain(|inst| {
 -            if dead_loads.contains(&inst.id) { return false; }
 -            if dead_stores.contains(&inst.id) { return false; }
 -            if alloca_ids.contains(&inst.id) { return false; }
 +            if dead_loads.contains(&inst.id) {
 +                return false;
 +            }
 +            if dead_stores.contains(&inst.id) {
 +                return false;
 +            }
 +            if alloca_ids.contains(&inst.id) {
 +                return false;
 +            }
              true
          });
+     }
      true
+ }
 -fn resolve_promoted_value(
 -    mut value: ValueId,
 -    load_renames: &HashMap<ValueId, ValueId>,
 -) -> ValueId {
 +fn resolve_promoted_value(mut value: ValueId, load_renames: &HashMap<ValueId, ValueId>) -> ValueId {
      let mut seen = HashSet::new();
      while let Some(&next) = load_renames.get(&value) {
          if !seen.insert(value) || next == value {
+             }
+         }
+     }
 -    if candidates.is_empty() { return Vec::new(); }
 +    if candidates.is_empty() {
 +        return Vec::new();
 +    }
      // Second pass: walk every use and disqualify any alloca whose
      // ValueId appears in a non-load/non-store-addr position.
          for inst in &block.insts {
              if let InstKind::Alloca(_) = &inst.kind {
                  if let Some(ty) = candidates.remove(&inst.id) {
 -                    out.push(Promotable { alloca_id: inst.id, pointee_ty: ty });
 +                    out.push(Promotable {
 +                        alloca_id: inst.id,
 +                        pointee_ty: ty,
 +                    });
+                 }
+             }
+         }
          Terminator::Branch(d, args) if *d == target => {
              args.extend_from_slice(new_args);
+         }
 -        Terminator::CondBranch { true_dest, true_args, false_dest, false_args, .. } => {
 +        Terminator::CondBranch {
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +            ..
 +        } => {
              if *true_dest == target {
                  true_args.extend_from_slice(new_args);
+             }
      use super::*;
      use crate::ir::types::IntWidth;
      use crate::ir::verify::verify_module;
 -    use crate::lexer::{Span, Position};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn push_inst(f: &mut Function, block: BlockId, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
 -        f.block_mut(block).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        f.block_mut(block).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c7 = push_inst(&mut f, entry,
 +        let c7 = push_inst(
 +            &mut f,
 +            entry,
              InstKind::ConstInt(7, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, entry,
 -            InstKind::Store(c7, slot),
 -            IrType::Void,
 -        );
 -        let loaded = push_inst(&mut f, entry,
 +        push_inst(&mut f, entry, InstKind::Store(c7, slot), IrType::Void);
 +        let loaded = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Load(slot),
              IrType::Int(IntWidth::I32),
          );
          // After: alloca/store/load all gone. The return should
          // reference c7 directly (via substitution).
          let block = &m.functions[0].blocks[0];
 -        assert!(!block.insts.iter().any(|i| matches!(i.kind, InstKind::Alloca(_))),
 -            "alloca should be gone");
 -        assert!(!block.insts.iter().any(|i| matches!(i.kind, InstKind::Load(_))),
 -            "load should be gone");
 -        assert!(!block.insts.iter().any(|i| matches!(i.kind, InstKind::Store(..))),
 -            "store should be gone");
 +        assert!(
 +            !block
 +                .insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::Alloca(_))),
 +            "alloca should be gone"
 +        );
 +        assert!(
 +            !block
 +                .insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::Load(_))),
 +            "load should be gone"
 +        );
 +        assert!(
 +            !block
 +                .insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::Store(..))),
 +            "store should be gone"
 +        );
          match block.terminator.as_ref().unwrap() {
 -            Terminator::Return(Some(v)) => assert_eq!(*v, c7,
 -                "return should reference the stored const directly"),
 +            Terminator::Return(Some(v)) => {
 +                assert_eq!(*v, c7, "return should reference the stored const directly")
 +            }
              _ => panic!(),
+         }
+     }
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let cond = push_inst(&mut f, entry,
 -            InstKind::ConstBool(true),
 -            IrType::Bool,
 -        );
 +        let cond = push_inst(&mut f, entry, InstKind::ConstBool(true), IrType::Bool);
          let then_b = f.create_block("then");
          let else_b = f.create_block("else");
          let merge = f.create_block("merge");
          f.block_mut(entry).terminator = Some(Terminator::CondBranch {
 -            cond, true_dest: then_b, true_args: vec![],
 -            false_dest: else_b, false_args: vec![],
 +            cond,
 +            true_dest: then_b,
 +            true_args: vec![],
 +            false_dest: else_b,
 +            false_args: vec![],
          });
 -        let c1 = push_inst(&mut f, then_b,
 +        let c1 = push_inst(
 +            &mut f,
 +            then_b,
              InstKind::ConstInt(1, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, then_b,
 -            InstKind::Store(c1, slot), IrType::Void,
 -        );
 +        push_inst(&mut f, then_b, InstKind::Store(c1, slot), IrType::Void);
          f.block_mut(then_b).terminator = Some(Terminator::Branch(merge, vec![]));
 -        let c2 = push_inst(&mut f, else_b,
 +        let c2 = push_inst(
 +            &mut f,
 +            else_b,
              InstKind::ConstInt(2, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, else_b,
 -            InstKind::Store(c2, slot), IrType::Void,
 -        );
 +        push_inst(&mut f, else_b, InstKind::Store(c2, slot), IrType::Void);
          f.block_mut(else_b).terminator = Some(Terminator::Branch(merge, vec![]));
 -        let loaded = push_inst(&mut f, merge,
 +        let loaded = push_inst(
 +            &mut f,
 +            merge,
              InstKind::Load(slot),
              IrType::Int(IntWidth::I32),
          );
          // that param.
          let f = &m.functions[0];
          let merge_block = f.block(merge);
 -        assert_eq!(merge_block.params.len(), 1, "merge should have 1 block param");
 +        assert_eq!(
 +            merge_block.params.len(),
 +            1,
 +            "merge should have 1 block param"
 +        );
          let param_id = merge_block.params[0].id;
          match merge_block.terminator.as_ref().unwrap() {
 -            Terminator::Return(Some(v)) => assert_eq!(*v, param_id,
 -                "return should reference the merge block param"),
 +            Terminator::Return(Some(v)) => assert_eq!(
 +                *v, param_id,
 +                "return should reference the merge block param"
 +            ),
              _ => panic!(),
+         }
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
          // Call that takes the slot's address — escape!
 -        push_inst(&mut f, entry,
 +        push_inst(
 +            &mut f,
 +            entry,
              InstKind::Call(FuncRef::External("takes_ptr".into()), vec![slot]),
              IrType::Void,
          );
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
 -        assert!(!Mem2Reg.run(&mut m), "escaping alloca should not be promoted");
 +        assert!(
 +            !Mem2Reg.run(&mut m),
 +            "escaping alloca should not be promoted"
 +        );
          // The alloca is still there.
 -        assert!(m.functions[0].blocks[0].insts.iter()
 +        assert!(m.functions[0].blocks[0]
 +            .insts
 +            .iter()
              .any(|i| matches!(i.kind, InstKind::Alloca(_))));
+     }
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
          // Promotable: only used by store + load.
 -        let good = push_inst(&mut f, entry,
 +        let good = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
          // Non-promotable: escapes via call.
 -        let bad = push_inst(&mut f, entry,
 +        let bad = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c42 = push_inst(&mut f, entry,
 +        let c42 = push_inst(
 +            &mut f,
 +            entry,
              InstKind::ConstInt(42, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, entry,
 -            InstKind::Store(c42, good), IrType::Void,
 -        );
 -        push_inst(&mut f, entry,
 +        push_inst(&mut f, entry, InstKind::Store(c42, good), IrType::Void);
 +        push_inst(
 +            &mut f,
 +            entry,
              InstKind::Call(FuncRef::External("takes_ptr".into()), vec![bad]),
              IrType::Void,
          );
 -        let loaded = push_inst(&mut f, entry,
 -            InstKind::Load(good), IrType::Int(IntWidth::I32),
 +        let loaded = push_inst(
 +            &mut f,
 +            entry,
 +            InstKind::Load(good),
 +            IrType::Int(IntWidth::I32),
          );
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(loaded)));
          m.add_function(f);
          let block = &m.functions[0].blocks[0];
          // `good` is gone; `bad` remains.
 -        let alloca_count = block.insts.iter()
 +        let alloca_count = block
 +            .insts
 +            .iter()
              .filter(|i| matches!(i.kind, InstKind::Alloca(_)))
              .count();
          assert_eq!(alloca_count, 1, "bad alloca should survive");
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c0 = push_inst(&mut f, entry,
 +        let c0 = push_inst(
 +            &mut f,
 +            entry,
              InstKind::ConstInt(0, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, entry,
 -            InstKind::Store(c0, slot), IrType::Void,
 -        );
 +        push_inst(&mut f, entry, InstKind::Store(c0, slot), IrType::Void);
          let header = f.create_block("header");
          let body = f.create_block("body");
          f.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![]));
          // header: load i, cmp i < 10, cond br body/exit
 -        let cur = push_inst(&mut f, header,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32),
 +        let cur = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
          );
 -        let c10 = push_inst(&mut f, header,
 +        let c10 = push_inst(
 +            &mut f,
 +            header,
              InstKind::ConstInt(10, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        let cmp = push_inst(&mut f, header,
 +        let cmp = push_inst(
 +            &mut f,
 +            header,
              InstKind::ICmp(CmpOp::Lt, cur, c10),
              IrType::Bool,
          );
          f.block_mut(header).terminator = Some(Terminator::CondBranch {
 -            cond: cmp, true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            cond: cmp,
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // body: i = i + 1; br header
 -        let cur2 = push_inst(&mut f, body,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32),
 +        let cur2 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
          );
 -        let c1 = push_inst(&mut f, body,
 +        let c1 = push_inst(
 +            &mut f,
 +            body,
              InstKind::ConstInt(1, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
 -        let next = push_inst(&mut f, body,
 +        let next = push_inst(
 +            &mut f,
 +            body,
              InstKind::IAdd(cur2, c1),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, body,
 -            InstKind::Store(next, slot), IrType::Void,
 -        );
 +        push_inst(&mut f, body, InstKind::Store(next, slot), IrType::Void);
          f.block_mut(body).terminator = Some(Terminator::Branch(header, vec![]));
          f.block_mut(exit).terminator = Some(Terminator::Return(None));
          let f = &m.functions[0];
          let header_block = f.block(header);
          // Header should have exactly one block param (the promoted counter).
 -        assert_eq!(header_block.params.len(), 1,
 -            "header should have 1 block param for the promoted counter");
 +        assert_eq!(
 +            header_block.params.len(),
 +            1,
 +            "header should have 1 block param for the promoted counter"
 +        );
          // No loads or stores anywhere.
          for b in &f.blocks {
              for i in &b.insts {
 -                assert!(!matches!(i.kind, InstKind::Load(_)),
 -                    "no loads should survive mem2reg");
 -                assert!(!matches!(i.kind, InstKind::Store(..)),
 -                    "no stores should survive mem2reg");
 -                assert!(!matches!(i.kind, InstKind::Alloca(_)),
 -                    "no allocas should survive mem2reg");
 +                assert!(
 +                    !matches!(i.kind, InstKind::Load(_)),
 +                    "no loads should survive mem2reg"
 +                );
 +                assert!(
 +                    !matches!(i.kind, InstKind::Store(..)),
 +                    "no stores should survive mem2reg"
 +                );
 +                assert!(
 +                    !matches!(i.kind, InstKind::Alloca(_)),
 +                    "no allocas should survive mem2reg"
 +                );
+             }
+         }
+     }
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let loaded = push_inst(&mut f, entry,
 +        let loaded = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Load(slot),
              IrType::Int(IntWidth::I32),
          );
          // Return should reference the synthetic Undef.
          let f = &m.functions[0];
 -        let undef_id = f.blocks[0].insts.iter()
 +        let undef_id = f.blocks[0]
 +            .insts
 +            .iter()
              .find(|i| matches!(i.kind, InstKind::Undef(_)))
              .map(|i| i.id)
              .expect("no Undef inserted");
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c1 = push_inst(&mut f, entry,
 +        let c1 = push_inst(
 +            &mut f,
 +            entry,
              InstKind::ConstInt(1, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
          push_inst(&mut f, entry, InstKind::Store(c1, slot), IrType::Void);
 -        let loaded = push_inst(&mut f, entry,
 +        let loaded = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Load(slot),
              IrType::Int(IntWidth::I32),
          );
          // Nothing branches to it from entry, so prune_unreachable
          // should remove it before the rename walk.
          let dead = f.create_block("dead");
 -        let c99 = push_inst(&mut f, dead,
 +        let c99 = push_inst(
 +            &mut f,
 +            dead,
              InstKind::ConstInt(99, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
          assert!(Mem2Reg.run(&mut m));
          let errs = verify_module(&m);
 -        assert!(errs.is_empty(),
 -            "post-mem2reg IR invalid (unreachable store regression): {:?}", errs);
 +        assert!(
 +            errs.is_empty(),
 +            "post-mem2reg IR invalid (unreachable store regression): {:?}",
 +            errs
 +        );
          let f = &m.functions[0];
          // The dead block must be gone (pruned by Phase 0).
 -        assert!(!f.blocks.iter().any(|b| b.id == dead),
 -            "unreachable block should be pruned by mem2reg Phase 0");
 +        assert!(
 +            !f.blocks.iter().any(|b| b.id == dead),
 +            "unreachable block should be pruned by mem2reg Phase 0"
 +        );
          // The promoted alloca and its load/store should be gone.
          let entry_block = f.block(f.entry);
 -        assert!(!entry_block.insts.iter().any(|i| matches!(i.kind, InstKind::Alloca(_))));
 -        assert!(!entry_block.insts.iter().any(|i| matches!(i.kind, InstKind::Load(_))));
 -        assert!(!entry_block.insts.iter().any(|i| matches!(i.kind, InstKind::Store(..))));
 +        assert!(!entry_block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::Alloca(_))));
 +        assert!(!entry_block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::Load(_))));
 +        assert!(!entry_block
 +            .insts
 +            .iter()
 +            .any(|i| matches!(i.kind, InstKind::Store(..))));
          // Return must reference c1 (the live store value).
          match entry_block.terminator.as_ref().unwrap() {
 -            Terminator::Return(Some(v)) => assert_eq!(*v, c1,
 -                "return should reach c1 directly, not the dead block's c99"),
 +            Terminator::Return(Some(v)) => assert_eq!(
 +                *v, c1,
 +                "return should reach c1 directly, not the dead block's c99"
 +            ),
              _ => panic!(),
+         }
+     }
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c1 = push_inst(&mut f, entry,
 +        let c1 = push_inst(
 +            &mut f,
 +            entry,
              InstKind::ConstInt(1, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
          // Conditional branch where both arms target `then_b`. The
          // pre-fix mem2reg would visit `then_b` twice via the
          // successor list and double-append the new branch args.
 -        let cond = push_inst(&mut f, entry,
 -            InstKind::ConstBool(true), IrType::Bool,
 -        );
 +        let cond = push_inst(&mut f, entry, InstKind::ConstBool(true), IrType::Bool);
          f.block_mut(entry).terminator = Some(Terminator::CondBranch {
              cond,
              true_dest: then_b,
          });
          // `then_b` stores a different value, then branches to merge.
 -        let c2 = push_inst(&mut f, then_b,
 +        let c2 = push_inst(
 +            &mut f,
 +            then_b,
              InstKind::ConstInt(2, IntWidth::I32),
              IrType::Int(IntWidth::I32),
          );
          f.block_mut(then_b).terminator = Some(Terminator::Branch(merge, vec![]));
          // `merge` loads from slot and returns it.
 -        let loaded = push_inst(&mut f, merge,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32),
 +        let loaded = push_inst(
 +            &mut f,
 +            merge,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
          );
          f.block_mut(merge).terminator = Some(Terminator::Return(Some(loaded)));
          assert!(Mem2Reg.run(&mut m));
          let errs = verify_module(&m);
 -        assert!(errs.is_empty(),
 -            "post-mem2reg IR invalid (same-target CondBranch regression): {:?}", errs);
 +        assert!(
 +            errs.is_empty(),
 +            "post-mem2reg IR invalid (same-target CondBranch regression): {:?}",
 +            errs
 +        );
          // Verify the entry's CondBranch has at most ONE arg per arm
          // (the new phi-arg added for the promoted slot). Pre-fix it
          let f = &m.functions[0];
          let entry_block = f.block(f.entry);
          match entry_block.terminator.as_ref().unwrap() {
 -            Terminator::CondBranch { true_args, false_args, .. } => {
 -                assert!(true_args.len() <= 1,
 -                    "true_args double-appended: {:?}", true_args);
 -                assert!(false_args.len() <= 1,
 -                    "false_args double-appended: {:?}", false_args);
 +            Terminator::CondBranch {
 +                true_args,
 +                false_args,
 +                ..
 +            } => {
 +                assert!(
 +                    true_args.len() <= 1,
 +                    "true_args double-appended: {:?}",
 +                    true_args
 +                );
 +                assert!(
 +                    false_args.len() <= 1,
 +                    "false_args double-appended: {:?}",
 +                    false_args
 +                );
+             }
              // mem2reg may have collapsed the cond_branch to a
              // direct branch if the cond was constant; that's
          // The dead block is unreachable; it should not appear in
          // the DF map at all.
 -        assert!(!df.contains_key(&dead),
 -            "DF map should not contain unreachable block, got {:?}", df);
 +        assert!(
 +            !df.contains_key(&dead),
 +            "DF map should not contain unreachable block, got {:?}",
 +            df
 +        );
          // The merge block has only ONE reachable predecessor
          // (entry), so it isn't a true join point and merge ∉ any
          // DF set.
          for (b, frontier) in &df {
 -            assert!(!frontier.contains(&merge),
 -                "merge should not be in DF[{:?}]: only one reachable pred", b);
 +            assert!(
 +                !frontier.contains(&merge),
 +                "merge should not be in DF[{:?}]: only one reachable pred",
 +                b
 +            );
+         }
+     }
          let mut m = Module::new("t".into());
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
          // Two loads with no intervening store.
 -        let l1 = push_inst(&mut f, entry,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32),
 +        let l1 = push_inst(
 +            &mut f,
 +            entry,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
          );
 -        let _ = push_inst(&mut f, entry,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32),
 +        let _ = push_inst(
 +            &mut f,
 +            entry,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
          );
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(l1)));
          m.add_function(f);
 -        assert!(Mem2Reg.run(&mut m), "no-store alloca should still be promotable");
 +        assert!(
 +            Mem2Reg.run(&mut m),
 +            "no-store alloca should still be promotable"
 +        );
          let errs = verify_module(&m);
          assert!(errs.is_empty(), "post-mem2reg IR invalid: {:?}", errs);
          let block = &m.functions[0].blocks[0];
 -        assert!(!block.insts.iter().any(|i| matches!(i.kind, InstKind::Alloca(_))),
 -            "alloca should be gone");
 -        assert!(!block.insts.iter().any(|i| matches!(i.kind, InstKind::Load(_))),
 -            "loads should be gone");
 +        assert!(
 +            !block
 +                .insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::Alloca(_))),
 +            "alloca should be gone"
 +        );
 +        assert!(
 +            !block
 +                .insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::Load(_))),
 +            "loads should be gone"
 +        );
          // Both loads should be replaced by an Undef sentinel.
 -        assert!(block.insts.iter().any(|i| matches!(i.kind, InstKind::Undef(_))),
 -            "Undef sentinel should be inserted");
 +        assert!(
 +            block
 +                .insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::Undef(_))),
 +            "Undef sentinel should be inserted"
 +        );
+     }
      // =============================================================
          let entry = f.entry;
          // bag: a Ptr<Ptr<i32>> slot that we'll write the escape into.
 -        let bag = push_inst(&mut f, entry,
 +        let bag = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32)))),
              IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))))),
          );
          // escapee: the alloca whose address we leak.
 -        let escapee = push_inst(&mut f, entry,
 +        let escapee = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
          // Store the escapee POINTER into bag — escapee escapes.
 -        push_inst(&mut f, entry,
 -            InstKind::Store(escapee, bag), IrType::Void,
 -        );
 +        push_inst(&mut f, entry, InstKind::Store(escapee, bag), IrType::Void);
          f.block_mut(entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
          assert!(errs.is_empty(), "post-mem2reg IR invalid: {:?}", errs);
          let block = &m.functions[0].blocks[0];
 -        let surviving_allocas = block.insts.iter()
 +        let surviving_allocas = block
 +            .insts
 +            .iter()
              .filter(|i| matches!(i.kind, InstKind::Alloca(_)))
              .count();
          assert!(
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
          let else_b = f.create_block("else");
          let merge = f.create_block("merge");
          f.block_mut(entry).terminator = Some(Terminator::CondBranch {
 -            cond, true_dest: then_b, true_args: vec![],
 -            false_dest: else_b, false_args: vec![],
 +            cond,
 +            true_dest: then_b,
 +            true_args: vec![],
 +            false_dest: else_b,
 +            false_args: vec![],
          });
 -        let c1 = push_inst(&mut f, then_b,
 -            InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32),
 +        let c1 = push_inst(
 +            &mut f,
 +            then_b,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
          );
          push_inst(&mut f, then_b, InstKind::Store(c1, slot), IrType::Void);
          f.block_mut(then_b).terminator = Some(Terminator::Branch(merge, vec![]));
 -        let c2 = push_inst(&mut f, else_b,
 -            InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32),
 +        let c2 = push_inst(
 +            &mut f,
 +            else_b,
 +            InstKind::ConstInt(2, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
          );
          push_inst(&mut f, else_b, InstKind::Store(c2, slot), IrType::Void);
          f.block_mut(else_b).terminator = Some(Terminator::Branch(merge, vec![]));
 -        let loaded = push_inst(&mut f, merge,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32),
 +        let loaded = push_inst(
 +            &mut f,
 +            merge,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
          );
          f.block_mut(merge).terminator = Some(Terminator::Return(Some(loaded)));
          m.add_function(f);
          assert!(Mem2Reg.run(&mut m), "first run should promote");
          // Second run must be a no-op: nothing left to promote.
 -        assert!(!Mem2Reg.run(&mut m), "second run on already-promoted IR should be a no-op");
 +        assert!(
 +            !Mem2Reg.run(&mut m),
 +            "second run on already-promoted IR should be a no-op"
 +        );
          let errs = verify_module(&m);
          assert!(errs.is_empty(), "post-mem2reg IR invalid: {:?}", errs);
+     }
          let mut f = Function::new("f".into(), vec![], IrType::Int(IntWidth::I32));
          let entry = f.entry;
 -        let slot_a = push_inst(&mut f, entry,
 +        let slot_a = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let slot_b = push_inst(&mut f, entry,
 +        let slot_b = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
          let else_b = f.create_block("else");
          let merge = f.create_block("merge");
          f.block_mut(entry).terminator = Some(Terminator::CondBranch {
 -            cond, true_dest: then_b, true_args: vec![],
 -            false_dest: else_b, false_args: vec![],
 +            cond,
 +            true_dest: then_b,
 +            true_args: vec![],
 +            false_dest: else_b,
 +            false_args: vec![],
          });
          // then: a=1, b=10
 -        let c1 = push_inst(&mut f, then_b,
 -            InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let c10 = push_inst(&mut f, then_b,
 -            InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c1 = push_inst(
 +            &mut f,
 +            then_b,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c10 = push_inst(
 +            &mut f,
 +            then_b,
 +            InstKind::ConstInt(10, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, then_b, InstKind::Store(c1, slot_a), IrType::Void);
          push_inst(&mut f, then_b, InstKind::Store(c10, slot_b), IrType::Void);
          f.block_mut(then_b).terminator = Some(Terminator::Branch(merge, vec![]));
          // else: a=2, b=20
 -        let c2 = push_inst(&mut f, else_b,
 -            InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let c20 = push_inst(&mut f, else_b,
 -            InstKind::ConstInt(20, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c2 = push_inst(
 +            &mut f,
 +            else_b,
 +            InstKind::ConstInt(2, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c20 = push_inst(
 +            &mut f,
 +            else_b,
 +            InstKind::ConstInt(20, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, else_b, InstKind::Store(c2, slot_a), IrType::Void);
          push_inst(&mut f, else_b, InstKind::Store(c20, slot_b), IrType::Void);
          f.block_mut(else_b).terminator = Some(Terminator::Branch(merge, vec![]));
          // merge: result = a + b
 -        let la = push_inst(&mut f, merge,
 -            InstKind::Load(slot_a), IrType::Int(IntWidth::I32));
 -        let lb = push_inst(&mut f, merge,
 -            InstKind::Load(slot_b), IrType::Int(IntWidth::I32));
 -        let sum = push_inst(&mut f, merge,
 -            InstKind::IAdd(la, lb), IrType::Int(IntWidth::I32));
 +        let la = push_inst(
 +            &mut f,
 +            merge,
 +            InstKind::Load(slot_a),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let lb = push_inst(
 +            &mut f,
 +            merge,
 +            InstKind::Load(slot_b),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let sum = push_inst(
 +            &mut f,
 +            merge,
 +            InstKind::IAdd(la, lb),
 +            IrType::Int(IntWidth::I32),
 +        );
          f.block_mut(merge).terminator = Some(Terminator::Return(Some(sum)));
          m.add_function(f);
          let f = &m.functions[0];
          let merge_block = f.block(merge);
 -        assert_eq!(merge_block.params.len(), 2,
 -            "merge should have 2 block params, one per promoted alloca");
 +        assert_eq!(
 +            merge_block.params.len(),
 +            2,
 +            "merge should have 2 block params, one per promoted alloca"
 +        );
          // Each predecessor must now carry 2 branch args.
          for pred in [then_b, else_b] {
              let term = f.block(pred).terminator.as_ref().unwrap();
              match term {
 -                Terminator::Branch(_, args) => assert_eq!(args.len(), 2,
 -                    "predecessor {:?} should pass 2 args to merge", pred),
 +                Terminator::Branch(_, args) => assert_eq!(
 +                    args.len(),
 +                    2,
 +                    "predecessor {:?} should pass 2 args to merge",
 +                    pred
 +                ),
                  _ => panic!("predecessor terminator should be Branch"),
+             }
+         }
              InstKind::Load(save_slot),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, then_b, InstKind::Store(then_load, tmp_slot), IrType::Void);
 +        push_inst(
 +            &mut f,
 +            then_b,
 +            InstKind::Store(then_load, tmp_slot),
 +            IrType::Void,
 +        );
          let then_tmp = push_inst(
              &mut f,
              then_b,
              InstKind::Load(tmp_slot),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, then_b, InstKind::Store(then_tmp, result_slot), IrType::Void);
 +        push_inst(
 +            &mut f,
 +            then_b,
 +            InstKind::Store(then_tmp, result_slot),
 +            IrType::Void,
 +        );
          f.block_mut(then_b).terminator = Some(Terminator::Branch(merge, vec![]));
          let else_load = push_inst(
              InstKind::Load(save_slot),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, else_b, InstKind::Store(else_load, tmp_slot), IrType::Void);
 +        push_inst(
 +            &mut f,
 +            else_b,
 +            InstKind::Store(else_load, tmp_slot),
 +            IrType::Void,
 +        );
          let else_tmp = push_inst(
              &mut f,
              else_b,
              InstKind::IAdd(else_tmp, one),
              IrType::Int(IntWidth::I32),
          );
 -        push_inst(&mut f, else_b, InstKind::Store(bumped, result_slot), IrType::Void);
 +        push_inst(
 +            &mut f,
 +            else_b,
 +            InstKind::Store(bumped, result_slot),
 +            IrType::Void,
 +        );
          f.block_mut(else_b).terminator = Some(Terminator::Branch(merge, vec![]));
          let merged = push_inst(
          for block in &f.blocks {
              for inst in &block.insts {
                  assert!(
 -                    !matches!(inst.kind, InstKind::Alloca(_) | InstKind::Load(_) | InstKind::Store(_, _)),
 +                    !matches!(
 +                        inst.kind,
 +                        InstKind::Alloca(_) | InstKind::Load(_) | InstKind::Store(_, _)
 +                    ),
                      "promoted branchy scalar should leave no memory traffic, found {:?}",
                      inst.kind
                  );
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c0 = push_inst(&mut f, entry,
 -            InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c0 = push_inst(
 +            &mut f,
 +            entry,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, entry, InstKind::Store(c0, slot), IrType::Void);
          let header = f.create_block("header");
          f.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![]));
          // header: i = load slot; cmp i < 5
 -        let cur = push_inst(&mut f, header,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32));
 -        let c5 = push_inst(&mut f, header,
 -            InstKind::ConstInt(5, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let cmp = push_inst(&mut f, header,
 -            InstKind::ICmp(CmpOp::Lt, cur, c5), IrType::Bool);
 +        let cur = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c5 = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::ConstInt(5, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let cmp = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::ICmp(CmpOp::Lt, cur, c5),
 +            IrType::Bool,
 +        );
          f.block_mut(header).terminator = Some(Terminator::CondBranch {
 -            cond: cmp, true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            cond: cmp,
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // body: store cur+1 to slot, then store (cur+1)+10 to slot.
          // The SECOND store is the one that should flow to header.
 -        let c1 = push_inst(&mut f, body,
 -            InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let cur2 = push_inst(&mut f, body,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32));
 -        let plus1 = push_inst(&mut f, body,
 -            InstKind::IAdd(cur2, c1), IrType::Int(IntWidth::I32));
 +        let c1 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let cur2 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let plus1 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::IAdd(cur2, c1),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, body, InstKind::Store(plus1, slot), IrType::Void);
 -        let c10 = push_inst(&mut f, body,
 -            InstKind::ConstInt(10, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let plus10 = push_inst(&mut f, body,
 -            InstKind::IAdd(plus1, c10), IrType::Int(IntWidth::I32));
 +        let c10 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::ConstInt(10, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let plus10 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::IAdd(plus1, c10),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, body, InstKind::Store(plus10, slot), IrType::Void);
          f.block_mut(body).terminator = Some(Terminator::Branch(header, vec![]));
          // No loads/stores/allocas anywhere.
          for b in &f.blocks {
              for i in &b.insts {
 -                assert!(!matches!(i.kind, InstKind::Load(_) | InstKind::Store(..) | InstKind::Alloca(_)),
 -                    "should be promoted away: {:?}", i.kind);
 +                assert!(
 +                    !matches!(
 +                        i.kind,
 +                        InstKind::Load(_) | InstKind::Store(..) | InstKind::Alloca(_)
 +                    ),
 +                    "should be promoted away: {:?}",
 +                    i.kind
 +                );
+             }
+         }
          // body's branch back to header should pass `plus10` (the
          match body_term {
              Terminator::Branch(_, args) => {
                  assert_eq!(args.len(), 1, "body should pass 1 arg to header");
 -                assert_eq!(args[0], plus10,
 -                    "header arg should be the LAST store value, not the first");
 +                assert_eq!(
 +                    args[0], plus10,
 +                    "header arg should be the LAST store value, not the first"
 +                );
+             }
              _ => panic!("body terminator should be Branch"),
+         }
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let entry = f.entry;
 -        let slot = push_inst(&mut f, entry,
 +        let slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c0 = push_inst(&mut f, entry,
 -            InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c0 = push_inst(
 +            &mut f,
 +            entry,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, entry, InstKind::Store(c0, slot), IrType::Void);
          let header = f.create_block("header");
          f.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![]));
          // header: i = load; cmp i < 100; cond br body / exit
 -        let cur = push_inst(&mut f, header,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32));
 -        let c100 = push_inst(&mut f, header,
 -            InstKind::ConstInt(100, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let cmp_top = push_inst(&mut f, header,
 -            InstKind::ICmp(CmpOp::Lt, cur, c100), IrType::Bool);
 +        let cur = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c100 = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::ConstInt(100, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let cmp_top = push_inst(
 +            &mut f,
 +            header,
 +            InstKind::ICmp(CmpOp::Lt, cur, c100),
 +            IrType::Bool,
 +        );
          f.block_mut(header).terminator = Some(Terminator::CondBranch {
 -            cond: cmp_top, true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            cond: cmp_top,
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // body: branch to latch_a or latch_b based on cur.
 -        let c50 = push_inst(&mut f, body,
 -            InstKind::ConstInt(50, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let cmp_mid = push_inst(&mut f, body,
 -            InstKind::ICmp(CmpOp::Lt, cur, c50), IrType::Bool);
 +        let c50 = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::ConstInt(50, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let cmp_mid = push_inst(
 +            &mut f,
 +            body,
 +            InstKind::ICmp(CmpOp::Lt, cur, c50),
 +            IrType::Bool,
 +        );
          f.block_mut(body).terminator = Some(Terminator::CondBranch {
 -            cond: cmp_mid, true_dest: latch_a, true_args: vec![],
 -            false_dest: latch_b, false_args: vec![],
 +            cond: cmp_mid,
 +            true_dest: latch_a,
 +            true_args: vec![],
 +            false_dest: latch_b,
 +            false_args: vec![],
          });
          // latch_a: store cur+1; jump header
 -        let c1a = push_inst(&mut f, latch_a,
 -            InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let curla = push_inst(&mut f, latch_a,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32));
 -        let nexta = push_inst(&mut f, latch_a,
 -            InstKind::IAdd(curla, c1a), IrType::Int(IntWidth::I32));
 +        let c1a = push_inst(
 +            &mut f,
 +            latch_a,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let curla = push_inst(
 +            &mut f,
 +            latch_a,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let nexta = push_inst(
 +            &mut f,
 +            latch_a,
 +            InstKind::IAdd(curla, c1a),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, latch_a, InstKind::Store(nexta, slot), IrType::Void);
          f.block_mut(latch_a).terminator = Some(Terminator::Branch(header, vec![]));
          // latch_b: store cur+2; jump header
 -        let c2b = push_inst(&mut f, latch_b,
 -            InstKind::ConstInt(2, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let curlb = push_inst(&mut f, latch_b,
 -            InstKind::Load(slot), IrType::Int(IntWidth::I32));
 -        let nextb = push_inst(&mut f, latch_b,
 -            InstKind::IAdd(curlb, c2b), IrType::Int(IntWidth::I32));
 +        let c2b = push_inst(
 +            &mut f,
 +            latch_b,
 +            InstKind::ConstInt(2, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let curlb = push_inst(
 +            &mut f,
 +            latch_b,
 +            InstKind::Load(slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let nextb = push_inst(
 +            &mut f,
 +            latch_b,
 +            InstKind::IAdd(curlb, c2b),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, latch_b, InstKind::Store(nextb, slot), IrType::Void);
          f.block_mut(latch_b).terminator = Some(Terminator::Branch(header, vec![]));
          let f = &m.functions[0];
          let header_block = f.block(header);
 -        assert_eq!(header_block.params.len(), 1,
 -            "header should have 1 block param for the counter");
 +        assert_eq!(
 +            header_block.params.len(),
 +            1,
 +            "header should have 1 block param for the counter"
 +        );
          // Each latch's branch to header should pass exactly one arg
          // (its computed `next` value).
          let mut f = Function::new("f".into(), vec![], IrType::Void);
          let entry = f.entry;
 -        let outer_slot = push_inst(&mut f, entry,
 +        let outer_slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let inner_slot = push_inst(&mut f, entry,
 +        let inner_slot = push_inst(
 +            &mut f,
 +            entry,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
              IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
          );
 -        let c0 = push_inst(&mut f, entry,
 -            InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c0 = push_inst(
 +            &mut f,
 +            entry,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          push_inst(&mut f, entry, InstKind::Store(c0, outer_slot), IrType::Void);
          let outer_header = f.create_block("outer_header");
 -        let inner_init  = f.create_block("inner_init");
 +        let inner_init = f.create_block("inner_init");
          let inner_header = f.create_block("inner_header");
 -        let inner_body  = f.create_block("inner_body");
 +        let inner_body = f.create_block("inner_body");
          let outer_latch = f.create_block("outer_latch");
          let exit = f.create_block("exit");
          f.block_mut(entry).terminator = Some(Terminator::Branch(outer_header, vec![]));
          // outer_header: i = load outer; cmp i<3; br inner_init / exit
 -        let i = push_inst(&mut f, outer_header,
 -            InstKind::Load(outer_slot), IrType::Int(IntWidth::I32));
 -        let c3 = push_inst(&mut f, outer_header,
 -            InstKind::ConstInt(3, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let cmpo = push_inst(&mut f, outer_header,
 -            InstKind::ICmp(CmpOp::Lt, i, c3), IrType::Bool);
 +        let i = push_inst(
 +            &mut f,
 +            outer_header,
 +            InstKind::Load(outer_slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c3 = push_inst(
 +            &mut f,
 +            outer_header,
 +            InstKind::ConstInt(3, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let cmpo = push_inst(
 +            &mut f,
 +            outer_header,
 +            InstKind::ICmp(CmpOp::Lt, i, c3),
 +            IrType::Bool,
 +        );
          f.block_mut(outer_header).terminator = Some(Terminator::CondBranch {
 -            cond: cmpo, true_dest: inner_init, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            cond: cmpo,
 +            true_dest: inner_init,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // inner_init: store 0 to inner; br inner_header
 -        let c0i = push_inst(&mut f, inner_init,
 -            InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        push_inst(&mut f, inner_init, InstKind::Store(c0i, inner_slot), IrType::Void);
 +        let c0i = push_inst(
 +            &mut f,
 +            inner_init,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        push_inst(
 +            &mut f,
 +            inner_init,
 +            InstKind::Store(c0i, inner_slot),
 +            IrType::Void,
 +        );
          f.block_mut(inner_init).terminator = Some(Terminator::Branch(inner_header, vec![]));
          // inner_header: j = load inner; cmp j<5; br inner_body / outer_latch
 -        let j = push_inst(&mut f, inner_header,
 -            InstKind::Load(inner_slot), IrType::Int(IntWidth::I32));
 -        let c5 = push_inst(&mut f, inner_header,
 -            InstKind::ConstInt(5, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let cmpi = push_inst(&mut f, inner_header,
 -            InstKind::ICmp(CmpOp::Lt, j, c5), IrType::Bool);
 +        let j = push_inst(
 +            &mut f,
 +            inner_header,
 +            InstKind::Load(inner_slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c5 = push_inst(
 +            &mut f,
 +            inner_header,
 +            InstKind::ConstInt(5, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let cmpi = push_inst(
 +            &mut f,
 +            inner_header,
 +            InstKind::ICmp(CmpOp::Lt, j, c5),
 +            IrType::Bool,
 +        );
          f.block_mut(inner_header).terminator = Some(Terminator::CondBranch {
 -            cond: cmpi, true_dest: inner_body, true_args: vec![],
 -            false_dest: outer_latch, false_args: vec![],
 +            cond: cmpi,
 +            true_dest: inner_body,
 +            true_args: vec![],
 +            false_dest: outer_latch,
 +            false_args: vec![],
          });
          // inner_body: j = j + 1; store inner; br inner_header
 -        let c1i = push_inst(&mut f, inner_body,
 -            InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let jcur = push_inst(&mut f, inner_body,
 -            InstKind::Load(inner_slot), IrType::Int(IntWidth::I32));
 -        let jnext = push_inst(&mut f, inner_body,
 -            InstKind::IAdd(jcur, c1i), IrType::Int(IntWidth::I32));
 -        push_inst(&mut f, inner_body, InstKind::Store(jnext, inner_slot), IrType::Void);
 +        let c1i = push_inst(
 +            &mut f,
 +            inner_body,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let jcur = push_inst(
 +            &mut f,
 +            inner_body,
 +            InstKind::Load(inner_slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let jnext = push_inst(
 +            &mut f,
 +            inner_body,
 +            InstKind::IAdd(jcur, c1i),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        push_inst(
 +            &mut f,
 +            inner_body,
 +            InstKind::Store(jnext, inner_slot),
 +            IrType::Void,
 +        );
          f.block_mut(inner_body).terminator = Some(Terminator::Branch(inner_header, vec![]));
          // outer_latch: i = i + 1; store outer; br outer_header
 -        let c1o = push_inst(&mut f, outer_latch,
 -            InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let icur = push_inst(&mut f, outer_latch,
 -            InstKind::Load(outer_slot), IrType::Int(IntWidth::I32));
 -        let inext = push_inst(&mut f, outer_latch,
 -            InstKind::IAdd(icur, c1o), IrType::Int(IntWidth::I32));
 -        push_inst(&mut f, outer_latch, InstKind::Store(inext, outer_slot), IrType::Void);
 +        let c1o = push_inst(
 +            &mut f,
 +            outer_latch,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let icur = push_inst(
 +            &mut f,
 +            outer_latch,
 +            InstKind::Load(outer_slot),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let inext = push_inst(
 +            &mut f,
 +            outer_latch,
 +            InstKind::IAdd(icur, c1o),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        push_inst(
 +            &mut f,
 +            outer_latch,
 +            InstKind::Store(inext, outer_slot),
 +            IrType::Void,
 +        );
          f.block_mut(outer_latch).terminator = Some(Terminator::Branch(outer_header, vec![]));
          f.block_mut(exit).terminator = Some(Terminator::Return(None));
          assert_eq!(f.block(outer_header).params.len(), 2,
              "outer_header should have exactly 2 params (outer + inner counter via back-edge IDF), got {}",
              f.block(outer_header).params.len());
 -        assert_eq!(f.block(inner_header).params.len(), 1,
 +        assert_eq!(
 +            f.block(inner_header).params.len(),
 +            1,
              "inner_header should have exactly 1 param for inner counter, got {}",
 -            f.block(inner_header).params.len());
 +            f.block(inner_header).params.len()
 +        );
          // No loads/stores/allocas anywhere — both slots fully promoted.
          for b in &f.blocks {
              for i in &b.insts {
 -                assert!(!matches!(i.kind, InstKind::Load(_) | InstKind::Store(..) | InstKind::Alloca(_)),
 -                    "{:?}: kind {:?} should be promoted away", b.id, i.kind);
 +                assert!(
 +                    !matches!(
 +                        i.kind,
 +                        InstKind::Load(_) | InstKind::Store(..) | InstKind::Alloca(_)
 +                    ),
 +                    "{:?}: kind {:?} should be promoted away",
 +                    b.id,
 +                    i.kind
 +                );
+             }
+         }
+     }

src/opt/mod.rsmodified

77 lines changed — click to load

  //! invocation is determined by the `OptLevel` selected on the command
  //! line (`-O0` through `-Ofast`).
 -pub mod pass;
 -pub mod pipeline;
 -pub mod util;
 +pub mod alias;
 +pub mod bce;
 +pub mod call_resolve;
 +pub mod callgraph;
 +pub mod const_arg;
  pub mod const_fold;
  pub mod const_prop;
 -pub mod dce;
  pub mod cse;
 -pub mod strength_reduce;
 -pub mod licm;
 -pub mod mem2reg;
 -pub mod dse;
 -pub mod lsf;
 -pub mod unroll;
 -pub mod loop_tree;
 -pub mod loop_utils;
 -pub mod preheader;
 -pub mod unswitch;
 -pub mod interchange;
 +pub mod dce;
 +pub mod dead_arg;
 +pub mod dead_func;
  pub mod dep_analysis;
 -pub mod peel;
 +pub mod dse;
 +pub mod fast_math;
  pub mod fission;
  pub mod fusion;
 -pub mod call_resolve;
 -pub mod callgraph;
 +pub mod global_lsf;
 +pub mod gvn;
  pub mod inline;
 -pub mod simplify_cfg;
 -pub mod dead_func;
 -pub mod dead_arg;
 -pub mod const_arg;
 +pub mod interchange;
 +pub mod licm;
 +pub mod loop_tree;
 +pub mod loop_utils;
 +pub mod lsf;
 +pub mod mem2reg;
 +pub mod pass;
 +pub mod peel;
 +pub mod pipeline;
 +pub mod preheader;
  pub mod return_prop;
 -pub mod fast_math;
 +pub mod simplify_cfg;
  pub mod sroa;
 -pub mod alias;
 -pub mod gvn;
 -pub mod global_lsf;
 -pub mod bce;
 +pub mod strength_reduce;
 +pub mod unroll;
 +pub mod unswitch;
 +pub mod util;
  pub mod vectorize;
  #[cfg(test)]
  // driver actually uses. Audit Cos-2: previously every pass was
  // re-exported behind `#[allow(unused_imports)]`, which masked any
  // future regressions that orphaned a re-export.
 -pub use pipeline::{OptLevel, build_i128_pipeline, build_pipeline};
 +pub use pipeline::{build_i128_pipeline, build_pipeline, OptLevel};
  // Test-only re-export so audit_tests can refer to passes by their
  // short name without the full module path.

src/opt/pass.rsmodified

64 lines changed — click to load

+             }
+         }
 -        PassRunResult { change_count, iterations }
 +        PassRunResult {
 +            change_count,
 +            iterations,
 +        }
+     }
      fn verify_or_panic(&self, module: &Module, after: &str) {
+         }
          let errors: Vec<VerifyError> = verify_module(module);
          if !errors.is_empty() {
 -            let mut msg = format!(
 -                "IR verifier failed after pass `{}`:\n",
 -                after
 -            );
 +            let mut msg = format!("IR verifier failed after pass `{}`:\n", after);
              for e in &errors {
                  msg.push_str("  - ");
                  msg.push_str(&e.msg);
      /// A pass that does nothing — used to test infrastructure plumbing.
      struct NoopPass;
      impl Pass for NoopPass {
 -        fn name(&self) -> &'static str { "noop" }
 -        fn run(&self, _module: &mut Module) -> bool { false }
 +        fn name(&self) -> &'static str {
 +            "noop"
 +        }
 +        fn run(&self, _module: &mut Module) -> bool {
 +            false
 +        }
+     }
      /// A pass that claims it changed once, then is idle.
          fired: std::cell::Cell<bool>,
+     }
      impl Pass for OneShotPass {
 -        fn name(&self) -> &'static str { "oneshot" }
 +        fn name(&self) -> &'static str {
 +            "oneshot"
 +        }
          fn run(&self, _module: &mut Module) -> bool {
 -            if self.fired.get() { false } else { self.fired.set(true); true }
 +            if self.fired.get() {
 +                false
 +            } else {
 +                self.fired.set(true);
 +                true
 +            }
+         }
+     }
      #[test]
      fn oneshot_runs_then_terminates() {
          let mut pm = PassManager::new();
 -        pm.add(Box::new(OneShotPass { fired: std::cell::Cell::new(false) }));
 +        pm.add(Box::new(OneShotPass {
 +            fired: std::cell::Cell::new(false),
 +        }));
          let mut m = empty_module();
          let r = pm.run(&mut m);
          assert_eq!(r.change_count, 1);

src/opt/peel.rsmodified

268 lines changed — click to load

  //! peeled iteration. Later const-prop folds `iv=init_const` through the
  //! clone, turning `if (i==1)` into `if (true)` and eliminating dead code.
 -use std::collections::HashSet;
 +use super::loop_utils::{clone_loop, find_preheader, loop_defined_values, resolve_const_int};
 +use super::pass::Pass;
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  use crate::ir::walk::{find_natural_loops, predecessors};
 -use super::loop_utils::{find_preheader, resolve_const_int, loop_defined_values, clone_loop};
 -use super::pass::Pass;
 +use std::collections::HashSet;
  pub struct LoopPeel;
  impl Pass for LoopPeel {
 -    fn name(&self) -> &'static str { "loop-peel" }
 +    fn name(&self) -> &'static str {
 +        "loop-peel"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if peel_in_function(func) { changed = true; }
 +            if peel_in_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
      let preds = predecessors(func);
      for lp in &loops {
 -        let Some(ph_id) = find_preheader(func, lp, &preds) else { continue };
 +        let Some(ph_id) = find_preheader(func, lp, &preds) else {
 +            continue;
 +        };
          // Header must have exactly 1 block param (the IV).
          let hdr = func.block(lp.header);
 -        if hdr.params.len() != 1 { continue; }
 +        if hdr.params.len() != 1 {
 +            continue;
 +        }
          let iv = hdr.params[0].id;
          // Get the init value from the preheader's branch to header.
          let init_val = match &func.block(ph_id).terminator {
 -            Some(Terminator::Branch(dest, args)) if *dest == lp.header && args.len() == 1 =>
 -                args[0],
 +            Some(Terminator::Branch(dest, args)) if *dest == lp.header && args.len() == 1 => {
 +                args[0]
 +            }
              _ => continue,
          };
          // Init must be a compile-time constant.
 -        let Some(init_const) = resolve_const_int(func, init_val) else { continue };
 +        let Some(init_const) = resolve_const_int(func, init_val) else {
 +            continue;
 +        };
          // Must have a single latch.
 -        if lp.latches.len() != 1 { continue; }
 +        if lp.latches.len() != 1 {
 +            continue;
 +        }
          let latch_id = lp.latches[0];
          // Latch must branch back to header with one arg.
          let next_iv = match &func.block(latch_id).terminator {
 -            Some(Terminator::Branch(dest, args)) if *dest == lp.header && args.len() == 1 =>
 -                args[0],
 +            Some(Terminator::Branch(dest, args)) if *dest == lp.header && args.len() == 1 => {
 +                args[0]
 +            }
              _ => continue,
          };
              for inst in &func.block(latch_id).insts {
                  if inst.id == next_iv {
                      if let InstKind::IAdd(a, b) = &inst.kind {
 -                        if *a == iv { found = resolve_const_int(func, *b); }
 -                        else if *b == iv { found = resolve_const_int(func, *a); }
 +                        if *a == iv {
 +                            found = resolve_const_int(func, *b);
 +                        } else if *b == iv {
 +                            found = resolve_const_int(func, *a);
 +                        }
+                     }
                      break;
+                 }
          for inst in &block.insts {
              if let InstKind::ICmp(CmpOp::Eq, a, b) = &inst.kind {
                  // One operand must be the IV.
 -                let (is_iv, other) = if *a == iv { (true, *b) }
 -                    else if *b == iv { (true, *a) }
 -                    else { (false, ValueId(0)) };
 -                if !is_iv { continue; }
 +                let (is_iv, other) = if *a == iv {
 +                    (true, *b)
 +                } else if *b == iv {
 +                    (true, *a)
 +                } else {
 +                    (false, ValueId(0))
 +                };
 +                if !is_iv {
 +                    continue;
 +                }
                  // The other operand must resolve to the init constant
                  // and be loop-invariant.
 -                if loop_defs.contains(&other) { continue; }
 +                if loop_defs.contains(&other) {
 +                    continue;
 +                }
                  if let Some(c) = resolve_const_int(func, other) {
                      if c == init_const {
                          // Must feed a CondBranch in this block.
                          if let Some(Terminator::CondBranch { cond, .. }) = &block.terminator {
 -                            if *cond == inst.id { return true; }
 +                            if *cond == inst.id {
 +                                return true;
 +                            }
+                         }
+                     }
+                 }
+ }
  /// Get the args passed to the exit block from the cmp's false-branch.
 -fn find_exit_args(func: &Function, lp: &crate::ir::walk::NaturalLoop, exit_id: BlockId) -> Vec<ValueId> {
 +fn find_exit_args(
 +    func: &Function,
 +    lp: &crate::ir::walk::NaturalLoop,
 +    exit_id: BlockId,
 +) -> Vec<ValueId> {
      for &bid in &lp.body {
          let block = func.block(bid);
 -        if let Some(Terminator::CondBranch { false_dest, false_args, .. }) = &block.terminator {
 +        if let Some(Terminator::CondBranch {
 +            false_dest,
 +            false_args,
 +            ..
 +        }) = &block.terminator
 +        {
              if *false_dest == exit_id {
                  return false_args.clone();
+             }
      // The IV type (needed to emit the init+stride constant).
      let hdr = func.block(lp.header);
      let iv_ty = hdr.params[0].ty.clone();
 -    let iv_width = match &iv_ty { IrType::Int(w) => *w, _ => return };
 +    let iv_width = match &iv_ty {
 +        IrType::Int(w) => *w,
 +        _ => return,
 +    };
      let init_const = resolve_const_int(func, init_val).unwrap();
      // Emit init+stride constant in a helper block so it's available.
      // --- Wire preheader → clone's header ---
      let clone_header = block_map[&lp.header];
 -    func.block_mut(ph_id).terminator =
 -        Some(Terminator::Branch(clone_header, vec![init_val]));
 +    func.block_mut(ph_id).terminator = Some(Terminator::Branch(clone_header, vec![init_val]));
+ }
  // ---------------------------------------------------------------------------
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
      use crate::ir::inst::*;
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      use crate::opt::pass::Pass;
 -    use crate::lexer::{Span, Position};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      #[test]
          let c1 = f.next_value_id();
          f.register_type(c1, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c1, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c1,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let c10 = f.next_value_id();
          f.register_type(c10, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c10, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c10,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(10, IntWidth::I32),
          });
          f.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![c1]));
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          f.block_mut(header).terminator = Some(Terminator::Branch(cmp, vec![]));
          let cmp_v = f.next_value_id();
          f.register_type(cmp_v, IrType::Bool);
          f.block_mut(cmp).insts.push(Inst {
 -            id: cmp_v, ty: IrType::Bool, span: span(),
 +            id: cmp_v,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, c10),
          });
          f.block_mut(cmp).terminator = Some(Terminator::CondBranch {
              cond: cmp_v,
 -            true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // Body has NO equality check — just a store.
          let alloca = f.next_value_id();
          f.register_type(alloca, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(body).insts.push(Inst {
 -            id: alloca, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: alloca,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Int(IntWidth::I32)),
          });
          let store_id = f.next_value_id();
          f.register_type(store_id, IrType::Void);
          f.block_mut(body).insts.push(Inst {
 -            id: store_id, ty: IrType::Void, span: span(),
 +            id: store_id,
 +            ty: IrType::Void,
 +            span: span(),
              kind: InstKind::Store(iv, alloca),
          });
          f.block_mut(body).terminator = Some(Terminator::Branch(latch, vec![]));
          let nxt = f.next_value_id();
          f.register_type(nxt, IrType::Int(IntWidth::I32));
          f.block_mut(latch).insts.push(Inst {
 -            id: nxt, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: nxt,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::IAdd(iv, c1),
          });
          f.block_mut(latch).terminator = Some(Terminator::Branch(header, vec![nxt]));

src/opt/pipeline.rsmodified

104 lines changed — click to load

  //! configured `PassManager`. Adding a new pass to a level is a one-line
  //! change here, which keeps the dispatch logic in one place.
 -use super::pass::PassManager;
 +use super::bce::Bce;
 +use super::call_resolve::CallResolve;
 +use super::const_arg::ConstArgSpecialize;
  use super::const_fold::ConstFold;
  use super::const_prop::ConstProp;
 -use super::dce::Dce;
  use super::cse::LocalCse;
 -use super::strength_reduce::StrengthReduce;
 -use super::licm::Licm;
 -use super::mem2reg::Mem2Reg;
 +use super::dce::Dce;
 +use super::dead_arg::DeadArgElim;
 +use super::dead_func::DeadFuncElim;
  use super::dse::Dse;
 -use super::lsf::LocalLsf;
 -use super::unroll::LoopUnroll;
 -use super::preheader::PreheaderInsert;
 -use super::unswitch::LoopUnswitch;
 +use super::fast_math::FastMathReassoc;
 +use super::fission::LoopFission;
 +use super::fusion::LoopFusion;
 +use super::global_lsf::GlobalLsf;
 +use super::gvn::Gvn;
 +use super::inline::Inline;
  use super::interchange::LoopInterchange;
 +use super::licm::Licm;
 +use super::lsf::LocalLsf;
 +use super::mem2reg::Mem2Reg;
 +use super::pass::PassManager;
  use super::peel::LoopPeel;
 -use super::call_resolve::CallResolve;
 -use super::inline::Inline;
 -use super::simplify_cfg::SimplifyCfg;
 -use super::dead_func::DeadFuncElim;
 -use super::dead_arg::DeadArgElim;
 -use super::const_arg::ConstArgSpecialize;
 +use super::preheader::PreheaderInsert;
  use super::return_prop::ReturnPropagate;
 -use super::fast_math::FastMathReassoc;
 +use super::simplify_cfg::SimplifyCfg;
  use super::sroa::Sroa;
 -use super::gvn::Gvn;
 -use super::global_lsf::GlobalLsf;
 -use super::bce::Bce;
 -use super::fission::LoopFission;
 -use super::fusion::LoopFusion;
 +use super::strength_reduce::StrengthReduce;
 +use super::unroll::LoopUnroll;
 +use super::unswitch::LoopUnswitch;
  use super::vectorize::Vectorize;
  /// Compiler optimization levels.
      /// builder below will gate registration on this. Same for the
      /// other two predicates.
      pub fn inlining(self) -> bool {
 -        matches!(self, Self::O1 | Self::O2 | Self::O3 | Self::Os | Self::Ofast)
 +        matches!(
 +            self,
 +            Self::O1 | Self::O2 | Self::O3 | Self::Os | Self::Ofast
 +        )
+     }
      /// Does this level enable loop vectorization (NEON)?
              pm.add(Box::new(CallResolve));
              pm.add(Box::new(Mem2Reg));
              pm.add(Box::new(ConstFold));
 -            pm.add(Box::new(Sroa));    // after SSA + const fold (GCC pattern)
 +            pm.add(Box::new(Sroa)); // after SSA + const fold (GCC pattern)
              pm.add(Box::new(Mem2Reg)); // re-promote SROA-created scalar allocas
              pm.add(Box::new(Inline::for_level(OptLevel::O2)));
              pm.add(Box::new(ConstArgSpecialize));
              pm.add(Box::new(LoopFission));
              pm.add(Box::new(LoopFusion));
              pm.add(Box::new(LoopUnroll));
 -            pm.add(Box::new(Gvn));  // after loop passes to avoid SSA conflicts
 +            pm.add(Box::new(Gvn)); // after loop passes to avoid SSA conflicts
              pm.add(Box::new(Dce));
+         }
          OptLevel::Os => {
      fn pipelines_build() {
          // O0 has no passes; every other level has at least one.
          assert!(build_pipeline(OptLevel::O0).is_empty());
 -        for lvl in [OptLevel::O1, OptLevel::O2, OptLevel::O3, OptLevel::Os, OptLevel::Ofast] {
 +        for lvl in [
 +            OptLevel::O1,
 +            OptLevel::O2,
 +            OptLevel::O3,
 +            OptLevel::Os,
 +            OptLevel::Ofast,
 +        ] {
              let pm = build_pipeline(lvl);
 -            assert!(!pm.is_empty(), "pipeline {:?} should have at least one pass", lvl);
 +            assert!(
 +                !pm.is_empty(),
 +                "pipeline {:?} should have at least one pass",
 +                lvl
 +            );
+         }
+     }

src/opt/preheader.rsmodified

234 lines changed — click to load

  //! Run early at O2+ so downstream passes (LICM, unswitching, interchange)
  //! can assume every loop has a preheader.
 -use crate::ir::inst::*;
 -use crate::ir::walk::{find_natural_loops, predecessors};
  use super::loop_utils::find_preheader;
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use crate::ir::walk::{find_natural_loops, predecessors};
  /// Preheader insertion pass.
  pub struct PreheaderInsert;
  impl Pass for PreheaderInsert {
 -    fn name(&self) -> &'static str { "preheader-insert" }
 +    fn name(&self) -> &'static str {
 +        "preheader-insert"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if insert_preheaders(func) { changed = true; }
 +            if insert_preheaders(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
              Some(p) => p,
              None => continue,
          };
 -        let mut outside: Vec<BlockId> = header_preds.iter()
 +        let mut outside: Vec<BlockId> = header_preds
 +            .iter()
              .copied()
              .filter(|p| !lp.body.contains(p))
              .collect();
          outside.sort_by_key(|b| b.0);
          outside.dedup();
 -        if outside.is_empty() { continue; }
 +        if outside.is_empty() {
 +            continue;
 +        }
          // Create the preheader block. It receives the same block params
          // as the header and unconditionally branches to the header,
          // Preheader terminates with unconditional branch to header,
          // passing its params through.
 -        func.block_mut(ph_id).terminator =
 -            Some(Terminator::Branch(lp.header, ph_param_ids));
 +        func.block_mut(ph_id).terminator = Some(Terminator::Branch(lp.header, ph_param_ids));
          // Redirect each out-of-loop predecessor to branch to the
          // preheader instead of the header.
      };
      match term {
          Terminator::Branch(dest, _) => {
 -            if *dest == old_dest { *dest = new_dest; }
 +            if *dest == old_dest {
 +                *dest = new_dest;
 +            }
+         }
 -        Terminator::CondBranch { true_dest, false_dest, .. } => {
 -            if *true_dest == old_dest { *true_dest = new_dest; }
 -            if *false_dest == old_dest { *false_dest = new_dest; }
 +        Terminator::CondBranch {
 +            true_dest,
 +            false_dest,
 +            ..
 +        } => {
 +            if *true_dest == old_dest {
 +                *true_dest = new_dest;
 +            }
 +            if *false_dest == old_dest {
 +                *false_dest = new_dest;
 +            }
+         }
          Terminator::Switch { default, cases, .. } => {
 -            if *default == old_dest { *default = new_dest; }
 +            if *default == old_dest {
 +                *default = new_dest;
 +            }
              for (_, dest) in cases.iter_mut() {
 -                if *dest == old_dest { *dest = new_dest; }
 +                if *dest == old_dest {
 +                    *dest = new_dest;
 +                }
+             }
+         }
          _ => {}
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::ir::walk::predecessors;
 -    use crate::lexer::{Span, Position};
 +    use crate::lexer::{Position, Span};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      /// Build a function where the loop header has TWO out-of-loop
          let mut f = Function::new("test".into(), vec![], IrType::Void);
          let header = f.create_block("header");
 -        let body   = f.create_block("body");
 -        let latch  = f.create_block("latch");
 -        let exit   = f.create_block("exit");
 -        let alt    = f.create_block("alt_entry");
 -        let entry  = f.entry;
 +        let body = f.create_block("body");
 +        let latch = f.create_block("latch");
 +        let exit = f.create_block("exit");
 +        let alt = f.create_block("alt_entry");
 +        let entry = f.entry;
          // Entry: const 1, condBr → header(1) or alt_entry
          let c1 = f.next_value_id();
          f.register_type(c1, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c1, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c1,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let cond = f.next_value_id();
          f.register_type(cond, IrType::Bool);
          f.block_mut(entry).insts.push(Inst {
 -            id: cond, ty: IrType::Bool, span: span(),
 +            id: cond,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ConstBool(true),
          });
          f.block_mut(entry).terminator = Some(Terminator::CondBranch {
              cond,
 -            true_dest: header, true_args: vec![c1],
 -            false_dest: alt, false_args: vec![],
 +            true_dest: header,
 +            true_args: vec![c1],
 +            false_dest: alt,
 +            false_args: vec![],
          });
          // Alt entry: const 5, br header(5)
          let c5 = f.next_value_id();
          f.register_type(c5, IrType::Int(IntWidth::I32));
          f.block_mut(alt).insts.push(Inst {
 -            id: c5, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c5,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(5, IntWidth::I32),
          });
          f.block_mut(alt).terminator = Some(Terminator::Branch(header, vec![c5]));
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
          f.block_mut(header).params.push(BlockParam {
 -            id: iv, ty: IrType::Int(IntWidth::I32),
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
          });
          let c10 = f.next_value_id();
          f.register_type(c10, IrType::Int(IntWidth::I32));
          f.block_mut(header).insts.push(Inst {
 -            id: c10, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c10,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(10, IntWidth::I32),
          });
          let cmp = f.next_value_id();
          f.register_type(cmp, IrType::Bool);
          f.block_mut(header).insts.push(Inst {
 -            id: cmp, ty: IrType::Bool, span: span(),
 +            id: cmp,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, c10),
          });
          f.block_mut(header).terminator = Some(Terminator::CondBranch {
              cond: cmp,
 -            true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // Body → latch
          let one_l = f.next_value_id();
          f.register_type(one_l, IrType::Int(IntWidth::I32));
          f.block_mut(latch).insts.push(Inst {
 -            id: one_l, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: one_l,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let nxt = f.next_value_id();
          f.register_type(nxt, IrType::Int(IntWidth::I32));
          f.block_mut(latch).insts.push(Inst {
 -            id: nxt, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: nxt,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::IAdd(iv, one_l),
          });
          f.block_mut(latch).terminator = Some(Terminator::Branch(header, vec![nxt]));
          let loops = find_natural_loops(f);
          let preds = predecessors(f);
          assert_eq!(loops.len(), 1);
 -        assert!(find_preheader(f, &loops[0], &preds).is_none(),
 -            "should have no preheader before insertion");
 +        assert!(
 +            find_preheader(f, &loops[0], &preds).is_none(),
 +            "should have no preheader before insertion"
 +        );
          let pass = PreheaderInsert;
          let changed = pass.run(&mut m);

src/opt/return_prop.rsmodified

169 lines changed — click to load

  pub struct ReturnPropagate;
  impl Pass for ReturnPropagate {
 -    fn name(&self) -> &'static str { "return-prop" }
 +    fn name(&self) -> &'static str {
 +        "return-prop"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let plans = collect_plans(module);
+ }
  fn side_effect_free(kind: &InstKind) -> bool {
 -    !matches!(kind, InstKind::Store(..) | InstKind::Call(..) | InstKind::RuntimeCall(..))
 +    !matches!(
 +        kind,
 +        InstKind::Store(..) | InstKind::Call(..) | InstKind::RuntimeCall(..)
 +    )
+ }
  fn classify_return_source(func: &Function, value: ValueId) -> Option<ReturnSource> {
 -    if let Some((idx, param)) = func.params.iter().enumerate().find(|(_, param)| param.id == value) {
 +    if let Some((idx, param)) = func
 +        .params
 +        .iter()
 +        .enumerate()
 +        .find(|(_, param)| param.id == value)
 +    {
          if !param.ty.is_ptr() && is_scalar_type(&param.ty) {
              return Some(ReturnSource::Param(idx));
+         }
      let inst = defs.get(&value)?;
      match inst.kind {
          InstKind::Load(addr) => {
 -            let (idx, param) = func.params.iter().enumerate().find(|(_, param)| param.id == addr)?;
 +            let (idx, param) = func
 +                .params
 +                .iter()
 +                .enumerate()
 +                .find(|(_, param)| param.id == addr)?;
              let IrType::Ptr(inner) = &param.ty else {
                  return None;
              };
          if !func.internal_only || matches!(func.return_type, IrType::Void) {
              continue;
+         }
 -        if func.blocks.iter().flat_map(|block| block.insts.iter()).any(|inst| !side_effect_free(&inst.kind)) {
 +        if func
 +            .blocks
 +            .iter()
 +            .flat_map(|block| block.insts.iter())
 +            .any(|inst| !side_effect_free(&inst.kind))
 +        {
              continue;
+         }
          span
      } else {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
+ }
      for (call_id, args, plan) in scheduled {
          let replacement = match plan {
              ReturnSource::Param(param_idx) => args.get(param_idx).copied(),
 -            ReturnSource::LoadParam(param_idx) => {
 -                args.get(param_idx)
 -                    .copied()
 -                    .and_then(|ptr| wrapper_value_for_call(caller, ptr, call_id))
 -            }
 +            ReturnSource::LoadParam(param_idx) => args
 +                .get(param_idx)
 +                .copied()
 +                .and_then(|ptr| wrapper_value_for_call(caller, ptr, call_id)),
              ReturnSource::Const(value) => Some(ensure_const_in_entry(caller, &mut cache, value)),
          };
          let Some(replacement) = replacement else {
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty: ty.clone(), span: span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty: ty.clone(),
 +            span: span(),
 +        });
          f.register_type(id, ty);
          id
+     }
          }];
          let mut callee = Function::new("passthrough".into(), params, IrType::Int(IntWidth::I32));
          callee.internal_only = true;
 -        let loaded = push(&mut callee, InstKind::Load(ValueId(0)), IrType::Int(IntWidth::I32));
 +        let loaded = push(
 +            &mut callee,
 +            InstKind::Load(ValueId(0)),
 +            IrType::Int(IntWidth::I32),
 +        );
          let callee_entry = callee.entry;
          callee.block_mut(callee_entry).terminator = Some(Terminator::Return(Some(loaded)));
          module.add_function(callee);
          let mut caller = Function::new("main".into(), vec![], IrType::Int(IntWidth::I32));
 -        let c7 = push(&mut caller, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c7 = push(
 +            &mut caller,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let slot = push(
              &mut caller,
              InstKind::Alloca(IrType::Int(IntWidth::I32)),
          assert!(ReturnPropagate.run(&mut module));
          let caller_insts = &module.functions[1].blocks[0].insts;
          assert!(
 -            !caller_insts.iter().any(|inst| matches!(inst.kind, InstKind::Call(..))),
 +            !caller_insts
 +                .iter()
 +                .any(|inst| matches!(inst.kind, InstKind::Call(..))),
              "call should be removed after return propagation"
          );
          assert!(
          let mut callee = Function::new("const_fn".into(), vec![], IrType::Int(IntWidth::I32));
          callee.internal_only = true;
 -        let c42 = push(&mut callee, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let c42 = push(
 +            &mut callee,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let callee_entry = callee.entry;
          callee.block_mut(callee_entry).terminator = Some(Terminator::Return(Some(c42)));
          module.add_function(callee);
          assert!(ReturnPropagate.run(&mut module));
          let caller_insts = &module.functions[1].blocks[0].insts;
          assert!(
 -            !caller_insts.iter().any(|inst| matches!(inst.kind, InstKind::Call(..))),
 +            !caller_insts
 +                .iter()
 +                .any(|inst| matches!(inst.kind, InstKind::Call(..))),
              "constant helper call should be removed"
          );
          assert!(
 -            caller_insts.iter().any(|inst| matches!(inst.kind, InstKind::ConstInt(42, IntWidth::I32))),
 +            caller_insts
 +                .iter()
 +                .any(|inst| matches!(inst.kind, InstKind::ConstInt(42, IntWidth::I32))),
              "caller should materialize the propagated constant"
          );
+     }

src/opt/simplify_cfg.rsmodified

149 lines changed — click to load

  //!
  //! This eliminates the empty block chains left by inlining.
 +use super::pass::Pass;
  use crate::ir::inst::*;
  use crate::ir::walk::predecessors;
 -use super::pass::Pass;
  pub struct SimplifyCfg;
  impl Pass for SimplifyCfg {
 -    fn name(&self) -> &'static str { "simplify-cfg" }
 +    fn name(&self) -> &'static str {
 +        "simplify-cfg"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if simplify_function(func) { changed = true; }
 +            if simplify_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
          let mut redirect: Option<(BlockId, BlockId)> = None;
          for block in &func.blocks {
 -            if block.id == func.entry { continue; }
 -            if !block.insts.is_empty() { continue; }
 -            if !block.params.is_empty() { continue; }
 +            if block.id == func.entry {
 +                continue;
 +            }
 +            if !block.insts.is_empty() {
 +                continue;
 +            }
 +            if !block.params.is_empty() {
 +                continue;
 +            }
              if let Some(Terminator::Branch(target, args)) = &block.terminator {
                  if args.is_empty() {
                      // This block is empty and just forwards to target.
+             }
+         }
 -        let Some((empty_block, target)) = redirect else { break };
 +        let Some((empty_block, target)) = redirect else {
 +            break;
 +        };
          // Redirect all predecessors of empty_block to target instead.
          for block in &mut func.blocks {
 -            if block.id == empty_block { continue; } // don't redirect self
 +            if block.id == empty_block {
 +                continue;
 +            } // don't redirect self
              let term = match &mut block.terminator {
                  Some(t) => t,
                  None => continue,
+             }
+         }
 -        let Some((pred_id, succ_id)) = merge else { break };
 +        let Some((pred_id, succ_id)) = merge else {
 +            break;
 +        };
          // Merge: append successor's instructions and terminator to predecessor.
          let succ_insts = func.block(succ_id).insts.clone();
  fn redirect_terminator(term: &mut Terminator, old: BlockId, new: BlockId) {
      match term {
          Terminator::Branch(dest, _) => {
 -            if *dest == old { *dest = new; }
 +            if *dest == old {
 +                *dest = new;
 +            }
+         }
 -        Terminator::CondBranch { true_dest, false_dest, .. } => {
 -            if *true_dest == old { *true_dest = new; }
 -            if *false_dest == old { *false_dest = new; }
 +        Terminator::CondBranch {
 +            true_dest,
 +            false_dest,
 +            ..
 +        } => {
 +            if *true_dest == old {
 +                *true_dest = new;
 +            }
 +            if *false_dest == old {
 +                *false_dest = new;
 +            }
+         }
          Terminator::Switch { default, cases, .. } => {
 -            if *default == old { *default = new; }
 +            if *default == old {
 +                *default = new;
 +            }
              for (_, dest) in cases.iter_mut() {
 -                if *dest == old { *dest = new; }
 +                if *dest == old {
 +                    *dest = new;
 +                }
+             }
+         }
          _ => {}
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::opt::pass::Pass;
      #[test]
          // contain the ret directly).
          let f = &m.functions[0];
          // The chain should be collapsed.
 -        assert!(f.blocks.len() <= 2, "should merge empty chain, got {} blocks", f.blocks.len());
 +        assert!(
 +            f.blocks.len() <= 2,
 +            "should merge empty chain, got {} blocks",
 +            f.blocks.len()
 +        );
+     }
      #[test]
          let id = f.next_value_id();
          f.register_type(id, IrType::Int(IntWidth::I32));
          f.block_mut(b).insts.push(Inst {
 -            id, ty: IrType::Int(IntWidth::I32),
 +            id,
 +            ty: IrType::Int(IntWidth::I32),
              span: crate::lexer::Span {
                  file_id: 0,
                  start: crate::lexer::Position { line: 0, col: 0 },
          // Body block may be merged into entry (single pred + unconditional branch).
          // But the instruction should be preserved.
          let f = &m.functions[0];
 -        let has_const = f.blocks.iter().any(|bl|
 -            bl.insts.iter().any(|i| matches!(i.kind, InstKind::ConstInt(42, _))));
 +        let has_const = f.blocks.iter().any(|bl| {
 +            bl.insts
 +                .iter()
 +                .any(|i| matches!(i.kind, InstKind::ConstInt(42, _)))
 +        });
          assert!(has_const, "const instruction must be preserved");
+     }
+ }

src/opt/sroa.rsmodified

185 lines changed — click to load

  //!
  //! After SROA, a second Mem2Reg pass promotes the new scalar allocas.
 -use std::collections::HashMap;
 +use super::loop_utils::resolve_const_int;
 +use super::pass::Pass;
  use crate::ir::inst::*;
  use crate::ir::types::IrType;
  use crate::ir::walk::inst_uses;
 -use super::loop_utils::resolve_const_int;
 -use super::pass::Pass;
 +use std::collections::HashMap;
  const SROA_MAX_FIELDS: u64 = 8;
  pub struct Sroa;
  impl Pass for Sroa {
 -    fn name(&self) -> &'static str { "sroa" }
 +    fn name(&self) -> &'static str {
 +        "sroa"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if sroa_function(func) { changed = true; }
 +            if sroa_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
  fn sroa_function(func: &mut Function) -> bool {
      // Collect candidate allocas: Array type, small, all constant-index GEPs.
      let candidates = find_candidates(func);
 -    if candidates.is_empty() { return false; }
 +    if candidates.is_empty() {
 +        return false;
 +    }
      let mut changed = false;
      for cand in candidates {
      for block in &func.blocks {
          for inst in &block.insts {
              let uses = inst_uses(&inst.kind);
 -            if !uses.contains(&alloca_id) { continue; }
 +            if !uses.contains(&alloca_id) {
 +                continue;
 +            }
              // Classify this use of the alloca.
              match &inst.kind {
                  // GEP with the alloca as base: OK if single constant index
                  // AND the result type matches the element type (not byte-level).
                  InstKind::GetElementPtr(base, indices) if *base == alloca_id => {
 -                    if indices.len() != 1 { return false; }
 +                    if indices.len() != 1 {
 +                        return false;
 +                    }
                      if resolve_const_int(func, indices[0]).is_none() {
                          return false;
+                     }
              match term {
                  Terminator::Return(Some(v)) if *v == gep_id => return true,
                  Terminator::Branch(_, args) if args.contains(&gep_id) => return true,
 -                Terminator::CondBranch { cond, true_args, false_args, .. } => {
 -                    if *cond == gep_id || true_args.contains(&gep_id) || false_args.contains(&gep_id) {
 +                Terminator::CondBranch {
 +                    cond,
 +                    true_args,
 +                    false_args,
 +                    ..
 +                } => {
 +                    if *cond == gep_id
 +                        || true_args.contains(&gep_id)
 +                        || false_args.contains(&gep_id)
 +                    {
                          return true;
+                     }
+                 }
          let new_id = func.next_value_id();
          let ptr_ty = IrType::Ptr(Box::new(cand.elem_ty.clone()));
          func.register_type(new_id, ptr_ty.clone());
 -        func.block_mut(cand.alloca_block).insts.insert(insert_pos + i as usize, Inst {
 -            id: new_id,
 -            kind: InstKind::Alloca(cand.elem_ty.clone()),
 -            ty: ptr_ty,
 -            span,
 -        });
 +        func.block_mut(cand.alloca_block).insts.insert(
 +            insert_pos + i as usize,
 +            Inst {
 +                id: new_id,
 +                kind: InstKind::Alloca(cand.elem_ty.clone()),
 +                ty: ptr_ty,
 +                span,
 +            },
 +        );
          field_allocas.push(new_id);
+     }
+         }
+     }
 -    if gep_to_field.is_empty() { return false; }
 +    if gep_to_field.is_empty() {
 +        return false;
 +    }
      // Rewrite all uses of GEP results to use the field allocas.
      for block in &mut func.blocks {
  mod tests {
      use super::*;
      use crate::ir::types::IntWidth;
 +    use crate::lexer::{Position, Span};
      use crate::opt::pass::Pass;
 -    use crate::lexer::{Span, Position};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      #[test]
          let a = f.next_value_id();
          f.register_type(a, IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
          f.block_mut(f.entry).insts.push(Inst {
 -            id: a, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))), span: span(),
 +            id: a,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Int(IntWidth::I32)),
          });
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
          });
          let gep = f.next_value_id();
 -        f.register_type(gep, IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))))));
 +        f.register_type(
 +            gep,
 +            IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))))),
 +        );
          f.block_mut(f.entry).insts.push(Inst {
              id: gep,
              ty: IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))))),
          });
          let sink = f.next_value_id();
 -        f.register_type(sink, IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))))))));
 +        f.register_type(
 +            sink,
 +            IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Ptr(Box::new(
 +                IrType::Int(IntWidth::I8),
 +            )))))),
 +        );
          f.block_mut(f.entry).insts.push(Inst {
              id: sink,
 -            ty: IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I8))))))),
 +            ty: IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Ptr(Box::new(
 +                IrType::Int(IntWidth::I8),
 +            )))))),
              span: span(),
 -            kind: InstKind::Alloca(IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(IntWidth::I8)))))),
 +            kind: InstKind::Alloca(IrType::Ptr(Box::new(IrType::Ptr(Box::new(IrType::Int(
 +                IntWidth::I8,
 +            )))))),
          });
          let escape_store = f.next_value_id();
          f.block_mut(f.entry).terminator = Some(Terminator::Return(None));
          m.add_function(f);
 -        assert!(!Sroa.run(&mut m), "GEP addresses that escape should block SROA");
 +        assert!(
 +            !Sroa.run(&mut m),
 +            "GEP addresses that escape should block SROA"
 +        );
+     }
+ }

src/opt/strength_reduce.rsmodified

416 lines changed — click to load

  use super::pass::Pass;
  use super::util::{for_each_operand_mut, for_each_terminator_operand_mut};
  use crate::ir::inst::*;
 -use crate::ir::types::{IrType, IntWidth};
 +use crate::ir::types::{IntWidth, IrType};
  use std::collections::HashMap;
  /// Apply `rewrites` to every operand slot in the function in a
  /// Sign-extend a stored i64 to its declared bit width. Used so that
  /// "is this -1?" checks survive narrow types.
  fn sext(v: i64, bits: u32) -> i64 {
 -    if bits >= 64 { v }
 -    else {
 +    if bits >= 64 {
 +        v
 +    } else {
          let shift = 64 - bits;
          (v << shift) >> shift
+     }
  /// when `v == 1 << k` and `k > 0`. (`v == 1` is handled separately as
  /// "multiply by 1 → identity".)
  fn pow2_exponent(v: i64) -> Option<u32> {
 -    if v <= 0 { return None; }
 +    if v <= 0 {
 +        return None;
 +    }
      let u = v as u64;
      if u.is_power_of_two() && u != 1 {
          Some(u.trailing_zeros())
  /// Try to derive a strength-reduction rewrite for one instruction.
  /// Returns `None` if no rewrite applies.
 -fn rewrite_for(
 -    inst: &Inst,
 -    consts: &HashMap<ValueId, (i64, IntWidth)>,
 -) -> Option<Rewrite> {
 -    let int_w = if let IrType::Int(w) = inst.ty { w } else { return None; };
 +fn rewrite_for(inst: &Inst, consts: &HashMap<ValueId, (i64, IntWidth)>) -> Option<Rewrite> {
 +    let int_w = if let IrType::Int(w) = inst.ty {
 +        w
 +    } else {
 +        return None;
 +    };
      // Audit m4-1: after the M4-4 normalization in `collect_int_consts`,
      // every `kv` returned from `const_int` is already sign-extended
      // at its source width. The earlier code re-sext'd at `int_w` (the
                      return Some(Rewrite::KindOnly(InstKind::ConstInt(0, int_w)));
+                 }
                  if kv == 1 {
 -                    return Some(Rewrite::Identity { pass_through: var_id });
 +                    return Some(Rewrite::Identity {
 +                        pass_through: var_id,
 +                    });
+                 }
                  if kv == -1 {
                      return Some(Rewrite::KindOnly(InstKind::INeg(var_id)));
  pub struct StrengthReduce;
  impl Pass for StrengthReduce {
 -    fn name(&self) -> &'static str { "strength-reduce" }
 +    fn name(&self) -> &'static str {
 +        "strength-reduce"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
+                     }
+                 }
+             }
 -            if rewrites.is_empty() { continue; }
 +            if rewrites.is_empty() {
 +                continue;
 +            }
              // Second pass: apply rewrites. We process them in reverse
              // block-then-instruction order so that inserting a new
              for (bi, ii, rw, old_id, ty) in rewrites {
                  match rw {
                      Rewrite::ShlByConst { var, k } => {
 -                        let int_w = if let IrType::Int(w) = ty { w } else { unreachable!() };
 +                        let int_w = if let IrType::Int(w) = ty {
 +                            w
 +                        } else {
 +                            unreachable!()
 +                        };
                          let kid = func.next_value_id();
                          let span = func.blocks[bi].insts[ii].span;
 -                        func.blocks[bi].insts.insert(ii, Inst {
 -                            id: kid,
 -                            kind: InstKind::ConstInt(k as i128, int_w),
 -                            ty: IrType::Int(int_w),
 -                            span,
 -                        });
 +                        func.blocks[bi].insts.insert(
 +                            ii,
 +                            Inst {
 +                                id: kid,
 +                                kind: InstKind::ConstInt(k as i128, int_w),
 +                                ty: IrType::Int(int_w),
 +                                span,
 +                            },
 +                        );
                          // The original instruction shifted to ii+1.
                          func.blocks[bi].insts[ii + 1].kind = InstKind::Shl(var, kid);
+                     }
                          std::collections::HashSet::new();
                      visited.insert(k);
                      while let Some(&next) = identity_rewrites.get(&cur) {
 -                        if !visited.insert(next) { break; }
 +                        if !visited.insert(next) {
 +                            break;
 +                        }
                          cur = next;
+                     }
                      identity_rewrites.insert(k, cur);
  mod tests {
      use super::*;
      use crate::ir::types::IrType;
 -    use crate::lexer::{Span, Position};
 +    use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
          let p = Position { line: 1, col: 1 };
 -        Span { start: p, end: p, file_id: 0 }
 +        Span {
 +            start: p,
 +            end: p,
 +            file_id: 0,
 +        }
+     }
      fn push(f: &mut Function, kind: InstKind, ty: IrType) -> ValueId {
          let id = f.next_value_id();
          let entry = f.entry;
 -        f.block_mut(entry).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        f.block_mut(entry).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
      #[test]
      fn imul_by_pow2_becomes_shl() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let k = push(&mut f, InstKind::ConstInt(8, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let k = push(
 +            &mut f,
 +            InstKind::ConstInt(8, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::IMul(x, k), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          assert!(StrengthReduce.run(&mut m));
          // The Shl should reference x and a freshly inserted const(3).
          let block = &m.functions[0].blocks[0];
 -        let shl = block.insts.iter().find_map(|i| match &i.kind {
 -            InstKind::Shl(var, kid) => Some((*var, *kid)),
 -            _ => None,
 -        }).expect("expected Shl");
 +        let shl = block
 +            .insts
 +            .iter()
 +            .find_map(|i| match &i.kind {
 +                InstKind::Shl(var, kid) => Some((*var, *kid)),
 +                _ => None,
 +            })
 +            .expect("expected Shl");
          assert_eq!(shl.0, x);
          // The shift count should be a const(3).
 -        let kconst = block.insts.iter().find(|i| i.id == shl.1).expect("shift const");
 +        let kconst = block
 +            .insts
 +            .iter()
 +            .find(|i| i.id == shl.1)
 +            .expect("shift const");
          assert!(matches!(kconst.kind, InstKind::ConstInt(3, IntWidth::I32)));
+     }
      #[test]
      fn imul_by_zero_becomes_const_zero() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let z = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let z = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::IMul(x, z), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          assert!(StrengthReduce.run(&mut m));
          // y now defines const(0)
 -        let y_inst = m.functions[0].blocks[0].insts.iter().find(|i| i.id == y).unwrap();
 +        let y_inst = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
 +            .find(|i| i.id == y)
 +            .unwrap();
          assert!(matches!(y_inst.kind, InstKind::ConstInt(0, IntWidth::I32)));
+     }
      #[test]
      fn imul_by_one_becomes_identity() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let one = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::IMul(x, one), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
      #[test]
      fn imul_by_neg_one_becomes_neg() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(7, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let neg = push(&mut f, InstKind::ConstInt(-1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(7, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let neg = push(
 +            &mut f,
 +            InstKind::ConstInt(-1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::IMul(x, neg), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          m.add_function(f);
          assert!(StrengthReduce.run(&mut m));
 -        let y_inst = m.functions[0].blocks[0].insts.iter().find(|i| i.id == y).unwrap();
 +        let y_inst = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
 +            .find(|i| i.id == y)
 +            .unwrap();
          match y_inst.kind {
              InstKind::INeg(v) => assert_eq!(v, x),
              ref other => panic!("expected INeg, got {:?}", other),
      #[test]
      fn iadd_zero_becomes_identity() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let z = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let z = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::IAdd(x, z), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
      #[test]
      fn isub_from_zero_becomes_neg() {
          let (mut m, mut f) = make_fn();
 -        let z = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let z = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::ISub(z, x), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          m.add_function(f);
          assert!(StrengthReduce.run(&mut m));
 -        let y_inst = m.functions[0].blocks[0].insts.iter().find(|i| i.id == y).unwrap();
 +        let y_inst = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
 +            .find(|i| i.id == y)
 +            .unwrap();
          match y_inst.kind {
              InstKind::INeg(v) => assert_eq!(v, x),
              _ => panic!(),
      #[test]
      fn idiv_by_one_becomes_identity() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let one = push(&mut f, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let one = push(
 +            &mut f,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::IDiv(x, one), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
      #[test]
      fn band_with_neg_one_becomes_identity() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let mask = push(&mut f, InstKind::ConstInt(-1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let y = push(&mut f, InstKind::BitAnd(x, mask), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let mask = push(
 +            &mut f,
 +            InstKind::ConstInt(-1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let y = push(
 +            &mut f,
 +            InstKind::BitAnd(x, mask),
 +            IrType::Int(IntWidth::I32),
 +        );
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          m.add_function(f);
      #[test]
      fn band_with_zero_becomes_const_zero() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let z = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let z = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::BitAnd(x, z), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          m.add_function(f);
          assert!(StrengthReduce.run(&mut m));
 -        let y_inst = m.functions[0].blocks[0].insts.iter().find(|i| i.id == y).unwrap();
 +        let y_inst = m.functions[0].blocks[0]
 +            .insts
 +            .iter()
 +            .find(|i| i.id == y)
 +            .unwrap();
          assert!(matches!(y_inst.kind, InstKind::ConstInt(0, IntWidth::I32)));
+     }
      #[test]
      fn shift_by_zero_becomes_identity() {
          let (mut m, mut f) = make_fn();
 -        let x = push(&mut f, InstKind::ConstInt(42, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let z = push(&mut f, InstKind::ConstInt(0, IntWidth::I32), IrType::Int(IntWidth::I32));
 +        let x = push(
 +            &mut f,
 +            InstKind::ConstInt(42, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let z = push(
 +            &mut f,
 +            InstKind::ConstInt(0, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
          let y = push(&mut f, InstKind::Shl(x, z), IrType::Int(IntWidth::I32));
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
              },
          ];
          let mut f = Function::new("f".into(), params, IrType::Int(IntWidth::I32));
 -        let y = push(&mut f, InstKind::IMul(ValueId(0), ValueId(1)), IrType::Int(IntWidth::I32));
 +        let y = push(
 +            &mut f,
 +            InstKind::IMul(ValueId(0), ValueId(1)),
 +            IrType::Int(IntWidth::I32),
 +        );
          let entry = f.entry;
          f.block_mut(entry).terminator = Some(Terminator::Return(Some(y)));
          m.add_function(f);

src/opt/unroll.rsmodified

934 lines changed — click to load

  use super::pass::Pass;
  use super::util::{find_natural_loops, predecessors, NaturalLoop};
  use crate::ir::inst::*;
 -use crate::ir::types::{IrType, IntWidth};
 +use crate::ir::types::{IntWidth, IrType};
  use crate::ir::walk::prune_unreachable;
 -use crate::lexer::{Span, Position};
 +use crate::lexer::{Position, Span};
  use std::collections::{HashMap, HashSet};
  fn dummy_span() -> Span {
      let pos = Position { line: 0, col: 0 };
 -    Span { file_id: 0, start: pos, end: pos }
 +    Span {
 +        file_id: 0,
 +        start: pos,
 +        end: pos,
 +    }
+ }
  // ---------------------------------------------------------------------------
  pub struct LoopUnroll;
  impl Pass for LoopUnroll {
 -    fn name(&self) -> &'static str { "loop-unroll" }
 +    fn name(&self) -> &'static str {
 +        "loop-unroll"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
  #[derive(Debug)]
  struct LoopShape {
 -    preheader:   BlockId,
 -    header:      BlockId,   // block with IV block param; branches to cmp_block
 -    cmp_block:   BlockId,   // block with icmp + condBr to body/exit
 +    preheader: BlockId,
 +    header: BlockId,    // block with IV block param; branches to cmp_block
 +    cmp_block: BlockId, // block with icmp + condBr to body/exit
      /// The computation blocks (everything that is not header, cmp_block, or
      /// latch). Ordered in CFG traversal order from cmp_block's true-successor
      /// to latch's predecessor. For most Fortran DO loops this is a single
      /// block ("do_body"). Multi-block bodies are supported as long as the
      /// sub-CFG is a linear chain with no branches to outside.
      body_blocks: Vec<BlockId>,
 -    latch:       BlockId,   // iadd IV, 1 + br header(IV_next)
 -    exit:        BlockId,   // cond_br false target
 -    iv_param:    ValueId,
 -    iv_ty:       IrType,
 -    iv_init:     i64,
 -    iv_bound:    i64,       // inclusive upper bound
 -    trip_count:  usize,
 -    exit_args:   Vec<ValueId>, // args from cmp_block's false branch to exit
 +    latch: BlockId, // iadd IV, 1 + br header(IV_next)
 +    exit: BlockId,  // cond_br false target
 +    iv_param: ValueId,
 +    iv_ty: IrType,
 +    iv_init: i64,
 +    iv_bound: i64, // inclusive upper bound
 +    trip_count: usize,
 +    exit_args: Vec<ValueId>, // args from cmp_block's false branch to exit
+ }
  fn is_do_concurrent_loop(
      preds: &HashMap<BlockId, Vec<BlockId>>,
  ) -> Option<LoopShape> {
      // ---- structural requirements ----------------------------------------
 -    if nl.latches.len() != 1 { return None; }
 +    if nl.latches.len() != 1 {
 +        return None;
 +    }
      let latch = nl.latches[0];
 -    if latch == nl.header { return None; }    // no self-loop
 -    // Body must have between 2 (header+latch) and 5 (header+cmp+body×N+latch) blocks.
 -    if nl.body.len() < 2 || nl.body.len() > 5 { return None; }
 +    if latch == nl.header {
 +        return None;
 +    } // no self-loop
 +      // Body must have between 2 (header+latch) and 5 (header+cmp+body×N+latch) blocks.
 +    if nl.body.len() < 2 || nl.body.len() > 5 {
 +        return None;
 +    }
      let header = nl.header;
      // ---- header must have exactly 1 block param (the IV) ----------------
      let hdr = func.block(header);
 -    if hdr.params.len() != 1 { return None; }
 +    if hdr.params.len() != 1 {
 +        return None;
 +    }
      let iv_param = hdr.params[0].id;
 -    let iv_ty    = hdr.params[0].ty.clone();
 -    if !matches!(iv_ty, IrType::Int(_)) { return None; }
 +    let iv_ty = hdr.params[0].ty.clone();
 +    if !matches!(iv_ty, IrType::Int(_)) {
 +        return None;
 +    }
      // ---- find preheader -------------------------------------------------
      let header_preds = preds.get(&header)?;
 -    let mut outside: Vec<BlockId> = header_preds.iter()
 +    let mut outside: Vec<BlockId> = header_preds
 +        .iter()
          .copied()
          .filter(|p| !nl.body.contains(p))
          .collect();
      outside.sort_by_key(|b| b.0);
      outside.dedup();
 -    if outside.len() != 1 { return None; }
 +    if outside.len() != 1 {
 +        return None;
 +    }
      let preheader = outside[0];
      // Preheader must branch to header with exactly 1 arg (the initial IV).
      let ph_blk = func.block(preheader);
      let iv_init = match &ph_blk.terminator {
 -        Some(Terminator::Branch(dest, args)) if *dest == header && args.len() == 1 =>
 -            resolve_const_int(func, args[0])?,
 +        Some(Terminator::Branch(dest, args)) if *dest == header && args.len() == 1 => {
 +            resolve_const_int(func, args[0])?
 +        }
          _ => return None,
      };
          } else {
              // Case (b): header must be a transparent relay.
              let hdr_blk = func.block(header);
 -            if !hdr_blk.insts.is_empty() { return None; } // must have 0 instructions
 +            if !hdr_blk.insts.is_empty() {
 +                return None;
 +            } // must have 0 instructions
              let relay_target = match &hdr_blk.terminator {
                  Some(Terminator::Branch(t, args)) if args.is_empty() => *t,
                  _ => return None,
              };
 -            if !nl.body.contains(&relay_target) { return None; }
 +            if !nl.body.contains(&relay_target) {
 +                return None;
 +            }
              let (bound, ex, args) = detect_bound_and_exit(func, relay_target, iv_param)?;
              (relay_target, bound, ex, args)
+         }
      };
 -    if nl.body.contains(&exit) { return None; }
 +    if nl.body.contains(&exit) {
 +        return None;
 +    }
      // ---- latch: stride-1 increment, passes only iv back to header ------
 -    if !check_latch(func, latch, header, iv_param) { return None; }
 +    if !check_latch(func, latch, header, iv_param) {
 +        return None;
 +    }
      // ---- compute body_blocks: body − {header, cmp_block, latch} --------
      //
      // mem2reg may have threaded into OUTER loop latches via dominance-frontier
      // placement. If that param is used outside nl.body, the header's block param
      // becomes undefined after we discard the header block.
 -    for &bb in body_blocks.iter()
 +    for &bb in body_blocks
 +        .iter()
          .chain(std::iter::once(&header))
          .chain(std::iter::once(&cmp_block))
          .chain(std::iter::once(&latch))
+     {
 -        if has_escaping_values(func, bb, &nl.body, preds) { return None; }
 +        if has_escaping_values(func, bb, &nl.body, preds) {
 +            return None;
 +        }
+     }
      // ---- size check ------------------------------------------------------
 -    let total_insts: usize = body_blocks.iter()
 -        .map(|&b| func.block(b).insts.len())
 -        .sum();
 -    if total_insts > BODY_SIZE_MAX { return None; }
 +    let total_insts: usize = body_blocks.iter().map(|&b| func.block(b).insts.len()).sum();
 +    if total_insts > BODY_SIZE_MAX {
 +        return None;
 +    }
      let full_unroll_max = if is_do_concurrent {
          DO_CONCURRENT_FULL_UNROLL_MAX
      // ---- trip count ------------------------------------------------------
      let trip_count_i64 = iv_bound - iv_init + 1;
 -    if trip_count_i64 <= 0 { return None; }
 -    if trip_count_i64 > full_unroll_max { return None; }
 +    if trip_count_i64 <= 0 {
 +        return None;
 +    }
 +    if trip_count_i64 > full_unroll_max {
 +        return None;
 +    }
      Some(LoopShape {
          preheader,
          Some(Terminator::CondBranch { true_dest, .. }) => *true_dest,
          _ => return None,
      };
 -    if !loop_body.contains(&first) { return None; }
 +    if !loop_body.contains(&first) {
 +        return None;
 +    }
      if first == latch {
          // Case (a): the cmp's true-successor is the latch itself.
      let mut chain = Vec::new();
      let mut cur = first;
      loop {
 -        if !loop_body.contains(&cur) { return None; }
 +        if !loop_body.contains(&cur) {
 +            return None;
 +        }
          chain.push(cur);
 -        if cur == latch { break; }
 +        if cur == latch {
 +            break;
 +        }
          let blk = func.block(cur);
          // Each block in the chain must have no params (no join point).
 -        if !blk.params.is_empty() { return None; }
 +        if !blk.params.is_empty() {
 +            return None;
 +        }
          // Its terminator must be an unconditional branch to the next block.
          match &blk.terminator {
              Some(Terminator::Branch(next, args)) if args.is_empty() => {
+             }
              _ => return None,
+         }
 -        if chain.len() > 4 { return None; } // safety limit
 +        if chain.len() > 4 {
 +            return None;
 +        } // safety limit
+     }
      Some(chain)
+ }
      // Find the single ICmp that involves the IV.
      let mut cmp_id: Option<ValueId> = None;
 -    let mut bound: Option<i64>     = None;
 -    let mut is_lt = false;  // true when we need bound-1
 +    let mut bound: Option<i64> = None;
 +    let mut is_lt = false; // true when we need bound-1
      for inst in &hdr.insts {
          if let InstKind::ICmp(op, a, b) = &inst.kind {
              };
              let c = resolve_const_int(func, other)?;
              match op {
 -                CmpOp::Le => { bound = Some(c); is_lt = false; }
 -                CmpOp::Lt => { bound = Some(c); is_lt = true; }
 -                CmpOp::Ge => { bound = Some(c); is_lt = false; } // iv >= c means upper = c when commuted
 -                CmpOp::Gt => { bound = Some(c); is_lt = true; }  // iv > c means upper = c-1 commuted
 +                CmpOp::Le => {
 +                    bound = Some(c);
 +                    is_lt = false;
 +                }
 +                CmpOp::Lt => {
 +                    bound = Some(c);
 +                    is_lt = true;
 +                }
 +                CmpOp::Ge => {
 +                    bound = Some(c);
 +                    is_lt = false;
 +                } // iv >= c means upper = c when commuted
 +                CmpOp::Gt => {
 +                    bound = Some(c);
 +                    is_lt = true;
 +                } // iv > c means upper = c-1 commuted
                  _ => return None,
+             }
              cmp_id = Some(inst.id);
      // Terminator must be CondBranch on that cmp.
      match &hdr.terminator {
 -        Some(Terminator::CondBranch { cond, true_dest, true_args, false_dest, false_args })
 -            if *cond == cmp_id =>
 -        {
 +        Some(Terminator::CondBranch {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        }) if *cond == cmp_id => {
              // true → body (latch), false → exit.
              // Check which side is the latch. We don't have the latch id here;
              // we'll accept either ordering and return the "false" side as exit.
      // Terminator must be unconditional branch to header with exactly 1 arg.
      let iv_next = match &blk.terminator {
 -        Some(Terminator::Branch(dest, args)) if *dest == header && args.len() == 1 =>
 -            args[0],
 +        Some(Terminator::Branch(dest, args)) if *dest == header && args.len() == 1 => args[0],
          _ => return false,
      };
          if inst.id == iv_next {
              match &inst.kind {
                  InstKind::IAdd(a, b) => {
 -                    let (is_iv, other) = if *a == iv { (true, *b) } else if *b == iv { (true, *a) } else { (false, *a) };
 -                    if !is_iv { return false; }
 +                    let (is_iv, other) = if *a == iv {
 +                        (true, *b)
 +                    } else if *b == iv {
 +                        (true, *a)
 +                    } else {
 +                        (false, *a)
 +                    };
 +                    if !is_iv {
 +                        return false;
 +                    }
                      return resolve_const_int(func, other) == Some(1);
+                 }
                  _ => return false,
      // latch it becomes undefined after unrolling removes the block.
      let latch_blk = func.block(latch);
      let mut latch_defs: HashSet<ValueId> = HashSet::new();
 -    for bp   in &latch_blk.params { latch_defs.insert(bp.id); }
 -    for inst in &latch_blk.insts  { latch_defs.insert(inst.id); }
 +    for bp in &latch_blk.params {
 +        latch_defs.insert(bp.id);
 +    }
 +    for inst in &latch_blk.insts {
 +        latch_defs.insert(inst.id);
 +    }
 -    if latch_defs.is_empty() { return false; }
 +    if latch_defs.is_empty() {
 +        return false;
 +    }
      // Check every block outside the loop body for uses of those values.
      for block in &func.blocks {
 -        if body.contains(&block.id) { continue; }
 +        if body.contains(&block.id) {
 +            continue;
 +        }
          // Check instruction operands.
          for inst in &block.insts {
              for use_id in inst_uses(&inst.kind) {
 -                if latch_defs.contains(&use_id) { return true; }
 +                if latch_defs.contains(&use_id) {
 +                    return true;
 +                }
+             }
+         }
          // Check terminator operands.
          if let Some(term) = &block.terminator {
              for &use_id in terminator_uses_vec(term).iter() {
 -                if latch_defs.contains(&use_id) { return true; }
 +                if latch_defs.contains(&use_id) {
 +                    return true;
 +                }
+             }
+         }
          // Also check block params of outside blocks that receive args from latch.
  fn terminator_uses_vec(term: &Terminator) -> Vec<ValueId> {
      let mut out = Vec::new();
      match term {
 -        Terminator::Return(Some(v))          => out.push(*v),
 -        Terminator::Branch(_, args)           => out.extend(args),
 -        Terminator::CondBranch { cond, true_args, false_args, .. } => {
 +        Terminator::Return(Some(v)) => out.push(*v),
 +        Terminator::Branch(_, args) => out.extend(args),
 +        Terminator::CondBranch {
 +            cond,
 +            true_args,
 +            false_args,
 +            ..
 +        } => {
              out.push(*cond);
              out.extend(true_args);
              out.extend(false_args);
+         }
 -        Terminator::Switch { selector, .. }  => out.push(*selector),
 -        _                                    => {}
 +        Terminator::Switch { selector, .. } => out.push(*selector),
 +        _ => {}
+     }
      out
+ }
  fn do_unroll(func: &mut Function, shape: LoopShape) {
      // Collect per-body-block instructions once (before we mutate func).
 -    let body_snapshots: Vec<Vec<Inst>> = shape.body_blocks.iter()
 +    let body_snapshots: Vec<Vec<Inst>> = shape
 +        .body_blocks
 +        .iter()
          .map(|&b| func.block(b).insts.clone())
          .collect();
      // Determine the IV width.
 -    let iv_width = match &shape.iv_ty { IrType::Int(w) => *w, _ => IntWidth::I32 };
 +    let iv_width = match &shape.iv_ty {
 +        IrType::Int(w) => *w,
 +        _ => IntWidth::I32,
 +    };
      // For each iteration, we create one new block per body block, cloned
      // with the IV substituted by a constant. The chain is:
                      (after_iter, exit_args.clone())
                  };
                  let _ = original_body_next[bi]; // consumed above
 -                func.block_mut(cur_blk).terminator =
 -                    Some(Terminator::Branch(next_blk, args));
 +                func.block_mut(cur_blk).terminator = Some(Terminator::Branch(next_blk, args));
+             }
+         }
+     }
          Some(Terminator::Branch(first_block, preheader_args));
      // Mark loop control blocks as Unreachable → prune_unreachable removes them.
 -    func.block_mut(shape.header).terminator   = Some(Terminator::Unreachable);
 +    func.block_mut(shape.header).terminator = Some(Terminator::Unreachable);
      func.block_mut(shape.cmp_block).terminator = Some(Terminator::Unreachable);
 -    func.block_mut(shape.latch).terminator     = Some(Terminator::Unreachable);
 +    func.block_mut(shape.latch).terminator = Some(Terminator::Unreachable);
      for &b in &shape.body_blocks {
          func.block_mut(b).terminator = Some(Terminator::Unreachable);
+     }
      let r = |v: &ValueId| *subst.get(v).unwrap_or(v);
      match kind {
          // Constants — no operands.
 -        InstKind::ConstInt(v, w)     => InstKind::ConstInt(*v, *w),
 -        InstKind::ConstFloat(v, w)   => InstKind::ConstFloat(*v, *w),
 -        InstKind::ConstBool(v)       => InstKind::ConstBool(*v),
 -        InstKind::ConstString(v)     => InstKind::ConstString(v.clone()),
 -        InstKind::Undef(t)           => InstKind::Undef(t.clone()),
 -        InstKind::GlobalAddr(s)      => InstKind::GlobalAddr(s.clone()),
 +        InstKind::ConstInt(v, w) => InstKind::ConstInt(*v, *w),
 +        InstKind::ConstFloat(v, w) => InstKind::ConstFloat(*v, *w),
 +        InstKind::ConstBool(v) => InstKind::ConstBool(*v),
 +        InstKind::ConstString(v) => InstKind::ConstString(v.clone()),
 +        InstKind::Undef(t) => InstKind::Undef(t.clone()),
 +        InstKind::GlobalAddr(s) => InstKind::GlobalAddr(s.clone()),
          // Integer arithmetic.
 -        InstKind::IAdd(a, b)  => InstKind::IAdd(r(a), r(b)),
 -        InstKind::ISub(a, b)  => InstKind::ISub(r(a), r(b)),
 -        InstKind::IMul(a, b)  => InstKind::IMul(r(a), r(b)),
 -        InstKind::IDiv(a, b)  => InstKind::IDiv(r(a), r(b)),
 -        InstKind::IMod(a, b)  => InstKind::IMod(r(a), r(b)),
 -        InstKind::INeg(a)     => InstKind::INeg(r(a)),
 +        InstKind::IAdd(a, b) => InstKind::IAdd(r(a), r(b)),
 +        InstKind::ISub(a, b) => InstKind::ISub(r(a), r(b)),
 +        InstKind::IMul(a, b) => InstKind::IMul(r(a), r(b)),
 +        InstKind::IDiv(a, b) => InstKind::IDiv(r(a), r(b)),
 +        InstKind::IMod(a, b) => InstKind::IMod(r(a), r(b)),
 +        InstKind::INeg(a) => InstKind::INeg(r(a)),
          // Float arithmetic.
 -        InstKind::FAdd(a, b)  => InstKind::FAdd(r(a), r(b)),
 -        InstKind::FSub(a, b)  => InstKind::FSub(r(a), r(b)),
 -        InstKind::FMul(a, b)  => InstKind::FMul(r(a), r(b)),
 -        InstKind::FDiv(a, b)  => InstKind::FDiv(r(a), r(b)),
 -        InstKind::FNeg(a)     => InstKind::FNeg(r(a)),
 -        InstKind::FAbs(a)     => InstKind::FAbs(r(a)),
 -        InstKind::FSqrt(a)    => InstKind::FSqrt(r(a)),
 -        InstKind::FPow(a, b)  => InstKind::FPow(r(a), r(b)),
 +        InstKind::FAdd(a, b) => InstKind::FAdd(r(a), r(b)),
 +        InstKind::FSub(a, b) => InstKind::FSub(r(a), r(b)),
 +        InstKind::FMul(a, b) => InstKind::FMul(r(a), r(b)),
 +        InstKind::FDiv(a, b) => InstKind::FDiv(r(a), r(b)),
 +        InstKind::FNeg(a) => InstKind::FNeg(r(a)),
 +        InstKind::FAbs(a) => InstKind::FAbs(r(a)),
 +        InstKind::FSqrt(a) => InstKind::FSqrt(r(a)),
 +        InstKind::FPow(a, b) => InstKind::FPow(r(a), r(b)),
          // Comparison.
          InstKind::ICmp(op, a, b) => InstKind::ICmp(*op, r(a), r(b)),
          // Logic.
          InstKind::And(a, b) => InstKind::And(r(a), r(b)),
 -        InstKind::Or(a, b)  => InstKind::Or(r(a), r(b)),
 -        InstKind::Not(a)    => InstKind::Not(r(a)),
 +        InstKind::Or(a, b) => InstKind::Or(r(a), r(b)),
 +        InstKind::Not(a) => InstKind::Not(r(a)),
          // Select.
          InstKind::Select(c, t, f) => InstKind::Select(r(c), r(t), r(f)),
          // Bitwise.
 -        InstKind::BitAnd(a, b)           => InstKind::BitAnd(r(a), r(b)),
 -        InstKind::BitOr(a, b)            => InstKind::BitOr(r(a), r(b)),
 -        InstKind::BitXor(a, b)           => InstKind::BitXor(r(a), r(b)),
 -        InstKind::BitNot(a)              => InstKind::BitNot(r(a)),
 -        InstKind::Shl(a, b)              => InstKind::Shl(r(a), r(b)),
 -        InstKind::LShr(a, b)             => InstKind::LShr(r(a), r(b)),
 -        InstKind::AShr(a, b)             => InstKind::AShr(r(a), r(b)),
 -        InstKind::CountLeadingZeros(a)   => InstKind::CountLeadingZeros(r(a)),
 -        InstKind::CountTrailingZeros(a)  => InstKind::CountTrailingZeros(r(a)),
 -        InstKind::PopCount(a)            => InstKind::PopCount(r(a)),
 +        InstKind::BitAnd(a, b) => InstKind::BitAnd(r(a), r(b)),
 +        InstKind::BitOr(a, b) => InstKind::BitOr(r(a), r(b)),
 +        InstKind::BitXor(a, b) => InstKind::BitXor(r(a), r(b)),
 +        InstKind::BitNot(a) => InstKind::BitNot(r(a)),
 +        InstKind::Shl(a, b) => InstKind::Shl(r(a), r(b)),
 +        InstKind::LShr(a, b) => InstKind::LShr(r(a), r(b)),
 +        InstKind::AShr(a, b) => InstKind::AShr(r(a), r(b)),
 +        InstKind::CountLeadingZeros(a) => InstKind::CountLeadingZeros(r(a)),
 +        InstKind::CountTrailingZeros(a) => InstKind::CountTrailingZeros(r(a)),
 +        InstKind::PopCount(a) => InstKind::PopCount(r(a)),
          // Conversions.
 -        InstKind::IntToFloat(a, w)    => InstKind::IntToFloat(r(a), *w),
 -        InstKind::FloatToInt(a, w)    => InstKind::FloatToInt(r(a), *w),
 -        InstKind::FloatExtend(a, w)   => InstKind::FloatExtend(r(a), *w),
 -        InstKind::FloatTrunc(a, w)    => InstKind::FloatTrunc(r(a), *w),
 -        InstKind::IntExtend(a, w, s)  => InstKind::IntExtend(r(a), *w, *s),
 -        InstKind::IntTrunc(a, w)      => InstKind::IntTrunc(r(a), *w),
 -        InstKind::PtrToInt(a)         => InstKind::PtrToInt(r(a)),
 -        InstKind::IntToPtr(a, ty)     => InstKind::IntToPtr(r(a), ty.clone()),
 +        InstKind::IntToFloat(a, w) => InstKind::IntToFloat(r(a), *w),
 +        InstKind::FloatToInt(a, w) => InstKind::FloatToInt(r(a), *w),
 +        InstKind::FloatExtend(a, w) => InstKind::FloatExtend(r(a), *w),
 +        InstKind::FloatTrunc(a, w) => InstKind::FloatTrunc(r(a), *w),
 +        InstKind::IntExtend(a, w, s) => InstKind::IntExtend(r(a), *w, *s),
 +        InstKind::IntTrunc(a, w) => InstKind::IntTrunc(r(a), *w),
 +        InstKind::PtrToInt(a) => InstKind::PtrToInt(r(a)),
 +        InstKind::IntToPtr(a, ty) => InstKind::IntToPtr(r(a), ty.clone()),
          // Memory.
 -        InstKind::Alloca(t)  => InstKind::Alloca(t.clone()),
 -        InstKind::Load(a)    => InstKind::Load(r(a)),
 +        InstKind::Alloca(t) => InstKind::Alloca(t.clone()),
 +        InstKind::Load(a) => InstKind::Load(r(a)),
          InstKind::Store(v, p) => InstKind::Store(r(v), r(p)),
 -        InstKind::GetElementPtr(base, idxs) =>
 -            InstKind::GetElementPtr(r(base), idxs.iter().map(&r).collect()),
 +        InstKind::GetElementPtr(base, idxs) => {
 +            InstKind::GetElementPtr(r(base), idxs.iter().map(&r).collect())
 +        }
          // Calls.
 -        InstKind::Call(f, args) =>
 -            InstKind::Call(f.clone(), args.iter().map(&r).collect()),
 -        InstKind::RuntimeCall(f, args) =>
 -            InstKind::RuntimeCall(f.clone(), args.iter().map(&r).collect()),
 +        InstKind::Call(f, args) => InstKind::Call(f.clone(), args.iter().map(&r).collect()),
 +        InstKind::RuntimeCall(f, args) => {
 +            InstKind::RuntimeCall(f.clone(), args.iter().map(&r).collect())
 +        }
          // Aggregates.
 -        InstKind::ExtractField(v, idx)     => InstKind::ExtractField(r(v), *idx),
 +        InstKind::ExtractField(v, idx) => InstKind::ExtractField(r(v), *idx),
          InstKind::InsertField(v, idx, fld) => InstKind::InsertField(r(v), *idx, r(fld)),
+     }
+ }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 -    use crate::opt::pass::Pass;
 +    use crate::ir::types::{IntWidth, IrType};
      use crate::lexer::Span;
 +    use crate::opt::pass::Pass;
 -    fn span() -> Span { super::dummy_span() }
 +    fn span() -> Span {
 +        super::dummy_span()
 +    }
      /// Build a minimal Module with one function containing a simple
      /// counted loop: do i = 1, N; a(i_offset) = const(42); end do
          // Allocate block IDs.
          let header_id = f.create_block(&format!("{}_check", prefix));
 -        let latch_id  = f.create_block(&format!("{}_body", prefix));
 -        let exit_id   = f.create_block("exit");
 -        let entry_id  = f.entry; // preheader
 +        let latch_id = f.create_block(&format!("{}_body", prefix));
 +        let exit_id = f.create_block("exit");
 +        let entry_id = f.entry; // preheader
          // ---- entry (preheader) -------------------------------------------
          // const lo
          let lo_val = f.next_value_id();
          f.block_mut(entry_id).insts.push(Inst {
 -            id: lo_val, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: lo_val,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(lo as i128, IntWidth::I64),
          });
          // alloca for the "array" (just a slot we store into)
          let alloca_val = f.next_value_id();
          f.block_mut(entry_id).insts.push(Inst {
 -            id: alloca_val, ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I64))), span: span(),
 +            id: alloca_val,
 +            ty: IrType::Ptr(Box::new(IrType::Int(IntWidth::I64))),
 +            span: span(),
              kind: InstKind::Alloca(IrType::Int(IntWidth::I64)),
          });
          // br header(lo)
 -        f.block_mut(entry_id).terminator =
 -            Some(Terminator::Branch(header_id, vec![lo_val]));
 +        f.block_mut(entry_id).terminator = Some(Terminator::Branch(header_id, vec![lo_val]));
          // ---- header (%i) -------------------------------------------------
          let iv_param = f.next_value_id();
          f.block_mut(header_id).params.push(BlockParam {
 -            id: iv_param, ty: IrType::Int(IntWidth::I64),
 +            id: iv_param,
 +            ty: IrType::Int(IntWidth::I64),
          });
          // const hi
          let hi_val = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
 -            id: hi_val, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: hi_val,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(hi as i128, IntWidth::I64),
          });
          // %cmp = icmp.sle %i, hi
          let cmp_val = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
 -            id: cmp_val, ty: IrType::Bool, span: span(),
 +            id: cmp_val,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv_param, hi_val),
          });
          // condBr %cmp, latch, exit
          f.block_mut(header_id).terminator = Some(Terminator::CondBranch {
              cond: cmp_val,
 -            true_dest: latch_id, true_args: vec![],
 -            false_dest: exit_id, false_args: vec![],
 +            true_dest: latch_id,
 +            true_args: vec![],
 +            false_dest: exit_id,
 +            false_args: vec![],
          });
          // ---- latch -------------------------------------------------------
          // Store 42 to the alloca (simulates a(i) = 42).
          let const42 = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: const42, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: const42,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(42, IntWidth::I64),
          });
          let store_id = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: store_id, ty: IrType::Void, span: span(),
 +            id: store_id,
 +            ty: IrType::Void,
 +            span: span(),
              kind: InstKind::Store(const42, alloca_val),
          });
          // %i_next = iadd %i, 1
          let one = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: one, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: one,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I64),
          });
          let i_next = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: i_next, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: i_next,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::IAdd(iv_param, one),
          });
          // br header(%i_next)
 -        f.block_mut(latch_id).terminator =
 -            Some(Terminator::Branch(header_id, vec![i_next]));
 +        f.block_mut(latch_id).terminator = Some(Terminator::Branch(header_id, vec![i_next]));
          // ---- exit --------------------------------------------------------
          f.block_mut(exit_id).terminator = Some(Terminator::Return(None));
          assert_eq!(f.blocks.len(), 6, "expected entry + 4 iter blocks + exit");
          // Each iteration block has a ConstInt for that iteration's IV value.
 -        let all_iv_consts: Vec<i128> = f.blocks.iter()
 +        let all_iv_consts: Vec<i128> = f
 +            .blocks
 +            .iter()
              .flat_map(|b| b.insts.iter())
 -            .filter_map(|i| if let InstKind::ConstInt(v, _) = i.kind { Some(v) } else { None })
 +            .filter_map(|i| {
 +                if let InstKind::ConstInt(v, _) = i.kind {
 +                    Some(v)
 +                } else {
 +                    None
 +                }
 +            })
              .collect();
          assert!(all_iv_consts.contains(&1), "IV=1 should appear");
          assert!(all_iv_consts.contains(&2), "IV=2 should appear");
          let mut m = build_counted_loop_with_prefix(1, 10, "doconc");
          let pass = LoopUnroll;
          let changed = pass.run(&mut m);
 -        assert!(changed, "DO CONCURRENT trip-count-10 loop should fully unroll");
 +        assert!(
 +            changed,
 +            "DO CONCURRENT trip-count-10 loop should fully unroll"
 +        );
          let f = &m.functions[0];
          assert_eq!(f.blocks.len(), 12, "expected entry + 10 iter blocks + exit");
          let mut m = Module::new("test".into());
          let mut f = Function::new("reduce".into(), vec![], IrType::Void);
          let header_id = f.create_block("header");
 -        let latch_id  = f.create_block("latch");
 -        let exit_id   = f.create_block("exit");
 -        let entry_id  = f.entry;
 +        let latch_id = f.create_block("latch");
 +        let exit_id = f.create_block("exit");
 +        let entry_id = f.entry;
          // Entry: br header(1, 0)
          let lo = f.next_value_id();
          f.block_mut(entry_id).insts.push(Inst {
 -            id: lo, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: lo,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I64),
          });
          let z = f.next_value_id();
          f.block_mut(entry_id).insts.push(Inst {
 -            id: z, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: z,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(0, IntWidth::I64),
          });
 -        f.block_mut(entry_id).terminator =
 -            Some(Terminator::Branch(header_id, vec![lo, z]));
 +        f.block_mut(entry_id).terminator = Some(Terminator::Branch(header_id, vec![lo, z]));
          // Header: 2 params (iv, acc)
 -        let iv  = f.next_value_id();
 +        let iv = f.next_value_id();
          let acc = f.next_value_id();
 -        f.block_mut(header_id).params.push(BlockParam { id: iv,  ty: IrType::Int(IntWidth::I64) });
 -        f.block_mut(header_id).params.push(BlockParam { id: acc, ty: IrType::Int(IntWidth::I64) });
 +        f.block_mut(header_id).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I64),
 +        });
 +        f.block_mut(header_id).params.push(BlockParam {
 +            id: acc,
 +            ty: IrType::Int(IntWidth::I64),
 +        });
          let hi = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
 -            id: hi, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: hi,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(4, IntWidth::I64),
          });
          let cmp = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
 -            id: cmp, ty: IrType::Bool, span: span(),
 +            id: cmp,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, hi),
          });
          f.block_mut(header_id).terminator = Some(Terminator::CondBranch {
              cond: cmp,
 -            true_dest: latch_id, true_args: vec![],
 -            false_dest: exit_id, false_args: vec![acc],
 +            true_dest: latch_id,
 +            true_args: vec![],
 +            false_dest: exit_id,
 +            false_args: vec![acc],
          });
          // Latch: acc_next = acc + iv; i_next = iv + 1; br header(i_next, acc_next)
          let one = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: one, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: one,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I64),
          });
          let acc_next = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: acc_next, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: acc_next,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::IAdd(acc, iv),
          });
          let i_next = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: i_next, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: i_next,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::IAdd(iv, one),
          });
          f.block_mut(latch_id).terminator =
          // Exit: acc param, return
          let acc_out = f.next_value_id();
 -        f.block_mut(exit_id).params.push(BlockParam { id: acc_out, ty: IrType::Int(IntWidth::I64) });
 +        f.block_mut(exit_id).params.push(BlockParam {
 +            id: acc_out,
 +            ty: IrType::Int(IntWidth::I64),
 +        });
          f.block_mut(exit_id).terminator = Some(Terminator::Return(None));
          m.add_function(f);
          let pass = LoopUnroll;
          let changed = pass.run(&mut m);
 -        assert!(!changed, "reduction loop with 2 header params should not be unrolled");
 +        assert!(
 +            !changed,
 +            "reduction loop with 2 header params should not be unrolled"
 +        );
+     }
      #[test]
          let mut m = Module::new("test".into());
          let mut f = Function::new("escape_test".into(), vec![], IrType::Void);
 -        let header_id   = f.create_block("header");
 -        let latch_id    = f.create_block("latch");
 -        let exit_id     = f.create_block("exit");
 +        let header_id = f.create_block("header");
 +        let latch_id = f.create_block("latch");
 +        let exit_id = f.create_block("exit");
          let outer_latch = f.create_block("outer_latch");
 -        let outer_dest  = f.create_block("outer_dest");
 -        let entry_id    = f.entry;
 +        let outer_dest = f.create_block("outer_dest");
 +        let entry_id = f.entry;
          // Entry: const 1; br header(1)
          let lo = f.next_value_id();
          f.block_mut(entry_id).insts.push(Inst {
 -            id: lo, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: lo,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I64),
          });
 -        f.block_mut(entry_id).terminator =
 -            Some(Terminator::Branch(header_id, vec![lo]));
 +        f.block_mut(entry_id).terminator = Some(Terminator::Branch(header_id, vec![lo]));
          // Header: block param %iv; icmp %iv ≤ 3; condBr latch, exit
          let iv = f.next_value_id();
          f.block_mut(header_id).params.push(BlockParam {
 -            id: iv, ty: IrType::Int(IntWidth::I64),
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I64),
          });
          let hi_c = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
 -            id: hi_c, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: hi_c,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(3, IntWidth::I64),
          });
          let cmp = f.next_value_id();
          f.block_mut(header_id).insts.push(Inst {
 -            id: cmp, ty: IrType::Bool, span: span(),
 +            id: cmp,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, hi_c),
          });
          f.block_mut(header_id).terminator = Some(Terminator::CondBranch {
              cond: cmp,
 -            true_dest: latch_id, true_args: vec![],
 -            false_dest: exit_id, false_args: vec![],
 +            true_dest: latch_id,
 +            true_args: vec![],
 +            false_dest: exit_id,
 +            false_args: vec![],
          });
          // Latch: %next = iadd %iv, 1; br header(%next)
          let one = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: one, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: one,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I64),
          });
          let nxt = f.next_value_id();
          f.block_mut(latch_id).insts.push(Inst {
 -            id: nxt, ty: IrType::Int(IntWidth::I64), span: span(),
 +            id: nxt,
 +            ty: IrType::Int(IntWidth::I64),
 +            span: span(),
              kind: InstKind::IAdd(iv, one),
          });
 -        f.block_mut(latch_id).terminator =
 -            Some(Terminator::Branch(header_id, vec![nxt]));
 +        f.block_mut(latch_id).terminator = Some(Terminator::Branch(header_id, vec![nxt]));
          // Exit: ret void
          f.block_mut(exit_id).terminator = Some(Terminator::Return(None));
          // outer_latch: br outer_dest(%iv)
          // Simulates an outer-loop latch that mem2reg threaded %iv through.
          // %iv is the header's block param — it escapes into this external block.
 -        f.block_mut(outer_latch).terminator =
 -            Some(Terminator::Branch(outer_dest, vec![iv]));
 +        f.block_mut(outer_latch).terminator = Some(Terminator::Branch(outer_dest, vec![iv]));
          // outer_dest(%x): ret void
          let x = f.next_value_id();
          f.block_mut(outer_dest).params.push(BlockParam {
 -            id: x, ty: IrType::Int(IntWidth::I64),
 +            id: x,
 +            ty: IrType::Int(IntWidth::I64),
          });
          f.block_mut(outer_dest).terminator = Some(Terminator::Return(None));

src/opt/unswitch.rsmodified

332 lines changed — click to load

  //! Gated on body size (≤ UNSWITCH_MAX_BODY instructions) to prevent
  //! code bloat. Fires at O2+.
 -use std::collections::{HashMap, HashSet};
 -use crate::ir::inst::*;
 -use crate::ir::walk::{find_natural_loops, predecessors, prune_unreachable};
  use super::loop_utils::{find_preheader, loop_defined_values};
  use super::pass::Pass;
 +use crate::ir::inst::*;
 +use crate::ir::walk::{find_natural_loops, predecessors, prune_unreachable};
 +use std::collections::{HashMap, HashSet};
  /// Maximum number of instructions in the loop body to consider for
  /// unswitching. Unswitching doubles the code, so keep this tight.
  pub struct LoopUnswitch;
 -type UnswitchCandidate = (BlockId, ValueId, BlockId, Vec<ValueId>, BlockId, Vec<ValueId>);
 +type UnswitchCandidate = (
 +    BlockId,
 +    ValueId,
 +    BlockId,
 +    Vec<ValueId>,
 +    BlockId,
 +    Vec<ValueId>,
 +);
  impl Pass for LoopUnswitch {
 -    fn name(&self) -> &'static str { "loop-unswitch" }
 +    fn name(&self) -> &'static str {
 +        "loop-unswitch"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          for func in &mut module.functions {
 -            if unswitch_in_function(func) { changed = true; }
 +            if unswitch_in_function(func) {
 +                changed = true;
 +            }
+         }
          changed
+     }
      let preds = predecessors(func);
      for lp in &loops {
 -        let Some(ph_id) = find_preheader(func, lp, &preds) else { continue };
 +        let Some(ph_id) = find_preheader(func, lp, &preds) else {
 +            continue;
 +        };
          // Size guard.
 -        let total_insts: usize = lp.body.iter()
 -            .map(|&b| func.block(b).insts.len())
 -            .sum();
 -        if total_insts > UNSWITCH_MAX_BODY { continue; }
 +        let total_insts: usize = lp.body.iter().map(|&b| func.block(b).insts.len()).sum();
 +        if total_insts > UNSWITCH_MAX_BODY {
 +            continue;
 +        }
          // Find a CondBranch inside the loop whose condition is invariant.
          let loop_defs = loop_defined_values(func, lp);
          let candidate = find_unswitch_candidate(func, lp, &loop_defs);
 -        let Some((cond_block, cond_val, true_dest, true_args, false_dest, false_args)) = candidate else {
 +        let Some((cond_block, cond_val, true_dest, true_args, false_dest, false_args)) = candidate
 +        else {
              continue;
          };
          let true_cond_block = true_map[&cond_block];
          let true_true_dest = true_map[&true_dest];
          let true_val_map = build_value_map(func, lp, &true_blocks, &true_map);
 -        let remapped_true_args: Vec<ValueId> = true_args.iter()
 +        let remapped_true_args: Vec<ValueId> = true_args
 +            .iter()
              .map(|v| *true_val_map.get(v).unwrap_or(v))
              .collect();
          func.block_mut(true_cond_block).terminator =
          let false_cond_block = false_map[&cond_block];
          let false_false_dest = false_map[&false_dest];
          let false_val_map = build_value_map(func, lp, &false_blocks, &false_map);
 -        let remapped_false_args: Vec<ValueId> = false_args.iter()
 +        let remapped_false_args: Vec<ValueId> = false_args
 +            .iter()
              .map(|v| *false_val_map.get(v).unwrap_or(v))
              .collect();
          func.block_mut(false_cond_block).terminator =
      for &bid in &lp.body {
          let block = func.block(bid);
          if let Some(Terminator::CondBranch {
 -            cond, true_dest, true_args, false_dest, false_args,
 -        }) = &block.terminator {
 +            cond,
 +            true_dest,
 +            true_args,
 +            false_dest,
 +            false_args,
 +        }) = &block.terminator
 +        {
              // Condition must be loop-invariant (not defined in the loop).
              if !loop_defs.contains(cond) {
                  // Both targets must be in the loop (not the loop exit).
                  if lp.body.contains(true_dest) && lp.body.contains(false_dest) {
 -                    return Some((bid, *cond, *true_dest, true_args.clone(),
 -                                 *false_dest, false_args.clone()));
 +                    return Some((
 +                        bid,
 +                        *cond,
 +                        *true_dest,
 +                        true_args.clone(),
 +                        *false_dest,
 +                        false_args.clone(),
 +                    ));
+                 }
+             }
+         }
  #[cfg(test)]
  mod tests {
      use super::*;
 -    use crate::ir::types::{IrType, IntWidth};
 +    use crate::ir::types::{IntWidth, IrType};
 +    use crate::lexer::{Position, Span};
      use crate::opt::pass::Pass;
 -    use crate::lexer::{Span, Position};
      fn span() -> Span {
          let pos = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: pos, end: pos }
 +        Span {
 +            file_id: 0,
 +            start: pos,
 +            end: pos,
 +        }
+     }
      /// Build: entry → preheader → header(%i) → cmp → body → cond_branch(flag, t_body, f_body) →
          let mut f = Function::new("test".into(), vec![], IrType::Void);
          let preheader = f.create_block("preheader");
 -        let header    = f.create_block("header");
 -        let cmp_blk   = f.create_block("cmp");
 -        let body      = f.create_block("body");
 -        let t_body    = f.create_block("t_body");
 -        let f_body    = f.create_block("f_body");
 -        let latch     = f.create_block("latch");
 -        let exit      = f.create_block("exit");
 -        let entry     = f.entry;
 +        let header = f.create_block("header");
 +        let cmp_blk = f.create_block("cmp");
 +        let body = f.create_block("body");
 +        let t_body = f.create_block("t_body");
 +        let f_body = f.create_block("f_body");
 +        let latch = f.create_block("latch");
 +        let exit = f.create_block("exit");
 +        let entry = f.entry;
          // Entry: flag = const_bool(true), c1 = const 1, c10 = const 10
          let flag = f.next_value_id();
          f.register_type(flag, IrType::Bool);
          f.block_mut(entry).insts.push(Inst {
 -            id: flag, ty: IrType::Bool, span: span(),
 +            id: flag,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ConstBool(true),
          });
          let c1 = f.next_value_id();
          f.register_type(c1, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c1, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c1,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let c10 = f.next_value_id();
          f.register_type(c10, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c10, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c10,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(10, IntWidth::I32),
          });
          f.block_mut(entry).terminator = Some(Terminator::Branch(preheader, vec![]));
          // Header(%i) → cmp
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          f.block_mut(header).terminator = Some(Terminator::Branch(cmp_blk, vec![]));
          // Cmp: icmp le %i, 10; condBr body, exit
          let cmp_v = f.next_value_id();
          f.register_type(cmp_v, IrType::Bool);
          f.block_mut(cmp_blk).insts.push(Inst {
 -            id: cmp_v, ty: IrType::Bool, span: span(),
 +            id: cmp_v,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, c10),
          });
          f.block_mut(cmp_blk).terminator = Some(Terminator::CondBranch {
              cond: cmp_v,
 -            true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // Body: condBr flag, t_body, f_body  ← the unswitchable conditional
          f.block_mut(body).terminator = Some(Terminator::CondBranch {
              cond: flag,
 -            true_dest: t_body, true_args: vec![],
 -            false_dest: f_body, false_args: vec![],
 +            true_dest: t_body,
 +            true_args: vec![],
 +            false_dest: f_body,
 +            false_args: vec![],
          });
          // t_body → latch
          let nxt = f.next_value_id();
          f.register_type(nxt, IrType::Int(IntWidth::I32));
          f.block_mut(latch).insts.push(Inst {
 -            id: nxt, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: nxt,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::IAdd(iv, c1),
          });
          f.block_mut(latch).terminator = Some(Terminator::Branch(header, vec![nxt]));
          // After unswitching, the preheader should have a CondBranch (not a Branch).
          let f = &m.functions[0];
 -        let preheader = f.blocks.iter().find(|b| b.name.contains("preheader")).unwrap();
 +        let preheader = f
 +            .blocks
 +            .iter()
 +            .find(|b| b.name.contains("preheader"))
 +            .unwrap();
          assert!(
              matches!(&preheader.terminator, Some(Terminator::CondBranch { .. })),
 -            "preheader should now have a CondBranch: {:?}", preheader.terminator
 +            "preheader should now have a CondBranch: {:?}",
 +            preheader.terminator
          );
+     }
          let c1 = f.next_value_id();
          f.register_type(c1, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c1, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c1,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(1, IntWidth::I32),
          });
          let c10 = f.next_value_id();
          f.register_type(c10, IrType::Int(IntWidth::I32));
          f.block_mut(entry).insts.push(Inst {
 -            id: c10, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: c10,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::ConstInt(10, IntWidth::I32),
          });
          f.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![c1]));
          let iv = f.next_value_id();
          f.register_type(iv, IrType::Int(IntWidth::I32));
 -        f.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 +        f.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
          let cmp_v = f.next_value_id();
          f.register_type(cmp_v, IrType::Bool);
          f.block_mut(header).insts.push(Inst {
 -            id: cmp_v, ty: IrType::Bool, span: span(),
 +            id: cmp_v,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, c10),
          });
          f.block_mut(header).terminator = Some(Terminator::CondBranch {
              cond: cmp_v,
 -            true_dest: body, true_args: vec![],
 -            false_dest: exit, false_args: vec![],
 +            true_dest: body,
 +            true_args: vec![],
 +            false_dest: exit,
 +            false_args: vec![],
          });
          // Body: the "conditional" uses the IV (loop-variant).
          let iv_cmp = f.next_value_id();
          f.register_type(iv_cmp, IrType::Bool);
          f.block_mut(body).insts.push(Inst {
 -            id: iv_cmp, ty: IrType::Bool, span: span(),
 +            id: iv_cmp,
 +            ty: IrType::Bool,
 +            span: span(),
              kind: InstKind::ICmp(CmpOp::Le, iv, c1),
          });
          f.block_mut(body).terminator = Some(Terminator::CondBranch {
              cond: iv_cmp,
 -            true_dest: latch, true_args: vec![],
 -            false_dest: latch, false_args: vec![],
 +            true_dest: latch,
 +            true_args: vec![],
 +            false_dest: latch,
 +            false_args: vec![],
          });
          let nxt = f.next_value_id();
          f.register_type(nxt, IrType::Int(IntWidth::I32));
          f.block_mut(latch).insts.push(Inst {
 -            id: nxt, ty: IrType::Int(IntWidth::I32), span: span(),
 +            id: nxt,
 +            ty: IrType::Int(IntWidth::I32),
 +            span: span(),
              kind: InstKind::IAdd(iv, c1),
          });
          f.block_mut(latch).terminator = Some(Terminator::Branch(header, vec![nxt]));

src/opt/util.rsmodified

22 lines changed — click to load

  // flagged it as dead code from this module's perspective.
  #[allow(unused_imports)]
  pub use crate::ir::walk::{
 -    inst_uses,
 -    terminator_uses,
 -    terminator_targets,
 -    for_each_operand_mut,
 -    for_each_terminator_operand_mut,
 -    substitute_uses,
 -    predecessors,
 -    compute_dominators,
 -    compute_immediate_dominators,
 -    dominator_tree_children,
 -    compute_dominance_frontiers,
 -    find_natural_loops,
 -    NaturalLoop,
 -    prune_unreachable,
 +    compute_dominance_frontiers, compute_dominators, compute_immediate_dominators,
 +    dominator_tree_children, find_natural_loops, for_each_operand_mut,
 +    for_each_terminator_operand_mut, inst_uses, predecessors, prune_unreachable, substitute_uses,
 +    terminator_targets, terminator_uses, NaturalLoop,
  };

src/opt/vectorize.rsmodified

320 lines changed — click to load

  pub struct Vectorize;
  impl Pass for Vectorize {
 -    fn name(&self) -> &'static str { "vectorize" }
 +    fn name(&self) -> &'static str {
 +        "vectorize"
 +    }
      fn run(&self, module: &mut Module) -> bool {
          let mut changed = false;
          }) => (*cond, *true_dest, *false_dest, true_args, false_args),
          _ => return None,
      };
 -    if !true_args.is_empty() || !false_args.is_empty() || true_dest != body || lp.body.contains(&false_dest) {
 +    if !true_args.is_empty()
 +        || !false_args.is_empty()
 +        || true_dest != body
 +        || lp.body.contains(&false_dest)
 +    {
          return None;
+     }
      let cond_inst = header_block.insts.iter().find(|inst| inst.id == cond_id)?;
      let iv_bound = match cond_inst.kind {
          InstKind::ICmp(CmpOp::Le, lhs, rhs) if lhs == iv_param => resolve_const_int(func, rhs)?,
 -        InstKind::ICmp(CmpOp::Lt, lhs, rhs) if lhs == iv_param => resolve_const_int(func, rhs)?.checked_sub(1)?,
 +        InstKind::ICmp(CmpOp::Lt, lhs, rhs) if lhs == iv_param => {
 +            resolve_const_int(func, rhs)?.checked_sub(1)?
 +        }
          _ => return None,
      };
          return None;
+     }
 -    let mut stores = body
 -        .insts
 -        .iter()
 -        .filter_map(|inst| match inst.kind {
 -            InstKind::Store(value, ptr) => Some((inst.span, value, ptr)),
 -            _ => None,
 -        });
 +    let mut stores = body.insts.iter().filter_map(|inst| match inst.kind {
 +        InstKind::Store(value, ptr) => Some((inst.span, value, ptr)),
 +        _ => None,
 +    });
      let (span, stored_value, dest_ptr) = stores.next()?;
      if stores.next().is_some() {
          return None;
          return None;
+     }
 -    let plan = if let Some(scalar) = classify_invariant_scalar(func, loop_defs, stored_value, &dest.elem_ty) {
 +    let plan = if let Some(scalar) =
 +        classify_invariant_scalar(func, loop_defs, stored_value, &dest.elem_ty)
 +    {
          let kernel = fill_kernel_name(&dest.elem_ty)?;
          KernelPlan::Fill {
              kernel,
      (func.value_type(value).as_ref() == Some(elem_ty)).then_some(value)
+ }
 -fn classify_loaded_array(func: &Function, value: ValueId, iv_param: ValueId) -> Option<ArrayAccess> {
 +fn classify_loaded_array(
 +    func: &Function,
 +    value: ValueId,
 +    iv_param: ValueId,
 +) -> Option<ArrayAccess> {
      let defs = inst_map(func);
      let inst = defs.get(&value)?;
      let InstKind::Load(ptr) = inst.kind else {
          if lp.body.contains(&block.id) {
              continue;
+         }
 -        if block
 -            .insts
 -            .iter()
 -            .any(|inst| inst_uses(&inst.kind).into_iter().any(|value| loop_defs.contains(&value)))
 -        {
 +        if block.insts.iter().any(|inst| {
 +            inst_uses(&inst.kind)
 +                .into_iter()
 +                .any(|value| loop_defs.contains(&value))
 +        }) {
              return true;
+         }
 -        if block
 -            .terminator
 -            .as_ref()
 -            .is_some_and(|term| terminator_uses(term).into_iter().any(|value| loop_defs.contains(&value)))
 -        {
 +        if block.terminator.as_ref().is_some_and(|term| {
 +            terminator_uses(term)
 +                .into_iter()
 +                .any(|value| loop_defs.contains(&value))
 +        }) {
              return true;
+         }
+     }
  ) {
      let n_id = ensure_i64_const(func, shape.preheader, kernel_len(plan) as i64, span);
      let (kernel, args) = match plan {
 -        KernelPlan::Fill { kernel, dest, scalar, .. } => (kernel, vec![dest, n_id, scalar]),
 -        KernelPlan::ArrayBinary { kernel, dest, lhs, rhs, .. } => (kernel, vec![dest, lhs, rhs, n_id]),
 -        KernelPlan::ArrayScalar { kernel, dest, src, scalar, .. } => {
 -            (kernel, vec![dest, src, scalar, n_id])
 -        }
 -        KernelPlan::ScalarArray { kernel, dest, scalar, src, .. } => {
 -            (kernel, vec![dest, scalar, src, n_id])
 -        }
 +        KernelPlan::Fill {
 +            kernel,
 +            dest,
 +            scalar,
 +            ..
 +        } => (kernel, vec![dest, n_id, scalar]),
 +        KernelPlan::ArrayBinary {
 +            kernel,
 +            dest,
 +            lhs,
 +            rhs,
 +            ..
 +        } => (kernel, vec![dest, lhs, rhs, n_id]),
 +        KernelPlan::ArrayScalar {
 +            kernel,
 +            dest,
 +            src,
 +            scalar,
 +            ..
 +        } => (kernel, vec![dest, src, scalar, n_id]),
 +        KernelPlan::ScalarArray {
 +            kernel,
 +            dest,
 +            scalar,
 +            src,
 +            ..
 +        } => (kernel, vec![dest, scalar, src, n_id]),
      };
      let id = func.next_value_id();
  mod tests {
      use super::*;
      use crate::ir::types::IrType;
 -    use crate::opt::pass::Pass;
      use crate::lexer::{Position, Span};
 +    use crate::opt::pass::Pass;
      fn dummy_span() -> Span {
          let p = Position { line: 0, col: 0 };
 -        Span { file_id: 0, start: p, end: p }
 +        Span {
 +            file_id: 0,
 +            start: p,
 +            end: p,
 +        }
+     }
      fn push_inst(func: &mut Function, block: BlockId, kind: InstKind, ty: IrType) -> ValueId {
          let id = func.next_value_id();
          func.register_type(id, ty.clone());
 -        func.block_mut(block).insts.push(Inst { id, kind, ty, span: dummy_span() });
 +        func.block_mut(block).insts.push(Inst {
 +            id,
 +            kind,
 +            ty,
 +            span: dummy_span(),
 +        });
          id
+     }
              &mut func,
              entry,
              InstKind::Alloca(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 32)),
 -            IrType::Ptr(Box::new(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 32))),
 +            IrType::Ptr(Box::new(IrType::Array(
 +                Box::new(IrType::Int(IntWidth::I32)),
 +                32,
 +            ))),
          );
          let b = push_inst(
              &mut func,
              entry,
              InstKind::Alloca(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 32)),
 -            IrType::Ptr(Box::new(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 32))),
 +            IrType::Ptr(Box::new(IrType::Array(
 +                Box::new(IrType::Int(IntWidth::I32)),
 +                32,
 +            ))),
          );
          let c = push_inst(
              &mut func,
              entry,
              InstKind::Alloca(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 32)),
 -            IrType::Ptr(Box::new(IrType::Array(Box::new(IrType::Int(IntWidth::I32)), 32))),
 +            IrType::Ptr(Box::new(IrType::Array(
 +                Box::new(IrType::Int(IntWidth::I32)),
 +                32,
 +            ))),
 +        );
 +        let one_i32 = push_inst(
 +            &mut func,
 +            entry,
 +            InstKind::ConstInt(1, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let hi_i32 = push_inst(
 +            &mut func,
 +            entry,
 +            InstKind::ConstInt(32, IntWidth::I32),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let one_i64 = push_inst(
 +            &mut func,
 +            entry,
 +            InstKind::ConstInt(1, IntWidth::I64),
 +            IrType::Int(IntWidth::I64),
          );
 -        let one_i32 = push_inst(&mut func, entry, InstKind::ConstInt(1, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let hi_i32 = push_inst(&mut func, entry, InstKind::ConstInt(32, IntWidth::I32), IrType::Int(IntWidth::I32));
 -        let one_i64 = push_inst(&mut func, entry, InstKind::ConstInt(1, IntWidth::I64), IrType::Int(IntWidth::I64));
          func.block_mut(entry).terminator = Some(Terminator::Branch(header, vec![one_i32]));
          let iv = func.next_value_id();
          func.register_type(iv, IrType::Int(IntWidth::I32));
 -        func.block_mut(header).params.push(BlockParam { id: iv, ty: IrType::Int(IntWidth::I32) });
 -        let cmp = push_inst(&mut func, header, InstKind::ICmp(CmpOp::Le, iv, hi_i32), IrType::Bool);
 +        func.block_mut(header).params.push(BlockParam {
 +            id: iv,
 +            ty: IrType::Int(IntWidth::I32),
 +        });
 +        let cmp = push_inst(
 +            &mut func,
 +            header,
 +            InstKind::ICmp(CmpOp::Le, iv, hi_i32),
 +            IrType::Bool,
 +        );
          func.block_mut(header).terminator = Some(Terminator::CondBranch {
              cond: cmp,
              true_dest: body,
              false_args: vec![],
          });
 -        let idx64 = push_inst(&mut func, body, InstKind::IntExtend(iv, IntWidth::I64, true), IrType::Int(IntWidth::I64));
 -        let offset = push_inst(&mut func, body, InstKind::ISub(idx64, one_i64), IrType::Int(IntWidth::I64));
 -        let a_ptr = push_inst(&mut func, body, InstKind::GetElementPtr(a, vec![offset]), IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let a_val = push_inst(&mut func, body, InstKind::Load(a_ptr), IrType::Int(IntWidth::I32));
 -        let b_ptr = push_inst(&mut func, body, InstKind::GetElementPtr(b, vec![offset]), IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 -        let b_val = push_inst(&mut func, body, InstKind::Load(b_ptr), IrType::Int(IntWidth::I32));
 -        let sum = push_inst(&mut func, body, InstKind::IAdd(a_val, b_val), IrType::Int(IntWidth::I32));
 -        let c_ptr = push_inst(&mut func, body, InstKind::GetElementPtr(c, vec![offset]), IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))));
 +        let idx64 = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::IntExtend(iv, IntWidth::I64, true),
 +            IrType::Int(IntWidth::I64),
 +        );
 +        let offset = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::ISub(idx64, one_i64),
 +            IrType::Int(IntWidth::I64),
 +        );
 +        let a_ptr = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::GetElementPtr(a, vec![offset]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let a_val = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::Load(a_ptr),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let b_ptr = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::GetElementPtr(b, vec![offset]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
 +        let b_val = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::Load(b_ptr),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let sum = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::IAdd(a_val, b_val),
 +            IrType::Int(IntWidth::I32),
 +        );
 +        let c_ptr = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::GetElementPtr(c, vec![offset]),
 +            IrType::Ptr(Box::new(IrType::Int(IntWidth::I32))),
 +        );
          push_inst(&mut func, body, InstKind::Store(sum, c_ptr), IrType::Void);
 -        let next = push_inst(&mut func, body, InstKind::IAdd(iv, one_i32), IrType::Int(IntWidth::I32));
 +        let next = push_inst(
 +            &mut func,
 +            body,
 +            InstKind::IAdd(iv, one_i32),
 +            IrType::Int(IntWidth::I32),
 +        );
          func.block_mut(body).terminator = Some(Terminator::Branch(header, vec![next]));
          func.block_mut(exit).terminator = Some(Terminator::Return(None));
          module.add_function(func);
          let changed = Vectorize.run(&mut module);
 -        assert!(changed, "vectorize should rewrite the counted array-add loop");
 +        assert!(
 +            changed,
 +            "vectorize should rewrite the counted array-add loop"
 +        );
          let func = &module.functions[0];
          let entry_block = func.block(entry);

src/parser/decl.rsmodified

1041 lines changed — click to load

  //! Parses type declarations, USE statements, IMPLICIT, derived type
  //! definitions, and legacy declaration forms (COMMON, DATA, etc.).
 -use crate::ast::Spanned;
 +use super::{ParseError, Parser};
  use crate::ast::decl::*;
 +use crate::ast::Spanned;
  use crate::lexer::TokenKind;
 -use super::{Parser, ParseError};
  impl<'a> Parser<'a> {
      // ---- Type specifier parsing ----
      pub fn try_parse_type_spec(&mut self) -> Option<Result<TypeSpec, ParseError>> {
          let text = self.peek_text().to_lowercase();
          match text.as_str() {
 -            "integer" => { self.advance(); Some(self.parse_kind_selector().map(TypeSpec::Integer)) }
 -            "real" => { self.advance(); Some(self.parse_kind_selector().map(TypeSpec::Real)) }
 +            "integer" => {
 +                self.advance();
 +                Some(self.parse_kind_selector().map(TypeSpec::Integer))
 +            }
 +            "real" => {
 +                self.advance();
 +                Some(self.parse_kind_selector().map(TypeSpec::Real))
 +            }
              "doubleprecision" | "double" => {
                  self.advance();
                  // Handle "double precision" / "double complex" as two tokens.
                      Some(Ok(TypeSpec::DoublePrecision))
+                 }
+             }
 -            "complex" => { self.advance(); Some(self.parse_kind_selector().map(TypeSpec::Complex)) }
 -            "doublecomplex" => { self.advance(); Some(Ok(TypeSpec::DoubleComplex)) }
 -            "logical" => { self.advance(); Some(self.parse_kind_selector().map(TypeSpec::Logical)) }
 -            "character" => { self.advance(); Some(self.parse_char_selector().map(TypeSpec::Character)) }
 +            "complex" => {
 +                self.advance();
 +                Some(self.parse_kind_selector().map(TypeSpec::Complex))
 +            }
 +            "doublecomplex" => {
 +                self.advance();
 +                Some(Ok(TypeSpec::DoubleComplex))
 +            }
 +            "logical" => {
 +                self.advance();
 +                Some(self.parse_kind_selector().map(TypeSpec::Logical))
 +            }
 +            "character" => {
 +                self.advance();
 +                Some(self.parse_char_selector().map(TypeSpec::Character))
 +            }
              "type" => {
                  // type(name) is a type specifier, but type :: name is a derived type definition.
                  // Only consume if followed by (.
      fn parse_implicit_type_spec(&mut self) -> Option<Result<TypeSpec, ParseError>> {
          let text = self.peek_text().to_lowercase();
          match text.as_str() {
 -            "integer" => { self.advance(); Some(Ok(TypeSpec::Integer(None))) }
 -            "real" => { self.advance(); Some(Ok(TypeSpec::Real(None))) }
 +            "integer" => {
 +                self.advance();
 +                Some(Ok(TypeSpec::Integer(None)))
 +            }
 +            "real" => {
 +                self.advance();
 +                Some(Ok(TypeSpec::Real(None)))
 +            }
              "doubleprecision" | "double" => {
                  self.advance();
                  if self.peek_text().eq_ignore_ascii_case("precision") {
                      Some(Ok(TypeSpec::DoublePrecision))
+                 }
+             }
 -            "complex" => { self.advance(); Some(Ok(TypeSpec::Complex(None))) }
 -            "logical" => { self.advance(); Some(Ok(TypeSpec::Logical(None))) }
 -            "character" => { self.advance(); Some(Ok(TypeSpec::Character(None))) }
 +            "complex" => {
 +                self.advance();
 +                Some(Ok(TypeSpec::Complex(None)))
 +            }
 +            "logical" => {
 +                self.advance();
 +                Some(Ok(TypeSpec::Logical(None)))
 +            }
 +            "character" => {
 +                self.advance();
 +                Some(Ok(TypeSpec::Character(None)))
 +            }
              _ => None,
+         }
+     }
              return Ok(None);
+         }
          self.advance(); // (
 -        // Check for kind= keyword
 +                        // Check for kind= keyword
          if self.peek_text().eq_ignore_ascii_case("kind") {
              let next_pos = self.pos + 1;
              if next_pos < self.tokens.len() && self.tokens[next_pos].kind == TokenKind::Assign {
          // Check for *N (old-style)
          if self.eat(&TokenKind::Star) {
              let len = self.parse_len_spec()?;
 -            return Ok(Some(CharSelector { len: Some(len), kind: None }));
 +            return Ok(Some(CharSelector {
 +                len: Some(len),
 +                kind: None,
 +            }));
+         }
          if self.peek() != &TokenKind::LParen {
              return Ok(None);
          self.expect(&TokenKind::LParen)?;
          if self.eat(&TokenKind::Star) {
              self.expect(&TokenKind::RParen)?;
 -            return Ok(if is_class { TypeSpec::ClassStar } else { TypeSpec::TypeStar });
 +            return Ok(if is_class {
 +                TypeSpec::ClassStar
 +            } else {
 +                TypeSpec::TypeStar
 +            });
+         }
          if self.peek() != &TokenKind::Identifier {
              return Err(self.error(format!("expected type name, got {}", self.peek())));
          let name_tok = self.advance().clone();
          let name = name_tok.text;
          self.expect(&TokenKind::RParen)?;
 -        Ok(if is_class { TypeSpec::Class(name) } else { TypeSpec::Type(name) })
 +        Ok(if is_class {
 +            TypeSpec::Class(name)
 +        } else {
 +            TypeSpec::Type(name)
 +        })
+     }
      // ---- Attribute parsing ----
      pub fn try_parse_attribute(&mut self) -> Option<Result<Attribute, ParseError>> {
          let text = self.peek_text().to_lowercase();
          match text.as_str() {
 -            "allocatable" => { self.advance(); Some(Ok(Attribute::Allocatable)) }
 -            "pointer" => { self.advance(); Some(Ok(Attribute::Pointer)) }
 -            "target" => { self.advance(); Some(Ok(Attribute::Target)) }
 -            "optional" => { self.advance(); Some(Ok(Attribute::Optional)) }
 -            "save" => { self.advance(); Some(Ok(Attribute::Save)) }
 -            "parameter" => { self.advance(); Some(Ok(Attribute::Parameter)) }
 -            "value" => { self.advance(); Some(Ok(Attribute::Value)) }
 -            "volatile" => { self.advance(); Some(Ok(Attribute::Volatile)) }
 -            "asynchronous" => { self.advance(); Some(Ok(Attribute::Asynchronous)) }
 -            "protected" => { self.advance(); Some(Ok(Attribute::Protected)) }
 -            "contiguous" => { self.advance(); Some(Ok(Attribute::Contiguous)) }
 -            "external" => { self.advance(); Some(Ok(Attribute::External)) }
 -            "intrinsic" => { self.advance(); Some(Ok(Attribute::Intrinsic)) }
 -            "public" => { self.advance(); Some(Ok(Attribute::Public)) }
 -            "private" => { self.advance(); Some(Ok(Attribute::Private)) }
 +            "allocatable" => {
 +                self.advance();
 +                Some(Ok(Attribute::Allocatable))
 +            }
 +            "pointer" => {
 +                self.advance();
 +                Some(Ok(Attribute::Pointer))
 +            }
 +            "target" => {
 +                self.advance();
 +                Some(Ok(Attribute::Target))
 +            }
 +            "optional" => {
 +                self.advance();
 +                Some(Ok(Attribute::Optional))
 +            }
 +            "save" => {
 +                self.advance();
 +                Some(Ok(Attribute::Save))
 +            }
 +            "parameter" => {
 +                self.advance();
 +                Some(Ok(Attribute::Parameter))
 +            }
 +            "value" => {
 +                self.advance();
 +                Some(Ok(Attribute::Value))
 +            }
 +            "volatile" => {
 +                self.advance();
 +                Some(Ok(Attribute::Volatile))
 +            }
 +            "asynchronous" => {
 +                self.advance();
 +                Some(Ok(Attribute::Asynchronous))
 +            }
 +            "protected" => {
 +                self.advance();
 +                Some(Ok(Attribute::Protected))
 +            }
 +            "contiguous" => {
 +                self.advance();
 +                Some(Ok(Attribute::Contiguous))
 +            }
 +            "external" => {
 +                self.advance();
 +                Some(Ok(Attribute::External))
 +            }
 +            "intrinsic" => {
 +                self.advance();
 +                Some(Ok(Attribute::Intrinsic))
 +            }
 +            "public" => {
 +                self.advance();
 +                Some(Ok(Attribute::Public))
 +            }
 +            "private" => {
 +                self.advance();
 +                Some(Ok(Attribute::Private))
 +            }
              "dimension" => {
                  self.advance();
                  Some(self.parse_dimension_spec().map(Attribute::Dimension))
          let mut specs = Vec::new();
          loop {
              specs.push(self.parse_one_array_spec()?);
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          Ok(specs)
+     }
                  return Ok(ArraySpec::AssumedShape { lower: Some(first) });
+             }
              let upper = self.parse_expr()?;
 -            return Ok(ArraySpec::Explicit { lower: Some(first), upper });
 +            return Ok(ArraySpec::Explicit {
 +                lower: Some(first),
 +                upper,
 +            });
+         }
          // Just an upper bound (lower is 1 implicitly).
 -        Ok(ArraySpec::Explicit { lower: None, upper: first })
 +        Ok(ArraySpec::Explicit {
 +            lower: None,
 +            upper: first,
 +        })
+     }
      fn parse_intent_spec(&mut self) -> Result<Intent, ParseError> {
                      Intent::In
+                 }
+             }
 -            "out" => { self.advance(); Intent::Out }
 -            "inout" => { self.advance(); Intent::InOut }
 -            _ => return Err(self.error(format!("expected intent specifier, got {}", self.peek_text()))),
 +            "out" => {
 +                self.advance();
 +                Intent::Out
 +            }
 +            "inout" => {
 +                self.advance();
 +                Intent::InOut
 +            }
 +            _ => {
 +                return Err(self.error(format!(
 +                    "expected intent specifier, got {}",
 +                    self.peek_text()
 +                )))
 +            }
          };
          self.expect(&TokenKind::RParen)?;
          Ok(intent)
          let entities = self.parse_entity_list()?;
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
 -        Ok(Spanned::new(Decl::TypeDecl { type_spec, attrs, entities }, span))
 +        Ok(Spanned::new(
 +            Decl::TypeDecl {
 +                type_spec,
 +                attrs,
 +                entities,
 +            },
 +            span,
 +        ))
+     }
      fn parse_entity_list(&mut self) -> Result<Vec<EntityDecl>, ParseError> {
          let mut entities = Vec::new();
          loop {
              entities.push(self.parse_entity_decl()?);
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          Ok(entities)
+     }
          if self.peek() == &TokenKind::LBracket {
              return Err(
 -                self.error("coarray declarations are recognized but not yet implemented".into()),
 +                self.error("coarray declarations are recognized but not yet implemented".into())
              );
+         }
              None
          };
 -        Ok(EntityDecl { name, array_spec, char_len, init, ptr_init })
 +        Ok(EntityDecl {
 +            name,
 +            array_spec,
 +            char_len,
 +            init,
 +            ptr_init,
 +        })
+     }
      // ---- USE statement ----
+         }
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
 -        Ok(Spanned::new(Decl::UseStmt { module, nature, renames, only }, span))
 +        Ok(Spanned::new(
 +            Decl::UseStmt {
 +                module,
 +                nature,
 +                renames,
 +                only,
 +            },
 +            span,
 +        ))
+     }
      fn parse_only_list(&mut self) -> Result<Vec<OnlyItem>, ParseError> {
          let mut items = Vec::new();
 -        if self.at_stmt_end() { return Ok(items); }
 +        if self.at_stmt_end() {
 +            return Ok(items);
 +        }
          loop {
              let name = self.advance().clone().text;
              if self.eat(&TokenKind::Arrow) {
                  let remote = self.advance().clone().text;
 -                items.push(OnlyItem::Rename(Rename { local: name, remote }));
 +                items.push(OnlyItem::Rename(Rename {
 +                    local: name,
 +                    remote,
 +                }));
              } else {
                  items.push(OnlyItem::Name(name));
+             }
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          Ok(items)
+     }
              self.expect(&TokenKind::Arrow)?;
              let remote = self.advance().clone().text;
              renames.push(Rename { local, remote });
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          Ok(renames)
+     }
                  loop {
                      let spec = self.peek_text().to_lowercase();
                      match spec.as_str() {
 -                        "type" => { self.advance(); type_ = true; }
 -                        "external" => { self.advance(); external = true; }
 +                        "type" => {
 +                            self.advance();
 +                            type_ = true;
 +                        }
 +                        "external" => {
 +                            self.advance();
 +                            external = true;
 +                        }
                          _ => break,
+                     }
 -                    if !self.eat(&TokenKind::Comma) { break; }
 +                    if !self.eat(&TokenKind::Comma) {
 +                        break;
 +                    }
+                 }
                  self.expect(&TokenKind::RParen)?;
+             }
          // is a letter range, not kind=i-n.
          let mut specs = Vec::new();
          loop {
 -            let type_spec = self.parse_implicit_type_spec()
 +            let type_spec = self
 +                .parse_implicit_type_spec()
                  .ok_or_else(|| self.error("expected type specifier in IMPLICIT".into()))??;
              self.expect(&TokenKind::LParen)?;
              let mut ranges = Vec::new();
                  self.expect(&TokenKind::Minus)?;
                  let end_letter = self.advance().clone().text.chars().next().unwrap_or('z');
                  ranges.push((start_letter, end_letter));
 -                if !self.eat(&TokenKind::Comma) { break; }
 +                if !self.eat(&TokenKind::Comma) {
 +                    break;
 +                }
+             }
              self.expect(&TokenKind::RParen)?;
              specs.push(ImplicitSpec { type_spec, ranges });
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
          while self.eat(&TokenKind::Comma) {
              let text = self.peek_text().to_lowercase();
              match text.as_str() {
 -                "abstract" => { self.advance(); attrs.push(TypeAttr::Abstract); }
 -                "public" => { self.advance(); attrs.push(TypeAttr::Public); }
 -                "private" => { self.advance(); attrs.push(TypeAttr::Private); }
 +                "abstract" => {
 +                    self.advance();
 +                    attrs.push(TypeAttr::Abstract);
 +                }
 +                "public" => {
 +                    self.advance();
 +                    attrs.push(TypeAttr::Public);
 +                }
 +                "private" => {
 +                    self.advance();
 +                    attrs.push(TypeAttr::Private);
 +                }
                  "bind" => {
                      self.advance();
                      let name = self.parse_bind_spec()?;
                  loop {
                      self.skip_newlines();
                      let proc_text = self.peek_text().to_lowercase();
 -                    if proc_text == "end" { break; }
 -                    if proc_text == "endtype" { break; }
 +                    if proc_text == "end" {
 +                        break;
 +                    }
 +                    if proc_text == "endtype" {
 +                        break;
 +                    }
                      if proc_text == "procedure" {
                          self.advance();
                          final_procs.push(name);
                      } else {
                          // Skip unknown lines in contains section.
 -                        while !self.at_stmt_end() { self.advance(); }
 +                        while !self.at_stmt_end() {
 +                            self.advance();
 +                        }
+                     }
                      self.skip_newlines();
+                 }
                  components.push(comp);
              } else {
                  // Skip unrecognized lines.
 -                while !self.at_stmt_end() { self.advance(); }
 +                while !self.at_stmt_end() {
 +                    self.advance();
 +                }
                  self.skip_newlines();
+             }
+         }
+         }
          let extends = attrs.iter().find_map(|a| {
 -            if let TypeAttr::Extends(ref p) = a { Some(p.clone()) } else { None }
 +            if let TypeAttr::Extends(ref p) = a {
 +                Some(p.clone())
 +            } else {
 +                None
 +            }
          });
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
 -        Ok(Spanned::new(Decl::DerivedTypeDef {
 -            name, extends, attrs, components, type_bound_procs, final_procs,
 -        }, span))
 +        Ok(Spanned::new(
 +            Decl::DerivedTypeDef {
 +                name,
 +                extends,
 +                attrs,
 +                components,
 +                type_bound_procs,
 +                final_procs,
 +            },
 +            span,
 +        ))
+     }
      fn parse_type_bound_proc(&mut self) -> Result<TypeBoundProc, ParseError> {
          } else {
              None
          };
 -        Ok(TypeBoundProc { name, binding, attrs: proc_attrs, is_generic: false })
 +        Ok(TypeBoundProc {
 +            name,
 +            binding,
 +            attrs: proc_attrs,
 +            is_generic: false,
 +        })
+     }
      fn parse_type_bound_proc_generic(&mut self) -> Result<TypeBoundProc, ParseError> {
          } else {
              None
          };
 -        Ok(TypeBoundProc { name, binding, attrs: Vec::new(), is_generic: true })
 +        Ok(TypeBoundProc {
 +            name,
 +            binding,
 +            attrs: Vec::new(),
 +            is_generic: true,
 +        })
+     }
      // ---- PARAMETER, COMMON, EQUIVALENCE, DATA ----
              self.expect(&TokenKind::Assign)?;
              let value = self.parse_expr()?;
              pairs.push((name, value));
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          self.expect(&TokenKind::RParen)?;
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
          let mut vars = Vec::new();
          loop {
              vars.push(self.advance().clone().text);
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
          Ok(Spanned::new(Decl::CommonBlock { name, vars }, span))
              let mut objects = Vec::new();
              while self.peek() != &TokenKind::Slash {
                  objects.push(self.parse_expr_bp(BP_MUL.right)?);
 -                if !self.eat(&TokenKind::Comma) { break; }
 +                if !self.eat(&TokenKind::Comma) {
 +                    break;
 +                }
+             }
              self.expect(&TokenKind::Slash)?;
              let mut values = Vec::new();
              while self.peek() != &TokenKind::Slash {
                  values.push(self.parse_expr_bp(BP_MUL.right)?);
 -                if !self.eat(&TokenKind::Comma) { break; }
 +                if !self.eat(&TokenKind::Comma) {
 +                    break;
 +                }
+             }
              self.expect(&TokenKind::Slash)?;
              sets.push(DataSet { objects, values });
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
              // Check if next batch starts or if we're at end of statement.
 -            if self.at_stmt_end() { break; }
 +            if self.at_stmt_end() {
 +                break;
 +            }
+         }
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
          Ok(Spanned::new(Decl::DataStmt { sets }, span))
              let mut group = Vec::new();
              loop {
                  group.push(self.parse_expr()?);
 -                if !self.eat(&TokenKind::Comma) { break; }
 +                if !self.eat(&TokenKind::Comma) {
 +                    break;
 +                }
+             }
              self.expect(&TokenKind::RParen)?;
              groups.push(group);
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          let span = crate::parser::expr::span_from_to(start, self.prev_span());
          Ok(Spanned::new(Decl::EquivalenceStmt { groups }, span))
      #[test]
      fn integer_simple() {
          let d = parse_decl("integer :: x, y, z");
 -        if let Decl::TypeDecl { type_spec, entities, .. } = &d.node {
 +        if let Decl::TypeDecl {
 +            type_spec,
 +            entities,
 +            ..
 +        } = &d.node
 +        {
              assert!(matches!(type_spec, TypeSpec::Integer(None)));
              assert_eq!(entities.len(), 3);
              assert_eq!(entities[0].name, "x");
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          if let Decl::TypeDecl { entities, .. } = &d.node {
              assert!(entities[0].init.is_some());
              assert!(entities[1].init.is_some());
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("integer(8) :: x");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::Integer(Some(_))));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
      fn real_allocatable() {
          let d = parse_decl("real(8), allocatable :: matrix(:,:)");
 -        if let Decl::TypeDecl { type_spec, attrs, entities } = &d.node {
 +        if let Decl::TypeDecl {
 +            type_spec,
 +            attrs,
 +            entities,
 +        } = &d.node
 +        {
              assert!(matches!(type_spec, TypeSpec::Real(Some(_))));
              assert!(attrs.contains(&Attribute::Allocatable));
              assert!(entities[0].array_spec.is_some());
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
      fn character_deferred_length() {
          let d = parse_decl("character(len=:), allocatable :: name");
 -        if let Decl::TypeDecl { type_spec, attrs, .. } = &d.node {
 +        if let Decl::TypeDecl {
 +            type_spec, attrs, ..
 +        } = &d.node
 +        {
              if let TypeSpec::Character(Some(cs)) = type_spec {
                  assert!(matches!(cs.len, Some(LenSpec::Colon)));
 -            } else { panic!("not character type"); }
 +            } else {
 +                panic!("not character type");
 +            }
              assert!(attrs.contains(&Attribute::Allocatable));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
      fn character_assumed_length() {
          let d = parse_decl("character(len=*), intent(in) :: input");
 -        if let Decl::TypeDecl { type_spec, attrs, .. } = &d.node {
 +        if let Decl::TypeDecl {
 +            type_spec, attrs, ..
 +        } = &d.node
 +        {
              if let TypeSpec::Character(Some(cs)) = type_spec {
                  assert!(matches!(cs.len, Some(LenSpec::Star)));
 -            } else { panic!("not character type"); }
 -            assert!(attrs.iter().any(|a| matches!(a, Attribute::Intent(Intent::In))));
 -        } else { panic!("not TypeDecl"); }
 +            } else {
 +                panic!("not character type");
 +            }
 +            assert!(attrs
 +                .iter()
 +                .any(|a| matches!(a, Attribute::Intent(Intent::In))));
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("type(my_type) :: obj");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::Type(ref n) if n == "my_type"));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("class(*) :: poly");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::ClassStar));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("type(node), pointer :: ptr => null()");
          if let Decl::TypeDecl { entities, .. } = &d.node {
              assert!(entities[0].ptr_init.is_some());
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
      fn intent_inout() {
          let d = parse_decl("real, intent(inout) :: x");
          if let Decl::TypeDecl { attrs, .. } = &d.node {
 -            assert!(attrs.iter().any(|a| matches!(a, Attribute::Intent(Intent::InOut))));
 -        } else { panic!("not TypeDecl"); }
 +            assert!(attrs
 +                .iter()
 +                .any(|a| matches!(a, Attribute::Intent(Intent::InOut))));
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
      fn intent_in_out_two_words() {
          let d = parse_decl("real, intent(in out) :: x");
          if let Decl::TypeDecl { attrs, .. } = &d.node {
 -            assert!(attrs.iter().any(|a| matches!(a, Attribute::Intent(Intent::InOut))));
 -        } else { panic!("not TypeDecl"); }
 +            assert!(attrs
 +                .iter()
 +                .any(|a| matches!(a, Attribute::Intent(Intent::InOut))));
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          if let Decl::TypeDecl { attrs, .. } = &d.node {
              assert!(attrs.iter().any(|a| matches!(a, Attribute::Dimension(_))));
              assert!(attrs.contains(&Attribute::Allocatable));
 -            assert!(attrs.iter().any(|a| matches!(a, Attribute::Intent(Intent::InOut))));
 -        } else { panic!("not TypeDecl"); }
 +            assert!(attrs
 +                .iter()
 +                .any(|a| matches!(a, Attribute::Intent(Intent::InOut))));
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          if let Decl::TypeDecl { entities, .. } = &d.node {
              assert_eq!(entities.len(), 2);
              assert_eq!(entities[0].name, "x");
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("double precision :: x");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::DoublePrecision));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("integer, bind(c) :: x");
          if let Decl::TypeDecl { attrs, .. } = &d.node {
              assert!(attrs.iter().any(|a| matches!(a, Attribute::Bind(None))));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      // ---- USE statements ----
          if let Decl::UseStmt { module, nature, .. } = &d.node {
              assert_eq!(module, "my_module");
              assert_eq!(*nature, UseNature::Normal);
 -        } else { panic!("not UseStmt"); }
 +        } else {
 +            panic!("not UseStmt");
 +        }
+     }
      #[test]
          if let Decl::UseStmt { only, .. } = &d.node {
              let items = only.as_ref().unwrap();
              assert_eq!(items.len(), 2);
 -        } else { panic!("not UseStmt"); }
 +        } else {
 +            panic!("not UseStmt");
 +        }
+     }
      #[test]
          if let Decl::UseStmt { module, nature, .. } = &d.node {
              assert_eq!(module, "iso_c_binding");
              assert_eq!(*nature, UseNature::Intrinsic);
 -        } else { panic!("not UseStmt"); }
 +        } else {
 +            panic!("not UseStmt");
 +        }
+     }
      #[test]
          if let Decl::UseStmt { only, .. } = &d.node {
              let items = only.as_ref().unwrap();
              assert!(matches!(&items[0], OnlyItem::Rename(_)));
 -        } else { panic!("not UseStmt"); }
 +        } else {
 +            panic!("not UseStmt");
 +        }
+     }
      // ---- IMPLICIT ----
      #[test]
      fn implicit_none() {
          let d = parse_decl("implicit none");
 -        assert!(matches!(d.node, Decl::ImplicitNone { type_: true, external: false }));
 +        assert!(matches!(
 +            d.node,
 +            Decl::ImplicitNone {
 +                type_: true,
 +                external: false
 +            }
 +        ));
+     }
      #[test]
      fn implicit_none_type_external() {
          let d = parse_decl("implicit none(type, external)");
 -        assert!(matches!(d.node, Decl::ImplicitNone { type_: true, external: true }));
 +        assert!(matches!(
 +            d.node,
 +            Decl::ImplicitNone {
 +                type_: true,
 +                external: true
 +            }
 +        ));
+     }
      #[test]
              assert_eq!(specs.len(), 1);
              assert!(matches!(specs[0].type_spec, TypeSpec::DoublePrecision));
              assert_eq!(specs[0].ranges.len(), 2);
 -        } else { panic!("not ImplicitStmt"); }
 +        } else {
 +            panic!("not ImplicitStmt");
 +        }
+     }
      // ---- PARAMETER, COMMON, DATA, EQUIVALENCE ----
              assert_eq!(pairs.len(), 2);
              assert_eq!(pairs[0].0, "pi");
              assert_eq!(pairs[1].0, "e");
 -        } else { panic!("not ParameterStmt"); }
 +        } else {
 +            panic!("not ParameterStmt");
 +        }
+     }
      #[test]
          if let Decl::CommonBlock { name, vars } = &d.node {
              assert_eq!(name.as_deref(), Some("block1"));
              assert_eq!(vars.len(), 3);
 -        } else { panic!("not CommonBlock"); }
 +        } else {
 +            panic!("not CommonBlock");
 +        }
+     }
      #[test]
          let d = parse_decl("data x /1.0/, y /2.0/");
          if let Decl::DataStmt { sets } = &d.node {
              assert_eq!(sets.len(), 2);
 -        } else { panic!("not DataStmt"); }
 +        } else {
 +            panic!("not DataStmt");
 +        }
+     }
      #[test]
          if let Decl::EquivalenceStmt { groups } = &d.node {
              assert_eq!(groups.len(), 2);
              assert_eq!(groups[0].len(), 2);
 -        } else { panic!("not EquivalenceStmt"); }
 +        } else {
 +            panic!("not EquivalenceStmt");
 +        }
+     }
      // ---- Audit test gap coverage ----
      fn real_star8_old_style() {
          let d = parse_decl("real*8 :: x");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
 -            assert!(matches!(type_spec, TypeSpec::Real(Some(KindSelector::Star(_)))));
 -        } else { panic!("not TypeDecl"); }
 +            assert!(matches!(
 +                type_spec,
 +                TypeSpec::Real(Some(KindSelector::Star(_)))
 +            ));
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              if let TypeSpec::Character(Some(cs)) = type_spec {
                  assert!(matches!(cs.len, Some(LenSpec::Expr(_))));
 -            } else { panic!("not character type"); }
 -        } else { panic!("not TypeDecl"); }
 +            } else {
 +                panic!("not character type");
 +            }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("integer(kind=4) :: x");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::Integer(Some(_))));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("class(my_type) :: x");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::Class(ref n) if n == "my_type"));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("type(*) :: x");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::TypeStar));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("logical :: flag");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::Logical(None)));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("complex :: z");
          if let Decl::TypeDecl { type_spec, .. } = &d.node {
              assert!(matches!(type_spec, TypeSpec::Complex(None)));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("implicit integer (i-n)");
          if let Decl::ImplicitStmt { specs } = &d.node {
              assert!(matches!(specs[0].type_spec, TypeSpec::Integer(_)));
 -        } else { panic!("not ImplicitStmt"); }
 +        } else {
 +            panic!("not ImplicitStmt");
 +        }
+     }
      #[test]
          let d = parse_decl("use :: my_module");
          if let Decl::UseStmt { module, .. } = &d.node {
              assert_eq!(module, "my_module");
 -        } else { panic!("not UseStmt"); }
 +        } else {
 +            panic!("not UseStmt");
 +        }
+     }
      #[test]
          let d = parse_decl("integer, bind(c, name='cfunc') :: x");
          if let Decl::TypeDecl { attrs, .. } = &d.node {
              assert!(attrs.iter().any(|a| matches!(a, Attribute::Bind(Some(_)))));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("integer, save :: x");
          if let Decl::TypeDecl { attrs, .. } = &d.node {
              assert!(attrs.contains(&Attribute::Save));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
      #[test]
          let d = parse_decl("integer, value :: x");
          if let Decl::TypeDecl { attrs, .. } = &d.node {
              assert!(attrs.contains(&Attribute::Value));
 -        } else { panic!("not TypeDecl"); }
 +        } else {
 +            panic!("not TypeDecl");
 +        }
+     }
+ }

src/parser/expr.rsmodified

557 lines changed — click to load

  //! unary operators, function calls, array constructors, and
  //! component access chains.
 -use crate::ast::Spanned;
 +use super::{ParseError, Parser};
  use crate::ast::expr::*;
 -use crate::lexer::{TokenKind, Span};
 -use super::{Parser, ParseError};
 +use crate::ast::Spanned;
 +use crate::lexer::{Span, TokenKind};
  /// Binding power for Pratt parsing.
  /// Higher = tighter binding. Each level has left and right binding power.
  // Precedence levels (from Fortran standard, lowest to highest).
  // We use even numbers for left bp, odd for right, to create the half-levels
  // needed for associativity.
 -const BP_DEFINED_BINARY: Bp = Bp { left: 2, right: 3 };  // .myop. (binary)
 -const BP_EQV: Bp = Bp { left: 4, right: 5 };             // .eqv., .neqv.
 -const BP_OR: Bp = Bp { left: 6, right: 7 };              // .or.
 -const BP_AND: Bp = Bp { left: 8, right: 9 };             // .and.
 -const BP_NOT: u8 = 10;                                    // .not. (unary, right)
 -const BP_COMPARISON: Bp = Bp { left: 12, right: 12 };    // ==, /=, <, >, <=, >= (non-assoc)
 -const BP_CONCAT: Bp = Bp { left: 14, right: 15 };        // //
 -const BP_ADD: Bp = Bp { left: 16, right: 17 };           // +, - (binary)
 -const BP_UNARY_ADD: u8 = 18;                              // +, - (unary)
 -pub(crate) const BP_MUL: Bp = Bp { left: 20, right: 21 };           // *, /
 -const BP_POW: Bp = Bp { left: 23, right: 22 };           // ** (RIGHT-assoc: left > right)
 -const BP_DEFINED_UNARY: u8 = 24;                          // .myop. (unary)
 +const BP_DEFINED_BINARY: Bp = Bp { left: 2, right: 3 }; // .myop. (binary)
 +const BP_EQV: Bp = Bp { left: 4, right: 5 }; // .eqv., .neqv.
 +const BP_OR: Bp = Bp { left: 6, right: 7 }; // .or.
 +const BP_AND: Bp = Bp { left: 8, right: 9 }; // .and.
 +const BP_NOT: u8 = 10; // .not. (unary, right)
 +const BP_COMPARISON: Bp = Bp {
 +    left: 12,
 +    right: 12,
 +}; // ==, /=, <, >, <=, >= (non-assoc)
 +const BP_CONCAT: Bp = Bp {
 +    left: 14,
 +    right: 15,
 +}; // //
 +const BP_ADD: Bp = Bp {
 +    left: 16,
 +    right: 17,
 +}; // +, - (binary)
 +const BP_UNARY_ADD: u8 = 18; // +, - (unary)
 +pub(crate) const BP_MUL: Bp = Bp {
 +    left: 20,
 +    right: 21,
 +}; // *, /
 +const BP_POW: Bp = Bp {
 +    left: 23,
 +    right: 22,
 +}; // ** (RIGHT-assoc: left > right)
 +const BP_DEFINED_UNARY: u8 = 24; // .myop. (unary)
  impl<'a> Parser<'a> {
      /// Parse an expression.
              // Check for infix operator.
              let Some(bp) = self.infix_bp() else { break };
 -            if bp.left < min_bp { break; }
 +            if bp.left < min_bp {
 +                break;
 +            }
              // Non-associative operators: if left_bp == right_bp and we're at the
              // same precedence level, reject chaining (e.g., a < b < c is illegal).
              if bp.left == bp.right && bp.left == min_bp {
                  return Err(self.error(
 -                    "chained comparison operators are not allowed in Fortran (non-associative)".into()
 +                    "chained comparison operators are not allowed in Fortran (non-associative)"
 +                        .into(),
                  ));
+             }
                  end: right.span.end,
              };
 -            left = Spanned::new(Expr::BinaryOp {
 -                op,
 -                left: Box::new(left),
 -                right: Box::new(right),
 -            }, span);
 +            left = Spanned::new(
 +                Expr::BinaryOp {
 +                    op,
 +                    left: Box::new(left),
 +                    right: Box::new(right),
 +                },
 +                span,
 +            );
+         }
          Ok(left)
                  self.advance();
                  let operand = self.parse_expr_bp(BP_UNARY_ADD)?;
                  let span = span_from_to(start, operand.span);
 -                Ok(Spanned::new(Expr::UnaryOp {
 -                    op: UnaryOp::Plus,
 -                    operand: Box::new(operand),
 -                }, span))
 +                Ok(Spanned::new(
 +                    Expr::UnaryOp {
 +                        op: UnaryOp::Plus,
 +                        operand: Box::new(operand),
 +                    },
 +                    span,
 +                ))
+             }
              TokenKind::Minus => {
                  self.advance();
                  let operand = self.parse_expr_bp(BP_UNARY_ADD)?;
                  let span = span_from_to(start, operand.span);
 -                Ok(Spanned::new(Expr::UnaryOp {
 -                    op: UnaryOp::Minus,
 -                    operand: Box::new(operand),
 -                }, span))
 +                Ok(Spanned::new(
 +                    Expr::UnaryOp {
 +                        op: UnaryOp::Minus,
 +                        operand: Box::new(operand),
 +                    },
 +                    span,
 +                ))
+             }
              TokenKind::DotOp(ref name) if name == "not" => {
                  self.advance();
                  let operand = self.parse_expr_bp(BP_NOT)?;
                  let span = span_from_to(start, operand.span);
 -                Ok(Spanned::new(Expr::UnaryOp {
 -                    op: UnaryOp::Not,
 -                    operand: Box::new(operand),
 -                }, span))
 +                Ok(Spanned::new(
 +                    Expr::UnaryOp {
 +                        op: UnaryOp::Not,
 +                        operand: Box::new(operand),
 +                    },
 +                    span,
 +                ))
+             }
              TokenKind::DefinedOp(ref name) => {
                  let op_name = name.clone();
                  self.advance();
                  let operand = self.parse_expr_bp(BP_DEFINED_UNARY)?;
                  let span = span_from_to(start, operand.span);
 -                Ok(Spanned::new(Expr::UnaryOp {
 -                    op: UnaryOp::Defined(op_name),
 -                    operand: Box::new(operand),
 -                }, span))
 +                Ok(Spanned::new(
 +                    Expr::UnaryOp {
 +                        op: UnaryOp::Defined(op_name),
 +                        operand: Box::new(operand),
 +                    },
 +                    span,
 +                ))
+             }
              // Parenthesized expression or array constructor (/ ... /).
                      let imag = self.parse_expr()?;
                      self.expect(&TokenKind::RParen)?;
                      let span = span_from_to(start, self.prev_span());
 -                    return Ok(Spanned::new(Expr::ComplexLiteral {
 -                        real: Box::new(inner),
 -                        imag: Box::new(imag),
 -                    }, span));
 +                    return Ok(Spanned::new(
 +                        Expr::ComplexLiteral {
 +                            real: Box::new(inner),
 +                            imag: Box::new(imag),
 +                        },
 +                        span,
 +                    ));
+                 }
                  self.expect(&TokenKind::RParen)?;
                  let span = span_from_to(start, self.prev_span());
 -                Ok(Spanned::new(Expr::ParenExpr {
 -                    inner: Box::new(inner),
 -                }, span))
 +                Ok(Spanned::new(
 +                    Expr::ParenExpr {
 +                        inner: Box::new(inner),
 +                    },
 +                    span,
 +                ))
+             }
              // Array constructor [...]
                      let args = self.parse_argument_list()?;
                      self.expect(&TokenKind::RParen)?;
                      let span = span_from_to(expr.span, self.prev_span());
 -                    expr = Spanned::new(Expr::FunctionCall {
 -                        callee: Box::new(expr),
 -                        args,
 -                    }, span);
 +                    expr = Spanned::new(
 +                        Expr::FunctionCall {
 +                            callee: Box::new(expr),
 +                            args,
 +                        },
 +                        span,
 +                    );
+                 }
                  // Component access: expr%name
                  TokenKind::Percent => {
                          });
+                     }
                      let span = span_from_to(expr.span, name_tok.span);
 -                    expr = Spanned::new(Expr::ComponentAccess {
 -                        base: Box::new(expr),
 -                        component: name_tok.text,
 -                    }, span);
 +                    expr = Spanned::new(
 +                        Expr::ComponentAccess {
 +                            base: Box::new(expr),
 +                            component: name_tok.text,
 +                        },
 +                        span,
 +                    );
+                 }
                  _ => break,
+             }
              TokenKind::Plus => Some(BP_ADD),
              TokenKind::Minus => Some(BP_ADD),
              TokenKind::Concat => Some(BP_CONCAT),
 -            TokenKind::Eq | TokenKind::Ne | TokenKind::Lt |
 -            TokenKind::Le | TokenKind::Gt | TokenKind::Ge => Some(BP_COMPARISON),
 +            TokenKind::Eq
 +            | TokenKind::Ne
 +            | TokenKind::Lt
 +            | TokenKind::Le
 +            | TokenKind::Gt
 +            | TokenKind::Ge => Some(BP_COMPARISON),
              TokenKind::DotOp(ref name) => match name.as_str() {
                  "eq" | "ne" | "lt" | "le" | "gt" | "ge" => Some(BP_COMPARISON),
                  "and" => Some(BP_AND),
          let tok = self.advance().clone();
          // Strip outer quotes for the value.
          let value = if tok.text.len() >= 2 {
 -            tok.text[1..tok.text.len()-1].replace("''", "'").replace("\"\"", "\"")
 +            tok.text[1..tok.text.len() - 1]
 +                .replace("''", "'")
 +                .replace("\"\"", "\"")
          } else {
              tok.text.clone()
          };
 -        Ok(Spanned::new(Expr::StringLiteral { value, kind: None }, tok.span))
 +        Ok(Spanned::new(
 +            Expr::StringLiteral { value, kind: None },
 +            tok.span,
 +        ))
+     }
      fn parse_logical_literal(&mut self) -> Result<SpannedExpr, ParseError> {
          let tok = self.advance().clone();
          let lower = tok.text.to_lowercase();
          let value = lower.contains("true");
 -        let kind = lower.find("._").map(|pos| {
 -            lower[pos+2..].trim_end_matches('.').to_string()
 -        });
 +        let kind = lower
 +            .find("._")
 +            .map(|pos| lower[pos + 2..].trim_end_matches('.').to_string());
          Ok(Spanned::new(Expr::LogicalLiteral { value, kind }, tok.span))
+     }
              b'Z' | b'z' => BozBase::Hex,
              _ => BozBase::Hex,
          };
 -        Ok(Spanned::new(Expr::BozLiteral { text: tok.text, base }, tok.span))
 +        Ok(Spanned::new(
 +            Expr::BozLiteral {
 +                text: tok.text,
 +                base,
 +            },
 +            tok.span,
 +        ))
+     }
      fn parse_name(&mut self) -> Result<SpannedExpr, ParseError> {
          loop {
              let arg = self.parse_argument()?;
              args.push(arg);
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          Ok(args)
+     }
          // Leading colon → range with no start: :end or : or ::stride
          if matches!(self.peek(), TokenKind::Colon | TokenKind::ColonColon) {
              let sub = self.parse_range(None)?;
 -            return Ok(Argument { keyword: None, value: sub });
 +            return Ok(Argument {
 +                keyword: None,
 +                value: sub,
 +            });
+         }
          // Parse an expression.
          // If followed by colon, it's a range: start:end[:stride]
          if self.peek() == &TokenKind::Colon {
              let sub = self.parse_range(Some(expr))?;
 -            return Ok(Argument { keyword: None, value: sub });
 +            return Ok(Argument {
 +                keyword: None,
 +                value: sub,
 +            });
+         }
          // Plain element.
 -        Ok(Argument { keyword: None, value: SectionSubscript::Element(expr) })
 +        Ok(Argument {
 +            keyword: None,
 +            value: SectionSubscript::Element(expr),
 +        })
+     }
      /// Parse a range subscript: [start]:end[:stride] or [start]: or :
      fn parse_range(&mut self, start: Option<SpannedExpr>) -> Result<SectionSubscript, ParseError> {
          // Handle :: (ColonColon token) as two colons — means start::stride with no end.
          if self.eat(&TokenKind::ColonColon) {
 -            let stride = if !matches!(self.peek(),
 -                TokenKind::Comma | TokenKind::RParen | TokenKind::RBracket)
 -            {
 +            let stride = if !matches!(
 +                self.peek(),
 +                TokenKind::Comma | TokenKind::RParen | TokenKind::RBracket
 +            ) {
                  Some(self.parse_expr()?)
              } else {
                  None
              };
 -            return Ok(SectionSubscript::Range { start, end: None, stride });
 +            return Ok(SectionSubscript::Range {
 +                start,
 +                end: None,
 +                stride,
 +            });
+         }
          self.expect(&TokenKind::Colon)?; // consume first colon
          // Parse end (optional — absent if next is colon, comma, ), ], or ::).
 -        let end = if !matches!(self.peek(),
 -            TokenKind::Colon | TokenKind::ColonColon | TokenKind::Comma |
 -            TokenKind::RParen | TokenKind::RBracket)
 -        {
 +        let end = if !matches!(
 +            self.peek(),
 +            TokenKind::Colon
 +                | TokenKind::ColonColon
 +                | TokenKind::Comma
 +                | TokenKind::RParen
 +                | TokenKind::RBracket
 +        ) {
              Some(self.parse_expr()?)
          } else {
              None
          // Parse stride (optional, after second colon).
          let stride = if self.eat(&TokenKind::Colon) {
 -            if !matches!(self.peek(),
 -                TokenKind::Comma | TokenKind::RParen | TokenKind::RBracket)
 -            {
 +            if !matches!(
 +                self.peek(),
 +                TokenKind::Comma | TokenKind::RParen | TokenKind::RBracket
 +            ) {
                  Some(self.parse_expr()?)
              } else {
                  None
          if self.peek() != &TokenKind::RBracket {
              loop {
                  values.push(self.parse_ac_value()?);
 -                if !self.eat(&TokenKind::Comma) { break; }
 +                if !self.eat(&TokenKind::Comma) {
 +                    break;
 +                }
+             }
+         }
          self.expect(&TokenKind::RBracket)?;
          let span = span_from_to(start, self.prev_span());
 -        Ok(Spanned::new(Expr::ArrayConstructor { type_spec, values }, span))
 +        Ok(Spanned::new(
 +            Expr::ArrayConstructor { type_spec, values },
 +            span,
 +        ))
+     }
      fn parse_array_constructor_slash(&mut self, start: Span) -> Result<SpannedExpr, ParseError> {
          // parenthesised implied-do form and errored on `=`.
          let mut values = Vec::new();
          loop {
 -            if matches!(self.peek(), TokenKind::Slash) { break; }
 +            if matches!(self.peek(), TokenKind::Slash) {
 +                break;
 +            }
              values.push(self.parse_ac_value_bracketed(BP_MUL.right)?);
 -            if !self.eat(&TokenKind::Comma) { break; }
 +            if !self.eat(&TokenKind::Comma) {
 +                break;
 +            }
+         }
          self.expect(&TokenKind::Slash)?;
          self.expect(&TokenKind::RParen)?;
          let span = span_from_to(start, self.prev_span());
 -        Ok(Spanned::new(Expr::ArrayConstructor { type_spec: None, values }, span))
 +        Ok(Spanned::new(
 +            Expr::ArrayConstructor {
 +                type_spec: None,
 +                values,
 +            },
 +            span,
 +        ))
+     }
      /// Variant of parse_ac_value that honours a minimum binding
              "or" => Ok(BinaryOp::Or),
              "eqv" => Ok(BinaryOp::Eqv),
              "neqv" => Ok(BinaryOp::Neqv),
 -            _ => Err(ParseError { span: tok.span, msg: format!("unknown dot-operator .{}.", name) }),
 +            _ => Err(ParseError {
 +                span: tok.span,
 +                msg: format!("unknown dot-operator .{}.", name),
 +            }),
          },
          TokenKind::DefinedOp(name) => Ok(BinaryOp::Defined(name.clone())),
 -        _ => Err(ParseError { span: tok.span, msg: format!("expected operator, got {}", tok.kind) }),
 +        _ => Err(ParseError {
 +            span: tok.span,
 +            msg: format!("expected operator, got {}", tok.kind),
 +        }),
+     }
+ }
  fn split_kind_suffix(text: &str) -> (String, Option<String>) {
      if let Some(pos) = text.find('_') {
          let num = text[..pos].to_string();
 -        let kind = text[pos+1..].to_string();
 +        let kind = text[pos + 1..].to_string();
          if kind.is_empty() {
              (text.to_string(), None)
          } else {
      // ---- Literals ----
 -    #[test] fn integer() { assert_eq!(sexpr("42"), "42"); }
 -    #[test] fn integer_kind() { assert_eq!(sexpr("42_8"), "42"); }
 -    #[test] fn real() { assert_eq!(sexpr("3.14"), "3.14"); }
 -    #[test] fn real_exp() { assert_eq!(sexpr("1.0e5"), "1.0e5"); }
 -    #[test] fn real_double() { assert_eq!(sexpr("1.0d0"), "1.0d0"); }
 -    #[test] fn string_single() { assert_eq!(sexpr("'hello'"), "'hello'"); }
 -    #[test] fn string_double() { assert_eq!(sexpr("\"hello\""), "'hello'"); }
 -    #[test] fn logical_true() { assert_eq!(sexpr(".true."), ".true."); }
 -    #[test] fn logical_false() { assert_eq!(sexpr(".false."), ".false."); }
 -    #[test] fn boz() { assert_eq!(sexpr("B'1010'"), "B'1010'"); }
 -    #[test] fn complex_literal() { assert_eq!(sexpr("(1.0, 2.0)"), "(1.0, 2.0)"); }
 -    #[test] fn complex_literal_exprs() { assert_eq!(sexpr("(a + b, c * d)"), "((a + b), (c * d))"); }
 -    #[test] fn name() { assert_eq!(sexpr("x"), "x"); }
 +    #[test]
 +    fn integer() {
 +        assert_eq!(sexpr("42"), "42");
 +    }
 +    #[test]
 +    fn integer_kind() {
 +        assert_eq!(sexpr("42_8"), "42");
 +    }
 +    #[test]
 +    fn real() {
 +        assert_eq!(sexpr("3.14"), "3.14");
 +    }
 +    #[test]
 +    fn real_exp() {
 +        assert_eq!(sexpr("1.0e5"), "1.0e5");
 +    }
 +    #[test]
 +    fn real_double() {
 +        assert_eq!(sexpr("1.0d0"), "1.0d0");
 +    }
 +    #[test]
 +    fn string_single() {
 +        assert_eq!(sexpr("'hello'"), "'hello'");
 +    }
 +    #[test]
 +    fn string_double() {
 +        assert_eq!(sexpr("\"hello\""), "'hello'");
 +    }
 +    #[test]
 +    fn logical_true() {
 +        assert_eq!(sexpr(".true."), ".true.");
 +    }
 +    #[test]
 +    fn logical_false() {
 +        assert_eq!(sexpr(".false."), ".false.");
 +    }
 +    #[test]
 +    fn boz() {
 +        assert_eq!(sexpr("B'1010'"), "B'1010'");
 +    }
 +    #[test]
 +    fn complex_literal() {
 +        assert_eq!(sexpr("(1.0, 2.0)"), "(1.0, 2.0)");
 +    }
 +    #[test]
 +    fn complex_literal_exprs() {
 +        assert_eq!(sexpr("(a + b, c * d)"), "((a + b), (c * d))");
 +    }
 +    #[test]
 +    fn name() {
 +        assert_eq!(sexpr("x"), "x");
 +    }
      // ---- Arithmetic precedence ----
      #[test]
      fn mixed_comparison_and_logical() {
 -        assert_eq!(
 -            sexpr("x > 0 .and. y < 10"),
 -            "((x > 0) .and. (y < 10))"
 -        );
 +        assert_eq!(sexpr("x > 0 .and. y < 10"), "((x > 0) .and. (y < 10))");
+     }
      #[test]
+     }
      // ---- BOZ variants ----
 -    #[test] fn boz_octal() { assert_eq!(sexpr("O'777'"), "O'777'"); }
 -    #[test] fn boz_hex() { assert_eq!(sexpr("Z'FF'"), "Z'FF'"); }
 +    #[test]
 +    fn boz_octal() {
 +        assert_eq!(sexpr("O'777'"), "O'777'");
 +    }
 +    #[test]
 +    fn boz_hex() {
 +        assert_eq!(sexpr("Z'FF'"), "Z'FF'");
 +    }
      // ---- Real literal edge cases ----
 -    #[test] fn real_leading_dot() { assert_eq!(sexpr(".5"), ".5"); }
 -    #[test] fn real_trailing_dot() { assert_eq!(sexpr("5."), "5."); }
 +    #[test]
 +    fn real_leading_dot() {
 +        assert_eq!(sexpr(".5"), ".5");
 +    }
 +    #[test]
 +    fn real_trailing_dot() {
 +        assert_eq!(sexpr("5."), "5.");
 +    }
      // ---- Mixed postfix chains ----
      #[test]

src/parser/mod.rsmodified

61 lines changed — click to load

  //! Expression parsing uses a Pratt parser with 12 precedence levels
  //! matching the Fortran standard exactly.
 -pub mod expr;
  pub mod decl;
 +pub mod expr;
  pub mod stmt;
  pub mod unit;
 -use crate::lexer::{Token, TokenKind, Span};
 +use crate::lexer::{Span, Token, TokenKind};
  use std::fmt;
  impl fmt::Display for ParseError {
      fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 -        write!(f, "{}:{}: error: {}", self.span.start.line, self.span.start.col, self.msg)
 +        write!(
 +            f,
 +            "{}:{}: error: {}",
 +            self.span.start.line, self.span.start.col, self.msg
 +        )
+     }
+ }
      /// F2018 §6.3.2: a semicolon separates statements on the same line
      /// and is semantically equivalent to a newline.
      pub fn skip_newlines(&mut self) {
 -        while matches!(self.peek(), TokenKind::Newline | TokenKind::Comment | TokenKind::Semicolon) {
 +        while matches!(
 +            self.peek(),
 +            TokenKind::Newline | TokenKind::Comment | TokenKind::Semicolon
 +        ) {
              self.advance();
+         }
+     }
      /// Check if we're at a statement-ending token.
      pub fn at_stmt_end(&self) -> bool {
 -        matches!(self.peek(), TokenKind::Newline | TokenKind::Semicolon | TokenKind::Eof | TokenKind::Comment)
 +        matches!(
 +            self.peek(),
 +            TokenKind::Newline | TokenKind::Semicolon | TokenKind::Eof | TokenKind::Comment
 +        )
+     }
      /// Check if the token at offset `n` from current position is a statement terminator.
      pub fn at_stmt_end_after(&self, n: usize) -> bool {
          let idx = self.pos + n;
 -        if idx >= self.tokens.len() { return true; }
 -        matches!(self.tokens[idx].kind, TokenKind::Newline | TokenKind::Semicolon | TokenKind::Eof | TokenKind::Comment)
 +        if idx >= self.tokens.len() {
 +            return true;
 +        }
 +        matches!(
 +            self.tokens[idx].kind,
 +            TokenKind::Newline | TokenKind::Semicolon | TokenKind::Eof | TokenKind::Comment
 +        )
+     }
+ }

src/parser/stmt.rsmodified

43 lines changed — click to load

                      Some(TokenKind::Identifier)
                  );
                  if looks_like_entry_stmt {
 -                    Err(self.error("ENTRY statements are recognized but not yet implemented".into()))
 +                    Err(self
 +                        .error("ENTRY statements are recognized but not yet implemented".into()))
                  } else {
                      self.parse_assignment_or_call(start)
+                 }
                  let span = span_from_to(start, self.prev_span());
                  Ok(Spanned::new(Stmt::Continue { label: None }, span))
+             }
 -            "sync" => Err(self.error("coarray SYNC statements are recognized but not yet implemented".into())),
 +            "sync" => {
 +                Err(self
 +                    .error("coarray SYNC statements are recognized but not yet implemented".into()))
 +            }
              _ => self.parse_assignment_or_call(start),
+         }
+     }
          loop {
              self.skip_newlines();
              if self.peek() == &TokenKind::Eof {
 -                return Err(
 -                    self.error(format!("expected statement with terminating label {}", label))
 -                );
 +                return Err(self.error(format!(
 +                    "expected statement with terminating label {}",
 +                    label
 +                )));
+             }
              let is_terminator = self.peek() == &TokenKind::IntegerLiteral
          let tokens = Lexer::tokenize("entry g(y)\n", 0).unwrap();
          let mut parser = Parser::new(&tokens);
          let err = parser.parse_stmt().expect_err("ENTRY should not parse yet");
 -        assert!(err.msg.contains("ENTRY statements are recognized but not yet implemented"));
 +        assert!(err
 +            .msg
 +            .contains("ENTRY statements are recognized but not yet implemented"));
+     }
      #[test]

src/preprocess/mod.rsmodified

697 lines changed — click to load

  impl MacroDef {
      pub fn object(body: &str) -> Self {
 -        Self { body: body.into(), params: Vec::new(), is_function: false, is_variadic: false }
 +        Self {
 +            body: body.into(),
 +            params: Vec::new(),
 +            is_function: false,
 +            is_variadic: false,
 +        }
+     }
      pub fn function(params: Vec<String>, body: &str) -> Self {
 -        Self { body: body.into(), params, is_function: true, is_variadic: false }
 +        Self {
 +            body: body.into(),
 +            params,
 +            is_function: true,
 +            is_variadic: false,
 +        }
+     }
+ }
      fn make_source_loc(&self, filename: &str, line: u32) -> SourceLoc {
          if let Some((override_line, ref override_file)) = self.line_override {
 -            let fname = if override_file.is_empty() { filename } else { override_file.as_str() };
 -            SourceLoc { filename: fname.into(), line: override_line }
 +            let fname = if override_file.is_empty() {
 +                filename
 +            } else {
 +                override_file.as_str()
 +            };
 +            SourceLoc {
 +                filename: fname.into(),
 +                line: override_line,
 +            }
          } else {
 -            SourceLoc { filename: filename.into(), line }
 +            SourceLoc {
 +                filename: filename.into(),
 +                line,
 +            }
+         }
+     }
              return Err(PreprocError {
                  filename: filename.into(),
                  line: source.lines().count() as u32,
 -                msg: format!("unterminated #if/#ifdef ({} level(s) still open)", self.cond_stack.len()),
 +                msg: format!(
 +                    "unterminated #if/#ifdef ({} level(s) still open)",
 +                    self.cond_stack.len()
 +                ),
              });
+         }
 -        Ok(PreprocOutput { text: output, source_map })
 +        Ok(PreprocOutput {
 +            text: output,
 +            source_map,
 +        })
+     }
      fn process_into(
          source_map: &mut Vec<SourceLoc>,
      ) -> Result<(), PreprocError> {
          // Set dynamic macros.
 -        self.defines.insert("__FILE__".into(), MacroDef::object(&format!("\"{}\"", filename)));
 +        self.defines.insert(
 +            "__FILE__".into(),
 +            MacroDef::object(&format!("\"{}\"", filename)),
 +        );
          let now = current_datetime();
 -        self.defines.insert("__DATE__".into(), MacroDef::object(&format!("\"{}\"", now.0)));
 -        self.defines.insert("__TIME__".into(), MacroDef::object(&format!("\"{}\"", now.1)));
 +        self.defines.insert(
 +            "__DATE__".into(),
 +            MacroDef::object(&format!("\"{}\"", now.0)),
 +        );
 +        self.defines.insert(
 +            "__TIME__".into(),
 +            MacroDef::object(&format!("\"{}\"", now.1)),
 +        );
          // Process lines with inline backslash continuation joining,
          // tracking original line numbers so __LINE__ and source_map are correct.
+             }
              // Update __LINE__ to the original starting line of this logical line.
 -            self.defines.insert("__LINE__".into(), MacroDef::object(&orig_line_num.to_string()));
 +            self.defines.insert(
 +                "__LINE__".into(),
 +                MacroDef::object(&orig_line_num.to_string()),
 +            );
              // Fixed-form: C, c, or * in column 1 is a comment line.
              if self.fixed_form {
              "undef" => self.do_undef(args),
              "include" => self.do_include(args, filename, line_num, output, source_map),
              "error" => Err(PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: format!("#error {}", args),
              }),
              "warning" => {
+             }
              "line" => self.do_line(args, filename, line_num),
              "" => Ok(()), // bare # is allowed (null directive)
 -            _ => Ok(()), // unknown directives are ignored (like #pragma)
 +            _ => Ok(()),  // unknown directives are ignored (like #pragma)
+         }
+     }
      // ---- Conditional directive helpers (maintain skip_depth counter) ----
      fn push_cond(&mut self, state: CondState) {
 -        if !matches!(state, CondState::Active) { self.skip_depth += 1; }
 +        if !matches!(state, CondState::Active) {
 +            self.skip_depth += 1;
 +        }
          self.cond_stack.push(state);
+     }
      fn pop_cond(&mut self) -> Option<CondState> {
          let popped = self.cond_stack.pop()?;
 -        if !matches!(popped, CondState::Active) { self.skip_depth -= 1; }
 +        if !matches!(popped, CondState::Active) {
 +            self.skip_depth -= 1;
 +        }
          Some(popped)
+     }
+         }
          let defined = self.defines.contains_key(name);
          let condition = if negate { !defined } else { defined };
 -        self.push_cond(if condition { CondState::Active } else { CondState::Skipping });
 +        self.push_cond(if condition {
 +            CondState::Active
 +        } else {
 +            CondState::Skipping
 +        });
          Ok(())
+     }
              return Ok(());
+         }
          let val = self.eval_condition(args, filename, line_num)?;
 -        self.push_cond(if val { CondState::Active } else { CondState::Skipping });
 +        self.push_cond(if val {
 +            CondState::Active
 +        } else {
 +            CondState::Skipping
 +        });
          Ok(())
+     }
      fn do_elif(&mut self, args: &str, filename: &str, line_num: u32) -> Result<(), PreprocError> {
          match self.cond_stack.last().copied() {
              None => Err(PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: "#elif without matching #if".into(),
              }),
              Some(CondState::ParentSkipping) => Ok(()),
              Some(CondState::Done) => Ok(()),
              Some(CondState::Skipping) => {
                  let val = self.eval_condition(args, filename, line_num)?;
 -                self.set_top_cond(if val { CondState::Active } else { CondState::Skipping });
 +                self.set_top_cond(if val {
 +                    CondState::Active
 +                } else {
 +                    CondState::Skipping
 +                });
                  Ok(())
+             }
+         }
      fn do_else(&mut self, filename: &str, line_num: u32) -> Result<(), PreprocError> {
          match self.cond_stack.last().copied() {
              None => Err(PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: "#else without matching #if".into(),
              }),
              Some(CondState::ParentSkipping) => Ok(()),
      fn do_endif(&mut self, filename: &str, line_num: u32) -> Result<(), PreprocError> {
          if self.pop_cond().is_none() {
              return Err(PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: "#endif without matching #if".into(),
              });
+         }
                  let rest = &args[paren_pos + 1..];
                  if let Some(close) = rest.find(')') {
                      let params_str = &rest[..close];
 -                    let mut params: Vec<String> = params_str.split(',')
 +                    let mut params: Vec<String> = params_str
 +                        .split(',')
                          .map(|p| p.trim().to_string())
                          .filter(|p| !p.is_empty())
                          .collect();
          let args = args.trim();
          let (path_str, search_system) = if let Some(rest) = args.strip_prefix('"') {
              let end = rest.find('"').ok_or_else(|| PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: "unterminated #include string".into(),
              })?;
              (&rest[..end], false)
          } else if let Some(rest) = args.strip_prefix('<') {
              let end = rest.find('>').ok_or_else(|| PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: "unterminated #include <path>".into(),
              })?;
              (&rest[..end], true)
          } else {
              return Err(PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: format!("expected \"file\" or <file> after #include, got: {}", args),
              });
          };
          if self.include_depth >= 64 {
              return Err(PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: "include depth limit exceeded (possible recursion)".into(),
              });
+         }
          // Search for the file.
 -        let resolved = self.resolve_include(path_str, filename, search_system)
 +        let resolved = self
 +            .resolve_include(path_str, filename, search_system)
              .ok_or_else(|| PreprocError {
 -                filename: filename.into(), line: line_num,
 +                filename: filename.into(),
 +                line: line_num,
                  msg: format!("cannot find include file: {}", path_str),
              })?;
 -        let content = std::fs::read_to_string(&resolved)
 -            .map_err(|e| PreprocError {
 -                filename: filename.into(), line: line_num,
 -                msg: format!("reading {}: {}", resolved.display(), e),
 -            })?;
 +        let content = std::fs::read_to_string(&resolved).map_err(|e| PreprocError {
 +            filename: filename.into(),
 +            line: line_num,
 +            msg: format!("reading {}: {}", resolved.display(), e),
 +        })?;
          // Save __FILE__ so it's restored after the include returns.
          let saved_file = self.defines.get("__FILE__").cloned();
      // ---- Condition expression evaluator ----
 -    fn eval_condition(&self, expr: &str, filename: &str, line_num: u32) -> Result<bool, PreprocError> {
 +    fn eval_condition(
 +        &self,
 +        expr: &str,
 +        filename: &str,
 +        line_num: u32,
 +    ) -> Result<bool, PreprocError> {
          // Expand macros in the expression first.
          let expanded = self.expand_condition_macros(expr);
          // Parse and evaluate the expression.
          eval_expr(&expanded).map_err(|msg| PreprocError {
 -            filename: filename.into(), line: line_num,
 +            filename: filename.into(),
 +            line: line_num,
              msg: format!("in #if expression: {}", msg),
          })
+     }
                  if mode == MacroExpandMode::ConditionExpr && ident == "defined" {
                      let (name, new_i) = parse_defined_operand(line, i);
 -                    result.push_str(if self.defines.contains_key(name) { "1" } else { "0" });
 +                    result.push_str(if self.defines.contains_key(name) {
 +                        "1"
 +                    } else {
 +                        "0"
 +                    });
                      i = new_i;
                      continue;
+                 }
                  if let Some(def) = self.defines.get(ident) {
                      if def.is_function {
                          if i < bytes.len() && bytes[i] == b'(' {
 -                            if let Some((expanded, new_i)) = self.expand_function_macro(def, line, i) {
 +                            if let Some((expanded, new_i)) =
 +                                self.expand_function_macro(def, line, i)
 +                            {
                                  // Re-expand the result with this macro marked as expanding.
                                  let mut next_expanding = expanding.clone();
                                  next_expanding.insert(ident.to_string());
 -                                result.push_str(&self.expand_macros_inner(&expanded, &next_expanding, mode));
 +                                result.push_str(&self.expand_macros_inner(
 +                                    &expanded,
 +                                    &next_expanding,
 +                                    mode,
 +                                ));
                                  i = new_i;
                                  continue;
+                             }
                          // Re-expand object macro body with this macro marked as expanding.
                          let mut next_expanding = expanding.clone();
                          next_expanding.insert(ident.to_string());
 -                        result.push_str(&self.expand_macros_inner(&def.body, &next_expanding, mode));
 +                        result.push_str(&self.expand_macros_inner(
 +                            &def.body,
 +                            &next_expanding,
 +                            mode,
 +                        ));
+                     }
                  } else {
                      result.push_str(ident);
          result
+     }
 -    fn expand_function_macro(&self, def: &MacroDef, line: &str, paren_start: usize) -> Option<(String, usize)> {
 +    fn expand_function_macro(
 +        &self,
 +        def: &MacroDef,
 +        line: &str,
 +        paren_start: usize,
 +    ) -> Option<(String, usize)> {
          let bytes = line.as_bytes();
          let mut i = paren_start + 1; // skip '('
          let mut args: Vec<String> = Vec::new();
          while i < bytes.len() && depth > 0 {
              match bytes[i] {
 -                b'(' => { depth += 1; current_arg.push('('); }
 +                b'(' => {
 +                    depth += 1;
 +                    current_arg.push('(');
 +                }
                  b')' => {
                      depth -= 1;
 -                    if depth > 0 { current_arg.push(')'); }
 +                    if depth > 0 {
 +                        current_arg.push(')');
 +                    }
+                 }
                  b',' if depth == 1 => {
                      args.push(current_arg.trim().to_string());
              i += 1;
+         }
 -        if depth != 0 { return None; }
 +        if depth != 0 {
 +            return None;
 +        }
          args.push(current_arg.trim().to_string());
          // Build parameter lookup table.
                      id_start += 1;
+                 }
                  let mut id_end = id_start;
 -                while id_end < body_bytes.len() && (body_bytes[id_end].is_ascii_alphanumeric() || body_bytes[id_end] == b'_') {
 +                while id_end < body_bytes.len()
 +                    && (body_bytes[id_end].is_ascii_alphanumeric() || body_bytes[id_end] == b'_')
 +                {
                      id_end += 1;
+                 }
                  if id_end > id_start {
                      let id = std::str::from_utf8(&body_bytes[id_start..id_end]).unwrap_or("");
                      if let Some(&pi) = param_map.get(id) {
 -                        body.push_str(&format!("\"{}\"", args.get(pi).map(|s| s.as_str()).unwrap_or("")));
 +                        body.push_str(&format!(
 +                            "\"{}\"",
 +                            args.get(pi).map(|s| s.as_str()).unwrap_or("")
 +                        ));
                          bi = id_end;
                          continue;
+                     }
              // Identifier: check if it's a parameter name.
              if body_bytes[bi].is_ascii_alphabetic() || body_bytes[bi] == b'_' {
                  let id_start = bi;
 -                while bi < body_bytes.len() && (body_bytes[bi].is_ascii_alphanumeric() || body_bytes[bi] == b'_') {
 +                while bi < body_bytes.len()
 +                    && (body_bytes[bi].is_ascii_alphanumeric() || body_bytes[bi] == b'_')
 +                {
                      bi += 1;
+                 }
                  let id = std::str::from_utf8(&body_bytes[id_start..bi]).unwrap_or("");
  fn eval_comparison(expr: &str) -> Result<i64, String> {
      // Scan right-to-left for left-associative evaluation.
 -    for (op, op_len) in [("==", 2), ("!=", 2), (">=", 2), ("<=", 2), (">", 1), ("<", 1)] {
 +    for (op, op_len) in [
 +        ("==", 2),
 +        ("!=", 2),
 +        (">=", 2),
 +        ("<=", 2),
 +        (">", 1),
 +        ("<", 1),
 +    ] {
          if let Some(pos) = find_op_right(expr, op) {
              let left = eval_comparison(&expr[..pos])?;
              let right = eval_additive(&expr[pos + op_len..])?;
      if let Some(pos) = find_op_right(expr, "/") {
          let left = eval_multiplicative(&expr[..pos])?;
          let right = eval_unary(&expr[pos + 1..])?;
 -        if right == 0 { return Err("division by zero in #if expression".into()); }
 +        if right == 0 {
 +            return Err("division by zero in #if expression".into());
 +        }
          return Ok(left / right);
+     }
      if let Some(pos) = find_op_right(expr, "%") {
          let left = eval_multiplicative(&expr[..pos])?;
          let right = eval_unary(&expr[pos + 1..])?;
 -        if right == 0 { return Err("modulo by zero in #if expression".into()); }
 +        if right == 0 {
 +            return Err("modulo by zero in #if expression".into());
 +        }
          return Ok(left % right);
+     }
      eval_unary(expr)
      // Parenthesized expression.
      if trimmed.starts_with('(') {
 -        let close = find_matching_paren(trimmed)
 -            .ok_or("unmatched parenthesis in #if expression")?;
 +        let close =
 +            find_matching_paren(trimmed).ok_or("unmatched parenthesis in #if expression")?;
          return eval_or(&trimmed[1..close]);
+     }
              '(' => depth += 1,
              ')' => {
                  depth -= 1;
 -                if depth == 0 { return Some(i); }
 +                if depth == 0 {
 +                    return Some(i);
 +                }
+             }
              _ => {}
+         }
      // Days since epoch to year/month/day (simplified Gregorian).
      let (year, month, day) = epoch_days_to_date(days);
 -    let months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
 -                   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 +    let months = [
 +        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 +    ];
      let month_name = months.get(month as usize).unwrap_or(&"???");
      let date = format!("{} {:2} {}", month_name, day, year);
      #[test]
      fn if_arithmetic() {
 -        let out = pp_with("#if MAX > 512\nbig\n#else\nsmall\n#endif\n", &[("MAX", "1024")]);
 +        let out = pp_with(
 +            "#if MAX > 512\nbig\n#else\nsmall\n#endif\n",
 +            &[("MAX", "1024")],
 +        );
          assert!(lines(&out).contains(&"big"));
+     }
          // Regression test: the '' must not cause early string termination.
          let out = pp_with("x = 'he said ''hello'' there' + FOO\n", &[("FOO", "1")]);
          assert!(out.contains("'he said ''hello'' there'"), "got: {:?}", out);
 -        assert!(out.contains("+ 1"), "FOO after string should expand, got: {:?}", out);
 +        assert!(
 +            out.contains("+ 1"),
 +            "FOO after string should expand, got: {:?}",
 +            out
 +        );
+     }
      #[test]
      #[test]
      fn if_with_arithmetic() {
 -        let out = pp_with("#if MAX + 1 > 512\nbig\n#else\nsmall\n#endif\n", &[("MAX", "1024")]);
 +        let out = pp_with(
 +            "#if MAX + 1 > 512\nbig\n#else\nsmall\n#endif\n",
 +            &[("MAX", "1024")],
 +        );
          assert!(lines(&out).contains(&"big"));
+     }
      fn if_chained_macros() {
          // A -> 1, B -> A. #if B should expand B->A->1, evaluating to true.
          let out = pp_with("#if B\nyes\n#endif\n", &[("A", "1"), ("B", "A")]);
 -        assert!(lines(&out).contains(&"yes"), "chained macro in #if failed, got: {:?}", lines(&out));
 +        assert!(
 +            lines(&out).contains(&"yes"),
 +            "chained macro in #if failed, got: {:?}",
 +            lines(&out)
 +        );
+     }
      #[test]
      fn if_chained_three_levels() {
 -        let out = pp_with("#if C > 10\nyes\n#endif\n", &[("A", "42"), ("B", "A"), ("C", "B")]);
 -        assert!(lines(&out).contains(&"yes"), "3-level chain in #if failed, got: {:?}", lines(&out));
 +        let out = pp_with(
 +            "#if C > 10\nyes\n#endif\n",
 +            &[("A", "42"), ("B", "A"), ("C", "B")],
 +        );
 +        assert!(
 +            lines(&out).contains(&"yes"),
 +            "3-level chain in #if failed, got: {:?}",
 +            lines(&out)
 +        );
+     }
      #[test]
      fn if_defined_and_value() {
          // Common real-world pattern: #if defined(FOO) && FOO > 5
 -        let out = pp_with("#if defined(FOO) && FOO > 5\nyes\n#endif\n", &[("FOO", "10")]);
 +        let out = pp_with(
 +            "#if defined(FOO) && FOO > 5\nyes\n#endif\n",
 +            &[("FOO", "10")],
 +        );
          assert!(lines(&out).contains(&"yes"));
+     }
      #[test]
      fn if_function_macro_expands() {
          let out = pp("#define INC(x) ((x) + 1)\n#if INC(41) > 41\nyes\n#endif\n");
 -        assert!(lines(&out).contains(&"yes"), "function macro in #if failed, got: {:?}", lines(&out));
 +        assert!(
 +            lines(&out).contains(&"yes"),
 +            "function macro in #if failed, got: {:?}",
 +            lines(&out)
 +        );
+     }
      #[test]
          // After continuation joining, the define body is "    ((a) +      (b))"
          // with leading/trailing whitespace from the continuation lines.
          // The body gets trimmed during define processing, so it becomes "((a) +      (b))".
 -        assert!(out.contains("((1) +"), "got: {:?}", out.lines().collect::<Vec<_>>());
 +        assert!(
 +            out.contains("((1) +"),
 +            "got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
          assert!(out.contains("(2))"));
+     }
      fn line_number_correct_after_continuation() {
          // Lines 1-3 are a continued #define. Line 4 should report __LINE__ = 4.
          let out = pp("#define M \\\n    42\na\nb = __LINE__\n");
 -        assert!(out.contains("b = 4"), "got: {:?}", out.lines().collect::<Vec<_>>());
 +        assert!(
 +            out.contains("b = 4"),
 +            "got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
+     }
      // ---- Self-referencing macro (no infinite loop) ----
          config.include_paths.push(dir);
          let src = "#include \"test_pp_include.inc\"\nreal :: x\n";
          let result = preprocess(src, &config).unwrap();
 -        assert!(result.text.contains("integer :: included_var"), "got: {:?}", result.text);
 +        assert!(
 +            result.text.contains("integer :: included_var"),
 +            "got: {:?}",
 +            result.text
 +        );
          assert!(result.text.contains("real :: x"));
+     }
          config.filename = "parent.f90".into();
          let src = "before = __FILE__\n#include \"test_pp_file_restore.inc\"\nafter = __FILE__\n";
          let result = preprocess(src, &config).unwrap();
 -        assert!(result.text.contains("before = \"parent.f90\""), "got: {:?}", result.text);
 -        assert!(result.text.contains("after = \"parent.f90\""), "__FILE__ not restored, got: {:?}", result.text);
 +        assert!(
 +            result.text.contains("before = \"parent.f90\""),
 +            "got: {:?}",
 +            result.text
 +        );
 +        assert!(
 +            result.text.contains("after = \"parent.f90\""),
 +            "__FILE__ not restored, got: {:?}",
 +            result.text
 +        );
+     }
      // ---- Fixed-form awareness ----
          config.defines.insert("FOO".into(), MacroDef::object("BAR"));
          let result = preprocess("C     FOO is a comment\n      x = FOO\n", &config).unwrap();
          // C-line should not have FOO expanded.
 -        assert!(result.text.contains("C     FOO is a comment"), "got: {:?}", result.text);
 +        assert!(
 +            result.text.contains("C     FOO is a comment"),
 +            "got: {:?}",
 +            result.text
 +        );
          // Continuation line should expand FOO.
          assert!(result.text.contains("x = BAR"), "got: {:?}", result.text);
+     }
          config.fixed_form = true;
          config.defines.insert("FOO".into(), MacroDef::object("BAR"));
          let result = preprocess("*     FOO is a comment\n", &config).unwrap();
 -        assert!(result.text.contains("*     FOO is a comment"), "got: {:?}", result.text);
 +        assert!(
 +            result.text.contains("*     FOO is a comment"),
 +            "got: {:?}",
 +            result.text
 +        );
+     }
      // ---- Fortran & continuation ----
      #[test]
      fn fortran_ampersand_continuation() {
          let out = pp_with("x = FOO + &\n    BAR\n", &[("FOO", "1"), ("BAR", "2")]);
 -        assert!(out.contains("x = 1 + 2"), "got: {:?}", out.lines().collect::<Vec<_>>());
 +        assert!(
 +            out.contains("x = 1 + 2"),
 +            "got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
+     }
      #[test]
      fn ampersand_in_string_not_continued() {
          // & inside a string literal must NOT trigger continuation.
          let out = pp("x = 'hello &'\ny = 2\n");
 -        assert!(out.contains("'hello &'"), "string corrupted, got: {:?}", out.lines().collect::<Vec<_>>());
 -        assert!(out.contains("y = 2"), "next line missing, got: {:?}", out.lines().collect::<Vec<_>>());
 +        assert!(
 +            out.contains("'hello &'"),
 +            "string corrupted, got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
 +        assert!(
 +            out.contains("y = 2"),
 +            "next line missing, got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
+     }
      #[test]
      fn ampersand_in_comment_not_continued() {
          // & after ! comment must NOT trigger continuation.
          let out = pp("x = 1 ! comment &\ny = 2\n");
 -        assert!(out.contains("! comment &"), "comment corrupted, got: {:?}", out.lines().collect::<Vec<_>>());
 -        assert!(out.contains("y = 2"), "next line missing, got: {:?}", out.lines().collect::<Vec<_>>());
 +        assert!(
 +            out.contains("! comment &"),
 +            "comment corrupted, got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
 +        assert!(
 +            out.contains("y = 2"),
 +            "next line missing, got: {:?}",
 +            out.lines().collect::<Vec<_>>()
 +        );
+     }
      // ---- __DATE__ and __TIME__ ----
          let mut config = PreprocConfig::default();
          config.filename = "test.f90".into();
          let result = preprocess("x = __FILE__\n", &config).unwrap();
 -        assert!(result.text.contains("\"test.f90\""), "got: {:?}", result.text);
 +        assert!(
 +            result.text.contains("\"test.f90\""),
 +            "got: {:?}",
 +            result.text
 +        );
+     }
      // ---- defined without parens ----
          let result = preprocess("#include \"test_pp_recurse.inc\"\n", &config);
          assert!(result.is_err());
          let err = result.unwrap_err();
 -        assert!(err.msg.contains("depth") || err.msg.contains("recursion"), "got: {}", err.msg);
 +        assert!(
 +            err.msg.contains("depth") || err.msg.contains("recursion"),
 +            "got: {}",
 +            err.msg
 +        );
+     }
+ }

src/sema/intrinsic_modules.rsmodified

224 lines changed — click to load

  fn builtin_span() -> Span {
      let pos = crate::lexer::Position { line: 0, col: 0 };
 -    Span { start: pos, end: pos, file_id: 0 }
 +    Span {
 +        start: pos,
 +        end: pos,
 +        file_id: 0,
 +    }
+ }
  fn insert_param(st: &mut SymbolTable, mod_id: ScopeId, name: &str, ti: TypeInfo) {
      insert_param_val(st, mod_id, name, ti, None);
+ }
 -fn insert_param_val(st: &mut SymbolTable, mod_id: ScopeId, name: &str, ti: TypeInfo, val: Option<i64>) {
 +fn insert_param_val(
 +    st: &mut SymbolTable,
 +    mod_id: ScopeId,
 +    name: &str,
 +    ti: TypeInfo,
 +    val: Option<i64>,
 +) {
      let span = builtin_span();
 -    st.scope_mut(mod_id).symbols.insert(name.to_lowercase(), Symbol {
 -        name: name.to_string(),
 -        kind: SymbolKind::Parameter,
 -        type_info: Some(ti),
 -        attrs: SymbolAttrs { parameter: true, ..Default::default() },
 -        defined_at: span,
 -        scope: mod_id,
 -        arg_names: vec![],
 -        const_value: val,
 -    });
 +    st.scope_mut(mod_id).symbols.insert(
 +        name.to_lowercase(),
 +        Symbol {
 +            name: name.to_string(),
 +            kind: SymbolKind::Parameter,
 +            type_info: Some(ti),
 +            attrs: SymbolAttrs {
 +                parameter: true,
 +                ..Default::default()
 +            },
 +            defined_at: span,
 +            scope: mod_id,
 +            arg_names: vec![],
 +            const_value: val,
 +        },
 +    );
+ }
  fn insert_type(st: &mut SymbolTable, mod_id: ScopeId, name: &str) {
      let span = builtin_span();
 -    st.scope_mut(mod_id).symbols.insert(name.to_lowercase(), Symbol {
 -        name: name.to_string(),
 -        kind: SymbolKind::DerivedType,
 -        type_info: Some(TypeInfo::Derived(name.to_string())),
 -        attrs: Default::default(),
 -        defined_at: span,
 -        scope: mod_id,
 -        arg_names: vec![],
 -        const_value: None,
 -    });
 +    st.scope_mut(mod_id).symbols.insert(
 +        name.to_lowercase(),
 +        Symbol {
 +            name: name.to_string(),
 +            kind: SymbolKind::DerivedType,
 +            type_info: Some(TypeInfo::Derived(name.to_string())),
 +            attrs: Default::default(),
 +            defined_at: span,
 +            scope: mod_id,
 +            arg_names: vec![],
 +            const_value: None,
 +        },
 +    );
+ }
  fn insert_proc(st: &mut SymbolTable, mod_id: ScopeId, name: &str) {
      let span = builtin_span();
 -    st.scope_mut(mod_id).symbols.insert(name.to_lowercase(), Symbol {
 -        name: name.to_string(),
 -        kind: SymbolKind::IntrinsicProc,
 -        type_info: None,
 -        attrs: SymbolAttrs { intrinsic: true, ..Default::default() },
 -        defined_at: span,
 -        scope: mod_id,
 -        arg_names: vec![],
 -        const_value: None,
 -    });
 +    st.scope_mut(mod_id).symbols.insert(
 +        name.to_lowercase(),
 +        Symbol {
 +            name: name.to_string(),
 +            kind: SymbolKind::IntrinsicProc,
 +            type_info: None,
 +            attrs: SymbolAttrs {
 +                intrinsic: true,
 +                ..Default::default()
 +            },
 +            defined_at: span,
 +            scope: mod_id,
 +            arg_names: vec![],
 +            const_value: None,
 +        },
 +    );
+ }
  /// Populate the iso_c_binding module scope.
      // Each constant's VALUE is the kind number (e.g., c_int = 4 means kind=4 = 4 bytes).
      let ik = |k: u8| TypeInfo::Integer { kind: Some(k) };
      for (name, kind) in [
 -        ("c_int", 4u8), ("c_short", 2), ("c_long", 8), ("c_long_long", 8),
 +        ("c_int", 4u8),
 +        ("c_short", 2),
 +        ("c_long", 8),
 +        ("c_long_long", 8),
          ("c_signed_char", 1),
 -        ("c_int8_t", 1), ("c_int16_t", 2), ("c_int32_t", 4), ("c_int64_t", 8),
 -        ("c_size_t", 8), ("c_intptr_t", 8), ("c_ptrdiff_t", 8),
 +        ("c_int8_t", 1),
 +        ("c_int16_t", 2),
 +        ("c_int32_t", 4),
 +        ("c_int64_t", 8),
 +        ("c_size_t", 8),
 +        ("c_intptr_t", 8),
 +        ("c_ptrdiff_t", 8),
      ] {
          insert_param_val(st, m, name, ik(4), Some(kind as i64));
+     }
      // ---- Real kind parameters ----
 -    for (name, kind) in [
 -        ("c_float", 4u8), ("c_double", 8), ("c_long_double", 8),
 -    ] {
 -        insert_param_val(st, m, name, TypeInfo::Integer { kind: Some(4) }, Some(kind as i64));
 +    for (name, kind) in [("c_float", 4u8), ("c_double", 8), ("c_long_double", 8)] {
 +        insert_param_val(
 +            st,
 +            m,
 +            name,
 +            TypeInfo::Integer { kind: Some(4) },
 +            Some(kind as i64),
 +        );
+     }
      // ---- Complex kind parameters ----
      for (name, kind) in [
 -        ("c_float_complex", 4u8), ("c_double_complex", 8), ("c_long_double_complex", 8),
 +        ("c_float_complex", 4u8),
 +        ("c_double_complex", 8),
 +        ("c_long_double_complex", 8),
      ] {
 -        insert_param_val(st, m, name, TypeInfo::Integer { kind: Some(4) }, Some(kind as i64));
 +        insert_param_val(
 +            st,
 +            m,
 +            name,
 +            TypeInfo::Integer { kind: Some(4) },
 +            Some(kind as i64),
 +        );
+     }
      // ---- Character and logical kinds ----
      // c_char is an integer kind parameter (value = 1), not a character type.
      insert_param_val(st, m, "c_char", ik(4), Some(1));
 -    insert_param_val(st, m, "c_bool", TypeInfo::Integer { kind: Some(4) }, Some(1));
 +    insert_param_val(
 +        st,
 +        m,
 +        "c_bool",
 +        TypeInfo::Integer { kind: Some(4) },
 +        Some(1),
 +    );
      // ---- Character constants (c_null_char, etc.) ----
      // Each constant's value is its ASCII byte code.
 -    let ck = TypeInfo::Character { len: Some(1), kind: Some(1) };
 +    let ck = TypeInfo::Character {
 +        len: Some(1),
 +        kind: Some(1),
 +    };
      for (name, ascii) in [
          ("c_null_char", 0i64),
          ("c_alert", 7),
      insert_param(st, m, "c_null_funptr", ik(8));
      // ---- Procedures ----
 -    for name in ["c_loc", "c_funloc", "c_f_pointer", "c_f_procpointer", "c_associated", "c_sizeof"] {
 +    for name in [
 +        "c_loc",
 +        "c_funloc",
 +        "c_f_pointer",
 +        "c_f_procpointer",
 +        "c_associated",
 +        "c_sizeof",
 +    ] {
          insert_proc(st, m, name);
+     }
                  insert_proc(st, m, "ieee_set_halting_mode");
+             }
              "ieee_features" => {
 -                for feat in ["ieee_datatype", "ieee_denormal", "ieee_divide",
 -                             "ieee_halting", "ieee_inexact_flag", "ieee_inf",
 -                             "ieee_invalid_flag", "ieee_nan", "ieee_rounding",
 -                             "ieee_sqrt", "ieee_underflow_flag"] {
 +                for feat in [
 +                    "ieee_datatype",
 +                    "ieee_denormal",
 +                    "ieee_divide",
 +                    "ieee_halting",
 +                    "ieee_inexact_flag",
 +                    "ieee_inf",
 +                    "ieee_invalid_flag",
 +                    "ieee_nan",
 +                    "ieee_rounding",
 +                    "ieee_sqrt",
 +                    "ieee_underflow_flag",
 +                ] {
                      insert_param(st, m, feat, TypeInfo::Logical { kind: Some(4) });
+                 }
+             }

src/sema/mod.rsmodified

14 lines changed — click to load

  //! Symbol tables, scoping, type checking, module resolution,
  //! interface validation, and standard conformance checks.
 -pub mod symtab;
 +pub mod amod;
 +pub mod intrinsic_modules;
  pub mod resolve;
 +pub mod symtab;
 +pub mod type_layout;
  pub mod types;
  pub mod validate;
 -pub mod intrinsic_modules;
 -pub mod type_layout;
 -pub mod amod;

src/sema/symtab.rsmodified

193 lines changed — click to load

  //! mechanisms: local declaration, USE association, host association, and
  //! IMPORT. Handles implicit typing and case-insensitive lookup.
 -use std::collections::HashMap;
  use crate::lexer::Span;
 +use std::collections::HashMap;
  /// Scope identifier — an index into the SymbolTable's scope list.
  pub type ScopeId = usize;
              pending_access: HashMap::new(),
              arg_order: Vec::new(),
          };
 -        Self { scopes: vec![global], current: 0 }
 +        Self {
 +            scopes: vec![global],
 +            current: 0,
 +        }
+     }
+ }
  impl Default for SymbolTable {
 -    fn default() -> Self { Self::new() }
 +    fn default() -> Self {
 +        Self::new()
 +    }
+ }
  impl SymbolTable {
+-
      /// Create a new child scope of the current scope.
      pub fn push_scope(&mut self, kind: ScopeKind) -> ScopeId {
          let id = self.scopes.len();
              // 2. Direct USE association.
              for assoc in &scope.use_associations {
                  if assoc.local_name == key {
 -                    if let Some(sym) = self.scopes[assoc.source_scope].symbols.get(&assoc.original_name) {
 +                    if let Some(sym) = self.scopes[assoc.source_scope]
 +                        .symbols
 +                        .get(&assoc.original_name)
 +                    {
                          if sym.attrs.access != Access::Private || assoc.is_submodule_access {
                              return Some(sym);
+                         }
          for scope in &self.scopes {
              for assoc in &scope.use_associations {
                  if assoc.local_name == key {
 -                    if let Some(sym) = self.scopes[assoc.source_scope].symbols.get(&assoc.original_name) {
 +                    if let Some(sym) = self.scopes[assoc.source_scope]
 +                        .symbols
 +                        .get(&assoc.original_name)
 +                    {
                          return Some(sym);
+                     }
+                 }
      pub fn set_implicit_rule(&mut self, start: char, end: char, itype: ImplicitType) {
          let scope = &mut self.scopes[self.current];
          for c in start..=end {
 -            scope.implicit_rules.rules.insert(c.to_ascii_lowercase(), itype);
 +            scope
 +                .implicit_rules
 +                .rules
 +                .insert(c.to_ascii_lowercase(), itype);
+         }
+     }
          let key = name.to_lowercase();
          self.scopes.iter().find_map(|s| {
              if let ScopeKind::Module(ref n) = s.kind {
 -                if n.to_lowercase() == key { Some(s.id) } else { None }
 -            } else { None }
 +                if n.to_lowercase() == key {
 +                    Some(s.id)
 +                } else {
 +                    None
 +                }
 +            } else {
 +                None
 +            }
          })
+     }
+ }
      /// Standard Fortran default: I-N integer, everything else real.
      pub fn default_fortran() -> Self {
          let mut rules = HashMap::new();
 -        for c in 'a'..='h' { rules.insert(c, ImplicitType::Real); }
 -        for c in 'i'..='n' { rules.insert(c, ImplicitType::Integer); }
 -        for c in 'o'..='z' { rules.insert(c, ImplicitType::Real); }
 -        Self { none_type: false, none_external: false, rules }
 +        for c in 'a'..='h' {
 +            rules.insert(c, ImplicitType::Real);
 +        }
 +        for c in 'i'..='n' {
 +            rules.insert(c, ImplicitType::Integer);
 +        }
 +        for c in 'o'..='z' {
 +            rules.insert(c, ImplicitType::Real);
 +        }
 +        Self {
 +            none_type: false,
 +            none_external: false,
 +            rules,
 +        }
+     }
      /// Look up the implicit type for a name's first letter.
      pub fn type_for(&self, name: &str) -> Option<ImplicitType> {
 -        if self.none_type { return None; }
 +        if self.none_type {
 +            return None;
 +        }
          let first = name.chars().next()?.to_ascii_lowercase();
          self.rules.get(&first).copied()
+     }
  impl std::fmt::Display for SemaError {
      fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 -        write!(f, "{}:{}: error: {}", self.span.start.line, self.span.start.col, self.msg)
 +        write!(
 +            f,
 +            "{}:{}: error: {}",
 +            self.span.start.line, self.span.start.col, self.msg
 +        )
+     }
+ }
      use crate::lexer::{Position, Span};
      fn dummy_span() -> Span {
 -        Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } }
 +        Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        }
+     }
      fn make_symbol(name: &str, kind: SymbolKind) -> Symbol {
      fn case_insensitive_lookup() {
          let mut st = SymbolTable::new();
          st.push_scope(ScopeKind::Program("main".into()));
 -        st.define(make_symbol("MyVar", SymbolKind::Variable)).unwrap();
 +        st.define(make_symbol("MyVar", SymbolKind::Variable))
 +            .unwrap();
          assert!(st.lookup("myvar").is_some());
          assert!(st.lookup("MYVAR").is_some());
          assert!(st.lookup("MyVar").is_some());
          let mut st = SymbolTable::new();
          let mod_scope = st.push_scope(ScopeKind::Module("mymod".into()));
 -        st.define(make_symbol("original_name", SymbolKind::Variable)).unwrap();
 +        st.define(make_symbol("original_name", SymbolKind::Variable))
 +            .unwrap();
          st.pop_scope();
          st.push_scope(ScopeKind::Program("main".into()));
      fn implicit_default_rules() {
          let st = SymbolTable::new();
          // i-n → integer.
 -        assert_eq!(st.scopes[0].implicit_rules.type_for("index"), Some(ImplicitType::Integer));
 -        assert_eq!(st.scopes[0].implicit_rules.type_for("jmax"), Some(ImplicitType::Integer));
 +        assert_eq!(
 +            st.scopes[0].implicit_rules.type_for("index"),
 +            Some(ImplicitType::Integer)
 +        );
 +        assert_eq!(
 +            st.scopes[0].implicit_rules.type_for("jmax"),
 +            Some(ImplicitType::Integer)
 +        );
          // a-h, o-z → real.
 -        assert_eq!(st.scopes[0].implicit_rules.type_for("x"), Some(ImplicitType::Real));
 -        assert_eq!(st.scopes[0].implicit_rules.type_for("alpha"), Some(ImplicitType::Real));
 +        assert_eq!(
 +            st.scopes[0].implicit_rules.type_for("x"),
 +            Some(ImplicitType::Real)
 +        );
 +        assert_eq!(
 +            st.scopes[0].implicit_rules.type_for("alpha"),
 +            Some(ImplicitType::Real)
 +        );
+     }
      #[test]
          st.push_scope(ScopeKind::Program("main".into()));
          st.set_implicit_rule('a', 'z', ImplicitType::DoublePrecision);
          assert_eq!(st.implicit_type("x"), Some(ImplicitType::DoublePrecision));
 -        assert_eq!(st.implicit_type("index"), Some(ImplicitType::DoublePrecision));
 +        assert_eq!(
 +            st.implicit_type("index"),
 +            Some(ImplicitType::DoublePrecision)
 +        );
+     }
      // ---- Module scope finding ----

src/sema/type_layout.rsmodified

385 lines changed — click to load

  //! Computes field offsets, alignment, and total size for derived types
  //! using natural alignment rules (same as C struct layout on ARM64).
 -use std::collections::HashMap;
  use super::symtab::TypeInfo;
 +use std::collections::HashMap;
  /// Layout of a single field in a derived type.
  #[derive(Debug, Clone)]
      /// Look up a type-bound procedure by method name.
      pub fn bound_proc(&self, name: &str) -> Option<&BoundProc> {
          let key = name.to_lowercase();
 -        self.bound_procs.iter().find(|p| p.method_name.to_lowercase() == key)
 +        self.bound_procs
 +            .iter()
 +            .find(|p| p.method_name.to_lowercase() == key)
+     }
+ }
  impl TypeLayoutRegistry {
      pub fn new() -> Self {
 -        Self { layouts: HashMap::new(), next_tag: 1 }
 +        Self {
 +            layouts: HashMap::new(),
 +            next_tag: 1,
 +        }
+     }
      pub fn alloc_tag(&mut self) -> u64 {
                      };
                      match &e.node {
                          Expr::RealLiteral { text, .. } => {
 -                            Some(if text.contains('d') || text.contains('D') { 8 } else { 4 })
 +                            Some(if text.contains('d') || text.contains('D') {
 +                                8
 +                            } else {
 +                                4
 +                            })
+                         }
                          Expr::IntegerLiteral { .. } => Some(4),
                          _ => None,
      ts: &crate::ast::decl::TypeSpec,
      const_params: &HashMap<String, i64>,
  ) -> TypeInfo {
 -    use crate::ast::decl::{TypeSpec, KindSelector, LenSpec};
 +    use crate::ast::decl::{KindSelector, LenSpec, TypeSpec};
      match ts {
          TypeSpec::Integer(kind) => TypeInfo::Integer {
 -            kind: kind
 -                .as_ref()
 -                .and_then(|k| match k {
 -                    KindSelector::Expr(e) | KindSelector::Star(e) => {
 -                        eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 -                    }
 -                }),
 +            kind: kind.as_ref().and_then(|k| match k {
 +                KindSelector::Expr(e) | KindSelector::Star(e) => {
 +                    eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 +                }
 +            }),
          },
          TypeSpec::Real(kind) => TypeInfo::Real {
 -            kind: kind
 -                .as_ref()
 -                .and_then(|k| match k {
 -                    KindSelector::Expr(e) | KindSelector::Star(e) => {
 -                        eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 -                    }
 -                }),
 +            kind: kind.as_ref().and_then(|k| match k {
 +                KindSelector::Expr(e) | KindSelector::Star(e) => {
 +                    eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 +                }
 +            }),
          },
          TypeSpec::DoublePrecision => TypeInfo::DoublePrecision,
          TypeSpec::Complex(kind) => TypeInfo::Complex {
 -            kind: kind
 -                .as_ref()
 -                .and_then(|k| match k {
 -                    KindSelector::Expr(e) | KindSelector::Star(e) => {
 -                        eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 -                    }
 -                }),
 +            kind: kind.as_ref().and_then(|k| match k {
 +                KindSelector::Expr(e) | KindSelector::Star(e) => {
 +                    eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 +                }
 +            }),
          },
          TypeSpec::DoubleComplex => TypeInfo::Complex { kind: Some(8) },
          TypeSpec::Logical(kind) => TypeInfo::Logical {
 -            kind: kind
 -                .as_ref()
 -                .and_then(|k| match k {
 -                    KindSelector::Expr(e) | KindSelector::Star(e) => {
 -                        eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 -                    }
 -                }),
 +            kind: kind.as_ref().and_then(|k| match k {
 +                KindSelector::Expr(e) | KindSelector::Star(e) => {
 +                    eval_const_int_expr(e, const_params).and_then(|v| u8::try_from(v).ok())
 +                }
 +            }),
          },
          TypeSpec::Character(sel) => {
 -            let len = sel.as_ref().and_then(|s| s.len.as_ref()).and_then(|l| match l {
 -                LenSpec::Expr(e) => eval_const_int_expr(e, const_params),
 -                _ => None,
 -            });
 +            let len = sel
 +                .as_ref()
 +                .and_then(|s| s.len.as_ref())
 +                .and_then(|l| match l {
 +                    LenSpec::Expr(e) => eval_const_int_expr(e, const_params),
 +                    _ => None,
 +                });
              let kind = sel
                  .as_ref()
                  .and_then(|s| s.kind.as_ref())
      // Process component declarations.
      for decl in components {
 -        if let crate::ast::decl::Decl::TypeDecl { type_spec, attrs, entities } = &decl.node {
 -            let is_allocatable = attrs.iter().any(|a| matches!(a, crate::ast::decl::Attribute::Allocatable));
 -            let is_pointer = attrs.iter().any(|a| matches!(a, crate::ast::decl::Attribute::Pointer));
 -            let is_target = attrs.iter().any(|a| matches!(a, crate::ast::decl::Attribute::Target));
 +        if let crate::ast::decl::Decl::TypeDecl {
 +            type_spec,
 +            attrs,
 +            entities,
 +        } = &decl.node
 +        {
 +            let is_allocatable = attrs
 +                .iter()
 +                .any(|a| matches!(a, crate::ast::decl::Attribute::Allocatable));
 +            let is_pointer = attrs
 +                .iter()
 +                .any(|a| matches!(a, crate::ast::decl::Attribute::Pointer));
 +            let is_target = attrs
 +                .iter()
 +                .any(|a| matches!(a, crate::ast::decl::Attribute::Target));
              let ti = type_spec_to_type_info(type_spec, const_params);
              for entity in entities {
                  } else {
                      eval_explicit_array_dims(entity.array_spec.as_ref(), const_params)
                  };
 -                let (elem_size, elem_align) = if matches!(
 -                    &ti,
 -                    TypeInfo::Character { len: None, .. }
 -                ) && (is_allocatable || is_pointer) && entity.array_spec.is_none() {
 -                    (32, 8) // StringDescriptor for deferred-length scalar char components
 -                } else if is_allocatable || is_pointer {
 -                    (384, 8) // ArrayDescriptor size for allocatable/pointer components
 -                } else if let TypeInfo::Derived(ref dname) = ti {
 -                    registry.get(dname)
 -                        .map(|l| (l.size, l.align))
 -                        .unwrap_or((8, 8))
 -                } else {
 -                    size_of_type(&ti)
 -                };
 +                let (elem_size, elem_align) =
 +                    if matches!(&ti, TypeInfo::Character { len: None, .. })
 +                        && (is_allocatable || is_pointer)
 +                        && entity.array_spec.is_none()
 +                    {
 +                        (32, 8) // StringDescriptor for deferred-length scalar char components
 +                    } else if is_allocatable || is_pointer {
 +                        (384, 8) // ArrayDescriptor size for allocatable/pointer components
 +                    } else if let TypeInfo::Derived(ref dname) = ti {
 +                        registry
 +                            .get(dname)
 +                            .map(|l| (l.size, l.align))
 +                            .unwrap_or((8, 8))
 +                    } else {
 +                        size_of_type(&ti)
 +                    };
                  // Pad to alignment.
                  let padding = (elem_align - (offset % elem_align)) % elem_align;
                  offset += padding;
+     }
      // Collect type-bound procedure mappings.
 -    let bound_procs: Vec<BoundProc> = type_bound_procs.iter().map(|tbp| {
 -        let target = tbp.binding.as_deref().unwrap_or(&tbp.name);
 -        let nopass = tbp.attrs.iter().any(|a| a.eq_ignore_ascii_case("nopass"));
 -        BoundProc {
 -            method_name: tbp.name.clone(),
 -            target_name: target.to_string(),
 -            nopass,
 -        }
 -    }).collect();
 +    let bound_procs: Vec<BoundProc> = type_bound_procs
 +        .iter()
 +        .map(|tbp| {
 +            let target = tbp.binding.as_deref().unwrap_or(&tbp.name);
 +            let nopass = tbp.attrs.iter().any(|a| a.eq_ignore_ascii_case("nopass"));
 +            BoundProc {
 +                method_name: tbp.name.clone(),
 +                target_name: target.to_string(),
 +                nopass,
 +            }
 +        })
 +        .collect();
      TypeLayout {
          name: type_name.to_string(),
          assert_eq!(size_of_type(&TypeInfo::Real { kind: Some(4) }), (4, 4));
          assert_eq!(size_of_type(&TypeInfo::Real { kind: Some(8) }), (8, 8));
          assert_eq!(size_of_type(&TypeInfo::Logical { kind: Some(4) }), (4, 4));
 -        assert_eq!(size_of_type(&TypeInfo::Character { len: Some(10), kind: None }), (10, 1));
 +        assert_eq!(
 +            size_of_type(&TypeInfo::Character {
 +                len: Some(10),
 +                kind: None
 +            }),
 +            (10, 1)
 +        );
          assert_eq!(size_of_type(&TypeInfo::Complex { kind: Some(4) }), (8, 4));
          assert_eq!(size_of_type(&TypeInfo::Complex { kind: Some(8) }), (16, 8));
+     }
              size: 8,
              align: 4,
              fields: vec![
 -                FieldLayout { name: "x".into(), offset: 0, size: 4, dims: vec![], type_info: TypeInfo::Real { kind: Some(4) }, allocatable: false, pointer: false, target: false },
 -                FieldLayout { name: "y".into(), offset: 4, size: 4, dims: vec![], type_info: TypeInfo::Real { kind: Some(4) }, allocatable: false, pointer: false, target: false },
 +                FieldLayout {
 +                    name: "x".into(),
 +                    offset: 0,
 +                    size: 4,
 +                    dims: vec![],
 +                    type_info: TypeInfo::Real { kind: Some(4) },
 +                    allocatable: false,
 +                    pointer: false,
 +                    target: false,
 +                },
 +                FieldLayout {
 +                    name: "y".into(),
 +                    offset: 4,
 +                    size: 4,
 +                    dims: vec![],
 +                    type_info: TypeInfo::Real { kind: Some(4) },
 +                    allocatable: false,
 +                    pointer: false,
 +                    target: false,
 +                },
              ],
              bound_procs: vec![],
              final_procs: vec![],
              size: 24,
              align: 8,
              fields: vec![
 -                FieldLayout { name: "a".into(), offset: 0, size: 1, dims: vec![], type_info: TypeInfo::Integer { kind: Some(1) }, allocatable: false, pointer: false, target: false },
 -                FieldLayout { name: "b".into(), offset: 8, size: 8, dims: vec![], type_info: TypeInfo::Real { kind: Some(8) }, allocatable: false, pointer: false, target: false },
 -                FieldLayout { name: "c".into(), offset: 16, size: 4, dims: vec![], type_info: TypeInfo::Integer { kind: Some(4) }, allocatable: false, pointer: false, target: false },
 +                FieldLayout {
 +                    name: "a".into(),
 +                    offset: 0,
 +                    size: 1,
 +                    dims: vec![],
 +                    type_info: TypeInfo::Integer { kind: Some(1) },
 +                    allocatable: false,
 +                    pointer: false,
 +                    target: false,
 +                },
 +                FieldLayout {
 +                    name: "b".into(),
 +                    offset: 8,
 +                    size: 8,
 +                    dims: vec![],
 +                    type_info: TypeInfo::Real { kind: Some(8) },
 +                    allocatable: false,
 +                    pointer: false,
 +                    target: false,
 +                },
 +                FieldLayout {
 +                    name: "c".into(),
 +                    offset: 16,
 +                    size: 4,
 +                    dims: vec![],
 +                    type_info: TypeInfo::Integer { kind: Some(4) },
 +                    allocatable: false,
 +                    pointer: false,
 +                    target: false,
 +                },
              ],
              bound_procs: vec![],
              final_procs: vec![],
          use crate::ast::decl::*;
          use crate::ast::Spanned;
          let pos = crate::lexer::Position { line: 0, col: 0 };
 -        let span = crate::lexer::Span { start: pos, end: pos, file_id: 0 };
 -        Spanned::new(Decl::TypeDecl {
 -            type_spec: ts,
 -            attrs: vec![],
 -            entities: vec![EntityDecl {
 -                name: name.to_string(),
 -                array_spec: None,
 -                char_len: None,
 -                init: None,
 -                ptr_init: None,
 -            }],
 -        }, span)
 +        let span = crate::lexer::Span {
 +            start: pos,
 +            end: pos,
 +            file_id: 0,
 +        };
 +        Spanned::new(
 +            Decl::TypeDecl {
 +                type_spec: ts,
 +                attrs: vec![],
 +                entities: vec![EntityDecl {
 +                    name: name.to_string(),
 +                    array_spec: None,
 +                    char_len: None,
 +                    init: None,
 +                    ptr_init: None,
 +                }],
 +            },
 +            span,
 +        )
+     }
      fn empty_params() -> std::collections::HashMap<String, i64> {
          // a(1) + 7pad + b(8) = 16
          let reg = TypeLayoutRegistry::new();
          let components = vec![
 -            make_component("a", crate::ast::decl::TypeSpec::Integer(
 -                Some(crate::ast::decl::KindSelector::Expr(
 +            make_component(
 +                "a",
 +                crate::ast::decl::TypeSpec::Integer(Some(crate::ast::decl::KindSelector::Expr(
                      crate::ast::Spanned::new(
 -                        crate::ast::expr::Expr::IntegerLiteral { text: "1".into(), kind: None },
 -                        crate::lexer::Span { start: crate::lexer::Position { line: 0, col: 0 }, end: crate::lexer::Position { line: 0, col: 0 }, file_id: 0 },
 -                    )
 -                ))
 -            )),
 +                        crate::ast::expr::Expr::IntegerLiteral {
 +                            text: "1".into(),
 +                            kind: None,
 +                        },
 +                        crate::lexer::Span {
 +                            start: crate::lexer::Position { line: 0, col: 0 },
 +                            end: crate::lexer::Position { line: 0, col: 0 },
 +                            file_id: 0,
 +                        },
 +                    ),
 +                ))),
 +            ),
              make_component("b", crate::ast::decl::TypeSpec::DoublePrecision),
          ];
          let layout = compute_layout("padded", &[], &[], &components, None, &reg, &empty_params());
          // type :: base; integer :: x; end type
          // type, extends(base) :: child; real :: y; end type
          let reg = TypeLayoutRegistry::new();
 -        let base_comps = vec![make_component("x", crate::ast::decl::TypeSpec::Integer(None))];
 -        let base_layout = compute_layout("base", &[], &[], &base_comps, None, &reg, &empty_params());
 +        let base_comps = vec![make_component(
 +            "x",
 +            crate::ast::decl::TypeSpec::Integer(None),
 +        )];
 +        let base_layout =
 +            compute_layout("base", &[], &[], &base_comps, None, &reg, &empty_params());
          assert_eq!(base_layout.size, 4);
          let child_comps = vec![make_component("y", crate::ast::decl::TypeSpec::Real(None))];
 -        let child_layout =
 -            compute_layout("child", &[], &[], &child_comps, Some(&base_layout), &reg, &empty_params());
 +        let child_layout = compute_layout(
 +            "child",
 +            &[],
 +            &[],
 +            &child_comps,
 +            Some(&base_layout),
 +            &reg,
 +            &empty_params(),
 +        );
          assert_eq!(child_layout.fields.len(), 2); // x + y
          assert_eq!(child_layout.field("x").unwrap().offset, 0); // inherited
          assert_eq!(child_layout.field("y").unwrap().offset, 4); // appended

src/sema/types.rsmodified

1836 lines changed — click to load

  /// A Fortran type.
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum FortranType {
 -    Integer { kind: u8 },        // kind in bytes: 1, 2, 4, 8, 16
 -    Real { kind: u8 },           // 4 (single), 8 (double), 16 (quad)
 -    Complex { kind: u8 },        // 4, 8, 16
 -    Logical { kind: u8 },        // 1, 2, 4, 8
 +    Integer { kind: u8 }, // kind in bytes: 1, 2, 4, 8, 16
 +    Real { kind: u8 },    // 4 (single), 8 (double), 16 (quad)
 +    Complex { kind: u8 }, // 4, 8, 16
 +    Logical { kind: u8 }, // 1, 2, 4, 8
      Character { kind: u8, len: CharLen },
      Derived { name: String },
 -    ClassOf { base: String },    // CLASS(t)
 -    UnlimitedPoly,               // CLASS(*)
 -    AssumedType,                 // TYPE(*)
 -    Void,                        // subroutine (no return value)
 -    Unknown,                     // not yet determined
 +    ClassOf { base: String }, // CLASS(t)
 +    UnlimitedPoly,            // CLASS(*)
 +    AssumedType,              // TYPE(*)
 +    Void,                     // subroutine (no return value)
 +    Unknown,                  // not yet determined
+ }
  /// Character length.
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum CharLen {
      Known(i64),
 -    Assumed,    // len=*
 -    Deferred,   // len=:
 -    Unknown,    // runtime expression
 +    Assumed,  // len=*
 +    Deferred, // len=:
 +    Unknown,  // runtime expression
+ }
  /// Array type information — wraps an element type with rank and shape.
  impl FortranType {
      /// Default integer: integer(4).
 -    pub fn default_integer() -> Self { Self::Integer { kind: 4 } }
 +    pub fn default_integer() -> Self {
 +        Self::Integer { kind: 4 }
 +    }
      /// Default real: real(4).
 -    pub fn default_real() -> Self { Self::Real { kind: 4 } }
 +    pub fn default_real() -> Self {
 +        Self::Real { kind: 4 }
 +    }
      /// Default double precision: real(8).
 -    pub fn double_precision() -> Self { Self::Real { kind: 8 } }
 +    pub fn double_precision() -> Self {
 +        Self::Real { kind: 8 }
 +    }
      /// Default complex: complex(4).
 -    pub fn default_complex() -> Self { Self::Complex { kind: 4 } }
 +    pub fn default_complex() -> Self {
 +        Self::Complex { kind: 4 }
 +    }
      /// Default logical: logical(4).
 -    pub fn default_logical() -> Self { Self::Logical { kind: 4 } }
 +    pub fn default_logical() -> Self {
 +        Self::Logical { kind: 4 }
 +    }
      /// Default character: character(1, len=1).
 -    pub fn default_character() -> Self { Self::Character { kind: 1, len: CharLen::Known(1) } }
 +    pub fn default_character() -> Self {
 +        Self::Character {
 +            kind: 1,
 +            len: CharLen::Known(1),
 +        }
 +    }
      /// Is this a numeric type (integer, real, or complex)?
      pub fn is_numeric(&self) -> bool {
 -        matches!(self, Self::Integer { .. } | Self::Real { .. } | Self::Complex { .. })
 +        matches!(
 +            self,
 +            Self::Integer { .. } | Self::Real { .. } | Self::Complex { .. }
 +        )
+     }
      /// Is this a logical type?
 -    pub fn is_logical(&self) -> bool { matches!(self, Self::Logical { .. }) }
 +    pub fn is_logical(&self) -> bool {
 +        matches!(self, Self::Logical { .. })
 +    }
      /// Is this a character type?
 -    pub fn is_character(&self) -> bool { matches!(self, Self::Character { .. }) }
 +    pub fn is_character(&self) -> bool {
 +        matches!(self, Self::Character { .. })
 +    }
      /// Get the kind (size in bytes) for numeric/logical types.
      pub fn kind(&self) -> Option<u8> {
          match self {
 -            Self::Integer { kind } | Self::Real { kind } |
 -            Self::Complex { kind } | Self::Logical { kind } |
 -            Self::Character { kind, .. } => Some(*kind),
 +            Self::Integer { kind }
 +            | Self::Real { kind }
 +            | Self::Complex { kind }
 +            | Self::Logical { kind }
 +            | Self::Character { kind, .. } => Some(*kind),
              _ => None,
+         }
+     }
      //   real + complex → max(kind_a, kind_b)
      let result_rank = left_rank.max(right_rank);
      let result_kind = if left_rank == right_rank {
 -        left_kind.max(right_kind)  // same type class: max kind
 +        left_kind.max(right_kind) // same type class: max kind
      } else if left_rank == 1 {
 -        right_kind  // integer + real/complex: use real/complex kind
 +        right_kind // integer + real/complex: use real/complex kind
      } else if right_rank == 1 {
 -        left_kind   // real/complex + integer: use real/complex kind
 +        left_kind // real/complex + integer: use real/complex kind
      } else {
 -        left_kind.max(right_kind)  // real + complex: max kind
 +        left_kind.max(right_kind) // real + complex: max kind
      };
      Some(match result_rank {
          return None;
+     }
      // If both integer, result is integer with max kind.
 -    if matches!(base, FortranType::Integer { .. }) && matches!(exponent, FortranType::Integer { .. }) {
 +    if matches!(base, FortranType::Integer { .. })
 +        && matches!(exponent, FortranType::Integer { .. })
 +    {
          let kind = base.kind().unwrap_or(4).max(exponent.kind().unwrap_or(4));
          return Some(FortranType::Integer { kind });
+     }
          (CharLen::Known(a), CharLen::Known(b)) => CharLen::Known(a + b),
          _ => CharLen::Unknown,
      };
 -    Some(FortranType::Character { kind: left_kind, len: result_len })
 +    Some(FortranType::Character {
 +        kind: left_kind,
 +        len: result_len,
 +    })
+ }
  /// Check if an implicit conversion is needed from `from` to `to`.
  /// Returns None if no conversion needed, or the target type if needed.
  /// Complex→non-complex requires explicit conversion per standard.
  pub fn needs_conversion(from: &FortranType, to: &FortranType) -> Option<FortranType> {
 -    if from == to { return None; }
 +    if from == to {
 +        return None;
 +    }
      if from.is_numeric() && to.is_numeric() {
          // Complex → non-complex requires explicit conversion (REAL(), INT()).
 -        if matches!(from, FortranType::Complex { .. }) && !matches!(to, FortranType::Complex { .. }) {
 +        if matches!(from, FortranType::Complex { .. }) && !matches!(to, FortranType::Complex { .. })
 +        {
              return None;
+         }
          return Some(to.clone());
  /// Logical operators require logical operands and produce logical.
  pub fn logical_result_type(operand: &FortranType) -> Option<FortranType> {
      if operand.is_logical() {
 -        Some(FortranType::Logical { kind: operand.kind().unwrap_or(4) })
 +        Some(FortranType::Logical {
 +            kind: operand.kind().unwrap_or(4),
 +        })
      } else {
          None // Error: logical operator applied to non-logical type
+     }
+ }
  /// Compute the result type of any binary operation.
 -pub fn binary_op_result_type(op: &crate::ast::expr::BinaryOp, left: &FortranType, right: &FortranType) -> Option<FortranType> {
 +pub fn binary_op_result_type(
 +    op: &crate::ast::expr::BinaryOp,
 +    left: &FortranType,
 +    right: &FortranType,
 +) -> Option<FortranType> {
      use crate::ast::expr::BinaryOp;
      match op {
          BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div => {
+         }
          BinaryOp::Pow => power_result_type(left, right),
          BinaryOp::Concat => concat_result_type(left, right),
 -        BinaryOp::Eq | BinaryOp::Ne | BinaryOp::Lt | BinaryOp::Le |
 -        BinaryOp::Gt | BinaryOp::Ge => {
 -            if (left.is_numeric() && right.is_numeric()) || (left.is_character() && right.is_character()) {
 +        BinaryOp::Eq | BinaryOp::Ne | BinaryOp::Lt | BinaryOp::Le | BinaryOp::Gt | BinaryOp::Ge => {
 +            if (left.is_numeric() && right.is_numeric())
 +                || (left.is_character() && right.is_character())
 +            {
                  Some(comparison_result_type())
              } else {
                  None
+ }
  /// Compute the result type of a unary operation.
 -pub fn unary_op_result_type(op: &crate::ast::expr::UnaryOp, operand: &FortranType) -> Option<FortranType> {
 +pub fn unary_op_result_type(
 +    op: &crate::ast::expr::UnaryOp,
 +    operand: &FortranType,
 +) -> Option<FortranType> {
      use crate::ast::expr::UnaryOp;
      match op {
          UnaryOp::Plus | UnaryOp::Minus => {
 -            if operand.is_numeric() { Some(operand.clone()) } else { None }
 +            if operand.is_numeric() {
 +                Some(operand.clone())
 +            } else {
 +                None
 +            }
+         }
          UnaryOp::Not => logical_result_type(operand),
          UnaryOp::Defined(_) => Some(FortranType::Unknown),
+ }
  /// Disambiguate `A(I)` based on symbol table information.
 -pub fn disambiguate_call(sym_kind: &super::symtab::SymbolKind, has_range_subscript: bool) -> CallKind {
 +pub fn disambiguate_call(
 +    sym_kind: &super::symtab::SymbolKind,
 +    has_range_subscript: bool,
 +) -> CallKind {
      use super::symtab::SymbolKind;
      match sym_kind {
          SymbolKind::Variable => {
                  CallKind::ArrayElement // variable with subscripts → array element
+             }
+         }
 -        SymbolKind::Function | SymbolKind::ExternalProc |
 -        SymbolKind::IntrinsicProc | SymbolKind::ProcedurePointer => CallKind::FunctionCall,
 +        SymbolKind::Function
 +        | SymbolKind::ExternalProc
 +        | SymbolKind::IntrinsicProc
 +        | SymbolKind::ProcedurePointer => CallKind::FunctionCall,
          SymbolKind::NamedInterface => CallKind::FunctionCall, // generic → function call
          _ => CallKind::Unknown,
+     }
  pub fn type_info_to_fortran_type(info: &super::symtab::TypeInfo) -> FortranType {
      use super::symtab::TypeInfo;
      match info {
 -        TypeInfo::Integer { kind } => FortranType::Integer { kind: kind.unwrap_or(4) },
 -        TypeInfo::Real { kind } => FortranType::Real { kind: kind.unwrap_or(4) },
 +        TypeInfo::Integer { kind } => FortranType::Integer {
 +            kind: kind.unwrap_or(4),
 +        },
 +        TypeInfo::Real { kind } => FortranType::Real {
 +            kind: kind.unwrap_or(4),
 +        },
          TypeInfo::DoublePrecision => FortranType::Real { kind: 8 },
 -        TypeInfo::Complex { kind } => FortranType::Complex { kind: kind.unwrap_or(4) },
 -        TypeInfo::Logical { kind } => FortranType::Logical { kind: kind.unwrap_or(4) },
 +        TypeInfo::Complex { kind } => FortranType::Complex {
 +            kind: kind.unwrap_or(4),
 +        },
 +        TypeInfo::Logical { kind } => FortranType::Logical {
 +            kind: kind.unwrap_or(4),
 +        },
          TypeInfo::Character { len, kind } => FortranType::Character {
              kind: kind.unwrap_or(1),
              len: match len {
      use crate::ast::expr::Expr;
      match expr {
          Expr::IntegerLiteral { kind, .. } => {
 -            let k = kind.as_ref().and_then(|s| s.parse::<u8>().ok()).unwrap_or(4);
 +            let k = kind
 +                .as_ref()
 +                .and_then(|s| s.parse::<u8>().ok())
 +                .unwrap_or(4);
              FortranType::Integer { kind: k }
+         }
          Expr::RealLiteral { text, kind, .. } => {
+             }
+         }
          Expr::StringLiteral { kind, value, .. } => {
 -            let k = kind.as_ref().and_then(|s| s.parse::<u8>().ok()).unwrap_or(1);
 -            FortranType::Character { kind: k, len: CharLen::Known(value.len() as i64) }
 +            let k = kind
 +                .as_ref()
 +                .and_then(|s| s.parse::<u8>().ok())
 +                .unwrap_or(1);
 +            FortranType::Character {
 +                kind: k,
 +                len: CharLen::Known(value.len() as i64),
 +            }
+         }
          Expr::LogicalLiteral { kind, .. } => {
 -            let k = kind.as_ref().and_then(|s| s.parse::<u8>().ok()).unwrap_or(4);
 +            let k = kind
 +                .as_ref()
 +                .and_then(|s| s.parse::<u8>().ok())
 +                .unwrap_or(4);
              FortranType::Logical { kind: k }
+         }
          Expr::ComplexLiteral { .. } => FortranType::default_complex(),
  /// Compute the type of an expression given a symbol table context.
  /// Returns Unknown for expressions that can't be resolved without more context.
 -pub fn expr_type(expr: &crate::ast::expr::SpannedExpr, symtab: &super::symtab::SymbolTable) -> FortranType {
 +pub fn expr_type(
 +    expr: &crate::ast::expr::SpannedExpr,
 +    symtab: &super::symtab::SymbolTable,
 +) -> FortranType {
      use crate::ast::expr::Expr;
      match &expr.node {
          // Literals
 -        Expr::IntegerLiteral { .. } | Expr::RealLiteral { .. } |
 -        Expr::StringLiteral { .. } | Expr::LogicalLiteral { .. } |
 -        Expr::ComplexLiteral { .. } | Expr::BozLiteral { .. } => literal_type(&expr.node),
 +        Expr::IntegerLiteral { .. }
 +        | Expr::RealLiteral { .. }
 +        | Expr::StringLiteral { .. }
 +        | Expr::LogicalLiteral { .. }
 +        | Expr::ComplexLiteral { .. }
 +        | Expr::BozLiteral { .. } => literal_type(&expr.node),
          // Name — look up in symbol table
          Expr::Name { name } => {
          Expr::FunctionCall { callee, args } => {
              if let Expr::Name { name } = &callee.node {
                  // Check intrinsics first
 -                let arg_types: Vec<FortranType> = args.iter().map(|a| {
 -                    match &a.value {
 +                let arg_types: Vec<FortranType> = args
 +                    .iter()
 +                    .map(|a| match &a.value {
                          crate::ast::expr::SectionSubscript::Element(e) => expr_type(e, symtab),
                          crate::ast::expr::SectionSubscript::Range { .. } => FortranType::Unknown,
 -                    }
 -                }).collect();
 +                    })
 +                    .collect();
                  if let Some(result) = intrinsic_result_type(name, &arg_types) {
                      return result;
                                  None => FortranType::Unknown,
+                             }
+                         }
 -                        CallKind::Substring => {
 -                            FortranType::Character { kind: 1, len: CharLen::Unknown }
 -                        }
 +                        CallKind::Substring => FortranType::Character {
 +                            kind: 1,
 +                            len: CharLen::Unknown,
 +                        },
                          CallKind::Unknown => FortranType::Unknown,
+                     }
                  } else {
          if let Some(kw) = keyword {
              seen_keyword = true;
              // Keyword argument — find matching dummy
 -            if let Some(idx) = dummy_args.iter().position(|d| d.name.eq_ignore_ascii_case(kw)) {
 +            if let Some(idx) = dummy_args
 +                .iter()
 +                .position(|d| d.name.eq_ignore_ascii_case(kw))
 +            {
                  if matched[idx] {
                      errors.push(format!("duplicate keyword argument '{}'", kw));
                  } else {
                  check_arg_type(&dummy_args[pos], actual_type, &mut errors);
                  pos += 1;
              } else {
 -                errors.push(format!("too many arguments (expected at most {})", dummy_args.len()));
 +                errors.push(format!(
 +                    "too many arguments (expected at most {})",
 +                    dummy_args.len()
 +                ));
                  break;
+             }
+         }
          "sign" | "mod" | "modulo" => args.first().cloned(),
          // Real-valued math.
 -        "sin" | "cos" | "tan" | "asin" | "acos" | "atan" |
 -        "exp" | "log" | "log10" | "sqrt" | "atan2" => {
 -            Some(args.first().cloned().unwrap_or(FortranType::default_real()))
 -        }
 +        "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "exp" | "log" | "log10" | "sqrt"
 +        | "atan2" => Some(args.first().cloned().unwrap_or(FortranType::default_real())),
          // Integer-valued.
          "int" | "nint" | "floor" | "ceiling" => Some(FortranType::default_integer()),
          "any" | "all" => Some(FortranType::default_logical()),
          // Character-valued.
 -        "trim" | "adjustl" | "adjustr" | "repeat" => {
 -            Some(FortranType::Character { kind: 1, len: CharLen::Unknown })
 -        }
 -        "char" | "achar" => Some(FortranType::Character { kind: 1, len: CharLen::Known(1) }),
 +        "trim" | "adjustl" | "adjustr" | "repeat" => Some(FortranType::Character {
 +            kind: 1,
 +            len: CharLen::Unknown,
 +        }),
 +        "char" | "achar" => Some(FortranType::Character {
 +            kind: 1,
 +            len: CharLen::Known(1),
 +        }),
          // Complex-valued.
          "cmplx" => Some(FortranType::default_complex()),
          // Inquiry intrinsics.
          "huge" | "tiny" | "epsilon" => args.first().cloned(),
 -        "precision" | "range" | "digits" | "radix" | "exponent" => Some(FortranType::default_integer()),
 +        "precision" | "range" | "digits" | "radix" | "exponent" => {
 +            Some(FortranType::default_integer())
 +        }
          "storage_size" | "c_sizeof" => Some(FortranType::default_integer()),
          "iachar" | "ichar" => Some(FortranType::default_integer()),
          // System / misc.
          "command_argument_count" => Some(FortranType::default_integer()),
          "null" => Some(FortranType::Unknown), // null pointer — type from context
 -        "new_line" => Some(FortranType::Character { kind: 1, len: CharLen::Known(1) }),
 +        "new_line" => Some(FortranType::Character {
 +            kind: 1,
 +            len: CharLen::Known(1),
 +        }),
          "logical" => Some(FortranType::default_logical()),
          // iso_c_binding.
 -        "c_loc" | "c_funloc" => Some(FortranType::Derived { name: "c_ptr".into() }),
 +        "c_loc" | "c_funloc" => Some(FortranType::Derived {
 +            name: "c_ptr".into(),
 +        }),
          "c_associated" => Some(FortranType::default_logical()),
          // Status inquiry.
          let result = arithmetic_result_type(
              &FortranType::Integer { kind: 4 },
              &FortranType::Integer { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Integer { kind: 4 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Integer { kind: 4 },
              &FortranType::Real { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 4 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Real { kind: 4 },
              &FortranType::Complex { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Complex { kind: 4 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Integer { kind: 4 },
              &FortranType::Real { kind: 8 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 8 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Integer { kind: 4 },
              &FortranType::Integer { kind: 8 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Integer { kind: 8 });
+     }
          assert!(arithmetic_result_type(
              &FortranType::default_logical(),
              &FortranType::default_integer(),
 -        ).is_none());
 +        )
 +        .is_none());
+     }
      // ---- Power ----
          let result = power_result_type(
              &FortranType::Integer { kind: 4 },
              &FortranType::Integer { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Integer { kind: 4 });
+     }
          let result = power_result_type(
              &FortranType::Real { kind: 8 },
              &FortranType::Integer { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 8 });
+     }
          let result = power_result_type(
              &FortranType::Integer { kind: 4 },
              &FortranType::Complex { kind: 8 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Complex { kind: 8 });
+     }
      #[test]
      fn concat_known_lengths() {
          let result = concat_result_type(
 -            &FortranType::Character { kind: 1, len: CharLen::Known(5) },
 -            &FortranType::Character { kind: 1, len: CharLen::Known(3) },
 -        ).unwrap();
 -        assert_eq!(result, FortranType::Character { kind: 1, len: CharLen::Known(8) });
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(5),
 +            },
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(3),
 +            },
 +        )
 +        .unwrap();
 +        assert_eq!(
 +            result,
 +            FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(8)
 +            }
 +        );
+     }
      #[test]
      fn concat_non_character_returns_none() {
          assert!(concat_result_type(
              &FortranType::default_integer(),
 -            &FortranType::Character { kind: 1, len: CharLen::Known(5) },
 -        ).is_none());
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(5)
 +            },
 +        )
 +        .is_none());
+     }
      // ---- Conversion ----
          assert!(needs_conversion(
              &FortranType::Integer { kind: 4 },
              &FortranType::Integer { kind: 4 },
 -        ).is_none());
 +        )
 +        .is_none());
+     }
      #[test]
          let conv = needs_conversion(
              &FortranType::Integer { kind: 4 },
              &FortranType::Real { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(conv, FortranType::Real { kind: 4 });
+     }
      #[test]
      fn len_returns_integer() {
 -        let result = intrinsic_result_type("len", &[
 -            FortranType::Character { kind: 1, len: CharLen::Known(10) }
 -        ]).unwrap();
 +        let result = intrinsic_result_type(
 +            "len",
 +            &[FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(10),
 +            }],
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::default_integer());
+     }
      #[test]
      fn trim_returns_character() {
 -        let result = intrinsic_result_type("trim", &[
 -            FortranType::Character { kind: 1, len: CharLen::Known(20) }
 -        ]).unwrap();
 +        let result = intrinsic_result_type(
 +            "trim",
 +            &[FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(20),
 +            }],
 +        )
 +        .unwrap();
          assert!(result.is_character());
+     }
      #[test]
      fn unknown_intrinsic_returns_none() {
 -        assert!(intrinsic_result_type("nonexistent_func", &[FortranType::default_integer()]).is_none());
 +        assert!(
 +            intrinsic_result_type("nonexistent_func", &[FortranType::default_integer()]).is_none()
 +        );
+     }
      // ---- Binary op result type ----
              &BinaryOp::Add,
              &FortranType::Integer { kind: 4 },
              &FortranType::Real { kind: 8 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 8 });
+     }
              &BinaryOp::Pow,
              &FortranType::Real { kind: 4 },
              &FortranType::Integer { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 4 });
+     }
          use crate::ast::expr::BinaryOp;
          let result = binary_op_result_type(
              &BinaryOp::Concat,
 -            &FortranType::Character { kind: 1, len: CharLen::Known(3) },
 -            &FortranType::Character { kind: 1, len: CharLen::Known(4) },
 -        ).unwrap();
 -        assert_eq!(result, FortranType::Character { kind: 1, len: CharLen::Known(7) });
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(3),
 +            },
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(4),
 +            },
 +        )
 +        .unwrap();
 +        assert_eq!(
 +            result,
 +            FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(7)
 +            }
 +        );
+     }
      #[test]
              &BinaryOp::Eq,
              &FortranType::Integer { kind: 4 },
              &FortranType::Real { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::default_logical());
+     }
          use crate::ast::expr::BinaryOp;
          let result = binary_op_result_type(
              &BinaryOp::Lt,
 -            &FortranType::Character { kind: 1, len: CharLen::Known(5) },
 -            &FortranType::Character { kind: 1, len: CharLen::Known(5) },
 -        ).unwrap();
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(5),
 +            },
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(5),
 +            },
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::default_logical());
+     }
          assert!(binary_op_result_type(
              &BinaryOp::Eq,
              &FortranType::Integer { kind: 4 },
 -            &FortranType::Character { kind: 1, len: CharLen::Known(3) },
 -        ).is_none());
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(3)
 +            },
 +        )
 +        .is_none());
+     }
      #[test]
              &BinaryOp::And,
              &FortranType::Logical { kind: 4 },
              &FortranType::Logical { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Logical { kind: 4 });
+     }
              &BinaryOp::And,
              &FortranType::Integer { kind: 4 },
              &FortranType::Logical { kind: 4 },
 -        ).is_none());
 +        )
 +        .is_none());
+     }
      #[test]
              &BinaryOp::Or,
              &FortranType::Logical { kind: 1 },
              &FortranType::Logical { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Logical { kind: 4 });
+     }
              &BinaryOp::Defined("cross".into()),
              &FortranType::default_real(),
              &FortranType::default_real(),
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Unknown);
+     }
      #[test]
      fn unary_minus_real() {
          use crate::ast::expr::UnaryOp;
 -        let result = unary_op_result_type(
 -            &UnaryOp::Minus,
 -            &FortranType::Real { kind: 8 },
 -        ).unwrap();
 +        let result = unary_op_result_type(&UnaryOp::Minus, &FortranType::Real { kind: 8 }).unwrap();
          assert_eq!(result, FortranType::Real { kind: 8 });
+     }
      #[test]
      fn unary_plus_non_numeric_returns_none() {
          use crate::ast::expr::UnaryOp;
 -        assert!(unary_op_result_type(
 -            &UnaryOp::Plus,
 -            &FortranType::default_logical(),
 -        ).is_none());
 +        assert!(unary_op_result_type(&UnaryOp::Plus, &FortranType::default_logical(),).is_none());
+     }
      #[test]
      fn unary_not_logical() {
          use crate::ast::expr::UnaryOp;
 -        let result = unary_op_result_type(
 -            &UnaryOp::Not,
 -            &FortranType::Logical { kind: 4 },
 -        ).unwrap();
 +        let result =
 +            unary_op_result_type(&UnaryOp::Not, &FortranType::Logical { kind: 4 }).unwrap();
          assert_eq!(result, FortranType::Logical { kind: 4 });
+     }
      #[test]
      fn unary_not_non_logical_returns_none() {
          use crate::ast::expr::UnaryOp;
 -        assert!(unary_op_result_type(
 -            &UnaryOp::Not,
 -            &FortranType::Integer { kind: 4 },
 -        ).is_none());
 +        assert!(unary_op_result_type(&UnaryOp::Not, &FortranType::Integer { kind: 4 },).is_none());
+     }
      // ---- Disambiguation ----
      #[test]
      fn disambiguate_variable_element() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::Variable, false), CallKind::ArrayElement);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::Variable, false),
 +            CallKind::ArrayElement
 +        );
+     }
      #[test]
      fn disambiguate_variable_range_is_substring() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::Variable, true), CallKind::Substring);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::Variable, true),
 +            CallKind::Substring
 +        );
+     }
      #[test]
      fn disambiguate_function() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::Function, false), CallKind::FunctionCall);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::Function, false),
 +            CallKind::FunctionCall
 +        );
+     }
      #[test]
      fn disambiguate_external_proc() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::ExternalProc, false), CallKind::FunctionCall);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::ExternalProc, false),
 +            CallKind::FunctionCall
 +        );
+     }
      #[test]
      fn disambiguate_intrinsic_proc() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::IntrinsicProc, true), CallKind::FunctionCall);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::IntrinsicProc, true),
 +            CallKind::FunctionCall
 +        );
+     }
      #[test]
      fn disambiguate_named_interface() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::NamedInterface, false), CallKind::FunctionCall);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::NamedInterface, false),
 +            CallKind::FunctionCall
 +        );
+     }
      #[test]
      fn disambiguate_unknown_kind() {
          use super::super::symtab::SymbolKind;
 -        assert_eq!(disambiguate_call(&SymbolKind::Module, false), CallKind::Unknown);
 +        assert_eq!(
 +            disambiguate_call(&SymbolKind::Module, false),
 +            CallKind::Unknown
 +        );
+     }
      // ---- TypeInfo → FortranType conversion ----
      fn type_info_character_with_len() {
          use super::super::symtab::TypeInfo;
          assert_eq!(
 -            type_info_to_fortran_type(&TypeInfo::Character { len: Some(10), kind: None }),
 -            FortranType::Character { kind: 1, len: CharLen::Known(10) }
 +            type_info_to_fortran_type(&TypeInfo::Character {
 +                len: Some(10),
 +                kind: None
 +            }),
 +            FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(10)
 +            }
          );
+     }
          use super::super::symtab::TypeInfo;
          assert_eq!(
              type_info_to_fortran_type(&TypeInfo::Derived("point".into())),
 -            FortranType::Derived { name: "point".into() }
 +            FortranType::Derived {
 +                name: "point".into()
 +            }
          );
+     }
      fn literal_type_integer() {
          use crate::ast::expr::Expr;
          assert_eq!(
 -            literal_type(&Expr::IntegerLiteral { text: "42".into(), kind: None }),
 +            literal_type(&Expr::IntegerLiteral {
 +                text: "42".into(),
 +                kind: None
 +            }),
              FortranType::Integer { kind: 4 }
          );
+     }
      fn literal_type_integer_kind8() {
          use crate::ast::expr::Expr;
          assert_eq!(
 -            literal_type(&Expr::IntegerLiteral { text: "42".into(), kind: Some("8".into()) }),
 +            literal_type(&Expr::IntegerLiteral {
 +                text: "42".into(),
 +                kind: Some("8".into())
 +            }),
              FortranType::Integer { kind: 8 }
          );
+     }
      fn literal_type_real_default() {
          use crate::ast::expr::Expr;
          assert_eq!(
 -            literal_type(&Expr::RealLiteral { text: "3.14".into(), kind: None }),
 +            literal_type(&Expr::RealLiteral {
 +                text: "3.14".into(),
 +                kind: None
 +            }),
              FortranType::Real { kind: 4 }
          );
+     }
      fn literal_type_real_d_exponent() {
          use crate::ast::expr::Expr;
          assert_eq!(
 -            literal_type(&Expr::RealLiteral { text: "1.0d0".into(), kind: None }),
 +            literal_type(&Expr::RealLiteral {
 +                text: "1.0d0".into(),
 +                kind: None
 +            }),
              FortranType::Real { kind: 8 }
          );
+     }
      fn literal_type_string() {
          use crate::ast::expr::Expr;
          assert_eq!(
 -            literal_type(&Expr::StringLiteral { value: "hello".into(), kind: None }),
 -            FortranType::Character { kind: 1, len: CharLen::Known(5) }
 +            literal_type(&Expr::StringLiteral {
 +                value: "hello".into(),
 +                kind: None
 +            }),
 +            FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(5)
 +            }
          );
+     }
      fn literal_type_logical() {
          use crate::ast::expr::Expr;
          assert_eq!(
 -            literal_type(&Expr::LogicalLiteral { value: true, kind: None }),
 +            literal_type(&Expr::LogicalLiteral {
 +                value: true,
 +                kind: None
 +            }),
              FortranType::Logical { kind: 4 }
          );
+     }
      fn expr_type_integer_literal() {
          use crate::ast::expr::Expr;
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 -        let expr = Spanned::new(Expr::IntegerLiteral { text: "42".into(), kind: None }, span);
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
 +        let expr = Spanned::new(
 +            Expr::IntegerLiteral {
 +                text: "42".into(),
 +                kind: None,
 +            },
 +            span,
 +        );
          let st = super::super::symtab::SymbolTable::new();
          assert_eq!(expr_type(&expr, &st), FortranType::Integer { kind: 4 });
+     }
      #[test]
      fn expr_type_name_lookup() {
 +        use super::super::symtab::*;
          use crate::ast::expr::Expr;
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        use super::super::symtab::*;
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let mut st = SymbolTable::new();
          st.push_scope(ScopeKind::Program("main".into()));
              scope: 0,
              arg_names: vec![],
              const_value: None,
 -        }).unwrap();
 +        })
 +        .unwrap();
          let expr = Spanned::new(Expr::Name { name: "x".into() }, span);
          assert_eq!(expr_type(&expr, &st), FortranType::Real { kind: 8 });
      #[test]
      fn expr_type_name_implicit() {
 +        use super::super::symtab::*;
          use crate::ast::expr::Expr;
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        use super::super::symtab::*;
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let mut st = SymbolTable::new();
          st.push_scope(ScopeKind::Program("main".into()));
      #[test]
      fn expr_type_binary_add() {
 -        use crate::ast::expr::{Expr, BinaryOp};
 +        use crate::ast::expr::{BinaryOp, Expr};
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let st = super::super::symtab::SymbolTable::new();
 -        let left = Box::new(Spanned::new(Expr::IntegerLiteral { text: "1".into(), kind: None }, span));
 -        let right = Box::new(Spanned::new(Expr::RealLiteral { text: "2.0".into(), kind: None }, span));
 -        let expr = Spanned::new(Expr::BinaryOp { op: BinaryOp::Add, left, right }, span);
 +        let left = Box::new(Spanned::new(
 +            Expr::IntegerLiteral {
 +                text: "1".into(),
 +                kind: None,
 +            },
 +            span,
 +        ));
 +        let right = Box::new(Spanned::new(
 +            Expr::RealLiteral {
 +                text: "2.0".into(),
 +                kind: None,
 +            },
 +            span,
 +        ));
 +        let expr = Spanned::new(
 +            Expr::BinaryOp {
 +                op: BinaryOp::Add,
 +                left,
 +                right,
 +            },
 +            span,
 +        );
          assert_eq!(expr_type(&expr, &st), FortranType::Real { kind: 4 });
+     }
      fn expr_type_unary_minus() {
          use crate::ast::expr::{Expr, UnaryOp};
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let st = super::super::symtab::SymbolTable::new();
 -        let operand = Box::new(Spanned::new(Expr::RealLiteral { text: "3.14".into(), kind: None }, span));
 -        let expr = Spanned::new(Expr::UnaryOp { op: UnaryOp::Minus, operand }, span);
 +        let operand = Box::new(Spanned::new(
 +            Expr::RealLiteral {
 +                text: "3.14".into(),
 +                kind: None,
 +            },
 +            span,
 +        ));
 +        let expr = Spanned::new(
 +            Expr::UnaryOp {
 +                op: UnaryOp::Minus,
 +                operand,
 +            },
 +            span,
 +        );
          assert_eq!(expr_type(&expr, &st), FortranType::Real { kind: 4 });
+     }
      #[test]
      fn expr_type_intrinsic_call() {
 -        use crate::ast::expr::{Expr, Argument, SectionSubscript};
 +        use crate::ast::expr::{Argument, Expr, SectionSubscript};
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let st = super::super::symtab::SymbolTable::new();
          let callee = Box::new(Spanned::new(Expr::Name { name: "abs".into() }, span));
          let arg = Argument {
              keyword: None,
              value: SectionSubscript::Element(Spanned::new(
 -                Expr::IntegerLiteral { text: "-5".into(), kind: None }, span
 +                Expr::IntegerLiteral {
 +                    text: "-5".into(),
 +                    kind: None,
 +                },
 +                span,
              )),
          };
 -        let expr = Spanned::new(Expr::FunctionCall { callee, args: vec![arg] }, span);
 +        let expr = Spanned::new(
 +            Expr::FunctionCall {
 +                callee,
 +                args: vec![arg],
 +            },
 +            span,
 +        );
          assert_eq!(expr_type(&expr, &st), FortranType::Integer { kind: 4 });
+     }
      fn expr_type_paren() {
          use crate::ast::expr::Expr;
          use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let st = super::super::symtab::SymbolTable::new();
 -        let inner = Box::new(Spanned::new(Expr::RealLiteral { text: "1.0".into(), kind: None }, span));
 +        let inner = Box::new(Spanned::new(
 +            Expr::RealLiteral {
 +                text: "1.0".into(),
 +                kind: None,
 +            },
 +            span,
 +        ));
          let expr = Spanned::new(Expr::ParenExpr { inner }, span);
          assert_eq!(expr_type(&expr, &st), FortranType::Real { kind: 4 });
+     }
      #[test]
      fn expr_type_array_element() {
 -        use crate::ast::expr::{Expr, Argument, SectionSubscript};
 -        use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
          use super::super::symtab::*;
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::ast::expr::{Argument, Expr, SectionSubscript};
 +        use crate::ast::Spanned;
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let mut st = SymbolTable::new();
          st.push_scope(ScopeKind::Program("main".into()));
              scope: 0,
              arg_names: vec![],
              const_value: None,
 -        }).unwrap();
 +        })
 +        .unwrap();
          let callee = Box::new(Spanned::new(Expr::Name { name: "arr".into() }, span));
          let arg = Argument {
              keyword: None,
              value: SectionSubscript::Element(Spanned::new(
 -                Expr::IntegerLiteral { text: "3".into(), kind: None }, span
 +                Expr::IntegerLiteral {
 +                    text: "3".into(),
 +                    kind: None,
 +                },
 +                span,
              )),
          };
 -        let expr = Spanned::new(Expr::FunctionCall { callee, args: vec![arg] }, span);
 +        let expr = Spanned::new(
 +            Expr::FunctionCall {
 +                callee,
 +                args: vec![arg],
 +            },
 +            span,
 +        );
          // arr(3) where arr is a variable → array element → real(8)
          assert_eq!(expr_type(&expr, &st), FortranType::Real { kind: 8 });
+     }
      #[test]
      fn expr_type_substring() {
 -        use crate::ast::expr::{Expr, Argument, SectionSubscript};
 -        use crate::ast::Spanned;
 -        use crate::lexer::{Span, Position};
          use super::super::symtab::*;
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        use crate::ast::expr::{Argument, Expr, SectionSubscript};
 +        use crate::ast::Spanned;
 +        use crate::lexer::{Position, Span};
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          let mut st = SymbolTable::new();
          st.push_scope(ScopeKind::Program("main".into()));
          st.define(Symbol {
              name: "s".into(),
              kind: SymbolKind::Variable,
 -            type_info: Some(TypeInfo::Character { len: Some(20), kind: None }),
 +            type_info: Some(TypeInfo::Character {
 +                len: Some(20),
 +                kind: None,
 +            }),
              attrs: SymbolAttrs::default(),
              defined_at: span,
              scope: 0,
              arg_names: vec![],
              const_value: None,
 -        }).unwrap();
 +        })
 +        .unwrap();
          let callee = Box::new(Spanned::new(Expr::Name { name: "s".into() }, span));
          let arg = Argument {
              keyword: None,
              value: SectionSubscript::Range {
 -                start: Some(Spanned::new(Expr::IntegerLiteral { text: "1".into(), kind: None }, span)),
 -                end: Some(Spanned::new(Expr::IntegerLiteral { text: "5".into(), kind: None }, span)),
 +                start: Some(Spanned::new(
 +                    Expr::IntegerLiteral {
 +                        text: "1".into(),
 +                        kind: None,
 +                    },
 +                    span,
 +                )),
 +                end: Some(Spanned::new(
 +                    Expr::IntegerLiteral {
 +                        text: "5".into(),
 +                        kind: None,
 +                    },
 +                    span,
 +                )),
                  stride: None,
              },
          };
 -        let expr = Spanned::new(Expr::FunctionCall { callee, args: vec![arg] }, span);
 +        let expr = Spanned::new(
 +            Expr::FunctionCall {
 +                callee,
 +                args: vec![arg],
 +            },
 +            span,
 +        );
          // s(1:5) where s is character variable → substring
          assert!(expr_type(&expr, &st).is_character());
+     }
      fn check_args_positional_ok() {
          use super::super::symtab::Intent;
          let dummies = vec![
 -            DummyArgDesc { name: "a".into(), type_: FortranType::Real { kind: 4 }, intent: Some(Intent::In), optional: false },
 -            DummyArgDesc { name: "n".into(), type_: FortranType::Integer { kind: 4 }, intent: Some(Intent::In), optional: false },
 +            DummyArgDesc {
 +                name: "a".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: Some(Intent::In),
 +                optional: false,
 +            },
 +            DummyArgDesc {
 +                name: "n".into(),
 +                type_: FortranType::Integer { kind: 4 },
 +                intent: Some(Intent::In),
 +                optional: false,
 +            },
          ];
          let actuals = vec![
              (None, FortranType::Real { kind: 4 }),
      fn check_args_keyword_ok() {
          use super::super::symtab::Intent;
          let dummies = vec![
 -            DummyArgDesc { name: "a".into(), type_: FortranType::Real { kind: 4 }, intent: Some(Intent::In), optional: false },
 -            DummyArgDesc { name: "n".into(), type_: FortranType::Integer { kind: 4 }, intent: Some(Intent::In), optional: false },
 +            DummyArgDesc {
 +                name: "a".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: Some(Intent::In),
 +                optional: false,
 +            },
 +            DummyArgDesc {
 +                name: "n".into(),
 +                type_: FortranType::Integer { kind: 4 },
 +                intent: Some(Intent::In),
 +                optional: false,
 +            },
          ];
          let actuals = vec![
              (Some("n".into()), FortranType::Integer { kind: 4 }),
      #[test]
      fn check_args_optional_omitted_ok() {
          let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -            DummyArgDesc { name: "verbose".into(), type_: FortranType::default_logical(), intent: None, optional: true },
 -        ];
 -        let actuals = vec![
 -            (None, FortranType::Real { kind: 4 }),
 +            DummyArgDesc {
 +                name: "x".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: None,
 +                optional: false,
 +            },
 +            DummyArgDesc {
 +                name: "verbose".into(),
 +                type_: FortranType::default_logical(),
 +                intent: None,
 +                optional: true,
 +            },
          ];
 +        let actuals = vec![(None, FortranType::Real { kind: 4 })];
          assert!(check_arguments(&dummies, &actuals).is_empty());
+     }
      #[test]
      fn check_args_missing_required() {
          let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -            DummyArgDesc { name: "y".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -        ];
 -        let actuals = vec![
 -            (None, FortranType::Real { kind: 4 }),
 +            DummyArgDesc {
 +                name: "x".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: None,
 +                optional: false,
 +            },
 +            DummyArgDesc {
 +                name: "y".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: None,
 +                optional: false,
 +            },
          ];
 +        let actuals = vec![(None, FortranType::Real { kind: 4 })];
          let errs = check_arguments(&dummies, &actuals);
          assert_eq!(errs.len(), 1);
          assert!(errs[0].contains("missing required argument 'y'"));
      #[test]
      fn check_args_too_many() {
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::Real { kind: 4 },
 +            intent: None,
 +            optional: false,
 +        }];
          let actuals = vec![
              (None, FortranType::Real { kind: 4 }),
              (None, FortranType::Real { kind: 4 }),
      #[test]
      fn check_args_type_mismatch() {
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::default_logical(), intent: None, optional: false },
 -        ];
 -        let actuals = vec![
 -            (None, FortranType::Integer { kind: 4 }),
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::default_logical(),
 +            intent: None,
 +            optional: false,
 +        }];
 +        let actuals = vec![(None, FortranType::Integer { kind: 4 })];
          let errs = check_arguments(&dummies, &actuals);
          assert_eq!(errs.len(), 1);
          assert!(errs[0].contains("type mismatch"));
      #[test]
      fn check_args_numeric_conversion_allowed() {
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 8 }, intent: None, optional: false },
 -        ];
 -        let actuals = vec![
 -            (None, FortranType::Integer { kind: 4 }),
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::Real { kind: 8 },
 +            intent: None,
 +            optional: false,
 +        }];
 +        let actuals = vec![(None, FortranType::Integer { kind: 4 })];
          // integer → real conversion allowed
          assert!(check_arguments(&dummies, &actuals).is_empty());
+     }
      #[test]
      fn check_args_duplicate_keyword() {
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::Real { kind: 4 },
 +            intent: None,
 +            optional: false,
 +        }];
          let actuals = vec![
              (Some("x".into()), FortranType::Real { kind: 4 }),
              (Some("x".into()), FortranType::Real { kind: 4 }),
      #[test]
      fn check_args_unknown_keyword() {
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -        ];
 -        let actuals = vec![
 -            (Some("bogus".into()), FortranType::Real { kind: 4 }),
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::Real { kind: 4 },
 +            intent: None,
 +            optional: false,
 +        }];
 +        let actuals = vec![(Some("bogus".into()), FortranType::Real { kind: 4 })];
          let errs = check_arguments(&dummies, &actuals);
          assert!(errs.iter().any(|e| e.contains("unknown keyword")));
+     }
              SpecificProc {
                  name: "swap_int".into(),
                  dummy_args: vec![
 -                    DummyArgDesc { name: "a".into(), type_: FortranType::Integer { kind: 4 }, intent: None, optional: false },
 -                    DummyArgDesc { name: "b".into(), type_: FortranType::Integer { kind: 4 }, intent: None, optional: false },
 +                    DummyArgDesc {
 +                        name: "a".into(),
 +                        type_: FortranType::Integer { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
 +                    DummyArgDesc {
 +                        name: "b".into(),
 +                        type_: FortranType::Integer { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
                  ],
                  result_type: FortranType::Void,
              },
              SpecificProc {
                  name: "swap_real".into(),
                  dummy_args: vec![
 -                    DummyArgDesc { name: "a".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -                    DummyArgDesc { name: "b".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 +                    DummyArgDesc {
 +                        name: "a".into(),
 +                        type_: FortranType::Real { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
 +                    DummyArgDesc {
 +                        name: "b".into(),
 +                        type_: FortranType::Real { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
                  ],
                  result_type: FortranType::Void,
              },
          ];
          // integer args → swap_int (index 0)
 -        assert_eq!(resolve_generic(&specifics, &[
 -            FortranType::Integer { kind: 4 }, FortranType::Integer { kind: 4 }
 -        ]).unwrap(), 0);
 +        assert_eq!(
 +            resolve_generic(
 +                &specifics,
 +                &[
 +                    FortranType::Integer { kind: 4 },
 +                    FortranType::Integer { kind: 4 }
 +                ]
 +            )
 +            .unwrap(),
 +            0
 +        );
          // real args → swap_real (index 1)
 -        assert_eq!(resolve_generic(&specifics, &[
 -            FortranType::Real { kind: 4 }, FortranType::Real { kind: 4 }
 -        ]).unwrap(), 1);
 +        assert_eq!(
 +            resolve_generic(
 +                &specifics,
 +                &[FortranType::Real { kind: 4 }, FortranType::Real { kind: 4 }]
 +            )
 +            .unwrap(),
 +            1
 +        );
+     }
      #[test]
      fn resolve_generic_no_match() {
 -        let specifics = vec![
 -            SpecificProc {
 -                name: "foo_int".into(),
 -                dummy_args: vec![
 -                    DummyArgDesc { name: "x".into(), type_: FortranType::Integer { kind: 4 }, intent: None, optional: false },
 -                ],
 -                result_type: FortranType::Void,
 -            },
 -        ];
 +        let specifics = vec![SpecificProc {
 +            name: "foo_int".into(),
 +            dummy_args: vec![DummyArgDesc {
 +                name: "x".into(),
 +                type_: FortranType::Integer { kind: 4 },
 +                intent: None,
 +                optional: false,
 +            }],
 +            result_type: FortranType::Void,
 +        }];
          assert!(resolve_generic(&specifics, &[FortranType::Real { kind: 4 }]).is_err());
+     }
              SpecificProc {
                  name: "swap_int".into(),
                  dummy_args: vec![
 -                    DummyArgDesc { name: "a".into(), type_: FortranType::Integer { kind: 4 }, intent: None, optional: false },
 -                    DummyArgDesc { name: "b".into(), type_: FortranType::Integer { kind: 4 }, intent: None, optional: false },
 +                    DummyArgDesc {
 +                        name: "a".into(),
 +                        type_: FortranType::Integer { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
 +                    DummyArgDesc {
 +                        name: "b".into(),
 +                        type_: FortranType::Integer { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
                  ],
                  result_type: FortranType::Void,
              },
              SpecificProc {
                  name: "swap_real".into(),
                  dummy_args: vec![
 -                    DummyArgDesc { name: "a".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -                    DummyArgDesc { name: "b".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 +                    DummyArgDesc {
 +                        name: "a".into(),
 +                        type_: FortranType::Real { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
 +                    DummyArgDesc {
 +                        name: "b".into(),
 +                        type_: FortranType::Real { kind: 4 },
 +                        intent: None,
 +                        optional: false,
 +                    },
                  ],
                  result_type: FortranType::Void,
              },
          ];
          // mixed integer + real → no match (exact type required for disambiguation)
 -        assert!(resolve_generic(&specifics, &[
 -            FortranType::Integer { kind: 4 }, FortranType::Real { kind: 4 }
 -        ]).is_err());
 +        assert!(resolve_generic(
 +            &specifics,
 +            &[
 +                FortranType::Integer { kind: 4 },
 +                FortranType::Real { kind: 4 }
 +            ]
 +        )
 +        .is_err());
+     }
      #[test]
      fn resolve_generic_with_optional() {
 -        let specifics = vec![
 -            SpecificProc {
 -                name: "process".into(),
 -                dummy_args: vec![
 -                    DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -                    DummyArgDesc { name: "mask".into(), type_: FortranType::default_logical(), intent: None, optional: true },
 -                ],
 -                result_type: FortranType::Void,
 -            },
 -        ];
 +        let specifics = vec![SpecificProc {
 +            name: "process".into(),
 +            dummy_args: vec![
 +                DummyArgDesc {
 +                    name: "x".into(),
 +                    type_: FortranType::Real { kind: 4 },
 +                    intent: None,
 +                    optional: false,
 +                },
 +                DummyArgDesc {
 +                    name: "mask".into(),
 +                    type_: FortranType::default_logical(),
 +                    intent: None,
 +                    optional: true,
 +                },
 +            ],
 +            result_type: FortranType::Void,
 +        }];
          // Only required arg supplied — should match
 -        assert_eq!(resolve_generic(&specifics, &[
 -            FortranType::Real { kind: 4 }
 -        ]).unwrap(), 0);
 +        assert_eq!(
 +            resolve_generic(&specifics, &[FortranType::Real { kind: 4 }]).unwrap(),
 +            0
 +        );
+     }
      // ---- Logical result type ----
          let result = binary_logical_result_type(
              &FortranType::Logical { kind: 1 },
              &FortranType::Logical { kind: 8 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Logical { kind: 8 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Real { kind: 8 },
              &FortranType::Complex { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Complex { kind: 8 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Integer { kind: 8 },
              &FortranType::Real { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 4 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Integer { kind: 8 },
              &FortranType::Complex { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Complex { kind: 4 });
+     }
          let result = arithmetic_result_type(
              &FortranType::Real { kind: 4 },
              &FortranType::Integer { kind: 8 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Real { kind: 4 });
+     }
      #[test]
      fn positional_after_keyword_rejected() {
          let dummies = vec![
 -            DummyArgDesc { name: "a".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 -            DummyArgDesc { name: "b".into(), type_: FortranType::Real { kind: 4 }, intent: None, optional: false },
 +            DummyArgDesc {
 +                name: "a".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: None,
 +                optional: false,
 +            },
 +            DummyArgDesc {
 +                name: "b".into(),
 +                type_: FortranType::Real { kind: 4 },
 +                intent: None,
 +                optional: false,
 +            },
          ];
          let actuals = vec![
              (Some("a".into()), FortranType::Real { kind: 4 }),
              (None, FortranType::Real { kind: 4 }), // positional after keyword
          ];
          let errs = check_arguments(&dummies, &actuals);
 -        assert!(errs.iter().any(|e| e.contains("positional argument after keyword")));
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("positional argument after keyword")));
+     }
      // ---- Audit fix: M5 — intent(out/inout) rejects numeric conversion ----
      #[test]
      fn intent_inout_rejects_numeric_conversion() {
          use super::super::symtab::Intent;
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 8 }, intent: Some(Intent::InOut), optional: false },
 -        ];
 -        let actuals = vec![
 -            (None, FortranType::Integer { kind: 4 }),
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::Real { kind: 8 },
 +            intent: Some(Intent::InOut),
 +            optional: false,
 +        }];
 +        let actuals = vec![(None, FortranType::Integer { kind: 4 })];
          let errs = check_arguments(&dummies, &actuals);
          assert!(!errs.is_empty());
          assert!(errs[0].contains("intent(out/inout)"));
      #[test]
      fn intent_in_allows_numeric_conversion() {
          use super::super::symtab::Intent;
 -        let dummies = vec![
 -            DummyArgDesc { name: "x".into(), type_: FortranType::Real { kind: 8 }, intent: Some(Intent::In), optional: false },
 -        ];
 -        let actuals = vec![
 -            (None, FortranType::Integer { kind: 4 }),
 -        ];
 +        let dummies = vec![DummyArgDesc {
 +            name: "x".into(),
 +            type_: FortranType::Real { kind: 8 },
 +            intent: Some(Intent::In),
 +            optional: false,
 +        }];
 +        let actuals = vec![(None, FortranType::Integer { kind: 4 })];
          assert!(check_arguments(&dummies, &actuals).is_empty());
+     }
          assert!(needs_conversion(
              &FortranType::Complex { kind: 4 },
              &FortranType::Integer { kind: 4 },
 -        ).is_none());
 +        )
 +        .is_none());
+     }
      #[test]
          assert!(needs_conversion(
              &FortranType::Complex { kind: 4 },
              &FortranType::Real { kind: 4 },
 -        ).is_none());
 +        )
 +        .is_none());
+     }
      #[test]
          let conv = needs_conversion(
              &FortranType::Integer { kind: 4 },
              &FortranType::Complex { kind: 4 },
 -        ).unwrap();
 +        )
 +        .unwrap();
          assert_eq!(conv, FortranType::Complex { kind: 4 });
+     }
      #[test]
      fn concat_mismatched_kind_returns_none() {
          assert!(concat_result_type(
 -            &FortranType::Character { kind: 1, len: CharLen::Known(5) },
 -            &FortranType::Character { kind: 4, len: CharLen::Known(5) },
 -        ).is_none());
 +            &FortranType::Character {
 +                kind: 1,
 +                len: CharLen::Known(5)
 +            },
 +            &FortranType::Character {
 +                kind: 4,
 +                len: CharLen::Known(5)
 +            },
 +        )
 +        .is_none());
+     }
      // ---- New intrinsics ----
      #[test]
      fn intrinsic_c_associated() {
 -        let result = intrinsic_result_type("c_associated", &[
 -            FortranType::Derived { name: "c_ptr".into() }
 -        ]).unwrap();
 +        let result = intrinsic_result_type(
 +            "c_associated",
 +            &[FortranType::Derived {
 +                name: "c_ptr".into(),
 +            }],
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::default_logical());
+     }
      #[test]
      fn intrinsic_merge() {
 -        let result = intrinsic_result_type("merge", &[
 -            FortranType::Integer { kind: 4 },
 -            FortranType::Integer { kind: 4 },
 -            FortranType::default_logical(),
 -        ]).unwrap();
 +        let result = intrinsic_result_type(
 +            "merge",
 +            &[
 +                FortranType::Integer { kind: 4 },
 +                FortranType::Integer { kind: 4 },
 +                FortranType::default_logical(),
 +            ],
 +        )
 +        .unwrap();
          assert_eq!(result, FortranType::Integer { kind: 4 });
+     }
+ }

src/sema/validate.rsmodified

1701 lines changed — click to load

  //! constraints, label validation, and standard conformance. Runs after
  //! symbol resolution (resolve.rs) and type checking (types.rs).
 -use crate::ast::unit::*;
 -use crate::ast::stmt::*;
 +use super::symtab::*;
 +use crate::ast::decl::{Attribute, Decl, TypeAttr, TypeSpec};
  use crate::ast::expr::Expr;
 -use crate::ast::decl::{Decl, Attribute, TypeAttr, TypeSpec};
 +use crate::ast::stmt::*;
 +use crate::ast::unit::*;
  use crate::lexer::Span;
 -use super::symtab::*;
  use std::cell::RefCell;
  /// Fortran standard level for --std= conformance checking.
              DiagKind::Error => "error",
              DiagKind::Warning => "warning",
          };
 -        write!(f, "{}:{}: {}: {}", self.span.start.line, self.span.start.col, label, self.msg)
 +        write!(
 +            f,
 +            "{}:{}: {}: {}",
 +            self.span.start.line, self.span.start.col, label, self.msg
 +        )
+     }
+ }
      fn require_std(&mut self, span: Span, min: FortranStandard, feature: &str) {
          if let Some(selected) = self.std {
              if selected < min {
 -                self.error(span, format!("{} requires --std={:?} or later", feature, min));
 +                self.error(
 +                    span,
 +                    format!("{} requires --std={:?} or later", feature, min),
 +                );
+             }
+         }
+     }
+     }
      fn error(&mut self, span: Span, msg: impl Into<String>) {
 -        self.diags.push(Diagnostic { span, kind: DiagKind::Error, msg: msg.into() });
 +        self.diags.push(Diagnostic {
 +            span,
 +            kind: DiagKind::Error,
 +            msg: msg.into(),
 +        });
+     }
      fn warning(&mut self, span: Span, msg: impl Into<String>) {
 -        self.diags.push(Diagnostic { span, kind: DiagKind::Warning, msg: msg.into() });
 +        self.diags.push(Diagnostic {
 +            span,
 +            kind: DiagKind::Warning,
 +            msg: msg.into(),
 +        });
+     }
+ }
      std: Option<FortranStandard>,
      type_layouts: &crate::sema::type_layout::TypeLayoutRegistry,
  ) -> Vec<Diagnostic> {
 -    validate_file_with_layouts_and_warning_groups(
 -        units,
 -        st,
 -        std,
 -        type_layouts,
 -        false,
 -        false,
 -    )
 +    validate_file_with_layouts_and_warning_groups(units, st, std, type_layouts, false, false)
+ }
  pub fn validate_file_with_layouts_and_warning_groups(
      warn_pedantic: bool,
      warn_deprecated: bool,
  ) -> Vec<Diagnostic> {
 -    let mut ctx = Ctx::new_with_layouts(
 -        st,
 -        std,
 -        type_layouts,
 -        warn_pedantic,
 -        warn_deprecated,
 -    );
 +    let mut ctx = Ctx::new_with_layouts(st, std, type_layouts, warn_pedantic, warn_deprecated);
      for unit in units {
          validate_unit(&mut ctx, unit);
+     }
      attrs.iter().any(|attr| *attr == needle)
+ }
 -fn is_deferred_char_pointer_component(
 -    type_spec: &TypeSpec,
 -    attrs: &[Attribute],
 -) -> bool {
 +fn is_deferred_char_pointer_component(type_spec: &TypeSpec, attrs: &[Attribute]) -> bool {
      decl_attrs_contain(attrs, Attribute::Pointer)
          && matches!(
              type_spec,
+             }
              for implicit_stmt in implicit {
                  if matches!(implicit_stmt.node, Decl::ImplicitNone { .. }) {
 -                    ctx.require_std(
 -                        implicit_stmt.span,
 -                        FortranStandard::F90,
 -                        "IMPLICIT NONE",
 -                    );
 +                    ctx.require_std(implicit_stmt.span, FortranStandard::F90, "IMPLICIT NONE");
+                 }
+             }
              if !contains.is_empty() {
 -                ctx.require_std(unit.span, FortranStandard::F90, "CONTAINS/internal procedures");
 +                ctx.require_std(
 +                    unit.span,
 +                    FortranStandard::F90,
 +                    "CONTAINS/internal procedures",
 +                );
+             }
              validate_decls(ctx, decls);
              check_implicit_none(ctx, body, decls);
          ProgramUnit::Module {
              uses,
              implicit,
 -            decls, contains, ..
 +            decls,
 +            contains,
 +            ..
          } => {
              ctx.require_std(unit.span, FortranStandard::F90, "MODULE");
              for use_stmt in uses {
+             }
              for implicit_stmt in implicit {
                  if matches!(implicit_stmt.node, Decl::ImplicitNone { .. }) {
 -                    ctx.require_std(
 -                        implicit_stmt.span,
 -                        FortranStandard::F90,
 -                        "IMPLICIT NONE",
 -                    );
 +                    ctx.require_std(implicit_stmt.span, FortranStandard::F90, "IMPLICIT NONE");
+                 }
+             }
              validate_decls(ctx, decls);
+             }
              for implicit_stmt in implicit {
                  if matches!(implicit_stmt.node, Decl::ImplicitNone { .. }) {
 -                    ctx.require_std(
 -                        implicit_stmt.span,
 -                        FortranStandard::F90,
 -                        "IMPLICIT NONE",
 -                    );
 +                    ctx.require_std(implicit_stmt.span, FortranStandard::F90, "IMPLICIT NONE");
+                 }
+             }
              if !contains.is_empty() {
 -                ctx.require_std(unit.span, FortranStandard::F90, "CONTAINS/internal procedures");
 +                ctx.require_std(
 +                    unit.span,
 +                    FortranStandard::F90,
 +                    "CONTAINS/internal procedures",
 +                );
+             }
              validate_decls(ctx, decls);
              check_implicit_none(ctx, body, decls);
+             }
              for implicit_stmt in implicit {
                  if matches!(implicit_stmt.node, Decl::ImplicitNone { .. }) {
 -                    ctx.require_std(
 -                        implicit_stmt.span,
 -                        FortranStandard::F90,
 -                        "IMPLICIT NONE",
 -                    );
 +                    ctx.require_std(implicit_stmt.span, FortranStandard::F90, "IMPLICIT NONE");
+                 }
+             }
              if !contains.is_empty() {
 -                ctx.require_std(unit.span, FortranStandard::F90, "CONTAINS/internal procedures");
 +                ctx.require_std(
 +                    unit.span,
 +                    FortranStandard::F90,
 +                    "CONTAINS/internal procedures",
 +                );
+             }
              validate_decls(ctx, decls);
              check_implicit_none(ctx, body, decls);
+         }
          ProgramUnit::Submodule {
              uses,
 -            decls, contains, ..
 +            decls,
 +            contains,
 +            ..
          } => {
              ctx.require_std(unit.span, FortranStandard::F2008, "SUBMODULE");
              for use_stmt in uses {
          Stmt::Assignment { target, value } => {
              validate_assignment_target(ctx, target, stmt.span);
              reject_pure_nonlocal_definition(ctx, target, stmt.span, "assignment");
 -            if ctx.in_pure { check_pure_expr_calls(ctx, value); }
 +            if ctx.in_pure {
 +                check_pure_expr_calls(ctx, value);
 +            }
+         }
          Stmt::PointerAssignment { target, value, .. } => {
              validate_pointer_assignment(ctx, target, value, stmt.span);
+         }
          // ---- I/O in pure ----
 -        Stmt::Write { .. } | Stmt::Read { .. } | Stmt::Print { .. } |
 -        Stmt::Open { .. } | Stmt::Close { .. } | Stmt::Inquire { .. } |
 -        Stmt::Rewind { .. } | Stmt::Backspace { .. } | Stmt::Endfile { .. } |
 -        Stmt::Flush { .. } | Stmt::Wait { .. } => {
 +        Stmt::Write { .. }
 +        | Stmt::Read { .. }
 +        | Stmt::Print { .. }
 +        | Stmt::Open { .. }
 +        | Stmt::Close { .. }
 +        | Stmt::Inquire { .. }
 +        | Stmt::Rewind { .. }
 +        | Stmt::Backspace { .. }
 +        | Stmt::Endfile { .. }
 +        | Stmt::Flush { .. }
 +        | Stmt::Wait { .. } => {
              if ctx.in_pure {
                  ctx.error(stmt.span, "I/O statement not allowed in pure procedure");
+             }
+         }
          // ---- Control flow — recurse into bodies ----
 -        Stmt::IfConstruct { then_body, else_ifs, else_body, .. } => {
 +        Stmt::IfConstruct {
 +            then_body,
 +            else_ifs,
 +            else_body,
 +            ..
 +        } => {
              validate_stmts(ctx, then_body);
              for (_, body) in else_ifs {
                  validate_stmts(ctx, body);
              ctx.require_std(stmt.span, FortranStandard::F95, "FORALL statement");
              validate_stmt(ctx, inner);
+         }
 -        Stmt::Block { uses, ifaces, implicit, decls, body, .. } => {
 +        Stmt::Block {
 +            uses,
 +            ifaces,
 +            implicit,
 +            decls,
 +            body,
 +            ..
 +        } => {
              ctx.require_std(stmt.span, FortranStandard::F2008, "BLOCK construct");
              validate_decls(ctx, uses);
              validate_decls(ctx, implicit);
                  if let Some(ref name) = extract_base_name(item) {
                      let is_pointer = ctx.lookup(name).map(|s| s.attrs.pointer).unwrap_or(true);
                      if !is_pointer {
 -                        ctx.error(item.span, format!(
 -                            "NULLIFY target '{}' must have pointer attribute", name
 -                        ));
 +                        ctx.error(
 +                            item.span,
 +                            format!("NULLIFY target '{}' must have pointer attribute", name),
 +                        );
+                     }
+                 }
+             }
  /// variable's intent/parameter status applies to all parts.
  fn validate_assignment_target(ctx: &mut Ctx, target: &crate::ast::expr::SpannedExpr, span: Span) {
      if let Some(name) = extract_base_name(target) {
 -        let (is_intent_in, is_parameter, is_pointer) = ctx.lookup(&name)
 -            .map(|sym| (
 -                matches!(sym.attrs.intent, Some(Intent::In)),
 -                sym.attrs.parameter,
 -                sym.attrs.pointer,
 -            ))
 +        let (is_intent_in, is_parameter, is_pointer) = ctx
 +            .lookup(&name)
 +            .map(|sym| {
 +                (
 +                    matches!(sym.attrs.intent, Some(Intent::In)),
 +                    sym.attrs.parameter,
 +                    sym.attrs.pointer,
 +                )
 +            })
              .unwrap_or((false, false, false));
 -        let writes_through_pointer_target =
 -            is_pointer && !matches!(target.node, Expr::Name { .. });
 +        let writes_through_pointer_target = is_pointer && !matches!(target.node, Expr::Name { .. });
          if is_intent_in && !writes_through_pointer_target {
 -            ctx.error(span, format!("cannot assign to intent(in) variable '{}'", name));
 +            ctx.error(
 +                span,
 +                format!("cannot assign to intent(in) variable '{}'", name),
 +            );
+         }
          if is_parameter {
              ctx.error(span, format!("cannot assign to named constant '{}'", name));
      if expr_selects_component(target) {
          if let Some(leaf) = leaf_field_layout(ctx, target) {
              if !leaf.field.pointer {
 -                ctx.error(span, format!(
 -                    "pointer assignment target component '{}' must have pointer attribute",
 -                    leaf.field.name
 -                ));
 +                ctx.error(
 +                    span,
 +                    format!(
 +                        "pointer assignment target component '{}' must have pointer attribute",
 +                        leaf.field.name
 +                    ),
 +                );
+             }
+         }
      } else if let Some(name) = extract_base_name(target) {
          let is_pointer = ctx.lookup(&name).map(|s| s.attrs.pointer).unwrap_or(true);
          if !is_pointer {
 -            ctx.error(span, format!("pointer assignment target '{}' must have pointer attribute", name));
 +            ctx.error(
 +                span,
 +                format!(
 +                    "pointer assignment target '{}' must have pointer attribute",
 +                    name
 +                ),
 +            );
+         }
+     }
                  return;
+             }
+         }
 -        let ok = ctx.lookup(&name).map(|s| s.attrs.target || s.attrs.pointer).unwrap_or(true);
 +        let ok = ctx
 +            .lookup(&name)
 +            .map(|s| s.attrs.target || s.attrs.pointer)
 +            .unwrap_or(true);
          if !ok {
 -            ctx.error(span, format!("pointer assignment source '{}' must have target or pointer attribute", name));
 +            ctx.error(
 +                span,
 +                format!(
 +                    "pointer assignment source '{}' must have target or pointer attribute",
 +                    name
 +                ),
 +            );
+         }
+     }
+ }
      if expr_selects_component(item) {
          if let Some(leaf) = leaf_field_layout(ctx, item) {
              if !leaf.field.allocatable && !leaf.field.pointer {
 -                ctx.error(item.span, format!(
 +                ctx.error(
 +                    item.span,
 +                    format!(
                      "only allocatable or pointer components can appear in {}, but '{}' is neither",
                      stmt_name.to_uppercase(), leaf.field.name
 -                ));
 +                ),
 +                );
+             }
+         }
          return;
+     }
      let base_name = extract_base_name(item);
      if let Some(ref name) = base_name {
 -        let ok = ctx.lookup(name)
 +        let ok = ctx
 +            .lookup(name)
              .map(|s| s.attrs.allocatable || s.attrs.pointer)
              .unwrap_or(true); // unknown symbol — skip
          if !ok {
 -            ctx.error(item.span, format!(
 -                "only allocatable or pointer variables can appear in {}, but '{}' is neither",
 -                stmt_name.to_uppercase(), name
 -            ));
 +            ctx.error(
 +                item.span,
 +                format!(
 +                    "only allocatable or pointer variables can appear in {}, but '{}' is neither",
 +                    stmt_name.to_uppercase(),
 +                    name
 +                ),
 +            );
+         }
+     }
+ }
+         }
      };
      chain.reverse();
 -    if chain.is_empty() { return None; }
 +    if chain.is_empty() {
 +        return None;
 +    }
      // Resolve the base variable's derived type via the symbol table.
      let sym = ctx.lookup(base_name)?;
      let base_type = match sym.type_info.as_ref()? {
          // so the leaf check can honour inherited target-ness.
          let is_terminal = i + 1 == chain.len();
          if !is_terminal {
 -            if field.target { ancestor_is_target = true; }
 -            if field.allocatable { ancestor_is_allocatable = true; }
 +            if field.target {
 +                ancestor_is_target = true;
 +            }
 +            if field.allocatable {
 +                ancestor_is_allocatable = true;
 +            }
+         }
          leaf = Some(field);
          match &field.type_info {
      // symbol that is NOT marked pure/elemental/intrinsic, reject.
      // Unknown callees (external without an interface) are left
      // alone — the programmer's responsibility per F2018 §15.4.
 -    let Some(name) = extract_base_name(callee) else { return; };
 -    let Some(sym) = ctx.lookup(&name) else { return; };
 +    let Some(name) = extract_base_name(callee) else {
 +        return;
 +    };
 +    let Some(sym) = ctx.lookup(&name) else {
 +        return;
 +    };
      match sym.kind {
          SymbolKind::Function | SymbolKind::Subroutine => {
              if !sym.attrs.pure && !sym.attrs.elemental && !sym.attrs.intrinsic {
+             }
+         }
          SymbolKind::IntrinsicProc => {} // always OK
 -        _ => {} // external / unknown — can't check
 +        _ => {}                         // external / unknown — can't check
+     }
+ }
      if !ctx.in_pure {
          return;
+     }
 -    let Some(name) = extract_base_name(target) else { return; };
 -    let Some(sym) = ctx.lookup(&name) else { return; };
 +    let Some(name) = extract_base_name(target) else {
 +        return;
 +    };
 +    let Some(sym) = ctx.lookup(&name) else {
 +        return;
 +    };
      // Only variables and COMMON blocks can be "defined"; function
      // names get definition semantics too but those are the pure
      // function's own result variable (always local).
 -    if !matches!(sym.kind, SymbolKind::Variable | SymbolKind::Parameter | SymbolKind::CommonBlock) {
 +    if !matches!(
 +        sym.kind,
 +        SymbolKind::Variable | SymbolKind::Parameter | SymbolKind::CommonBlock
 +    ) {
          return;
+     }
      if symbol_is_non_local_to_procedure(ctx.st, sym, ctx.scope_id) {
      span: Span,
  ) {
      // Look up the callee to find its dummy argument intents.
 -    let callee_name = if let Expr::Name { name } = &callee.node { name.clone() } else { return; };
 +    let callee_name = if let Expr::Name { name } = &callee.node {
 +        name.clone()
 +    } else {
 +        return;
 +    };
      // For each actual argument, check if it's an lvalue when the dummy requires out/inout.
      // We can only check this if the callee's dummy arg info is in the symbol table.
              _ => continue,
          };
          // Check if actual is a literal (not an lvalue).
 -        let is_literal = matches!(actual.node,
 -            Expr::IntegerLiteral { .. } | Expr::RealLiteral { .. } |
 -            Expr::StringLiteral { .. } | Expr::LogicalLiteral { .. } |
 -            Expr::ComplexLiteral { .. }
 +        let is_literal = matches!(
 +            actual.node,
 +            Expr::IntegerLiteral { .. }
 +                | Expr::RealLiteral { .. }
 +                | Expr::StringLiteral { .. }
 +                | Expr::LogicalLiteral { .. }
 +                | Expr::ComplexLiteral { .. }
          );
          // Check if actual is a named constant (parameter).
          let is_parameter = if let Some(name) = extract_base_name(actual) {
 -            ctx.lookup(&name).map(|s| s.attrs.parameter).unwrap_or(false)
 -        } else { false };
 +            ctx.lookup(&name)
 +                .map(|s| s.attrs.parameter)
 +                .unwrap_or(false)
 +        } else {
 +            false
 +        };
          if is_literal || is_parameter {
              // We can't tell without the callee's interface whether this arg is
      for arg in args {
          if let DummyArg::Name(arg_name) = arg {
              for decl in decls {
 -                if let Decl::TypeDecl { attrs, entities, .. } = &decl.node {
 +                if let Decl::TypeDecl {
 +                    attrs, entities, ..
 +                } = &decl.node
 +                {
                      for entity in entities {
                          if entity.name.eq_ignore_ascii_case(arg_name) {
                              // Check for dimension attribute or explicit array spec on entity.
 -                            let has_dimension = attrs.iter().any(|a| matches!(a, Attribute::Dimension(_)));
 +                            let has_dimension =
 +                                attrs.iter().any(|a| matches!(a, Attribute::Dimension(_)));
                              let has_entity_dims = entity.array_spec.is_some();
                              if has_dimension || has_entity_dims {
 -                                ctx.error(span, format!(
 -                                    "elemental procedure argument '{}' must be scalar",
 -                                    arg_name
 -                                ));
 +                                ctx.error(
 +                                    span,
 +                                    format!(
 +                                        "elemental procedure argument '{}' must be scalar",
 +                                        arg_name
 +                                    ),
 +                                );
+                             }
+                         }
+                     }
  /// At the end of a scope, verify all GOTO labels have targets.
  fn validate_label_consistency(ctx: &mut Ctx, _scope_span: Span) {
      // Collect errors first to avoid borrow conflict.
 -    let errors: Vec<(Span, String)> = ctx.labels_referenced.iter()
 +    let errors: Vec<(Span, String)> = ctx
 +        .labels_referenced
 +        .iter()
          .filter(|(label, _)| !ctx.labels_defined.contains(label))
 -        .map(|(label, span)| (*span, format!("GOTO target label {} not defined in this scope", label)))
 +        .map(|(label, span)| {
 +            (
 +                *span,
 +                format!("GOTO target label {} not defined in this scope", label),
 +            )
 +        })
          .collect();
      for (span, msg) in errors {
          ctx.error(span, msg);
                  match &sub.node {
                      ProgramUnit::Function { args, .. } => {
                          if is_assignment {
 -                            ctx.error(sub.span, format!(
 +                            ctx.error(
 +                                sub.span,
 +                                format!(
                                  "ASSIGNMENT({}) interface must contain subroutines, not functions",
                                  "="
 -                            ));
 +                            ),
 +                            );
                              continue;
+                         }
                          // Operator functions: unary = 1 arg, binary = 2 args.
                          let nargs = args.len();
                          if !(1..=2).contains(&nargs) {
 -                            ctx.error(sub.span, format!(
 +                            ctx.error(
 +                                sub.span,
 +                                format!(
                                  "operator interface function must have 1 or 2 arguments, got {}",
                                  nargs
 -                            ));
 +                            ),
 +                            );
+                         }
                          // All arguments must be intent(in) — checked by looking at decls.
                          // Deferred: would need to walk the function's decls to check intent.
+                     }
                      ProgramUnit::Subroutine { args, .. } => {
                          if !is_assignment {
 -                            ctx.error(sub.span, "operator interface must contain functions, not subroutines");
 +                            ctx.error(
 +                                sub.span,
 +                                "operator interface must contain functions, not subroutines",
 +                            );
                              continue;
+                         }
                          // Assignment subroutines must have exactly 2 arguments.
                          if args.len() != 2 {
 -                            ctx.error(sub.span, format!(
 +                            ctx.error(
 +                                sub.span,
 +                                format!(
                                  "ASSIGNMENT(=) interface subroutine must have 2 arguments, got {}",
                                  args.len()
 -                            ));
 +                            ),
 +                            );
+                         }
+                     }
                      _ => {
          // Deferred procedures only allowed in abstract types.
          let is_deferred = tbp.attrs.iter().any(|a| a.eq_ignore_ascii_case("deferred"));
          if is_deferred && !is_abstract {
 -            ctx.error(span, format!(
 -                "type-bound procedure '{}' is DEFERRED but type '{}' is not ABSTRACT",
 -                tbp.name, name
 -            ));
 +            ctx.error(
 +                span,
 +                format!(
 +                    "type-bound procedure '{}' is DEFERRED but type '{}' is not ABSTRACT",
 +                    tbp.name, name
 +                ),
 +            );
+         }
          // PASS and NOPASS are mutually exclusive.
          });
          let has_nopass = tbp.attrs.iter().any(|a| a.eq_ignore_ascii_case("nopass"));
          if has_pass && has_nopass {
 -            ctx.error(span, format!(
 -                "type-bound procedure '{}' cannot have both PASS and NOPASS",
 -                tbp.name
 -            ));
 +            ctx.error(
 +                span,
 +                format!(
 +                    "type-bound procedure '{}' cannot have both PASS and NOPASS",
 +                    tbp.name
 +                ),
 +            );
+         }
          // Deferred procedures must have an interface (binding).
          if is_deferred && tbp.binding.is_none() {
 -            ctx.error(span, format!(
 -                "DEFERRED type-bound procedure '{}' must specify an interface",
 -                tbp.name
 -            ));
 +            ctx.error(
 +                span,
 +                format!(
 +                    "DEFERRED type-bound procedure '{}' must specify an interface",
 +                    tbp.name
 +                ),
 +            );
+         }
+     }
+ }
  /// Check that all variable references in a statement list are declared
  /// when IMPLICIT NONE is active in the current scope.
 -fn check_implicit_none(ctx: &mut Ctx, stmts: &[SpannedStmt], decls: &[crate::ast::decl::SpannedDecl]) {
 -    if !ctx.st.is_implicit_none(ctx.scope_id) { return; }
 +fn check_implicit_none(
 +    ctx: &mut Ctx,
 +    stmts: &[SpannedStmt],
 +    decls: &[crate::ast::decl::SpannedDecl],
 +) {
 +    if !ctx.st.is_implicit_none(ctx.scope_id) {
 +        return;
 +    }
      // Collect declared names in this scope (from declarations).
      let mut declared: std::collections::HashSet<String> = std::collections::HashSet::new();
      // should have them via resolve. We also check decls for
      // EXTERNAL statements.
      for decl in decls {
 -        if let Decl::TypeDecl { attrs, entities, .. } = &decl.node {
 +        if let Decl::TypeDecl {
 +            attrs, entities, ..
 +        } = &decl.node
 +        {
              if attrs.iter().any(|a| matches!(a, Attribute::External)) {
                  for e in entities {
                      declared.insert(e.name.to_lowercase());
      let mut undeclared = Vec::new();
      let mut resolution_cache: std::collections::HashMap<String, bool> =
          std::collections::HashMap::new();
 -    let outer_implicit_letters: std::collections::HashSet<char> =
 -        std::collections::HashSet::new();
 +    let outer_implicit_letters: std::collections::HashSet<char> = std::collections::HashSet::new();
      for stmt in stmts {
          walk_stmt_for_undeclared(
              ctx.st,
      for (name, span) in &undeclared {
          let key = name.to_lowercase();
          if reported.insert(key) {
 -            ctx.error(*span, format!(
 -                "variable '{}' used but not declared (IMPLICIT NONE is active)", name
 -            ));
 +            ctx.error(
 +                *span,
 +                format!(
 +                    "variable '{}' used but not declared (IMPLICIT NONE is active)",
 +                    name
 +                ),
 +            );
+         }
+     }
+ }
          for body in bodies {
              match body {
                  InterfaceBody::Subprogram(sub) => match &sub.node {
 -                    ProgramUnit::Function { name, .. }
 -                    | ProgramUnit::Subroutine { name, .. } => {
 +                    ProgramUnit::Function { name, .. } | ProgramUnit::Subroutine { name, .. } => {
                          declared.insert(name.to_lowercase());
+                     }
                      _ => {}
+     }
      match &stmt.node {
          Stmt::Assignment { target, value } => {
 -            chk!(target); chk!(value);
 +            chk!(target);
 +            chk!(value);
+         }
          Stmt::PointerAssignment { target, value, .. } => {
 -            chk!(target); chk!(value);
 +            chk!(target);
 +            chk!(value);
+         }
          Stmt::Print { items, .. } => {
 -            for item in items { chk!(item); }
 +            for item in items {
 +                chk!(item);
 +            }
+         }
 -        Stmt::Write { items, controls, .. } => {
 -            for item in items { chk!(item); }
 -            for ctrl in controls { chk!(&ctrl.value); }
 +        Stmt::Write {
 +            items, controls, ..
 +        } => {
 +            for item in items {
 +                chk!(item);
 +            }
 +            for ctrl in controls {
 +                chk!(&ctrl.value);
 +            }
+         }
 -        Stmt::Read { items, controls, .. } => {
 -            for item in items { chk!(item); }
 -            for ctrl in controls { chk!(&ctrl.value); }
 +        Stmt::Read {
 +            items, controls, ..
 +        } => {
 +            for item in items {
 +                chk!(item);
 +            }
 +            for ctrl in controls {
 +                chk!(&ctrl.value);
 +            }
+         }
 -        Stmt::IfConstruct { condition, then_body, else_ifs, else_body, .. } => {
 +        Stmt::IfConstruct {
 +            condition,
 +            then_body,
 +            else_ifs,
 +            else_body,
 +            ..
 +        } => {
              chk!(condition);
 -            for s in then_body { recurse!(s); }
 +            for s in then_body {
 +                recurse!(s);
 +            }
              for (cond, body) in else_ifs {
                  chk!(cond);
 -                for s in body { recurse!(s); }
 +                for s in body {
 +                    recurse!(s);
 +                }
+             }
              if let Some(body) = else_body {
 -                for s in body { recurse!(s); }
 +                for s in body {
 +                    recurse!(s);
 +                }
+             }
+         }
          Stmt::IfStmt { condition, action } => {
 -            chk!(condition); recurse!(action);
 +            chk!(condition);
 +            recurse!(action);
+         }
 -        Stmt::DoLoop { body, .. } | Stmt::DoWhile { body, .. } |
 -        Stmt::DoConcurrent { body, .. } => {
 -            for s in body { recurse!(s); }
 +        Stmt::DoLoop { body, .. }
 +        | Stmt::DoWhile { body, .. }
 +        | Stmt::DoConcurrent { body, .. } => {
 +            for s in body {
 +                recurse!(s);
 +            }
+         }
 -        Stmt::Block { uses, ifaces, implicit, decls, body, .. } => {
 +        Stmt::Block {
 +            uses,
 +            ifaces,
 +            implicit,
 +            decls,
 +            body,
 +            ..
 +        } => {
              // F2018 §11.1.4: a BLOCK construct establishes its own
              // scope with an independent implicit-typing environment.
              // Layer the block's declared names AND any IMPLICIT
                  );
+             }
+         }
 -        Stmt::SelectCase { selector, cases, .. } => {
 +        Stmt::SelectCase {
 +            selector, cases, ..
 +        } => {
              chk!(selector);
              for case in cases {
 -                for s in &case.body { recurse!(s); }
 +                for s in &case.body {
 +                    recurse!(s);
 +                }
+             }
+         }
          Stmt::Call { args, .. } => {
+                 }
+             }
+         }
 -        Stmt::Labeled { stmt: inner, .. } => { recurse!(inner); }
 -        Stmt::WhereConstruct { mask, body, elsewhere, .. } => {
 +        Stmt::Labeled { stmt: inner, .. } => {
 +            recurse!(inner);
 +        }
 +        Stmt::WhereConstruct {
 +            mask,
 +            body,
 +            elsewhere,
 +            ..
 +        } => {
              chk!(mask);
 -            for s in body { recurse!(s); }
 +            for s in body {
 +                recurse!(s);
 +            }
              for (m, b) in elsewhere {
 -                if let Some(m) = m { chk!(m); }
 -                for s in b { recurse!(s); }
 +                if let Some(m) = m {
 +                    chk!(m);
 +                }
 +                for s in b {
 +                    recurse!(s);
 +                }
+             }
+         }
          _ => {}
      let mut imported = std::collections::HashSet::new();
      for use_decl in uses {
 -        let crate::ast::decl::Decl::UseStmt { module, renames, only, .. } = &use_decl.node else {
 +        let crate::ast::decl::Decl::UseStmt {
 +            module,
 +            renames,
 +            only,
 +            ..
 +        } = &use_decl.node
 +        else {
              continue;
          };
          if let Some(only_items) = only {
          Expr::Name { name } => {
              let key = name.to_lowercase();
              // Skip format specifier * (appears in WRITE(*, *) / READ(*, *)).
 -            if key == "*" { return; }
 -            if declared.contains(&key) { return; }
 -            if is_intrinsic_name(&key) { return; }
 +            if key == "*" {
 +                return;
 +            }
 +            if declared.contains(&key) {
 +                return;
 +            }
 +            if is_intrinsic_name(&key) {
 +                return;
 +            }
              // F2018 §11.1.4: a BLOCK-scoped IMPLICIT statement gives
              // names whose first letter is in the covered range an
              // implicit type, even if the enclosing scope is
+ }
  pub fn is_intrinsic_name(name: &str) -> bool {
 -    matches!(name,
 +    matches!(
 +        name,
          "abs" | "iabs" | "dabs" | "cabs" | "acos" | "asin" | "atan" | "atan2" |
          "cos" | "sin" | "tan" | "exp" | "log" | "log10" | "sqrt" | "dsqrt" |
          "mod" | "modulo" | "max" | "min" | "sign" | "dim" |
          let tokens = Lexer::tokenize(src, 0).unwrap();
          let mut parser = Parser::new(&tokens);
          let units = parser.parse_file().unwrap();
 -        let rr = resolve::resolve_file(&units, &[]).unwrap(); let st = rr.st;
 +        let rr = resolve::resolve_file(&units, &[]).unwrap();
 +        let st = rr.st;
          validate_file(&units, &st)
+     }
      fn errors_from(src: &str) -> Vec<String> {
 -        validate_source(src).iter()
 +        validate_source(src)
 +            .iter()
              .filter(|d| d.kind == DiagKind::Error)
              .map(|d| d.msg.clone())
              .collect()
          let tokens = Lexer::tokenize(src, 0).unwrap();
          let mut parser = Parser::new(&tokens);
          let units = parser.parse_file().unwrap();
 -        let rr = resolve::resolve_file(&units, &[]).unwrap(); let st = rr.st;
 +        let rr = resolve::resolve_file(&units, &[]).unwrap();
 +        let st = rr.st;
          validate_file_with_std(&units, &st, Some(std))
              .iter()
              .filter(|d| d.kind == DiagKind::Error)
      #[test]
      fn assign_to_intent_in_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  subroutine foo(x)
    real, intent(in) :: x
    x = 1.0
  end subroutine
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("intent(in)")));
+     }
      #[test]
      fn assign_to_intent_inout_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  subroutine foo(x)
    real, intent(inout) :: x
    x = 1.0
  end subroutine
 -");
 +",
 +        );
          assert!(errs.is_empty());
+     }
      #[test]
      fn assign_through_intent_in_pointer_target_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    type :: t
      integer :: x
      p%x = 1
    end subroutine
  end module
 -");
 +",
 +        );
          assert!(!errs.iter().any(|e| e.contains("intent(in)")), "{:?}", errs);
+     }
      #[test]
      fn assign_to_parameter_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    integer, parameter :: n = 10
    n = 20
  end program
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("named constant")));
+     }
      #[test]
      fn allocate_non_allocatable_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    real :: x(10)
    allocate(x(20))
  end program
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("allocatable or pointer")));
+     }
      #[test]
      fn allocate_allocatable_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    real, allocatable :: x(:)
    allocate(x(10))
  end program
 -");
 +",
 +        );
          assert!(errs.is_empty());
+     }
      #[test]
      fn allocatable_and_pointer_forbidden() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    real, allocatable, pointer :: x
  end program
 -");
 -        assert!(errs.iter().any(|e| e.contains("both allocatable and pointer")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("both allocatable and pointer")));
+     }
      #[test]
      fn parameter_allocatable_forbidden() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    integer, parameter, allocatable :: x = 10
  end program
 -");
 -        assert!(errs.iter().any(|e| e.contains("parameter") && e.contains("allocatable")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("parameter") && e.contains("allocatable")));
+     }
      // ---- Pointer assignment ----
      #[test]
      fn pointer_assignment_non_pointer_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    real :: x
    real, target :: y
    x => y
  end program
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("pointer attribute")));
+     }
      #[test]
      fn pointer_assignment_non_target_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    real, pointer :: p
    real :: x
    p => x
  end program
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("target or pointer")));
+     }
      #[test]
      fn pointer_assignment_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    real, pointer :: p
    real, target :: x
    p => x
  end program
 -");
 +",
 +        );
          assert!(errs.is_empty());
+     }
      #[test]
      fn io_in_pure_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  pure subroutine foo(x)
    real, intent(in) :: x
    print *, x
  end subroutine
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("I/O") && e.contains("pure")));
+     }
      #[test]
      fn stop_in_pure_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  pure function bar(x) result(y)
    real, intent(in) :: x
    real :: y
    y = x
    stop
  end function
 -");
 -        assert!(errs.iter().any(|e| e.contains("STOP") && e.contains("pure")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("STOP") && e.contains("pure")));
+     }
      #[test]
      fn save_in_pure_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  pure subroutine foo(x)
    real, intent(in) :: x
    real, save :: counter
  end subroutine
 -");
 -        assert!(errs.iter().any(|e| e.contains("SAVE") && e.contains("pure")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("SAVE") && e.contains("pure")));
+     }
      #[test]
      fn pure_without_violations_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  pure function square(x) result(y)
    real, intent(in) :: x
    real :: y
    y = x * x
  end function
 -");
 +",
 +        );
          assert!(errs.is_empty());
+     }
      #[test]
      fn pure_write_to_module_variable_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    integer :: counter = 0
  contains
      r = counter
    end function
  end module
 -");
 +",
 +        );
          assert!(
 -            errs.iter().any(|e| e.contains("counter") && e.contains("pure") && e.contains("host or use association")),
 +            errs.iter().any(|e| e.contains("counter")
 +                && e.contains("pure")
 +                && e.contains("host or use association")),
              "expected pure+module-write error, got {:?}",
              errs,
          );
          // F2018 15.7 permits a pure procedure to *reference* a
          // variable accessed by use association; only definition
          // is forbidden.  reads_counter is a legal pure function.
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    integer :: counter = 0
  contains
      r = counter
    end function
  end module
 -");
 -        assert!(errs.is_empty(), "pure read of module variable should be legal, got {:?}", errs);
 +",
 +        );
 +        assert!(
 +            errs.is_empty(),
 +            "pure read of module variable should be legal, got {:?}",
 +            errs
 +        );
+     }
      #[test]
      fn pure_write_to_host_variable_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program p
    integer :: host_var
    host_var = 0
      host_var = 42
    end subroutine
  end program
 -");
 +",
 +        );
          assert!(
 -            errs.iter().any(|e| e.contains("host_var") && e.contains("pure") && e.contains("host or use association")),
 +            errs.iter().any(|e| e.contains("host_var")
 +                && e.contains("pure")
 +                && e.contains("host or use association")),
              "expected pure+host-write error, got {:?}",
              errs,
          );
      #[test]
      fn pure_pointer_reassoc_of_module_pointer_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    integer, pointer :: module_p
  contains
      module_p => t
    end subroutine
  end module
 -");
 +",
 +        );
          assert!(
 -            errs.iter().any(|e| e.contains("module_p") && e.contains("pure") && e.contains("pointer assignment")),
 +            errs.iter().any(|e| e.contains("module_p")
 +                && e.contains("pure")
 +                && e.contains("pointer assignment")),
              "expected pure+module-pointer error, got {:?}",
              errs,
          );
      fn pure_local_pointer_reassoc_ok() {
          // Associating a LOCAL pointer with a module TARGET is
          // legal — `q => counter` does not modify `counter`.
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    integer, target :: counter = 0
  contains
      r = 0
    end function
  end module
 -");
 -        assert!(errs.is_empty(), "pure local pointer reassoc should be legal, got {:?}", errs);
 +",
 +        );
 +        assert!(
 +            errs.is_empty(),
 +            "pure local pointer reassoc should be legal, got {:?}",
 +            errs
 +        );
+     }
      #[test]
      fn pure_intent_out_dummy_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  pure subroutine zero_it(x)
    integer, intent(out) :: x
    x = 0
  end subroutine
 -");
 -        assert!(errs.is_empty(), "pure write to intent(out) dummy should be legal, got {:?}", errs);
 +",
 +        );
 +        assert!(
 +            errs.is_empty(),
 +            "pure write to intent(out) dummy should be legal, got {:?}",
 +            errs
 +        );
+     }
      // ---- Deferred length character ----
      #[test]
      fn deferred_len_without_allocatable_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    character(len=:) :: s
  end program
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("deferred-length")));
+     }
      #[test]
      fn deferred_len_with_allocatable_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    character(len=:), allocatable :: s
  end program
 -");
 +",
 +        );
          assert!(errs.is_empty());
+     }
      #[test]
      fn duplicate_label_detected() {
 -        use crate::lexer::{Span, Position};
 +        use crate::lexer::{Position, Span};
          let st = SymbolTable::new();
          let mut ctx = Ctx::new(&st, None, false, false);
 -        let span = Span { file_id: 0, start: Position { line: 1, col: 1 }, end: Position { line: 1, col: 1 } };
 +        let span = Span {
 +            file_id: 0,
 +            start: Position { line: 1, col: 1 },
 +            end: Position { line: 1, col: 1 },
 +        };
          register_label(&mut ctx, 10, span);
          register_label(&mut ctx, 10, span); // duplicate
      #[test]
      fn clean_program_no_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    integer :: i, n
      x = real(i) * 2.0
    end do
  end program
 -");
 +",
 +        );
          assert!(errs.is_empty(), "unexpected errors: {:?}", errs);
+     }
      #[test]
      fn module_with_subroutine_no_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module mymod
    implicit none
    integer :: shared
      shared = val
    end subroutine
  end module
 -");
 +",
 +        );
          assert!(errs.is_empty(), "unexpected errors: {:?}", errs);
+     }
      #[test]
      fn module_parameter_visible_in_contained_subroutine() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    use iso_c_binding, only: c_int
    implicit none
      print *, color_red
    end subroutine
  end module
 -");
 +",
 +        );
          assert!(errs.is_empty(), "unexpected errors: {:?}", errs);
+     }
      #[test]
      fn operator_interface_subroutine_errors() {
          // Parse a top-level interface block with operator name.
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  interface operator(+)
    subroutine bad_add(a, b)
      integer, intent(in) :: a, b
    end subroutine
  end interface
 -");
 -        assert!(errs.iter().any(|e| e.contains("functions, not subroutines")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("functions, not subroutines")));
+     }
      #[test]
      fn operator_interface_wrong_arg_count() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  interface operator(+)
    function add3(a, b, c) result(r)
      integer, intent(in) :: a, b, c
      integer :: r
    end function
  end interface
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("1 or 2 arguments")));
+     }
      #[test]
      fn operator_interface_valid_binary() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  interface operator(+)
    function add_vec(a, b) result(c)
      integer, intent(in) :: a, b
      integer :: c
    end function
  end interface
 -");
 +",
 +        );
          assert!(errs.is_empty(), "unexpected errors: {:?}", errs);
+     }
      #[test]
      fn assignment_interface_function_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  interface assignment(=)
    function bad_assign(a, b) result(c)
      integer, intent(in) :: a, b
      integer :: c
    end function
  end interface
 -");
 -        assert!(errs.iter().any(|e| e.contains("subroutines, not functions")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("subroutines, not functions")));
+     }
      #[test]
      fn assignment_interface_wrong_arg_count() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  interface assignment(=)
    subroutine bad_assign(a, b, c)
      integer, intent(inout) :: a
      integer, intent(in) :: b, c
    end subroutine
  end interface
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("2 arguments")));
+     }
      #[test]
      fn deferred_in_non_abstract_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    implicit none
    type :: shape
      procedure, deferred :: area
    end type
  end module
 -");
 -        assert!(errs.iter().any(|e| e.contains("DEFERRED") && e.contains("not ABSTRACT")));
 +",
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("DEFERRED") && e.contains("not ABSTRACT")));
+     }
      #[test]
      fn deferred_in_abstract_ok() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    implicit none
    type, abstract :: shape
      procedure, deferred :: area
    end type
  end module
 -");
 +",
 +        );
          // No error for deferred in abstract type (the "must specify interface"
          // error is expected since our parser stores binding as None for simple
          // deferred procedures — that's a parser representation issue).
      #[test]
      fn pass_and_nopass_together_errors() {
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  module m
    implicit none
    type :: thing
      procedure, pass, nopass :: method
    end type
  end module
 -");
 +",
 +        );
          assert!(errs.iter().any(|e| e.contains("both PASS and NOPASS")));
+     }
      #[test]
      fn do_concurrent_requires_f2008() {
 -        let errs = errors_with_std("\
 +        let errs = errors_with_std(
 +            "\
  program test
    implicit none
    integer :: i
    do concurrent (i = 1:10)
    end do
  end program
 -", FortranStandard::F95);
 -        assert!(errs.iter().any(|e| e.contains("DO CONCURRENT") && e.contains("F2008")));
 +",
 +            FortranStandard::F95,
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("DO CONCURRENT") && e.contains("F2008")));
+     }
      #[test]
      fn do_concurrent_ok_with_f2008() {
 -        let errs = errors_with_std("\
 +        let errs = errors_with_std(
 +            "\
  program test
    implicit none
    integer :: i
    do concurrent (i = 1:10)
    end do
  end program
 -", FortranStandard::F2008);
 +",
 +            FortranStandard::F2008,
 +        );
          assert!(!errs.iter().any(|e| e.contains("DO CONCURRENT")));
+     }
      #[test]
      fn error_stop_requires_f2008() {
 -        let errs = errors_with_std("\
 +        let errs = errors_with_std(
 +            "\
  program test
    implicit none
    error stop
  end program
 -", FortranStandard::F95);
 -        assert!(errs.iter().any(|e| e.contains("ERROR STOP") && e.contains("F2008")));
 +",
 +            FortranStandard::F95,
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("ERROR STOP") && e.contains("F2008")));
+     }
      #[test]
      fn block_construct_requires_f2008() {
 -        let errs = errors_with_std("\
 +        let errs = errors_with_std(
 +            "\
  program test
    implicit none
    block
      x = 1
    end block
  end program
 -", FortranStandard::F95);
 -        assert!(errs.iter().any(|e| e.contains("BLOCK") && e.contains("F2008")));
 +",
 +            FortranStandard::F95,
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("BLOCK") && e.contains("F2008")));
+     }
      #[test]
      fn associate_requires_f2003() {
 -        let errs = errors_with_std("\
 +        let errs = errors_with_std(
 +            "\
  program test
    implicit none
    integer :: n
    associate (m => n)
    end associate
  end program
 -", FortranStandard::F95);
 -        assert!(errs.iter().any(|e| e.contains("ASSOCIATE") && e.contains("F2003")));
 +",
 +            FortranStandard::F95,
 +        );
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("ASSOCIATE") && e.contains("F2003")));
+     }
      #[test]
      fn no_std_violations_when_unset() {
          // With no --std= set, everything is allowed.
 -        let errs = errors_from("\
 +        let errs = errors_from(
 +            "\
  program test
    implicit none
    integer :: i
  ",
              FortranStandard::F95,
          );
 -        assert!(errs.iter().any(|e| e.contains("IMPURE") && e.contains("F2008")));
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("IMPURE") && e.contains("F2008")));
+     }
      #[test]
              },
              span,
          );
 -        let diags = validate_file_with_std(&[unit], &SymbolTable::new(), Some(FortranStandard::F95));
 +        let diags =
 +            validate_file_with_std(&[unit], &SymbolTable::new(), Some(FortranStandard::F95));
          let errs: Vec<_> = diags
              .into_iter()
              .filter(|d| d.kind == DiagKind::Error)
              .map(|d| d.msg)
              .collect();
 -        assert!(errs.iter().any(|e| e.contains("SUBMODULE") && e.contains("F2008")));
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("SUBMODULE") && e.contains("F2008")));
+     }
      #[test]
  ",
              FortranStandard::F95,
          );
 -        assert!(errs.iter().any(|e| e.contains("MOVE_ALLOC") && e.contains("F2003")));
 +        assert!(errs
 +            .iter()
 +            .any(|e| e.contains("MOVE_ALLOC") && e.contains("F2003")));
+     }
      // ---- Elemental ----

src/testing.rsmodified

103 lines changed — click to load

  use std::time::SystemTime;
  use crate::codegen::mir::{
 -    ArmCond, ConstPoolEntry, MachineFunction, MachineInst, MachineOperand, MBlockId, PhysReg,
 +    ArmCond, ConstPoolEntry, MBlockId, MachineFunction, MachineInst, MachineOperand, PhysReg,
      RegClass,
  };
  use crate::codegen::{emit, isel, linearscan};
  use crate::driver::OptLevel;
 -use crate::opt::{build_i128_pipeline, build_pipeline};
 -use crate::opt::pipeline::OptLevel as IrOptLevel;
  use crate::ir::{lower, printer as ir_printer, verify};
  use crate::lexer::{detect_source_form, tokenize, SourceForm, Token};
 +use crate::opt::pipeline::OptLevel as IrOptLevel;
 +use crate::opt::{build_i128_pipeline, build_pipeline};
  use crate::parser::Parser;
  use crate::sema::{resolve, validate};
      let mut stages = BTreeMap::new();
      let wants = |stage| request.requested.contains(&stage);
      let needs_backend = request.requested.iter().any(|stage| {
 -        matches!(stage, Stage::Mir | Stage::Regalloc | Stage::Asm | Stage::Obj | Stage::Run)
 +        matches!(
 +            stage,
 +            Stage::Mir | Stage::Regalloc | Stage::Asm | Stage::Obj | Stage::Run
 +        )
      });
      let input = request.input.clone();
      let source_form = detect_source_form(&input.to_string_lossy());
          });
+     }
 -    let (ir_module, _module_globals) = lower::lower_file(&units, &st, &type_layouts, std::collections::HashMap::new(), std::collections::HashMap::new());
 +    let (ir_module, _module_globals) = lower::lower_file(
 +        &units,
 +        &st,
 +        &type_layouts,
 +        std::collections::HashMap::new(),
 +        std::collections::HashMap::new(),
 +    );
      let ir_errors = verify::verify_module(&ir_module);
      if !ir_errors.is_empty() {
          let msg = ir_errors
          stages.insert(Stage::Ir, CapturedStage::Text(ir_text.clone()));
+     }
      let module_has_i128 = ir_module.contains_i128();
 -    let needs_optimized_pipeline =
 -        request.requested.iter().any(|stage| {
 -            matches!(
 -                stage,
 -                Stage::OptIr | Stage::Mir | Stage::Regalloc | Stage::Asm | Stage::Obj | Stage::Run
 -            )
 -        })
 -        && request.opt_level != OptLevel::O0;
 +    let needs_optimized_pipeline = request.requested.iter().any(|stage| {
 +        matches!(
 +            stage,
 +            Stage::OptIr | Stage::Mir | Stage::Regalloc | Stage::Asm | Stage::Obj | Stage::Run
 +        )
 +    }) && request.opt_level != OptLevel::O0;
      let optimized_module = if needs_optimized_pipeline {
          let mut optimized = ir_module.clone();
              input: input.clone(),
              opt_level: request.opt_level,
              stage: FailureStage::Ir,
 -            detail: "backend does not yet support integer(16) / i128 codegen; capture IR at O0 for now".into(),
 +            detail:
 +                "backend does not yet support integer(16) / i128 codegen; capture IR at O0 for now"
 +                    .into(),
              stages,
          });
+     }
              collect_sandbox_files(root, &path, out)?;
          } else {
              let rel = path.strip_prefix(root).unwrap();
 -            out.insert(
 -                rel.to_string_lossy().replace('\\', "/"),
 -                fs::read(&path)?,
 -            );
 +            out.insert(rel.to_string_lossy().replace('\\', "/"), fs::read(&path)?);
+         }
+     }
      Ok(())
          return Ok(());
      };
      let debug_archive = workspace_root.join("target/debug/libarmfortas_rt.a");
 -    let archive_mtime = fs::metadata(&debug_archive).ok().and_then(|meta| meta.modified().ok());
 +    let archive_mtime = fs::metadata(&debug_archive)
 +        .ok()
 +        .and_then(|meta| meta.modified().ok());
      if archive_mtime.is_some_and(|mtime| mtime >= source_mtime) {
          return Ok(());
      for base in bases {
          for ancestor in base.ancestors() {
 -            if ancestor.join("Cargo.toml").exists() && ancestor.join("runtime/Cargo.toml").exists() {
 +            if ancestor.join("Cargo.toml").exists() && ancestor.join("runtime/Cargo.toml").exists()
 +            {
                  return Some(ancestor.to_path_buf());
+             }
+         }

tests/artifact_audit_29_10.rsmodified

24 lines changed — click to load

  fn object_snapshot_is_deterministic_with_module_globals_across_opt_levels() {
      let source = fixture("module_init.f90");
 -    for opt in [OptLevel::O0, OptLevel::O1, OptLevel::O2, OptLevel::O3, OptLevel::Os, OptLevel::Ofast] {
 +    for opt in [
 +        OptLevel::O0,
 +        OptLevel::O1,
 +        OptLevel::O2,
 +        OptLevel::O3,
 +        OptLevel::Os,
 +        OptLevel::Ofast,
 +    ] {
          let first = capture_text(
              CaptureRequest {
                  input: source.clone(),
              Stage::Obj,
          );
          assert_eq!(
 -            first, second,
 +            first,
 +            second,
              "object snapshot should be deterministic for module globals at {}",
              opt_name(opt)
          );

tests/claims_audit_29_11.rsmodified

30 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
          "optimized IR should remove the trivial wrapper helper:\n{}",
          opt_ir
      );
 -    assert_eq!(obj_a, obj_b, "IPO-audited O2 object snapshot should stay deterministic");
 +    assert_eq!(
 +        obj_a, obj_b,
 +        "IPO-audited O2 object snapshot should stay deterministic"
 +    );
+ }
  #[test]
          "vectorized O3 assembly should reference the bulk add kernel:\n{}",
          o3_asm
      );
 -    assert_eq!(o3_obj_a, o3_obj_b, "vectorized O3 object snapshot should stay deterministic");
 +    assert_eq!(
 +        o3_obj_a, o3_obj_b,
 +        "vectorized O3 object snapshot should stay deterministic"
 +    );
+ }

tests/determinism_sweep.rsmodified

65 lines changed — click to load

  fn find_test_programs() -> PathBuf {
      for c in &["test_programs", "../test_programs"] {
          let p = PathBuf::from(c);
 -        if p.is_dir() { return p; }
 +        if p.is_dir() {
 +            return p;
 +        }
+     }
      panic!("cannot find test_programs/ directory");
+ }
  fn unique_path(prefix: &str, ext: &str) -> PathBuf {
      let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
      std::env::temp_dir().join(format!(
 -        "afs_det_{}_{}_{}{}", prefix, std::process::id(), id, ext
 +        "afs_det_{}_{}_{}{}",
 +        prefix,
 +        std::process::id(),
 +        id,
 +        ext
      ))
+ }
  fn compile_to_asm(compiler: &Path, source: &Path, opt: &str) -> Option<Vec<u8>> {
      let out = unique_path("sweep", ".s");
      let result = Command::new(compiler)
 -        .args([source.to_str().unwrap(), opt, "-S", "-o", out.to_str().unwrap()])
 +        .args([
 +            source.to_str().unwrap(),
 +            opt,
 +            "-S",
 +            "-o",
 +            out.to_str().unwrap(),
 +        ])
          .output()
          .expect("compiler launch failed");
      if !result.status.success() {
          if first != second {
              failures.push(format!(
                  "{}: assembly differs between two -O2 compilations ({} vs {} bytes)",
 -                name, first.len(), second.len(),
 +                name,
 +                first.len(),
 +                second.len(),
              ));
          } else {
              checked += 1;
      eprintln!(
          "\nDeterminism sweep: {} checked, {} skipped, {} failures out of {} programs",
 -        checked, skipped, failures.len(), sources.len(),
 +        checked,
 +        skipped,
 +        failures.len(),
 +        sources.len(),
      );
      if !failures.is_empty() {
 -        panic!(
 -            "Determinism failures:\n{}",
 -            failures.join("\n"),
 -        );
 +        panic!("Determinism failures:\n{}", failures.join("\n"),);
+     }
      // Sanity: we should have checked a substantial portion.

tests/fortran_alias_licm.rsmodified

28 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
      for (idx, _line) in func_section.match_indices('\n') {
          let line_start = idx + 1;
          let tail = &func_section[line_start..];
 -        let line_text = tail
 -            .split_once('\n')
 -            .map(|(line, _)| line)
 -            .unwrap_or(tail);
 +        let line_text = tail.split_once('\n').map(|(line, _)| line).unwrap_or(tail);
          if start.is_none() {
 -            if line_text.starts_with("    ") && !line_text.starts_with("      ") && line_text[4..].starts_with(prefix) {
 +            if line_text.starts_with("    ")
 +                && !line_text.starts_with("      ")
 +                && line_text[4..].starts_with(prefix)
 +            {
                  start = Some(line_start);
+             }
              continue;

tests/fuzz_smoke.rsmodified

36 lines changed — click to load

  /// Runs without threads — each input goes directly through the parser.
  fn fuzz_parser_with_fortran_fragments(count: usize) {
      let fragments = [
 -        "program p\nend program\n", "module m\nend module\n",
 -        "integer :: x\n", "real, allocatable :: a(:,:)\n",
 -        "do i = 1, 10\nend do\n", "if (x > 0) then\nend if\n",
 +        "program p\nend program\n",
 +        "module m\nend module\n",
 +        "integer :: x\n",
 +        "real, allocatable :: a(:,:)\n",
 +        "do i = 1, 10\nend do\n",
 +        "if (x > 0) then\nend if\n",
          "select case (x)\ncase (1)\nend select\n",
          "type :: t\n  integer :: f\nend type\n",
          "interface\nend interface\n",
 -        "goto 100\n", "100 continue\n",
 +        "goto 100\n",
 +        "100 continue\n",
          "use iso_c_binding, only: c_int\n",
 -        "", "!\n", "! comment\n",
 +        "",
 +        "!\n",
 +        "! comment\n",
          "end\n",
          "do concurrent (i = 1:10)\nend do\n",
          "block\n  integer :: local\nend block\n",
+         }
          if let Ok(tokens) = lexer::tokenize(&src, 0, SourceForm::FreeForm) {
 -            if tokens.len() > 100 { continue; }
 +            if tokens.len() > 100 {
 +                continue;
 +            }
              let mut parser = Parser::new(&tokens);
              let _ = parser.parse_file();
+         }

tests/gvn_dse_audit_29_11.rsmodified

22 lines changed — click to load

      for (idx, _line) in func_section.match_indices('\n') {
          let line_start = idx + 1;
          let tail = &func_section[line_start..];
 -        let line_text = tail
 -            .split_once('\n')
 -            .map(|(line, _)| line)
 -            .unwrap_or(tail);
 +        let line_text = tail.split_once('\n').map(|(line, _)| line).unwrap_or(tail);
          if start.is_none() {
              if line_text.starts_with("    ")
      for (idx, _line) in func_section.match_indices('\n') {
          let line_start = idx + 1;
          let tail = &func_section[line_start..];
 -        let line_text = tail
 -            .split_once('\n')
 -            .map(|(line, _)| line)
 -            .unwrap_or(tail);
 +        let line_text = tail.split_once('\n').map(|(line, _)| line).unwrap_or(tail);
          if line_text.starts_with("    ")
              && !line_text.starts_with("      ")
              && line_text[4..].starts_with(prefix)

tests/i128_cross_object.rsmodified

77 lines changed — click to load

  use std::fs;
  use std::path::{Path, PathBuf};
  use std::process::Command;
 -use std::sync::Mutex;
  use std::sync::atomic::{AtomicUsize, Ordering};
 +use std::sync::Mutex;
  use std::time::SystemTime;
  use armfortas::driver::{compile, OptLevel, Options};
          return;
      };
      let debug_archive = workspace_root.join("target/debug/libarmfortas_rt.a");
 -    let archive_mtime = fs::metadata(&debug_archive).ok().and_then(|meta| meta.modified().ok());
 +    let archive_mtime = fs::metadata(&debug_archive)
 +        .ok()
 +        .and_then(|meta| meta.modified().ok());
      if archive_mtime.is_some_and(|mtime| mtime >= source_mtime) {
          return;
      opt_level: OptLevel,
      expected_score: char,
  ) {
 -    let _guard = CROSS_OBJECT_LOCK.lock().unwrap_or_else(|poison| poison.into_inner());
 +    let _guard = CROSS_OBJECT_LOCK
 +        .lock()
 +        .unwrap_or_else(|poison| poison.into_inner());
      let program = fixture(program_name);
      let helper = fixture(helper_name);
      let stem = program.file_stem().unwrap().to_str().unwrap();
 -    let fortran_obj = unique_temp_path("i128_cross_object", &format!("{}_{}", stem, opt_label(opt_level)), ".o");
 +    let fortran_obj = unique_temp_path(
 +        "i128_cross_object",
 +        &format!("{}_{}", stem, opt_label(opt_level)),
 +        ".o",
 +    );
      let helper_obj = unique_temp_path("i128_cross_object_helper", stem, ".o");
 -    let binary = unique_temp_path("i128_cross_object_bin", &format!("{}_{}", stem, opt_label(opt_level)), "");
 +    let binary = unique_temp_path(
 +        "i128_cross_object_bin",
 +        &format!("{}_{}", stem, opt_label(opt_level)),
 +        "",
 +    );
      compile_fortran_object(&program, &fortran_obj, opt_level);
      compile_c_object(&helper, &helper_obj);
      );
+ }
 -fn deterministic_cross_object_case_named(program_name: &str, helper_name: &str, opt_level: OptLevel) {
 -    let _guard = CROSS_OBJECT_LOCK.lock().unwrap_or_else(|poison| poison.into_inner());
 +fn deterministic_cross_object_case_named(
 +    program_name: &str,
 +    helper_name: &str,
 +    opt_level: OptLevel,
 +) {
 +    let _guard = CROSS_OBJECT_LOCK
 +        .lock()
 +        .unwrap_or_else(|poison| poison.into_inner());
      let program = fixture(program_name);
      let helper = fixture(helper_name);
      let stem = program.file_stem().unwrap().to_str().unwrap();
 -    let fortran_obj = unique_temp_path("i128_cross_object", &format!("{}_{}", stem, opt_label(opt_level)), ".o");
 +    let fortran_obj = unique_temp_path(
 +        "i128_cross_object",
 +        &format!("{}_{}", stem, opt_label(opt_level)),
 +        ".o",
 +    );
      let helper_obj = unique_temp_path("i128_cross_object_helper", stem, ".o");
 -    let binary = unique_temp_path("i128_cross_object_bin", &format!("{}_{}", stem, opt_label(opt_level)), "");
 +    let binary = unique_temp_path(
 +        "i128_cross_object_bin",
 +        &format!("{}_{}", stem, opt_label(opt_level)),
 +        "",
 +    );
      compile_fortran_object(&program, &fortran_obj, opt_level);
      compile_c_object(&helper, &helper_obj);

tests/i128_formatted_read.rsmodified

137 lines changed — click to load

              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted integer(16) input should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted integer(16) input should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted integer(16) read run at {:?}:\n{:#?}", level, run);
 -        assert!(run.stdout.contains("170141183460469231731687303715884105727"));
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted integer(16) read run at {:?}:\n{:#?}",
 +            level, run
 +        );
 +        assert!(run
 +            .stdout
 +            .contains("170141183460469231731687303715884105727"));
          assert!(run.stdout.contains("42"));
+     }
+ }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted integer(16) lvalue read should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted integer(16) lvalue read should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted integer(16) lvalue read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted integer(16) lvalue read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          for needle in [
              "11",
              "-170141183460469231731687303715884105727",
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted integer(16) array reads should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted integer(16) array reads should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted integer(16) array read run at {:?}:\n{:#?}", level, run);
 -        assert!(run.stdout.contains("11 170141183460469231731687303715884105727 33"));
 -        assert!(run.stdout.contains("66 -170141183460469231731687303715884105727 44"));
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted integer(16) array read run at {:?}:\n{:#?}",
 +            level, run
 +        );
 +        assert!(run
 +            .stdout
 +            .contains("11 170141183460469231731687303715884105727 33"));
 +        assert!(run
 +            .stdout
 +            .contains("66 -170141183460469231731687303715884105727 44"));
+     }
+ }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted integer(16) section reads should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted integer(16) section reads should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted integer(16) section read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted integer(16) section read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(run.stdout.contains("101 202"));
          assert!(run.stdout.contains("606 505 404 303"));
+     }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("allocatable formatted integer(16) reverse section read should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "allocatable formatted integer(16) reverse section read should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful allocatable reverse section read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful allocatable reverse section read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(run.stdout.contains("8"));
+     }
+ }

tests/i128_gates.rsmodified

35 lines changed — click to load

  #[test]
  fn optimized_i128_capture_is_available_through_ofast() {
 -    for level in [OptLevel::O1, OptLevel::O2, OptLevel::O3, OptLevel::Os, OptLevel::Ofast] {
 +    for level in [
 +        OptLevel::O1,
 +        OptLevel::O2,
 +        OptLevel::O3,
 +        OptLevel::Os,
 +        OptLevel::Ofast,
 +    ] {
          capture_from_path(&CaptureRequest {
              input: fixture("integer16_mul.f90"),
              requested: BTreeSet::from([Stage::OptIr]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("optimized i128 capture should succeed at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "optimized i128 capture should succeed at {:?}:\n{}",
 +                level, e
 +            )
 +        });
+     }
+ }
      assert_eq!(err.stage, FailureStage::Ir);
      assert!(
 -        err.detail.contains("backend does not yet support integer(16) / i128 codegen"),
 +        err.detail
 +            .contains("backend does not yet support integer(16) / i128 codegen"),
          "unexpected capture failure:\n{}",
          err
      );

tests/i128_high_opt.rsmodified

12 lines changed — click to load

              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful {} integer(16) run:\n{:#?}", label, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful {} integer(16) run:\n{:#?}",
 +            label, run
 +        );
          assert!(
              run.stdout.contains('1'),
              "{} integer(16) internal call program should print score 1:\n{}",

tests/i128_internal_io.rsmodified

198 lines changed — click to load

              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful internal integer(16) I/O run at {:?}:\n{:#?}", level, run);
 -        assert!(run.stdout.contains("170141183460469231731687303715884105727"));
 -        assert!(run.stdout.contains("-170141183460469231731687303715884105727"));
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful internal integer(16) I/O run at {:?}:\n{:#?}",
 +            level, run
 +        );
 +        assert!(run
 +            .stdout
 +            .contains("170141183460469231731687303715884105727"));
 +        assert!(run
 +            .stdout
 +            .contains("-170141183460469231731687303715884105727"));
+     }
+ }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted internal integer(16) write should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted internal integer(16) write should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted internal integer(16) write run at {:?}:\n{:#?}", level, run);
 -        assert!(run.stdout.contains("170141183460469231731687303715884105727"));
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted internal integer(16) write run at {:?}:\n{:#?}",
 +            level, run
 +        );
 +        assert!(run
 +            .stdout
 +            .contains("170141183460469231731687303715884105727"));
+     }
+ }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted internal integer(16) read should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted internal integer(16) read should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted internal integer(16) read run at {:?}:\n{:#?}", level, run);
 -        assert!(run.stdout.contains("170141183460469231731687303715884105727"));
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted internal integer(16) read run at {:?}:\n{:#?}",
 +            level, run
 +        );
 +        assert!(run
 +            .stdout
 +            .contains("170141183460469231731687303715884105727"));
+     }
+ }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted internal integer(16) lvalue read should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted internal integer(16) lvalue read should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted internal integer(16) lvalue read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted internal integer(16) lvalue read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          for needle in [
              "11",
              "-170141183460469231731687303715884105727",
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted internal integer(16) array reads should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted internal integer(16) array reads should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted internal integer(16) array read run at {:?}:\n{:#?}", level, run);
 -        assert!(run.stdout.contains("11 170141183460469231731687303715884105727 33"));
 -        assert!(run.stdout.contains("66 -170141183460469231731687303715884105727 44"));
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted internal integer(16) array read run at {:?}:\n{:#?}",
 +            level, run
 +        );
 +        assert!(run
 +            .stdout
 +            .contains("11 170141183460469231731687303715884105727 33"));
 +        assert!(run
 +            .stdout
 +            .contains("66 -170141183460469231731687303715884105727 44"));
+     }
+ }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted internal integer(16) section reads should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted internal integer(16) section reads should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted internal integer(16) section read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted internal integer(16) section read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(run.stdout.contains("101 202"));
          assert!(run.stdout.contains("606 505 404 303"));
+     }
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("allocatable internal formatted integer(16) section read should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "allocatable internal formatted integer(16) section read should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful allocatable internal section read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful allocatable internal section read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(run.stdout.contains("11"));
+     }
+ }
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful allocatable internal reverse section read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful allocatable internal reverse section read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(run.stdout.contains("8"));
+     }
+ }

tests/i128_memory_backend.rsmodified

36 lines changed — click to load

          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful ordered branch run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful ordered branch run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('4'),
          "ordered i128 branch program should print score 4:\n{}",
          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful integer(16) select run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful integer(16) select run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('1'),
          "integer(16) select program should print score 1:\n{}",
          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful internal integer(16) call run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful internal integer(16) call run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('1'),
          "internal integer(16) call program should print score 1:\n{}",

tests/i128_o1.rsmodified

24 lines changed — click to load

          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful O1 integer(16) run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful O1 integer(16) run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('1'),
          "O1 integer(16) internal call program should print score 1:\n{}",
          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful O1 branchy integer(16) run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful O1 branchy integer(16) run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('1'),
          "branchy O1 integer(16) program should print score 1:\n{}",

tests/i128_o2.rsmodified

12 lines changed — click to load

          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful O2 integer(16) run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful O2 integer(16) run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('1'),
          "O2 integer(16) internal call program should print score 1:\n{}",

tests/i128_runtime_io.rsmodified

61 lines changed — click to load

              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful integer(16) print run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful integer(16) print run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(
 -            run.stdout.contains("170141183460469231731687303715884105727"),
 +            run.stdout
 +                .contains("170141183460469231731687303715884105727"),
              "wide positive integer(16) print should survive at {:?}:\n{}",
              level,
              run.stdout
          );
          assert!(
 -            run.stdout.contains("-170141183460469231731687303715884105727"),
 +            run.stdout
 +                .contains("-170141183460469231731687303715884105727"),
              "wide negative integer(16) print should survive at {:?}:\n{}",
              level,
              run.stdout
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("formatted integer(16) write should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "formatted integer(16) write should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful formatted integer(16) write run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful formatted integer(16) write run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(
 -            run.stdout.contains("170141183460469231731687303715884105727"),
 +            run.stdout
 +                .contains("170141183460469231731687303715884105727"),
              "wide positive formatted integer(16) output should survive at {:?}:\n{}",
              level,
              run.stdout
          );
          assert!(
 -            run.stdout.contains("-170141183460469231731687303715884105727"),
 +            run.stdout
 +                .contains("-170141183460469231731687303715884105727"),
              "wide negative formatted integer(16) output should survive at {:?}:\n{}",
              level,
              run.stdout

tests/i128_runtime_read.rsmodified

24 lines changed — click to load

              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful integer(16) read run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful integer(16) read run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(
 -            run.stdout.contains("170141183460469231731687303715884105727"),
 +            run.stdout
 +                .contains("170141183460469231731687303715884105727"),
              "wide positive integer(16) read should survive at {:?}:\n{}",
              level,
              run.stdout
          );
          assert!(
 -            run.stdout.contains("-170141183460469231731687303715884105727"),
 +            run.stdout
 +                .contains("-170141183460469231731687303715884105727"),
              "wide negative integer(16) read should survive at {:?}:\n{}",
              level,
              run.stdout

tests/i128_stack_args.rsmodified

50 lines changed — click to load

          .and_then(CapturedStage::as_run)
          .expect("missing run capture");
 -    assert_eq!(run.exit_code, 0, "expected successful integer(16) stack-call run:\n{:#?}", run);
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "expected successful integer(16) stack-call run:\n{:#?}",
 +        run
 +    );
      assert!(
          run.stdout.contains('1'),
          "internal integer(16) stack-call program should print score 1:\n{}",
  #[test]
  fn internal_i128_stack_call_runs_through_optimized_levels() {
 -    for level in [OptLevel::O1, OptLevel::O2, OptLevel::O3, OptLevel::Os, OptLevel::Ofast] {
 +    for level in [
 +        OptLevel::O1,
 +        OptLevel::O2,
 +        OptLevel::O3,
 +        OptLevel::Os,
 +        OptLevel::Ofast,
 +    ] {
          let result = capture_from_path(&CaptureRequest {
              input: fixture("integer16_internal_stack_call.f90"),
              requested: BTreeSet::from([Stage::Run]),
              opt_level: level,
          })
 -        .unwrap_or_else(|e| panic!("optimized integer(16) stack-call should run at {:?}:\n{}", level, e));
 +        .unwrap_or_else(|e| {
 +            panic!(
 +                "optimized integer(16) stack-call should run at {:?}:\n{}",
 +                level, e
 +            )
 +        });
          let run = result
              .get(Stage::Run)
              .and_then(CapturedStage::as_run)
              .expect("missing run capture");
 -        assert_eq!(run.exit_code, 0, "expected successful integer(16) stack-call run at {:?}:\n{:#?}", level, run);
 +        assert_eq!(
 +            run.exit_code, 0,
 +            "expected successful integer(16) stack-call run at {:?}:\n{:#?}",
 +            level, run
 +        );
          assert!(
              run.stdout.contains('1'),
              "integer(16) stack-call program should print score 1 at {:?}:\n{}",

tests/incremental.rsmodified

75 lines changed — click to load

  fn unique_dir() -> PathBuf {
      let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
 -    let dir = std::env::temp_dir().join(format!(
 -        "afs_incr_{}_{}", std::process::id(), id
 -    ));
 +    let dir = std::env::temp_dir().join(format!("afs_incr_{}_{}", std::process::id(), id));
      fs::create_dir_all(&dir).unwrap();
      dir
+ }
  fn find_compiler() -> PathBuf {
      for c in &["target/release/armfortas", "target/debug/armfortas"] {
          let p = PathBuf::from(c);
 -        if p.exists() { return fs::canonicalize(&p).unwrap(); }
 +        if p.exists() {
 +            return fs::canonicalize(&p).unwrap();
 +        }
+     }
      panic!("armfortas binary not found");
+ }
  fn compile(compiler: &Path, source: &Path, obj: &Path, search: &Path) {
      let result = Command::new(compiler)
          .args([
 -            source.to_str().unwrap(), "-c", "-O0",
 -            "-o", obj.to_str().unwrap(),
 +            source.to_str().unwrap(),
 +            "-c",
 +            "-O0",
 +            "-o",
 +            obj.to_str().unwrap(),
              &format!("-I{}", search.display()),
          ])
          .output()
      let amod1 = compile_module(&compiler, &dir, "m", v1);
      let amod2 = compile_module(&compiler, &dir, "m", v2);
 -    assert_ne!(amod1, amod2, ".amod should differ when public interface changes");
 +    assert_ne!(
 +        amod1, amod2,
 +        ".amod should differ when public interface changes"
 +    );
      let _ = fs::remove_dir_all(&dir);
+ }
      // header from the body) should be identical.
      let body1 = extract_amod_body(&amod1);
      let body2 = extract_amod_body(&amod2);
 -    assert_eq!(body1, body2, ".amod interface body changed but only private impl differs");
 +    assert_eq!(
 +        body1, body2,
 +        ".amod interface body changed but only private impl differs"
 +    );
      let _ = fs::remove_dir_all(&dir);
+ }
      compile(&compiler, &main_f90, &main_o, &dir);
      let obj2 = fs::read(&main_o).unwrap();
 -    assert_eq!(obj1, obj2, "consumer .o changed despite no source/amod change");
 +    assert_eq!(
 +        obj1, obj2,
 +        "consumer .o changed despite no source/amod change"
 +    );
      let _ = fs::remove_dir_all(&dir);
+ }
      let dir = unique_dir();
      let mod_v1 = "module m\n  implicit none\n  integer :: x = 42\nend module\n";
 -    let mod_v2 = "module m\n  implicit none\n  integer :: x = 42\n  integer :: y = 99\nend module\n";
 +    let mod_v2 =
 +        "module m\n  implicit none\n  integer :: x = 42\n  integer :: y = 99\nend module\n";
      let main_src = "program p\n  use m\n  implicit none\n  print *, x\nend program\n";
      // Compile module v1 and consumer.

tests/ipo_const_arg.rsmodified

58 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
          .filter_map(|line| {
              let line = line.trim();
              let call = line.find(&format!("call {}", callee_marker))?;
 -            let inside = line[call..]
 -                .split_once('(')?
 -                .1
 -                .split_once(')')?
 -                .0
 -                .trim();
 -            Some(if inside.is_empty() { 0 } else { inside.split(", ").count() })
 +            let inside = line[call..].split_once('(')?.1.split_once(')')?.0.trim();
 +            Some(if inside.is_empty() {
 +                0
 +            } else {
 +                inside.split(", ").count()
 +            })
          })
          .collect()
+ }
      let opt_main = function_section(&opt_ir, "__prog_ipo_const_arg");
      let opt_compute = function_section(&opt_ir, "compute");
 -    assert_eq!(param_count(raw_compute), 2, "raw helper should keep both dummies:\n{}", raw_compute);
 -    assert_eq!(param_count(opt_compute), 1, "optimized helper should specialize the constant dummy:\n{}", opt_compute);
 +    assert_eq!(
 +        param_count(raw_compute),
 +        2,
 +        "raw helper should keep both dummies:\n{}",
 +        raw_compute
 +    );
 +    assert_eq!(
 +        param_count(opt_compute),
 +        1,
 +        "optimized helper should specialize the constant dummy:\n{}",
 +        opt_compute
 +    );
      assert!(
          opt_compute.contains("const_int 4"),
          "optimized helper should materialize the specialized constant directly:\n{}",
          opt_main
      );
 -    assert_eq!(obj_o2_a, obj_o2_b, "specialized O2 object snapshot should stay deterministic");
 +    assert_eq!(
 +        obj_o2_a, obj_o2_b,
 +        "specialized O2 object snapshot should stay deterministic"
 +    );
+ }

tests/ipo_dead_arg.rsmodified

65 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
          .filter_map(|line| {
              let line = line.trim();
              let call = line.find(&format!("call {}", callee_marker))?;
 -            let inside = line[call..]
 -                .split_once('(')?
 -                .1
 -                .split_once(')')?
 -                .0
 -                .trim();
 -            Some(if inside.is_empty() { 0 } else { inside.split(", ").count() })
 +            let inside = line[call..].split_once('(')?.1.split_once(')')?.0.trim();
 +            Some(if inside.is_empty() {
 +                0
 +            } else {
 +                inside.split(", ").count()
 +            })
          })
          .collect()
+ }
      let opt_main = function_section(&opt_ir, "__prog_ipo_dead_arg");
      let opt_helper = function_section(&opt_ir, "helper");
 -    assert_eq!(param_count(raw_helper), 3, "raw helper should keep all dummy args:\n{}", raw_helper);
 -    assert_eq!(param_count(opt_helper), 2, "optimized helper should drop the dead dummy arg:\n{}", opt_helper);
 +    assert_eq!(
 +        param_count(raw_helper),
 +        3,
 +        "raw helper should keep all dummy args:\n{}",
 +        raw_helper
 +    );
 +    assert_eq!(
 +        param_count(opt_helper),
 +        2,
 +        "optimized helper should drop the dead dummy arg:\n{}",
 +        opt_helper
 +    );
      let raw_call_counts = [
          call_arg_counts_for(raw_main, "@helper"),
+     ]
      .concat();
 -    assert_eq!(raw_call_counts, vec![3, 3], "raw IR should pass all three args at both call sites");
 -    assert_eq!(opt_call_counts, vec![2, 2], "optimized IR should trim the dead arg at both call sites");
 +    assert_eq!(
 +        raw_call_counts,
 +        vec![3, 3],
 +        "raw IR should pass all three args at both call sites"
 +    );
 +    assert_eq!(
 +        opt_call_counts,
 +        vec![2, 2],
 +        "optimized IR should trim the dead arg at both call sites"
 +    );
+ }

tests/ipo_return_prop.rsmodified

38 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
          .filter_map(|line| {
              let line = line.trim();
              let call = line.find(&format!("call {}", callee_marker))?;
 -            let inside = line[call..]
 -                .split_once('(')?
 -                .1
 -                .split_once(')')?
 -                .0
 -                .trim();
 -            Some(if inside.is_empty() { 0 } else { inside.split(", ").count() })
 +            let inside = line[call..].split_once('(')?.1.split_once(')')?.0.trim();
 +            Some(if inside.is_empty() {
 +                0
 +            } else {
 +                inside.split(", ").count()
 +            })
          })
          .collect()
+ }
          "optimized caller should no longer call the passthrough helper:\n{}",
          opt_main
      );
 -    assert_eq!(obj_a, obj_b, "O2 object snapshot should stay deterministic after return propagation");
 +    assert_eq!(
 +        obj_a, obj_b,
 +        "O2 object snapshot should stay deterministic after return propagation"
 +    );
+ }

tests/licm_lsf_audit_29_11.rsmodified

31 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
      for (idx, _line) in func_section.match_indices('\n') {
          let line_start = idx + 1;
          let tail = &func_section[line_start..];
 -        let line_text = tail
 -            .split_once('\n')
 -            .map(|(line, _)| line)
 -            .unwrap_or(tail);
 +        let line_text = tail.split_once('\n').map(|(line, _)| line).unwrap_or(tail);
          if start.is_none() {
              if line_text.starts_with("    ")
+ }
  fn tail_after<'a>(text: &'a str, needle: &str) -> &'a str {
 -    let start = text.find(needle).unwrap_or_else(|| panic!("missing '{}' in:\n{}", needle, text));
 +    let start = text
 +        .find(needle)
 +        .unwrap_or_else(|| panic!("missing '{}' in:\n{}", needle, text));
      &text[start + needle.len()..]
+ }

tests/multifile.rsmodified

115 lines changed — click to load

  fn find_compiler() -> PathBuf {
      for c in &["target/release/armfortas", "target/debug/armfortas"] {
          let p = PathBuf::from(c);
 -        if p.exists() { return p; }
 +        if p.exists() {
 +            return p;
 +        }
+     }
      panic!("armfortas binary not found");
+ }
  fn find_runtime() -> PathBuf {
      for dir in &["target/release", "target/debug"] {
          let p = PathBuf::from(dir).join("libarmfortas_rt.a");
 -        if p.exists() { return p; }
 +        if p.exists() {
 +            return p;
 +        }
+     }
      panic!("libarmfortas_rt.a not found");
+ }
  /// Compile a .f90 file with -c, producing .o and optionally .amod.
  fn compile_file(compiler: &Path, source: &Path, output: &Path, search_dir: Option<&Path>) {
      let mut cmd = Command::new(compiler);
 -    cmd.args([source.to_str().unwrap(), "-c", "-o", output.to_str().unwrap()]);
 +    cmd.args([
 +        source.to_str().unwrap(),
 +        "-c",
 +        "-o",
 +        output.to_str().unwrap(),
 +    ]);
      if let Some(dir) = search_dir {
          cmd.arg(format!("-I{}", dir.display()));
+     }
          args.push(o.to_str().unwrap().into());
+     }
      args.push(runtime.to_str().unwrap().into());
 -    args.extend(["-lSystem".into(), "-syslibroot".into(), sdk, "-arch".into(), "arm64".into()]);
 -    let result = Command::new("ld").args(&args).output().expect("ld launch failed");
 +    args.extend([
 +        "-lSystem".into(),
 +        "-syslibroot".into(),
 +        sdk,
 +        "-arch".into(),
 +        "arm64".into(),
 +    ]);
 +    let result = Command::new("ld")
 +        .args(&args)
 +        .output()
 +        .expect("ld launch failed");
      assert!(
          result.status.success(),
          "link failed:\n{}",
  /// Run a binary and return its stdout.
  fn run_binary(binary: &Path) -> String {
 -    let result = Command::new(binary)
 -        .output()
 -        .expect("binary launch failed");
 +    let result = Command::new(binary).output().expect("binary launch failed");
      assert!(
          result.status.success(),
          "{} exited with {:?}\nstderr: {}",
+ }
  /// Full multi-file test: write sources, compile, link, run, check.
 -fn multifile_test(
 -    mod_source: &str,
 -    main_source: &str,
 -    expected_substring: &str,
 -) {
 +fn multifile_test(mod_source: &str, main_source: &str, expected_substring: &str) {
      let compiler = find_compiler();
      let dir = unique_dir();
      let mod_f90 = dir.join("mod.f90");
      std::fs::write(&base_f90, "module base\n  implicit none\n  interface add\n    module procedure add_int, add_real\n  end interface\ncontains\n  integer function add_int(a, b)\n    integer, intent(in) :: a, b\n    add_int = a + b\n  end function\n  real function add_real(a, b)\n    real, intent(in) :: a, b\n    add_real = a + b\n  end function\nend module\n").unwrap();
      std::fs::write(&middle_f90, "module middle\n  use base\nend module\n").unwrap();
 -    std::fs::write(&main_f90, "program p\n  use middle\n  print *, add(1, 2)\n  print *, add(1.5, 2.5)\nend program\n").unwrap();
 +    std::fs::write(
 +        &main_f90,
 +        "program p\n  use middle\n  print *, add(1, 2)\n  print *, add(1.5, 2.5)\nend program\n",
 +    )
 +    .unwrap();
      compile_file(&compiler, &base_f90, &base_o, None);
      compile_file(&compiler, &middle_f90, &middle_o, Some(&dir));
      compile_file(&compiler, &main_f90, &main_o, Some(&dir));
      link_files(&[&main_o, &middle_o, &base_o], &binary);
      let output = run_binary(&binary);
 -    assert!(output.contains("3"), "expected '3' in output, got:\n{}", output);
 -    assert!(output.contains("4.0000000E0"), "expected real add result in output, got:\n{}", output);
 +    assert!(
 +        output.contains("3"),
 +        "expected '3' in output, got:\n{}",
 +        output
 +    );
 +    assert!(
 +        output.contains("4.0000000E0"),
 +        "expected real add result in output, got:\n{}",
 +        output
 +    );
      let _ = std::fs::remove_dir_all(&dir);
+ }
      // Check .amod only has pub_val.
      let amod = std::fs::read_to_string(dir.join("priv_mod.amod")).unwrap();
      assert!(amod.contains("pub_val"), "pub_val should be in .amod");
 -    assert!(!amod.contains("priv_val"), "priv_val should NOT be in .amod");
 +    assert!(
 +        !amod.contains("priv_val"),
 +        "priv_val should NOT be in .amod"
 +    );
      let _ = std::fs::remove_dir_all(&dir);
+ }

tests/multifile_gen.rsmodified

142 lines changed — click to load

  fn unique_dir(prefix: &str) -> PathBuf {
      let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
 -    let dir = std::env::temp_dir().join(format!(
 -        "afs_gen_{}_{}_{}", prefix, std::process::id(), id
 -    ));
 +    let dir =
 +        std::env::temp_dir().join(format!("afs_gen_{}_{}_{}", prefix, std::process::id(), id));
      fs::create_dir_all(&dir).unwrap();
      dir
+ }
  fn find_compiler() -> PathBuf {
      for c in &["target/release/armfortas", "target/debug/armfortas"] {
          let p = PathBuf::from(c);
 -        if p.exists() { return fs::canonicalize(&p).unwrap(); }
 +        if p.exists() {
 +            return fs::canonicalize(&p).unwrap();
 +        }
+     }
      panic!("armfortas binary not found");
+ }
  fn find_runtime() -> PathBuf {
      for dir in &["target/release", "target/debug"] {
          let p = PathBuf::from(dir).join("libarmfortas_rt.a");
 -        if p.exists() { return p; }
 +        if p.exists() {
 +            return p;
 +        }
+     }
      panic!("libarmfortas_rt.a not found");
+ }
  fn compile_file(compiler: &Path, source: &Path, output: &Path, search_dir: &Path, opt: &str) {
      let result = Command::new(compiler)
          .args([
 -            source.to_str().unwrap(), "-c", opt,
 -            "-o", output.to_str().unwrap(),
 +            source.to_str().unwrap(),
 +            "-c",
 +            opt,
 +            "-o",
 +            output.to_str().unwrap(),
              &format!("-I{}", search_dir.display()),
          ])
          .output()
          args.push(o.to_str().unwrap().into());
+     }
      args.push(runtime.to_str().unwrap().into());
 -    args.extend(["-lSystem".into(), "-syslibroot".into(), sdk, "-arch".into(), "arm64".into()]);
 -    let result = Command::new("ld").args(&args).output().expect("ld launch failed");
 +    args.extend([
 +        "-lSystem".into(),
 +        "-syslibroot".into(),
 +        sdk,
 +        "-arch".into(),
 +        "arm64".into(),
 +    ]);
 +    let result = Command::new("ld")
 +        .args(&args)
 +        .output()
 +        .expect("ld launch failed");
      assert!(
          result.status.success(),
          "link failed:\n{}",
      assert!(
          result.status.success(),
          "{} exited with {:?}\nstderr: {}",
 -        binary.display(), result.status.code(),
 +        binary.display(),
 +        result.status.code(),
          String::from_utf8_lossy(&result.stderr)
      );
      String::from_utf8_lossy(&result.stdout).into_owned()
              format!(
                  "module mod_{i}\n  use mod_{next}\n  implicit none\n  \
                   integer, parameter :: val_{i} = val_{next} + {i}\nend module\n",
 -                i = i, next = i + 1
 +                i = i,
 +                next = i + 1
              ),
          ));
+     }
      // Main program uses mod_1 and prints the accumulated value.
      let expected: usize = (1..=depth).sum();
 -    let main_src = format!(
 -        "program p\n  use mod_1\n  implicit none\n  print *, val_1\nend program\n"
 -    );
 +    let main_src =
 +        format!("program p\n  use mod_1\n  implicit none\n  print *, val_1\nend program\n");
      // Files are already in compilation order: leaf first, then towards root.
      let expected_str = Box::leak(format!("{}", expected).into_boxed_str());
      assert!(
          output.contains(expected),
          "{} [{}]: expected '{}' in output, got:\n{}",
 -        label, opt, expected, output
 +        label,
 +        opt,
 +        expected,
 +        output
      );
      let _ = fs::remove_dir_all(&dir);
      assert!(
          output.contains(expected),
          "{}: mod@{} + main@{}: expected '{}' in output, got:\n{}",
 -        label, mod_opt, main_opt, expected, output
 +        label,
 +        mod_opt,
 +        main_opt,
 +        expected,
 +        output
      );
      let _ = fs::remove_dir_all(&dir);
  #[test]
  fn abi_matrix_chain5_mod_o0_main_ofast() {
      let (files, main_src, expected) = gen_chain(5);
 -    run_cross_opt_test(files, main_src, expected, "-O0", "-Ofast", "abi_chain5_0_fast");
 +    run_cross_opt_test(
 +        files,
 +        main_src,
 +        expected,
 +        "-O0",
 +        "-Ofast",
 +        "abi_chain5_0_fast",
 +    );
+ }
  #[test]
  fn abi_matrix_chain5_mod_ofast_main_o0() {
      let (files, main_src, expected) = gen_chain(5);
 -    run_cross_opt_test(files, main_src, expected, "-Ofast", "-O0", "abi_chain5_fast_0");
 +    run_cross_opt_test(
 +        files,
 +        main_src,
 +        expected,
 +        "-Ofast",
 +        "-O0",
 +        "abi_chain5_fast_0",
 +    );
+ }

tests/ofast_fast_math.rsmodified

31 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
          Stage::Obj,
      );
 -    assert_eq!(parse_last_int(&o3_run.stdout), 0, "strict O3 run should keep IEEE-style rounding loss");
 -    assert_eq!(parse_last_int(&ofast_run.stdout), 1, "Ofast run should expose fast-math reassociation");
 -    assert_eq!(ofast_obj_a, ofast_obj_b, "Ofast object snapshot should stay deterministic");
 +    assert_eq!(
 +        parse_last_int(&o3_run.stdout),
 +        0,
 +        "strict O3 run should keep IEEE-style rounding loss"
 +    );
 +    assert_eq!(
 +        parse_last_int(&ofast_run.stdout),
 +        1,
 +        "Ofast run should expose fast-math reassociation"
 +    );
 +    assert_eq!(
 +        ofast_obj_a, ofast_obj_b,
 +        "Ofast object snapshot should stay deterministic"
 +    );
+ }

tests/opt_audit_29_11.rsmodified

21 lines changed — click to load

          .find(&marker)
          .unwrap_or_else(|| panic!("missing function {} in IR:\n{}", name, ir));
      let rest = &ir[start..];
 -    let end = rest
 -        .find("\n  func @")
 -        .unwrap_or(rest.len());
 +    let end = rest.find("\n  func @").unwrap_or(rest.len());
      &rest[..end]
+ }
  #[test]
  fn realworld_29_8_kernels_have_deterministic_o2_objects() {
 -    for name in ["realworld_sasum_cleanup.f90", "realworld_three_point_apply.f90"] {
 +    for name in [
 +        "realworld_sasum_cleanup.f90",
 +        "realworld_three_point_apply.f90",
 +    ] {
          let source = fixture(name);
          let first = capture_text(
              CaptureRequest {

tests/program_entry_audit.rsmodified

11 lines changed — click to load

          opt_level: OptLevel::O2,
      });
 -    assert_eq!(run.exit_code, 0, "program should run successfully:\n{run:#?}");
 +    assert_eq!(
 +        run.exit_code, 0,
 +        "program should run successfully:\n{run:#?}"
 +    );
      assert!(
          run.stdout.split_whitespace().any(|field| field == "99"),
          "program body should execute and print the helper-written value:\n{}",

tests/pure_call_reuse.rsmodified

22 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")
      let raw_main = function_section(&raw_ir, "__prog_pure_recursive_reuse");
      let opt_main = function_section(&opt_ir, "__prog_pure_recursive_reuse");
 -    let raw_pure_calls =
 -        count(raw_main, "call @heavy_fact(") + count(raw_main, "call @func_");
 -    let opt_pure_calls =
 -        count(opt_main, "call @heavy_fact(") + count(opt_main, "call @func_");
 +    let raw_pure_calls = count(raw_main, "call @heavy_fact(") + count(raw_main, "call @func_");
 +    let opt_pure_calls = count(opt_main, "call @heavy_fact(") + count(opt_main, "call @func_");
      assert_eq!(
          raw_pure_calls, 2,

tests/pure_dead_call_elim.rsmodified

10 lines changed — click to load

  fn function_section<'a>(ir: &'a str, name: &str) -> &'a str {
      let header = format!("  func @{}", name);
 -    let start = ir.find(&header).unwrap_or_else(|| panic!("missing function section for {}", name));
 +    let start = ir
 +        .find(&header)
 +        .unwrap_or_else(|| panic!("missing function section for {}", name));
      let rest = &ir[start..];
      let end = rest
          .find("\n  }\n")

tests/vectorize_do_loop.rsmodified

9 lines changed — click to load

          "O3 assembly should reference the bulk add kernel:\n{}",
          o3_asm
      );
 -    assert_eq!(o3_obj_a, o3_obj_b, "O3 vectorized object snapshot should stay deterministic");
 +    assert_eq!(
 +        o3_obj_a, o3_obj_b,
 +        "O3 vectorized object snapshot should stay deterministic"
 +    );
+ }

fortrangoingonforty/armfortas / `f9a892d`

112 changed files