use rustc::ty::{GenericParamDef, GenericParamDefKind};
use rustc::ty::subst::{self, Subst, InternalSubsts, SubstsRef};
use rustc::ty::wf::object_region_bounds;
-use rustc::mir::interpret::ConstValue;
use rustc_target::spec::abi;
use crate::require_c_abi_if_c_variadic;
use smallvec::SmallVec;
use syntax::ast;
-use syntax::errors::pluralise;
+use syntax::errors::pluralize;
use syntax::feature_gate::{GateIssue, emit_feature_err};
use syntax::util::lev_distance::find_best_match_for_name;
use syntax::symbol::sym;
pub trait AstConv<'tcx> {
fn tcx<'a>(&'a self) -> TyCtxt<'tcx>;
+ fn item_def_id(&self) -> Option<DefId>;
+
/// Returns predicates in scope of the form `X: Foo`, where `X` is
/// a type parameter `X` with the given id `def_id`. This is a
/// subset of the full set of predicates.
quantifier,
bound,
kind,
- pluralise!(bound),
+ pluralize!(bound),
))
};
span,
E0191,
"the value of the associated type{} {} must be specified",
- pluralise!(associated_types.len()),
+ pluralize!(associated_types.len()),
names,
);
let (suggest, potential_assoc_types_spans) =
-> Ty<'tcx>
{
let tcx = self.tcx();
+
let trait_def_id = tcx.parent(item_def_id).unwrap();
+ debug!("qpath_to_ty: trait_def_id={:?}", trait_def_id);
+
self.prohibit_generics(slice::from_ref(item_segment));
let self_ty = if let Some(ty) = opt_self_ty {
ty
} else {
let path_str = tcx.def_path_str(trait_def_id);
+
+ let def_id = self.item_def_id();
+
+ debug!("qpath_to_ty: self.item_def_id()={:?}", def_id);
+
+ let parent_def_id = def_id.and_then(|def_id| tcx.hir().as_local_hir_id(def_id))
+ .map(|hir_id| tcx.hir().get_parent_did(hir_id));
+
+ debug!("qpath_to_ty: parent_def_id={:?}", parent_def_id);
+
+ // If the trait in segment is the same as the trait defining the item,
+ // use the `<Self as ..>` syntax in the error.
+ let is_part_of_self_trait_constraints = def_id == Some(trait_def_id);
+ let is_part_of_fn_in_self_trait = parent_def_id == Some(trait_def_id);
+
+ let type_name = if is_part_of_self_trait_constraints || is_part_of_fn_in_self_trait {
+ "Self"
+ } else {
+ "Type"
+ };
+
self.report_ambiguous_associated_type(
span,
- "Type",
+ type_name,
&path_str,
item_segment.ident.name,
);
let def_id = tcx.hir().local_def_id(ast_const.hir_id);
let mut const_ = ty::Const {
- val: ConstValue::Unevaluated(
+ val: ty::ConstKind::Unevaluated(
def_id,
InternalSubsts::identity_for_item(tcx, def_id),
),
let generics = tcx.generics_of(item_def_id);
let index = generics.param_def_id_to_index[&tcx.hir().local_def_id(hir_id)];
let name = tcx.hir().name(hir_id);
- const_.val = ConstValue::Param(ty::ParamConst::new(index, name));
+ const_.val = ty::ConstKind::Param(ty::ParamConst::new(index, name));
}
tcx.mk_const(const_)