-//! Serialization for client<->server communication.
+//! Serialization for client-server communication.
use std::any::Any;
use std::char;
pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
visitor.visit_vis(&item.vis);
- visitor.visit_name(item.span, item.name);
+ visitor.visit_ident(item.ident);
match item.node {
ItemKind::ExternCrate(orig_name) => {
visitor.visit_id(item.id);
visitor.visit_nested_body(body);
}
ItemKind::Fn(ref declaration, header, ref generics, body_id) => {
- visitor.visit_fn(FnKind::ItemFn(item.name,
+ visitor.visit_fn(FnKind::ItemFn(item.ident.name,
generics,
header,
&item.vis,
ItemKind::Union(ref struct_definition, ref generics) => {
visitor.visit_generics(generics);
visitor.visit_id(item.id);
- visitor.visit_variant_data(struct_definition, item.name, generics, item.id, item.span);
+ visitor.visit_variant_data(struct_definition, item.ident.name, generics, item.id,
+ item.span);
}
ItemKind::Trait(.., ref generics, ref bounds, ref trait_item_refs) => {
visitor.visit_id(item.id);
variant: &'v Variant,
generics: &'v Generics,
parent_item_id: NodeId) {
- visitor.visit_name(variant.span, variant.node.name);
+ visitor.visit_ident(variant.node.ident);
visitor.visit_variant_data(&variant.node.data,
- variant.node.name,
+ variant.node.ident.name,
generics,
parent_item_id,
variant.span);
pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v ForeignItem) {
visitor.visit_id(foreign_item.id);
visitor.visit_vis(&foreign_item.vis);
- visitor.visit_name(foreign_item.span, foreign_item.name);
+ visitor.visit_ident(foreign_item.ident);
match foreign_item.node {
ForeignItemKind::Fn(ref function_declaration, ref param_names, ref generics) => {
let exist_ty_item = hir::Item {
id: exist_ty_id.node_id,
hir_id: exist_ty_id.hir_id,
- name: keywords::Invalid.name(),
+ ident: keywords::Invalid.ident(),
attrs: Default::default(),
node: exist_ty_item_kind,
vis: respan(span.shrink_to_lo(), hir::VisibilityKind::Inherited),
fn lower_variant(&mut self, v: &Variant) -> hir::Variant {
Spanned {
node: hir::VariantKind {
- name: v.node.ident.name,
+ ident: v.node.ident,
attrs: self.lower_attrs(&v.node.attrs),
data: self.lower_variant_data(&v.node.data),
disr_expr: v.node.disr_expr.as_ref().map(|e| self.lower_anon_const(e)),
fn lower_item_kind(
&mut self,
id: NodeId,
- name: &mut Name,
+ ident: &mut Ident,
attrs: &hir::HirVec<Attribute>,
vis: &mut hir::Visibility,
i: &ItemKind,
span: use_tree.span,
};
- self.lower_use_tree(use_tree, &prefix, id, vis, name, attrs)
+ self.lower_use_tree(use_tree, &prefix, id, vis, ident, attrs)
}
ItemKind::Static(ref t, m, ref e) => {
let value = self.lower_body(None, |this| this.lower_expr(e));
prefix: &Path,
id: NodeId,
vis: &mut hir::Visibility,
- name: &mut Name,
+ ident: &mut Ident,
attrs: &hir::HirVec<Attribute>,
) -> hir::ItemKind {
debug!("lower_use_tree(tree={:?})", tree);
match tree.kind {
UseTreeKind::Simple(rename, id1, id2) => {
- *name = tree.ident().name;
+ *ident = tree.ident();
- // First apply the prefix to the path
+ // First, apply the prefix to the path.
let mut path = Path {
segments,
span: path.span,
};
- // Correctly resolve `self` imports
+ // Correctly resolve `self` imports.
if path.segments.len() > 1
&& path.segments.last().unwrap().ident.name == keywords::SelfLower.name()
{
let _ = path.segments.pop();
if rename.is_none() {
- *name = path.segments.last().unwrap().ident.name;
+ *ident = path.segments.last().unwrap().ident;
}
}
let parent_def_index = self.current_hir_id_owner.last().unwrap().0;
let mut defs = self.expect_full_def_from_use(id);
- // we want to return *something* from this function, so hang onto the first item
- // for later
+ // We want to return *something* from this function, so hold onto the first item
+ // for later.
let ret_def = defs.next().unwrap_or(Def::Err);
// Here, we are looping over namespaces, if they exist for the definition
// two imports.
for (def, &new_node_id) in defs.zip([id1, id2].iter()) {
let vis = vis.clone();
- let name = name.clone();
+ let ident = ident.clone();
let mut path = path.clone();
for seg in &mut path.segments {
seg.id = self.sess.next_node_id();
hir::Item {
id: new_id.node_id,
hir_id: new_id.hir_id,
- name: name,
+ ident,
attrs: attrs.clone(),
node: item,
vis,
hir::ItemKind::Use(path, hir::UseKind::Glob)
}
UseTreeKind::Nested(ref trees) => {
- // Nested imports are desugared into simple
- // imports. So if we start with
+ // Nested imports are desugared into simple imports.
+ // So, if we start with
//
// ```
// pub(x) use foo::{a, b};
// `self.items`. However, the structure of this
// function also requires us to return one item, and
// for that we return the `{}` import (called the
- // "`ListStem`").
+ // `ListStem`).
let prefix = Path {
segments,
span: prefix.span.to(path.span),
};
- // Add all the nested PathListItems to the HIR.
+ // Add all the nested `PathListItem`s to the HIR.
for &(ref use_tree, id) in trees {
self.allocate_hir_id_counter(id, &use_tree);
} = self.lower_node_id(id);
let mut vis = vis.clone();
- let mut name = name.clone();
+ let mut ident = ident.clone();
let mut prefix = prefix.clone();
- // Give the segments new ids since they are being cloned.
+ // Give the segments new node-ids since they are being cloned.
for seg in &mut prefix.segments {
seg.id = self.sess.next_node_id();
}
&prefix,
new_id,
&mut vis,
- &mut name,
+ &mut ident,
attrs);
let vis_kind = match vis.node {
hir::Item {
id: new_id,
hir_id: new_hir_id,
- name,
+ ident,
attrs: attrs.clone(),
node: item,
vis,
*vis = respan(prefix.span.shrink_to_lo(), hir::VisibilityKind::Inherited);
}
hir::VisibilityKind::Restricted { .. } => {
- // do nothing here, as described in the comment on the match
+ // Do nothing here, as described in the comment on the match.
}
}
}
pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item> {
- let mut name = i.ident.name;
+ let mut ident = i.ident;
let mut vis = self.lower_visibility(&i.vis, None);
let attrs = self.lower_attrs(&i.attrs);
if let ItemKind::MacroDef(ref def) = i.node {
attr::contains_name(&i.attrs, "rustc_doc_only_macro") {
let body = self.lower_token_stream(def.stream());
self.exported_macros.push(hir::MacroDef {
- name,
+ name: ident.name,
vis,
attrs,
id: i.id,
return None;
}
- let node = self.lower_item_kind(i.id, &mut name, &attrs, &mut vis, &i.node);
+ let node = self.lower_item_kind(i.id, &mut ident, &attrs, &mut vis, &i.node);
let LoweredNodeId { node_id, hir_id } = self.lower_node_id(i.id);
Some(hir::Item {
id: node_id,
hir_id,
- name,
+ ident,
attrs,
node,
vis,
let def_id = self.resolver.definitions().local_def_id(node_id);
hir::ForeignItem {
id: node_id,
- name: i.ident.name,
+ ident: i.ident,
attrs: self.lower_attrs(&i.attrs),
node: match i.node {
ForeignItemKind::Fn(ref fdec, ref generics) => {
ast::ItemKind::Fn(ref decl, header, ref generics, block) =>
item_fn(ItemFnParts {
id: i.id,
- name: i.name,
+ name: i.ident.name,
decl: &decl,
body: block,
vis: &i.vis,
/// Returns the name associated with the given NodeId's AST.
pub fn name(&self, id: NodeId) -> Name {
match self.get(id) {
- Node::Item(i) => i.name,
- Node::ForeignItem(i) => i.name,
+ Node::Item(i) => i.ident.name,
+ Node::ForeignItem(fi) => fi.ident.name,
Node::ImplItem(ii) => ii.ident.name,
Node::TraitItem(ti) => ti.ident.name,
- Node::Variant(v) => v.node.name,
+ Node::Variant(v) => v.node.ident.name,
Node::Field(f) => f.ident.name,
Node::Lifetime(lt) => lt.name.ident().name,
Node::GenericParam(param) => param.name.ident().name,
loop {
if let Node::Item(item) = map.find(id)? {
if item_is_mod(&item) {
- return Some((id, item.name))
+ return Some((id, item.ident.name))
}
}
let parent = map.get_parent(id);
impl<T:Named> Named for Spanned<T> { fn name(&self) -> Name { self.node.name() } }
-impl Named for Item { fn name(&self) -> Name { self.name } }
-impl Named for ForeignItem { fn name(&self) -> Name { self.name } }
-impl Named for VariantKind { fn name(&self) -> Name { self.name } }
+impl Named for Item { fn name(&self) -> Name { self.ident.name } }
+impl Named for ForeignItem { fn name(&self) -> Name { self.ident.name } }
+impl Named for VariantKind { fn name(&self) -> Name { self.ident.name } }
impl Named for StructField { fn name(&self) -> Name { self.ident.name } }
impl Named for TraitItem { fn name(&self) -> Name { self.ident.name } }
impl Named for ImplItem { fn name(&self) -> Name { self.ident.name } }
}
Some(Node::Variant(ref variant)) => {
format!("variant {} in {}{}",
- variant.node.name,
+ variant.node.ident,
path_str(), id_str)
}
Some(Node::Field(ref field)) => {
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct VariantKind {
- pub name: Name,
+ pub ident: Ident,
pub attrs: HirVec<Attribute>,
pub data: VariantData,
/// Explicit discriminant, e.g., `Foo = 1`
/// The name might be a dummy name in case of anonymous items
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Item {
- pub name: Name,
+ pub ident: Ident,
pub id: NodeId,
pub hir_id: HirId,
pub attrs: HirVec<Attribute>,
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct ForeignItem {
- pub name: Name,
+ pub ident: Ident,
pub attrs: HirVec<Attribute>,
pub node: ForeignItemKind,
pub id: NodeId,
abi: Abi::Rust,
asyncness: hir::IsAsync::NotAsync,
},
- Some(item.name),
+ Some(item.ident.name),
generics,
&item.vis,
arg_names,
if m {
self.word_space("mut")?;
}
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.word_space(":")?;
self.print_type(&t)?;
self.s.word(";")?;
}
hir::ForeignItemKind::Type => {
self.head(visibility_qualified(&item.vis, "type"))?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.s.word(";")?;
self.end()?; // end the head-ibox
self.end() // end the outer cbox
self.s.word("as")?;
self.s.space()?;
}
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.s.word(";")?;
self.end()?; // end inner head-block
self.end()?; // end outer head-block
match kind {
hir::UseKind::Single => {
- if path.segments.last().unwrap().ident.name != item.name {
+ if path.segments.last().unwrap().ident != item.ident {
self.s.space()?;
self.word_space("as")?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
}
self.s.word(";")?;
}
if m == hir::MutMutable {
self.word_space("mut")?;
}
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.word_space(":")?;
self.print_type(&ty)?;
self.s.space()?;
}
hir::ItemKind::Const(ref ty, expr) => {
self.head(visibility_qualified(&item.vis, "const"))?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.word_space(":")?;
self.print_type(&ty)?;
self.s.space()?;
self.head("")?;
self.print_fn(decl,
header,
- Some(item.name),
+ Some(item.ident.name),
typarams,
&item.vis,
&[],
}
hir::ItemKind::Mod(ref _mod) => {
self.head(visibility_qualified(&item.vis, "mod"))?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.nbsp()?;
self.bopen()?;
self.print_mod(_mod, &item.attrs)?;
}
hir::ItemKind::Ty(ref ty, ref generics) => {
self.head(visibility_qualified(&item.vis, "type"))?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.print_generic_params(&generics.params)?;
self.end()?; // end the inner ibox
}
hir::ItemKind::Existential(ref exist) => {
self.head(visibility_qualified(&item.vis, "existential type"))?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.print_generic_params(&exist.generics.params)?;
self.end()?; // end the inner ibox
self.end()?; // end the outer ibox
}
hir::ItemKind::Enum(ref enum_definition, ref params) => {
- self.print_enum_def(enum_definition, params, item.name, item.span, &item.vis)?;
+ self.print_enum_def(enum_definition, params, item.ident.name, item.span,
+ &item.vis)?;
}
hir::ItemKind::Struct(ref struct_def, ref generics) => {
self.head(visibility_qualified(&item.vis, "struct"))?;
- self.print_struct(struct_def, generics, item.name, item.span, true)?;
+ self.print_struct(struct_def, generics, item.ident.name, item.span, true)?;
}
hir::ItemKind::Union(ref struct_def, ref generics) => {
self.head(visibility_qualified(&item.vis, "union"))?;
- self.print_struct(struct_def, generics, item.name, item.span, true)?;
+ self.print_struct(struct_def, generics, item.ident.name, item.span, true)?;
}
hir::ItemKind::Impl(unsafety,
polarity,
self.print_is_auto(is_auto)?;
self.print_unsafety(unsafety)?;
self.word_nbsp("trait")?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.print_generic_params(&generics.params)?;
let mut real_bounds = Vec::with_capacity(bounds.len());
for b in bounds.iter() {
self.head("")?;
self.print_visibility(&item.vis)?;
self.word_nbsp("trait")?;
- self.print_name(item.name)?;
+ self.print_ident(item.ident)?;
self.print_generic_params(&generics.params)?;
let mut real_bounds = Vec::with_capacity(bounds.len());
// FIXME(durka) this seems to be some quite outdated syntax
pub fn print_variant(&mut self, v: &hir::Variant) -> io::Result<()> {
self.head("")?;
let generics = hir::Generics::empty();
- self.print_struct(&v.node.data, &generics, v.node.name, v.span, false)?;
+ self.print_struct(&v.node.data, &generics, v.node.ident.name, v.span, false)?;
if let Some(ref d) = v.node.disr_expr {
self.s.space()?;
self.word_space("=")?;
});
impl_stable_hash_for!(struct hir::VariantKind {
- name,
+ ident -> (ident.name),
attrs,
data,
disr_expr
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) {
let hir::Item {
- name,
+ ident,
ref attrs,
id: _,
hir_id: _,
} = *self;
hcx.hash_hir_item_like(|hcx| {
- name.hash_stable(hcx, hasher);
+ ident.name.hash_stable(hcx, hasher);
attrs.hash_stable(hcx, hasher);
node.hash_stable(hcx, hasher);
vis.hash_stable(hcx, hasher);
}
impl_stable_hash_for!(struct hir::ForeignItem {
- name,
+ ident -> (ident.name),
attrs,
node,
id,
self.warn_dead_code(
item.id,
span,
- item.name,
+ item.ident.name,
item.node.descriptive_variant(),
participle,
);
g: &'tcx hir::Generics,
id: ast::NodeId) {
if self.should_warn_about_variant(&variant.node) {
- self.warn_dead_code(variant.node.data.id(), variant.span, variant.node.name,
+ self.warn_dead_code(variant.node.data.id(), variant.span, variant.node.ident.name,
"variant", "constructed");
} else {
intravisit::walk_variant(self, variant, g, id);
fn visit_foreign_item(&mut self, fi: &'tcx hir::ForeignItem) {
if self.should_warn_about_foreign_item(fi) {
- self.warn_dead_code(fi.id, fi.span, fi.name,
+ self.warn_dead_code(fi.id, fi.span, fi.ident.name,
fi.node.descriptive_variant(), "used");
}
intravisit::walk_foreign_item(self, fi);
EntryPointType::Start
} else if attr::contains_name(&item.attrs, "main") {
EntryPointType::MainAttr
- } else if item.name == "main" {
+ } else if item.ident.name == "main" {
if at_root {
// This is a top-level function so can be 'main'.
EntryPointType::MainNamed
Promoted(ref promoted) => write!(fmt, "({:?}: {:?})", promoted.0, promoted.1),
Projection(ref data) => match data.elem {
ProjectionElem::Downcast(ref adt_def, index) => {
- write!(fmt, "({:?} as {})", data.base, adt_def.variants[index].name)
+ write!(fmt, "({:?} as {})", data.base, adt_def.variants[index].ident)
}
ProjectionElem::Deref => write!(fmt, "(*{:?})", data.base),
ProjectionElem::Field(field, ty) => {
use session::{self, DataTypeKind};
use ty::{self, Ty, TyCtxt, TypeFoldable, ReprOptions};
-use syntax::ast::{self, IntTy, UintTy};
+use syntax::ast::{self, Ident, IntTy, UintTy};
use syntax::attr;
use syntax_pos::DUMMY_SP;
let adt_kind = adt_def.adt_kind();
let adt_packed = adt_def.repr.packed();
- let build_variant_info = |n: Option<ast::Name>,
+ let build_variant_info = |n: Option<Ident>,
flds: &[ast::Name],
layout: TyLayout<'tcx>| {
let mut min_size = Size::ZERO;
match layout.variants {
Variants::Single { index } => {
debug!("print-type-size `{:#?}` variant {}",
- layout, adt_def.variants[index].name);
+ layout, adt_def.variants[index].ident);
if !adt_def.variants.is_empty() {
let variant_def = &adt_def.variants[index];
let fields: Vec<_> =
record(adt_kind.into(),
adt_packed,
None,
- vec![build_variant_info(Some(variant_def.name),
+ vec![build_variant_info(Some(variant_def.ident),
&fields,
layout)]);
} else {
adt_def.variants.iter_enumerated().map(|(i, variant_def)| {
let fields: Vec<_> =
variant_def.fields.iter().map(|f| f.ident.name).collect();
- build_variant_info(Some(variant_def.name),
+ build_variant_info(Some(variant_def.ident),
&fields,
layout.for_variant(self, i))
})
/// The variant's `DefId`. If this is a tuple-like struct,
/// this is the `DefId` of the struct's ctor.
pub did: DefId,
- pub name: Name, // struct's name if this is a struct
+ pub ident: Ident, // struct's name if this is a struct
pub discr: VariantDiscr,
pub fields: Vec<FieldDef>,
pub ctor_kind: CtorKind,
/// remove this hack and use the constructor DefId everywhere.
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
did: DefId,
- name: Name,
+ ident: Ident,
discr: VariantDiscr,
fields: Vec<FieldDef>,
adt_kind: AdtKind,
attribute_def_id: DefId)
-> Self
{
- debug!("VariantDef::new({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?})", did, name, discr,
+ debug!("VariantDef::new({:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?})", did, ident, discr,
fields, adt_kind, ctor_kind, attribute_def_id);
let mut flags = VariantFlags::NO_VARIANT_FLAGS;
if adt_kind == AdtKind::Struct && tcx.has_attr(attribute_def_id, "non_exhaustive") {
}
VariantDef {
did,
- name,
+ ident,
discr,
fields,
ctor_kind,
impl_stable_hash_for!(struct VariantDef {
did,
- name,
+ ident -> (ident.name),
discr,
fields,
ctor_kind,
bits
});
-
-
/// Represents the repr options provided by the user,
#[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Default)]
pub struct ReprOptions {
name: if fallback {
String::new()
} else {
- adt.variants[index].name.as_str().to_string()
+ adt.variants[index].ident.as_str().to_string()
},
type_metadata: variant_type_metadata,
offset: Size::ZERO,
name: if fallback {
String::new()
} else {
- adt.variants[i].name.as_str().to_string()
+ adt.variants[i].ident.as_str().to_string()
},
type_metadata: variant_type_metadata,
offset: Size::ZERO,
self.layout,
self.layout.fields.offset(0),
self.layout.field(cx, 0).size);
- name.push_str(&adt.variants[*niche_variants.start()].name.as_str());
+ name.push_str(&adt.variants[*niche_variants.start()].ident.as_str());
// Create the (singleton) list of descriptions of union members.
vec![
};
MemberDescription {
- name: adt.variants[i].name.as_str().to_string(),
+ name: adt.variants[i].ident.as_str().to_string(),
type_metadata: variant_type_metadata,
offset: Size::ZERO,
size: self.layout.size,
containing_scope: &'ll DIScope,
span: Span,
) -> (&'ll DICompositeType, MemberDescriptionFactory<'ll, 'tcx>) {
- let variant_name = variant.name.as_str();
+ let variant_name = variant.ident.as_str();
let unique_type_id = debug_context(cx).type_map
.borrow_mut()
.get_unique_type_id_of_enum_variant(
let enumerators_metadata: Vec<_> = def.discriminants(cx.tcx)
.zip(&def.variants)
.map(|((_, discr), v)| {
- let name = SmallCStr::new(&v.name.as_str());
+ let name = SmallCStr::new(&v.ident.as_str());
unsafe {
Some(llvm::LLVMRustDIBuilderCreateEnumerator(
DIB(cx),
= (&layout.ty.sty, &layout.variants)
{
if def.is_enum() && !def.variants.is_empty() {
- write!(&mut name, "::{}", def.variants[index].name).unwrap();
+ write!(&mut name, "::{}", def.variants[index].ident).unwrap();
}
}
Some(name)
assert!(idx < names.len());
for item in &m.item_ids {
let item = this.infcx.tcx.hir().expect_item(item.id);
- if item.name.to_string() == names[idx] {
+ if item.ident.to_string() == names[idx] {
return search(this, item, idx + 1, names);
}
}
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
if let hir::ItemKind::Mod(_) = it.node {
- self.check_snake_case(cx, "module", &it.name.as_str(), Some(it.span));
+ self.check_snake_case(cx, "module", &it.ident.as_str(), Some(it.span));
}
}
if attr::find_by_name(&it.attrs, "no_mangle").is_some() {
return;
}
- NonUpperCaseGlobals::check_upper_case(cx, "static variable", it.name, it.span);
+ NonUpperCaseGlobals::check_upper_case(cx, "static variable", it.ident.name,
+ it.span);
}
hir::ItemKind::Const(..) => {
- NonUpperCaseGlobals::check_upper_case(cx, "constant", it.name, it.span);
+ NonUpperCaseGlobals::check_upper_case(cx, "constant", it.ident.name,
+ it.span);
}
_ => {}
}
let bytes = variant_layout.size.bytes().saturating_sub(discr_size);
debug!("- variant `{}` is {} bytes large",
- variant.node.name,
+ variant.node.ident,
bytes);
bytes
})
ty::VariantDef::new(
tcx,
def_id,
- self.item_name(index).as_symbol(),
+ Ident::from_interned_str(self.item_name(index)),
data.discr,
item.children.decode(self).map(|index| {
let f = self.entry(index);
let pat_ty = cx.tables.pat_ty(p);
if let ty::Adt(edef, _) = pat_ty.sty {
if edef.is_enum() && edef.variants.iter().any(|variant| {
- variant.name == ident.name && variant.ctor_kind == CtorKind::Const
+ variant.ident == ident && variant.ctor_kind == CtorKind::Const
}) {
let ty_path = cx.tcx.item_path_str(edef.did);
let mut err = struct_span_warn!(cx.tcx.sess, p.span, E0170,
let mut start_or_continue = || if first { first = false; "" } else { ", " };
if let Some(variant) = variant {
- write!(f, "{}", variant.name)?;
+ write!(f, "{}", variant.ident)?;
// Only for Adt we can have `S {...}`,
// which we handle separately here.
variant_id: VariantIdx,
new_op: OpTy<'tcx, M::PointerTag>
) -> EvalResult<'tcx> {
- let name = old_op.layout.ty.ty_adt_def().unwrap().variants[variant_id].name;
+ let name = old_op.layout.ty.ty_adt_def().unwrap().variants[variant_id].ident.name;
self.visit_elem(new_op, PathElem::Variant(name))
}
let features = self.session.features_untracked();
if attr_kind == NonMacroAttrKind::Custom {
assert!(path.segments.len() == 1);
- let name = path.segments[0].ident.name.as_str();
+ let name = path.segments[0].ident.as_str();
if name.starts_with("rustc_") {
if !features.rustc_attrs {
let msg = "unless otherwise specified, attributes with the prefix \
span,
&format!("no variant `{}` on enum `{}`", &assoc_name.as_str(), ty_str),
);
- // Check if it was a typo
- let input = adt_def.variants.iter().map(|variant| &variant.name);
+ // Check if it was a typo.
+ let input = adt_def.variants.iter().map(|variant| &variant.ident.name);
if let Some(suggested_name) = find_best_match_for_name(
input,
&assoc_name.as_str(),
if plural == "" {
let input = unmentioned_fields.iter().map(|field| &field.name);
let suggested_name =
- find_best_match_for_name(input, &ident.name.as_str(), None);
+ find_best_match_for_name(input, &ident.as_str(), None);
if let Some(suggested_name) = suggested_name {
err.span_suggestion(*span, "did you mean", suggested_name.to_string());
// we don't want to throw `E0027` in case we have thrown `E0026` for them
pub fn check_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
it: &hir::ForeignItem) {
let param = |n| tcx.mk_ty_param(n, Symbol::intern(&format!("P{}", n)).as_interned_str());
- let name = it.name.as_str();
+ let name = it.ident.as_str();
let mk_va_list_ty = || {
tcx.lang_items().va_list().map(|did| {
let def_id = tcx.hir().local_def_id(it.id);
let i_n_tps = tcx.generics_of(def_id).own_counts().types;
- let name = it.name.as_str();
+ let name = it.ident.as_str();
let (n_tps, inputs, output) = match &*name {
"simd_eq" | "simd_ne" | "simd_lt" | "simd_le" | "simd_gt" | "simd_ge" => {
"method"
} else if actual.is_enum() {
if let Adt(ref adt_def, _) = actual.sty {
- let names = adt_def.variants.iter().map(|s| &s.name);
+ let names = adt_def.variants.iter().map(|s| &s.ident.name);
suggestion = find_best_match_for_name(names,
&item_name.as_str(),
None);
}
hir::ItemKind::Fn(..) => {} // entirely within check_item_body
hir::ItemKind::Impl(.., ref impl_item_refs) => {
- debug!("ItemKind::Impl {} with id {}", it.name, it.id);
+ debug!("ItemKind::Impl {} with id {}", it.ident, it.id);
let impl_def_id = tcx.hir().local_def_id(it.id);
if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
check_impl_items_against_trait(
ty::Adt(adt, ..) if adt.is_enum() => {
struct_span_err!(self.tcx.sess, field.ident.span, E0559,
"{} `{}::{}` has no field named `{}`",
- kind_name, actual, variant.name, field.ident)
+ kind_name, actual, variant.ident, field.ident)
}
_ => {
struct_span_err!(self.tcx.sess, field.ident.span, E0560,
if adt.is_enum() {
err.span_label(field.ident.span,
format!("`{}::{}` does not have this field",
- ty, variant.name));
+ ty, variant.ident));
} else {
err.span_label(field.ident.span,
format!("`{}` does not have this field", ty));
let parent = self.tcx.hir().get(fn_id);
if let Node::Item(&hir::Item {
- name, node: hir::ItemKind::Fn(ref decl, ..), ..
+ ident, node: hir::ItemKind::Fn(ref decl, ..), ..
}) = parent {
decl.clone().and_then(|decl| {
// This is less than ideal, it will not suggest a return type span on any
// method called `main`, regardless of whether it is actually the entry point,
// but it will still present it as the reason for the expected type.
- Some((decl, name != Symbol::intern("main")))
+ Some((decl, ident.name != Symbol::intern("main")))
})
} else if let Node::TraitItem(&hir::TraitItem {
node: hir::TraitItemKind::Method(hir::MethodSig {
// If the extern crate isn't in the extern prelude,
// there is no way it can be written as an `use`.
- let orig_name = extern_crate.orig_name.unwrap_or(item.name);
+ let orig_name = extern_crate.orig_name.unwrap_or(item.ident.name);
if !tcx.extern_prelude.get(&orig_name).map_or(false, |from_item| !from_item) {
continue;
}
visibility_qualified(&item.vis, "use")
);
let base_replacement = match extern_crate.orig_name {
- Some(orig_name) => format!("use {} as {};", orig_name, item.name),
- None => format!("use {};", item.name),
+ Some(orig_name) => format!("use {} as {};", orig_name, item.ident.name),
+ None => format!("use {};", item.ident.name),
};
let replacement = visibility_qualified(&item.vis, base_replacement);
tcx.struct_span_lint_node(lint, id, extern_crate.span, msg)
def_id: extern_crate_def_id,
span: item.span,
orig_name,
- warn_if_unused: !item.name.as_str().starts_with('_'),
+ warn_if_unused: !item.ident.as_str().starts_with('_'),
}
);
}
use rustc_target::spec::abi;
use syntax::ast;
-use syntax::ast::MetaItemKind;
+use syntax::ast::{Ident, MetaItemKind};
use syntax::attr::{InlineAttr, list_contains_name, mark_used};
use syntax::source_map::Spanned;
use syntax::feature_gate;
fn convert_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_id: ast::NodeId) {
let it = tcx.hir().expect_item(item_id);
- debug!("convert: item {} with id {}", it.name, it.id);
+ debug!("convert: item {} with id {}", it.ident, it.id);
let def_id = tcx.hir().local_def_id(item_id);
match it.node {
// These don't define types.
format!("overflowed on value after {}", prev_discr.unwrap()),
).note(&format!(
"explicitly set `{} = {}` if that is desired outcome",
- variant.node.name, wrapped_discr
+ variant.node.ident, wrapped_discr
))
.emit();
None
fn convert_variant<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
did: DefId,
- name: ast::Name,
+ ident: Ident,
discr: ty::VariantDiscr,
def: &hir::VariantData,
adt_kind: ty::AdtKind,
.collect();
ty::VariantDef::new(tcx,
did,
- name,
+ ident,
discr,
fields,
adt_kind,
CtorKind::from_hir(def),
- attribute_def_id)
+ attribute_def_id
+ )
}
fn adt_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::AdtDef {
};
distance_from_explicit += 1;
- convert_variant(tcx, did, v.node.name, discr, &v.node.data, AdtKind::Enum,
+ convert_variant(tcx, did, v.node.ident, discr, &v.node.data, AdtKind::Enum,
did)
})
.collect(),
std::iter::once(convert_variant(
tcx,
ctor_id.unwrap_or(def_id),
- item.name,
+ item.ident,
ty::VariantDiscr::Relative(0),
def,
AdtKind::Struct,
std::iter::once(convert_variant(
tcx,
def_id,
- item.name,
+ item.ident,
ty::VariantDiscr::Relative(0),
def,
AdtKind::Union,
}
};
Item {
- name: Some(self.name.clean(cx)),
+ name: Some(self.ident.clean(cx)),
attrs: inline::load_attrs(cx, self.did),
source: cx.tcx.def_span(self.did).clean(cx),
visibility: Some(Inherited),
s
}
+impl Clean<String> for Ident {
+ #[inline]
+ fn clean(&self, cx: &DocContext) -> String {
+ self.name.clean(cx)
+ }
+}
+
impl Clean<String> for ast::Name {
+ #[inline]
fn clean(&self, _: &DocContext) -> String {
self.to_string()
}
}
impl Clean<String> for InternedString {
+ #[inline]
fn clean(&self, _: &DocContext) -> String {
self.to_string()
}
};
Item {
- name: Some(self.name.clean(cx)),
+ name: Some(self.ident.clean(cx)),
attrs: self.attrs.clean(cx),
source: self.span.clean(cx),
def_id: cx.tcx.hir().local_def_id(self.id),
for item_id in mem::replace(&mut items, HirVec::new()).iter() {
let item = tcx.hir().expect_item(item_id.id);
- if item.name == *segment {
+ if item.ident.name == *segment {
if path_it.peek().is_none() {
return Some(tcx.hir().local_def_id(item_id.id))
}
};
let parent_def = Def::Enum(parent);
let variant = cx.tcx.expect_variant_def(def);
- Ok((parent_def, Some(format!("{}.v", variant.name))))
+ Ok((parent_def, Some(format!("{}.v", variant.ident.name))))
}
const PRIMITIVES: &[(&str, Def)] = &[
let name = if let hir::ItemKind::Impl(.., ref ty, _) = item.node {
self.map.node_to_pretty_string(ty.id)
} else {
- item.name.to_string()
+ item.ident.to_string()
};
self.visit_testable(name, &item.attrs, |this| {
}
fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem) {
- self.visit_testable(item.name.to_string(), &item.attrs, |this| {
+ self.visit_testable(item.ident.to_string(), &item.attrs, |this| {
intravisit::walk_foreign_item(this, item);
});
}
v: &'hir hir::Variant,
g: &'hir hir::Generics,
item_id: ast::NodeId) {
- self.visit_testable(v.node.name.to_string(), &v.node.attrs, |this| {
+ self.visit_testable(v.node.ident.to_string(), &v.node.attrs, |this| {
intravisit::walk_variant(this, v, g, item_id);
});
}
Enum {
name,
variants: def.variants.iter().map(|v| Variant {
- name: v.node.name,
+ name: v.node.ident.name,
attrs: v.node.attrs.clone(),
stab: self.stability(v.node.data.id()),
depr: self.deprecation(v.node.data.id()),
fn maybe_inline_local(&mut self,
id: ast::NodeId,
def: Def,
- renamed: Option<ast::Name>,
+ renamed: Option<ast::Ident>,
glob: bool,
om: &mut Module,
please_inline: bool) -> bool {
om.foreigns.push(hir::ForeignMod {
abi: tcx.hir().get_foreign_abi(it.id),
items: vec![hir::ForeignItem {
- name: renamed.unwrap_or(it.name),
+ ident: renamed.unwrap_or(it.ident),
.. it.clone()
}].into(),
});
true
}
Node::MacroDef(def) if !glob => {
- om.macros.push(self.visit_local_macro(def, renamed));
+ om.macros.push(self.visit_local_macro(def, renamed.map(|i| i.name)));
true
}
_ => false,
}
pub fn visit_item(&mut self, item: &hir::Item,
- renamed: Option<ast::Name>, om: &mut Module) {
+ renamed: Option<ast::Ident>, om: &mut Module) {
debug!("Visiting item {:?}", item);
- let name = renamed.unwrap_or(item.name);
+ let ident = renamed.unwrap_or(item.ident);
if item.vis.node.is_pub() {
let def_id = self.cx.tcx.hir().local_def_id(item.id);
om.extern_crates.push(ExternCrate {
cnum: self.cx.tcx.extern_mod_stmt_cnum(def_id)
.unwrap_or(LOCAL_CRATE),
- name,
+ name: ident.name,
path: orig_name.map(|x|x.to_string()),
vis: item.vis.clone(),
attrs: item.attrs.clone(),
_ => false,
}
});
- let name = if is_glob { None } else { Some(name) };
+ let ident = if is_glob { None } else { Some(ident) };
if self.maybe_inline_local(item.id,
path.def,
- name,
+ ident,
is_glob,
om,
please_inline) {
}
om.imports.push(Import {
- name,
+ name: ident.name,
id: item.id,
vis: item.vis.clone(),
attrs: item.attrs.clone(),
item.vis.clone(),
item.id,
m,
- Some(name)));
+ Some(ident.name)));
},
hir::ItemKind::Enum(ref ed, ref gen) =>
- om.enums.push(self.visit_enum_def(item, name, ed, gen)),
+ om.enums.push(self.visit_enum_def(item, ident.name, ed, gen)),
hir::ItemKind::Struct(ref sd, ref gen) =>
- om.structs.push(self.visit_variant_data(item, name, sd, gen)),
+ om.structs.push(self.visit_variant_data(item, ident.name, sd, gen)),
hir::ItemKind::Union(ref sd, ref gen) =>
- om.unions.push(self.visit_union_data(item, name, sd, gen)),
+ om.unions.push(self.visit_union_data(item, ident.name, sd, gen)),
hir::ItemKind::Fn(ref fd, header, ref gen, body) =>
- self.visit_fn(om, item, name, &**fd, header, gen, body),
+ self.visit_fn(om, item, ident.name, &**fd, header, gen, body),
hir::ItemKind::Ty(ref ty, ref gen) => {
let t = Typedef {
ty: ty.clone(),
gen: gen.clone(),
- name,
+ name: ident.name,
id: item.id,
attrs: item.attrs.clone(),
whence: item.span,
hir::ItemKind::Existential(ref exist_ty) => {
let t = Existential {
exist_ty: exist_ty.clone(),
- name,
+ name: ident.name,
id: item.id,
attrs: item.attrs.clone(),
whence: item.span,
mutability: mut_.clone(),
expr: exp.clone(),
id: item.id,
- name,
+ name: ident.name,
attrs: item.attrs.clone(),
whence: item.span,
vis: item.vis.clone(),
type_: ty.clone(),
expr: exp.clone(),
id: item.id,
- name,
+ name: ident.name,
attrs: item.attrs.clone(),
whence: item.span,
vis: item.vis.clone(),
let t = Trait {
is_auto,
unsafety,
- name,
+ name: ident.name,
items,
generics: gen.clone(),
bounds: b.iter().cloned().collect(),
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// force-host
+
+#![feature(plugin_registrar)]
+#![feature(box_syntax, rustc_private)]
+
+// Load rustc as a plugin to get macros.
+#[macro_use]
+extern crate rustc;
+extern crate rustc_plugin;
+
+use rustc::hir;
+use rustc::lint::{LateContext, LintContext, LintPass, LateLintPass, LateLintPassObject, LintArray};
+use rustc_plugin::Registry;
+
+declare_lint!(TEST_LINT, Warn, "Warn about items named 'lintme'");
+
+declare_lint!(PLEASE_LINT, Warn, "Warn about items named 'pleaselintme'");
+
+struct Pass;
+
+impl LintPass for Pass {
+ fn get_lints(&self) -> LintArray {
+ lint_array!(TEST_LINT, PLEASE_LINT)
+ }
+}
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
+ fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ match &*it.ident.as_str() {
+ "lintme" => cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'"),
+ "pleaselintme" => cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'"),
+ _ => {}
+ }
+ }
+}
+
+#[plugin_registrar]
+pub fn plugin_registrar(reg: &mut Registry) {
+ reg.register_late_lint_pass(box Pass);
+ reg.register_lint_group("lint_me", None, vec![TEST_LINT, PLEASE_LINT]);
+}
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
-// Load rustc as a plugin to get macros
+// Load rustc as a plugin to get macros.
#[macro_use]
extern crate rustc;
extern crate rustc_plugin;
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
- match &*it.name.as_str() {
+ match &*it.ident.as_str() {
"lintme" => cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'"),
"pleaselintme" => cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'"),
_ => {}
// run-pass
// aux-build:lint_group_plugin_test.rs
// ignore-stage1
+
#![feature(plugin)]
#![plugin(lint_group_plugin_test)]
#![allow(dead_code)]
warning: item is named 'lintme'
- --> $DIR/lint-group-plugin.rs:8:1
+ --> $DIR/lint-group-plugin.rs:9:1
|
LL | fn lintme() { } //~ WARNING item is named 'lintme'
| ^^^^^^^^^^^^^^^
= note: #[warn(test_lint)] on by default
warning: item is named 'pleaselintme'
- --> $DIR/lint-group-plugin.rs:9:1
+ --> $DIR/lint-group-plugin.rs:10:1
|
LL | fn pleaselintme() { } //~ WARNING item is named 'pleaselintme'
| ^^^^^^^^^^^^^^^^^^^^^
projects / rust.git / commitdiff