[−][src]Struct rustc::infer::at::At
🔬 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".
Auto Trait Implementations
Blanket Implementations
impl<T> MaybeResult for T
[src]
impl<T> MaybeResult for T
fn from_ok(T) -> T
[src]
fn from_ok(T) -> T
🔬 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?
fn map_same<F>(Self, F) -> T where
F: FnOnce(T) -> T,
[src]
fn map_same<F>(Self, F) -> T where
F: FnOnce(T) -> T,
🔬 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?
impl<'a, T> Captures for T where
T: ?Sized,
[src]
impl<'a, T> Captures for T where
T: ?Sized,
impl<T> From for T
[src]
impl<T> From for T
impl<T, U> Into for T where
U: From<T>,
[src]
impl<T, U> Into for T where
U: From<T>,
impl<T, U> TryFrom for T where
T: From<U>,
[src]
impl<T, U> TryFrom for T where
T: From<U>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
try_from
)Performs the conversion.
impl<T> Borrow for T where
T: ?Sized,
[src]
impl<T> Borrow for T where
T: ?Sized,
ⓘImportant traits for &'a mut Rfn borrow(&self) -> &T
[src]
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
try_from
)Performs the conversion.
impl<T> BorrowMut for T where
T: ?Sized,
[src]
impl<T> BorrowMut for T where
T: ?Sized,
ⓘImportant traits for &'a mut Rfn borrow_mut(&mut self) -> &mut T
[src]
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Any for T where
T: 'static + ?Sized,
fn get_type_id(&self) -> TypeId
[src]
fn get_type_id(&self) -> TypeId
🔬 This is a nightly-only experimental API. (get_type_id
)
this method will likely be replaced by an associated static
Gets the TypeId
of self
. Read more
impl<E> SpecializationError for E
[src]
impl<E> SpecializationError for E
fn not_found<S, T>(trait_name: &'static str, method_name: &'static str) -> E where
T: ?Sized,
[src]
fn not_found<S, T>(trait_name: &'static str, method_name: &'static str) -> E where
T: ?Sized,
🔬 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?
Create an error for a missing method specialization. Defaults to panicking with type, trait & method names. S
is the encoder/decoder state type, T
is the type being encoded/decoded, and the arguments are the names of the trait and method that should've been overridden. Read more
impl<T> Erased for T
[src]
impl<T> Erased for T
impl<T> Send for T where
T: ?Sized,
[src]
impl<T> Send for T where
T: ?Sized,
impl<T> Sync for T where
T: ?Sized,
[src]
impl<T> Sync for T where
T: ?Sized,
impl<T> Erased for T
impl<T> Erased for T