{
let item_doc = lookup_item(id, cdata.data());
reader::maybe_get_doc(item_doc, tag_item_trait_ref).map(|tp| {
- Rc::new(ty::bind(doc_trait_ref(tp, tcx, cdata)))
+ Rc::new(ty::Binder(doc_trait_ref(tp, tcx, cdata)))
})
}
let name = item_name(&*intr, item);
let (ctor_ty, arg_tys, arg_names) = match ctor_ty.sty {
ty::ty_bare_fn(ref f) =>
- (Some(ctor_ty), f.sig.inputs.clone(), None),
+ (Some(ctor_ty), f.sig.0.inputs.clone(), None),
_ => { // Nullary or struct enum variant.
let mut arg_names = Vec::new();
let arg_tys = get_struct_fields(intr.clone(), cdata, did.node)
}
'x' => {
assert_eq!(next(st), '[');
- let trait_ref = ty::bind(parse_trait_ref(st, |x,y| conv(x,y)));
+ let trait_ref = ty::Binder(parse_trait_ref(st, |x,y| conv(x,y)));
let bounds = parse_existential_bounds(st, |x,y| conv(x,y));
assert_eq!(next(st), ']');
return ty::mk_trait(st.tcx, trait_ref, bounds);
}
}
-fn parse_sig<'a, 'tcx>(st: &mut PState<'a, 'tcx>, conv: conv_did) -> ty::FnSig<'tcx> {
+fn parse_sig<'a, 'tcx>(st: &mut PState<'a, 'tcx>, conv: conv_did) -> ty::PolyFnSig<'tcx> {
assert_eq!(next(st), '[');
let mut inputs = Vec::new();
while peek(st) != ']' {
}
_ => ty::FnConverging(parse_ty(st, |x,y| conv(x,y)))
};
- ty::FnSig {inputs: inputs,
- output: output,
- variadic: variadic}
+ ty::Binder(ty::FnSig {inputs: inputs,
+ output: output,
+ variadic: variadic})
}
// Rust metadata parsing
-> ty::Predicate<'tcx>
{
match next(st) {
- 't' => ty::Predicate::Trait(Rc::new(ty::bind(parse_trait_ref(st, conv)))),
+ 't' => ty::Predicate::Trait(Rc::new(ty::Binder(parse_trait_ref(st, conv)))),
'e' => ty::Predicate::Equate(parse_ty(st, |x,y| conv(x,y)),
parse_ty(st, |x,y| conv(x,y))),
'r' => ty::Predicate::RegionOutlives(parse_region(st, |x,y| conv(x,y)),
}
'I' => {
param_bounds.trait_bounds.push(
- Rc::new(ty::bind(parse_trait_ref(st, |x,y| conv(x,y)))));
+ Rc::new(ty::Binder(parse_trait_ref(st, |x,y| conv(x,y)))));
}
'.' => {
return param_bounds;
ty::ty_trait(box ty::TyTrait { ref principal,
ref bounds }) => {
mywrite!(w, "x[");
- enc_trait_ref(w, cx, &principal.value);
+ enc_trait_ref(w, cx, &principal.0);
enc_existential_bounds(w, cx, bounds);
mywrite!(w, "]");
}
}
fn enc_fn_sig<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>,
- fsig: &ty::FnSig<'tcx>) {
+ fsig: &ty::PolyFnSig<'tcx>) {
mywrite!(w, "[");
- for ty in fsig.inputs.iter() {
+ for ty in fsig.0.inputs.iter() {
enc_ty(w, cx, *ty);
}
mywrite!(w, "]");
- if fsig.variadic {
+ if fsig.0.variadic {
mywrite!(w, "V");
} else {
mywrite!(w, "N");
}
- match fsig.output {
+ match fsig.0.output {
ty::FnConverging(result_type) => {
enc_ty(w, cx, result_type);
}
for tp in bs.trait_bounds.iter() {
mywrite!(w, "I");
- enc_trait_ref(w, cx, &tp.value);
+ enc_trait_ref(w, cx, &tp.0);
}
mywrite!(w, ".");
match *p {
ty::Predicate::Trait(ref trait_ref) => {
mywrite!(w, "t");
- enc_trait_ref(w, cx, &trait_ref.value);
+ enc_trait_ref(w, cx, &trait_ref.0);
}
ty::Predicate::Equate(a, b) => {
mywrite!(w, "e");
this.emit_enum_variant("MethodTypeParam", 2, 1, |this| {
this.emit_struct("MethodParam", 2, |this| {
try!(this.emit_struct_field("trait_ref", 0, |this| {
- Ok(this.emit_trait_ref(ecx, &p.trait_ref.value))
+ Ok(this.emit_trait_ref(ecx, &p.trait_ref.0))
}));
try!(this.emit_struct_field("method_num", 0, |this| {
this.emit_uint(p.method_num)
this.emit_enum_variant("MethodTraitObject", 3, 1, |this| {
this.emit_struct("MethodObject", 2, |this| {
try!(this.emit_struct_field("trait_ref", 0, |this| {
- Ok(this.emit_trait_ref(ecx, &o.trait_ref.value))
+ Ok(this.emit_trait_ref(ecx, &o.trait_ref.0))
}));
try!(this.emit_struct_field("object_trait_id", 0, |this| {
Ok(this.emit_def_id(o.object_trait_id))
this.emit_enum_variant("UnsizeVtable", 2, 4, |this| {
this.emit_enum_variant_arg(0, |this| {
try!(this.emit_struct_field("principal", 0, |this| {
- Ok(this.emit_trait_ref(ecx, &principal.value))
+ Ok(this.emit_trait_ref(ecx, &principal.0))
}));
this.emit_struct_field("bounds", 1, |this| {
Ok(this.emit_existential_bounds(ecx, b))
rbml_w.tag(c::tag_table_object_cast_map, |rbml_w| {
rbml_w.id(id);
rbml_w.tag(c::tag_table_val, |rbml_w| {
- rbml_w.emit_trait_ref(ecx, &trait_ref.value);
+ rbml_w.emit_trait_ref(ecx, &trait_ref.0);
})
})
}
fn read_poly_trait_ref<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
-> Rc<ty::PolyTraitRef<'tcx>> {
- Rc::new(ty::bind(self.read_opaque(|this, doc| {
+ Rc::new(ty::Binder(self.read_opaque(|this, doc| {
let ty = tydecode::parse_trait_ref_data(
doc.data,
dcx.cdata.cnum,
}
Some(ref trait_ref) => (*trait_ref).clone(),
};
- OverloadedCallType::from_trait_id(tcx, trait_ref.value.def_id)
+ OverloadedCallType::from_trait_id(tcx, trait_ref.def_id())
}
fn from_unboxed_closure(tcx: &ty::ctxt, closure_did: ast::DefId)
ty::ty_vec(..) => Some(VecSimplifiedType),
ty::ty_ptr(_) => Some(PtrSimplifiedType),
ty::ty_trait(ref trait_info) => {
- Some(TraitSimplifiedType(trait_info.principal.value.def_id))
+ Some(TraitSimplifiedType(trait_info.principal.def_id()))
}
ty::ty_struct(def_id, _) => {
Some(StructSimplifiedType(def_id))
Some(TupleSimplifiedType(tys.len()))
}
ty::ty_closure(ref f) => {
- Some(FunctionSimplifiedType(f.sig.inputs.len()))
+ Some(FunctionSimplifiedType(f.sig.0.inputs.len()))
}
ty::ty_bare_fn(ref f) => {
- Some(FunctionSimplifiedType(f.sig.inputs.len()))
+ Some(FunctionSimplifiedType(f.sig.0.inputs.len()))
}
ty::ty_param(_) => {
if can_simplify_params {
b: &ty::BareFnTy<'tcx>) -> cres<'tcx, ty::BareFnTy<'tcx>> {
let unsafety = try!(self.unsafeties(a.unsafety, b.unsafety));
let abi = try!(self.abi(a.abi, b.abi));
- let sig = try!(self.fn_sigs(&a.sig, &b.sig));
+ let sig = try!(self.binders(&a.sig, &b.sig));
Ok(ty::BareFnTy {unsafety: unsafety,
abi: abi,
sig: sig})
let unsafety = try!(self.unsafeties(a.unsafety, b.unsafety));
let onceness = try!(self.oncenesses(a.onceness, b.onceness));
let bounds = try!(self.existential_bounds(a.bounds, b.bounds));
- let sig = try!(self.fn_sigs(&a.sig, &b.sig));
+ let sig = try!(self.binders(&a.sig, &b.sig));
let abi = try!(self.abi(a.abi, b.abi));
Ok(ty::ClosureTy {
unsafety: unsafety,
})
}
- fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>) -> cres<'tcx, ty::FnSig<'tcx>>;
+ fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>) -> cres<'tcx, ty::FnSig<'tcx>> {
+ if a.variadic != b.variadic {
+ return Err(ty::terr_variadic_mismatch(expected_found(self, a.variadic, b.variadic)));
+ }
+
+ let inputs = try!(argvecs(self,
+ a.inputs.as_slice(),
+ b.inputs.as_slice()));
+
+ let output = try!(match (a.output, b.output) {
+ (ty::FnConverging(a_ty), ty::FnConverging(b_ty)) =>
+ Ok(ty::FnConverging(try!(self.tys(a_ty, b_ty)))),
+ (ty::FnDiverging, ty::FnDiverging) =>
+ Ok(ty::FnDiverging),
+ (a, b) =>
+ Err(ty::terr_convergence_mismatch(
+ expected_found(self, a != ty::FnDiverging, b != ty::FnDiverging))),
+ });
+
+ return Ok(ty::FnSig {inputs: inputs,
+ output: output,
+ variadic: a.variadic});
+
+
+ fn argvecs<'tcx, C: Combine<'tcx>>(combiner: &C,
+ a_args: &[Ty<'tcx>],
+ b_args: &[Ty<'tcx>])
+ -> cres<'tcx, Vec<Ty<'tcx>>>
+ {
+ if a_args.len() == b_args.len() {
+ a_args.iter().zip(b_args.iter())
+ .map(|(a, b)| combiner.args(*a, *b)).collect()
+ } else {
+ Err(ty::terr_arg_count)
+ }
+ }
+ }
fn args(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> cres<'tcx, Ty<'tcx>> {
self.contratys(a, b).and_then(|t| Ok(t))
}
}
- fn poly_trait_refs(&self,
- a: &ty::PolyTraitRef<'tcx>,
- b: &ty::PolyTraitRef<'tcx>)
- -> cres<'tcx, ty::PolyTraitRef<'tcx>>;
+ fn binders<T>(&self, a: &ty::Binder<T>, b: &ty::Binder<T>) -> cres<'tcx, ty::Binder<T>>
+ where T : Combineable<'tcx>;
// this must be overridden to do correctly, so as to account for higher-ranked
// behavior
}
+pub trait Combineable<'tcx> : Repr<'tcx> + TypeFoldable<'tcx> {
+ fn combine<C:Combine<'tcx>>(combiner: &C, a: &Self, b: &Self) -> cres<'tcx, Self>;
+}
+
+impl<'tcx> Combineable<'tcx> for ty::TraitRef<'tcx> {
+ fn combine<C:Combine<'tcx>>(combiner: &C,
+ a: &ty::TraitRef<'tcx>,
+ b: &ty::TraitRef<'tcx>)
+ -> cres<'tcx, ty::TraitRef<'tcx>>
+ {
+ combiner.trait_refs(a, b)
+ }
+}
+
+impl<'tcx> Combineable<'tcx> for ty::FnSig<'tcx> {
+ fn combine<C:Combine<'tcx>>(combiner: &C,
+ a: &ty::FnSig<'tcx>,
+ b: &ty::FnSig<'tcx>)
+ -> cres<'tcx, ty::FnSig<'tcx>>
+ {
+ combiner.fn_sigs(a, b)
+ }
+}
+
#[deriving(Clone)]
pub struct CombineFields<'a, 'tcx: 'a> {
pub infcx: &'a InferCtxt<'a, 'tcx>,
(&ty::ty_trait(ref a_),
&ty::ty_trait(ref b_)) => {
debug!("Trying to match traits {} and {}", a, b);
- let principal = try!(this.poly_trait_refs(&a_.principal, &b_.principal));
+ let principal = try!(this.binders(&a_.principal, &b_.principal));
let bounds = try!(this.existential_bounds(a_.bounds, b_.bounds));
Ok(ty::mk_trait(tcx, principal, bounds))
}
}
}
- fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>)
- -> cres<'tcx, ty::FnSig<'tcx>>
+ fn binders<T>(&self, a: &ty::Binder<T>, b: &ty::Binder<T>) -> cres<'tcx, ty::Binder<T>>
+ where T : Combineable<'tcx>
{
- try!(self.sub().fn_sigs(a, b));
- self.sub().fn_sigs(b, a)
- }
-
- fn poly_trait_refs(&self, a: &ty::PolyTraitRef<'tcx>, b: &ty::PolyTraitRef<'tcx>)
- -> cres<'tcx, ty::PolyTraitRef<'tcx>>
- {
- try!(self.sub().poly_trait_refs(a, b));
- self.sub().poly_trait_refs(b, a)
+ try!(self.sub().binders(a, b));
+ self.sub().binders(b, a)
}
}
Rc::new(infcx.resolve_type_vars_if_possible(&**self))
}
fn contains_error(&self) -> bool {
- ty::trait_ref_contains_error(&self.value)
+ ty::trait_ref_contains_error(&self.0)
}
}
super_lattice_tys(self, a, b)
}
- fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>)
- -> cres<'tcx, ty::FnSig<'tcx>> {
- self.higher_ranked_glb(a, b)
- }
-
- fn poly_trait_refs(&self, a: &ty::PolyTraitRef<'tcx>, b: &ty::PolyTraitRef<'tcx>)
- -> cres<'tcx, ty::PolyTraitRef<'tcx>> {
+ fn binders<T>(&self, a: &ty::Binder<T>, b: &ty::Binder<T>) -> cres<'tcx, ty::Binder<T>>
+ where T : Combineable<'tcx>
+ {
self.higher_ranked_glb(a, b)
}
}
//! Helper routines for higher-ranked things. See the `doc` module at
//! the end of the file for details.
-use super::{combine, CombinedSnapshot, cres, InferCtxt, HigherRankedType};
-use super::combine::Combine;
+use super::{CombinedSnapshot, cres, InferCtxt, HigherRankedType};
+use super::combine::{Combine, Combineable};
-use middle::ty::{mod, Ty, replace_late_bound_regions};
-use middle::ty_fold::{mod, HigherRankedFoldable, TypeFoldable};
+use middle::ty::{mod, Binder};
+use middle::ty_fold::{mod, TypeFoldable};
use syntax::codemap::Span;
use util::nodemap::{FnvHashMap, FnvHashSet};
-use util::ppaux::{bound_region_to_string, Repr};
-
-pub trait HigherRankedCombineable<'tcx>: HigherRankedFoldable<'tcx> +
- TypeFoldable<'tcx> + Repr<'tcx> {
- fn super_combine<C:Combine<'tcx>>(combiner: &C, a: &Self, b: &Self) -> cres<'tcx, Self>;
-}
+use util::ppaux::Repr;
pub trait HigherRankedRelations<'tcx> {
- fn higher_ranked_sub<T>(&self, a: &T, b: &T) -> cres<'tcx, T>
- where T : HigherRankedCombineable<'tcx>;
+ fn higher_ranked_sub<T>(&self, a: &Binder<T>, b: &Binder<T>) -> cres<'tcx, Binder<T>>
+ where T : Combineable<'tcx>;
- fn higher_ranked_lub<T>(&self, a: &T, b: &T) -> cres<'tcx, T>
- where T : HigherRankedCombineable<'tcx>;
+ fn higher_ranked_lub<T>(&self, a: &Binder<T>, b: &Binder<T>) -> cres<'tcx, Binder<T>>
+ where T : Combineable<'tcx>;
- fn higher_ranked_glb<T>(&self, a: &T, b: &T) -> cres<'tcx, T>
- where T : HigherRankedCombineable<'tcx>;
+ fn higher_ranked_glb<T>(&self, a: &Binder<T>, b: &Binder<T>) -> cres<'tcx, Binder<T>>
+ where T : Combineable<'tcx>;
}
trait InferCtxtExt<'tcx> {
impl<'tcx,C> HigherRankedRelations<'tcx> for C
where C : Combine<'tcx>
{
- fn higher_ranked_sub<T>(&self, a: &T, b: &T) -> cres<'tcx, T>
- where T : HigherRankedCombineable<'tcx>
+ fn higher_ranked_sub<T>(&self, a: &Binder<T>, b: &Binder<T>)
+ -> cres<'tcx, Binder<T>>
+ where T : Combineable<'tcx>
{
debug!("higher_ranked_sub(a={}, b={})",
a.repr(self.tcx()), b.repr(self.tcx()));
// Second, we instantiate each bound region in the supertype with a
// fresh concrete region.
- let (b_prime, skol_map) = skolemize_regions(self.infcx(), b, snapshot);
+ let (b_prime, skol_map) =
+ self.infcx().skolemize_late_bound_regions(b, snapshot);
debug!("a_prime={}", a_prime.repr(self.tcx()));
debug!("b_prime={}", b_prime.repr(self.tcx()));
// Compare types now that bound regions have been replaced.
- let result = try!(HigherRankedCombineable::super_combine(self, &a_prime, &b_prime));
+ let result = try!(Combineable::combine(self, &a_prime, &b_prime));
// Presuming type comparison succeeds, we need to check
// that the skolemized regions do not "leak".
debug!("higher_ranked_sub: OK result={}",
result.repr(self.tcx()));
- Ok(result)
+ Ok(ty::Binder(result))
});
}
- fn higher_ranked_lub<T>(&self, a: &T, b: &T) -> cres<'tcx, T>
- where T : HigherRankedCombineable<'tcx>
+ fn higher_ranked_lub<T>(&self, a: &Binder<T>, b: &Binder<T>) -> cres<'tcx, Binder<T>>
+ where T : Combineable<'tcx>
{
// Start a snapshot so we can examine "all bindings that were
// created as part of this type comparison".
// Collect constraints.
let result0 =
- try!(HigherRankedCombineable::super_combine(self, &a_with_fresh, &b_with_fresh));
+ try!(Combineable::combine(self, &a_with_fresh, &b_with_fresh));
let result0 =
self.infcx().resolve_type_vars_if_possible(&result0);
debug!("lub result0 = {}", result0.repr(self.tcx()));
b.repr(self.tcx()),
result1.repr(self.tcx()));
- Ok(result1)
+ Ok(ty::Binder(result1))
});
fn generalize_region(infcx: &InferCtxt,
}
}
- fn higher_ranked_glb<T>(&self, a: &T, b: &T) -> cres<'tcx, T>
- where T : HigherRankedCombineable<'tcx>
+ fn higher_ranked_glb<T>(&self, a: &Binder<T>, b: &Binder<T>) -> cres<'tcx, Binder<T>>
+ where T : Combineable<'tcx>
{
debug!("{}.higher_ranked_glb({}, {})",
self.tag(), a.repr(self.tcx()), b.repr(self.tcx()));
// Collect constraints.
let result0 =
- try!(HigherRankedCombineable::super_combine(self, &a_with_fresh, &b_with_fresh));
+ try!(Combineable::combine(self, &a_with_fresh, &b_with_fresh));
let result0 =
self.infcx().resolve_type_vars_if_possible(&result0);
debug!("glb result0 = {}", result0.repr(self.tcx()));
b.repr(self.tcx()),
result1.repr(self.tcx()));
- Ok(result1)
+ Ok(ty::Binder(result1))
});
fn generalize_region(infcx: &InferCtxt,
}
}
-impl<'tcx> HigherRankedCombineable<'tcx> for ty::FnSig<'tcx> {
- fn super_combine<C:Combine<'tcx>>(combiner: &C, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>)
- -> cres<'tcx, ty::FnSig<'tcx>>
- {
- if a.variadic != b.variadic {
- return Err(ty::terr_variadic_mismatch(
- combine::expected_found(combiner, a.variadic, b.variadic)));
- }
-
- let inputs = try!(argvecs(combiner,
- a.inputs.as_slice(),
- b.inputs.as_slice()));
-
- let output = try!(match (a.output, b.output) {
- (ty::FnConverging(a_ty), ty::FnConverging(b_ty)) =>
- Ok(ty::FnConverging(try!(combiner.tys(a_ty, b_ty)))),
- (ty::FnDiverging, ty::FnDiverging) =>
- Ok(ty::FnDiverging),
- (a, b) =>
- Err(ty::terr_convergence_mismatch(
- combine::expected_found(combiner, a != ty::FnDiverging, b != ty::FnDiverging))),
- });
-
- return Ok(ty::FnSig {inputs: inputs,
- output: output,
- variadic: a.variadic});
-
-
- fn argvecs<'tcx, C: Combine<'tcx>>(combiner: &C,
- a_args: &[Ty<'tcx>],
- b_args: &[Ty<'tcx>])
- -> cres<'tcx, Vec<Ty<'tcx>>>
- {
- if a_args.len() == b_args.len() {
- a_args.iter().zip(b_args.iter())
- .map(|(a, b)| combiner.args(*a, *b)).collect()
- } else {
- Err(ty::terr_arg_count)
- }
- }
- }
-}
-
-impl<'tcx> HigherRankedCombineable<'tcx> for ty::PolyTraitRef<'tcx> {
- fn super_combine<C:Combine<'tcx>>(combiner: &C,
- a: &ty::PolyTraitRef<'tcx>,
- b: &ty::PolyTraitRef<'tcx>)
- -> cres<'tcx, ty::PolyTraitRef<'tcx>>
- {
- Ok(ty::bind(try!(combiner.trait_refs(&a.value, &b.value))))
- }
-}
-
fn var_ids<'tcx, T: Combine<'tcx>>(combiner: &T,
map: &FnvHashMap<ty::BoundRegion, ty::Region>)
-> Vec<ty::RegionVid> {
}
}
-fn fold_regions_in<'tcx, T, F>(tcx: &ty::ctxt<'tcx>, value: &T, mut fldr: F) -> T where
- T: HigherRankedFoldable<'tcx>,
- F: FnMut(ty::Region, ty::DebruijnIndex) -> ty::Region,
+fn fold_regions_in<'tcx, T, F>(tcx: &ty::ctxt<'tcx>,
+ unbound_value: &T,
+ mut fldr: F)
+ -> T
+ where T : Combineable<'tcx>,
+ F : FnMut(ty::Region, ty::DebruijnIndex) -> ty::Region,
{
- value.fold_contents(&mut ty_fold::RegionFolder::new(tcx, |region, current_depth| {
+ unbound_value.fold_with(&mut ty_fold::RegionFolder::new(tcx, |region, current_depth| {
// we should only be encountering "escaping" late-bound regions here,
// because the ones at the current level should have been replaced
// with fresh variables
}
}
-fn skolemize_regions<'a,'tcx,HR>(infcx: &InferCtxt<'a,'tcx>,
- value: &HR,
- snapshot: &CombinedSnapshot)
- -> (HR, FnvHashMap<ty::BoundRegion,ty::Region>)
- where HR : HigherRankedFoldable<'tcx>
-{
- replace_late_bound_regions(infcx.tcx, value, |br, _| {
- let skol =
- infcx.region_vars.new_skolemized(
- br,
- &snapshot.region_vars_snapshot);
-
- debug!("Bound region {} skolemized to {}",
- bound_region_to_string(infcx.tcx, "", false, br),
- skol);
-
- skol
- })
-}
-
fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
skol_map: &FnvHashMap<ty::BoundRegion,ty::Region>,
snapshot: &CombinedSnapshot)
Ok(self.infcx().region_vars.lub_regions(Subtype(self.trace()), a, b))
}
- fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>)
- -> cres<'tcx, ty::FnSig<'tcx>> {
- self.higher_ranked_lub(a, b)
- }
-
fn tys(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> cres<'tcx, Ty<'tcx>> {
super_lattice_tys(self, a, b)
}
- fn poly_trait_refs(&self, a: &ty::PolyTraitRef<'tcx>, b: &ty::PolyTraitRef<'tcx>)
- -> cres<'tcx, ty::PolyTraitRef<'tcx>> {
+ fn binders<T>(&self, a: &ty::Binder<T>, b: &ty::Binder<T>) -> cres<'tcx, ty::Binder<T>>
+ where T : Combineable<'tcx>
+ {
self.higher_ranked_lub(a, b)
}
}
use middle::ty::{TyVid, IntVid, FloatVid, RegionVid};
use middle::ty::replace_late_bound_regions;
use middle::ty::{mod, Ty};
-use middle::ty_fold::{HigherRankedFoldable, TypeFolder, TypeFoldable};
+use middle::ty_fold::{TypeFolder, TypeFoldable};
use std::cell::{RefCell};
use std::rc::Rc;
use syntax::ast;
use util::common::indent;
use util::nodemap::FnvHashMap;
use util::ppaux::{ty_to_string};
-use util::ppaux::{trait_ref_to_string, Repr};
+use util::ppaux::{Repr, UserString};
use self::coercion::Coerce;
use self::combine::{Combine, CombineFields};
values: TraitRefs(expected_found(a_is_expected,
a.clone(), b.clone()))
};
- self.sub(a_is_expected, trace).poly_trait_refs(&*a, &*b).to_ures()
+ self.sub(a_is_expected, trace).binders(&*a, &*b).to_ures()
})
}
- pub fn skolemize_bound_regions<T>(&self,
- value: &ty::Binder<T>,
- snapshot: &CombinedSnapshot)
- -> (T, SkolemizationMap)
- where T : TypeFoldable<'tcx>
+ pub fn skolemize_late_bound_regions<T>(&self,
+ value: &ty::Binder<T>,
+ snapshot: &CombinedSnapshot)
+ -> (T, SkolemizationMap)
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
{
- let (result_binder, map) = replace_late_bound_regions(self.tcx, value, |br, _| {
+ let (result, map) = replace_late_bound_regions(self.tcx, value, |br, _| {
self.region_vars.new_skolemized(br, &snapshot.region_vars_snapshot)
});
debug!("skolemize_bound_regions(value={}, result={}, map={})",
value.repr(self.tcx),
- result_binder.value.repr(self.tcx),
+ result.repr(self.tcx),
map.repr(self.tcx));
- (result_binder.value, map)
+ (result, map)
}
pub fn next_ty_var_id(&self, diverging: bool) -> TyVid {
pub fn trait_ref_to_string(&self, t: &Rc<ty::TraitRef<'tcx>>) -> String {
let t = self.resolve_type_vars_if_possible(&**t);
- trait_ref_to_string(self.tcx, &t)
+ t.user_string(self.tcx)
}
pub fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> {
&self,
span: Span,
lbrct: LateBoundRegionConversionTime,
- value: &T)
+ value: &ty::Binder<T>)
-> (T, FnvHashMap<ty::BoundRegion,ty::Region>)
- where T : HigherRankedFoldable<'tcx>
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
{
ty::replace_late_bound_regions(
self.tcx,
}
}
- fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>)
- -> cres<'tcx, ty::FnSig<'tcx>> {
- self.higher_ranked_sub(a, b)
- }
-
- fn poly_trait_refs(&self, a: &ty::PolyTraitRef<'tcx>, b: &ty::PolyTraitRef<'tcx>)
- -> cres<'tcx, ty::PolyTraitRef<'tcx>> {
+ fn binders<T>(&self, a: &ty::Binder<T>, b: &ty::Binder<T>) -> cres<'tcx, ty::Binder<T>>
+ where T : Combineable<'tcx>
+ {
self.higher_ranked_sub(a, b)
}
}
let typ = ty::node_id_to_type(self.tcx, expr.id);
match typ.sty {
ty_bare_fn(ref bare_fn_ty) if bare_fn_ty.abi == RustIntrinsic => {
- if let ty::FnConverging(to) = bare_fn_ty.sig.output {
- let from = bare_fn_ty.sig.inputs[0];
+ if let ty::FnConverging(to) = bare_fn_ty.sig.0.output {
+ let from = bare_fn_ty.sig.0.inputs[0];
self.check_transmute(expr.span, from, to, expr.id);
}
}
.unwrap()
.closure_type
.sig
+ .0
.output,
_ => ty::ty_fn_ret(fn_ty)
}
};
let tr = ty::impl_trait_ref(self.tcx, local_def(item.id));
let public_trait = tr.clone().map_or(false, |tr| {
- !is_local(tr.value.def_id) ||
- self.exported_items.contains(&tr.value.def_id.node)
+ !is_local(tr.def_id()) ||
+ self.exported_items.contains(&tr.def_id().node)
});
if public_ty || public_trait {
match ty::impl_trait_ref(self.tcx, id) {
Some(t) => {
debug!("privacy - impl of trait {}", id);
- self.def_privacy(t.value.def_id)
+ self.def_privacy(t.def_id())
}
None => {
debug!("privacy - found a method {}",
match ty::impl_trait_ref(self.tcx, id) {
Some(t) => {
debug!("privacy - impl of trait {}", id);
- self.def_privacy(t.value.def_id)
+ self.def_privacy(t.def_id())
}
None => {
debug!("privacy - found a typedef {}",
use middle::subst::Subst;
use middle::ty::{mod, Ty};
use middle::infer::{mod, InferCtxt};
+use std::rc::Rc;
use syntax::ast;
use syntax::codemap::DUMMY_SP;
use util::ppaux::Repr;
let impl1_trait_ref =
infcx.replace_late_bound_regions_with_fresh_var(DUMMY_SP,
infer::FnCall,
- &impl1_trait_ref).0;
+ &*impl1_trait_ref).0;
// Determine whether `impl2` can provide an implementation for those
// same types.
let param_env = ty::empty_parameter_environment();
let mut selcx = SelectionContext::intercrate(infcx, ¶m_env, infcx.tcx);
- let obligation = Obligation::new(ObligationCause::dummy(), impl1_trait_ref);
+ let obligation = Obligation::new(ObligationCause::dummy(),
+ Rc::new(ty::Binder(impl1_trait_ref)));
debug!("impl_can_satisfy(obligation={})", obligation.repr(infcx.tcx));
selcx.evaluate_impl(impl2_def_id, &obligation)
}
debug!("trait_ref={}", trait_ref.repr(tcx));
// If the trait is local to the crate, ok.
- if trait_ref.value.def_id.krate == ast::LOCAL_CRATE {
+ if trait_ref.def_id().krate == ast::LOCAL_CRATE {
debug!("trait {} is local to current crate",
- trait_ref.value.def_id.repr(tcx));
+ trait_ref.def_id().repr(tcx));
return true;
}
// Otherwise, at least one of the input types must be local to the
// crate.
- trait_ref.value.input_types().iter().any(|&t| ty_is_local(tcx, t))
+ trait_ref.0.input_types().iter().any(|&t| ty_is_local(tcx, t))
}
pub fn ty_is_local<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
}
ty::ty_trait(ref tt) => {
- tt.principal.value.def_id.krate == ast::LOCAL_CRATE
+ tt.principal.def_id().krate == ast::LOCAL_CRATE
}
// Type parameters may be bound to types that are not local to
// This suffices to allow chains like `FnMut` implemented in
// terms of `Fn` etc, but we could probably make this more
// precise still.
- let input_types = stack.fresh_trait_ref.value.input_types();
+ let input_types = stack.fresh_trait_ref.0.input_types();
let unbound_input_types = input_types.iter().any(|&t| ty::type_is_fresh(t));
if
unbound_input_types &&
(self.intercrate ||
stack.iter().skip(1).any(
- |prev| stack.fresh_trait_ref.value.def_id == prev.fresh_trait_ref.value.def_id))
+ |prev| stack.fresh_trait_ref.def_id() == prev.fresh_trait_ref.def_id()))
{
debug!("evaluate_stack({}) --> unbound argument, recursion --> ambiguous",
stack.fresh_trait_ref.repr(self.tcx()));
// If the trait refers to any parameters in scope, then use
// the cache of the param-environment.
if
- cache_fresh_trait_ref.value.input_types().iter().any(
+ cache_fresh_trait_ref.0.input_types().iter().any(
|&t| ty::type_has_self(t) || ty::type_has_params(t))
{
return &self.param_env.selection_cache;
// See the discussion in doc.rs for more details.
if
!self.param_env.caller_bounds.is_empty() &&
- cache_fresh_trait_ref.value.input_types().iter().any(
+ cache_fresh_trait_ref.0.input_types().iter().any(
|&t| ty::type_has_ty_infer(t))
{
return &self.param_env.selection_cache;
// Other bounds. Consider both in-scope bounds from fn decl
// and applicable impls. There is a certain set of precedence rules here.
- match self.tcx().lang_items.to_builtin_kind(obligation.trait_ref.value.def_id) {
+ match self.tcx().lang_items.to_builtin_kind(obligation.trait_ref.def_id()) {
Some(ty::BoundCopy) => {
debug!("obligation self ty is {}",
obligation.self_ty().repr(self.tcx()));
candidates: &mut CandidateSet<'tcx>)
-> Result<(),SelectionError<'tcx>>
{
- let kind = match self.fn_family_trait_kind(obligation.trait_ref.value.def_id) {
+ let kind = match self.fn_family_trait_kind(obligation.trait_ref.def_id()) {
Some(k) => k,
None => { return Ok(()); }
};
// We provide a `Fn` impl for fn pointers. There is no need to provide
// the other traits (e.g. `FnMut`) since those are provided by blanket
// impls.
- if Some(obligation.trait_ref.value.def_id) != self.tcx().lang_items.fn_trait() {
+ if Some(obligation.trait_ref.def_id()) != self.tcx().lang_items.fn_trait() {
return Ok(());
}
ty::ty_bare_fn(ty::BareFnTy {
unsafety: ast::Unsafety::Normal,
abi: abi::Rust,
- sig: ty::FnSig {
+ sig: ty::Binder(ty::FnSig {
inputs: _,
output: ty::FnConverging(_),
variadic: false
- }
+ })
}) => {
candidates.vec.push(FnPointerCandidate);
}
candidates: &mut CandidateSet<'tcx>)
-> Result<(), SelectionError<'tcx>>
{
- let all_impls = self.all_impls(obligation.trait_ref.value.def_id);
+ let all_impls = self.all_impls(obligation.trait_ref.def_id());
for &impl_def_id in all_impls.iter() {
self.infcx.probe(|| {
match self.match_impl(impl_def_id, obligation) {
// bounds are required and thus we must fulfill.
let tmp_tr = data.principal_trait_ref_with_self_ty(ty::mk_err());
for tr in util::supertraits(self.tcx(), tmp_tr) {
- let td = ty::lookup_trait_def(self.tcx(), tr.value.def_id);
+ let td = ty::lookup_trait_def(self.tcx(), tr.def_id());
if td.bounds.builtin_bounds.contains(&bound) {
return Ok(If(Vec::new()))
}
};
- let arguments_tuple = ty::mk_tup(self.tcx(), sig.inputs.to_vec());
- let output_type = sig.output.unwrap();
+ let arguments_tuple = ty::mk_tup(self.tcx(), sig.0.inputs.to_vec());
+ let output_type = sig.0.output.unwrap();
let substs =
Substs::new_trait(
vec![arguments_tuple, output_type],
vec![],
vec![],
self_ty);
- let trait_ref = Rc::new(ty::bind(ty::TraitRef {
+ let trait_ref = Rc::new(ty::Binder(ty::TraitRef {
def_id: obligation.trait_ref.def_id(),
substs: substs,
}));
};
let closure_sig = &closure_type.sig;
- let arguments_tuple = closure_sig.inputs[0];
+ let arguments_tuple = closure_sig.0.inputs[0];
let substs =
Substs::new_trait(
vec![arguments_tuple.subst(self.tcx(), substs),
- closure_sig.output.unwrap().subst(self.tcx(), substs)],
+ closure_sig.0.output.unwrap().subst(self.tcx(), substs)],
vec![],
vec![],
obligation.self_ty());
- let trait_ref = Rc::new(ty::bind(ty::TraitRef {
+ let trait_ref = Rc::new(ty::Binder(ty::TraitRef {
def_id: obligation.trait_ref.def_id(),
substs: substs,
}));
{
match tcx.lang_items.from_builtin_kind(builtin_bound) {
Ok(def_id) => {
- Ok(Rc::new(ty::bind(ty::TraitRef {
+ Ok(Rc::new(ty::Binder(ty::TraitRef {
def_id: def_id,
substs: Substs::empty().with_self_ty(param_ty)
})))
use middle::traits::ObligationCause;
use middle::traits;
use middle::ty;
-use middle::ty_fold::{mod, TypeFoldable, TypeFolder, HigherRankedFoldable};
+use middle::ty_fold::{mod, TypeFoldable, TypeFolder};
use util::ppaux::{note_and_explain_region, bound_region_ptr_to_string};
use util::ppaux::{trait_store_to_string, ty_to_string};
use util::ppaux::{Repr, UserString};
pub struct BareFnTy<'tcx> {
pub unsafety: ast::Unsafety,
pub abi: abi::Abi,
- pub sig: FnSig<'tcx>,
+ pub sig: PolyFnSig<'tcx>,
}
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub onceness: ast::Onceness,
pub store: TraitStore,
pub bounds: ExistentialBounds,
- pub sig: FnSig<'tcx>,
+ pub sig: PolyFnSig<'tcx>,
pub abi: abi::Abi,
}
/// - `inputs` is the list of arguments and their modes.
/// - `output` is the return type.
/// - `variadic` indicates whether this is a varidic function. (only true for foreign fns)
-///
-/// Note that a `FnSig` introduces a level of region binding, to
-/// account for late-bound parameters that appear in the types of the
-/// fn's arguments or the fn's return type.
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct FnSig<'tcx> {
pub inputs: Vec<Ty<'tcx>>,
pub variadic: bool
}
+pub type PolyFnSig<'tcx> = Binder<FnSig<'tcx>>;
+
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub struct ParamTy {
pub space: subst::ParamSpace,
/// you must give *some* self-type. A common choice is `mk_err()`
/// or some skolemized type.
pub fn principal_trait_ref_with_self_ty(&self, self_ty: Ty<'tcx>) -> Rc<ty::PolyTraitRef<'tcx>> {
- Rc::new(ty::bind(ty::TraitRef {
- def_id: self.principal.value.def_id,
- substs: self.principal.value.substs.with_self_ty(self_ty),
+ Rc::new(ty::Binder(ty::TraitRef {
+ def_id: self.principal.def_id(),
+ substs: self.principal.substs().with_self_ty(self_ty),
}))
}
}
impl<'tcx> PolyTraitRef<'tcx> {
pub fn self_ty(&self) -> Ty<'tcx> {
- self.value.self_ty()
+ self.0.self_ty()
}
pub fn def_id(&self) -> ast::DefId {
- self.value.def_id
+ self.0.def_id
}
pub fn substs(&self) -> &Substs<'tcx> {
- &self.value.substs
+ &self.0.substs
}
pub fn input_types(&self) -> &[Ty<'tcx>] {
- self.value.input_types()
+ self.0.input_types()
}
}
/// by the binder supplied to it; but a type is not a binder, so you
/// must introduce an artificial one).
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
-pub struct Binder<T> {
- pub value: T
-}
-
-pub fn bind<T>(value: T) -> Binder<T> {
- Binder { value: value }
-}
+pub struct Binder<T>(pub T);
#[deriving(Clone, PartialEq)]
pub enum IntVarValue {
}
}
- fn add_fn_sig(&mut self, fn_sig: &FnSig) {
+ fn add_fn_sig(&mut self, fn_sig: &PolyFnSig) {
let mut computation = FlagComputation::new();
- computation.add_tys(fn_sig.inputs[]);
+ computation.add_tys(fn_sig.0.inputs[]);
- if let ty::FnConverging(output) = fn_sig.output {
+ if let ty::FnConverging(output) = fn_sig.0.output {
computation.add_ty(output);
}
BareFnTy {
unsafety: ast::Unsafety::Normal,
abi: abi::Rust,
- sig: FnSig {
+ sig: ty::Binder(FnSig {
inputs: input_args,
output: ty::FnConverging(output),
variadic: false
- }
+ })
})
}
}
ty_tup(ref ts) => { for tt in ts.iter() { maybe_walk_ty(*tt, |x| f(x)); } }
ty_bare_fn(ref ft) => {
- for a in ft.sig.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
- if let ty::FnConverging(output) = ft.sig.output {
+ for a in ft.sig.0.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
+ if let ty::FnConverging(output) = ft.sig.0.output {
maybe_walk_ty(output, f);
}
}
ty_closure(ref ft) => {
- for a in ft.sig.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
- if let ty::FnConverging(output) = ft.sig.output {
+ for a in ft.sig.0.inputs.iter() { maybe_walk_ty(*a, |x| f(x)); }
+ if let ty::FnConverging(output) = ft.sig.0.output {
maybe_walk_ty(output, f);
}
}
pub fn fn_is_variadic(fty: Ty) -> bool {
match fty.sty {
- ty_bare_fn(ref f) => f.sig.variadic,
- ty_closure(ref f) => f.sig.variadic,
+ ty_bare_fn(ref f) => f.sig.0.variadic,
+ ty_closure(ref f) => f.sig.0.variadic,
ref s => {
panic!("fn_is_variadic() called on non-fn type: {}", s)
}
}
}
-pub fn ty_fn_sig<'tcx>(fty: Ty<'tcx>) -> &'tcx FnSig<'tcx> {
+pub fn ty_fn_sig<'tcx>(fty: Ty<'tcx>) -> &'tcx PolyFnSig<'tcx> {
match fty.sty {
ty_bare_fn(ref f) => &f.sig,
ty_closure(ref f) => &f.sig,
// Type accessors for substructures of types
pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> &'tcx [Ty<'tcx>] {
- ty_fn_sig(fty).inputs.as_slice()
+ ty_fn_sig(fty).0.inputs.as_slice()
}
pub fn ty_closure_store(fty: Ty) -> TraitStore {
pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> FnOutput<'tcx> {
match fty.sty {
- ty_bare_fn(ref f) => f.sig.output,
- ty_closure(ref f) => f.sig.output,
+ ty_bare_fn(ref f) => f.sig.0.output,
+ ty_closure(ref f) => f.sig.0.output,
ref s => {
panic!("ty_fn_ret() called on non-fn type: {}", s)
}
&Some(ref t) => {
let trait_ref =
(*ty::node_id_to_trait_ref(cx, t.ref_id)).clone();
- Some(Rc::new(ty::bind(trait_ref)))
+ Some(Rc::new(ty::Binder(trait_ref)))
}
&None => None
}
trait_def.bounds.trait_bounds
.iter()
.map(|bound_trait_ref| {
- ty::bind(
+ ty::Binder(
ty::TraitRef::new(bound_trait_ref.def_id(),
bound_trait_ref.substs().subst(tcx, trait_ref.substs())))
})
subst::Substs { regions: subst::ErasedRegions,
types: substs.types.fold_with(self) }
}
-
- fn fold_fn_sig(&mut self,
- sig: &ty::FnSig<'tcx>)
- -> ty::FnSig<'tcx> {
- // The binder-id is only relevant to bound regions, which
- // are erased at trans time.
- ty::FnSig {
- inputs: sig.inputs.fold_with(self),
- output: sig.output.fold_with(self),
- variadic: sig.variadic,
- }
- }
}
}
let opt_trait_ref = opt_principal.map_or(Vec::new(), |principal| {
let substs = principal.substs().with_self_ty(open_ty);
- vec!(Rc::new(ty::bind(ty::TraitRef::new(principal.def_id(), substs))))
+ vec!(Rc::new(ty::Binder(ty::TraitRef::new(principal.def_id(), substs))))
});
let param_bounds = ty::ParamBounds {
/// Creates a hash of the type `Ty` which will be the same no matter what crate
/// context it's calculated within. This is used by the `type_id` intrinsic.
-pub fn hash_crate_independent(tcx: &ctxt, ty: Ty, svh: &Svh) -> u64 {
+pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -> u64 {
let mut state = sip::SipState::new();
helper(tcx, ty, svh, &mut state);
return state.result();
- fn helper(tcx: &ctxt, ty: Ty, svh: &Svh, state: &mut sip::SipState) {
+ fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, state: &mut sip::SipState) {
macro_rules! byte( ($b:expr) => { ($b as u8).hash(state) } );
macro_rules! hash( ($e:expr) => { $e.hash(state) } );
let mt = |state: &mut sip::SipState, mt: mt| {
mt.mutbl.hash(state);
};
- let fn_sig = |state: &mut sip::SipState, sig: &FnSig| {
+ let fn_sig = |state: &mut sip::SipState, sig: &Binder<FnSig<'tcx>>| {
let sig = anonymize_late_bound_regions(tcx, sig);
for a in sig.inputs.iter() { helper(tcx, *a, svh, state); }
if let ty::FnConverging(output) = sig.output {
hash!(bounds);
let principal = anonymize_late_bound_regions(tcx, principal);
- for subty in principal.substs().types.iter() {
+ for subty in principal.substs.types.iter() {
helper(tcx, *subty, svh, state);
}
//
let bounds = generics.to_bounds(tcx, &free_substs);
- let bounds = liberate_late_bound_regions(tcx, free_id_scope, &bind(bounds)).value;
+ let bounds = liberate_late_bound_regions(tcx, free_id_scope, &ty::Binder(bounds));
//
// Compute region bounds. For now, these relations are stored in a
/// Replace any late-bound regions bound in `value` with free variants attached to scope-id
/// `scope_id`.
-pub fn liberate_late_bound_regions<'tcx, HR>(
+pub fn liberate_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
scope: region::CodeExtent,
- value: &HR)
- -> HR
- where HR : HigherRankedFoldable<'tcx>
+ value: &Binder<T>)
+ -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
{
replace_late_bound_regions(
tcx, value,
/// Replace any late-bound regions bound in `value` with `'static`. Useful in trans but also
/// method lookup and a few other places where precise region relationships are not required.
-pub fn erase_late_bound_regions<'tcx, HR>(
+pub fn erase_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
- value: &HR)
- -> HR
- where HR : HigherRankedFoldable<'tcx>
+ value: &Binder<T>)
+ -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
{
replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic).0
}
/// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become
/// structurally identical. For example, `for<'a, 'b> fn(&'a int, &'b int)` and
/// `for<'a, 'b> fn(&'b int, &'a int)` will become identical after anonymization.
-pub fn anonymize_late_bound_regions<'tcx, HR>(tcx: &ctxt<'tcx>, sig: &HR) -> HR
- where HR: HigherRankedFoldable<'tcx> {
+pub fn anonymize_late_bound_regions<'tcx, T>(
+ tcx: &ctxt<'tcx>,
+ sig: &Binder<T>)
+ -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx>,
+{
let mut counter = 0;
replace_late_bound_regions(tcx, sig, |_, db| {
counter += 1;
}
/// Replaces the late-bound-regions in `value` that are bound by `value`.
-pub fn replace_late_bound_regions<'tcx, HR, F>(
+pub fn replace_late_bound_regions<'tcx, T, F>(
tcx: &ty::ctxt<'tcx>,
- value: &HR,
+ binder: &Binder<T>,
mut mapf: F)
--> (HR, FnvHashMap<ty::BoundRegion, ty::Region>) where
- HR : HigherRankedFoldable<'tcx>,
- F: FnMut(BoundRegion, DebruijnIndex) -> ty::Region,
+ -> (T, FnvHashMap<ty::BoundRegion,ty::Region>)
+ where T : TypeFoldable<'tcx> + Repr<'tcx>,
+ F : FnMut(BoundRegion, DebruijnIndex) -> ty::Region,
{
- debug!("replace_late_bound_regions({})", value.repr(tcx));
+ debug!("replace_late_bound_regions({})", binder.repr(tcx));
let mut map = FnvHashMap::new();
let value = {
}
});
- // Note: use `fold_contents` not `fold_with`. If we used
- // `fold_with`, it would consider the late-bound regions bound
- // by `value` to be bound, but we want to consider them as
- // `free`.
- value.fold_contents(&mut f)
+ // Note: fold the field `0`, not the binder, so that late-bound
+ // regions bound by `binder` are considered free.
+ binder.0.fold_with(&mut f)
};
debug!("resulting map: {} value: {}", map, value.repr(tcx));
(value, map)
impl<'tcx,T:RegionEscape> RegionEscape for Binder<T> {
fn has_regions_escaping_depth(&self, depth: uint) -> bool {
- self.value.has_regions_escaping_depth(depth + 1)
+ self.0.has_regions_escaping_depth(depth + 1)
}
}
impl<T:RegionEscape> Binder<T> {
pub fn has_bound_regions(&self) -> bool {
- self.value.has_regions_escaping_depth(0)
+ self.0.has_regions_escaping_depth(0)
}
}
}
fn fold_fn_sig(&mut self,
- sig: &ty::FnSig<'tcx>)
- -> ty::FnSig<'tcx> {
+ sig: &ty::FnSig<'tcx>)
+ -> ty::FnSig<'tcx> {
super_fold_fn_sig(self, sig)
}
impl<'tcx, T:TypeFoldable<'tcx>> TypeFoldable<'tcx> for ty::Binder<T> {
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::Binder<T> {
folder.enter_region_binder();
- let result = ty::bind(self.value.fold_with(folder));
+ let result = ty::Binder(self.0.fold_with(folder));
folder.exit_region_binder();
result
}
pub fn super_fold_fn_sig<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
sig: &ty::FnSig<'tcx>)
-> ty::FnSig<'tcx>
-{
- this.enter_region_binder();
- let result = super_fold_fn_sig_contents(this, sig);
- this.exit_region_binder();
- result
-}
-
-pub fn super_fold_fn_sig_contents<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
- sig: &ty::FnSig<'tcx>)
- -> ty::FnSig<'tcx>
{
ty::FnSig { inputs: sig.inputs.fold_with(this),
output: sig.output.fold_with(this),
}
}
-///////////////////////////////////////////////////////////////////////////
-// Higher-ranked things
-
-/// Designates a "binder" for late-bound regions.
-pub trait HigherRankedFoldable<'tcx>: Repr<'tcx> {
- /// Folds the contents of `self`, ignoring the region binder created
- /// by `self`.
- fn fold_contents<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self;
-}
-
-impl<'tcx> HigherRankedFoldable<'tcx> for ty::FnSig<'tcx> {
- fn fold_contents<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::FnSig<'tcx> {
- super_fold_fn_sig_contents(folder, self)
- }
-}
-
-impl<'tcx, T:TypeFoldable<'tcx>+Repr<'tcx>> HigherRankedFoldable<'tcx> for ty::Binder<T> {
- fn fold_contents<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::Binder<T> {
- ty::bind(self.value.fold_with(folder))
- }
-}
-
-impl<'tcx, T:HigherRankedFoldable<'tcx>> HigherRankedFoldable<'tcx> for Rc<T> {
- fn fold_contents<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Rc<T> {
- Rc::new((**self).fold_contents(folder))
- }
-}
-
///////////////////////////////////////////////////////////////////////////
// Some sample folders
/// regions (aka "lifetimes") that are bound within a type are not
/// visited by this folder; only regions that occur free will be
/// visited by `fld_r`.
-///
-/// (The distinction between "free" and "bound" is represented by
-/// keeping track of each `FnSig` in the lexical context of the
-/// current position of the fold.)
pub struct RegionFolder<'a, 'tcx: 'a, F> where F: FnMut(ty::Region, uint) -> ty::Region {
tcx: &'a ty::ctxt<'tcx>,
current_depth: uint,
use middle::ty::{ty_unboxed_closure};
use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer};
use middle::ty;
+use middle::ty_fold::TypeFoldable;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
use std::rc::Rc;
use syntax::abi;
use syntax::ast_map;
}
/// Produces a string suitable for showing to the user.
-pub trait UserString<'tcx> {
+pub trait UserString<'tcx> : Repr<'tcx> {
fn user_string(&self, tcx: &ctxt<'tcx>) -> String;
}
format!("[{}]", tstrs.connect(", "))
}
-pub fn fn_sig_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::FnSig<'tcx>) -> String {
- format!("fn{} -> {}", typ.inputs.repr(cx), typ.output.repr(cx))
-}
-
-pub fn trait_ref_to_string<'tcx>(cx: &ctxt<'tcx>,
- trait_ref: &ty::TraitRef<'tcx>) -> String {
- trait_ref.user_string(cx).to_string()
-}
-
pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
fn bare_fn_to_string<'tcx>(cx: &ctxt<'tcx>,
unsafety: ast::Unsafety,
abi: abi::Abi,
ident: Option<ast::Ident>,
- sig: &ty::FnSig<'tcx>)
+ sig: &ty::PolyFnSig<'tcx>)
-> String {
let mut s = String::new();
match unsafety {
s: &mut String,
bra: char,
ket: char,
- sig: &ty::FnSig<'tcx>,
+ sig: &ty::PolyFnSig<'tcx>,
bounds: &str) {
s.push(bra);
- let strs = sig.inputs
+ let strs = sig.0.inputs
.iter()
.map(|a| ty_to_string(cx, *a))
.collect::<Vec<_>>();
s.push_str(strs.connect(", ").as_slice());
- if sig.variadic {
+ if sig.0.variadic {
s.push_str(", ...");
}
s.push(ket);
s.push_str(bounds);
}
- match sig.output {
+ match sig.0.output {
ty::FnConverging(t) => {
if !ty::type_is_nil(t) {
s.push_str(" -> ");
impl<'tcx> Repr<'tcx> for ty::FnSig<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
- fn_sig_to_string(tcx, self)
+ format!("fn{} -> {}", self.inputs.repr(tcx), self.output.repr(tcx))
}
}
}
}
-impl<'tcx> UserString<'tcx> for ty::PolyTraitRef<'tcx> {
+impl<'tcx, T> UserString<'tcx> for ty::Binder<T>
+ where T : UserString<'tcx> + TypeFoldable<'tcx>
+{
fn user_string(&self, tcx: &ctxt<'tcx>) -> String {
// Replace any anonymous late-bound regions with named
// variants, using gensym'd identifiers, so that we can
// the output. We'll probably want to tweak this over time to
// decide just how much information to give.
let mut names = Vec::new();
- let (trait_ref, _) = ty::replace_late_bound_regions(tcx, self, |br, debruijn| {
+ let (unbound_value, _) = ty::replace_late_bound_regions(tcx, self, |br, debruijn| {
ty::ReLateBound(debruijn, match br {
ty::BrNamed(_, name) => {
names.push(token::get_name(name));
});
let names: Vec<_> = names.iter().map(|s| s.get()).collect();
- let trait_ref_str = trait_ref.value.user_string(tcx);
+ let value_str = unbound_value.user_string(tcx);
if names.len() == 0 {
- trait_ref_str
+ value_str
} else {
- format!("for<{}> {}", names.connect(","), trait_ref_str)
+ format!("for<{}> {}", names.connect(","), value_str)
}
}
}
impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for ty::Binder<T> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
- format!("Binder({})", self.value.repr(tcx))
+ format!("Binder({})", self.0.repr(tcx))
+ }
+}
+
+impl<'tcx, S, H, K, V> Repr<'tcx> for HashMap<K,V,H>
+ where K : Hash<S> + Eq + Repr<'tcx>,
+ V : Repr<'tcx>,
+ H : Hasher<S>
+{
+ fn repr(&self, tcx: &ctxt<'tcx>) -> String {
+ format!("HashMap({})",
+ self.iter()
+ .map(|(k,v)| format!("{} => {}", k.repr(tcx), v.repr(tcx)))
+ .collect::<Vec<String>>()
+ .connect(", "))
}
}
onceness: ast::Many,
store: ty::RegionTraitStore(region_bound, ast::MutMutable),
bounds: ty::region_existential_bound(region_bound),
- sig: ty::FnSig {
+ sig: ty::Binder(ty::FnSig {
inputs: input_tys.to_vec(),
output: ty::FnConverging(output_ty),
variadic: false,
- },
+ }),
abi: abi::Rust,
})
}
fn_ty: Ty<'tcx>, name: &str) -> ValueRef {
let (inputs, output, abi, env) = match fn_ty.sty {
ty::ty_bare_fn(ref f) => {
- (f.sig.inputs.clone(), f.sig.output, f.abi, None)
+ (f.sig.0.inputs.clone(), f.sig.0.output, f.abi, None)
}
ty::ty_closure(ref f) => {
- (f.sig.inputs.clone(), f.sig.output, f.abi, Some(Type::i8p(ccx)))
+ (f.sig.0.inputs.clone(), f.sig.0.output, f.abi, Some(Type::i8p(ccx)))
}
ty::ty_unboxed_closure(closure_did, _, ref substs) => {
let unboxed_closures = ccx.tcx().unboxed_closures.borrow();
let function_type = unboxed_closure.closure_type.clone();
let self_type = self_type_for_unboxed_closure(ccx, closure_did, fn_ty);
let llenvironment_type = type_of_explicit_arg(ccx, self_type);
- (function_type.sig.inputs.iter().map(|t| t.subst(ccx.tcx(), substs)).collect(),
- function_type.sig.output.subst(ccx.tcx(), substs),
+ (function_type.sig.0.inputs.iter().map(|t| t.subst(ccx.tcx(), substs)).collect(),
+ function_type.sig.0.output.subst(ccx.tcx(), substs),
RustCall,
Some(llenvironment_type))
}
let tcx = ccx.tcx();
let result_ty = match ctor_ty.sty {
- ty::ty_bare_fn(ref bft) => bft.sig.output.unwrap(),
+ ty::ty_bare_fn(ref bft) => bft.sig.0.output.unwrap(),
_ => ccx.sess().bug(
format!("trans_enum_variant_constructor: \
unexpected ctor return type {}",
let ctor_ty = ctor_ty.subst(ccx.tcx(), param_substs);
let result_ty = match ctor_ty.sty {
- ty::ty_bare_fn(ref bft) => bft.sig.output,
+ ty::ty_bare_fn(ref bft) => bft.sig.0.output,
_ => ccx.sess().bug(
format!("trans_enum_variant_or_tuple_like_struct: \
unexpected ctor return type {}",
// at either 1 or 2 depending on whether there's an env slot or not
let mut first_arg_offset = if has_env { 2 } else { 1 };
let mut attrs = llvm::AttrBuilder::new();
- let ret_ty = fn_sig.output;
+ let ret_ty = fn_sig.0.output;
// These have an odd calling convention, so we need to manually
// unpack the input ty's
ty::ty_unboxed_closure(_, _, _) => {
assert!(abi == RustCall);
- match fn_sig.inputs[0].sty {
+ match fn_sig.0.inputs[0].sty {
ty::ty_tup(ref inputs) => inputs.clone(),
_ => ccx.sess().bug("expected tuple'd inputs")
}
},
ty::ty_bare_fn(_) if abi == RustCall => {
- let mut inputs = vec![fn_sig.inputs[0]];
+ let mut inputs = vec![fn_sig.0.inputs[0]];
- match fn_sig.inputs[1].sty {
+ match fn_sig.0.inputs[1].sty {
ty::ty_tup(ref t_in) => {
inputs.push_all(t_in.as_slice());
inputs
_ => ccx.sess().bug("expected tuple'd inputs")
}
}
- _ => fn_sig.inputs.clone()
+ _ => fn_sig.0.inputs.clone()
};
if let ty::FnConverging(ret_ty) = ret_ty {
match bare_fn_ty.sty {
ty::ty_bare_fn(ty::BareFnTy { unsafety: ast::Unsafety::Normal,
abi: synabi::Rust,
- sig: ty::FnSig { inputs: ref input_tys,
- output: output_ty,
- variadic: false }}) =>
+ sig: ty::Binder(ty::FnSig { inputs: ref input_tys,
+ output: output_ty,
+ variadic: false })}) =>
{
(input_tys, output_ty)
}
let tuple_fn_ty = ty::mk_bare_fn(tcx,
ty::BareFnTy { unsafety: ast::Unsafety::Normal,
abi: synabi::RustCall,
- sig: ty::FnSig {
+ sig: ty::Binder(ty::FnSig {
inputs: vec![bare_fn_ty_ref,
tuple_input_ty],
output: output_ty,
variadic: false
- }});
+ })});
debug!("tuple_fn_ty: {}", tuple_fn_ty.repr(tcx));
//
let impl_or_trait_item = ty::impl_or_trait_item(tcx, source_id);
match impl_or_trait_item {
ty::MethodTraitItem(method) => {
- let trait_ref = ty::impl_trait_ref(tcx, impl_id).unwrap();
- let trait_ref = ty::erase_late_bound_regions(tcx, &trait_ref);
+ let poly_trait_ref = ty::impl_trait_ref(tcx, impl_id).unwrap();
+ let trait_ref = ty::erase_late_bound_regions(tcx, &*poly_trait_ref);
// Compute the first substitution
let first_subst =
- ty::make_substs_for_receiver_types(tcx, &trait_ref.value, &*method)
+ ty::make_substs_for_receiver_types(tcx, &trait_ref, &*method)
.erase_regions();
// And compose them
debug!("trans_fn_with_vtables - default method: \
substs = {}, trait_subst = {}, \
first_subst = {}, new_subst = {}",
- substs.repr(tcx), trait_ref.substs().repr(tcx),
+ substs.repr(tcx), trait_ref.substs.repr(tcx),
first_subst.repr(tcx), new_substs.repr(tcx));
(true, source_id, new_substs)
let mut bcx = callee.bcx;
let (abi, ret_ty) = match callee_ty.sty {
- ty::ty_bare_fn(ref f) => (f.abi, f.sig.output),
- ty::ty_closure(ref f) => (f.abi, f.sig.output),
+ ty::ty_bare_fn(ref f) => (f.abi, f.sig.0.output),
+ ty::ty_closure(ref f) => (f.abi, f.sig.0.output),
_ => panic!("expected bare rust fn or closure in trans_call_inner")
};
let arena = TypedArena::new();
let empty_param_substs = Substs::trans_empty();
- let fcx = new_fn_ctxt(ccx, llfn, ast::DUMMY_NODE_ID, true, f.sig.output,
+ let fcx = new_fn_ctxt(ccx, llfn, ast::DUMMY_NODE_ID, true, f.sig.0.output,
&empty_param_substs, None, &arena);
- let bcx = init_function(&fcx, true, f.sig.output);
+ let bcx = init_function(&fcx, true, f.sig.0.output);
let args = create_datums_for_fn_args(&fcx,
ty::ty_fn_args(closure_ty)
llargs.extend(args.iter().map(|arg| arg.val));
let retval = Call(bcx, fn_ptr, llargs.as_slice(), None);
- match f.sig.output {
+ match f.sig.0.output {
ty::FnConverging(output_type) => {
if return_type_is_void(ccx, output_type) || fcx.llretslotptr.get().is_some() {
RetVoid(bcx);
unique_type_id.push_str(" fn(");
- for ¶meter_type in sig.inputs.iter() {
+ for ¶meter_type in sig.0.inputs.iter() {
let parameter_type_id =
self.get_unique_type_id_of_type(cx, parameter_type);
let parameter_type_id =
unique_type_id.push(',');
}
- if sig.variadic {
+ if sig.0.variadic {
unique_type_id.push_str("...");
}
unique_type_id.push_str(")->");
- match sig.output {
+ match sig.0.output {
ty::FnConverging(ret_ty) => {
let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty);
let return_type_id = self.get_unique_type_id_as_string(return_type_id);
}
};
- for ¶meter_type in sig.inputs.iter() {
+ for ¶meter_type in sig.0.inputs.iter() {
let parameter_type_id =
self.get_unique_type_id_of_type(cx, parameter_type);
let parameter_type_id =
unique_type_id.push(',');
}
- if sig.variadic {
+ if sig.0.variadic {
unique_type_id.push_str("...");
}
unique_type_id.push_str("|->");
- match sig.output {
+ match sig.0.output {
ty::FnConverging(ret_ty) => {
let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty);
let return_type_id = self.get_unique_type_id_as_string(return_type_id);
fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
unique_type_id: UniqueTypeId,
- signature: &ty::FnSig<'tcx>,
+ signature: &ty::PolyFnSig<'tcx>,
span: Span)
-> MetadataCreationResult {
- let mut signature_metadata: Vec<DIType> = Vec::with_capacity(signature.inputs.len() + 1);
+ let mut signature_metadata: Vec<DIType> = Vec::with_capacity(signature.0.inputs.len() + 1);
// return type
- signature_metadata.push(match signature.output {
+ signature_metadata.push(match signature.0.output {
ty::FnConverging(ret_ty) => match ret_ty.sty {
ty::ty_tup(ref tys) if tys.is_empty() => ptr::null_mut(),
_ => type_metadata(cx, ret_ty, span)
});
// regular arguments
- for &argument_type in signature.inputs.iter() {
+ for &argument_type in signature.0.inputs.iter() {
signature_metadata.push(type_metadata(cx, argument_type, span));
}
output.push_str("fn(");
- if sig.inputs.len() > 0 {
- for ¶meter_type in sig.inputs.iter() {
+ if sig.0.inputs.len() > 0 {
+ for ¶meter_type in sig.0.inputs.iter() {
push_debuginfo_type_name(cx, parameter_type, true, output);
output.push_str(", ");
}
output.pop();
}
- if sig.variadic {
- if sig.inputs.len() > 0 {
+ if sig.0.variadic {
+ if sig.0.inputs.len() > 0 {
output.push_str(", ...");
} else {
output.push_str("...");
output.push(')');
- match sig.output {
+ match sig.0.output {
ty::FnConverging(result_type) if ty::type_is_nil(result_type) => {}
ty::FnConverging(result_type) => {
output.push_str(" -> ");
}
};
- if sig.inputs.len() > 0 {
- for ¶meter_type in sig.inputs.iter() {
+ if sig.0.inputs.len() > 0 {
+ for ¶meter_type in sig.0.inputs.iter() {
push_debuginfo_type_name(cx, parameter_type, true, output);
output.push_str(", ");
}
output.pop();
}
- if sig.variadic {
- if sig.inputs.len() > 0 {
+ if sig.0.variadic {
+ if sig.0.inputs.len() > 0 {
output.push_str(", ...");
} else {
output.push_str("...");
output.push(param_list_closing_char);
- match sig.output {
+ match sig.0.output {
ty::FnConverging(result_type) if ty::type_is_nil(result_type) => {}
ty::FnConverging(result_type) => {
output.push_str(" -> ");
&ty::UnsizeVtable(ty::TyTrait { ref principal, .. }, _) => {
let substs = principal.substs().with_self_ty(unadjusted_ty).erase_regions();
let trait_ref =
- Rc::new(ty::bind(ty::TraitRef { def_id: principal.def_id(),
- substs: substs }));
+ Rc::new(ty::Binder(ty::TraitRef { def_id: principal.def_id(),
+ substs: substs }));
let trait_ref = trait_ref.subst(bcx.tcx(), bcx.fcx.param_substs);
let box_ty = mk_ty(unadjusted_ty);
PointerCast(bcx,
use trans::type_::Type;
use trans::type_of::*;
use trans::type_of;
-use middle::ty::FnSig;
use middle::ty::{mod, Ty};
use middle::subst::{Subst, Substs};
use std::cmp;
struct ForeignTypes<'tcx> {
/// Rust signature of the function
- fn_sig: ty::FnSig<'tcx>,
+ fn_sig: ty::PolyFnSig<'tcx>,
/// Adapter object for handling native ABI rules (trust me, you
/// don't want to know)
// Make sure the calling convention is right for variadic functions
// (should've been caught if not in typeck)
- if tys.fn_sig.variadic {
+ if tys.fn_sig.0.variadic {
assert!(cc == llvm::CCallConv);
}
debug!("llforeign_ret_ty={}", ccx.tn().type_to_string(llforeign_ret_ty));
if llrust_ret_ty == llforeign_ret_ty {
- match fn_sig.output {
+ match fn_sig.0.output {
ty::FnConverging(result_ty) => {
base::store_ty(bcx, llforeign_retval, llretptr, result_ty)
}
};
// Push Rust return pointer, using null if it will be unused.
- let rust_uses_outptr = match tys.fn_sig.output {
+ let rust_uses_outptr = match tys.fn_sig.0.output {
ty::FnConverging(ret_ty) => type_of::return_uses_outptr(ccx, ret_ty),
ty::FnDiverging => false
};
return_ty={}",
ccx.tn().val_to_string(slot),
ccx.tn().type_to_string(llrust_ret_ty),
- tys.fn_sig.output.repr(tcx));
+ tys.fn_sig.0.output.repr(tcx));
llrust_args.push(slot);
return_alloca = Some(slot);
}
// Build up the arguments to the call to the rust function.
// Careful to adapt for cases where the native convention uses
// a pointer and Rust does not or vice versa.
- for i in range(0, tys.fn_sig.inputs.len()) {
- let rust_ty = tys.fn_sig.inputs[i];
+ for i in range(0, tys.fn_sig.0.inputs.len()) {
+ let rust_ty = tys.fn_sig.0.inputs[i];
let llrust_ty = tys.llsig.llarg_tys[i];
let rust_indirect = type_of::arg_is_indirect(ccx, rust_ty);
let llforeign_arg_ty = tys.fn_ty.arg_tys[i];
/// because foreign functions just plain ignore modes. They also don't pass aggregate values by
/// pointer like we do.
fn foreign_signature<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- fn_sig: &ty::FnSig<'tcx>, arg_tys: &[Ty<'tcx>])
+ fn_sig: &ty::PolyFnSig<'tcx>, arg_tys: &[Ty<'tcx>])
-> LlvmSignature {
let llarg_tys = arg_tys.iter().map(|&arg| arg_type_of(ccx, arg)).collect();
- let (llret_ty, ret_def) = match fn_sig.output {
+ let (llret_ty, ret_def) = match fn_sig.0.output {
ty::FnConverging(ret_ty) =>
(type_of::arg_type_of(ccx, ret_ty), !return_type_is_void(ccx, ret_ty)),
ty::FnDiverging =>
ty::ty_bare_fn(ref fn_ty) => fn_ty.sig.clone(),
_ => ccx.sess().bug("foreign_types_for_fn_ty called on non-function type")
};
- let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs.as_slice());
+ let llsig = foreign_signature(ccx, &fn_sig, fn_sig.0.inputs.as_slice());
let fn_ty = cabi::compute_abi_info(ccx,
llsig.llarg_tys.as_slice(),
llsig.llret_ty,
llargument_tys.push(llarg_ty);
}
- if tys.fn_sig.variadic {
+ if tys.fn_sig.0.variadic {
Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty)
} else {
Type::func(llargument_tys.as_slice(), &llreturn_ty)
let fty = ty::lookup_item_type(bcx.tcx(), dtor_did).ty.subst(bcx.tcx(), substs);
let self_ty = match fty.sty {
ty::ty_bare_fn(ref f) => {
- assert!(f.sig.inputs.len() == 1);
- f.sig.inputs[0]
+ assert!(f.sig.0.inputs.len() == 1);
+ f.sig.0.inputs[0]
}
_ => bcx.sess().bug(format!("Expected function type, found {}",
bcx.ty_to_string(fty)).as_slice())
let tcx = bcx.tcx();
let ret_ty = match callee_ty.sty {
- ty::ty_bare_fn(ref f) => f.sig.output,
+ ty::ty_bare_fn(ref f) => f.sig.0.output,
_ => panic!("expected bare_fn in trans_intrinsic_call")
};
let foreign_item = tcx.map.expect_foreign_item(node);
rcvr_assoc,
Vec::new()));
debug!("trait_substs={}", trait_substs.repr(bcx.tcx()));
- let trait_ref = Rc::new(ty::bind(ty::TraitRef { def_id: trait_id,
- substs: trait_substs }));
+ let trait_ref = Rc::new(ty::Binder(ty::TraitRef { def_id: trait_id,
+ substs: trait_substs }));
let vtbl = fulfill_obligation(bcx.ccx(),
DUMMY_SP,
trait_ref);
ty::ty_bare_fn(ref f) if f.abi == Rust || f.abi == RustCall => {
type_of_rust_fn(ccx,
Some(Type::i8p(ccx)),
- f.sig.inputs.slice_from(1),
- f.sig.output,
+ f.sig.0.inputs.slice_from(1),
+ f.sig.0.output,
f.abi)
}
_ => {
ty::ty_closure(ref f) => {
type_of_rust_fn(cx,
Some(Type::i8p(cx)),
- f.sig.inputs.as_slice(),
- f.sig.output,
+ f.sig.0.inputs.as_slice(),
+ f.sig.0.output,
f.abi)
}
ty::ty_bare_fn(ref f) => {
if f.abi == abi::Rust || f.abi == abi::RustCall {
type_of_rust_fn(cx,
None,
- f.sig.inputs.as_slice(),
- f.sig.output,
+ f.sig.0.inputs.as_slice(),
+ f.sig.0.output,
f.abi)
} else {
foreign::lltype_for_foreign_fn(cx, fty)
{
let trait_ref = instantiate_trait_ref(this, rscope, &ast_trait_ref.trait_ref, self_ty, allow_eq);
let trait_ref = (*trait_ref).clone();
- Rc::new(ty::bind(trait_ref)) // Ugh.
+ Rc::new(ty::Binder(trait_ref)) // Ugh.
}
/// Instantiates the path for the given trait reference, assuming that it's
ast::TyPath(ref path, id) => {
match this.tcx().def_map.borrow().get(&id) {
Some(&def::DefTrait(trait_def_id)) => {
- return Ok(ty::bind(ast_path_to_trait_ref(this,
- rscope,
- trait_def_id,
- None,
- path,
- AllowEqConstraints::Allow)));
+ return Ok(ty::Binder(ast_path_to_trait_ref(this,
+ rscope,
+ trait_def_id,
+ None,
+ path,
+ AllowEqConstraints::Allow)));
}
_ => {
span_err!(this.tcx().sess, ty.span, E0172, "expected a reference to a trait");
def::DefTrait(trait_def_id) => {
// N.B. this case overlaps somewhat with
// TyObjectSum, see that fn for details
- let result = ty::bind(ast_path_to_trait_ref(this,
- rscope,
- trait_def_id,
- None,
- path,
- AllowEqConstraints::Allow));
+ let result = ty::Binder(ast_path_to_trait_ref(this,
+ rscope,
+ trait_def_id,
+ None,
+ path,
+ AllowEqConstraints::Allow));
trait_ref_to_object_type(this, rscope, path.span, result, &[])
}
def::DefTy(did, _) | def::DefStruct(did) => {
let ty_param_defs = tcx.ty_param_defs.borrow();
let tp_def = &(*ty_param_defs)[did.node];
let assoc_tys = tp_def.bounds.trait_bounds.iter()
- .filter_map(|b| find_assoc_ty(this, &b.value, assoc_ident))
+ .filter_map(|b| find_assoc_ty(this, &b.0, assoc_ident))
.collect();
(assoc_tys, token::get_name(tp_def.name).to_string())
}
(ty::BareFnTy {
unsafety: unsafety,
abi: abi,
- sig: ty::FnSig {
+ sig: ty::Binder(ty::FnSig {
inputs: self_and_input_tys,
output: output_ty,
variadic: decl.variadic
- }
+ }),
}, explicit_self_category_result)
}
store: store,
bounds: bounds,
abi: abi,
- sig: ty::FnSig {inputs: input_tys,
- output: output_ty,
- variadic: decl.variadic}
+ sig: ty::Binder(ty::FnSig {inputs: input_tys,
+ output: output_ty,
+ variadic: decl.variadic}),
}
}
// Tuple up the arguments and insert the resulting function type into
// the `unboxed_closures` table.
- fn_ty.sig.inputs = vec![ty::mk_tup(fcx.tcx(), fn_ty.sig.inputs)];
+ fn_ty.sig.0.inputs = vec![ty::mk_tup(fcx.tcx(), fn_ty.sig.0.inputs)];
debug!("unboxed_closure for {} --> sig={} kind={}",
expr_def_id.repr(fcx.tcx()),
use middle::ty::{mod, Ty};
use middle::ty::{MethodCall, MethodCallee, MethodObject, MethodOrigin,
MethodParam, MethodStatic, MethodTraitObject, MethodTypeParam};
+use middle::ty_fold::TypeFoldable;
use middle::infer;
use middle::infer::InferCtxt;
-use middle::ty_fold::HigherRankedFoldable;
use syntax::ast;
use syntax::codemap::Span;
use std::rc::Rc;
// Create the final `MethodCallee`.
let fty = ty::mk_bare_fn(self.tcx(), ty::BareFnTy {
- sig: method_sig,
+ sig: ty::Binder(method_sig),
unsafety: pick.method_ty.fty.unsafety,
abi: pick.method_ty.fty.abi.clone(),
});
&trait_def.generics,
self.infcx().next_ty_var());
- let trait_ref = Rc::new(ty::bind(ty::TraitRef::new(trait_def_id, substs.clone())));
+ let trait_ref =
+ Rc::new(ty::Binder(ty::TraitRef::new(trait_def_id, substs.clone())));
let origin = MethodTypeParam(MethodParam { trait_ref: trait_ref,
method_num: method_num });
(substs, origin)
// The binder level here corresponds to the impl.
let (all_substs, (method_sig, method_generics)) =
self.replace_late_bound_regions_with_fresh_var(
- &ty::bind((all_substs,
- (pick.method_ty.fty.sig.clone(),
- pick.method_ty.generics.clone())))).value;
+ &ty::Binder((all_substs,
+ (pick.method_ty.fty.sig.clone(),
+ pick.method_ty.generics.clone()))));
debug!("late-bound lifetimes from impl instantiated, \
all_substs={} method_sig={} method_generics={}",
_ => return,
};
- match sig.inputs[0].sty {
+ match sig.0.inputs[0].sty {
ty::ty_rptr(_, ty::mt {
ty: _,
mutbl: ast::MutMutable,
target_trait_def_id.repr(self.tcx()))[]);
}
- fn replace_late_bound_regions_with_fresh_var<T>(&self, value: &T) -> T
- where T : HigherRankedFoldable<'tcx>
+ fn replace_late_bound_regions_with_fresh_var<T>(&self, value: &ty::Binder<T>) -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
{
self.infcx().replace_late_bound_regions_with_fresh_var(
self.span, infer::FnCall, value).0
// Construct a trait-reference `self_ty : Trait<input_tys>`
let substs = subst::Substs::new_trait(input_types, Vec::new(), assoc_types, self_ty);
- let trait_ref = Rc::new(ty::bind(ty::TraitRef::new(trait_def_id, substs)));
+ let trait_ref = Rc::new(ty::Binder(ty::TraitRef::new(trait_def_id, substs)));
// Construct an obligation
let obligation = traits::Obligation::misc(span,
&fn_sig).0;
let transformed_self_ty = fn_sig.inputs[0];
let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {
- sig: fn_sig,
+ sig: ty::Binder(fn_sig),
unsafety: bare_fn_ty.unsafety,
abi: bare_fn_ty.abi.clone(),
});
use middle::traits;
use middle::ty::{mod, Ty};
use middle::ty::{MethodObject};
-use middle::ty_fold::HigherRankedFoldable;
+use middle::ty_fold::TypeFoldable;
use middle::infer;
use middle::infer::InferCtxt;
use syntax::ast;
let vtable_index =
get_method_index(tcx, &*new_trait_ref, trait_ref.clone(), method_num);
- let xform_self_ty =
- this.xform_self_ty(&m, new_trait_ref.substs());
+ let xform_self_ty = this.xform_self_ty(&m, new_trait_ref.substs());
this.inherent_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
// Erase any late-bound regions bound in the impl
// which appear in the bounds.
- let impl_bounds = self.erase_late_bound_regions(&ty::bind(impl_bounds)).value;
+ let impl_bounds = self.erase_late_bound_regions(&ty::Binder(impl_bounds));
// Convert the bounds into obligations.
let obligations =
fn xform_self_ty(&self,
method: &Rc<ty::Method<'tcx>>,
substs: &subst::Substs<'tcx>)
- -> Ty<'tcx> {
+ -> Ty<'tcx>
+ {
debug!("xform_self_ty(self_ty={}, substs={})",
- method.fty.sig.inputs[0].repr(self.tcx()),
+ method.fty.sig.0.inputs[0].repr(self.tcx()),
substs.repr(self.tcx()));
// It is possible for type parameters or early-bound lifetimes
}
// Replace early-bound regions and types.
- let xform_self_ty = method.fty.sig.inputs[0].subst(self.tcx(), substs);
+ let xform_self_ty = method.fty.sig.0.inputs[0].subst(self.tcx(), substs);
// Replace late-bound regions bound in the impl or
- // where-clause (2 levels of binding).
- let xform_self_ty =
- self.erase_late_bound_regions(&ty::bind(ty::bind(xform_self_ty))).value.value;
-
- // Replace late-bound regions bound in the method (1 level of binding).
- self.erase_late_bound_regions(&ty::bind(xform_self_ty)).value
+ // where-clause (2 levels of binding) and method (1 level of binding).
+ self.erase_late_bound_regions(
+ &self.erase_late_bound_regions(
+ &ty::Binder(ty::Binder(xform_self_ty))))
}
fn impl_substs(&self,
/// region got replaced with the same variable, which requires a bit more coordination
/// and/or tracking the substitution and
/// so forth.
- fn erase_late_bound_regions<T>(&self, value: &T) -> T
- where T : HigherRankedFoldable<'tcx>
+ fn erase_late_bound_regions<T>(&self, value: &ty::Binder<T>) -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
{
ty::erase_late_bound_regions(self.tcx(), value)
}
fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
unsafety: ast::Unsafety,
unsafety_id: ast::NodeId,
- fn_sig: &ty::FnSig<'tcx>,
+ fn_sig: &ty::PolyFnSig<'tcx>,
decl: &ast::FnDecl,
fn_id: ast::NodeId,
body: &ast::Block,
let body_id = method.pe_body().id;
let fty = liberate_late_bound_regions(
- ccx.tcx, CodeExtent::from_node_id(body_id), &ty::bind(fty)).value;
+ ccx.tcx, CodeExtent::from_node_id(body_id), &ty::Binder(fty));
debug!("fty (liberated): {}", fty.repr(ccx.tcx));
check_bare_fn(ccx,
let infcx = infer::new_infer_ctxt(tcx);
- let trait_to_impl_substs = impl_trait_ref.substs();
+ let trait_to_impl_substs = impl_trait_ref.substs;
// Try to give more informative error messages about self typing
// mismatches. Note that any mismatch will also be detected
return;
}
- if impl_m.fty.sig.inputs.len() != trait_m.fty.sig.inputs.len() {
+ if impl_m.fty.sig.0.inputs.len() != trait_m.fty.sig.0.inputs.len() {
span_err!(tcx.sess, impl_m_span, E0050,
"method `{}` has {} parameter{} \
but the declaration in trait `{}` has {}",
token::get_name(trait_m.name),
- impl_m.fty.sig.inputs.len(),
- if impl_m.fty.sig.inputs.len() == 1 {""} else {"s"},
+ impl_m.fty.sig.0.inputs.len(),
+ if impl_m.fty.sig.0.inputs.len() == 1 {""} else {"s"},
ty::item_path_str(tcx, trait_m.def_id),
- trait_m.fty.sig.inputs.len());
+ trait_m.fty.sig.0.inputs.len());
return;
}
// `Bound<&'a T>`, the lifetime `'a` will be late-bound with a
// depth of 3 (it is nested within 3 binders: the impl, method,
// and trait-ref itself). So when we do the liberation, we have
- // two introduce two `ty::bind` scopes, one for the impl and one
+ // two introduce two `ty::Binder` scopes, one for the impl and one
// the method.
//
// The only late-bounded regions that can possibly appear here are
liberate_late_bound_regions(
tcx,
impl_m_body_scope,
- &ty::bind(ty::bind(impl_param_def.bounds.clone()))).value.value);
+ &ty::Binder(ty::Binder(impl_param_def.bounds.clone()))).0);
for (i, (trait_param_bounds, impl_param_bounds)) in
trait_bounds.zip(impl_bounds).enumerate()
{
let impl_fty = ty::mk_bare_fn(tcx, impl_m.fty.clone());
let impl_fty = impl_fty.subst(tcx, &impl_to_skol_substs);
let impl_fty = liberate_late_bound_regions(
- tcx, impl_m_body_scope, &ty::bind(impl_fty)).value;
+ tcx, impl_m_body_scope, &ty::Binder(impl_fty));
let trait_fty = ty::mk_bare_fn(tcx, trait_m.fty.clone());
let trait_fty = trait_fty.subst(tcx, &trait_to_skol_substs);
// impl, and the method.
let impl_bounds =
ty::liberate_late_bound_regions(
- tcx, impl_m_body_scope, &ty::bind(ty::bind(impl_bounds))).value.value;
+ tcx, impl_m_body_scope, &ty::Binder(ty::Binder(impl_bounds))).0;
debug!("check_region_bounds_on_impl_method: \
trait_param={} \
// HACK(eddyb) ignore self in the definition (see above).
check_argument_types(fcx,
sp,
- fty.sig.inputs.slice_from(1),
+ fty.sig.0.inputs.slice_from(1),
callee_expr,
args_no_rcvr,
autoref_args,
- fty.sig.variadic,
+ fty.sig.0.variadic,
tuple_arguments);
- fty.sig.output
+ fty.sig.0.output
}
_ => {
fcx.tcx().sess.span_bug(callee_expr.span,
// This is the "default" function signature, used in case of error.
// In that case, we check each argument against "error" in order to
// set up all the node type bindings.
- let error_fn_sig = FnSig {
+ let error_fn_sig = ty::Binder(FnSig {
inputs: err_args(args.len()),
output: ty::FnConverging(ty::mk_err()),
variadic: false
- };
+ });
let fn_sig = match *fn_sty {
ty::ty_bare_fn(ty::BareFnTy {ref sig, ..}) |
fcx.infcx().replace_late_bound_regions_with_fresh_var(
span,
infer::FnCall,
- &ty::bind((polytype.ty, bounds))).0.value;
+ &ty::Binder((polytype.ty, bounds))).0;
debug!("after late-bounds have been replaced: ty_late_bound={}", ty_late_bound.repr(fcx.tcx()));
debug!("after late-bounds have been replaced: bounds={}", bounds.repr(fcx.tcx()));
let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {
unsafety: ast::Unsafety::Unsafe,
abi: abi::RustIntrinsic,
- sig: FnSig {
+ sig: ty::Binder(FnSig {
inputs: inputs,
output: output,
variadic: false,
- }
+ }),
});
let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id));
let i_n_tps = i_ty.generics.types.len(subst::FnSpace);
// Treat overloaded autoderefs as if an AutoRef adjustment
// was applied on the base type, as that is always the case.
let fn_sig = ty::ty_fn_sig(method.ty);
- let self_ty = fn_sig.inputs[0];
+ let self_ty = fn_sig.0.inputs[0];
let (m, r) = match self_ty.sty {
ty::ty_rptr(r, ref m) => (m.mutbl, r),
_ => rcx.tcx().sess.span_bug(deref_expr.span,
// Specialized version of constrain_call.
type_must_outlive(rcx, infer::CallRcvr(deref_expr.span),
self_ty, r_deref_expr);
- match fn_sig.output {
+ match fn_sig.0.output {
ty::FnConverging(return_type) => {
type_must_outlive(rcx, infer::CallReturn(deref_expr.span),
return_type, r_deref_expr);
}
};
let ref sig = method.fty.sig;
- for &input_ty in sig.inputs[1..].iter() {
+ for &input_ty in sig.0.inputs[1..].iter() {
if let Some(msg) = check_for_self_ty(input_ty) {
msgs.push(msg);
}
}
- if let ty::FnConverging(result_type) = sig.output {
+ if let ty::FnConverging(result_type) = sig.0.output {
if let Some(msg) = check_for_self_ty(result_type) {
msgs.push(msg);
}
// liberated.
let self_ty = ty::node_id_to_type(fcx.tcx(), item.id);
let self_ty = self_ty.subst(fcx.tcx(), &fcx.inh.param_env.free_substs);
- let self_ty = liberate_late_bound_regions(
- fcx.tcx(), item_scope, &ty::bind(self_ty)).value;
+ let self_ty = liberate_late_bound_regions(fcx.tcx(), item_scope, &ty::Binder(self_ty));
bounds_checker.check_traits_in_ty(self_ty);
// There are special rules that apply to drop.
if
- fcx.tcx().lang_items.drop_trait() == Some(trait_ref.def_id()) &&
+ fcx.tcx().lang_items.drop_trait() == Some(trait_ref.def_id) &&
!attr::contains_name(item.attrs.as_slice(), "unsafe_destructor")
{
match self_ty.sty {
}
}
- if fcx.tcx().lang_items.copy_trait() == Some(trait_ref.def_id()) {
+ if fcx.tcx().lang_items.copy_trait() == Some(trait_ref.def_id) {
// This is checked in coherence.
return
}
traits::ObligationCause::new(
item.span,
fcx.body_id,
- traits::ItemObligation(trait_ref.def_id()));
+ traits::ItemObligation(trait_ref.def_id));
// Find the supertrait bounds. This will add `int:Bar`.
- let predicates = ty::predicates_for_trait_ref(fcx.tcx(), &trait_ref);
+ let poly_trait_ref = ty::Binder(trait_ref);
+ let predicates = ty::predicates_for_trait_ref(fcx.tcx(), &poly_trait_ref);
for predicate in predicates.into_iter() {
fcx.register_predicate(traits::Obligation::new(cause, predicate));
}
///
/// Note that it does not (currently, at least) check that `A : Copy` (that check is delegated
/// to the point where impl `A : Trait<B>` is implemented).
- pub fn check_trait_ref(&mut self, trait_ref: &ty::PolyTraitRef<'tcx>) {
- let trait_def = ty::lookup_trait_def(self.fcx.tcx(), trait_ref.def_id());
+ pub fn check_trait_ref(&mut self, trait_ref: &ty::TraitRef<'tcx>) {
+ let trait_def = ty::lookup_trait_def(self.fcx.tcx(), trait_ref.def_id);
- let bounds = trait_def.generics.to_bounds(self.tcx(), trait_ref.substs());
+ let bounds = trait_def.generics.to_bounds(self.tcx(), &trait_ref.substs);
self.fcx.add_obligations_for_parameters(
traits::ObligationCause::new(
self.span,
self.fcx.body_id,
- traits::ItemObligation(trait_ref.def_id())),
+ traits::ItemObligation(trait_ref.def_id)),
&bounds);
- for &ty in trait_ref.substs().types.iter() {
+ for &ty in trait_ref.substs.types.iter() {
self.check_traits_in_ty(ty);
}
}
let self_type =
ty::liberate_late_bound_regions(tcx,
item_scope,
- &ty::bind(self_type)).value;
+ &ty::Binder(self_type));
debug!("can_type_implement_copy(self_type={})",
self_type.repr(tcx));
let param_id = trait_id;
let self_trait_ref =
- Rc::new(ty::bind(ty::TraitRef { def_id: local_def(trait_id),
- substs: (*substs).clone() }));
+ Rc::new(ty::Binder(ty::TraitRef { def_id: local_def(trait_id),
+ substs: (*substs).clone() }));
let def = ty::TypeParameterDef {
space: subst::SelfSpace,
ty::BareFnTy {
abi: abi,
unsafety: ast::Unsafety::Unsafe,
- sig: ty::FnSig {inputs: input_tys,
- output: output,
- variadic: decl.variadic}
+ sig: ty::Binder(ty::FnSig {inputs: input_tys,
+ output: output,
+ variadic: decl.variadic}),
});
let pty = Polytype {
generics: ty_generics_for_fn_or_method,
assert!(!ty::type_escapes_depth(required_type, 1));
let required_type_free =
ty::liberate_late_bound_regions(
- crate_context.tcx, body_scope, &ty::bind(required_type)).value;
+ crate_context.tcx, body_scope, &ty::Binder(required_type));
// The "base type" comes from the impl. It may have late-bound
// regions from the impl or the method.
- let base_type_free = // liberate impl regions:
- ty::liberate_late_bound_regions(
- crate_context.tcx, body_scope, &ty::bind(ty::bind(base_type))).value.value;
- let base_type_free = // liberate method regions:
- ty::liberate_late_bound_regions(
- crate_context.tcx, body_scope, &ty::bind(base_type_free)).value;
+ let base_type_free =
+ ty::liberate_late_bound_regions( // liberate impl regions:
+ crate_context.tcx, body_scope,
+ &ty::liberate_late_bound_regions( // liberate method regions:
+ crate_context.tcx, body_scope,
+ &ty::Binder(ty::Binder(base_type))));
debug!("required_type={} required_type_free={} \
base_type={} base_type_free={}",
let se_ty = ty::mk_bare_fn(tcx, ty::BareFnTy {
unsafety: ast::Unsafety::Normal,
abi: abi::Rust,
- sig: ty::FnSig {
+ sig: ty::Binder(ty::FnSig {
inputs: Vec::new(),
output: ty::FnConverging(ty::mk_nil(tcx)),
variadic: false
- }
+ })
});
require_same_types(tcx, None, false, main_span, main_t, se_ty,
let se_ty = ty::mk_bare_fn(tcx, ty::BareFnTy {
unsafety: ast::Unsafety::Normal,
abi: abi::Rust,
- sig: ty::FnSig {
+ sig: ty::Binder(ty::FnSig {
inputs: vec!(
ty::mk_int(),
ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, ty::mk_u8()))
),
output: ty::FnConverging(ty::mk_int()),
variadic: false
- }
+ }),
});
require_same_types(tcx, None, false, start_span, start_t, se_ty,
/// Adds constraints appropriate for a function with signature
/// `sig` appearing in a context with ambient variance `variance`
fn add_constraints_from_sig(&mut self,
- sig: &ty::FnSig<'tcx>,
+ sig: &ty::PolyFnSig<'tcx>,
variance: VarianceTermPtr<'a>) {
let contra = self.contravariant(variance);
- for &input in sig.inputs.iter() {
+ for &input in sig.0.inputs.iter() {
self.add_constraints_from_ty(input, contra);
}
- if let ty::FnConverging(result_type) = sig.output {
+ if let ty::FnConverging(result_type) = sig.0.output {
self.add_constraints_from_ty(result_type, variance);
}
}
impl<'tcx> Clean<TyParamBound> for ty::PolyTraitRef<'tcx> {
fn clean(&self, cx: &DocContext) -> TyParamBound {
- self.value.clean(cx)
+ self.0.clean(cx)
}
}
}
}
-impl<'a, 'tcx> Clean<FnDecl> for (ast::DefId, &'a ty::FnSig<'tcx>) {
+impl<'a, 'tcx> Clean<FnDecl> for (ast::DefId, &'a ty::PolyFnSig<'tcx>) {
fn clean(&self, cx: &DocContext) -> FnDecl {
let (did, sig) = *self;
let mut names = if did.node != 0 {
let _ = names.next();
}
FnDecl {
- output: Return(sig.output.clean(cx)),
+ output: Return(sig.0.output.clean(cx)),
attrs: Vec::new(),
inputs: Arguments {
- values: sig.inputs.iter().map(|t| {
+ values: sig.0.inputs.iter().map(|t| {
Argument {
type_: t.clean(cx),
id: 0,
ty::StaticExplicitSelfCategory => (ast::SelfStatic.clean(cx),
self.fty.sig.clone()),
s => {
- let sig = ty::FnSig {
- inputs: self.fty.sig.inputs[1..].to_vec(),
- ..self.fty.sig.clone()
- };
+ let sig = ty::Binder(ty::FnSig {
+ inputs: self.fty.sig.0.inputs[1..].to_vec(),
+ ..self.fty.sig.0.clone()
+ });
let s = match s {
ty::ByValueExplicitSelfCategory => SelfValue,
ty::ByReferenceExplicitSelfCategory(..) => {
- match self.fty.sig.inputs[0].sty {
+ match self.fty.sig.0.inputs[0].sty {
ty::ty_rptr(r, mt) => {
SelfBorrowed(r.clean(cx), mt.mutbl.clean(cx))
}
}
}
ty::ByBoxExplicitSelfCategory => {
- SelfExplicit(self.fty.sig.inputs[0].clean(cx))
+ SelfExplicit(self.fty.sig.0.inputs[0].clean(cx))
}
ty::StaticExplicitSelfCategory => unreachable!(),
};
ty::ty_struct(did, ref substs) |
ty::ty_enum(did, ref substs) |
ty::ty_trait(box ty::TyTrait {
- principal: ty::Binder { value: ty::TraitRef { def_id: did, ref substs } },
+ principal: ty::Binder(ty::TraitRef { def_id: did, ref substs }),
.. }) =>
{
let fqn = csearch::get_item_path(cx.tcx(), did);
projects / rust.git / commitdiff