1
Fork 0

Give more Idents spans

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

View file

@ -1316,7 +1316,7 @@ impl<'a> LoweringContext<'a> {
ImplTraitContext::Universal(in_band_ty_params), ImplTraitContext::Universal(in_band_ty_params),
); );
// Set the name to `impl Bound1 + Bound2`. // 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 { in_band_ty_params.push(hir::GenericParam {
hir_id: self.lower_node_id(def_node_id), hir_id: self.lower_node_id(def_node_id),
name: ParamName::Plain(ident), name: ParamName::Plain(ident),

View file

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

View file

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

View file

@ -1256,7 +1256,7 @@ impl<'a> Parser<'a> {
for part in idents { for part in idents {
fixed_name.push_str(&format!("_{}", part.name)); 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) self.struct_span_err(fixed_name_sp, error_msg)
.span_label(fixed_name_sp, "dash-separated idents are not valid") .span_label(fixed_name_sp, "dash-separated idents are not valid")

View file

@ -109,7 +109,7 @@ pub fn some_ordering_collapsed(
GtOp => "gt", GtOp => "gt",
GeOp => "ge", 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> { pub fn cs_partial_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P<Expr> {

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 // 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 span = cx.with_def_site_ctxt(span);
let name = cx.expr_lit(span, ast::LitKind::Str(ident.name, ast::StrStyle::Cooked)); 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 builder_expr = cx.expr_ident(span, builder.clone());
let fmt = substr.nonself_args[0].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(..) => { ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
// tuple struct/"normal" variant // tuple struct/"normal" variant
let expr = 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)); stmts.push(cx.stmt_let(span, true, builder, expr));
for field in fields { for field in fields {
@ -93,7 +93,7 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
ast::VariantData::Struct(..) => { ast::VariantData::Struct(..) => {
// normal struct/struct variant // normal struct/struct variant
let expr = 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)); stmts.push(cx.stmt_let(DUMMY_SP, true, builder, expr));
for field in fields { 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)); stmts.push(cx.stmt_expr(expr));
let block = cx.block(span, stmts); let block = cx.block(span, stmts);

View file

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

View file

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

View file

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

View file

@ -72,7 +72,7 @@ impl<'a> Path<'a> {
self_ty: Ident, self_ty: Ident,
self_generics: &Generics) self_generics: &Generics)
-> ast::Path { -> 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 lt = mk_lifetimes(cx, span, &self.lifetime);
let tys: Vec<P<ast::Ty>> = let tys: Vec<P<ast::Ty>> =
self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics)).collect(); 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) cx.trait_bound(path)
}) })
.collect(); .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 { fn mk_generics(params: Vec<ast::GenericParam>, span: Span) -> Generics {

View file

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

View file

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

View file

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

View file

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

View file

@ -98,20 +98,20 @@ pub fn expand_test_or_bench(
// creates test::$name // creates test::$name
let test_path = |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 // creates test::ShouldPanic::$name
let should_panic_path = |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 // 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 { let test_fn = if is_bench {
// A simple ident for a lambda // 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![ cx.expr_call(sp, cx.expr_path(test_path("StaticBenchFn")), vec![
// |b| self::test::assert_test_result( // |b| self::test::assert_test_result(

View file

@ -250,7 +250,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
// test::test_main_static(...) // test::test_main_static(...)
let mut test_runner = cx.test_runner.clone().unwrap_or( 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; test_runner.span = sp;

View file

@ -765,7 +765,7 @@ impl Ident {
Ident::with_dummy_span(string.as_symbol()) 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 { pub fn from_str(string: &str) -> Ident {
Ident::with_dummy_span(Symbol::intern(string)) Ident::with_dummy_span(Symbol::intern(string))
} }