Skip to content

Commit bfd2a75

Browse files
IsaacWoodsIsaacWoods
committed
Rename ident to segments
1 parent af961c1 commit bfd2a75

File tree

3 files changed

+66
-64
lines changed

3 files changed

+66
-64
lines changed

‎src/librustc_resolve/lib.rs

Lines changed: 50 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,7 @@ mod build_reduced_graph;
8585
mod resolve_imports;
8686

8787
pub struct ResolvePath<'a> {
88-
ident: &'a [Ident],
88+
segments: &'a [Ident],
8989
/// NodeId of the path that we are attempting to resolve. When None, this path is being
9090
/// speculatively resolved and we should not emit errors or lints about it
9191
source: Option<NodeId>,
@@ -1663,7 +1663,7 @@ impl<'a> Resolver<'a> {
16631663
.collect();
16641664

16651665
let path = ResolvePath {
1666-
ident: &path,
1666+
segments: &path,
16671667
source: None,
16681668
};
16691669
// FIXME (Manishearth): Intra doc links won't get warned of epoch changes
@@ -2364,7 +2364,7 @@ impl<'a> Resolver<'a> {
23642364
.map(|seg| seg.ident)
23652365
.collect();
23662366
let path = ResolvePath {
2367-
ident: &path,
2367+
segments: &path,
23682368
source: Some(trait_ref.ref_id),
23692369
};
23702370
let def = self.smart_resolve_path_fragment(
@@ -2803,7 +2803,7 @@ impl<'a> Resolver<'a> {
28032803
.map(|seg| seg.ident)
28042804
.collect::<Vec<_>>();
28052805
let resolve_path = ResolvePath {
2806-
ident: &segments,
2806+
segments: &segments,
28072807
source: Some(id),
28082808
};
28092809
self.smart_resolve_path_fragment(id, qself, &resolve_path, path.span, source)
@@ -2816,7 +2816,7 @@ impl<'a> Resolver<'a> {
28162816
span: Span,
28172817
source: PathSource)
28182818
-> PathResolution {
2819-
let ident_span = path.ident.last().map_or(span, |ident| ident.span);
2819+
let ident_span = path.segments.last().map_or(span, |ident| ident.span);
28202820
let ns = source.namespace();
28212821
let is_expected = &|def| source.is_expected(def);
28222822
let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false };
@@ -2825,31 +2825,31 @@ impl<'a> Resolver<'a> {
28252825
let report_errors = |this: &mut Self, def: Option<Def>| {
28262826
// Make the base error.
28272827
let expected = source.descr_expected();
2828-
let path_str = names_to_string(path.ident);
2828+
let path_str = names_to_string(path.segments);
28292829
let code = source.error_code(def.is_some());
28302830
let (base_msg, fallback_label, base_span) = if let Some(def) = def {
28312831
(format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str),
28322832
format!("not a {}", expected),
28332833
span)
28342834
} else {
2835-
let item_str = path.ident[path.ident.len() - 1];
2836-
let item_span = path.ident[path.ident.len() - 1].span;
2837-
let (mod_prefix, mod_str) = if path.ident.len() == 1 {
2835+
let item_str = path.segments[path.segments.len() - 1];
2836+
let item_span = path.segments[path.segments.len() - 1].span;
2837+
let (mod_prefix, mod_str) = if path.segments.len() == 1 {
28382838
(format!(""), format!("this scope"))
2839-
} else if path.ident.len() == 2 &&
2840-
path.ident[0].name == keywords::CrateRoot.name() {
2839+
} else if path.segments.len() == 2 &&
2840+
path.segments[0].name == keywords::CrateRoot.name() {
28412841
(format!(""), format!("the crate root"))
28422842
} else {
28432843
let mod_path = ResolvePath {
2844-
ident: &path.ident[..path.ident.len() - 1],
2844+
segments: &path.segments[..path.segments.len() - 1],
28452845
source: Some(id),
28462846
};
28472847
let mod_prefix = match this.resolve_path(&mod_path, Some(TypeNS),
28482848
false, span) {
28492849
PathResult::Module(module) => module.def(),
28502850
_ => None,
28512851
}.map_or(format!(""), |def| format!("{} ", def.kind_name()));
2852-
(mod_prefix, format!("`{}`", names_to_string(mod_path.ident)))
2852+
(mod_prefix, format!("`{}`", names_to_string(mod_path.segments)))
28532853
};
28542854
(format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),
28552855
format!("not found in {}", mod_str),
@@ -2859,13 +2859,13 @@ impl<'a> Resolver<'a> {
28592859
let mut err = this.session.struct_span_err_with_code(base_span, &base_msg, code);
28602860

28612861
// Emit special messages for unresolved `Self` and `self`.
2862-
if is_self_type(path.ident, ns) {
2862+
if is_self_type(path.segments, ns) {
28632863
__diagnostic_used!(E0411);
28642864
err.code(DiagnosticId::Error("E0411".into()));
28652865
err.span_label(span, "`Self` is only available in traits and impls");
28662866
return (err, Vec::new());
28672867
}
2868-
if is_self_value(path.ident, ns) {
2868+
if is_self_value(path.segments, ns) {
28692869
__diagnostic_used!(E0424);
28702870
err.code(DiagnosticId::Error("E0424".into()));
28712871
err.span_label(span, format!("`self` value is only available in \
@@ -2874,7 +2874,7 @@ impl<'a> Resolver<'a> {
28742874
}
28752875

28762876
// Try to lookup the name in more relaxed fashion for better error reporting.
2877-
let ident = *path.ident.last().unwrap();
2877+
let ident = *path.segments.last().unwrap();
28782878
let candidates = this.lookup_import_candidates(ident.name, ns, is_expected);
28792879
if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) {
28802880
let enum_candidates =
@@ -2895,9 +2895,10 @@ impl<'a> Resolver<'a> {
28952895
}
28962896
}
28972897
}
2898-
if path.ident.len() == 1 && this.self_type_is_available(span) {
2898+
if path.segments.len() == 1 && this.self_type_is_available(span) {
28992899
if let Some(candidate) = this.lookup_assoc_candidate(ident, ns, is_expected) {
2900-
let self_is_available = this.self_value_is_available(path.ident[0].span, span);
2900+
let self_is_available = this.self_value_is_available(path.segments[0].span,
2901+
span);
29012902
match candidate {
29022903
AssocSuggestion::Field => {
29032904
err.span_suggestion(span, "try",
@@ -2923,7 +2924,8 @@ impl<'a> Resolver<'a> {
29232924
let mut levenshtein_worked = false;
29242925

29252926
// Try Levenshtein.
2926-
if let Some(candidate) = this.lookup_typo_candidate(path.ident, ns, is_expected, span) {
2927+
if let Some(candidate) = this.lookup_typo_candidate(path.segments, ns, is_expected,
2928+
span) {
29272929
err.span_label(ident_span, format!("did you mean `{}`?", candidate));
29282930
levenshtein_worked = true;
29292931
}
@@ -3051,7 +3053,7 @@ impl<'a> Resolver<'a> {
30513053
// or `<T>::A::B`. If `B` should be resolved in value namespace then
30523054
// it needs to be added to the trait map.
30533055
if ns == ValueNS {
3054-
let item_name = *path.ident.last().unwrap();
3056+
let item_name = *path.segments.last().unwrap();
30553057
let traits = self.get_traits_containing_item(item_name, ns);
30563058
self.trait_map.insert(id, traits);
30573059
}
@@ -3138,10 +3140,10 @@ impl<'a> Resolver<'a> {
31383140
};
31393141
}
31403142
}
3141-
let is_global = self.global_macros.get(&path.ident[0].name).cloned()
3143+
let is_global = self.global_macros.get(&path.segments[0].name).cloned()
31423144
.map(|binding| binding.get_macro(self).kind() == MacroKind::Bang).unwrap_or(false);
31433145
if primary_ns != MacroNS && (is_global ||
3144-
self.macro_names.contains(&path.ident[0].modern())) {
3146+
self.macro_names.contains(&path.segments[0].modern())) {
31453147
// Return some dummy definition, it's enough for error reporting.
31463148
return Some(
31473149
PathResolution::new(Def::Macro(DefId::local(CRATE_DEF_INDEX), MacroKind::Bang))
@@ -3163,19 +3165,19 @@ impl<'a> Resolver<'a> {
31633165
if qself.position == 0 {
31643166
// FIXME: Create some fake resolution that can't possibly be a type.
31653167
return Some(PathResolution::with_unresolved_segments(
3166-
Def::Mod(DefId::local(CRATE_DEF_INDEX)), path.ident.len()
3168+
Def::Mod(DefId::local(CRATE_DEF_INDEX)), path.segments.len()
31673169
));
31683170
}
31693171
// Make sure `A::B` in `<T as A>::B::C` is a trait item.
3170-
let ns = if qself.position + 1 == path.ident.len() { ns } else { TypeNS };
3172+
let ns = if qself.position + 1 == path.segments.len() { ns } else { TypeNS };
31713173
let path = ResolvePath {
3172-
ident: &path.ident[..qself.position + 1],
3174+
segments: &path.segments[..qself.position + 1],
31733175
source: Some(id),
31743176
};
31753177
let res = self.smart_resolve_path_fragment(id, None, &path,
31763178
span, PathSource::TraitItem(ns));
31773179
return Some(PathResolution::with_unresolved_segments(
3178-
res.base_def(), res.unresolved_segments() + path.ident.len() - qself.position - 1
3180+
res.base_def(), res.unresolved_segments() + path.segments.len() - qself.position - 1
31793181
));
31803182
}
31813183

@@ -3197,11 +3199,11 @@ impl<'a> Resolver<'a> {
31973199
// Such behavior is required for backward compatibility.
31983200
// The same fallback is used when `a` resolves to nothing.
31993201
PathResult::Module(..) | PathResult::Failed(..)
3200-
if (ns == TypeNS || path.ident.len() > 1) &&
3202+
if (ns == TypeNS || path.segments.len() > 1) &&
32013203
self.primitive_type_table.primitive_types
3202-
.contains_key(&path.ident[0].name) => {
3203-
let prim = self.primitive_type_table.primitive_types[&path.ident[0].name];
3204-
PathResolution::with_unresolved_segments(Def::PrimTy(prim), path.ident.len() - 1)
3204+
.contains_key(&path.segments[0].name) => {
3205+
let prim = self.primitive_type_table.primitive_types[&path.segments[0].name];
3206+
PathResolution::with_unresolved_segments(Def::PrimTy(prim), path.segments.len() - 1)
32053207
}
32063208
PathResult::Module(module) => PathResolution::new(module.def().unwrap()),
32073209
PathResult::Failed(span, msg, false) => {
@@ -3212,12 +3214,12 @@ impl<'a> Resolver<'a> {
32123214
PathResult::Indeterminate => bug!("indetermined path result in resolve_qpath"),
32133215
};
32143216

3215-
if path.ident.len() > 1 && !global_by_default && result.base_def() != Def::Err &&
3216-
path.ident[0].name != keywords::CrateRoot.name() &&
3217-
path.ident[0].name != keywords::DollarCrate.name() {
3217+
if path.segments.len() > 1 && !global_by_default && result.base_def() != Def::Err &&
3218+
path.segments[0].name != keywords::CrateRoot.name() &&
3219+
path.segments[0].name != keywords::DollarCrate.name() {
32183220
let unqualified_result = {
32193221
let path = ResolvePath {
3220-
ident: &[*path.ident.last().unwrap()],
3222+
segments: &[*path.segments.last().unwrap()],
32213223
source: None,
32223224
};
32233225
match self.resolve_path(&path, Some(ns), false, span) {
@@ -3243,9 +3245,9 @@ impl<'a> Resolver<'a> {
32433245
let mut module = None;
32443246
let mut allow_super = true;
32453247

3246-
for (i, &ident) in path.ident.iter().enumerate() {
3248+
for (i, &ident) in path.segments.iter().enumerate() {
32473249
debug!("resolve_path ident {} {:?}", i, ident);
3248-
let is_last = i == path.ident.len() - 1;
3250+
let is_last = i == path.segments.len() - 1;
32493251
let ns = if is_last { opt_ns.unwrap_or(TypeNS) } else { TypeNS };
32503252
let name = ident.name;
32513253

@@ -3275,7 +3277,7 @@ impl<'a> Resolver<'a> {
32753277
if (i == 0 && name == keywords::CrateRoot.name()) ||
32763278
(i == 0 && name == keywords::Crate.name()) ||
32773279
(i == 1 && name == keywords::Crate.name() &&
3278-
path.ident[0].name == keywords::CrateRoot.name()) {
3280+
path.segments[0].name == keywords::CrateRoot.name()) {
32793281
// `::a::b` or `::crate::a::b`
32803282
module = Some(self.resolve_crate_root(ident.span.ctxt(), false));
32813283
continue
@@ -3284,7 +3286,7 @@ impl<'a> Resolver<'a> {
32843286
module = Some(self.resolve_crate_root(ident.span.ctxt(), true));
32853287
continue
32863288
} else if i == 1 && !token::is_path_segment_keyword(ident) {
3287-
let prev_name = path.ident[0].name;
3289+
let prev_name = path.segments[0].name;
32883290
if prev_name == keywords::Extern.name() ||
32893291
prev_name == keywords::CrateRoot.name() &&
32903292
// Note: When this feature stabilizes, this should
@@ -3310,14 +3312,14 @@ impl<'a> Resolver<'a> {
33103312
name == keywords::Extern.name() && i != 0 ||
33113313
// we allow crate::foo and ::crate::foo but nothing else
33123314
name == keywords::Crate.name() && i > 1 &&
3313-
path.ident[0].name != keywords::CrateRoot.name() ||
3314-
name == keywords::Crate.name() && path.ident.len() == 1 {
3315+
path.segments[0].name != keywords::CrateRoot.name() ||
3316+
name == keywords::Crate.name() && path.segments.len() == 1 {
33153317
let name_str = if name == keywords::CrateRoot.name() {
33163318
format!("crate root")
33173319
} else {
33183320
format!("`{}`", name)
33193321
};
3320-
let msg = if i == 1 && path.ident[0].name == keywords::CrateRoot.name() {
3322+
let msg = if i == 1 && path.segments[0].name == keywords::CrateRoot.name() {
33213323
format!("global paths cannot start with {}", name_str)
33223324
} else {
33233325
format!("{} in paths can only be used in start position", name_str)
@@ -3336,7 +3338,7 @@ impl<'a> Resolver<'a> {
33363338
Some(LexicalScopeBinding::Def(def))
33373339
if opt_ns == Some(TypeNS) || opt_ns == Some(ValueNS) => {
33383340
return PathResult::NonModule(PathResolution::with_unresolved_segments(
3339-
def, path.ident.len() - 1
3341+
def, path.segments.len() - 1
33403342
));
33413343
}
33423344
_ => Err(if record_used { Determined } else { Undetermined }),
@@ -3353,7 +3355,7 @@ impl<'a> Resolver<'a> {
33533355
return PathResult::NonModule(err_path_resolution());
33543356
} else if opt_ns.is_some() && (is_last || maybe_assoc) {
33553357
return PathResult::NonModule(PathResolution::with_unresolved_segments(
3356-
def, path.ident.len() - i - 1
3358+
def, path.segments.len() - i - 1
33573359
));
33583360
} else {
33593361
return PathResult::Failed(ident.span,
@@ -3364,7 +3366,7 @@ impl<'a> Resolver<'a> {
33643366
if let Some(id) = path.source {
33653367
if i == 1 && self.session.features_untracked().crate_in_paths
33663368
&& !self.session.rust_2018() {
3367-
let prev_name = path.ident[0].name;
3369+
let prev_name = path.segments[0].name;
33683370
if prev_name == keywords::Extern.name() ||
33693371
prev_name == keywords::CrateRoot.name() {
33703372
let mut is_crate = false;
@@ -3393,7 +3395,7 @@ impl<'a> Resolver<'a> {
33933395
if let Some(module) = module {
33943396
if opt_ns.is_some() && !module.is_normal() {
33953397
return PathResult::NonModule(PathResolution::with_unresolved_segments(
3396-
module.def().unwrap(), path.ident.len() - i
3398+
module.def().unwrap(), path.segments.len() - i
33973399
));
33983400
}
33993401
}
@@ -3412,7 +3414,7 @@ impl<'a> Resolver<'a> {
34123414
} else if i == 0 {
34133415
format!("Use of undeclared type or module `{}`", ident)
34143416
} else {
3415-
format!("Could not find `{}` in `{}`", ident, path.ident[i - 1])
3417+
format!("Could not find `{}` in `{}`", ident, path.segments[i - 1])
34163418
};
34173419
return PathResult::Failed(ident.span, msg, is_last);
34183420
}
@@ -3633,7 +3635,7 @@ impl<'a> Resolver<'a> {
36333635
} else {
36343636
// Search in module.
36353637
let mod_path = ResolvePath {
3636-
ident: &path[..path.len() - 1],
3638+
segments: &path[..path.len() - 1],
36373639
source: None,
36383640
};
36393641
if let PathResult::Module(module) = self.resolve_path(&mod_path, Some(TypeNS),
@@ -4057,7 +4059,7 @@ impl<'a> Resolver<'a> {
40574059
.collect::<Vec<_>>();
40584060
let span = path.span;
40594061
let path = ResolvePath {
4060-
ident: &segments,
4062+
segments: &segments,
40614063
source: None,
40624064
};
40634065
let def = self.smart_resolve_path_fragment(id, None, &path, span,

0 commit comments

Comments
 (0)