b22a714840
The JIT that runs makepad apps from source: lexer, front end, type checker, lazy borrow checker (Gandalf; `--check-first` opts in), codegen, session and warm/cold caches keyed by compiler stamp, provided crates bound late, startup images, live patching. User-facing name is `makepad run` (binary `makepad`, MAKEPAD_RUN_* env, ~/.makepad-run); libs/relax stays the internal library name. `makepad check` reports rustc-style diagnostics with rustc error codes and checks a whole workspace (`--workspace`). Runs on macOS, Linux, Windows and Android. makepad-remote: one tool schema for apps and the WM (app/1): grabs, captures, traces, frame profiles and tweaks. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
98 lines
3.6 KiB
Rust
98 lines
3.6 KiB
Rust
// rustc tests/ui CRASH groups (frontend): reduced repros, each named after its suite file
|
|
use std::cell::Cell;
|
|
use std::rc::Rc;
|
|
|
|
// binding/match-ref-unsized: `let ref a = *"abc"` borrows the place (let's initializer is a
|
|
// place expression context)
|
|
#[test]
|
|
fn ref_binding_of_unsized_place() {
|
|
let ref a = *"abcdef";
|
|
assert_eq!(a, "abcdef");
|
|
let s: &str = "xy";
|
|
let ref d = *s;
|
|
assert_eq!(d.len(), 2);
|
|
}
|
|
|
|
// unsized-locals/box-fnonce: `&s as &str` is a coercion cast (deref coercion)
|
|
#[test]
|
|
fn coercion_cast_deref() {
|
|
fn call_it<T>(f: Box<dyn FnOnce() -> T>) -> T { f() }
|
|
let s = "hello".to_owned();
|
|
assert_eq!(&call_it(Box::new(|| s)) as &str, "hello");
|
|
let t = String::from("ab");
|
|
assert_eq!((&t as &str).len(), 2);
|
|
}
|
|
|
|
// macros/assert-ne-macro-unsized: `*l != *r` on slices is PartialEq; `&vec![..][..]` extends
|
|
// the Vec temporary (lifetime extension through the indexed operand)
|
|
#[test]
|
|
fn unsized_compare_and_index_extension() {
|
|
let l: &[i32] = &[6, 6, 6];
|
|
let r: &[i32] = &[1, 2, 3];
|
|
assert!(*l != *r);
|
|
assert!(!(*l == *r));
|
|
let y = &vec![1, 2, 3][..];
|
|
assert_eq!(y, &[1, 2, 3]);
|
|
assert_ne!([6, 6, 6][..], vec![1, 2, 3][..]);
|
|
assert!(*"ab" == *"ab");
|
|
}
|
|
|
|
// consts/control-flow/short-circuit-let: a diverging `&&` / `||` operand
|
|
#[test]
|
|
fn lazy_op_diverging_operand() {
|
|
fn truthy() -> bool { let x = true || return false; x }
|
|
fn falsy() -> bool { let x = true && return false; x }
|
|
assert!(truthy() && !falsy());
|
|
}
|
|
|
|
// deref/dereferenceable-type-behavior-22992: `*x` on a Deref type in a value context, and
|
|
// the probe's by-value step on `&&X` / autoref step on `&&A`
|
|
#[test]
|
|
fn explicit_deref_and_probe_steps() {
|
|
struct X { val: i32 }
|
|
impl std::ops::Deref for X { type Target = i32; fn deref(&self) -> &i32 { &self.val } }
|
|
trait M { fn m(self) -> u32; }
|
|
impl M for i32 { fn m(self) -> u32 { 1 } }
|
|
impl M for X { fn m(self) -> u32 { 2 } }
|
|
impl<'a> M for &'a X { fn m(self) -> u32 { 3 } }
|
|
trait RefM { fn refm(&self) -> u32; }
|
|
impl RefM for X { fn refm(&self) -> u32 { 10 } }
|
|
impl<'a> RefM for &'a X { fn refm(&self) -> u32 { 11 } }
|
|
impl<'a, 'b> RefM for &'a &'b X { fn refm(&self) -> u32 { 12 } }
|
|
#[derive(Clone, Copy)]
|
|
struct A;
|
|
impl M for A { fn m(self) -> u32 { 20 } }
|
|
impl<'a, 'b, 'c> M for &'a &'b &'c A { fn m(self) -> u32 { 21 } }
|
|
assert_eq!((*X { val: 42 }).m(), 1);
|
|
let x = X { val: 7 };
|
|
assert_eq!(*x + 1, 8);
|
|
assert_eq!((&X { val: 1 }).m(), 3);
|
|
assert_eq!((&&X { val: 1 }).refm(), 11);
|
|
assert_eq!((&&&X { val: 1 }).refm(), 12);
|
|
assert_eq!((&A).m(), 20);
|
|
assert_eq!((&&A).m(), 21);
|
|
}
|
|
|
|
// moves/match-move-same-binding-15571, closures/2229 move_closure: a derived Copy needs its
|
|
// type params Copy (Option<Box<T>> is not Copy), pattern moves and nested move closures
|
|
// consume captures, closures called through `&mut` live in memory
|
|
#[test]
|
|
fn closure_captures_by_value() {
|
|
let c = Rc::new(Cell::new(0));
|
|
struct D(Rc<Cell<u32>>);
|
|
impl Drop for D { fn drop(&mut self) { self.0.set(self.0.get() + 1) } }
|
|
let foo: Option<Box<D>> = Some(Box::new(D(c.clone())));
|
|
let f = move || { match foo { None => {}, Some(x) => drop(x) } };
|
|
f();
|
|
assert_eq!(c.get(), 1);
|
|
let mut s = (String::from("s"), 1u8);
|
|
let mut g = move || { s.0 = "x".into(); s.0.len() };
|
|
assert_eq!(g(), 1);
|
|
assert_eq!(g(), 1);
|
|
let mut t = (String::from("a"), 0u8);
|
|
let outer = || { let mut inner = move || { t.0.push('b'); t.0.len() }; inner() };
|
|
assert_eq!(outer(), 2);
|
|
let o: Option<Box<u8>> = Some(Box::new(3));
|
|
let h = move || o;
|
|
assert_eq!(*h().unwrap(), 3);
|
|
}
|