Skip to content

Commit 5ae3830

Browse files
matthewjaspermatthewjasper
committed
Give more Idents spans
1 parent 57a45e9 commit 5ae3830

File tree

17 files changed

+72
-68
lines changed

17 files changed

+72
-68
lines changed

‎src/librustc/hir/lowering.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1316,7 +1316,7 @@ impl<'a> LoweringContext<'a> {
13161316
ImplTraitContext::Universal(in_band_ty_params),
13171317
);
13181318
// Set the name to `impl Bound1 + Bound2`.
1319-
let ident = Ident::from_str(&pprust::ty_to_string(t)).with_span_pos(span);
1319+
let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span);
13201320
in_band_ty_params.push(hir::GenericParam {
13211321
hir_id: self.lower_node_id(def_node_id),
13221322
name: ParamName::Plain(ident),

‎src/libsyntax/ext/base.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1081,8 +1081,8 @@ impl<'a> ExtCtxt<'a> {
10811081
pub fn set_trace_macros(&mut self, x: bool) {
10821082
self.ecfg.trace_mac = x
10831083
}
1084-
pub fn ident_of(&self, st: &str) -> ast::Ident {
1085-
ast::Ident::from_str(st)
1084+
pub fn ident_of(&self, st: &str, sp: Span) -> ast::Ident {
1085+
ast::Ident::from_str_and_span(st, sp)
10861086
}
10871087
pub fn std_path(&self, components: &[Symbol]) -> Vec<ast::Ident> {
10881088
let def_site = self.with_def_site_ctxt(DUMMY_SP);

‎src/libsyntax/ext/build.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -525,7 +525,7 @@ impl<'a> ExtCtxt<'a> {
525525
let err = self.std_path(&[sym::result, sym::Result, sym::Err]);
526526
let err_path = self.path_global(sp, err);
527527

528-
let binding_variable = self.ident_of("__try_var");
528+
let binding_variable = self.ident_of("__try_var", sp);
529529
let binding_pat = self.pat_ident(sp, binding_variable);
530530
let binding_expr = self.expr_ident(sp, binding_variable);
531531

‎src/libsyntax/parse/parser/item.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1256,7 +1256,7 @@ impl<'a> Parser<'a> {
12561256
for part in idents {
12571257
fixed_name.push_str(&format!("_{}", part.name));
12581258
}
1259-
ident = Ident::from_str(&fixed_name).with_span_pos(fixed_name_sp);
1259+
ident = Ident::from_str_and_span(&fixed_name, fixed_name_sp);
12601260

12611261
self.struct_span_err(fixed_name_sp, error_msg)
12621262
.span_label(fixed_name_sp, "dash-separated idents are not valid")

‎src/libsyntax_ext/deriving/cmp/partial_ord.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ pub fn some_ordering_collapsed(
109109
GtOp => "gt",
110110
GeOp => "ge",
111111
};
112-
cx.expr_method_call(span, lft, ast::Ident::from_str_and_span(op_str, span), vec![rgt])
112+
cx.expr_method_call(span, lft, cx.ident_of(op_str, span), vec![rgt])
113113
}
114114

115115
pub fn cs_partial_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P<Expr> {

‎src/libsyntax_ext/deriving/debug.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
6262
// We want to make sure we have the ctxt set so that we can use unstable methods
6363
let span = cx.with_def_site_ctxt(span);
6464
let name = cx.expr_lit(span, ast::LitKind::Str(ident.name, ast::StrStyle::Cooked));
65-
let builder = Ident::from_str_and_span("debug_trait_builder", span);
65+
let builder = cx.ident_of("debug_trait_builder", span);
6666
let builder_expr = cx.expr_ident(span, builder.clone());
6767

6868
let fmt = substr.nonself_args[0].clone();
@@ -72,7 +72,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
7272
ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
7373
// tuple struct/"normal" variant
7474
let expr =
75-
cx.expr_method_call(span, fmt, Ident::from_str("debug_tuple"), vec![name]);
75+
cx.expr_method_call(span, fmt, cx.ident_of("debug_tuple", span), vec![name]);
7676
stmts.push(cx.stmt_let(span, true, builder, expr));
7777

7878
for field in fields {
@@ -93,7 +93,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
9393
ast::VariantData::Struct(..) => {
9494
// normal struct/struct variant
9595
let expr =
96-
cx.expr_method_call(span, fmt, Ident::from_str("debug_struct"), vec![name]);
96+
cx.expr_method_call(span, fmt, cx.ident_of("debug_struct", span), vec![name]);
9797
stmts.push(cx.stmt_let(DUMMY_SP, true, builder, expr));
9898

9999
for field in fields {
@@ -113,7 +113,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
113113
}
114114
}
115115

116-
let expr = cx.expr_method_call(span, builder_expr, Ident::from_str("finish"), vec![]);
116+
let expr = cx.expr_method_call(span, builder_expr, cx.ident_of("finish", span), vec![]);
117117

118118
stmts.push(cx.stmt_expr(expr));
119119
let block = cx.block(span, stmts);

‎src/libsyntax_ext/deriving/decodable.rs

+12-8
Original file line numberDiff line numberDiff line change
@@ -66,10 +66,14 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
6666
krate: &str)
6767
-> P<Expr> {
6868
let decoder = substr.nonself_args[0].clone();
69-
let recurse = vec![cx.ident_of(krate), cx.ident_of("Decodable"), cx.ident_of("decode")];
69+
let recurse = vec![
70+
cx.ident_of(krate, trait_span),
71+
cx.ident_of("Decodable", trait_span),
72+
cx.ident_of("decode", trait_span),
73+
];
7074
let exprdecode = cx.expr_path(cx.path_global(trait_span, recurse));
7175
// throw an underscore in front to suppress unused variable warnings
72-
let blkarg = cx.ident_of("_d");
76+
let blkarg = cx.ident_of("_d", trait_span);
7377
let blkdecoder = cx.expr_ident(trait_span, blkarg);
7478

7579
return match *substr.fields {
@@ -78,7 +82,7 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
7882
Unnamed(ref fields, _) => fields.len(),
7983
Named(ref fields) => fields.len(),
8084
};
81-
let read_struct_field = cx.ident_of("read_struct_field");
85+
let read_struct_field = cx.ident_of("read_struct_field", trait_span);
8286

8387
let path = cx.path_ident(trait_span, substr.type_ident);
8488
let result =
@@ -94,17 +98,17 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
9498
let result = cx.expr_ok(trait_span, result);
9599
cx.expr_method_call(trait_span,
96100
decoder,
97-
cx.ident_of("read_struct"),
101+
cx.ident_of("read_struct", trait_span),
98102
vec![cx.expr_str(trait_span, substr.type_ident.name),
99103
cx.expr_usize(trait_span, nfields),
100104
cx.lambda1(trait_span, result, blkarg)])
101105
}
102106
StaticEnum(_, ref fields) => {
103-
let variant = cx.ident_of("i");
107+
let variant = cx.ident_of("i", trait_span);
104108

105109
let mut arms = Vec::with_capacity(fields.len() + 1);
106110
let mut variants = Vec::with_capacity(fields.len());
107-
let rvariant_arg = cx.ident_of("read_enum_variant_arg");
111+
let rvariant_arg = cx.ident_of("read_enum_variant_arg", trait_span);
108112

109113
for (i, &(ident, v_span, ref parts)) in fields.iter().enumerate() {
110114
variants.push(cx.expr_str(v_span, ident.name));
@@ -132,11 +136,11 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
132136
let variant_vec = cx.expr_addr_of(trait_span, variant_vec);
133137
let result = cx.expr_method_call(trait_span,
134138
blkdecoder,
135-
cx.ident_of("read_enum_variant"),
139+
cx.ident_of("read_enum_variant", trait_span),
136140
vec![variant_vec, lambda]);
137141
cx.expr_method_call(trait_span,
138142
decoder,
139-
cx.ident_of("read_enum"),
143+
cx.ident_of("read_enum", trait_span),
140144
vec![cx.expr_str(trait_span, substr.type_ident.name),
141145
cx.lambda1(trait_span, result, blkarg)])
142146
}

‎src/libsyntax_ext/deriving/encodable.rs

+9-9
Original file line numberDiff line numberDiff line change
@@ -153,16 +153,16 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
153153
-> P<Expr> {
154154
let encoder = substr.nonself_args[0].clone();
155155
// throw an underscore in front to suppress unused variable warnings
156-
let blkarg = cx.ident_of("_e");
156+
let blkarg = cx.ident_of("_e", trait_span);
157157
let blkencoder = cx.expr_ident(trait_span, blkarg);
158158
let fn_path = cx.expr_path(cx.path_global(trait_span,
159-
vec![cx.ident_of(krate),
160-
cx.ident_of("Encodable"),
161-
cx.ident_of("encode")]));
159+
vec![cx.ident_of(krate, trait_span),
160+
cx.ident_of("Encodable", trait_span),
161+
cx.ident_of("encode", trait_span)]));
162162

163163
return match *substr.fields {
164164
Struct(_, ref fields) => {
165-
let emit_struct_field = cx.ident_of("emit_struct_field");
165+
let emit_struct_field = cx.ident_of("emit_struct_field", trait_span);
166166
let mut stmts = Vec::new();
167167
for (i, &FieldInfo { name, ref self_, span, .. }) in fields.iter().enumerate() {
168168
let name = match name {
@@ -201,7 +201,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
201201

202202
cx.expr_method_call(trait_span,
203203
encoder,
204-
cx.ident_of("emit_struct"),
204+
cx.ident_of("emit_struct", trait_span),
205205
vec![cx.expr_str(trait_span, substr.type_ident.name),
206206
cx.expr_usize(trait_span, fields.len()),
207207
blk])
@@ -214,7 +214,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
214214
// actually exist.
215215
let me = cx.stmt_let(trait_span, false, blkarg, encoder);
216216
let encoder = cx.expr_ident(trait_span, blkarg);
217-
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
217+
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg", trait_span);
218218
let mut stmts = Vec::new();
219219
if !fields.is_empty() {
220220
let last = fields.len() - 1;
@@ -244,15 +244,15 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
244244
let name = cx.expr_str(trait_span, variant.ident.name);
245245
let call = cx.expr_method_call(trait_span,
246246
blkencoder,
247-
cx.ident_of("emit_enum_variant"),
247+
cx.ident_of("emit_enum_variant", trait_span),
248248
vec![name,
249249
cx.expr_usize(trait_span, idx),
250250
cx.expr_usize(trait_span, fields.len()),
251251
blk]);
252252
let blk = cx.lambda1(trait_span, call, blkarg);
253253
let ret = cx.expr_method_call(trait_span,
254254
encoder,
255-
cx.ident_of("emit_enum"),
255+
cx.ident_of("emit_enum", trait_span),
256256
vec![cx.expr_str(trait_span ,substr.type_ident.name),
257257
blk]);
258258
cx.expr_block(cx.block(trait_span, vec![me, cx.stmt_expr(ret)]))

‎src/libsyntax_ext/deriving/generic/mod.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -843,7 +843,7 @@ impl<'a> MethodDef<'a> {
843843
-> P<Expr> {
844844
let substructure = Substructure {
845845
type_ident,
846-
method_ident: cx.ident_of(self.name),
846+
method_ident: cx.ident_of(self.name, trait_.span),
847847
self_args,
848848
nonself_args,
849849
fields,
@@ -890,7 +890,7 @@ impl<'a> MethodDef<'a> {
890890

891891
for (ty, name) in self.args.iter() {
892892
let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics);
893-
let ident = ast::Ident::from_str_and_span(name, trait_.span);
893+
let ident = cx.ident_of(name, trait_.span);
894894
arg_tys.push((ident, ast_ty));
895895

896896
let arg_expr = cx.expr_ident(trait_.span, ident);
@@ -938,7 +938,7 @@ impl<'a> MethodDef<'a> {
938938

939939
let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident);
940940

941-
let method_ident = cx.ident_of(self.name);
941+
let method_ident = cx.ident_of(self.name, trait_.span);
942942
let fn_decl = cx.fn_decl(args, ast::FunctionRetTy::Ty(ret_type));
943943
let body_block = cx.block_expr(body);
944944

@@ -1201,7 +1201,7 @@ impl<'a> MethodDef<'a> {
12011201
).collect::<Vec<String>>();
12021202

12031203
let self_arg_idents = self_arg_names.iter()
1204-
.map(|name| cx.ident_of(&name[..]))
1204+
.map(|name| cx.ident_of(name, sp))
12051205
.collect::<Vec<ast::Ident>>();
12061206

12071207
// The `vi_idents` will be bound, solely in the catch-all, to
@@ -1210,7 +1210,7 @@ impl<'a> MethodDef<'a> {
12101210
let vi_idents = self_arg_names.iter()
12111211
.map(|name| {
12121212
let vi_suffix = format!("{}_vi", &name[..]);
1213-
ast::Ident::from_str_and_span(&vi_suffix[..], trait_.span)
1213+
cx.ident_of(&vi_suffix[..], trait_.span)
12141214
})
12151215
.collect::<Vec<ast::Ident>>();
12161216

@@ -1389,7 +1389,7 @@ impl<'a> MethodDef<'a> {
13891389

13901390
let target_ty = cx.ty_ident(
13911391
sp,
1392-
ast::Ident::from_str_and_span(target_type_name, sp),
1392+
cx.ident_of(target_type_name, sp),
13931393
);
13941394
let variant_disr = cx.expr_cast(sp, variant_value, target_ty);
13951395
let let_stmt = cx.stmt_let(sp, false, ident, variant_disr);
@@ -1591,7 +1591,7 @@ impl<'a> TraitDef<'a> {
15911591
let mut ident_exprs = Vec::new();
15921592
for (i, struct_field) in struct_def.fields().iter().enumerate() {
15931593
let sp = struct_field.span.with_ctxt(self.span.ctxt());
1594-
let ident = ast::Ident::from_str_and_span(&format!("{}_{}", prefix, i), self.span);
1594+
let ident = cx.ident_of(&format!("{}_{}", prefix, i), self.span);
15951595
paths.push(ident.with_span_pos(sp));
15961596
let val = cx.expr_path(cx.path_ident(sp, ident));
15971597
let val = if use_temporaries {

‎src/libsyntax_ext/deriving/generic/ty.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ impl<'a> Path<'a> {
7272
self_ty: Ident,
7373
self_generics: &Generics)
7474
-> ast::Path {
75-
let mut idents = self.path.iter().map(|s| Ident::from_str_and_span(*s, span)).collect();
75+
let mut idents = self.path.iter().map(|s| cx.ident_of(*s, span)).collect();
7676
let lt = mk_lifetimes(cx, span, &self.lifetime);
7777
let tys: Vec<P<ast::Ty>> =
7878
self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics)).collect();
@@ -207,7 +207,7 @@ fn mk_ty_param(cx: &ExtCtxt<'_>,
207207
cx.trait_bound(path)
208208
})
209209
.collect();
210-
cx.typaram(span, ast::Ident::from_str_and_span(name, span), attrs.to_owned(), bounds, None)
210+
cx.typaram(span, cx.ident_of(name, span), attrs.to_owned(), bounds, None)
211211
}
212212

213213
fn mk_generics(params: Vec<ast::GenericParam>, span: Span) -> Generics {

‎src/libsyntax_ext/env.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -23,13 +23,13 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
2323
let sp = cx.with_legacy_ctxt(sp);
2424
let e = match env::var(&*var.as_str()) {
2525
Err(..) => {
26-
let lt = cx.lifetime(sp, Ident::with_dummy_span(kw::StaticLifetime));
26+
let lt = cx.lifetime(sp, Ident::new(kw::StaticLifetime, sp));
2727
cx.expr_path(cx.path_all(sp,
2828
true,
2929
cx.std_path(&[sym::option, sym::Option, sym::None]),
3030
vec![GenericArg::Type(cx.ty_rptr(sp,
3131
cx.ty_ident(sp,
32-
Ident::with_dummy_span(sym::str)),
32+
Ident::new(sym::str, sp)),
3333
Some(lt),
3434
ast::Mutability::Immutable))],
3535
vec![]))

‎src/libsyntax_ext/format.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -486,7 +486,7 @@ impl<'a, 'b> Context<'a, 'b> {
486486
let sp = self.macsp;
487487
let count = |c, arg| {
488488
let mut path = Context::rtpath(self.ecx, "Count");
489-
path.push(self.ecx.ident_of(c));
489+
path.push(self.ecx.ident_of(c, sp));
490490
match arg {
491491
Some(arg) => self.ecx.expr_call_global(sp, path, vec![arg]),
492492
None => self.ecx.expr_path(self.ecx.path_global(sp, path)),
@@ -534,7 +534,7 @@ impl<'a, 'b> Context<'a, 'b> {
534534
let pos = {
535535
let pos = |c, arg| {
536536
let mut path = Context::rtpath(self.ecx, "Position");
537-
path.push(self.ecx.ident_of(c));
537+
path.push(self.ecx.ident_of(c, sp));
538538
match arg {
539539
Some(i) => {
540540
let arg = self.ecx.expr_usize(sp, i);
@@ -603,7 +603,7 @@ impl<'a, 'b> Context<'a, 'b> {
603603
let fill = self.ecx.expr_lit(sp, ast::LitKind::Char(fill));
604604
let align = |name| {
605605
let mut p = Context::rtpath(self.ecx, "Alignment");
606-
p.push(self.ecx.ident_of(name));
606+
p.push(self.ecx.ident_of(name, sp));
607607
self.ecx.path_global(sp, p)
608608
};
609609
let align = match arg.format.align {
@@ -621,11 +621,11 @@ impl<'a, 'b> Context<'a, 'b> {
621621
sp,
622622
path,
623623
vec![
624-
self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
625-
self.ecx.field_imm(sp, self.ecx.ident_of("align"), align),
626-
self.ecx.field_imm(sp, self.ecx.ident_of("flags"), flags),
627-
self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
628-
self.ecx.field_imm(sp, self.ecx.ident_of("width"), width),
624+
self.ecx.field_imm(sp, self.ecx.ident_of("fill", sp), fill),
625+
self.ecx.field_imm(sp, self.ecx.ident_of("align", sp), align),
626+
self.ecx.field_imm(sp, self.ecx.ident_of("flags", sp), flags),
627+
self.ecx.field_imm(sp, self.ecx.ident_of("precision", sp), prec),
628+
self.ecx.field_imm(sp, self.ecx.ident_of("width", sp), width),
629629
],
630630
);
631631

@@ -634,8 +634,8 @@ impl<'a, 'b> Context<'a, 'b> {
634634
sp,
635635
path,
636636
vec![
637-
self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
638-
self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt),
637+
self.ecx.field_imm(sp, self.ecx.ident_of("position", sp), pos),
638+
self.ecx.field_imm(sp, self.ecx.ident_of("format", sp), fmt),
639639
],
640640
))
641641
}
@@ -653,7 +653,7 @@ impl<'a, 'b> Context<'a, 'b> {
653653
let mut heads = Vec::with_capacity(self.args.len());
654654

655655
let names_pos: Vec<_> = (0..self.args.len())
656-
.map(|i| ast::Ident::from_str_and_span(&format!("arg{}", i), self.macsp))
656+
.map(|i| self.ecx.ident_of(&format!("arg{}", i), self.macsp))
657657
.collect();
658658

659659
// First, build up the static array which will become our precompiled

0 commit comments

Comments
 (0)