}
pub fn resolve_closure(
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- def_id: DefId,
- substs: ty::ClosureSubsts<'tcx>,
- requested_kind: ty::ClosureKind)
- -> Instance<'tcx>
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ def_id: DefId,
+ substs: ty::ClosureSubsts<'tcx>,
+ requested_kind: ty::ClosureKind)
+ -> Instance<'tcx>
{
let actual_kind = substs.closure_kind(def_id, tcx);
) -> Option<Instance<'tcx>> {
let def_id = trait_item.def_id;
debug!("resolve_associated_item(trait_item={:?}, \
- trait_id={:?}, \
- rcvr_substs={:?})",
+ trait_id={:?}, \
+ rcvr_substs={:?})",
def_id, trait_id, rcvr_substs);
let trait_ref = ty::TraitRef::from_method(tcx, trait_id, rcvr_substs);
traits::VtableClosure(closure_data) => {
let trait_closure_kind = tcx.lang_items().fn_trait_kind(trait_id).unwrap();
Some(Instance::resolve_closure(tcx, closure_data.closure_def_id, closure_data.substs,
- trait_closure_kind))
+ trait_closure_kind))
}
traits::VtableFnPointer(ref data) => {
Some(Instance {
}
fn needs_fn_once_adapter_shim<'a, 'tcx>(actual_closure_kind: ty::ClosureKind,
- trait_closure_kind: ty::ClosureKind)
+ trait_closure_kind: ty::ClosureKind)
-> Result<bool, ()>
{
match (actual_closure_kind, trait_closure_kind) {
}
fn fn_once_adapter_instance<'a, 'tcx>(
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- closure_did: DefId,
- substs: ty::ClosureSubsts<'tcx>,
- ) -> Instance<'tcx> {
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ closure_did: DefId,
+ substs: ty::ClosureSubsts<'tcx>)
+ -> Instance<'tcx>
+{
debug!("fn_once_adapter_shim({:?}, {:?})",
- closure_did,
- substs);
+ closure_did,
+ substs);
let fn_once = tcx.lang_items().fn_once_trait().unwrap();
let call_once = tcx.associated_items(fn_once)
.find(|it| it.kind == ty::AssociatedKind::Method)
let data = cur_def_key.disambiguated_data.data;
let symbol = data.get_opt_name().map(|n| n.as_str()).unwrap_or_else(|| {
- if let DefPathData::CrateRoot = data { // reexported `extern crate` (#43189)
+ if let DefPathData::CrateRoot = data { // reexported `extern crate` (#43189)
self.original_crate_name(cur_def.krate).as_str()
} else {
Symbol::intern("<unnamed>").as_str()
if let Some(trait_ref) = impl_trait_ref {
// Trait impls.
- buffer.push(&format!("<{} as {}>",
- self_ty,
- trait_ref));
+ buffer.push(&format!("<{} as {}>", self_ty, trait_ref));
return;
}
fn to_ty<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, signed: bool) -> Ty<'tcx>;
fn from_attr<C: HasDataLayout>(cx: C, ity: attr::IntType) -> Integer;
fn repr_discr<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- ty: Ty<'tcx>,
- repr: &ReprOptions,
- min: i128,
- max: i128)
- -> (Integer, bool);
+ ty: Ty<'tcx>,
+ repr: &ReprOptions,
+ min: i128,
+ max: i128)
+ -> (Integer, bool);
}
impl IntegerExt for Integer {
/// N.B.: u128 values above i128::MAX will be treated as signed, but
/// that shouldn't affect anything, other than maybe debuginfo.
fn repr_discr<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- ty: Ty<'tcx>,
- repr: &ReprOptions,
- min: i128,
- max: i128)
- -> (Integer, bool) {
+ ty: Ty<'tcx>,
+ repr: &ReprOptions,
+ min: i128,
+ max: i128)
+ -> (Integer, bool) {
// Theoretically, negative values could be larger in unsigned representation
// than the unsigned representation of the signed minimum. However, if there
// are any negative values, the only valid unsigned representation is u128
let fit = if ity.is_signed() { signed_fit } else { unsigned_fit };
if discr < fit {
bug!("Integer::repr_discr: `#[repr]` hint too small for \
- discriminant range of enum `{}", ty)
+ discriminant range of enum `{}", ty)
}
return (discr, ity.is_signed());
}
// WARNING: the ARM EABI has two variants; the one corresponding
// to `at_least == I32` appears to be used on Linux and NetBSD,
// but some systems may use the variant corresponding to no
- // lower bound. However, we don't run on those yet...?
+ // lower bound. However, we don't run on those yet...?
"arm" => min_from_extern = Some(I32),
_ => min_from_extern = Some(I32),
}
/// A univariant, but with a prefix of an arbitrary size & alignment (e.g. enum tag).
Prefixed(Size, Align),
}
+
let univariant_uninterned = |fields: &[TyLayout<'_>], repr: &ReprOptions, kind| {
let packed = repr.packed();
if packed && repr.align > 0 {
let field = fields[i as usize];
if !sized {
bug!("univariant: field #{} of `{}` comes after unsized field",
- offsets.len(), ty);
+ offsets.len(), ty);
}
if field.is_unsized() {
};
univariant(&tys.iter().map(|ty| self.layout_of(ty)).collect::<Result<Vec<_>, _>>()?,
- &ReprOptions::default(), kind)?
+ &ReprOptions::default(), kind)?
}
// SIMD vector types.
Abi::Scalar(ref scalar) => scalar.clone(),
_ => {
tcx.sess.fatal(&format!("monomorphising SIMD type `{}` with \
- a non-machine element type `{}`",
+ a non-machine element type `{}`",
ty, element.ty));
}
};
// Only one variant is present.
(present_second.is_none() &&
// Representation optimizations are allowed.
- !def.repr.inhibit_enum_layout_opt());
+ !def.repr.inhibit_enum_layout_opt());
if is_struct {
// Struct, or univariant enum equivalent to a struct.
// (Typechecking will reject discriminant-sizing attrs.)
let param_env = tcx.param_env(def.did);
let last_field = def.variants[v].fields.last().unwrap();
let always_sized = tcx.type_of(last_field.did)
- .is_sized(tcx.at(DUMMY_SP), param_env);
+ .is_sized(tcx.at(DUMMY_SP), param_env);
if !always_sized { StructKind::MaybeUnsized }
else { StructKind::AlwaysSized }
};
let fields: Vec<_> =
variant_def.fields.iter().map(|f| f.ident.name).collect();
build_variant_info(Some(variant_def.name),
- &fields,
- layout.for_variant(self, i))
+ &fields,
+ layout.for_variant(self, i))
})
.collect();
record(adt_kind.into(), adt_packed, match layout.variants {
}
} else {
tcx.generics_of(self.parent.expect("parent_count>0 but no parent?"))
- .region_param(param, tcx)
+ .region_param(param, tcx)
}
}
}
} else {
tcx.generics_of(self.parent.expect("parent_count>0 but no parent?"))
- .type_param(param, tcx)
+ .type_param(param, tcx)
}
}
}
if !expr_did.is_local() {
span_bug!(tcx.def_span(expr_did),
"variant discriminant evaluation succeeded \
- in its crate but failed locally");
+ in its crate but failed locally");
}
None
}
debug!("sized_constraint_for_ty({:?}) intermediate = {:?}",
ty, adt_tys);
adt_tys.iter()
- .map(|ty| ty.subst(tcx, substs))
- .flat_map(|ty| self.sized_constraint_for_ty(tcx, ty))
- .collect()
+ .map(|ty| ty.subst(tcx, substs))
+ .flat_map(|ty| self.sized_constraint_for_ty(tcx, ty))
+ .collect()
}
Projection(..) | Opaque(..) => {
}
}
-fn associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
- -> AssociatedItem
-{
+fn associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> AssociatedItem {
let id = tcx.hir.as_local_node_id(def_id).unwrap();
let parent_id = tcx.hir.get_parent(id);
let parent_def_id = tcx.hir.local_def_id(parent_id);
/// See `ParamEnv` struct def'n for details.
fn param_env<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
- -> ParamEnv<'tcx> {
-
+ -> ParamEnv<'tcx>
+{
// The param_env of an impl Trait type is its defining function's param_env
if let Some(parent) = is_impl_trait_defn(tcx, def_id) {
return param_env(tcx, parent);
// projection).
match ty.sty {
ty::Closure(def_id, ref substs) => {
-
for upvar_ty in substs.upvar_tys(def_id, *self) {
self.compute_components(upvar_ty, out);
}
if a.len() != b.len() {
Err(TypeError::ProjectionBoundsLength(expected_found(relation, &a.len(), &b.len())))
} else {
- a.iter().zip(b)
- .map(|(a, b)| relation.relate(a, b))
- .collect()
+ a.iter()
+ .zip(b)
+ .map(|(a, b)| relation.relate(a, b))
+ .collect()
}
}
}
type Lifted = ty::GenSig<'tcx>;
fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
tcx.lift(&(self.yield_ty, self.return_ty))
- .map(|(yield_ty, return_ty)| {
- ty::GenSig {
- yield_ty,
- return_ty,
- }
- })
+ .map(|(yield_ty, return_ty)| {
+ ty::GenSig {
+ yield_ty,
+ return_ty,
+ }
+ })
}
}
CyclicTy(t) => return tcx.lift(&t).map(|t| CyclicTy(t)),
ProjectionMismatched(x) => ProjectionMismatched(x),
ProjectionBoundsLength(x) => ProjectionBoundsLength(x),
-
Sorts(ref x) => return tcx.lift(x).map(Sorts),
OldStyleLUB(ref x) => return tcx.lift(x).map(OldStyleLUB),
ExistentialMismatch(ref x) => return tcx.lift(x).map(ExistentialMismatch)
pub trait Subst<'tcx> : Sized {
fn subst<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>,
- substs: &[Kind<'tcx>]) -> Self {
+ substs: &[Kind<'tcx>]) -> Self {
self.subst_spanned(tcx, substs, None)
}
span_bug!(
span,
"Type parameter `{:?}` ({:?}/{}) out of range \
- when substituting (root type={:?}) substs={:?}",
+ when substituting (root type={:?}) substs={:?}",
p,
source_ty,
p.idx,
fast_reject::simplify_type(tcx, impl_self_ty, false)
{
impls.non_blanket_impls
- .entry(simplified_self_ty)
- .or_default()
- .push(impl_def_id);
+ .entry(simplified_self_ty)
+ .or_default()
+ .push(impl_def_id);
} else {
impls.blanket_impls.push(impl_def_id);
}
impl IntTypeExt for attr::IntType {
fn to_ty<'a, 'gcx, 'tcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
match *self {
- SignedInt(ast::IntTy::I8) => tcx.types.i8,
- SignedInt(ast::IntTy::I16) => tcx.types.i16,
- SignedInt(ast::IntTy::I32) => tcx.types.i32,
- SignedInt(ast::IntTy::I64) => tcx.types.i64,
+ SignedInt(ast::IntTy::I8) => tcx.types.i8,
+ SignedInt(ast::IntTy::I16) => tcx.types.i16,
+ SignedInt(ast::IntTy::I32) => tcx.types.i32,
+ SignedInt(ast::IntTy::I64) => tcx.types.i64,
SignedInt(ast::IntTy::I128) => tcx.types.i128,
- SignedInt(ast::IntTy::Isize) => tcx.types.isize,
+ SignedInt(ast::IntTy::Isize) => tcx.types.isize,
UnsignedInt(ast::UintTy::U8) => tcx.types.u8,
UnsignedInt(ast::UintTy::U16) => tcx.types.u16,
UnsignedInt(ast::UintTy::U32) => tcx.types.u32,
UnsignedInt(ast::UintTy::U64) => tcx.types.u64,
- UnsignedInt(ast::UintTy::U128) => tcx.types.u128,
+ UnsignedInt(ast::UintTy::U128) => tcx.types.u128,
UnsignedInt(ast::UintTy::Usize) => tcx.types.usize,
}
}
false
}
}
- }).map(|(&item_param, _)| item_param).collect();
+ })
+ .map(|(&item_param, _)| item_param)
+ .collect();
debug!("destructor_constraint({:?}) = {:?}", def.did, result);
result
}
pub fn is_representable(&'tcx self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
sp: Span)
- -> Representability {
-
+ -> Representability
+ {
// Iterate until something non-representable is found
fn fold_repr<It: Iterator<Item=Representability>>(iter: It) -> Representability {
iter.fold(Representability::Representable, |r1, r2| {
let predicate = ty::Predicate::ConstEvaluatable(def_id, substs);
let cause = self.cause(traits::MiscObligation);
self.out.push(traits::Obligation::new(cause,
- self.param_env,
- predicate));
+ self.param_env,
+ predicate));
}
}