Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Positive coverage: prove_predicate / forall

forall
LineCoverageSource
354(scope(enter_universally_with_constraints(decls, env, assumptions, binder) => (env, p1)) with(c)
(prove_predicate(decls, env, assumptions, p1) => c))
──────── ("forall")
3826(prove_predicate(decls, env, assumptions, Predicate::ForAll(binder)) => c)

26 tests exercised this rule:


Source location: crates/formality-rust/src/prove/test/binder_scope.rs:17 (all coverage from this test)

#[test]
fn outlives_every_lifetime() {
    test_prove_pending_outlives(Program::empty(), term("exists<'x> {} => {for<'a> 'x : 'a}"))
        .assert_ok(expect!["{Constraints { env: Env { variables: [?lt_1], bias: Soundness, pending: [?lt_1 : ' static], allow_pending_outlives: true }, known_true: true, substitution: {} }}"]);
}
Proof tree

Source location: crates/formality-rust/src/prove/test/binder_scope.rs:27 (all coverage from this test)

#[test]
fn outlives_every_lifetime_given_static() {
    test_prove_pending_outlives(
        Program::empty(),
        term("forall<'x> {'x : 'static} => {for<'a> 'x : 'a}"),
    )
    .assert_ok(expect!["{Constraints { env: Env { variables: [!lt_1], bias: Soundness, pending: [], allow_pending_outlives: true }, known_true: true, substitution: {} }, Constraints { env: Env { variables: [!lt_1], bias: Soundness, pending: [!lt_1 : ' static], allow_pending_outlives: true }, known_true: true, substitution: {} }}"]);
}
Proof tree

Source location: crates/formality-rust/src/prove/test/eq_assumptions.rs:15 (all coverage from this test)

#[test]
fn test_a() {
    test_prove(
        Program::empty(),
        term("{} => {for<T, U> if {T = u32, U = Vec<T>} U = Vec<u32>}"),
    )
    .assert_ok(expect!["{Constraints { env: Env { variables: [], bias: Soundness, pending: [], allow_pending_outlives: false }, known_true: true, substitution: {} }}"]);
}
Proof tree

Source location: crates/formality-rust/src/prove/test/eq_assumptions.rs:24 (all coverage from this test)

#[test]
fn test_b() {
    test_prove(
        Program::empty(),
        term("exists<A> {} => {for<T, U> if {T = u32, U = Vec<T>} A = U}"),
    )
    .assert_ok(expect!["{Constraints { env: Env { variables: [?ty_2, ?ty_1], bias: Soundness, pending: [], allow_pending_outlives: false }, known_true: true, substitution: {?ty_1 => Vec<u32>, ?ty_2 => u32} }}"]);
}
Proof tree

Source location: crates/formality-rust/src/prove/test/eq_assumptions.rs:33 (all coverage from this test)

#[test]
fn test_normalize_assoc_ty() {
    test_prove(
        Program::empty(),
        term("{} => {for<T> if { <T as Iterator>::Item = u32 } <T as Iterator>::Item = u32}"),
    )
    .assert_ok(expect!["{Constraints { env: Env { variables: [], bias: Soundness, pending: [], allow_pending_outlives: false }, known_true: true, substitution: {} }}"]);
}
Proof tree

Source location: crates/formality-rust/src/prove/test/eq_partial_eq.rs:25 (all coverage from this test)

#[test]
fn eq_implies_partial_eq() {
    let assumptions: Predicates = Predicates::t();
    let goal: Predicate = term("for<T> if {Eq(T)} PartialEq(T)");
    let constraints = prove(decls(), (), assumptions, goal);
    constraints.assert_ok(
    expect!["{Constraints { env: Env { variables: [], bias: Soundness, pending: [], allow_pending_outlives: false }, known_true: true, substitution: {} }}"]);
}
Proof tree

Source location: crates/formality-rust/src/prove/test/universes.rs:37 (all coverage from this test)

#[test]
fn for_t_exists_u() {
    let decls = Program {
        crates: Arc::new(Program::program_from_items(vec![
            term("trait Test<T> where {}"),
            term("impl<X> Test<X> for X {}"),
        ])),
        ..Program::empty()
    };

    test_prove(decls, term("{} => {for<T> Test(T, T)}")).assert_ok(expect!["{Constraints { env: Env { variables: [], bias: Soundness, pending: [], allow_pending_outlives: false }, known_true: true, substitution: {} }}"]);
}
Proof tree

Source location: tests/basic_tests.rs:74 (all coverage from this test)

#[test]
fn basic_where_clauses_pass() {
    FormalityTest::new(crates![crate core {
        #![feature(non_lifetime_binders)]
        trait A<T> where T: B { }

        trait B { }

        trait WellFormed where for<T> u32: A<T> { }

        impl <T> B for T {}
    }])
    .skip_execute()
    .ok()
}
Proof tree

Source location: tests/basic_tests.rs:121 (all coverage from this test)

fn foo() -> () where for<T> u32: A<T> { trusted }

impl <T> B for T {}
}])
p_execute()
)
}

#[test]
ifetime_binder_in_fn_where_clause_fail() {
alityTest::new(crates![crate core {
trait A<T> where T: B { }

trait B { }

fn foo() -> () where for<T> u32: A<T> { trusted }
}])
(expect_test::expect![[r#"
the rule "check crate" at (mod.rs) failed because
  non lifetime binders require #![feature(non_lifetime_binders)]"#]])
}

#[test]
ifetime_binder_in_trait_impl_where_clause_pass() {
alityTest::new(crates![crate core {
#![feature(non_lifetime_binders)]
trait A<T> where T: B { }

trait B { }

impl<T> B for T where for<U> u32: A<U> { }
}])
p_execute()
)
}

#[test]
ifetime_binder_in_trait_impl_where_clause_fail() {
alityTest::new(crates![crate core {
trait A<T> where T: B { }

trait B { }

impl<T> B for T where for<U> u32: A<U> { }
}])
(expect_test::expect![[r#"
the rule "check crate" at (mod.rs) failed because
  non lifetime binders require #![feature(non_lifetime_binders)]"#]])
}

#[test]
ifetime_binder_in_neg_trait_impl_where_clause_pass() {
alityTest::new(crates![crate core {
#![feature(non_lifetime_binders)]
trait A<T> where T: B { }

trait B { }

impl<T> !A<T> for u32 where for<U> u32: A<U> { }

impl <T> B for T {}
}])
p_execute()
)
}

#[test]
ifetime_binder_in_neg_trait_impl_where_clause_fail() {
alityTest::new(crates![crate core {
trait A<T> where T: B { }

trait B { }

impl<T> !A<T> for u32 where for<U> u32: A<U> { }
}])
(expect_test::expect![[r#"
the rule "check crate" at (mod.rs) failed because
  non lifetime binders require #![feature(non_lifetime_binders)]"#]])
}

#[test]
ifetime_binder_in_enum_where_clause_pass() {
alityTest::new(crates![crate core {
#![feature(non_lifetime_binders)]
trait A<T> where T: B { }

trait B { }

enum E where for<U> u32: A<U> { }

impl <T> B for T {}
}])
p_execute()
)
}

#[test]
ifetime_binder_in_enum_where_clause_fail() {
alityTest::new(crates![crate core {
trait A<T> where T: B { }

trait B { }

enum E where for<U> u32: A<U> { }
}])
(expect_test::expect![[r#"
the rule "check crate" at (mod.rs) failed because
  non lifetime binders require #![feature(non_lifetime_binders)]"#]])
}

#[test]
ifetime_binder_in_struct_where_clause_pass() {
alityTest::new(crates![crate core {
#![feature(non_lifetime_binders)]
trait A<T> where T: B { }

trait B { }

struct S<T> where for<U> u32: A<U> { }

impl <T> B for T {}
}])
p_execute()
)
}

#[test]
ifetime_binder_in_struct_where_clause_fail() {
alityTest::new(crates![crate core {
trait A<T> where T: B { }

trait B { }

struct S<T> where for<U> u32: A<U> { }
}])
(expect_test::expect![[r#"
the rule "check crate" at (mod.rs) failed because
  non lifetime binders require #![feature(non_lifetime_binders)]"#]])
}

#[test]
ime_binder_in_where_clause_without_feature_pass() {
alityTest::new(crates![crate core {
trait A<'b> { }

impl<'b> A<'b> for u32 { }

trait WellFormed where for<'b> u32: A<'b> { }
}])
p_execute()
)
}

#[test]
_adt_variant_dup() {
alityTest::new(crates![crate Foo {
enum Bar {
    Baz{},
    Baz{},
}
Proof tree

Source location: tests/basic_tests.rs:149 (all coverage from this test)

#[test]
fn non_lifetime_binder_in_trait_impl_where_clause_pass() {
    FormalityTest::new(crates![crate core {
        #![feature(non_lifetime_binders)]
        trait A<T> where T: B { }

        trait B { }

        impl<T> B for T where for<U> u32: A<U> { }
    }])
    .skip_execute()
    .ok()
}
Proof tree

Source location: tests/basic_tests.rs:179 (all coverage from this test)

#[test]
fn non_lifetime_binder_in_neg_trait_impl_where_clause_pass() {
    FormalityTest::new(crates![crate core {
        #![feature(non_lifetime_binders)]
        trait A<T> where T: B { }

        trait B { }

        impl<T> !A<T> for u32 where for<U> u32: A<U> { }

        impl <T> B for T {}
    }])
    .skip_execute()
    .ok()
}

Proof trees omitted for the remaining 16 tests; each one is on its test’s page in Coverage by test.


Source location: tests/basic_tests.rs:209 (all coverage from this test)

#[test]
fn non_lifetime_binder_in_enum_where_clause_pass() {
    FormalityTest::new(crates![crate core {
        #![feature(non_lifetime_binders)]
        trait A<T> where T: B { }

        trait B { }

        enum E where for<U> u32: A<U> { }

        impl <T> B for T {}
    }])
    .skip_execute()
    .ok()
}

Source location: tests/basic_tests.rs:239 (all coverage from this test)

#[test]
fn non_lifetime_binder_in_struct_where_clause_pass() {
    FormalityTest::new(crates![crate core {
        #![feature(non_lifetime_binders)]
        trait A<T> where T: B { }

        trait B { }

        struct S<T> where for<U> u32: A<U> { }

        impl <T> B for T {}
    }])
    .skip_execute()
    .ok()
}

Source location: tests/basic_tests.rs:266 (all coverage from this test)

#[test]
fn lifetime_binder_in_where_clause_without_feature_pass() {
    FormalityTest::new(crates![crate core {
        trait A<'b> { }

        impl<'b> A<'b> for u32 { }

        trait WellFormed where for<'b> u32: A<'b> { }
    }])
    .skip_execute()
    .ok()
}

Source location: tests/consts.rs:131 (all coverage from this test)

#[test]
fn nested_const_bound_accepts_outer_parameter() {
    FormalityTest::new(crates![crate Foo {
        trait Foo<const C> where for<'a> type_of_const C is bool {}
    }])
    .skip_execute()
    .ok()
}

Source location: tests/consts.rs:141 (all coverage from this test)

#[test]
fn nested_const_bound_accepts_inner_parameter() {
    FormalityTest::new(crates![crate Foo {
        #![feature(non_lifetime_binders)]
        trait Foo where for<const C> type_of_const C is bool {}
    }])
    .skip_execute()
    .ok()
}

Source location: tests/higher_ranked_where_clauses.rs:12 (all coverage from this test)

fn foo<T>() -> () where for<'a> T: Trait<'a> {}
}])
p_execute()
tc_ok()
);
}

#[test]
ait_bound_at_body_lifetime() {
alityTest::new(crates![crate Foo {
trait Trait<'a> {}
fn needs_one<'x, T>() -> () where T: Trait<'x> {}
fn foo<T>() -> () where for<'a> T: Trait<'a> {
    exists<'r> {
        needs_one::<'r, T>();
    }
}

Source location: tests/higher_ranked_where_clauses.rs:28 (all coverage from this test)

fn foo<T>() -> () where for<'a> T: Trait<'a> {
    exists<'r> {
        needs_one::<'r, T>();
    }
}

Source location: tests/higher_ranked_where_clauses.rs:42 (all coverage from this test)

fn foo<'b, T>() -> () where for<'a> T: Trait<'a> {
    needs_one::<'b, T>();
}

Source location: tests/higher_ranked_where_clauses.rs:56 (all coverage from this test)

fn foo<T>() -> () where for<'a> T: Trait<'a> {
    needs_all::<T>();
}

Source location: tests/higher_ranked_where_clauses.rs:118 (all coverage from this test)

fn foo<T>() -> u32 where for<'a> T: Trait<'a> {
    let v: u32 = 1_u32;
    exists<'r> {
        let r: &'r u32 = first::<'r, T>(&'r v);
        let n: u32 = *r;
        v = 2_u32;
        return n;
    }
}

Source location: tests/higher_ranked_where_clauses.rs:176 (all coverage from this test)

fn foo<T>() -> () where for<'a> T: 'a {
    needs_static::<T>();
}

Source location: tests/higher_ranked_where_clauses.rs:189 (all coverage from this test)

fn foo<'x, T>() -> () where for<'a> T: 'a {
    needs_one::<'x, T>();
}

Source location: tests/higher_ranked_where_clauses.rs:202 (all coverage from this test)

fn foo<T>() -> () where for<'a> T: 'a {
    needs_all::<T>();
}

Source location: tests/mir_typeck.rs:2160 (all coverage from this test)

fn main() -> () {
    let v0: u32 = 0_u32;
    exists<'r> {
        let v1: &'r u32 = &'r v0;
        needs_all::<&'r u32>(v1);
        v0 = 1_u32;
    }
}

Source location: tests/mir_typeck.rs:2176 (all coverage from this test)

fn caller<'x>(v: &'x u32) -> () where 'x: 'static {
    needs_all::<&'x u32>(v);
}

How to read this page