use middle::ty::{self, RegionEscape, Ty, ToPredicate, HasTypeFlags};
use middle::ty_fold;
use require_c_abi_if_variadic;
-use rscope::{self, UnelidableRscope, RegionScope, ElidableRscope, ExplicitRscope,
+use rscope::{self, UnelidableRscope, RegionScope, ElidableRscope,
ObjectLifetimeDefaultRscope, ShiftedRscope, BindingRscope,
ElisionFailureInfo, ElidedLifetime};
use util::common::{ErrorReported, FN_OUTPUT_NAME};
use std::slice;
use syntax::{abi, ast, ast_util};
use syntax::codemap::{Span, Pos};
+use syntax::feature_gate::emit_feature_err;
use syntax::parse::token;
use syntax::print::pprust;
// For now, require that parenthetical notation be used
// only with `Fn()` etc.
if !this.tcx().sess.features.borrow().unboxed_closures && trait_def.paren_sugar {
- span_err!(this.tcx().sess, span, E0215,
- "angle-bracket notation is not stable when \
- used with the `Fn` family of traits, use parentheses");
- fileline_help!(this.tcx().sess, span,
- "add `#![feature(unboxed_closures)]` to \
- the crate attributes to enable");
+ emit_feature_err(&this.tcx().sess.parse_sess.span_diagnostic,
+ "unboxed_closures", span,
+ "\
+ the precise format of `Fn`-family traits' type parameters is \
+ subject to change. Use parenthetical notation (Fn(Foo, Bar) -> Baz) instead");
}
convert_angle_bracketed_parameters(this, rscope, span, &trait_def.generics, data)
// For now, require that parenthetical notation be used
// only with `Fn()` etc.
if !this.tcx().sess.features.borrow().unboxed_closures && !trait_def.paren_sugar {
- span_err!(this.tcx().sess, span, E0216,
- "parenthetical notation is only stable when \
- used with the `Fn` family of traits");
- fileline_help!(this.tcx().sess, span,
- "add `#![feature(unboxed_closures)]` to \
- the crate attributes to enable");
+ emit_feature_err(&this.tcx().sess.parse_sess.span_diagnostic,
+ "unboxed_closures", span,
+ "\
+ parenthetical notation is only stable when used with `Fn`-family traits");
}
convert_parenthesized_parameters(this, rscope, span, &trait_def.generics, data)
let candidate = try!(one_bound_for_assoc_type(tcx,
candidates,
&trait_ref.to_string(),
- &token::get_name(binding.item_name),
+ &binding.item_name.as_str(),
binding.span));
Ok(ty::Binder(ty::ProjectionPredicate { // <-------------------------+
one_bound_for_assoc_type(tcx,
suitable_bounds,
- &token::get_name(ty_param_name),
- &token::get_name(assoc_name),
+ &ty_param_name.as_str(),
+ &assoc_name.as_str(),
span)
}
(_, def::DefSelfTy(Some(trait_did), Some((impl_id, _)))) => {
// `Self` in an impl of a trait - we have a concrete self type and a
// trait reference.
- match tcx.map.expect_item(impl_id).node {
- ast::ItemImpl(_, _, _, Some(ref trait_ref), _, _) => {
- if this.ensure_super_predicates(span, trait_did).is_err() {
- return (tcx.types.err, ty_path_def);
- }
+ let trait_ref = tcx.impl_trait_ref(ast_util::local_def(impl_id)).unwrap();
+ let trait_ref = if let Some(free_substs) = this.get_free_substs() {
+ trait_ref.subst(tcx, free_substs)
+ } else {
+ trait_ref
+ };
- let trait_segment = &trait_ref.path.segments.last().unwrap();
- let trait_ref = ast_path_to_mono_trait_ref(this,
- &ExplicitRscope,
- span,
- PathParamMode::Explicit,
- trait_did,
- Some(ty),
- trait_segment);
-
- let candidates: Vec<ty::PolyTraitRef> =
- traits::supertraits(tcx, ty::Binder(trait_ref.clone()))
- .filter(|r| this.trait_defines_associated_type_named(r.def_id(),
- assoc_name))
- .collect();
-
- match one_bound_for_assoc_type(tcx,
- candidates,
- "Self",
- &token::get_name(assoc_name),
- span) {
- Ok(bound) => bound,
- Err(ErrorReported) => return (tcx.types.err, ty_path_def),
- }
- }
- _ => unreachable!()
+ if this.ensure_super_predicates(span, trait_did).is_err() {
+ return (tcx.types.err, ty_path_def);
+ }
+
+ let candidates: Vec<ty::PolyTraitRef> =
+ traits::supertraits(tcx, ty::Binder(trait_ref))
+ .filter(|r| this.trait_defines_associated_type_named(r.def_id(),
+ assoc_name))
+ .collect();
+
+ match one_bound_for_assoc_type(tcx,
+ candidates,
+ "Self",
+ &assoc_name.as_str(),
+ span) {
+ Ok(bound) => bound,
+ Err(ErrorReported) => return (tcx.types.err, ty_path_def),
}
}
- (&ty::TyParam(_), def::DefSelfTy(Some(trait_did), None)) => {
+ (&ty::TyParam(_), def::DefSelfTy(Some(trait_did), None)) => {
assert_eq!(trait_did.krate, ast::LOCAL_CRATE);
match find_bound_for_assoc_item(this,
trait_did.node,
span,
&ty.to_string(),
"Trait",
- &token::get_name(assoc_name));
+ &assoc_name.as_str());
return (tcx.types.err, ty_path_def);
}
};
span,
"Type",
&path_str,
- &token::get_ident(item_segment.identifier));
+ &item_segment.identifier.name.as_str());
return tcx.types.err;
};
// handled specially and will not descend into this routine.
this.ty_infer(None, None, None, ast_ty.span)
}
+ ast::TyMac(_) => {
+ tcx.sess.span_bug(ast_ty.span, "unexpanded type macro found conversion")
+ }
};
tcx.ast_ty_to_ty_cache.borrow_mut().insert(ast_ty.id, typ);
projects / rust.git / blobdiff