use syntax::ast::{Ident, MetaItemKind};
use syntax::attr::{InlineAttr, OptimizeAttr, list_contains_name, mark_used};
use syntax::feature_gate;
-use syntax::symbol::{InternedString, kw, Symbol, sym};
+use syntax::symbol::{kw, Symbol, sym};
use syntax_pos::{Span, DUMMY_SP};
use rustc::hir::def::{CtorKind, Res, DefKind};
let param_owner_def_id = tcx.hir().local_def_id(param_owner);
let generics = tcx.generics_of(param_owner_def_id);
let index = generics.param_def_id_to_index[&def_id];
- let ty = tcx.mk_ty_param(index, tcx.hir().ty_param_name(param_id).as_interned_str());
+ let ty = tcx.mk_ty_param(index, tcx.hir().ty_param_name(param_id));
// Don't look for bounds where the type parameter isn't in scope.
let parent = if item_def_id == param_owner_def_id {
opt_self = Some(ty::GenericParamDef {
index: 0,
- name: kw::SelfUpper.as_interned_str(),
+ name: kw::SelfUpper,
def_id: tcx.hir().local_def_id(param_id),
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type {
early_lifetimes
.enumerate()
.map(|(i, param)| ty::GenericParamDef {
- name: param.name.ident().as_interned_str(),
+ name: param.name.ident().name,
index: own_start + i as u32,
def_id: tcx.hir().local_def_id(param.hir_id),
pure_wrt_drop: param.pure_wrt_drop,
let param_def = ty::GenericParamDef {
index: type_start + i as u32,
- name: param.name.ident().as_interned_str(),
+ name: param.name.ident().name,
def_id: tcx.hir().local_def_id(param.hir_id),
pure_wrt_drop: param.pure_wrt_drop,
kind,
.enumerate()
.map(|(i, &arg)| ty::GenericParamDef {
index: type_start + i as u32,
- name: InternedString::intern(arg),
+ name: Symbol::intern(arg),
def_id,
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type {
params.extend(upvars.iter().zip((dummy_args.len() as u32)..).map(|(_, i)| {
ty::GenericParamDef {
index: type_start + i,
- name: InternedString::intern("<upvar>"),
+ name: Symbol::intern("<upvar>"),
def_id,
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type {
);
};
}
+ if ty::search_for_structural_match_violation(
+ param.hir_id, param.span, tcx, ty).is_some()
+ {
+ struct_span_err!(
+ tcx.sess,
+ hir_ty.span,
+ E0741,
+ "the types of const generic parameters must derive `PartialEq` and `Eq`",
+ ).span_label(
+ hir_ty.span,
+ format!("`{}` doesn't derive both `PartialEq` and `Eq`", ty),
+ ).emit();
+ }
ty
}
x => {
);
let inferred_outlives = tcx.inferred_outlives_of(def_id);
if !inferred_outlives.is_empty() {
- let span = tcx.def_span(def_id);
debug!(
"predicates_defined_on: inferred_outlives_of({:?}) = {:?}",
def_id,
inferred_outlives,
);
- result.predicates = tcx.arena.alloc_from_iter(
- result.predicates.iter().copied().chain(
- // FIXME(eddyb) use better spans - maybe add `Span`s
- // to `inferred_outlives_of` predicates as well?
- inferred_outlives.iter().map(|&p| (p, span)),
- ),
- );
+ if result.predicates.is_empty() {
+ result.predicates = inferred_outlives;
+ } else {
+ result.predicates = tcx.arena.alloc_from_iter(
+ result.predicates.iter().chain(inferred_outlives).copied(),
+ );
+ }
}
debug!("predicates_defined_on({:?}) = {:?}", def_id, result);
result
let region = tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
def_id: tcx.hir().local_def_id(param.hir_id),
index,
- name: param.name.ident().as_interned_str(),
+ name: param.name.ident().name,
}));
index += 1;
// type parameter (e.g., `<T: Foo>`).
for param in &ast_generics.params {
if let GenericParamKind::Type { .. } = param.kind {
- let name = param.name.ident().as_interned_str();
+ let name = param.name.ident().name;
let param_ty = ty::ParamTy::new(index, name).to_ty(tcx);
index += 1;