bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

syntax::codemap: Add static DUMMY_SP

Browse source 
It replaces `dummy_sp()`.
This commit is contained in:
klutzy 2014-01-01 15:53:22 +09:00
parent db204b20ab
commit 9cdad685a3
21 changed files with 94 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/librustc/front/std_inject.rs
View file

@ -14,7 +14,7 @@ use driver::session::Session;
use std::vec; use std::vec;
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::codemap::dummy_sp; use syntax::codemap::DUMMY_SP;
use syntax::codemap; use syntax::codemap;
use syntax::fold::ast_fold; use syntax::fold::ast_fold;
use syntax::fold; use syntax::fold;
@ -47,7 +47,7 @@ fn no_prelude(attrs: &[ast::Attribute]) -> bool {
fn spanned<T>(x: T) -> codemap::Spanned<T> { fn spanned<T>(x: T) -> codemap::Spanned<T> {
codemap::Spanned { codemap::Spanned {
node: x, node: x,
span: dummy_sp(), span: DUMMY_SP,
} }
} }
@ -66,7 +66,7 @@ impl fold::ast_fold for StandardLibraryInjector {
ast::DUMMY_NODE_ID), ast::DUMMY_NODE_ID),
attrs: ~[], attrs: ~[],
vis: ast::private, vis: ast::private,
span: dummy_sp() span: DUMMY_SP
}]; }];
if use_uv(&crate) && !self.sess.building_library.get() { if use_uv(&crate) && !self.sess.building_library.get() {
@ -77,7 +77,7 @@ impl fold::ast_fold for StandardLibraryInjector {
ast::DUMMY_NODE_ID), ast::DUMMY_NODE_ID),
attrs: ~[], attrs: ~[],
vis: ast::private, vis: ast::private,
span: dummy_sp() span: DUMMY_SP
}); });
vis.push(ast::view_item { vis.push(ast::view_item {
node: ast::view_item_extern_mod(self.sess.ident_of("rustuv"), node: ast::view_item_extern_mod(self.sess.ident_of("rustuv"),
@ -86,7 +86,7 @@ impl fold::ast_fold for StandardLibraryInjector {
ast::DUMMY_NODE_ID), ast::DUMMY_NODE_ID),
attrs: ~[], attrs: ~[],
vis: ast::private, vis: ast::private,
span: dummy_sp() span: DUMMY_SP
}); });
} }
@ -121,7 +121,7 @@ impl fold::ast_fold for StandardLibraryInjector {
fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod { fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {
let prelude_path = ast::Path { let prelude_path = ast::Path {
span: dummy_sp(), span: DUMMY_SP,
global: false, global: false,
segments: ~[ segments: ~[
ast::PathSegment { ast::PathSegment {
@ -143,7 +143,7 @@ impl fold::ast_fold for StandardLibraryInjector {
node: ast::view_item_use(~[vp]), node: ast::view_item_use(~[vp]),
attrs: ~[], attrs: ~[],
vis: ast::private, vis: ast::private,
span: dummy_sp(), span: DUMMY_SP,
}; };
let vis = vec::append(~[vi2], module.view_items); let vis = vec::append(~[vi2], module.view_items);

18
src/librustc/front/test.rs
View file

@ -19,7 +19,7 @@ use std::vec;
use syntax::ast_util::*; use syntax::ast_util::*;
use syntax::attr::AttrMetaMethods; use syntax::attr::AttrMetaMethods;
use syntax::attr; use syntax::attr;
use syntax::codemap::{dummy_sp, Span, ExpnInfo, NameAndSpan, MacroAttribute}; use syntax::codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute};
use syntax::codemap; use syntax::codemap;
use syntax::ext::base::ExtCtxt; use syntax::ext::base::ExtCtxt;
use syntax::fold::ast_fold; use syntax::fold::ast_fold;
@ -164,7 +164,7 @@ fn generate_test_harness(sess: session::Session, crate: ast::Crate)
}; };
cx.ext_cx.bt_push(ExpnInfo { cx.ext_cx.bt_push(ExpnInfo {
call_site: dummy_sp(), call_site: DUMMY_SP,
callee: NameAndSpan { callee: NameAndSpan {
name: @"test", name: @"test",
format: MacroAttribute, format: MacroAttribute,
@ -298,7 +298,7 @@ fn mk_std(cx: &TestCtxt) -> ast::view_item {
node: vi, node: vi,
attrs: ~[], attrs: ~[],
vis: ast::public, vis: ast::public,
span: dummy_sp() span: DUMMY_SP
} }
} }
@ -335,7 +335,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: item_, node: item_,
vis: ast::public, vis: ast::public,
span: dummy_sp(), span: DUMMY_SP,
}; };
debug!("Synthetic test module:\n{}\n", debug!("Synthetic test module:\n{}\n",
@ -345,12 +345,12 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
} }
fn nospan<T>(t: T) -> codemap::Spanned<T> { fn nospan<T>(t: T) -> codemap::Spanned<T> {
codemap::Spanned { node: t, span: dummy_sp() } codemap::Spanned { node: t, span: DUMMY_SP }
} }
fn path_node(ids: ~[ast::Ident]) -> ast::Path { fn path_node(ids: ~[ast::Ident]) -> ast::Path {
ast::Path { ast::Path {
span: dummy_sp(), span: DUMMY_SP,
global: false, global: false,
segments: ids.move_iter().map(|identifier| ast::PathSegment { segments: ids.move_iter().map(|identifier| ast::PathSegment {
identifier: identifier, identifier: identifier,
@ -362,7 +362,7 @@ fn path_node(ids: ~[ast::Ident]) -> ast::Path {
fn path_node_global(ids: ~[ast::Ident]) -> ast::Path { fn path_node_global(ids: ~[ast::Ident]) -> ast::Path {
ast::Path { ast::Path {
span: dummy_sp(), span: DUMMY_SP,
global: true, global: true,
segments: ids.move_iter().map(|identifier| ast::PathSegment { segments: ids.move_iter().map(|identifier| ast::PathSegment {
identifier: identifier, identifier: identifier,
@ -403,13 +403,13 @@ fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
let inner_expr = @ast::Expr { let inner_expr = @ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprVec(descs, ast::MutImmutable), node: ast::ExprVec(descs, ast::MutImmutable),
span: dummy_sp(), span: DUMMY_SP,
}; };
@ast::Expr { @ast::Expr {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ExprVstore(inner_expr, ast::ExprVstoreSlice), node: ast::ExprVstore(inner_expr, ast::ExprVstoreSlice),
span: dummy_sp(), span: DUMMY_SP,
} }
} }

4
src/librustc/metadata/creader.rs
View file

@ -21,7 +21,7 @@ use syntax::ast;
use syntax::abi; use syntax::abi;
use syntax::attr; use syntax::attr;
use syntax::attr::AttrMetaMethods; use syntax::attr::AttrMetaMethods;
use syntax::codemap::{Span, dummy_sp}; use syntax::codemap::{Span, DUMMY_SP};
use syntax::diagnostic::SpanHandler; use syntax::diagnostic::SpanHandler;
use syntax::parse::token; use syntax::parse::token;
use syntax::parse::token::ident_interner; use syntax::parse::token::ident_interner;
@ -346,7 +346,7 @@ fn resolve_crate_deps(e: &mut Env, cdata: &[u8]) -> cstore::cnum_map {
// This is a new one so we've got to load it // This is a new one so we've got to load it
// FIXME (#2404): Need better error reporting than just a bogus // FIXME (#2404): Need better error reporting than just a bogus
// span. // span.
let fake_span = dummy_sp(); let fake_span = DUMMY_SP;
let local_cnum = resolve_crate(e, cname_str, cname_str, dep.vers, let local_cnum = resolve_crate(e, cname_str, cname_str, dep.vers,
dep.hash, fake_span); dep.hash, fake_span);
cnum_map.insert(extrn_cnum, local_cnum); cnum_map.insert(extrn_cnum, local_cnum);

2
src/librustc/metadata/decoder.rs
View file

@ -1099,7 +1099,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::Attribute] {
value: meta_item, value: meta_item,
is_sugared_doc: false, is_sugared_doc: false,
}, },
span: codemap::dummy_sp() span: codemap::DUMMY_SP
}); });
true true
}); });

2
src/librustc/middle/astencode.rs
View file

@ -218,7 +218,7 @@ impl ExtendedDecodeContext {
ast::DefId { crate: ast::LOCAL_CRATE, node: self.tr_id(did.node) } ast::DefId { crate: ast::LOCAL_CRATE, node: self.tr_id(did.node) }
} }
pub fn tr_span(&self, _span: Span) -> Span { pub fn tr_span(&self, _span: Span) -> Span {
codemap::dummy_sp() // FIXME (#1972): handle span properly codemap::DUMMY_SP // FIXME (#1972): handle span properly
} }
} }

6
src/librustc/middle/check_match.rs
View file

@ -23,7 +23,7 @@ use std::num;
use std::vec; use std::vec;
use syntax::ast::*; use syntax::ast::*;
use syntax::ast_util::{unguarded_pat, walk_pat}; use syntax::ast_util::{unguarded_pat, walk_pat};
use syntax::codemap::{Span, dummy_sp, Spanned}; use syntax::codemap::{Span, DUMMY_SP, Spanned};
use syntax::visit; use syntax::visit;
use syntax::visit::{Visitor,fn_kind}; use syntax::visit::{Visitor,fn_kind};
@ -536,11 +536,11 @@ fn ctor_arity(cx: &MatchCheckCtxt, ctor: &ctor, ty: ty::t) -> uint {
} }
fn wild() -> @Pat { fn wild() -> @Pat {
@Pat {id: 0, node: PatWild, span: dummy_sp()} @Pat {id: 0, node: PatWild, span: DUMMY_SP}
} }
fn wild_multi() -> @Pat { fn wild_multi() -> @Pat {
@Pat {id: 0, node: PatWildMulti, span: dummy_sp()} @Pat {id: 0, node: PatWildMulti, span: DUMMY_SP}
} }
fn specialize(cx: &MatchCheckCtxt, fn specialize(cx: &MatchCheckCtxt,

32
src/librustc/middle/resolve.rs
View file

@ -24,7 +24,7 @@ use syntax::parse::token;
use syntax::parse::token::{ident_interner, interner_get}; use syntax::parse::token::{ident_interner, interner_get};
use syntax::parse::token::special_idents; use syntax::parse::token::special_idents;
use syntax::print::pprust::path_to_str; use syntax::print::pprust::path_to_str;
use syntax::codemap::{Span, dummy_sp, Pos}; use syntax::codemap::{Span, DUMMY_SP, Pos};
use syntax::opt_vec::OptVec; use syntax::opt_vec::OptVec;
use syntax::visit; use syntax::visit;
use syntax::visit::Visitor; use syntax::visit::Visitor;
@ -1643,7 +1643,7 @@ impl Resolver {
NormalModuleKind, NormalModuleKind,
true, true,
is_public, is_public,
dummy_sp()); DUMMY_SP);
} }
} }
} }
@ -1661,16 +1661,16 @@ impl Resolver {
// public. // public.
let is_public = vis != ast::private; let is_public = vis != ast::private;
if is_struct { if is_struct {
child_name_bindings.define_type(def, dummy_sp(), is_public); child_name_bindings.define_type(def, DUMMY_SP, is_public);
self.structs.insert(variant_id); self.structs.insert(variant_id);
} else { } else {
child_name_bindings.define_value(def, dummy_sp(), is_public); child_name_bindings.define_value(def, DUMMY_SP, is_public);
} }
} }
DefFn(..) | DefStaticMethod(..) | DefStatic(..) => { DefFn(..) | DefStaticMethod(..) | DefStatic(..) => {
debug!("(building reduced graph for external \ debug!("(building reduced graph for external \
crate) building value (fn/static) {}", final_ident); crate) building value (fn/static) {}", final_ident);
child_name_bindings.define_value(def, dummy_sp(), is_public); child_name_bindings.define_value(def, DUMMY_SP, is_public);
} }
DefTrait(def_id) => { DefTrait(def_id) => {
debug!("(building reduced graph for external \ debug!("(building reduced graph for external \
@ -1711,7 +1711,7 @@ impl Resolver {
} }
} }
child_name_bindings.define_type(def, dummy_sp(), is_public); child_name_bindings.define_type(def, DUMMY_SP, is_public);
// Define a module if necessary. // Define a module if necessary.
let parent_link = self.get_parent_link(new_parent, ident); let parent_link = self.get_parent_link(new_parent, ident);
@ -1720,21 +1720,21 @@ impl Resolver {
TraitModuleKind, TraitModuleKind,
true, true,
is_public, is_public,
dummy_sp()) DUMMY_SP)
} }
DefTy(_) => { DefTy(_) => {
debug!("(building reduced graph for external \ debug!("(building reduced graph for external \
crate) building type {}", final_ident); crate) building type {}", final_ident);
child_name_bindings.define_type(def, dummy_sp(), is_public); child_name_bindings.define_type(def, DUMMY_SP, is_public);
} }
DefStruct(def_id) => { DefStruct(def_id) => {
debug!("(building reduced graph for external \ debug!("(building reduced graph for external \
crate) building type and value for {}", crate) building type and value for {}",
final_ident); final_ident);
child_name_bindings.define_type(def, dummy_sp(), is_public); child_name_bindings.define_type(def, DUMMY_SP, is_public);
if csearch::get_struct_fields(self.session.cstore, def_id).len() == 0 { if csearch::get_struct_fields(self.session.cstore, def_id).len() == 0 {
child_name_bindings.define_value(def, dummy_sp(), is_public); child_name_bindings.define_value(def, DUMMY_SP, is_public);
} }
self.structs.insert(def_id); self.structs.insert(def_id);
} }
@ -1782,7 +1782,7 @@ impl Resolver {
self.add_child(ident, self.add_child(ident,
ModuleReducedGraphParent(root), ModuleReducedGraphParent(root),
OverwriteDuplicates, OverwriteDuplicates,
dummy_sp()); DUMMY_SP);
self.handle_external_def(def, self.handle_external_def(def,
visibility, visibility,
@ -1814,7 +1814,7 @@ impl Resolver {
final_ident, final_ident,
ModuleReducedGraphParent(root), ModuleReducedGraphParent(root),
OverwriteDuplicates, OverwriteDuplicates,
dummy_sp()); DUMMY_SP);
// Process the static methods. First, // Process the static methods. First,
// create the module. // create the module.
@ -1842,7 +1842,7 @@ impl Resolver {
ImplModuleKind, ImplModuleKind,
true, true,
true, true,
dummy_sp()); DUMMY_SP);
type_module = type_module =
child_name_bindings. child_name_bindings.
get_module(); get_module();
@ -1864,13 +1864,13 @@ impl Resolver {
self.add_child(ident, self.add_child(ident,
new_parent, new_parent,
OverwriteDuplicates, OverwriteDuplicates,
dummy_sp()); DUMMY_SP);
let def = DefFn( let def = DefFn(
static_method_info.def_id, static_method_info.def_id,
static_method_info.purity); static_method_info.purity);
method_name_bindings.define_value( method_name_bindings.define_value(
def, dummy_sp(), def, DUMMY_SP,
visibility == ast::public); visibility == ast::public);
} }
} }
@ -5576,7 +5576,7 @@ impl Resolver {
// because this means that they were generated in some fashion by the // because this means that they were generated in some fashion by the
// compiler and we don't need to consider them. // compiler and we don't need to consider them.
if vi.vis == public { return } if vi.vis == public { return }
if vi.span == dummy_sp() { return } if vi.span == DUMMY_SP { return }
match vi.node { match vi.node {
view_item_extern_mod(..) => {} // ignore view_item_extern_mod(..) => {} // ignore

18
src/librustc/middle/trans/_match.rs
View file

@ -227,7 +227,7 @@ use syntax::ast;
use syntax::ast::Ident; use syntax::ast::Ident;
use syntax::ast_util::path_to_ident; use syntax::ast_util::path_to_ident;
use syntax::ast_util; use syntax::ast_util;
use syntax::codemap::{Span, dummy_sp}; use syntax::codemap::{Span, DUMMY_SP};
// An option identifying a literal: either a unit-like struct or an // An option identifying a literal: either a unit-like struct or an
// expression. // expression.
@ -617,7 +617,7 @@ fn enter_opt<'r>(bcx: @Block,
let _indenter = indenter(); let _indenter = indenter();
let tcx = bcx.tcx(); let tcx = bcx.tcx();
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: dummy_sp()}; let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
let mut i = 0; let mut i = 0;
enter_match(bcx, tcx.def_map, m, col, val, |p| { enter_match(bcx, tcx.def_map, m, col, val, |p| {
let answer = match p.node { let answer = match p.node {
@ -758,7 +758,7 @@ fn enter_rec_or_struct<'r>(bcx: @Block,
bcx.val_to_str(val)); bcx.val_to_str(val));
let _indenter = indenter(); let _indenter = indenter();
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: dummy_sp()}; let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| { enter_match(bcx, dm, m, col, val, |p| {
match p.node { match p.node {
ast::PatStruct(_, ref fpats, _) => { ast::PatStruct(_, ref fpats, _) => {
@ -793,7 +793,7 @@ fn enter_tup<'r>(bcx: @Block,
bcx.val_to_str(val)); bcx.val_to_str(val));
let _indenter = indenter(); let _indenter = indenter();
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: dummy_sp()}; let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| { enter_match(bcx, dm, m, col, val, |p| {
match p.node { match p.node {
ast::PatTup(ref elts) => Some((*elts).clone()), ast::PatTup(ref elts) => Some((*elts).clone()),
@ -819,7 +819,7 @@ fn enter_tuple_struct<'r>(bcx: @Block,
bcx.val_to_str(val)); bcx.val_to_str(val));
let _indenter = indenter(); let _indenter = indenter();
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: dummy_sp()}; let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| { enter_match(bcx, dm, m, col, val, |p| {
match p.node { match p.node {
ast::PatEnum(_, Some(ref elts)) => Some((*elts).clone()), ast::PatEnum(_, Some(ref elts)) => Some((*elts).clone()),
@ -844,7 +844,7 @@ fn enter_box<'r>(bcx: @Block,
bcx.val_to_str(val)); bcx.val_to_str(val));
let _indenter = indenter(); let _indenter = indenter();
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: dummy_sp()}; let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| { enter_match(bcx, dm, m, col, val, |p| {
match p.node { match p.node {
ast::PatBox(sub) => { ast::PatBox(sub) => {
@ -871,7 +871,7 @@ fn enter_uniq<'r>(bcx: @Block,
bcx.val_to_str(val)); bcx.val_to_str(val));
let _indenter = indenter(); let _indenter = indenter();
let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: dummy_sp()}; let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
enter_match(bcx, dm, m, col, val, |p| { enter_match(bcx, dm, m, col, val, |p| {
match p.node { match p.node {
ast::PatUniq(sub) => { ast::PatUniq(sub) => {
@ -898,7 +898,7 @@ fn enter_region<'r>(bcx: @Block,
bcx.val_to_str(val)); bcx.val_to_str(val));
let _indenter = indenter(); let _indenter = indenter();
let dummy = @ast::Pat { id: 0, node: ast::PatWild, span: dummy_sp() }; let dummy = @ast::Pat { id: 0, node: ast::PatWild, span: DUMMY_SP };
enter_match(bcx, dm, m, col, val, |p| { enter_match(bcx, dm, m, col, val, |p| {
match p.node { match p.node {
ast::PatRegion(sub) => { ast::PatRegion(sub) => {
@ -1535,7 +1535,7 @@ fn compile_submatch_continue(mut bcx: @Block,
vals.slice(col + 1u, vals.len())); vals.slice(col + 1u, vals.len()));
let ccx = bcx.fcx.ccx; let ccx = bcx.fcx.ccx;
let mut pat_id = 0; let mut pat_id = 0;
let mut pat_span = dummy_sp(); let mut pat_span = DUMMY_SP;
for br in m.iter() { for br in m.iter() {
// Find a real id (we're adding placeholder wildcard patterns, but // Find a real id (we're adding placeholder wildcard patterns, but
// each column is guaranteed to have at least one real pattern) // each column is guaranteed to have at least one real pattern)

2
src/librustc/middle/trans/base.rs
View file

@ -2107,7 +2107,7 @@ pub fn trans_enum_variant_or_tuple_like_struct<A:IdAndTy>(
ty: varg.ty(), ty: varg.ty(),
pat: ast_util::ident_to_pat( pat: ast_util::ident_to_pat(
ccx.tcx.sess.next_node_id(), ccx.tcx.sess.next_node_id(),
codemap::dummy_sp(), codemap::DUMMY_SP,
special_idents::arg), special_idents::arg),
id: varg.id(), id: varg.id(),
} }

32
src/librustc/middle/trans/debuginfo.rs
View file

@ -678,7 +678,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
}; };
// This can be the case for functions inlined from another crate // This can be the case for functions inlined from another crate
if span == codemap::dummy_sp() { if span == codemap::DUMMY_SP {
return FunctionWithoutDebugInfo; return FunctionWithoutDebugInfo;
} }
@ -797,7 +797,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
} }
}; };
signature.push(type_metadata(cx, return_type, codemap::dummy_sp())); signature.push(type_metadata(cx, return_type, codemap::DUMMY_SP));
} }
} }
@ -812,7 +812,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
} }
}; };
signature.push(type_metadata(cx, arg_type, codemap::dummy_sp())); signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP));
} }
return create_DIArray(DIB(cx), signature); return create_DIArray(DIB(cx), signature);
@ -856,7 +856,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
if cx.sess.opts.extra_debuginfo { if cx.sess.opts.extra_debuginfo {
let actual_self_type_metadata = type_metadata(cx, let actual_self_type_metadata = type_metadata(cx,
actual_self_type, actual_self_type,
codemap::dummy_sp()); codemap::DUMMY_SP);
let ident = special_idents::type_self; let ident = special_idents::type_self;
@ -897,7 +897,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
// Again, only create type information if extra_debuginfo is enabled // Again, only create type information if extra_debuginfo is enabled
if cx.sess.opts.extra_debuginfo { if cx.sess.opts.extra_debuginfo {
let actual_type_metadata = type_metadata(cx, actual_type, codemap::dummy_sp()); let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP);
let param_metadata = token::ident_to_str(&ident).with_c_str(|name| { let param_metadata = token::ident_to_str(&ident).with_c_str(|name| {
unsafe { unsafe {
llvm::LLVMDIBuilderCreateTemplateTypeParameter( llvm::LLVMDIBuilderCreateTemplateTypeParameter(
@ -1271,7 +1271,7 @@ impl RecursiveTypeDescription {
llvm_type, llvm_type,
member_descriptions, member_descriptions,
file_metadata, file_metadata,
codemap::dummy_sp()); codemap::DUMMY_SP);
return metadata_stub; return metadata_stub;
} }
} }
@ -1364,7 +1364,7 @@ impl MemberDescriptionFactory for GeneralMemberDescriptionFactory {
variant_llvm_type, variant_llvm_type,
member_descriptions, member_descriptions,
self.file_metadata, self.file_metadata,
codemap::dummy_sp()); codemap::DUMMY_SP);
MemberDescription { MemberDescription {
name: @"", name: @"",
llvm_type: variant_llvm_type, llvm_type: variant_llvm_type,
@ -1419,12 +1419,12 @@ fn describe_variant(cx: &CrateContext,
cx.sess.span_warn(span, cx.sess.span_warn(span,
format!("debuginfo::enum_metadata()::adt_struct_metadata() - Unexpected node \ format!("debuginfo::enum_metadata()::adt_struct_metadata() - Unexpected node \
type: {:?}. This is a bug.", node)); type: {:?}. This is a bug.", node));
codemap::dummy_sp() codemap::DUMMY_SP
} }
} }
} else { } else {
// For definitions from other crates we have no location information available. // For definitions from other crates we have no location information available.
codemap::dummy_sp() codemap::DUMMY_SP
}; };
let metadata_stub = create_struct_stub(cx, let metadata_stub = create_struct_stub(cx,
@ -1511,7 +1511,7 @@ fn prepare_enum_metadata(cx: &CrateContext,
let discriminant_llvm_type = adt::ll_inttype(cx, inttype); let discriminant_llvm_type = adt::ll_inttype(cx, inttype);
let (discriminant_size, discriminant_align) = size_and_align_of(cx, discriminant_llvm_type); let (discriminant_size, discriminant_align) = size_and_align_of(cx, discriminant_llvm_type);
let discriminant_base_type_metadata = type_metadata(cx, adt::ty_of_inttype(inttype), let discriminant_base_type_metadata = type_metadata(cx, adt::ty_of_inttype(inttype),
codemap::dummy_sp()); codemap::DUMMY_SP);
enum_name.with_c_str(|enum_name| { enum_name.with_c_str(|enum_name| {
unsafe { unsafe {
llvm::LLVMDIBuilderCreateEnumerationType( llvm::LLVMDIBuilderCreateEnumerationType(
@ -1773,13 +1773,13 @@ fn boxed_type_metadata(cx: &CrateContext,
let int_type = ty::mk_int(); let int_type = ty::mk_int();
let nil_pointer_type = ty::mk_nil_ptr(cx.tcx); let nil_pointer_type = ty::mk_nil_ptr(cx.tcx);
let nil_pointer_type_metadata = type_metadata(cx, nil_pointer_type, codemap::dummy_sp()); let nil_pointer_type_metadata = type_metadata(cx, nil_pointer_type, codemap::DUMMY_SP);
let member_descriptions = [ let member_descriptions = [
MemberDescription { MemberDescription {
name: @"refcnt", name: @"refcnt",
llvm_type: member_llvm_types[0], llvm_type: member_llvm_types[0],
type_metadata: type_metadata(cx, int_type, codemap::dummy_sp()), type_metadata: type_metadata(cx, int_type, codemap::DUMMY_SP),
offset: ComputedMemberOffset, offset: ComputedMemberOffset,
}, },
MemberDescription { MemberDescription {
@ -2086,14 +2086,14 @@ fn type_metadata(cx: &CrateContext,
let content_type_metadata = type_metadata( let content_type_metadata = type_metadata(
cx, cx,
type_in_box, type_in_box,
codemap::dummy_sp()); codemap::DUMMY_SP);
let box_metadata = boxed_type_metadata( let box_metadata = boxed_type_metadata(
cx, cx,
Some(content_type_name), Some(content_type_name),
content_llvm_type, content_llvm_type,
content_type_metadata, content_type_metadata,
codemap::dummy_sp()); codemap::DUMMY_SP);
pointer_type_metadata(cx, pointer_type, box_metadata) pointer_type_metadata(cx, pointer_type, box_metadata)
} }
@ -2294,13 +2294,13 @@ fn get_namespace_and_span_for_item(cx: &CrateContext,
cx.sess.span_warn(warning_span, cx.sess.span_warn(warning_span,
format!("debuginfo::get_namespace_and_span_for_item() \ format!("debuginfo::get_namespace_and_span_for_item() \
- Unexpected node type: {:?}", *node)); - Unexpected node type: {:?}", *node));
codemap::dummy_sp() codemap::DUMMY_SP
} }
}; };
definition_span definition_span
} else { } else {
// For external items there is no span information // For external items there is no span information
codemap::dummy_sp() codemap::DUMMY_SP
}; };
(containing_scope, definition_span) (containing_scope, definition_span)

6
src/librustc/middle/typeck/infer/mod.rs
View file

@ -326,7 +326,7 @@ pub fn can_mk_subty(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures {
indent(|| { indent(|| {
cx.probe(|| { cx.probe(|| {
let trace = TypeTrace { let trace = TypeTrace {
origin: Misc(codemap::dummy_sp()), origin: Misc(codemap::DUMMY_SP),
values: Types(expected_found(true, a, b)) values: Types(expected_found(true, a, b))
}; };
cx.sub(true, trace).tys(a, b) cx.sub(true, trace).tys(a, b)
@ -418,7 +418,7 @@ pub fn can_mk_coercety(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures {
indent(|| { indent(|| {
cx.probe(|| { cx.probe(|| {
let trace = TypeTrace { let trace = TypeTrace {
origin: Misc(codemap::dummy_sp()), origin: Misc(codemap::DUMMY_SP),
values: Types(expected_found(true, a, b)) values: Types(expected_found(true, a, b))
}; };
Coerce(cx.combine_fields(true, trace)).tys(a, b) Coerce(cx.combine_fields(true, trace)).tys(a, b)
@ -927,7 +927,7 @@ impl RegionVariableOrigin {
BoundRegionInFnCall(a, _) => a, BoundRegionInFnCall(a, _) => a,
BoundRegionInFnType(a, _) => a, BoundRegionInFnType(a, _) => a,
BoundRegionInTypeOrImpl(a) => a, BoundRegionInTypeOrImpl(a) => a,
BoundRegionInCoherence => codemap::dummy_sp(), BoundRegionInCoherence => codemap::DUMMY_SP,
} }
} }
} }

6
src/librustc/middle/typeck/infer/test.rs
View file

@ -29,7 +29,7 @@ use extra::getopts::{opt_present};
use extra::getopts; use extra::getopts;
use extra::getopts; use extra::getopts;
use extra::oldmap::HashMap; use extra::oldmap::HashMap;
use syntax::codemap::dummy_sp; use syntax::codemap::DUMMY_SP;
use syntax::parse::parse_crate_from_source_str; use syntax::parse::parse_crate_from_source_str;
use syntax::{ast, attr, parse}; use syntax::{ast, attr, parse};
@ -221,9 +221,9 @@ impl Env {
ty::mk_imm_rptr(self.tcx, ty::ReStatic, self.t_int()) ty::mk_imm_rptr(self.tcx, ty::ReStatic, self.t_int())
} }
pub fn lub() -> Lub { Lub(self.infcx.combine_fields(true, dummy_sp())) } pub fn lub() -> Lub { Lub(self.infcx.combine_fields(true, DUMMY_SP)) }
pub fn glb() -> Glb { Glb(self.infcx.combine_fields(true, dummy_sp())) } pub fn glb() -> Glb { Glb(self.infcx.combine_fields(true, DUMMY_SP)) }
pub fn resolve_regions(exp_count: uint) { pub fn resolve_regions(exp_count: uint) {
debug!("resolve_regions(%u)", exp_count); debug!("resolve_regions(%u)", exp_count);

2
src/librustdoc/doctree.rs
View file

@ -40,7 +40,7 @@ impl Module {
name : name, name : name,
id: 0, id: 0,
vis: ast::private, vis: ast::private,
where: syntax::codemap::dummy_sp(), where: syntax::codemap::DUMMY_SP,
attrs : ~[], attrs : ~[],
structs : ~[], structs : ~[],
enums : ~[], enums : ~[],

4
src/librustpkg/util.rs
View file

@ -19,7 +19,7 @@ use extra::workcache;
use rustc::driver::{driver, session}; use rustc::driver::{driver, session};
use extra::getopts::groups::getopts; use extra::getopts::groups::getopts;
use syntax::ast_util::*; use syntax::ast_util::*;
use syntax::codemap::{dummy_sp, Spanned}; use syntax::codemap::{DUMMY_SP, Spanned};
use syntax::ext::base::ExtCtxt; use syntax::ext::base::ExtCtxt;
use syntax::{ast, attr, codemap, diagnostic, fold, visit}; use syntax::{ast, attr, codemap, diagnostic, fold, visit};
use syntax::attr::AttrMetaMethods; use syntax::attr::AttrMetaMethods;
@ -631,7 +631,7 @@ pub fn find_and_install_dependencies(context: &BuildContext,
pub fn mk_string_lit(s: @str) -> ast::lit { pub fn mk_string_lit(s: @str) -> ast::lit {
Spanned { Spanned {
node: ast::lit_str(s, ast::CookedStr), node: ast::lit_str(s, ast::CookedStr),
span: dummy_sp() span: DUMMY_SP
} }
} }

13
src/libsyntax/codemap.rs
View file

@ -90,6 +90,8 @@ pub struct Span {
expn_info: Option<@ExpnInfo> expn_info: Option<@ExpnInfo>
} }
pub static DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_info: None };
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
pub struct Spanned<T> { pub struct Spanned<T> {
node: T, node: T,
@ -112,7 +114,7 @@ impl<S:Encoder> Encodable<S> for Span {
impl<D:Decoder> Decodable<D> for Span { impl<D:Decoder> Decodable<D> for Span {
fn decode(_d: &mut D) -> Span { fn decode(_d: &mut D) -> Span {
dummy_sp() DUMMY_SP
} }
} }
@ -125,7 +127,7 @@ pub fn respan<T>(sp: Span, t: T) -> Spanned<T> {
} }
pub fn dummy_spanned<T>(t: T) -> Spanned<T> { pub fn dummy_spanned<T>(t: T) -> Spanned<T> {
respan(dummy_sp(), t) respan(DUMMY_SP, t)
} }
/* assuming that we're not in macro expansion */ /* assuming that we're not in macro expansion */
@ -133,11 +135,6 @@ pub fn mk_sp(lo: BytePos, hi: BytePos) -> Span {
Span {lo: lo, hi: hi, expn_info: None} Span {lo: lo, hi: hi, expn_info: None}
} }
// make this a const, once the compiler supports it
pub fn dummy_sp() -> Span { return mk_sp(BytePos(0), BytePos(0)); }
/// A source code location used for error reporting /// A source code location used for error reporting
pub struct Loc { pub struct Loc {
/// Information about the original source /// Information about the original source
@ -350,7 +347,7 @@ impl CodeMap {
pub fn span_to_str(&self, sp: Span) -> ~str { pub fn span_to_str(&self, sp: Span) -> ~str {
let files = &*self.files; let files = &*self.files;
if files.len() == 0 && sp == dummy_sp() { if files.len() == 0 && sp == DUMMY_SP {
return ~"no-location"; return ~"no-location";
} }

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

@ -12,7 +12,7 @@ use abi::AbiSet;
use ast::{P, Ident}; use ast::{P, Ident};
use ast; use ast;
use ast_util; use ast_util;
use codemap::{Span, respan, dummy_sp}; use codemap::{Span, respan, DUMMY_SP};
use ext::base::ExtCtxt; use ext::base::ExtCtxt;
use ext::quote::rt::*; use ext::quote::rt::*;
use fold::ast_fold; use fold::ast_fold;
@ -321,7 +321,7 @@ impl AstBuilder for ExtCtxt {
fn ty_option(&self, ty: P<ast::Ty>) -> P<ast::Ty> { fn ty_option(&self, ty: P<ast::Ty>) -> P<ast::Ty> {
self.ty_path( self.ty_path(
self.path_all(dummy_sp(), self.path_all(DUMMY_SP,
true, true,
~[ ~[
self.ident_of("std"), self.ident_of("std"),
@ -348,7 +348,7 @@ impl AstBuilder for ExtCtxt {
P(ast::Ty { P(ast::Ty {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ty_nil, node: ast::ty_nil,
span: dummy_sp(), span: DUMMY_SP,
}) })
} }
@ -361,13 +361,13 @@ impl AstBuilder for ExtCtxt {
// incorrect code. // incorrect code.
fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] { fn ty_vars(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] {
opt_vec::take_vec( opt_vec::take_vec(
ty_params.map(|p| self.ty_ident(dummy_sp(), p.ident))) ty_params.map(|p| self.ty_ident(DUMMY_SP, p.ident)))
} }
fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] { fn ty_vars_global(&self, ty_params: &OptVec<ast::TyParam>) -> ~[P<ast::Ty>] {
opt_vec::take_vec( opt_vec::take_vec(
ty_params.map(|p| self.ty_path( ty_params.map(|p| self.ty_path(
self.path_global(dummy_sp(), ~[p.ident]), None))) self.path_global(DUMMY_SP, ~[p.ident]), None)))
} }
fn strip_bounds(&self, generics: &Generics) -> Generics { fn strip_bounds(&self, generics: &Generics) -> Generics {

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

@ -1279,12 +1279,12 @@ mod test {
// make a MetaWord outer attribute with the given name // make a MetaWord outer attribute with the given name
fn make_dummy_attr(s: @str) -> ast::Attribute { fn make_dummy_attr(s: @str) -> ast::Attribute {
Spanned { Spanned {
span:codemap::dummy_sp(), span:codemap::DUMMY_SP,
node: Attribute_ { node: Attribute_ {
style: AttrOuter, style: AttrOuter,
value: @Spanned { value: @Spanned {
node: MetaWord(s), node: MetaWord(s),
span: codemap::dummy_sp(), span: codemap::DUMMY_SP,
}, },
is_sugared_doc: false, is_sugared_doc: false,
} }

6
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -11,7 +11,7 @@
use ast::{Ident, matcher_, matcher, match_tok, match_nonterminal, match_seq}; use ast::{Ident, matcher_, matcher, match_tok, match_nonterminal, match_seq};
use ast::{tt_delim}; use ast::{tt_delim};
use ast; use ast;
use codemap::{Span, Spanned, dummy_sp}; use codemap::{Span, Spanned, DUMMY_SP};
use ext::base::{AnyMacro, ExtCtxt, MacResult, MRAny, MRDef, MacroDef}; use ext::base::{AnyMacro, ExtCtxt, MacResult, MRAny, MRDef, MacroDef};
use ext::base::{NormalTT, SyntaxExpanderTTTrait}; use ext::base::{NormalTT, SyntaxExpanderTTTrait};
use ext::base; use ext::base;
@ -109,7 +109,7 @@ fn generic_extension(cx: &ExtCtxt,
} }
// Which arm's failure should we report? (the one furthest along) // Which arm's failure should we report? (the one furthest along)
let mut best_fail_spot = dummy_sp(); let mut best_fail_spot = DUMMY_SP;
let mut best_fail_msg = ~"internal error: ran no matchers"; let mut best_fail_msg = ~"internal error: ran no matchers";
let s_d = cx.parse_sess().span_diagnostic; let s_d = cx.parse_sess().span_diagnostic;
@ -178,7 +178,7 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
fn ms(m: matcher_) -> matcher { fn ms(m: matcher_) -> matcher {
Spanned { Spanned {
node: m.clone(), node: m.clone(),
span: dummy_sp() span: DUMMY_SP
} }
} }

4
src/libsyntax/ext/tt/transcribe.rs
View file

@ -10,7 +10,7 @@
use ast; use ast;
use ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,Ident}; use ast::{token_tree, tt_delim, tt_tok, tt_seq, tt_nonterminal,Ident};
use codemap::{Span, dummy_sp}; use codemap::{Span, DUMMY_SP};
use diagnostic::SpanHandler; use diagnostic::SpanHandler;
use ext::tt::macro_parser::{named_match, matched_seq, matched_nonterminal}; use ext::tt::macro_parser::{named_match, matched_seq, matched_nonterminal};
use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident}; use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident};
@ -66,7 +66,7 @@ pub fn new_tt_reader(sp_diag: @mut SpanHandler,
repeat_len: ~[], repeat_len: ~[],
/* dummy values, never read: */ /* dummy values, never read: */
cur_tok: EOF, cur_tok: EOF,
cur_span: dummy_sp() cur_span: DUMMY_SP
}; };
tt_next_token(r); /* get cur_tok and cur_span set up */ tt_next_token(r); /* get cur_tok and cur_span set up */
return r; return r;

2
src/libsyntax/parse/lexer.rs
View file

@ -81,7 +81,7 @@ pub fn new_low_level_string_reader(span_diagnostic: @mut SpanHandler,
filemap: filemap, filemap: filemap,
/* dummy values; not read */ /* dummy values; not read */
peek_tok: token::EOF, peek_tok: token::EOF,
peek_span: codemap::dummy_sp() peek_span: codemap::DUMMY_SP
}; };
bump(r); bump(r);
return r; return r;

4
src/libsyntax/print/pprust.rs
View file

@ -2422,7 +2422,7 @@ mod test {
inputs: ~[], inputs: ~[],
output: ast::P(ast::Ty {id: 0, output: ast::P(ast::Ty {id: 0,
node: ast::ty_nil, node: ast::ty_nil,
span: codemap::dummy_sp()}), span: codemap::DUMMY_SP}),
cf: ast::return_val, cf: ast::return_val,
variadic: false variadic: false
}; };
@ -2436,7 +2436,7 @@ mod test {
fn test_variant_to_str() { fn test_variant_to_str() {
let ident = token::str_to_ident("principal_skinner"); let ident = token::str_to_ident("principal_skinner");
let var = codemap::respan(codemap::dummy_sp(), ast::variant_ { let var = codemap::respan(codemap::DUMMY_SP, ast::variant_ {
name: ident, name: ident,
attrs: ~[], attrs: ~[],
// making this up as I go.... ? // making this up as I go.... ?