diff --git a/quest/m2/README.md b/quest/m2/README.md index 519239868..26669d251 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -23,8 +23,8 @@ The fork's feature quests folded into the [exporter](/quest/m1/ffi-export.md); - [MIR's codec as fast as THIR's](/quest/m2/ts-mir-codec.md) - the codec from MIR no slower than from THIR in any engine - [Lower bodies from MIR](/quest/m2/ts-mir.md) - the MIR spike's prototype becomes the only lowering, and the THIR one goes -- [Enum variant field order](/quest/m2/ts-variant-order.md) - a variant's fields evaluate in the order written, not declared - [Stable names](/quest/m2/ts-stable-names.md) - generic instances and trait-impl methods always carry their suffix, so callers' names never shift +- [Struct update on a std range](/quest/m2/ts-range-update.md) - `Range { start, ..r }` reads its base, or is refused with a span, instead of dropping it or panicking the driver - [Cheaper byte slices](/quest/m2/ts-byte-views.md) - splitting a `&[u8]` stops making a `Uint8Array` view per split - [Wide-integer fast paths](/quest/m2/ts-wide-fast.md) - a fused `from_halves` and an unboxed limb product, kept only if measured faster - [Drop in the TypeScript translator](/quest/m2/ts-drop.md) - every value that drops in moq-net and kio drops where Rust drops it diff --git a/quest/m2/ts-range-update.md b/quest/m2/ts-range-update.md new file mode 100644 index 000000000..5922587c3 --- /dev/null +++ b/quest/m2/ts-range-update.md @@ -0,0 +1,19 @@ +# [XS] Struct update syntax on a std range + +## Goal + +[rust2-ts](/ts/README.md) translates `Range { start, ..r }` with the base's fields, or +refuses it with an error at its span, under both lowerings. Today the THIR lowering +drops the base when it builds the range, and panics the driver on an index when a +`for` loop iterates it. + +## Plan + +Found in [#49](https://github.com/kixelated/rust2/pull/49). The std arm of the THIR +aggregate lowering returns before the base is read, and the `for` loop and slicing +paths assume every field is written. MIR's aggregate carries every field, so it may +already be right: prove it with a differential case before deciding whether THIR +supports it or refuses it. If [Lower bodies from MIR](/quest/m2/ts-mir.md) lands +first, only the MIR check remains. + +Public API: none. diff --git a/quest/m2/ts-variant-order.md b/quest/m2/ts-variant-order.md deleted file mode 100644 index b517915fb..000000000 --- a/quest/m2/ts-variant-order.md +++ /dev/null @@ -1,19 +0,0 @@ -# [S] Enum variant fields evaluate as written - -## Goal - -[rust2-ts](/ts/README.md) evaluates an enum variant's fields in the order the Rust -source writes them, as it already does a struct's, proven by a differential test whose -field expressions log as they run. - -## Plan - -Found in the [tree-shaking spike](https://github.com/kixelated/rust2/pull/32): a -variant built with its fields out of declaration order lowers to an object literal in -declaration order, so `Shape::Rect { height: push(log, 1), width: push(log, 2), .. }` -runs `push(log, 2)` first. A value with statements of its own is spilled in order -already; a call is not. Struct literals spill every non-constant field first when -they reorder; variants can do the same. Check the `Range` constructor and positional -struct fields given by index (`S { 1: a, 0: b }`) for the same reordering. - -Public API: none. diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 14d93f721..820899dcf 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -5,7 +5,7 @@ import { ints, strings, derived, written, panics } from "./fmt.ts"; import { methods } from "./generics.ts"; import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast, convert } from "./ints.ts"; import { adaptors, consumers, ranges, options, own, values } from "./iters.ts"; -import { copies, discriminants, loops, patterns, closures, library } from "./shapes.ts"; +import { copies, order, discriminants, loops, patterns, closures, library } from "./shapes.ts"; /** Run one case. */ export function run(input: Uint8Array): rt.ByteVec { @@ -17,7 +17,7 @@ export function run(input: Uint8Array): rt.ByteVec { const kind = input[1]; const data = input.subarray(2, input.length - 0); const [op2, kind2] = [op, kind] as [rt.u8, rt.u8]; - const value = rt.u8.rem(op2, 33); + const value = rt.u8.rem(op2, 34); if (value === 0) { u8Op(kind2, data, out); } else if (value === 1) { @@ -102,8 +102,10 @@ export function run(input: Uint8Array): rt.ByteVec { options(data, out); } else if (value === 31) { own(data, out); - } else { + } else if (value === 32) { values(data, out); + } else { + order(data, out); } return out; } diff --git a/ts/fixtures/lang/expected/shapes.Moved.ts b/ts/fixtures/lang/expected/shapes.Moved.ts new file mode 100644 index 000000000..37b241c1b --- /dev/null +++ b/ts/fixtures/lang/expected/shapes.Moved.ts @@ -0,0 +1,15 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function fmt(self: Moved, f: rt.Formatter): rt.Result { + return f.debugTuple("Moved").field((f: rt.Formatter) => rt.u8.display(self._0, f)).field((f: rt.Formatter) => rt.u16.display(self._1, f)).finish(); +} + +/** A tuple struct that is not `Copy`, so struct update syntax reads its base in place. */ +export interface Moved { + _0: rt.u8; + _1: rt.u16; +} + +//# sourceMappingURL=shapes.Moved.ts.map diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 162e34689..3cc26c31c 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -1,8 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import * as Pair from "./fmt.Pair.ts"; import type * as Dir from "./shapes.Dir.ts"; import * as Meters from "./shapes.Meters.ts"; +import * as Moved from "./shapes.Moved.ts"; import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; import type * as Signed from "./shapes.Signed.ts"; @@ -159,6 +161,71 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { return out.length; } +/** + * Aggregates written with their fields out of declaration order evaluate them as + * written: each field logs as it runs. + */ +export function order(data: Uint8Array, out: rt.ByteVec): void { + const at = (i: rt.usize): rt.u8 => { + return rt.option.unwrapOr(rt.slice.get(data, i), 0); + }; + const arg = mark(out, at(0)) & 0xffff; + const arg2 = mark(out, at(1)) & 0xffff; + const field = mark(out, 2) | 0; + const field2 = arg; + const field3 = arg2; + const rect = { tag: "Rect", corner: { x: mark(out, 3) | 0, y: field }, width: field3, height: field2 } as Shape.Shape; + const field4 = Point.new(mark(out, 4) | 0, 0); + const line = { tag: "Line", _0: Point.new(mark(out, 5) | 0, 0), _1: field4 } as Shape.Shape; + const field5 = mark(out, 6) as rt.i64; + const pair = { _0: mark(out, 7) & 0xff, _1: field5 }; + let n: Uint8Array = Uint8Array.of(at(2)); + const field6 = n[0] as rt.i32; + const read = { x: increment(n) as rt.i32, y: field6 }; + let base: Moved.Moved = { _0: at(4), _1: 0 }; + const field7 = reset(base); + const updated = { _0: base._0, _1: field7 }; + let taken: Shape.Shape; + if (rt.u8.rem(at(3), 2) === 0) { + const field8 = mark(out, 8) & 0xffff; + taken = { tag: "Rect", corner: Point.new(0, mark(out, 9) | 0), width: field8, height: 1 }; + } else { + taken = { tag: "Dot" }; + } + const field9 = mark(out, 10); + const range = new rt.Range(rt.usize.div(mark(out, 11), 2), field9); + let sum: rt.usize = 0; + const end = mark(out, 12); + for (let i2 = rt.usize.sub(mark(out, 13), 4); i2 < end; i2++) { + sum = rt.usize.add(sum, i2); + } + const len = data.length; + const arg3 = logged(data, out); + const field10 = rt.min(mark(out, 14), len); + const slice = rt.slice.range(arg3, rt.usize.div(rt.min(mark(out, 15), len), 2), field10); + const text = rt.fmt.format([(f: rt.Formatter) => Shape.fmt(rect, f), " ", (f: rt.Formatter) => Shape.fmt(line, f), " ", (f: rt.Formatter) => Pair.fmt(pair, f), " ", (f: rt.Formatter) => Point.fmt(read, f), " ", (f: rt.Formatter) => Moved.fmt(updated, f), " ", (f: rt.Formatter) => Shape.fmt(taken, f), " ", (f: rt.Formatter) => rt.usize.display(range.start, f), " ", (f: rt.Formatter) => rt.usize.display(range.end, f), " ", (f: rt.Formatter) => rt.usize.display(sum, f), " ", (f: rt.Formatter) => rt.fmt.list(slice, f, rt.u8.display)]); + out.extendFromSlice(rt.string.asBytes(text)); +} + +/** `data`, logging that it was read. */ +export function logged(data: Uint8Array, out: rt.ByteVec): Uint8Array { + out.push(0xee); + return data; +} + +/** `n`'s byte, incremented. */ +export function increment(n: Uint8Array): rt.u8 { + const value = rt.u8.wrappingAdd(n[0], 1); + n[0] = value; + return n[0]; +} + +/** Changes `m`'s first field. */ +export function reset(m: Moved.Moved): rt.u16 { + m._0 = 9; + return 1; +} + /** Fieldless enums cast to every width, past their discriminant's range and sign. */ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { for (const item of data) { diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index e1c9b69db..ab2f71063 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -19,7 +19,7 @@ pub fn run(input: &[u8]) -> Vec { return out; }; let (op, kind) = (*op, *kind); - match op % 33 { + match op % 34 { 0 => ints::u8_op(kind, data, &mut out), 1 => ints::u16_op(kind, data, &mut out), 2 => ints::u32_op(kind, data, &mut out), @@ -62,7 +62,8 @@ pub fn run(input: &[u8]) -> Vec { 29 => iters::ranges(data, &mut out), 30 => iters::options(data, &mut out), 31 => iters::own(data, &mut out), - _ => iters::values(data, &mut out), + 32 => iters::values(data, &mut out), + _ => shapes::order(data, &mut out), } out } diff --git a/ts/fixtures/lang/src/shapes.rs b/ts/fixtures/lang/src/shapes.rs index 27b0963b2..e7d293edf 100644 --- a/ts/fixtures/lang/src/shapes.rs +++ b/ts/fixtures/lang/src/shapes.rs @@ -1,5 +1,7 @@ //! Control flow, patterns, aggregates, closures, and traits. +use crate::fmt::Pair; + /// A `Copy` struct, which Rust copies where JS would share. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Point { @@ -27,6 +29,10 @@ impl Point { #[derive(Clone, Copy)] pub struct Meters(pub u64); +/// A tuple struct that is not `Copy`, so struct update syntax reads its base in place. +#[derive(Debug)] +pub struct Moved(pub u8, pub u16); + /// An enum with data, and one without. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Shape { @@ -245,6 +251,92 @@ fn mark(out: &mut Vec, b: u8) -> usize { out.len() } +/// Aggregates written with their fields out of declaration order evaluate them as +/// written: each field logs as it runs. +pub fn order(data: &[u8], out: &mut Vec) { + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let rect = Shape::Rect { + height: mark(out, at(0)) as u16, + width: mark(out, at(1)) as u16, + corner: Point { + y: mark(out, 2) as i32, + x: mark(out, 3) as i32, + }, + }; + let line = Shape::Line { + 1: Point::new(mark(out, 4) as i32, 0), + 0: Point::new(mark(out, 5) as i32, 0), + }; + let pair = Pair { + 1: mark(out, 6) as i64, + 0: mark(out, 7) as u8, + }; + // A local read before a later field changes it. + let mut n = [at(2)]; + let read = Point { + y: n[0] as i32, + x: increment(&mut n) as i32, + }; + // The base is read after the fields, which change it. + let mut base = Moved(at(4), 0); + let updated = Moved { + 1: reset(&mut base), + ..base + }; + // Only the branch taken runs its fields. + let taken = match at(3) % 2 { + 0 => Shape::Rect { + width: mark(out, 8) as u16, + height: 1, + corner: Point::new(0, mark(out, 9) as i32), + }, + _ => Shape::Dot, + }; + let range = std::ops::Range { + end: mark(out, 10), + start: mark(out, 11) / 2, + }; + let mut sum = 0; + for i in (std::ops::Range { + end: mark(out, 12), + start: mark(out, 13) - 4, + }) { + sum += i; + } + let len = data.len(); + // The sliced value comes before the range's fields. + let slice = &logged(data, out)[std::ops::Range { + end: mark(out, 14).min(len), + start: mark(out, 15).min(len) / 2, + }]; + let text = format!( + "{rect:?} {line:?} {pair:?} {read:?} {updated:?} {taken:?} {} {} {sum} {slice:?}", + range.start, range.end + ); + out.extend_from_slice(text.as_bytes()); +} + +/// `data`, logging that it was read. +#[inline(never)] +fn logged<'a>(data: &'a [u8], out: &mut Vec) -> &'a [u8] { + out.push(0xee); + data +} + +/// `n`'s byte, incremented. +#[inline(never)] +fn increment(n: &mut [u8; 1]) -> u8 { + n[0] = n[0].wrapping_add(1); + n[0] +} + +/// Changes `m`'s first field. +#[inline(never)] +fn reset(m: &mut Moved) -> u16 { + m.0 = 9; + 1 +} + /// Fieldless enums cast to every width, past their discriminant's range and sign. pub fn discriminants(data: &[u8], out: &mut Vec) { for &b in data { diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index a2dc8f535..b83889575 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -865,8 +865,11 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { ExprKind::LogicalOp { lhs, rhs, .. } => self.simple(*lhs) && self.simple(*rhs), ExprKind::Call { args, fun, .. } => self.simple(*fun) && args.iter().all(|a| self.simple(*a)), ExprKind::Tuple { fields } | ExprKind::Array { fields } => fields.iter().all(|f| self.simple(*f)), + // Fields written out of declaration order may be spilled to keep their order. ExprKind::Adt(adt) => { - adt.fields.iter().all(|f| self.simple(f.expr)) && matches!(adt.base, thir::AdtExprBase::None) + adt.fields.iter().all(|f| self.simple(f.expr)) + && adt.fields.is_sorted_by_key(|f| f.name) + && matches!(adt.base, thir::AdtExprBase::None) } ExprKind::VarRef { .. } | ExprKind::UpvarRef { .. } @@ -1654,22 +1657,25 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { .err(span, "a `for` loop over a range that is not written in place"); return None; }; - let mut fields: Vec = vec![range.fields[0].expr, range.fields[1].expr]; - if range.fields[0].name.index() == 1 { - fields.swap(0, 1); - } - let mut values = self.operands(&fields, out); - let end = values.pop().unwrap(); - let mut start = values.pop().unwrap(); - let end = match end.is_constant() { - true => end, - false => { - if !start.is_constant() { - start = self.spill(start, "start", out); + let ids: Vec = range.fields.iter().map(|f| f.expr).collect(); + let mut values = self.operands(&ids, out); + // `end` is read on every turn, so unless constant it is spilled, after what is + // written before it. + let swapped = range.fields[0].name.index() == 1; + let end_at = if swapped { 0 } else { 1 }; + if !values[end_at].is_constant() { + for (i, value) in values.iter_mut().enumerate().take(end_at + 1) { + if !value.is_constant() { + let saved = std::mem::replace(value, Expr::undefined()); + *value = self.spill(saved, if i == end_at { "end" } else { "start" }, out); } - self.spill(end, "end", out) } - }; + } + if swapped { + values.swap(0, 1); + } + let end = values.pop().unwrap(); + let start = values.pop().unwrap(); Some(range_of(ty, start, end, false)) } ty::Adt(adt, _) if tcx.is_lang_item(adt.did(), rustc_attr_ir::LangItem::RangeInclusiveStruct) => { @@ -1748,6 +1754,25 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { Expr::ident(name) } + /// Fields' values by index, from the order they are written to declaration order. + /// Each that would then evaluate after one written later is spilled first, unless + /// constant, so they still evaluate as written. + pub fn declared(&mut self, mut written: Vec<(usize, Expr)>, out: &mut Vec) -> Vec<(usize, Expr)> { + // The longest tail already in declaration order evaluates in place, after the rest. + let mut tail = written.len().saturating_sub(1); + while tail > 0 && written[tail - 1].0 < written[tail].0 { + tail -= 1; + } + for (_, value) in &mut written[..tail] { + if !value.is_constant() { + let saved = std::mem::replace(value, Expr::undefined()); + *value = self.spill(saved, "field", out); + } + } + written.sort_by_key(|(i, _)| *i); + written + } + /// `value`, from `id`, as something patterns can read more than once. fn path(&mut self, value: Expr, id: ExprId, out: &mut Vec) -> Expr { if value.is_path() { @@ -2496,10 +2521,8 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { (library::Std::Result, _) => Expr::rt("Err", values), (library::Std::FmtError, _) => Expr::New(Box::new(Expr::Rt("FmtError")), Vec::new()), (library::Std::Range, _) => { - let mut ordered: Vec<(usize, Expr)> = - adt.fields.iter().map(|f| f.name.index()).zip(values).collect(); - ordered.sort_by_key(|(i, _)| *i); - let mut args: Vec = ordered.into_iter().map(|(_, v)| v).collect(); + let written = adt.fields.iter().map(|f| f.name.index()).zip(values).collect(); + let mut args: Vec = self.declared(written, out).into_iter().map(|(_, v)| v).collect(); // A wide range steps past 2^53 through its type. let ty::Adt(_, gargs) = ty.kind() else { unreachable!("a range is a struct") @@ -2547,68 +2570,34 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { }; match info.repr { AdtRepr::Struct { ctor, fields } => { - let class = Box::new(Expr::Sym(info.sym)); + // The fields in the order they evaluate: as written, then those the base fills. + let mut written: Vec<(usize, Expr)> = adt + .fields + .iter() + .zip(values) + .map(|(f, value)| (f.name.index(), field_arg(tcx, &variant.fields[f.name], value))) + .collect(); + if let Some(base) = &base { + for (i, field) in variant.fields.iter().enumerate() { + if adt.fields.iter().any(|f| f.name.index() == i) { + continue; + } + let field_ty = self.subst(field.ty(tcx, adt.args).skip_norm_wip()); + written.push((i, self.copied(base.clone().field(fields[i]), field_ty))); + } + } match ctor { ts::Ctor::Unit => self.t.construct(info.sym, &ts::Ctor::Unit, &fields, Vec::new()), - ts::Ctor::Positional => { - let mut ordered: Vec> = vec![None; variant.fields.len()]; - for (f, value) in adt.fields.iter().zip(values) { - ordered[f.name.index()] = Some(field_arg(tcx, &variant.fields[f.name], value)); - } - let args = ordered - .into_iter() - .enumerate() - .map(|(i, v)| match (v, &base) { - (Some(v), _) => v, - (None, Some(base)) => { - let field_ty = self.subst( - variant.fields[rustc_abi::FieldIdx::from_usize(i)] - .ty(tcx, adt.args) - .skip_norm_wip(), - ); - self.copied(base.clone().field(fields[i]), field_ty) - } - (None, None) => Expr::undefined(), - }) - .collect(); - self.t.construct(info.sym, &ts::Ctor::Positional, &fields, args) + // A class takes its named fields as an object, which evaluates them as written. + ts::Ctor::Named if !self.t.plain(info.sym) => { + let props = written.into_iter().map(|(i, v)| (Key::Field(fields[i]), v)).collect(); + Expr::New(Box::new(Expr::Sym(info.sym)), vec![Expr::Object(props)]) } - ts::Ctor::Named => { - let mut props: Vec<(Key, Expr)> = adt - .fields - .iter() - .zip(values) - .map(|(f, value)| { - let value = field_arg(tcx, &variant.fields[f.name], value); - (Key::Field(fields[f.name.index()]), value) - }) - .collect(); - if let Some(base) = &base { - for (i, field) in variant.fields.iter().enumerate() { - if adt.fields.iter().any(|f| f.name.index() == i) { - continue; - } - let field_ty = self.subst(field.ty(tcx, adt.args).skip_norm_wip()); - let value = self.copied(base.clone().field(fields[i]), field_ty); - props.push((Key::Field(fields[i]), value)); - } - } - if !self.t.plain(info.sym) { - return Expr::New(class, vec![Expr::Object(props)]); - } - // A plain object's properties go in declaration order, so every value of - // the struct shares one shape; the values are still evaluated as written. - let index = |key: &Key| fields.iter().position(|f| matches!(key, Key::Field(k) if k == f)); - if !props.is_sorted_by_key(|(key, _)| index(key)) { - for (_, value) in props.iter_mut() { - if !value.is_constant() { - let saved = std::mem::replace(value, Expr::undefined()); - *value = self.spill(saved, "field", out); - } - } - props.sort_by_key(|(key, _)| index(key)); - } - Expr::Object(props) + // A plain object's properties go in declaration order, so every value of the + // struct shares one shape. + _ => { + let args = self.declared(written, out).into_iter().map(|(_, v)| v).collect(); + self.t.construct(info.sym, &ctor, &fields, args) } } } @@ -2618,14 +2607,8 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } AdtRepr::Union => { let mut props = vec![(Key::Name("tag".into()), Expr::Str(variant.name.to_string()))]; - let mut ordered: Vec<(usize, Expr)> = adt - .fields - .iter() - .zip(values) - .map(|(f, value)| (f.name.index(), value)) - .collect(); - ordered.sort_by_key(|(i, _)| *i); - for (i, value) in ordered { + let written = adt.fields.iter().map(|f| f.name.index()).zip(values).collect(); + for (i, value) in self.declared(written, out) { let name = super::field_name(variant.fields[rustc_abi::FieldIdx::from_usize(i)].name.as_str(), i); props.push((Key::Name(name), value)); } diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index bf0fa0058..2ed2340ca 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -558,8 +558,9 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, let Args::Thir(ids) = args else { return None; }; - let s = b.operand(ids[0], out); - let (start, end) = range_bounds(b, ids[1], out)?; + let mut s = [b.operand(ids[0], out)]; + let (start, end) = range_bounds(b, &mut s, ids[1], out)?; + let [s] = s; let end = end.unwrap_or_else(|| s.clone().member("length")); let dest = b.operand(ids[2], out); Expr::Rt("slice").member("copyWithin").call(vec![s, start, end, dest]) @@ -684,7 +685,9 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Args<'_>, // A JS array has no views, so a mutable subslice would be a copy. return None; } - let (start, end) = range_bounds(b, ids[1], out)?; + let mut base = [base]; + let (start, end) = range_bounds(b, &mut base, ids[1], out)?; + let [base] = base; let mut values = vec![base, start]; values.extend(end); Expr::Rt("slice").member("range").call(values) @@ -966,7 +969,13 @@ fn path<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, base: &str, out: &mut Vec } /// The start and optional end of a range written in place: `a..b`, `..b`, `a..`, `..`. -fn range_bounds<'tcx>(b: &mut Body<'_, '_, 'tcx>, id: ExprId, out: &mut Vec) -> Option<(Expr, Option)> { +/// `earlier` are the operands evaluated before it, spilled if the range needs statements. +fn range_bounds<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + earlier: &mut [Expr], + id: ExprId, + out: &mut Vec, +) -> Option<(Expr, Option)> { let tcx = b.t.tcx; let written = id; let id = b.strip(id); @@ -981,11 +990,19 @@ fn range_bounds<'tcx>(b: &mut Body<'_, '_, 'tcx>, id: ExprId, out: &mut Vec = range.fields.iter().map(|f| (f.name.index(), f.expr)).collect(); - fields.sort_by_key(|(i, _)| *i); - let ids: Vec = fields.iter().map(|(_, id)| *id).collect(); + let ids: Vec = range.fields.iter().map(|f| f.expr).collect(); b.visit(written); - let mut values = b.operands(&ids, out); + let mut pre = Vec::new(); + let values = b.operands(&ids, &mut pre); + let values = range.fields.iter().map(|f| f.name.index()).zip(values).collect(); + let mut values: Vec = b.declared(values, &mut pre).into_iter().map(|(_, v)| v).collect(); + if !pre.is_empty() { + for value in earlier.iter_mut().filter(|v| !v.is_constant()) { + let saved = std::mem::replace(value, Expr::undefined()); + *value = b.spill(saved, "arg", out); + } + } + out.extend(pre); match name.as_str() { "Range" => { let end = values.pop()?;