mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename PathSegment::identifier to ident

Browse Source
This commit is contained in:
Vadim Petrochenkov 2018-03-18 03:53:41 +03:00
parent baae274fb7
commit 8719d1ed05
19 changed files with 67 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/librustc/hir/lowering.rs
View File

@ -1607,7 +1607,7 @@ impl<'a> LoweringContext<'a> {
}
hir::PathSegment::new(
self.lower_ident(segment.identifier),
self.lower_ident(segment.ident),
parameters,
infer_types,
)
@ -2356,11 +2356,11 @@ impl<'a> LoweringContext<'a> {
// Correctly resolve `self` imports
if path.segments.len() > 1
&& path.segments.last().unwrap().identifier.name == keywords::SelfValue.name()
&& path.segments.last().unwrap().ident.name == keywords::SelfValue.name()
{
let _ = path.segments.pop();
if rename.is_none() {
*name = path.segments.last().unwrap().identifier.name;
*name = path.segments.last().unwrap().ident.name;
}
}

2
src/librustc/ich/impls_syntax.rs
View File

@ -211,7 +211,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for ast::Attribute {
style.hash_stable(hcx, hasher);
path.segments.len().hash_stable(hcx, hasher);
for segment in &path.segments {
segment.identifier.name.hash_stable(hcx, hasher);
segment.ident.name.hash_stable(hcx, hasher);
}
for tt in tokens.trees() {
tt.hash_stable(hcx, hasher);

8
src/librustc_resolve/build_reduced_graph.rs
View File

@ -115,7 +115,7 @@ impl<'a> Resolver<'a> {
let mut module_path: Vec<_> = prefix.segments.iter()
.chain(path.segments.iter())
.map(|seg| respan(seg.span, seg.identifier))
.map(|seg| respan(seg.span, seg.ident))
.collect();
match use_tree.kind {
@ -196,11 +196,7 @@ impl<'a> Resolver<'a> {
ast::UseTreeKind::Nested(ref items) => {
let prefix = ast::Path {
segments: module_path.iter()
.map(|s| ast::PathSegment {
identifier: s.node,
span: s.span,
parameters: None,
})
.map(|s| ast::PathSegment::from_ident(s.node, s.span))
.collect(),
span: path.span,
};

12
src/librustc_resolve/lib.rs
View File

@ -2351,7 +2351,7 @@ impl<'a> Resolver<'a> {
let mut new_id = None;
if let Some(trait_ref) = opt_trait_ref {
let path: Vec<_> = trait_ref.path.segments.iter()
.map(|seg| respan(seg.span, seg.identifier))
.map(|seg| respan(seg.span, seg.ident))
.collect();
let def = self.smart_resolve_path_fragment(
trait_ref.ref_id,
@ -2786,7 +2786,7 @@ impl<'a> Resolver<'a> {
source: PathSource)
-> PathResolution {
let segments = &path.segments.iter()
.map(|seg| respan(seg.span, seg.identifier))
.map(|seg| respan(seg.span, seg.ident))
.collect::<Vec<_>>();
self.smart_resolve_path_fragment(id, qself, segments, path.span, source)
}
@ -2924,7 +2924,7 @@ impl<'a> Resolver<'a> {
}
ExprKind::MethodCall(ref segment, ..) => {
err.span_label(parent.span, format!("did you mean `{}::{}(...)`?",
path_str, segment.identifier));
path_str, segment.ident));
return (err, candidates);
}
_ => {}
@ -3750,7 +3750,7 @@ impl<'a> Resolver<'a> {
ExprKind::MethodCall(ref segment, ..) => {
debug!("(recording candidate traits for expr) recording traits for {}",
expr.id);
let traits = self.get_traits_containing_item(segment.identifier, ValueNS);
let traits = self.get_traits_containing_item(segment.ident, ValueNS);
self.trait_map.insert(expr.id, traits);
}
_ => {
@ -4222,7 +4222,7 @@ impl<'a> Resolver<'a> {
if attr.path.segments.len() > 1 {
continue
}
let ident = attr.path.segments[0].identifier;
let ident = attr.path.segments[0].ident;
let result = self.resolve_lexical_macro_path_segment(ident,
MacroNS,
false,
@ -4267,7 +4267,7 @@ fn names_to_string(idents: &[SpannedIdent]) -> String {
fn path_names_to_string(path: &Path) -> String {
names_to_string(&path.segments.iter()
.map(|seg| respan(seg.span, seg.identifier))
.map(|seg| respan(seg.span, seg.ident))
.collect::<Vec<_>>())
}

12
src/librustc_resolve/macros.rs
View File

@ -137,9 +137,9 @@ impl<'a> base::Resolver for Resolver<'a> {
impl<'a, 'b> Folder for EliminateCrateVar<'a, 'b> {
fn fold_path(&mut self, mut path: ast::Path) -> ast::Path {
let ident = path.segments[0].identifier;
let ident = path.segments[0].ident;
if ident.name == keywords::DollarCrate.name() {
path.segments[0].identifier.name = keywords::CrateRoot.name();
path.segments[0].ident.name = keywords::CrateRoot.name();
let module = self.0.resolve_crate_root(ident.span.ctxt(), true);
if !module.is_local() {
let span = path.segments[0].span;
@ -249,7 +249,7 @@ impl<'a> base::Resolver for Resolver<'a> {
if traits[j].segments.len() > 1 {
continue
}
let trait_name = traits[j].segments[0].identifier.name;
let trait_name = traits[j].segments[0].ident.name;
let legacy_name = Symbol::intern(&format!("derive_{}", trait_name));
if !self.global_macros.contains_key(&legacy_name) {
continue
@ -268,7 +268,7 @@ impl<'a> base::Resolver for Resolver<'a> {
if k > 0 {
tokens.push(TokenTree::Token(path.span, Token::ModSep).into());
}
let tok = Token::from_ast_ident(segment.identifier);
let tok = Token::from_ast_ident(segment.ident);
tokens.push(TokenTree::Token(path.span, tok).into());
}
}
@ -365,7 +365,7 @@ impl<'a> Resolver<'a> {
}
let attr_name = match path.segments.len() {
1 => path.segments[0].identifier.name,
1 => path.segments[0].ident.name,
_ => return Err(determinacy),
};
for path in traits {
@ -413,7 +413,7 @@ impl<'a> Resolver<'a> {
kind: MacroKind, force: bool)
-> Result<Def, Determinacy> {
let ast::Path { ref segments, span } = *path;
let path: Vec<_> = segments.iter().map(|seg| respan(seg.span, seg.identifier)).collect();
let path: Vec<_> = segments.iter().map(|seg| respan(seg.span, seg.ident)).collect();
let invocation = self.invocations[&scope];
let module = invocation.module.get();
self.current_module = if module.is_trait() { module.parent.unwrap() } else { module };

12
src/librustdoc/clean/mod.rs
View File

@ -1146,16 +1146,8 @@ fn resolve(cx: &DocContext, path_str: &str, is_val: bool) -> Result<(Def, Option
fn macro_resolve(cx: &DocContext, path_str: &str) -> Option<Def> {
use syntax::ext::base::{MacroKind, SyntaxExtension};
use syntax::ext::hygiene::Mark;
let segment = ast::PathSegment {
identifier: ast::Ident::from_str(path_str),
span: DUMMY_SP,
parameters: None,
};
let path = ast::Path {
span: DUMMY_SP,
segments: vec![segment],
};
let segment = ast::PathSegment::from_ident(ast::Ident::from_str(path_str), DUMMY_SP);
let path = ast::Path { segments: vec![segment], span: DUMMY_SP };
let mut resolver = cx.resolver.borrow_mut();
let mark = Mark::root();
let res = resolver

20
src/libsyntax/ast.rs
View File

@ -82,7 +82,7 @@ pub struct Path {
impl<'a> PartialEq<&'a str> for Path {
fn eq(&self, string: &&'a str) -> bool {
self.segments.len() == 1 && self.segments[0].identifier.name == *string
self.segments.len() == 1 && self.segments[0].ident.name == *string
}
}
@ -101,17 +101,17 @@ impl fmt::Display for Path {
impl Path {
// convert a span and an identifier to the corresponding
// 1-segment path
pub fn from_ident(s: Span, identifier: Ident) -> Path {
pub fn from_ident(s: Span, ident: Ident) -> Path {
Path {
span: s,
segments: vec![PathSegment::from_ident(identifier, s)],
segments: vec![PathSegment::from_ident(ident, s)],
}
}
// Make a "crate root" segment for this path unless it already has it
// or starts with something like `self`/`super`/`$crate`/etc.
pub fn make_root(&self) -> Option<PathSegment> {
if let Some(ident) = self.segments.get(0).map(|seg| seg.identifier) {
if let Some(ident) = self.segments.get(0).map(|seg| seg.ident) {
if ::parse::token::is_path_segment_keyword(ident) &&
ident.name != keywords::Crate.name() {
return None;
@ -121,7 +121,7 @@ impl Path {
}
pub fn is_global(&self) -> bool {
!self.segments.is_empty() && self.segments[0].identifier.name == keywords::CrateRoot.name()
!self.segments.is_empty() && self.segments[0].ident.name == keywords::CrateRoot.name()
}
}
@ -131,7 +131,7 @@ impl Path {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct PathSegment {
/// The identifier portion of this path segment.
pub identifier: Ident,
pub ident: Ident,
/// Span of the segment identifier.
pub span: Span,
@ -146,14 +146,10 @@ pub struct PathSegment {
impl PathSegment {
pub fn from_ident(ident: Ident, span: Span) -> Self {
PathSegment { identifier: ident, span: span, parameters: None }
PathSegment { ident, span, parameters: None }
}
pub fn crate_root(span: Span) -> Self {
PathSegment {
identifier: Ident::new(keywords::CrateRoot.name(), span),
span,
parameters: None,
}
PathSegment::from_ident(Ident::new(keywords::CrateRoot.name(), span), span)
}
}

6
src/libsyntax/attr.rs
View File

@ -215,7 +215,7 @@ impl Attribute {
pub fn name(&self) -> Option<Name> {
match self.path.segments.len() {
1 => Some(self.path.segments[0].identifier.name),
1 => Some(self.path.segments[0].ident.name),
_ => None,
}
}
@ -301,7 +301,7 @@ impl Attribute {
let mut tokens = self.tokens.trees().peekable();
Some(MetaItem {
name: match self.path.segments.len() {
1 => self.path.segments[0].identifier.name,
1 => self.path.segments[0].ident.name,
_ => return None,
},
node: if let Some(node) = MetaItemKind::from_tokens(&mut tokens) {
@ -353,7 +353,7 @@ impl Attribute {
}
Ok(MetaItem {
name: self.path.segments.last().unwrap().identifier.name,
name: self.path.segments.last().unwrap().ident.name,
node: self.parse(sess, |parser| parser.parse_meta_item_kind())?,
span: self.span,
})

6
src/libsyntax/ext/build.rs
View File

@ -319,7 +319,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
types: Vec<P<ast::Ty>>,
bindings: Vec<ast::TypeBinding> )
-> ast::Path {
let last_identifier = idents.pop().unwrap();
let last_ident = idents.pop().unwrap();
let mut segments: Vec<ast::PathSegment> = Vec::new();
segments.extend(idents.into_iter().map(|i| ast::PathSegment::from_ident(i, span)));
@ -328,7 +328,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} else {
None
};
segments.push(ast::PathSegment { identifier: last_identifier, span, parameters });
segments.push(ast::PathSegment { ident: last_ident, span, parameters });
let mut path = ast::Path { span, segments };
if global {
if let Some(seg) = path.make_root() {
@ -367,7 +367,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
None
};
path.segments.push(ast::PathSegment {
identifier: ident.node,
ident: ident.node,
span: ident.span,
parameters,
});

2
src/libsyntax/ext/derive.rs
View File

@ -54,7 +54,7 @@ pub fn add_derived_markers<T>(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path]
pretty_name.push_str(", ");
}
pretty_name.push_str(&path.to_string());
names.insert(unwrap_or!(path.segments.get(0), continue).identifier.name);
names.insert(unwrap_or!(path.segments.get(0), continue).ident.name);
}
pretty_name.push(')');

8
src/libsyntax/ext/expand.rs
View File

@ -168,10 +168,10 @@ fn macro_bang_format(path: &ast::Path) -> ExpnFormat {
path_str.push_str("::");
}
if segment.identifier.name != keywords::CrateRoot.name() &&
segment.identifier.name != keywords::DollarCrate.name()
if segment.ident.name != keywords::CrateRoot.name() &&
segment.ident.name != keywords::DollarCrate.name()
{
path_str.push_str(&segment.identifier.name.as_str())
path_str.push_str(&segment.ident.name.as_str())
}
}
@ -688,7 +688,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
opt_expanded
} else {
let msg = format!("non-{kind} macro in {kind} position: {name}",
name = path.segments[0].identifier.name, kind = kind.name());
name = path.segments[0].ident.name, kind = kind.name());
self.cx.span_err(path.span, &msg);
self.cx.trace_macros_diag();
kind.dummy(span)

2
src/libsyntax/ext/quote.rs
View File

@ -239,7 +239,7 @@ pub mod rt {
inner.push(TokenTree::Token(self.span, token::Colon).into());
}
inner.push(TokenTree::Token(
self.span, token::Token::from_ast_ident(segment.identifier)
self.span, token::Token::from_ast_ident(segment.ident)
).into());
}
inner.push(self.tokens.clone());

4
src/libsyntax/feature_gate.rs
View File

@ -1766,10 +1766,10 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
fn visit_path(&mut self, path: &'a ast::Path, _id: NodeId) {
for segment in &path.segments {
if segment.identifier.name == keywords::Crate.name() {
if segment.ident.name == keywords::Crate.name() {
gate_feature_post!(&self, crate_in_paths, segment.span,
"`crate` in paths is experimental");
} else if segment.identifier.name == keywords::Extern.name() {
} else if segment.ident.name == keywords::Extern.name() {
gate_feature_post!(&self, extern_in_paths, segment.span,
"`extern` in paths is experimental");
}

6
src/libsyntax/fold.rs
View File

@ -449,8 +449,8 @@ pub fn noop_fold_usize<T: Folder>(i: usize, _: &mut T) -> usize {
pub fn noop_fold_path<T: Folder>(Path { segments, span }: Path, fld: &mut T) -> Path {
Path {
segments: segments.move_map(|PathSegment {identifier, span, parameters}| PathSegment {
identifier: fld.fold_ident(identifier),
segments: segments.move_map(|PathSegment {ident, span, parameters}| PathSegment {
ident: fld.fold_ident(ident),
span: fld.new_span(span),
parameters: parameters.map(|ps| ps.map(|ps| fld.fold_path_parameters(ps))),
}),
@ -1195,7 +1195,7 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
ExprKind::MethodCall(seg, args) => {
ExprKind::MethodCall(
PathSegment {
identifier: folder.fold_ident(seg.identifier),
ident: folder.fold_ident(seg.ident),
span: folder.new_span(seg.span),
parameters: seg.parameters.map(|ps| {
ps.map(|ps| folder.fold_path_parameters(ps))

4
src/libsyntax/parse/parser.rs
View File

@ -2051,7 +2051,7 @@ impl<'a> Parser<'a> {
ParenthesizedParameterData { inputs, output, span }.into()
};
PathSegment { identifier: ident, span: ident_span, parameters }
PathSegment { ident, span: ident_span, parameters }
} else {
// Generic arguments are not found.
PathSegment::from_ident(ident, ident_span)
@ -2592,7 +2592,7 @@ impl<'a> Parser<'a> {
}
let span = lo.to(self.prev_span);
let ident = respan(segment.span, segment.identifier);
let ident = respan(segment.span, segment.ident);
self.mk_expr(span, ExprKind::Field(self_arg, ident), ThinVec::new())
}
})

24
src/libsyntax/print/pprust.rs
View File

@ -739,11 +739,11 @@ pub trait PrintState<'a> {
if i > 0 {
self.writer().word("::")?
}
if segment.identifier.name != keywords::CrateRoot.name() &&
segment.identifier.name != keywords::DollarCrate.name() {
self.writer().word(&segment.identifier.name.as_str())?;
} else if segment.identifier.name == keywords::DollarCrate.name() {
self.print_dollar_crate(segment.identifier.span.ctxt())?;
if segment.ident.name != keywords::CrateRoot.name() &&
segment.ident.name != keywords::DollarCrate.name() {
self.writer().word(&segment.ident.name.as_str())?;
} else if segment.ident.name == keywords::DollarCrate.name() {
self.print_dollar_crate(segment.ident.span.ctxt())?;
}
}
self.writer().space()?;
@ -1981,7 +1981,7 @@ impl<'a> State<'a> {
let base_args = &args[1..];
self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX)?;
self.s.word(".")?;
self.print_ident(segment.identifier)?;
self.print_ident(segment.ident)?;
if let Some(ref parameters) = segment.parameters {
self.print_path_parameters(parameters, true)?;
}
@ -2417,14 +2417,14 @@ impl<'a> State<'a> {
colons_before_params: bool)
-> io::Result<()>
{
if segment.identifier.name != keywords::CrateRoot.name() &&
segment.identifier.name != keywords::DollarCrate.name() {
self.print_ident(segment.identifier)?;
if segment.ident.name != keywords::CrateRoot.name() &&
segment.ident.name != keywords::DollarCrate.name() {
self.print_ident(segment.ident)?;
if let Some(ref parameters) = segment.parameters {
self.print_path_parameters(parameters, colons_before_params)?;
}
} else if segment.identifier.name == keywords::DollarCrate.name() {
self.print_dollar_crate(segment.identifier.span.ctxt())?;
} else if segment.ident.name == keywords::DollarCrate.name() {
self.print_dollar_crate(segment.ident.span.ctxt())?;
}
Ok(())
}
@ -2446,7 +2446,7 @@ impl<'a> State<'a> {
self.s.word(">")?;
self.s.word("::")?;
let item_segment = path.segments.last().unwrap();
self.print_ident(item_segment.identifier)?;
self.print_ident(item_segment.ident)?;
match item_segment.parameters {
Some(ref parameters) => self.print_path_parameters(parameters, colons_before_params),
None => Ok(()),

2
src/libsyntax/visit.rs
View File

@ -372,7 +372,7 @@ pub fn walk_use_tree<'a, V: Visitor<'a>>(
pub fn walk_path_segment<'a, V: Visitor<'a>>(visitor: &mut V,
path_span: Span,
segment: &'a PathSegment) {
visitor.visit_ident(path_span, segment.identifier);
visitor.visit_ident(path_span, segment.ident);
if let Some(ref parameters) = segment.parameters {
visitor.visit_path_parameters(path_span, parameters);
}

4
src/libsyntax_ext/deriving/generic/mod.rs
View File

@ -367,7 +367,7 @@ fn find_type_parameters(ty: &ast::Ty,
fn visit_ty(&mut self, ty: &'a ast::Ty) {
if let ast::TyKind::Path(_, ref path) = ty.node {
if let Some(segment) = path.segments.first() {
if self.ty_param_names.contains(&segment.identifier.name) {
if self.ty_param_names.contains(&segment.ident.name) {
self.types.push(P(ty.clone()));
}
}
@ -622,7 +622,7 @@ impl<'a> TraitDef<'a> {
// if we have already handled this type, skip it
if let ast::TyKind::Path(_, ref p) = ty.node {
if p.segments.len() == 1 &&
ty_param_names.contains(&p.segments[0].identifier.name) ||
ty_param_names.contains(&p.segments[0].ident.name) ||
processed_field_types.contains(&p.segments) {
continue;
};

29
src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs
View File

@ -61,15 +61,8 @@ fn expr(kind: ExprKind) -> P<Expr> {
}
fn make_x() -> P<Expr> {
let seg = PathSegment {
identifier: Ident::from_str("x"),
span: DUMMY_SP,
parameters: None,
};
let path = Path {
span: DUMMY_SP,
segments: vec![seg],
};
let seg = PathSegment::from_ident(Ident::from_str("x"), DUMMY_SP);
let path = Path { segments: vec![seg], span: DUMMY_SP };
expr(ExprKind::Path(None, path))
}
@ -89,12 +82,7 @@ fn iter_exprs(depth: usize, f: &mut FnMut(P<Expr>)) {
0 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Box(e))),
1 => iter_exprs(depth - 1, &mut |e| g(ExprKind::Call(e, vec![]))),
2 => {
let seg = PathSegment {
identifier: Ident::from_str("x"),
span: DUMMY_SP,
parameters: None,
};
let seg = PathSegment::from_ident(Ident::from_str("x"), DUMMY_SP);
iter_exprs(depth - 1, &mut |e| g(ExprKind::MethodCall(
seg.clone(), vec![e, make_x()])));
iter_exprs(depth - 1, &mut |e| g(ExprKind::MethodCall(
@ -163,15 +151,8 @@ fn iter_exprs(depth: usize, f: &mut FnMut(P<Expr>)) {
iter_exprs(depth - 1, &mut |e| g(ExprKind::Ret(Some(e))));
},
14 => {
let seg = PathSegment {
identifier: Ident::from_str("S"),
span: DUMMY_SP,
parameters: None,
};
let path = Path {
span: DUMMY_SP,
segments: vec![seg],
};
let seg = PathSegment::new(Ident::from_str("S"), DUMMY_SP);
let path = Path { segments: vec![seg], span: DUMMY_SP };
g(ExprKind::Struct(path, vec![], Some(make_x())));
},
15 => {