nandi/rustnim · 04f5b3e

⑂ 04f5b3e

Fold `SOME_ARRAY.len()` in an array length

An array's length is part of its type in Rust and in Nim, so this is a
constant on both sides; Nim spells it without the parentheses.

Found by the dependency run, in a `[Feature; ARABIC_FEATURES.len()]`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

nandithebull committed 2026-09-19T10:32:08-07:00 Browse files

04f5b3e parent: 62d5926

modified src/ty.rs +6 -0 Viewed

@@ -622,6 +622,12 @@ pub fn const_expr(e: &syn::Expr) -> Result<String, String> {
622	622	.ok_or_else(\|\| format!("`{nim}` in an array length needs a type argument"))??;
623	623	Ok(format!("{}({})", nim, t.render()))
624	624	}
	625	+ // `SOME_CONST_ARRAY.len()`. An array's length is part of its type in
	626	+ // both languages, so this is a constant on both sides -- Nim spells it
	627	+ // without the parentheses.
	628	+ Expr::MethodCall(m) if m.method == "len" && m.args.is_empty() => {
	629	+ Ok(format!("({}).len", const_expr(&m.receiver)?))
	630	+ }
625	631	Expr::Cast(c) => const_expr(&c.expr),
626	632	other => Err(format!(
627	633	"array length is not a const expression rustnim can render: `{}`",

                  .ok_or_else(|| format!("`{nim}` in an array length needs a type argument"))??;
              Ok(format!("{}({})", nim, t.render()))
          }
++        // `SOME_CONST_ARRAY.len()`. An array's length is part of its type in
++        // both languages, so this is a constant on both sides -- Nim spells it
++        // without the parentheses.
++        Expr::MethodCall(m) if m.method == "len" && m.args.is_empty() => {
++            Ok(format!("({}).len", const_expr(&m.receiver)?))
++        }
          Expr::Cast(c) => const_expr(&c.expr),
          other => Err(format!(
              "array length is not a const expression rustnim can render: `{}`",

modified tests/cases/052-const-array-len.rs +6 -0 Viewed

@@ -3,6 +3,7 @@
3	3	// rather than resolved to a number.
4	4	const BLOCK: usize = 4;
5	5	const DOUBLE: usize = BLOCK * 2;
	6	+const FEATURES: [u8; 3] = [1, 2, 3];
6	7
7	8	struct Oid;
8	9
@@ -45,4 +46,9 @@ fn main() {
45	46	// output writes it with.
46	47	let q: [u8; { Oid::MAX_SIZE }] = [2u8; Oid::MAX_SIZE];
47	48	println!("{} {}", q.len(), sum(&q));
	49	+
	50	+ // The length of another const array. An array's length is part of its
	51	+ // type in both languages, so it is a constant on both sides.
	52	+ let r: [u8; FEATURES.len()] = [4u8; FEATURES.len()];
	53	+ println!("{} {}", r.len(), sum(&r));
48	54	}

  // rather than resolved to a number.
  const BLOCK: usize = 4;
  const DOUBLE: usize = BLOCK * 2;
++const FEATURES: [u8; 3] = [1, 2, 3];
  struct Oid;
      // output writes it with.
      let q: [u8; { Oid::MAX_SIZE }] = [2u8; Oid::MAX_SIZE];
      println!("{} {}", q.len(), sum(&q));
++
++    // The length of another const array. An array's length is part of its
++    // type in both languages, so it is a constant on both sides.
++    let r: [u8; FEATURES.len()] = [4u8; FEATURES.len()];
++    println!("{} {}", r.len(), sum(&r));
  }