Struct rustc::infer::at::At [−][src]
pub struct At<'a, 'gcx: 'tcx, 'tcx: 'a> { pub infcx: &'a InferCtxt<'a, 'gcx, 'tcx>, pub cause: &'a ObligationCause<'tcx>, pub param_env: ParamEnv<'tcx>, }
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Fields
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
cause: &'a ObligationCause<'tcx>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
param_env: ParamEnv<'tcx>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Methods
impl<'a, 'gcx, 'tcx> At<'a, 'gcx, 'tcx>
[src]
impl<'a, 'gcx, 'tcx> At<'a, 'gcx, 'tcx>
pub fn eq_impl_headers(
self,
expected: &ImplHeader<'tcx>,
actual: &ImplHeader<'tcx>
) -> InferResult<'tcx, ()>
[src]
pub fn eq_impl_headers(
self,
expected: &ImplHeader<'tcx>,
actual: &ImplHeader<'tcx>
) -> InferResult<'tcx, ()>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Hacky routine for equating two impl headers in coherence.
pub fn sub_exp<T>(
self,
a_is_expected: bool,
a: T,
b: T
) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
[src]
pub fn sub_exp<T>(
self,
a_is_expected: bool,
a: T,
b: T
) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Make a <: b
where a
may or may not be expected
pub fn sup<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
[src]
pub fn sup<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Make actual <: expected
. For example, if type-checking a
call like foo(x)
, where foo: fn(i32)
, you might have
sup(i32, x)
, since the "expected" type is the type that
appears in the signature.
pub fn sub<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
[src]
pub fn sub<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Make expected <: actual
pub fn eq_exp<T>(self, a_is_expected: bool, a: T, b: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
[src]
pub fn eq_exp<T>(self, a_is_expected: bool, a: T, b: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Make expected <: actual
pub fn eq<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
[src]
pub fn eq<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Make expected <: actual
pub fn lub<T>(self, expected: T, actual: T) -> InferResult<'tcx, T> where
T: ToTrace<'tcx>,
[src]
pub fn lub<T>(self, expected: T, actual: T) -> InferResult<'tcx, T> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Compute the least-upper-bound, or mutual supertype, of two values. The order of the arguments doesn't matter, but since this can result in an error (e.g., if asked to compute LUB of u32 and i32), it is meaningful to call one of them the "expected type".
pub fn glb<T>(self, expected: T, actual: T) -> InferResult<'tcx, T> where
T: ToTrace<'tcx>,
[src]
pub fn glb<T>(self, expected: T, actual: T) -> InferResult<'tcx, T> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Compute the greatest-lower-bound, or mutual subtype, of two
values. As with lub
order doesn't matter, except for error
cases.
pub fn trace<T>(self, expected: T, actual: T) -> Trace<'a, 'gcx, 'tcx> where
T: ToTrace<'tcx>,
[src]
pub fn trace<T>(self, expected: T, actual: T) -> Trace<'a, 'gcx, 'tcx> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Sets the "trace" values that will be used for error-reporting, but doesn't actually perform any operation yet (this is useful when you want to set the trace using distinct values from those you wish to operate upon).
pub fn trace_exp<T>(
self,
a_is_expected: bool,
a: T,
b: T
) -> Trace<'a, 'gcx, 'tcx> where
T: ToTrace<'tcx>,
[src]
pub fn trace_exp<T>(
self,
a_is_expected: bool,
a: T,
b: T
) -> Trace<'a, 'gcx, 'tcx> where
T: ToTrace<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Like trace
, but the expected value is determined by the
boolean argument (if true, then the first argument a
is the
"expected" value).
impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx>
[src]
impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx>
pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<Kind<'tcx>>>
[src]
pub fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<Kind<'tcx>>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Given a type ty
of some value being dropped, computes a set
of "kinds" (types, regions) that must be outlive the execution
of the destructor. These basically correspond to data that the
destructor might access. This is used during regionck to
impose "outlives" constraints on any lifetimes referenced
within.
The rules here are given by the "dropck" RFCs, notably #1238
and #1327. This is a fixed-point computation, where we
explore all the data that will be dropped (transitively) when
a value of type ty
is dropped. For each type T that will be
dropped and which has a destructor, we must assume that all
the types/regions of T are live during the destructor, unless
they are marked with a special attribute (#[may_dangle]
).
impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx>
[src]
impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx>
pub fn normalize<T>(&self, value: &T) -> Result<Normalized<'tcx, T>, NoSolution> where
T: TypeFoldable<'tcx>,
[src]
pub fn normalize<T>(&self, value: &T) -> Result<Normalized<'tcx, T>, NoSolution> where
T: TypeFoldable<'tcx>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Normalize value
in the context of the inference context,
yielding a resulting type, or an error if value
cannot be
normalized. If you don't care about regions, you should prefer
normalize_erasing_regions
, which is more efficient.
If the normalization succeeds and is unambiguous, returns back the normalized value along with various outlives relations (in the form of obligations that must be discharged).
NB. This will eventually be the main means of normalizing, but for now should be used only when we actually know that normalization will succeed, since error reporting and other details are still "under development".