bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Give more Idents spans

Browse source
This commit is contained in:
Matthew Jasper 2019-09-14 21:16:51 +01:00
parent 57a45e9cbd
commit 5ae3830d58
17 changed files with 72 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/hir/lowering.rs
View file

@ -1316,7 +1316,7 @@ impl<'a> LoweringContext<'a> {
ImplTraitContext::Universal(in_band_ty_params),
);
// Set the name to `impl Bound1 + Bound2`.
let ident = Ident::from_str(&pprust::ty_to_string(t)).with_span_pos(span);
let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span);
in_band_ty_params.push(hir::GenericParam {
hir_id: self.lower_node_id(def_node_id),
name: ParamName::Plain(ident),

4
src/libsyntax/ext/base.rs
View file

@ -1081,8 +1081,8 @@ impl<'a> ExtCtxt<'a> {
pub fn set_trace_macros(&mut self, x: bool) {
self.ecfg.trace_mac = x
}
pub fn ident_of(&self, st: &str) -> ast::Ident {
ast::Ident::from_str(st)
pub fn ident_of(&self, st: &str, sp: Span) -> ast::Ident {
ast::Ident::from_str_and_span(st, sp)
}
pub fn std_path(&self, components: &[Symbol]) -> Vec<ast::Ident> {
let def_site = self.with_def_site_ctxt(DUMMY_SP);

2
src/libsyntax/ext/build.rs
View file

@ -525,7 +525,7 @@ impl<'a> ExtCtxt<'a> {
let err = self.std_path(&[sym::result, sym::Result, sym::Err]);
let err_path = self.path_global(sp, err);
let binding_variable = self.ident_of("__try_var");
let binding_variable = self.ident_of("__try_var", sp);
let binding_pat = self.pat_ident(sp, binding_variable);
let binding_expr = self.expr_ident(sp, binding_variable);

2
src/libsyntax/parse/parser/item.rs
View file

@ -1256,7 +1256,7 @@ impl<'a> Parser<'a> {
for part in idents {
fixed_name.push_str(&format!("_{}", part.name));
}
ident = Ident::from_str(&fixed_name).with_span_pos(fixed_name_sp);
ident = Ident::from_str_and_span(&fixed_name, fixed_name_sp);
self.struct_span_err(fixed_name_sp, error_msg)
.span_label(fixed_name_sp, "dash-separated idents are not valid")

2
src/libsyntax_ext/deriving/cmp/partial_ord.rs
View file

@ -109,7 +109,7 @@ pub fn some_ordering_collapsed(
GtOp => "gt",
GeOp => "ge",
};
cx.expr_method_call(span, lft, ast::Ident::from_str_and_span(op_str, span), vec![rgt])
cx.expr_method_call(span, lft, cx.ident_of(op_str, span), vec![rgt])
}
pub fn cs_partial_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P<Expr> {

8
src/libsyntax_ext/deriving/debug.rs
View file

@ -62,7 +62,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
// We want to make sure we have the ctxt set so that we can use unstable methods
let span = cx.with_def_site_ctxt(span);
let name = cx.expr_lit(span, ast::LitKind::Str(ident.name, ast::StrStyle::Cooked));
let builder = Ident::from_str_and_span("debug_trait_builder", span);
let builder = cx.ident_of("debug_trait_builder", span);
let builder_expr = cx.expr_ident(span, builder.clone());
let fmt = substr.nonself_args[0].clone();
@ -72,7 +72,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
// tuple struct/"normal" variant
let expr =
cx.expr_method_call(span, fmt, Ident::from_str("debug_tuple"), vec![name]);
cx.expr_method_call(span, fmt, cx.ident_of("debug_tuple", span), vec![name]);
stmts.push(cx.stmt_let(span, true, builder, expr));
for field in fields {
@ -93,7 +93,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
ast::VariantData::Struct(..) => {
// normal struct/struct variant
let expr =
cx.expr_method_call(span, fmt, Ident::from_str("debug_struct"), vec![name]);
cx.expr_method_call(span, fmt, cx.ident_of("debug_struct", span), vec![name]);
stmts.push(cx.stmt_let(DUMMY_SP, true, builder, expr));
for field in fields {
@ -113,7 +113,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
}
}
let expr = cx.expr_method_call(span, builder_expr, Ident::from_str("finish"), vec![]);
let expr = cx.expr_method_call(span, builder_expr, cx.ident_of("finish", span), vec![]);
stmts.push(cx.stmt_expr(expr));
let block = cx.block(span, stmts);

20
src/libsyntax_ext/deriving/decodable.rs
View file

@ -66,10 +66,14 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
krate: &str)
-> P<Expr> {
let decoder = substr.nonself_args[0].clone();
let recurse = vec![cx.ident_of(krate), cx.ident_of("Decodable"), cx.ident_of("decode")];
let recurse = vec![
cx.ident_of(krate, trait_span),
cx.ident_of("Decodable", trait_span),
cx.ident_of("decode", trait_span),
];
let exprdecode = cx.expr_path(cx.path_global(trait_span, recurse));
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_d");
let blkarg = cx.ident_of("_d", trait_span);
let blkdecoder = cx.expr_ident(trait_span, blkarg);
return match *substr.fields {
@ -78,7 +82,7 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
Unnamed(ref fields, _) => fields.len(),
Named(ref fields) => fields.len(),
};
let read_struct_field = cx.ident_of("read_struct_field");
let read_struct_field = cx.ident_of("read_struct_field", trait_span);
let path = cx.path_ident(trait_span, substr.type_ident);
let result =
@ -94,17 +98,17 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
let result = cx.expr_ok(trait_span, result);
cx.expr_method_call(trait_span,
decoder,
cx.ident_of("read_struct"),
cx.ident_of("read_struct", trait_span),
vec![cx.expr_str(trait_span, substr.type_ident.name),
cx.expr_usize(trait_span, nfields),
cx.lambda1(trait_span, result, blkarg)])
}
StaticEnum(_, ref fields) => {
let variant = cx.ident_of("i");
let variant = cx.ident_of("i", trait_span);
let mut arms = Vec::with_capacity(fields.len() + 1);
let mut variants = Vec::with_capacity(fields.len());
let rvariant_arg = cx.ident_of("read_enum_variant_arg");
let rvariant_arg = cx.ident_of("read_enum_variant_arg", trait_span);
for (i, &(ident, v_span, ref parts)) in fields.iter().enumerate() {
variants.push(cx.expr_str(v_span, ident.name));
@ -132,11 +136,11 @@ fn decodable_substructure(cx: &mut ExtCtxt<'_>,
let variant_vec = cx.expr_addr_of(trait_span, variant_vec);
let result = cx.expr_method_call(trait_span,
blkdecoder,
cx.ident_of("read_enum_variant"),
cx.ident_of("read_enum_variant", trait_span),
vec![variant_vec, lambda]);
cx.expr_method_call(trait_span,
decoder,
cx.ident_of("read_enum"),
cx.ident_of("read_enum", trait_span),
vec![cx.expr_str(trait_span, substr.type_ident.name),
cx.lambda1(trait_span, result, blkarg)])
}

18
src/libsyntax_ext/deriving/encodable.rs
View file

@ -153,16 +153,16 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
-> P<Expr> {
let encoder = substr.nonself_args[0].clone();
// throw an underscore in front to suppress unused variable warnings
let blkarg = cx.ident_of("_e");
let blkarg = cx.ident_of("_e", trait_span);
let blkencoder = cx.expr_ident(trait_span, blkarg);
let fn_path = cx.expr_path(cx.path_global(trait_span,
vec![cx.ident_of(krate),
cx.ident_of("Encodable"),
cx.ident_of("encode")]));
vec![cx.ident_of(krate, trait_span),
cx.ident_of("Encodable", trait_span),
cx.ident_of("encode", trait_span)]));
return match *substr.fields {
Struct(_, ref fields) => {
let emit_struct_field = cx.ident_of("emit_struct_field");
let emit_struct_field = cx.ident_of("emit_struct_field", trait_span);
let mut stmts = Vec::new();
for (i, &FieldInfo { name, ref self_, span, .. }) in fields.iter().enumerate() {
let name = match name {
@ -201,7 +201,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
cx.expr_method_call(trait_span,
encoder,
cx.ident_of("emit_struct"),
cx.ident_of("emit_struct", trait_span),
vec![cx.expr_str(trait_span, substr.type_ident.name),
cx.expr_usize(trait_span, fields.len()),
blk])
@ -214,7 +214,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
// actually exist.
let me = cx.stmt_let(trait_span, false, blkarg, encoder);
let encoder = cx.expr_ident(trait_span, blkarg);
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg", trait_span);
let mut stmts = Vec::new();
if !fields.is_empty() {
let last = fields.len() - 1;
@ -244,7 +244,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
let name = cx.expr_str(trait_span, variant.ident.name);
let call = cx.expr_method_call(trait_span,
blkencoder,
cx.ident_of("emit_enum_variant"),
cx.ident_of("emit_enum_variant", trait_span),
vec![name,
cx.expr_usize(trait_span, idx),
cx.expr_usize(trait_span, fields.len()),
@ -252,7 +252,7 @@ fn encodable_substructure(cx: &mut ExtCtxt<'_>,
let blk = cx.lambda1(trait_span, call, blkarg);
let ret = cx.expr_method_call(trait_span,
encoder,
cx.ident_of("emit_enum"),
cx.ident_of("emit_enum", trait_span),
vec![cx.expr_str(trait_span ,substr.type_ident.name),
blk]);
cx.expr_block(cx.block(trait_span, vec![me, cx.stmt_expr(ret)]))

14
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -843,7 +843,7 @@ impl<'a> MethodDef<'a> {
-> P<Expr> {
let substructure = Substructure {
type_ident,
method_ident: cx.ident_of(self.name),
method_ident: cx.ident_of(self.name, trait_.span),
self_args,
nonself_args,
fields,
@ -890,7 +890,7 @@ impl<'a> MethodDef<'a> {
for (ty, name) in self.args.iter() {
let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics);
let ident = ast::Ident::from_str_and_span(name, trait_.span);
let ident = cx.ident_of(name, trait_.span);
arg_tys.push((ident, ast_ty));
let arg_expr = cx.expr_ident(trait_.span, ident);
@ -938,7 +938,7 @@ impl<'a> MethodDef<'a> {
let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident);
let method_ident = cx.ident_of(self.name);
let method_ident = cx.ident_of(self.name, trait_.span);
let fn_decl = cx.fn_decl(args, ast::FunctionRetTy::Ty(ret_type));
let body_block = cx.block_expr(body);
@ -1201,7 +1201,7 @@ impl<'a> MethodDef<'a> {
).collect::<Vec<String>>();
let self_arg_idents = self_arg_names.iter()
.map(|name| cx.ident_of(&name[..]))
.map(|name| cx.ident_of(name, sp))
.collect::<Vec<ast::Ident>>();
// The `vi_idents` will be bound, solely in the catch-all, to
@ -1210,7 +1210,7 @@ impl<'a> MethodDef<'a> {
let vi_idents = self_arg_names.iter()
.map(|name| {
let vi_suffix = format!("{}_vi", &name[..]);
ast::Ident::from_str_and_span(&vi_suffix[..], trait_.span)
cx.ident_of(&vi_suffix[..], trait_.span)
})
.collect::<Vec<ast::Ident>>();
@ -1389,7 +1389,7 @@ impl<'a> MethodDef<'a> {
let target_ty = cx.ty_ident(
sp,
ast::Ident::from_str_and_span(target_type_name, sp),
cx.ident_of(target_type_name, sp),
);
let variant_disr = cx.expr_cast(sp, variant_value, target_ty);
let let_stmt = cx.stmt_let(sp, false, ident, variant_disr);
@ -1591,7 +1591,7 @@ impl<'a> TraitDef<'a> {
let mut ident_exprs = Vec::new();
for (i, struct_field) in struct_def.fields().iter().enumerate() {
let sp = struct_field.span.with_ctxt(self.span.ctxt());
let ident = ast::Ident::from_str_and_span(&format!("{}_{}", prefix, i), self.span);
let ident = cx.ident_of(&format!("{}_{}", prefix, i), self.span);
paths.push(ident.with_span_pos(sp));
let val = cx.expr_path(cx.path_ident(sp, ident));
let val = if use_temporaries {

4
src/libsyntax_ext/deriving/generic/ty.rs
View file

@ -72,7 +72,7 @@ impl<'a> Path<'a> {
self_ty: Ident,
self_generics: &Generics)
-> ast::Path {
let mut idents = self.path.iter().map(|s| Ident::from_str_and_span(*s, span)).collect();
let mut idents = self.path.iter().map(|s| cx.ident_of(*s, span)).collect();
let lt = mk_lifetimes(cx, span, &self.lifetime);
let tys: Vec<P<ast::Ty>> =
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<'_>,
cx.trait_bound(path)
})
.collect();
cx.typaram(span, ast::Ident::from_str_and_span(name, span), attrs.to_owned(), bounds, None)
cx.typaram(span, cx.ident_of(name, span), attrs.to_owned(), bounds, None)
}
fn mk_generics(params: Vec<ast::GenericParam>, span: Span) -> Generics {

4
src/libsyntax_ext/env.rs
View file

@ -23,13 +23,13 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
let sp = cx.with_legacy_ctxt(sp);
let e = match env::var(&*var.as_str()) {
Err(..) => {
let lt = cx.lifetime(sp, Ident::with_dummy_span(kw::StaticLifetime));
let lt = cx.lifetime(sp, Ident::new(kw::StaticLifetime, sp));
cx.expr_path(cx.path_all(sp,
true,
cx.std_path(&[sym::option, sym::Option, sym::None]),
vec![GenericArg::Type(cx.ty_rptr(sp,
cx.ty_ident(sp,
Ident::with_dummy_span(sym::str)),
Ident::new(sym::str, sp)),
Some(lt),
ast::Mutability::Immutable))],
vec![]))

22
src/libsyntax_ext/format.rs
View file

@ -486,7 +486,7 @@ impl<'a, 'b> Context<'a, 'b> {
let sp = self.macsp;
let count = |c, arg| {
let mut path = Context::rtpath(self.ecx, "Count");
path.push(self.ecx.ident_of(c));
path.push(self.ecx.ident_of(c, sp));
match arg {
Some(arg) => self.ecx.expr_call_global(sp, path, vec![arg]),
None => self.ecx.expr_path(self.ecx.path_global(sp, path)),
@ -534,7 +534,7 @@ impl<'a, 'b> Context<'a, 'b> {
let pos = {
let pos = |c, arg| {
let mut path = Context::rtpath(self.ecx, "Position");
path.push(self.ecx.ident_of(c));
path.push(self.ecx.ident_of(c, sp));
match arg {
Some(i) => {
let arg = self.ecx.expr_usize(sp, i);
@ -603,7 +603,7 @@ impl<'a, 'b> Context<'a, 'b> {
let fill = self.ecx.expr_lit(sp, ast::LitKind::Char(fill));
let align = |name| {
let mut p = Context::rtpath(self.ecx, "Alignment");
p.push(self.ecx.ident_of(name));
p.push(self.ecx.ident_of(name, sp));
self.ecx.path_global(sp, p)
};
let align = match arg.format.align {
@ -621,11 +621,11 @@ impl<'a, 'b> Context<'a, 'b> {
sp,
path,
vec![
self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
self.ecx.field_imm(sp, self.ecx.ident_of("align"), align),
self.ecx.field_imm(sp, self.ecx.ident_of("flags"), flags),
self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
self.ecx.field_imm(sp, self.ecx.ident_of("width"), width),
self.ecx.field_imm(sp, self.ecx.ident_of("fill", sp), fill),
self.ecx.field_imm(sp, self.ecx.ident_of("align", sp), align),
self.ecx.field_imm(sp, self.ecx.ident_of("flags", sp), flags),
self.ecx.field_imm(sp, self.ecx.ident_of("precision", sp), prec),
self.ecx.field_imm(sp, self.ecx.ident_of("width", sp), width),
],
);
@ -634,8 +634,8 @@ impl<'a, 'b> Context<'a, 'b> {
sp,
path,
vec![
self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt),
self.ecx.field_imm(sp, self.ecx.ident_of("position", sp), pos),
self.ecx.field_imm(sp, self.ecx.ident_of("format", sp), fmt),
],
))
}
@ -653,7 +653,7 @@ impl<'a, 'b> Context<'a, 'b> {
let mut heads = Vec::with_capacity(self.args.len());
let names_pos: Vec<_> = (0..self.args.len())
.map(|i| ast::Ident::from_str_and_span(&format!("arg{}", i), self.macsp))
.map(|i| self.ecx.ident_of(&format!("arg{}", i), self.macsp))
.collect();
// First, build up the static array which will become our precompiled

12
src/libsyntax_ext/global_allocator.rs
View file

@ -43,7 +43,7 @@ pub fn expand(
let const_ty = ecx.ty(span, TyKind::Tup(Vec::new()));
let const_body = ecx.expr_block(ecx.block(span, stmts));
let const_item =
ecx.item_const(span, Ident::with_dummy_span(kw::Underscore), const_ty, const_body);
ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
// Return the original item and the new methods.
vec![Annotatable::Item(item), Annotatable::Item(const_item)]
@ -61,7 +61,7 @@ impl AllocFnFactory<'_, '_> {
let mut abi_args = Vec::new();
let mut i = 0;
let ref mut mk = || {
let name = Ident::from_str(&format!("arg{}", i));
let name = self.cx.ident_of(&format!("arg{}", i), self.span);
i += 1;
name
};
@ -83,7 +83,7 @@ impl AllocFnFactory<'_, '_> {
);
let item = self.cx.item(
self.span,
Ident::from_str(&self.kind.fn_name(method.name)),
self.cx.ident_of(&self.kind.fn_name(method.name), self.span),
self.attrs(),
kind,
);
@ -119,7 +119,7 @@ impl AllocFnFactory<'_, '_> {
) -> P<Expr> {
match *ty {
AllocatorTy::Layout => {
let usize = self.cx.path_ident(self.span, Ident::with_dummy_span(sym::usize));
let usize = self.cx.path_ident(self.span, Ident::new(sym::usize, self.span));
let ty_usize = self.cx.ty_path(usize);
let size = ident();
let align = ident();
@ -177,12 +177,12 @@ impl AllocFnFactory<'_, '_> {
}
fn usize(&self) -> P<Ty> {
let usize = self.cx.path_ident(self.span, Ident::with_dummy_span(sym::usize));
let usize = self.cx.path_ident(self.span, Ident::new(sym::usize, self.span));
self.cx.ty_path(usize)
}
fn ptr_u8(&self) -> P<Ty> {
let u8 = self.cx.path_ident(self.span, Ident::with_dummy_span(sym::u8));
let u8 = self.cx.path_ident(self.span, Ident::new(sym::u8, self.span));
let ty_u8 = self.cx.ty_path(u8);
self.cx.ty_ptr(self.span, ty_u8, Mutability::Mutable)
}

14
src/libsyntax_ext/proc_macro_harness.rs
View file

@ -340,12 +340,12 @@ fn mk_decls(
Vec::new(),
ast::ItemKind::ExternCrate(None));
let bridge = Ident::from_str_and_span("bridge", span);
let client = Ident::from_str_and_span("client", span);
let proc_macro_ty = Ident::from_str_and_span("ProcMacro", span);
let custom_derive = Ident::from_str_and_span("custom_derive", span);
let attr = Ident::from_str_and_span("attr", span);
let bang = Ident::from_str_and_span("bang", span);
let bridge = cx.ident_of("bridge", span);
let client = cx.ident_of("client", span);
let proc_macro_ty = cx.ident_of("ProcMacro", span);
let custom_derive = cx.ident_of("custom_derive", span);
let attr = cx.ident_of("attr", span);
let bang = cx.ident_of("bang", span);
let decls = {
let local_path = |sp: Span, name| {
@ -378,7 +378,7 @@ fn mk_decls(
let decls_static = cx.item_static(
span,
Ident::from_str_and_span("_DECLS", span),
cx.ident_of("_DECLS", span),
cx.ty_rptr(span,
cx.ty(span, ast::TyKind::Slice(
cx.ty_path(cx.path(span,

8
src/libsyntax_ext/test.rs
View file

@ -98,20 +98,20 @@ pub fn expand_test_or_bench(
// creates test::$name
let test_path = |name| {
cx.path(sp, vec![test_id, cx.ident_of(name)])
cx.path(sp, vec![test_id, cx.ident_of(name, sp)])
};
// creates test::ShouldPanic::$name
let should_panic_path = |name| {
cx.path(sp, vec![test_id, cx.ident_of("ShouldPanic"), cx.ident_of(name)])
cx.path(sp, vec![test_id, cx.ident_of("ShouldPanic", sp), cx.ident_of(name, sp)])
};
// creates $name: $expr
let field = |name, expr| cx.field_imm(sp, cx.ident_of(name), expr);
let field = |name, expr| cx.field_imm(sp, cx.ident_of(name, sp), expr);
let test_fn = if is_bench {
// A simple ident for a lambda
let b = ast::Ident::from_str_and_span("b", attr_sp);
let b = cx.ident_of("b", attr_sp);
cx.expr_call(sp, cx.expr_path(test_path("StaticBenchFn")), vec![
// |b| self::test::assert_test_result(

2
src/libsyntax_ext/test_harness.rs
View file

@ -250,7 +250,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
// test::test_main_static(...)
let mut test_runner = cx.test_runner.clone().unwrap_or(
ecx.path(sp, vec![test_id, Ident::from_str_and_span("test_main_static", sp)]));
ecx.path(sp, vec![test_id, ecx.ident_of("test_main_static", sp)]));
test_runner.span = sp;

2
src/libsyntax_pos/symbol.rs
View file

@ -765,7 +765,7 @@ impl Ident {
Ident::with_dummy_span(string.as_symbol())
}
/// Maps a string to an identifier with an empty span.
/// Maps a string to an identifier with a dummy span.
pub fn from_str(string: &str) -> Ident {
Ident::with_dummy_span(Symbol::intern(string))
}