mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ed5015939f
rust/src/test/run-pass/coherence-subtyping.rs

49 lines
1.3 KiB
Rust
Raw Normal View History

Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Test that two distinct impls which match subtypes of one another
// yield coherence errors (or not) depending on the variance.
trait Contravariant {
fn foo(&self) { }
}
make HR algorithms account for region subtyping Currently, we consider region subtyping a failure if a skolemized lifetime is relatable to any other lifetime in any way at all. But a more precise formulation is to say that a skolemized lifetime: - must not have any *incoming* edges in the region graph - only has *outgoing* edges to nodes that are `'static` To enforce the latter requirement, we add edges from `'static -> 'x` for each lifetime '`x' reachable from a skolemized region. We now have to add a new `pop_skolemized` routine to do cleanup. Whereas before if there were *any* edges relating to a skolemized region, we would return `Err` and hence rollback the transaction, we now tolerate some edges and return `Ok`. Therefore, the `pop_skolemized` routine runs and cleans up those edges.
2016-04-20 18:51:56 -05:00
impl Contravariant for for<'a,'b> fn(&'a u8, &'b u8) -> &'a u8 {
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
make HR algorithms account for region subtyping Currently, we consider region subtyping a failure if a skolemized lifetime is relatable to any other lifetime in any way at all. But a more precise formulation is to say that a skolemized lifetime: - must not have any *incoming* edges in the region graph - only has *outgoing* edges to nodes that are `'static` To enforce the latter requirement, we add edges from `'static -> 'x` for each lifetime '`x' reachable from a skolemized region. We now have to add a new `pop_skolemized` routine to do cleanup. Whereas before if there were *any* edges relating to a skolemized region, we would return `Err` and hence rollback the transaction, we now tolerate some edges and return `Ok`. Therefore, the `pop_skolemized` routine runs and cleans up those edges.
2016-04-20 18:51:56 -05:00
impl Contravariant for for<'a> fn(&'a u8, &'a u8) -> &'a u8 {
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
///////////////////////////////////////////////////////////////////////////
trait Covariant {
fn foo(&self) { }
}
make HR algorithms account for region subtyping Currently, we consider region subtyping a failure if a skolemized lifetime is relatable to any other lifetime in any way at all. But a more precise formulation is to say that a skolemized lifetime: - must not have any *incoming* edges in the region graph - only has *outgoing* edges to nodes that are `'static` To enforce the latter requirement, we add edges from `'static -> 'x` for each lifetime '`x' reachable from a skolemized region. We now have to add a new `pop_skolemized` routine to do cleanup. Whereas before if there were *any* edges relating to a skolemized region, we would return `Err` and hence rollback the transaction, we now tolerate some edges and return `Ok`. Therefore, the `pop_skolemized` routine runs and cleans up those edges.
2016-04-20 18:51:56 -05:00
impl Covariant for for<'a,'b> fn(&'a u8, &'b u8) -> &'a u8 {
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
make HR algorithms account for region subtyping Currently, we consider region subtyping a failure if a skolemized lifetime is relatable to any other lifetime in any way at all. But a more precise formulation is to say that a skolemized lifetime: - must not have any *incoming* edges in the region graph - only has *outgoing* edges to nodes that are `'static` To enforce the latter requirement, we add edges from `'static -> 'x` for each lifetime '`x' reachable from a skolemized region. We now have to add a new `pop_skolemized` routine to do cleanup. Whereas before if there were *any* edges relating to a skolemized region, we would return `Err` and hence rollback the transaction, we now tolerate some edges and return `Ok`. Therefore, the `pop_skolemized` routine runs and cleans up those edges.
2016-04-20 18:51:56 -05:00
impl Covariant for for<'a> fn(&'a u8, &'a u8) -> &'a u8 {
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
///////////////////////////////////////////////////////////////////////////
trait Invariant {
Fallout in tests
2015-03-31 18:58:01 -05:00
fn foo(&self) { }
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
make HR algorithms account for region subtyping Currently, we consider region subtyping a failure if a skolemized lifetime is relatable to any other lifetime in any way at all. But a more precise formulation is to say that a skolemized lifetime: - must not have any *incoming* edges in the region graph - only has *outgoing* edges to nodes that are `'static` To enforce the latter requirement, we add edges from `'static -> 'x` for each lifetime '`x' reachable from a skolemized region. We now have to add a new `pop_skolemized` routine to do cleanup. Whereas before if there were *any* edges relating to a skolemized region, we would return `Err` and hence rollback the transaction, we now tolerate some edges and return `Ok`. Therefore, the `pop_skolemized` routine runs and cleans up those edges.
2016-04-20 18:51:56 -05:00
impl Invariant for for<'a,'b> fn(&'a u8, &'b u8) -> &'a u8 {
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
make HR algorithms account for region subtyping Currently, we consider region subtyping a failure if a skolemized lifetime is relatable to any other lifetime in any way at all. But a more precise formulation is to say that a skolemized lifetime: - must not have any *incoming* edges in the region graph - only has *outgoing* edges to nodes that are `'static` To enforce the latter requirement, we add edges from `'static -> 'x` for each lifetime '`x' reachable from a skolemized region. We now have to add a new `pop_skolemized` routine to do cleanup. Whereas before if there were *any* edges relating to a skolemized region, we would return `Err` and hence rollback the transaction, we now tolerate some edges and return `Ok`. Therefore, the `pop_skolemized` routine runs and cleans up those edges.
2016-04-20 18:51:56 -05:00
impl Invariant for for<'a> fn(&'a u8, &'a u8) -> &'a u8 {
Extend coherence check to understand subtyping.
2015-02-12 11:42:02 -06:00
}
fn main() { }
Reference in New Issue Copy Permalink