diff --git a/mk/crates.mk b/mk/crates.mk index 2b168b8f0e448..0bd0c70bd0519 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -57,10 +57,10 @@ TARGET_CRATES := libc std term \ panic_abort panic_unwind unwind RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \ rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \ - rustc_data_structures rustc_platform_intrinsics \ + rustc_data_structures rustc_platform_intrinsics rustc_errors \ rustc_plugin rustc_metadata rustc_passes rustc_save_analysis \ rustc_const_eval rustc_const_math rustc_incremental -HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros \ +HOST_CRATES := syntax syntax_ext syntax_pos $(RUSTC_CRATES) rustdoc fmt_macros \ flate arena graphviz rbml log serialize TOOLS := compiletest rustdoc rustc rustbook error_index_generator @@ -98,43 +98,45 @@ DEPS_serialize := std log DEPS_term := std DEPS_test := std getopts term native:rust_test_helpers -DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode -DEPS_syntax_ext := syntax fmt_macros +DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode rustc_errors syntax_pos +DEPS_syntax_ext := syntax syntax_pos rustc_errors fmt_macros +DEPS_syntax_pos := serialize DEPS_rustc_const_math := std syntax log serialize DEPS_rustc_const_eval := rustc_const_math rustc syntax log serialize \ - rustc_back graphviz + rustc_back graphviz syntax_pos DEPS_rustc := syntax fmt_macros flate arena serialize getopts rbml \ log graphviz rustc_llvm rustc_back rustc_data_structures\ - rustc_const_math + rustc_const_math syntax_pos rustc_errors DEPS_rustc_back := std syntax flate log libc -DEPS_rustc_borrowck := rustc log graphviz syntax rustc_mir +DEPS_rustc_borrowck := rustc log graphviz syntax syntax_pos rustc_errors rustc_mir DEPS_rustc_data_structures := std log serialize DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \ rustc_typeck rustc_mir rustc_resolve log syntax serialize rustc_llvm \ rustc_trans rustc_privacy rustc_lint rustc_plugin \ rustc_metadata syntax_ext rustc_passes rustc_save_analysis rustc_const_eval \ - rustc_incremental -DEPS_rustc_lint := rustc log syntax rustc_const_eval + rustc_incremental syntax_pos rustc_errors +DEPS_rustc_errors := log libc serialize syntax_pos +DEPS_rustc_lint := rustc log syntax syntax_pos rustc_const_eval DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags -DEPS_rustc_metadata := rustc syntax rbml rustc_const_math -DEPS_rustc_passes := syntax rustc core rustc_const_eval -DEPS_rustc_mir := rustc syntax rustc_const_math rustc_const_eval rustc_bitflags -DEPS_rustc_resolve := arena rustc log syntax +DEPS_rustc_metadata := rustc syntax syntax_pos rustc_errors rbml rustc_const_math +DEPS_rustc_passes := syntax syntax_pos rustc core rustc_const_eval rustc_errors +DEPS_rustc_mir := rustc syntax syntax_pos rustc_const_math rustc_const_eval rustc_bitflags +DEPS_rustc_resolve := arena rustc log syntax syntax_pos rustc_errors DEPS_rustc_platform_intrinsics := std -DEPS_rustc_plugin := rustc rustc_metadata syntax -DEPS_rustc_privacy := rustc log syntax +DEPS_rustc_plugin := rustc rustc_metadata syntax syntax_pos rustc_errors +DEPS_rustc_privacy := rustc log syntax syntax_pos DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \ log syntax serialize rustc_llvm rustc_platform_intrinsics \ - rustc_const_math rustc_const_eval rustc_incremental -DEPS_rustc_incremental := rbml rustc serialize rustc_data_structures -DEPS_rustc_save_analysis := rustc log syntax serialize -DEPS_rustc_typeck := rustc syntax rustc_platform_intrinsics rustc_const_math \ - rustc_const_eval + rustc_const_math rustc_const_eval rustc_incremental rustc_errors syntax_pos +DEPS_rustc_incremental := rbml rustc syntax_pos serialize rustc_data_structures +DEPS_rustc_save_analysis := rustc log syntax syntax_pos serialize +DEPS_rustc_typeck := rustc syntax syntax_pos rustc_platform_intrinsics rustc_const_math \ + rustc_const_eval rustc_errors DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \ - test rustc_lint rustc_const_eval + test rustc_lint rustc_const_eval syntax_pos TOOL_DEPS_compiletest := test getopts log serialize diff --git a/src/doc/book/compiler-plugins.md b/src/doc/book/compiler-plugins.md index 5b75ad6cfa858..8426d5a626549 100644 --- a/src/doc/book/compiler-plugins.md +++ b/src/doc/book/compiler-plugins.md @@ -45,11 +45,11 @@ extern crate syntax; extern crate rustc; extern crate rustc_plugin; -use syntax::codemap::Span; use syntax::parse::token; use syntax::ast::TokenTree; use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager}; use syntax::ext::build::AstBuilder; // trait for expr_usize +use syntax_pos::Span; use rustc_plugin::Registry; fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) diff --git a/src/grammar/verify.rs b/src/grammar/verify.rs index a07fdec32801d..884db34189240 100644 --- a/src/grammar/verify.rs +++ b/src/grammar/verify.rs @@ -32,9 +32,9 @@ use std::rc::Rc; use syntax::ast; use syntax::ast::Name; use syntax::codemap; -use syntax::codemap::Pos; use syntax::parse::token::{self, BinOpToken, DelimToken, Lit, Token}; use syntax::parse::lexer::TokenAndSpan; +use syntax_pos::Pos; fn parse_token_list(file: &str) -> HashMap { fn id() -> token::Token { @@ -233,10 +233,10 @@ fn parse_antlr_token(s: &str, tokens: &HashMap, surrogate_ lo -= surrogate_pairs_pos.binary_search(&(lo as usize)).unwrap_or_else(|x| x) as u32; hi -= surrogate_pairs_pos.binary_search(&(hi as usize)).unwrap_or_else(|x| x) as u32; - let sp = codemap::Span { - lo: codemap::BytePos(lo), - hi: codemap::BytePos(hi), - expn_id: codemap::NO_EXPANSION + let sp = syntax_pos::Span { + lo: syntax_pos::BytePos(lo), + hi: syntax_pos::BytePos(hi), + expn_id: syntax_pos::NO_EXPANSION }; TokenAndSpan { diff --git a/src/librustc/Cargo.toml b/src/librustc/Cargo.toml index 9291227a734f7..c17eadbc2ac6d 100644 --- a/src/librustc/Cargo.toml +++ b/src/librustc/Cargo.toml @@ -19,6 +19,8 @@ rustc_back = { path = "../librustc_back" } rustc_bitflags = { path = "../librustc_bitflags" } rustc_const_math = { path = "../librustc_const_math" } rustc_data_structures = { path = "../librustc_data_structures" } +rustc_errors = { path = "../librustc_errors" } rustc_llvm = { path = "../librustc_llvm" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } +syntax_pos = { path "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc/hir/fold.rs b/src/librustc/hir/fold.rs index 1e80bc3c54dd0..778709035bf1e 100644 --- a/src/librustc/hir/fold.rs +++ b/src/librustc/hir/fold.rs @@ -16,7 +16,8 @@ use syntax::ast::{Name, NodeId, DUMMY_NODE_ID, Attribute, Attribute_, MetaItem}; use syntax::ast::MetaItemKind; use syntax::attr::ThinAttributesExt; use hir; -use syntax::codemap::{respan, Span, Spanned}; +use syntax_pos::Span; +use syntax::codemap::{respan, Spanned}; use syntax::ptr::P; use syntax::parse::token::keywords; use syntax::util::move_map::MoveMap; diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index d47de676e7960..9bb53065ec4c3 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -28,7 +28,8 @@ use syntax::abi::Abi; use syntax::ast::{NodeId, CRATE_NODE_ID, Name, Attribute}; use syntax::attr::ThinAttributesExt; -use syntax::codemap::{Span, Spanned}; +use syntax::codemap::Spanned; +use syntax_pos::Span; use hir::*; use std::cmp; diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 393045bf93efb..cfceb70881e91 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -52,10 +52,11 @@ use std::iter; use syntax::ast::*; use syntax::attr::{ThinAttributes, ThinAttributesExt}; use syntax::ptr::P; -use syntax::codemap::{respan, Spanned, Span}; +use syntax::codemap::{respan, Spanned}; use syntax::parse::token; use syntax::std_inject; use syntax::visit::{self, Visitor}; +use syntax_pos::Span; pub struct LoweringContext<'a> { crate_root: Option<&'static str>, diff --git a/src/librustc/hir/map/blocks.rs b/src/librustc/hir/map/blocks.rs index bac96c68e4cf8..5ff3cf0518786 100644 --- a/src/librustc/hir/map/blocks.rs +++ b/src/librustc/hir/map/blocks.rs @@ -29,7 +29,7 @@ use hir::{Block, FnDecl}; use syntax::ast::{Attribute, Name, NodeId}; use syntax::attr::ThinAttributesExt; use hir as ast; -use syntax::codemap::Span; +use syntax_pos::Span; use hir::intravisit::FnKind; /// An FnLikeNode is a Node that is like a fn, in that it has a decl diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index 692f56bde28f5..693d7a2edfca5 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -17,7 +17,7 @@ use hir::def_id::DefId; use middle::cstore::InlinedItem; use std::iter::repeat; use syntax::ast::{NodeId, CRATE_NODE_ID}; -use syntax::codemap::Span; +use syntax_pos::Span; /// A Visitor that walks over the HIR and collects Nodes into a HIR map pub struct NodeCollector<'ast> { diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 41b72e569f475..488177e60c741 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -24,8 +24,9 @@ use hir::def_id::{CRATE_DEF_INDEX, DefId, DefIndex}; use syntax::abi::Abi; use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID, }; use syntax::attr::ThinAttributesExt; -use syntax::codemap::{Span, Spanned}; +use syntax::codemap::Spanned; use syntax::visit; +use syntax_pos::Span; use hir::*; use hir::fold::Folder; diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 8faa1cc1174e8..1e2144b6da8f9 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -36,7 +36,8 @@ use hir::def::Def; use hir::def_id::DefId; use util::nodemap::{NodeMap, FnvHashSet}; -use syntax::codemap::{self, mk_sp, respan, Span, Spanned, ExpnId}; +use syntax_pos::{mk_sp, Span, ExpnId}; +use syntax::codemap::{self, respan, Spanned}; use syntax::abi::Abi; use syntax::ast::{Name, NodeId, DUMMY_NODE_ID, TokenTree, AsmDialect}; use syntax::ast::{Attribute, Lit, StrStyle, FloatTy, IntTy, UintTy, MetaItem}; diff --git a/src/librustc/hir/pat_util.rs b/src/librustc/hir/pat_util.rs index 6405be7455dfe..3bb9b6d260255 100644 --- a/src/librustc/hir/pat_util.rs +++ b/src/librustc/hir/pat_util.rs @@ -14,7 +14,8 @@ use hir::{self, PatKind}; use ty::TyCtxt; use util::nodemap::FnvHashMap; use syntax::ast; -use syntax::codemap::{Span, Spanned, DUMMY_SP}; +use syntax::codemap::Spanned; +use syntax_pos::{Span, DUMMY_SP}; use std::iter::{Enumerate, ExactSizeIterator}; diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 6340f9e74724a..598a2cfca1320 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -12,8 +12,7 @@ pub use self::AnnNode::*; use syntax::abi::Abi; use syntax::ast; -use syntax::codemap::{self, CodeMap, BytePos, Spanned}; -use syntax::errors; +use syntax::codemap::{CodeMap, Spanned}; use syntax::parse::token::{self, keywords, BinOpToken}; use syntax::parse::lexer::comments; use syntax::print::pp::{self, break_offset, word, space, hardbreak}; @@ -21,6 +20,8 @@ use syntax::print::pp::{Breaks, eof}; use syntax::print::pp::Breaks::{Consistent, Inconsistent}; use syntax::print::pprust::{self as ast_pp, PrintState}; use syntax::ptr::P; +use syntax_pos::{self, BytePos}; +use errors; use hir; use hir::{Crate, PatKind, RegionTyParamBound, SelfKind, TraitTyParamBound, TraitBoundModifier}; @@ -368,11 +369,11 @@ impl<'a> State<'a> { self.end() // close the head-box } - pub fn bclose_(&mut self, span: codemap::Span, indented: usize) -> io::Result<()> { + pub fn bclose_(&mut self, span: syntax_pos::Span, indented: usize) -> io::Result<()> { self.bclose_maybe_open(span, indented, true) } pub fn bclose_maybe_open(&mut self, - span: codemap::Span, + span: syntax_pos::Span, indented: usize, close_box: bool) -> io::Result<()> { @@ -384,7 +385,7 @@ impl<'a> State<'a> { } Ok(()) } - pub fn bclose(&mut self, span: codemap::Span) -> io::Result<()> { + pub fn bclose(&mut self, span: syntax_pos::Span) -> io::Result<()> { self.bclose_(span, indent_unit) } @@ -432,7 +433,7 @@ impl<'a> State<'a> { mut get_span: G) -> io::Result<()> where F: FnMut(&mut State, &T) -> io::Result<()>, - G: FnMut(&T) -> codemap::Span + G: FnMut(&T) -> syntax_pos::Span { self.rbox(0, b)?; let len = elts.len(); @@ -859,7 +860,7 @@ impl<'a> State<'a> { enum_definition: &hir::EnumDef, generics: &hir::Generics, name: ast::Name, - span: codemap::Span, + span: syntax_pos::Span, visibility: &hir::Visibility) -> io::Result<()> { self.head(&visibility_qualified(visibility, "enum"))?; @@ -872,7 +873,7 @@ impl<'a> State<'a> { pub fn print_variants(&mut self, variants: &[hir::Variant], - span: codemap::Span) + span: syntax_pos::Span) -> io::Result<()> { self.bopen()?; for v in variants { @@ -902,7 +903,7 @@ impl<'a> State<'a> { struct_def: &hir::VariantData, generics: &hir::Generics, name: ast::Name, - span: codemap::Span, + span: syntax_pos::Span, print_finalizer: bool) -> io::Result<()> { self.print_name(name)?; @@ -2237,7 +2238,7 @@ impl<'a> State<'a> { } pub fn maybe_print_trailing_comment(&mut self, - span: codemap::Span, + span: syntax_pos::Span, next_pos: Option) -> io::Result<()> { let cm = match self.cm { diff --git a/src/librustc/infer/combine.rs b/src/librustc/infer/combine.rs index fa3715b6891a0..c9235d063cba0 100644 --- a/src/librustc/infer/combine.rs +++ b/src/librustc/infer/combine.rs @@ -49,7 +49,7 @@ use ty::relate::{RelateResult, TypeRelation}; use traits::PredicateObligations; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; #[derive(Clone)] pub struct CombineFields<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { diff --git a/src/librustc/infer/error_reporting.rs b/src/librustc/infer/error_reporting.rs index 86bc4355b2d3c..894044296cbd6 100644 --- a/src/librustc/infer/error_reporting.rs +++ b/src/librustc/infer/error_reporting.rs @@ -91,10 +91,10 @@ use std::cell::{Cell, RefCell}; use std::char::from_u32; use std::fmt; use syntax::ast; -use syntax::errors::{DiagnosticBuilder, check_old_skool}; -use syntax::codemap::{self, Pos, Span}; use syntax::parse::token; use syntax::ptr::P; +use syntax_pos::{self, Pos, Span}; +use errors::{DiagnosticBuilder, check_old_skool}; impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { pub fn note_and_explain_region(self, @@ -1933,6 +1933,6 @@ impl LifeGiver { fn name_to_dummy_lifetime(name: ast::Name) -> hir::Lifetime { hir::Lifetime { id: ast::DUMMY_NODE_ID, - span: codemap::DUMMY_SP, + span: syntax_pos::DUMMY_SP, name: name } } diff --git a/src/librustc/infer/higher_ranked/mod.rs b/src/librustc/infer/higher_ranked/mod.rs index 84b72d9be60a1..03a09917c5343 100644 --- a/src/librustc/infer/higher_ranked/mod.rs +++ b/src/librustc/infer/higher_ranked/mod.rs @@ -23,7 +23,7 @@ use super::region_inference::{TaintDirections}; use ty::{self, TyCtxt, Binder, TypeFoldable}; use ty::error::TypeError; use ty::relate::{Relate, RelateResult, TypeRelation}; -use syntax::codemap::Span; +use syntax_pos::Span; use util::nodemap::{FnvHashMap, FnvHashSet}; pub struct HrMatchResult { diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index 620e6504f413f..2ea2978b2940d 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -39,9 +39,8 @@ use rustc_data_structures::unify::{self, UnificationTable}; use std::cell::{Cell, RefCell, Ref, RefMut}; use std::fmt; use syntax::ast; -use syntax::codemap; -use syntax::codemap::{Span, DUMMY_SP}; -use syntax::errors::DiagnosticBuilder; +use errors::DiagnosticBuilder; +use syntax_pos::{self, Span, DUMMY_SP}; use util::nodemap::{FnvHashMap, FnvHashSet, NodeMap}; use self::combine::CombineFields; @@ -1036,7 +1035,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { -> UnitResult<'tcx> { self.probe(|_| { - let origin = TypeOrigin::Misc(codemap::DUMMY_SP); + let origin = TypeOrigin::Misc(syntax_pos::DUMMY_SP); let trace = TypeTrace::types(origin, true, a, b); self.sub(true, trace, &a, &b).map(|_| ()) }) @@ -1813,7 +1812,7 @@ impl<'a, 'gcx, 'tcx> TypeTrace<'tcx> { pub fn dummy(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> TypeTrace<'tcx> { TypeTrace { - origin: TypeOrigin::Misc(codemap::DUMMY_SP), + origin: TypeOrigin::Misc(syntax_pos::DUMMY_SP), values: Types(ExpectedFound { expected: tcx.types.err, found: tcx.types.err, @@ -1887,7 +1886,7 @@ impl RegionVariableOrigin { Coercion(a) => a, EarlyBoundRegion(a, _) => a, LateBoundRegion(a, _, _) => a, - BoundRegionInCoherence(_) => codemap::DUMMY_SP, + BoundRegionInCoherence(_) => syntax_pos::DUMMY_SP, UpvarRegion(_, a) => a } } diff --git a/src/librustc/infer/type_variable.rs b/src/librustc/infer/type_variable.rs index badbeccee83cf..09ae16540c4f1 100644 --- a/src/librustc/infer/type_variable.rs +++ b/src/librustc/infer/type_variable.rs @@ -13,7 +13,7 @@ use self::TypeVariableValue::*; use self::UndoEntry::*; use hir::def_id::{DefId}; use ty::{self, Ty}; -use syntax::codemap::Span; +use syntax_pos::Span; use std::cmp::min; use std::marker::PhantomData; diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index fc2d68d7262e6..eb9dd7dfcb36f 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -55,8 +55,10 @@ extern crate rustc_data_structures; extern crate serialize; extern crate collections; extern crate rustc_const_math; +extern crate rustc_errors as errors; #[macro_use] extern crate log; #[macro_use] extern crate syntax; +#[macro_use] extern crate syntax_pos; #[macro_use] #[no_link] extern crate rustc_bitflags; extern crate serialize as rustc_serialize; // used by deriving diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 94f17ea779ac8..207457128770d 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -40,11 +40,11 @@ use std::cmp; use std::default::Default as StdDefault; use std::mem; use syntax::attr::{self, AttrMetaMethods}; -use syntax::codemap::Span; -use syntax::errors::DiagnosticBuilder; use syntax::parse::token::InternedString; use syntax::ast; use syntax::attr::ThinAttributesExt; +use syntax_pos::Span; +use errors::DiagnosticBuilder; use hir; use hir::intravisit as hir_visit; use hir::intravisit::{IdVisitor, IdVisitingOperation}; diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index cc7fa54bd0a5e..f92003e3bb8b7 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -33,7 +33,7 @@ pub use self::LintSource::*; use std::hash; use std::ascii::AsciiExt; -use syntax::codemap::Span; +use syntax_pos::Span; use hir::intravisit::FnKind; use syntax::visit as ast_visit; use syntax::ast; diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs index f132212415f2f..e856eb84ff2c3 100644 --- a/src/librustc/middle/astconv_util.rs +++ b/src/librustc/middle/astconv_util.rs @@ -17,7 +17,7 @@ use hir::def::Def; use ty::{Ty, TyCtxt}; -use syntax::codemap::Span; +use syntax_pos::Span; use hir as ast; impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index d85ea96146227..fd9463b13c055 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -39,9 +39,9 @@ use std::rc::Rc; use std::path::PathBuf; use syntax::ast; use syntax::attr; -use syntax::codemap::Span; use syntax::ptr::P; use syntax::parse::token::InternedString; +use syntax_pos::Span; use rustc_back::target::Target; use hir; use hir::intravisit::{IdVisitor, IdVisitingOperation, Visitor}; diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 17da8ddbbc30c..2b59e603cc897 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -26,6 +26,7 @@ use lint; use std::collections::HashSet; use syntax::{ast, codemap}; use syntax::attr; +use syntax_pos; // Any local node that may call something in its body block should be // explored. For example, if it's a live NodeItem that is a @@ -215,7 +216,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> { fn visit_variant_data(&mut self, def: &hir::VariantData, _: ast::Name, - _: &hir::Generics, _: ast::NodeId, _: codemap::Span) { + _: &hir::Generics, _: ast::NodeId, _: syntax_pos::Span) { let has_extern_repr = self.struct_has_extern_repr; let inherited_pub_visibility = self.inherited_pub_visibility; let live_fields = def.fields().iter().filter(|f| { @@ -478,7 +479,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { fn warn_dead_code(&mut self, id: ast::NodeId, - span: codemap::Span, + span: syntax_pos::Span, name: ast::Name, node_type: &str) { let name = name.as_str(); diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index 24816d2b49729..6fe98119c7060 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -18,7 +18,7 @@ use ty::{self, Ty, TyCtxt}; use ty::MethodCall; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use hir; use hir::intravisit; use hir::intravisit::{FnKind, Visitor}; diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 602889375e970..23a261400ed07 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -15,8 +15,8 @@ use hir::def_id::{CRATE_DEF_INDEX}; use session::{config, Session}; use syntax::ast::NodeId; use syntax::attr; -use syntax::codemap::Span; use syntax::entry::EntryPointType; +use syntax_pos::Span; use hir::{Item, ItemFn}; use hir::intravisit::Visitor; diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 3b571ed057602..4e0b76365041c 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -30,7 +30,7 @@ use hir::{self, PatKind}; use syntax::ast; use syntax::ptr::P; -use syntax::codemap::Span; +use syntax_pos::Span; /////////////////////////////////////////////////////////////////////////// // The Delegate trait diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index 70158e9b9dff7..d753381d71e25 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -18,7 +18,7 @@ use ty::layout::{LayoutError, Pointer, SizeSkeleton}; use syntax::abi::Abi::RustIntrinsic; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use hir::intravisit::{self, Visitor, FnKind}; use hir; diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index ceffa366413fa..cb2f68bb55397 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -123,9 +123,10 @@ use std::io::prelude::*; use std::io; use std::rc::Rc; use syntax::ast::{self, NodeId}; -use syntax::codemap::{BytePos, original_sp, Span}; +use syntax::codemap::original_sp; use syntax::parse::token::keywords; use syntax::ptr::P; +use syntax_pos::{BytePos, Span}; use hir::Expr; use hir; diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index a345e94ebda0b..a70829347f1c1 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -83,7 +83,7 @@ use hir::{MutImmutable, MutMutable, PatKind}; use hir::pat_util::EnumerateAndAdjustIterator; use hir; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use std::fmt; use std::rc::Rc; diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 3efc584ae2b66..6f0ad087dc589 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -27,8 +27,9 @@ use std::cell::RefCell; use std::collections::hash_map::Entry; use std::fmt; use std::mem; -use syntax::codemap::{self, Span}; +use syntax::codemap; use syntax::ast::{self, NodeId}; +use syntax_pos::Span; use hir; use hir::intravisit::{self, Visitor, FnKind}; diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 78d9f5c9b7c29..2ba05b4ae3212 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -29,8 +29,8 @@ use ty; use std::fmt; use std::mem::replace; use syntax::ast; -use syntax::codemap::Span; use syntax::parse::token::keywords; +use syntax_pos::Span; use util::nodemap::NodeMap; use rustc_data_structures::fnv::FnvHashSet; diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 3744f564fa271..36268a9de960f 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -23,7 +23,7 @@ use hir::def_id::{CRATE_DEF_INDEX, DefId}; use ty::{self, TyCtxt}; use middle::privacy::AccessLevels; use syntax::parse::token::InternedString; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use syntax::ast; use syntax::ast::{NodeId, Attribute}; use syntax::feature_gate::{GateIssue, emit_feature_err, find_lang_feature_accepted_version}; diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index 325887684914b..20c5320fd6464 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -15,8 +15,8 @@ use session::Session; use middle::lang_items; use syntax::ast; -use syntax::codemap::Span; use syntax::parse::token::InternedString; +use syntax_pos::Span; use hir::intravisit::Visitor; use hir::intravisit; use hir; diff --git a/src/librustc/mir/repr.rs b/src/librustc/mir/repr.rs index a6052f9aa75a1..f55afc342e3f3 100644 --- a/src/librustc/mir/repr.rs +++ b/src/librustc/mir/repr.rs @@ -25,7 +25,7 @@ use std::fmt::{self, Debug, Formatter, Write}; use std::{iter, u32}; use std::ops::{Index, IndexMut}; use syntax::ast::{self, Name}; -use syntax::codemap::Span; +use syntax_pos::Span; use super::cache::Cache; diff --git a/src/librustc/mir/visit.rs b/src/librustc/mir/visit.rs index bc45a730c2e21..3f714ff4d5152 100644 --- a/src/librustc/mir/visit.rs +++ b/src/librustc/mir/visit.rs @@ -16,7 +16,7 @@ use mir::repr::*; use rustc_const_math::ConstUsize; use rustc_data_structures::tuple_slice::TupleSlice; use rustc_data_structures::indexed_vec::Idx; -use syntax::codemap::Span; +use syntax_pos::Span; // # The MIR Visitor // diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 7a1ac7c218c8c..a37990061920b 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -26,11 +26,12 @@ use middle::cstore; use syntax::ast::{self, IntTy, UintTy}; use syntax::attr; use syntax::attr::AttrMetaMethods; -use syntax::errors::{ColorConfig, Handler}; use syntax::parse; use syntax::parse::token::InternedString; use syntax::feature_gate::UnstableFeatures; +use errors::{ColorConfig, Handler}; + use getopts; use std::collections::HashMap; use std::env; @@ -1420,12 +1421,11 @@ mod tests { use middle::cstore::DummyCrateStore; use session::config::{build_configuration, build_session_options}; use session::build_session; - + use errors; use std::rc::Rc; use getopts::{getopts, OptGroup}; use syntax::attr; use syntax::attr::AttrMetaMethods; - use syntax::diagnostics; fn optgroups() -> Vec { super::rustc_optgroups().into_iter() @@ -1442,7 +1442,7 @@ mod tests { Ok(m) => m, Err(f) => panic!("test_switch_implies_cfg_test: {}", f) }; - let registry = diagnostics::registry::Registry::new(&[]); + let registry = errors::registry::Registry::new(&[]); let sessopts = build_session_options(matches); let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); let cfg = build_configuration(&sess); @@ -1462,7 +1462,7 @@ mod tests { panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f) } }; - let registry = diagnostics::registry::Registry::new(&[]); + let registry = errors::registry::Registry::new(&[]); let sessopts = build_session_options(matches); let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); @@ -1479,7 +1479,7 @@ mod tests { let matches = getopts(&[ "-Awarnings".to_string() ], &optgroups()).unwrap(); - let registry = diagnostics::registry::Registry::new(&[]); + let registry = errors::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); @@ -1491,7 +1491,7 @@ mod tests { "-Awarnings".to_string(), "-Dwarnings".to_string() ], &optgroups()).unwrap(); - let registry = diagnostics::registry::Registry::new(&[]); + let registry = errors::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); @@ -1502,7 +1502,7 @@ mod tests { let matches = getopts(&[ "-Adead_code".to_string() ], &optgroups()).unwrap(); - let registry = diagnostics::registry::Registry::new(&[]); + let registry = errors::registry::Registry::new(&[]); let sessopts = build_session_options(&matches); let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index d60c31369d0a1..77259cea24d28 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -21,17 +21,16 @@ use util::nodemap::{NodeMap, FnvHashMap}; use mir::transform as mir_pass; use syntax::ast::{NodeId, NodeIdAssigner, Name}; -use syntax::codemap::{Span, MultiSpan}; -use syntax::errors::{self, DiagnosticBuilder}; -use syntax::errors::emitter::{Emitter, BasicEmitter, EmitterWriter}; -use syntax::errors::json::JsonEmitter; -use syntax::diagnostics; +use errors::{self, DiagnosticBuilder}; +use errors::emitter::{Emitter, BasicEmitter, EmitterWriter}; +use syntax::json::JsonEmitter; use syntax::feature_gate; use syntax::parse; use syntax::parse::ParseSess; use syntax::parse::token; use syntax::{ast, codemap}; use syntax::feature_gate::AttributeType; +use syntax_pos::{Span, MultiSpan}; use rustc_back::target::Target; use llvm; @@ -424,7 +423,7 @@ fn split_msg_into_multilines(msg: &str) -> Option { pub fn build_session(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, - registry: diagnostics::registry::Registry, + registry: errors::registry::Registry, cstore: Rc CrateStore<'a>>) -> Session { build_session_with_codemap(sopts, @@ -438,7 +437,7 @@ pub fn build_session(sopts: config::Options, pub fn build_session_with_codemap(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, - registry: diagnostics::registry::Registry, + registry: errors::registry::Registry, cstore: Rc CrateStore<'a>>, codemap: Rc) -> Session { @@ -455,7 +454,10 @@ pub fn build_session_with_codemap(sopts: config::Options, let emitter: Box = match sopts.error_format { config::ErrorOutputType::HumanReadable(color_config) => { - Box::new(EmitterWriter::stderr(color_config, Some(registry), codemap.clone())) + Box::new(EmitterWriter::stderr(color_config, + Some(registry), + codemap.clone(), + errors::snippet::FormatMode::EnvironmentSelected)) } config::ErrorOutputType::Json => { Box::new(JsonEmitter::stderr(Some(registry), codemap.clone())) diff --git a/src/librustc/traits/coherence.rs b/src/librustc/traits/coherence.rs index 414b9fa70c302..4344eb1ebf664 100644 --- a/src/librustc/traits/coherence.rs +++ b/src/librustc/traits/coherence.rs @@ -17,7 +17,7 @@ use hir::def_id::DefId; use ty::subst::TypeSpace; use ty::{self, Ty, TyCtxt}; use infer::{InferCtxt, TypeOrigin}; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; #[derive(Copy, Clone)] struct InferIsLocal(bool); diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index 9a69958fea014..b6591471f0eef 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -37,8 +37,8 @@ use std::cmp; use std::fmt; use syntax::ast; use syntax::attr::{AttributeMethods, AttrMetaMethods}; -use syntax::codemap::Span; -use syntax::errors::DiagnosticBuilder; +use syntax_pos::Span; +use errors::DiagnosticBuilder; #[derive(Debug, PartialEq, Eq, Hash)] pub struct TraitErrorKey<'tcx> { diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index 5b363d90578b1..68db5f8647639 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -23,7 +23,7 @@ use infer::InferCtxt; use std::rc::Rc; use syntax::ast; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; pub use self::error_reporting::TraitErrorKey; pub use self::coherence::orphan_check; diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs index c7a3637557602..9348def1311eb 100644 --- a/src/librustc/traits/specialize/mod.rs +++ b/src/librustc/traits/specialize/mod.rs @@ -27,7 +27,7 @@ use middle::region; use ty::subst::{Subst, Substs}; use traits::{self, ProjectionMode, ObligationCause, Normalized}; use ty::{self, TyCtxt}; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; pub mod specialization_graph; diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index f8149565aa66b..a097c0093b2e1 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -12,7 +12,7 @@ use hir::def_id::DefId; use infer::InferCtxt; use ty::subst::{Subst, Substs}; use ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef}; -use syntax::codemap::Span; +use syntax_pos::Span; use util::common::ErrorReported; use util::nodemap::FnvHashSet; diff --git a/src/librustc/ty/adjustment.rs b/src/librustc/ty/adjustment.rs index 60f2ca6f4d9b6..47ca7d335ab82 100644 --- a/src/librustc/ty/adjustment.rs +++ b/src/librustc/ty/adjustment.rs @@ -15,7 +15,7 @@ use ty::{self, Ty, TyCtxt, TypeAndMut, TypeFoldable}; use ty::LvaluePreference::{NoPreference}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use hir; diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 3d187cfc08175..219cb5e383a8d 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -862,7 +862,7 @@ pub mod tls { use std::cell::Cell; use std::fmt; - use syntax::codemap; + use syntax_pos; /// Marker types used for the scoped TLS slot. /// The type context cannot be used directly because the scoped TLS @@ -875,7 +875,7 @@ pub mod tls { *const ThreadLocalInterners)>> = Cell::new(None) } - fn span_debug(span: codemap::Span, f: &mut fmt::Formatter) -> fmt::Result { + fn span_debug(span: syntax_pos::Span, f: &mut fmt::Formatter) -> fmt::Result { with(|tcx| { write!(f, "{}", tcx.sess.codemap().span_to_string(span)) }) @@ -884,7 +884,7 @@ pub mod tls { pub fn enter_global<'gcx, F, R>(gcx: GlobalCtxt<'gcx>, f: F) -> R where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'gcx>) -> R { - codemap::SPAN_DEBUG.with(|span_dbg| { + syntax_pos::SPAN_DEBUG.with(|span_dbg| { let original_span_debug = span_dbg.get(); span_dbg.set(span_debug); let result = enter(&gcx, &gcx.global_interners, f); diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs index b5190f313309f..bddc2dbdb7e77 100644 --- a/src/librustc/ty/error.rs +++ b/src/librustc/ty/error.rs @@ -16,8 +16,8 @@ use ty::{self, BoundRegion, Region, Ty, TyCtxt}; use std::fmt; use syntax::abi; use syntax::ast::{self, Name}; -use syntax::codemap::Span; -use syntax::errors::DiagnosticBuilder; +use errors::DiagnosticBuilder; +use syntax_pos::Span; use hir; diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index d305a772ae5db..61c8aa8fcebf3 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -21,7 +21,7 @@ use util::common::slice_pat; use syntax::ast::{FloatTy, IntTy, UintTy}; use syntax::attr; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; use std::cmp; use std::fmt; diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 2826680926637..14db922d29810 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -44,8 +44,8 @@ use std::slice; use std::vec::IntoIter; use syntax::ast::{self, CrateNum, Name, NodeId}; use syntax::attr::{self, AttrMetaMethods}; -use syntax::codemap::{DUMMY_SP, Span}; use syntax::parse::token::InternedString; +use syntax_pos::{DUMMY_SP, Span}; use rustc_const_math::ConstInt; diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs index fbc565ca847b6..595d965ffce26 100644 --- a/src/librustc/ty/subst.rs +++ b/src/librustc/ty/subst.rs @@ -22,7 +22,7 @@ use std::fmt; use std::iter::IntoIterator; use std::slice::Iter; use std::vec::{Vec, IntoIter}; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; /////////////////////////////////////////////////////////////////////////// diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs index 7745f00c2ebd9..ee7fb5fc94b77 100644 --- a/src/librustc/ty/util.rs +++ b/src/librustc/ty/util.rs @@ -27,7 +27,7 @@ use std::cmp; use std::hash::{Hash, SipHasher, Hasher}; use syntax::ast::{self, Name}; use syntax::attr::{self, SignedInt, UnsignedInt}; -use syntax::codemap::Span; +use syntax_pos::Span; use hir; diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs index a25994ea69981..37ba936d2f42a 100644 --- a/src/librustc/ty/wf.rs +++ b/src/librustc/ty/wf.rs @@ -16,7 +16,7 @@ use traits; use ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable}; use std::iter::once; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use util::common::ErrorReported; /// Returns the set of obligations needed to make `ty` well-formed. diff --git a/src/librustc_borrowck/Cargo.toml b/src/librustc_borrowck/Cargo.toml index c8a71ea350555..b9c64f8618221 100644 --- a/src/librustc_borrowck/Cargo.toml +++ b/src/librustc_borrowck/Cargo.toml @@ -12,6 +12,7 @@ test = false [dependencies] log = { path = "../liblog" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } graphviz = { path = "../libgraphviz" } rustc = { path = "../librustc" } rustc_data_structures = { path = "../librustc_data_structures" } diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index 36f95f62d0606..9cae270984f00 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -27,7 +27,7 @@ use rustc::middle::mem_categorization::Categorization; use rustc::middle::region; use rustc::ty::{self, TyCtxt}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir; use std::rc::Rc; diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 6ab85d7d449dc..d3d6fa9eb52b5 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -27,8 +27,8 @@ use rustc::middle::mem_categorization as mc; use std::mem; use std::rc::Rc; use syntax::ast; -use syntax::codemap::{Span, DUMMY_SP}; use syntax::attr::AttrMetaMethods; +use syntax_pos::{Span, DUMMY_SP}; #[derive(PartialEq, Eq, PartialOrd, Ord)] enum Fragment { diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index 64f35aed23f5c..9431dcdbcac8e 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -22,7 +22,7 @@ use rustc::ty; use std::rc::Rc; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir::{self, PatKind}; struct GatherMoveInfo<'tcx> { diff --git a/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs b/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs index c2492bba62473..e34c6e567bd8e 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs @@ -19,7 +19,7 @@ use rustc::middle::region; use rustc::ty; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; type R = Result<(),()>; diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index 7f814f5dfaa91..c982fc091d24c 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -25,8 +25,8 @@ use rustc::middle::region; use rustc::ty::{self, TyCtxt}; use syntax::ast; -use syntax::codemap::Span; use syntax::ast::NodeId; +use syntax_pos::Span; use rustc::hir; use rustc::hir::Expr; use rustc::hir::intravisit; diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index c1e83588570e7..fc17633d63b93 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -14,8 +14,8 @@ use rustc::middle::mem_categorization::Categorization; use rustc::middle::mem_categorization::InteriorOffsetKind as Kind; use rustc::ty; use syntax::ast; -use syntax::codemap; -use syntax::errors::DiagnosticBuilder; +use syntax_pos; +use errors::DiagnosticBuilder; use rustc::hir; pub struct MoveErrorCollector<'tcx> { @@ -56,7 +56,7 @@ impl<'tcx> MoveError<'tcx> { #[derive(Clone)] pub struct MoveSpanAndPath { - pub span: codemap::Span, + pub span: syntax_pos::Span, pub name: ast::Name, } @@ -169,7 +169,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, } fn note_move_destination(mut err: DiagnosticBuilder, - move_to_span: codemap::Span, + move_to_span: syntax_pos::Span, pat_name: ast::Name, is_first_note: bool) -> DiagnosticBuilder { if is_first_note { diff --git a/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs b/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs index ee8c3aff2ec80..3d9df4c8bd008 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs @@ -15,7 +15,7 @@ use rustc::middle::expr_use_visitor as euv; use rustc::middle::mem_categorization as mc; use rustc::middle::mem_categorization::Categorization; use rustc::ty; -use syntax::codemap::Span; +use syntax_pos::Span; use borrowck::ToInteriorKind; diff --git a/src/librustc_borrowck/borrowck/mir/dataflow/sanity_check.rs b/src/librustc_borrowck/borrowck/mir/dataflow/sanity_check.rs index c8d3ff01b6c1a..d59bdf93f3225 100644 --- a/src/librustc_borrowck/borrowck/mir/dataflow/sanity_check.rs +++ b/src/librustc_borrowck/borrowck/mir/dataflow/sanity_check.rs @@ -10,7 +10,7 @@ use syntax::abi::{Abi}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::ty::{self, TyCtxt}; use rustc::mir::repr::{self, Mir}; diff --git a/src/librustc_borrowck/borrowck/mir/elaborate_drops.rs b/src/librustc_borrowck/borrowck/mir/elaborate_drops.rs index 065cbbf76b384..623ea60c5a6d8 100644 --- a/src/librustc_borrowck/borrowck/mir/elaborate_drops.rs +++ b/src/librustc_borrowck/borrowck/mir/elaborate_drops.rs @@ -23,7 +23,7 @@ use rustc::middle::const_val::ConstVal; use rustc::middle::lang_items; use rustc::util::nodemap::FnvHashMap; use rustc_data_structures::indexed_vec::Idx; -use syntax::codemap::Span; +use syntax_pos::Span; use std::fmt; use std::u32; diff --git a/src/librustc_borrowck/borrowck/mir/mod.rs b/src/librustc_borrowck/borrowck/mir/mod.rs index 36f7c11c8cb81..7481b15685e69 100644 --- a/src/librustc_borrowck/borrowck/mir/mod.rs +++ b/src/librustc_borrowck/borrowck/mir/mod.rs @@ -12,8 +12,8 @@ use borrowck::BorrowckCtxt; use syntax::ast::{self, MetaItem}; use syntax::attr::AttrMetaMethods; -use syntax::codemap::{Span, DUMMY_SP}; use syntax::ptr::P; +use syntax_pos::{Span, DUMMY_SP}; use rustc::hir; use rustc::hir::intravisit::{FnKind}; diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 5acbb18a2ffee..e86120b73bf97 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -43,8 +43,8 @@ use std::mem; use std::rc::Rc; use syntax::ast; use syntax::attr::AttrMetaMethods; -use syntax::codemap::{MultiSpan, Span}; -use syntax::errors::DiagnosticBuilder; +use syntax_pos::{MultiSpan, Span}; +use errors::DiagnosticBuilder; use rustc::hir; use rustc::hir::{FnDecl, Block}; diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index a742260018676..4b8cbbffaa5ef 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -28,7 +28,7 @@ use std::cell::RefCell; use std::rc::Rc; use std::usize; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir; use rustc::hir::intravisit::IdRange; diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs index f3c39bd5fd165..16fefee347269 100644 --- a/src/librustc_borrowck/lib.rs +++ b/src/librustc_borrowck/lib.rs @@ -28,6 +28,8 @@ #![feature(question_mark)] #[macro_use] extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; +extern crate rustc_errors as errors; // for "clarity", rename the graphviz crate to dot; graphviz within `borrowck` // refers to the borrowck-specific graphviz adapter traits. diff --git a/src/librustc_const_eval/Cargo.toml b/src/librustc_const_eval/Cargo.toml index c572284a6bb37..01872bbe3c049 100644 --- a/src/librustc_const_eval/Cargo.toml +++ b/src/librustc_const_eval/Cargo.toml @@ -16,3 +16,4 @@ rustc_back = { path = "../librustc_back" } rustc_const_math = { path = "../librustc_const_math" } syntax = { path = "../libsyntax" } graphviz = { path = "../libgraphviz" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_const_eval/check_match.rs b/src/librustc_const_eval/check_match.rs index dbca15ffd34b9..173d1f513a569 100644 --- a/src/librustc_const_eval/check_match.rs +++ b/src/librustc_const_eval/check_match.rs @@ -37,7 +37,8 @@ use rustc::hir::intravisit::{self, IdVisitor, IdVisitingOperation, Visitor, FnKi use rustc_back::slice; use syntax::ast::{self, DUMMY_NODE_ID, NodeId}; -use syntax::codemap::{Span, Spanned, DUMMY_SP}; +use syntax::codemap::Spanned; +use syntax_pos::{Span, DUMMY_SP}; use rustc::hir::fold::{Folder, noop_fold_pat}; use rustc::hir::print::pat_to_string; use syntax::ptr::P; diff --git a/src/librustc_const_eval/eval.rs b/src/librustc_const_eval/eval.rs index 34dce44004823..c03903515abe6 100644 --- a/src/librustc_const_eval/eval.rs +++ b/src/librustc_const_eval/eval.rs @@ -33,10 +33,10 @@ use syntax::ast; use rustc::hir::{Expr, PatKind}; use rustc::hir; use rustc::hir::intravisit::FnKind; -use syntax::codemap::Span; use syntax::ptr::P; use syntax::codemap; use syntax::attr::IntType; +use syntax_pos::{self, Span}; use std::borrow::Cow; use std::cmp::Ordering; @@ -301,7 +301,7 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let field_pats = try!(fields.iter() .map(|field| Ok(codemap::Spanned { - span: codemap::DUMMY_SP, + span: syntax_pos::DUMMY_SP, node: hir::FieldPat { name: field.name.node, pat: try!(const_expr_to_pat(tcx, &field.expr, diff --git a/src/librustc_const_eval/lib.rs b/src/librustc_const_eval/lib.rs index 9ab6a437a5ab2..2da9a55f1fd44 100644 --- a/src/librustc_const_eval/lib.rs +++ b/src/librustc_const_eval/lib.rs @@ -38,7 +38,7 @@ extern crate rustc_back; extern crate rustc_const_math; extern crate graphviz; - +extern crate syntax_pos; extern crate serialize as rustc_serialize; // used by deriving // NB: This module needs to be declared first so diagnostics are diff --git a/src/librustc_driver/Cargo.toml b/src/librustc_driver/Cargo.toml index 4533946d26ea4..54c62d3665994 100644 --- a/src/librustc_driver/Cargo.toml +++ b/src/librustc_driver/Cargo.toml @@ -17,6 +17,7 @@ rustc = { path = "../librustc" } rustc_back = { path = "../librustc_back" } rustc_borrowck = { path = "../librustc_borrowck" } rustc_const_eval = { path = "../librustc_const_eval" } +rustc_errors = { path = "../librustc_errors" } rustc_lint = { path = "../librustc_lint" } rustc_llvm = { path = "../librustc_llvm" } rustc_mir = { path = "../librustc_mir" } @@ -32,3 +33,4 @@ rustc_metadata = { path = "../librustc_metadata" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } syntax_ext = { path = "../libsyntax_ext" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index bd6b0599e7832..32eb3fdd71092 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -42,6 +42,7 @@ extern crate rustc; extern crate rustc_back; extern crate rustc_borrowck; extern crate rustc_const_eval; +extern crate rustc_errors as errors; extern crate rustc_passes; extern crate rustc_lint; extern crate rustc_plugin; @@ -60,6 +61,7 @@ extern crate log; #[macro_use] extern crate syntax; extern crate syntax_ext; +extern crate syntax_pos; use driver::CompileController; use pretty::{PpMode, UserIdentifiedItem}; @@ -92,11 +94,12 @@ use std::thread; use rustc::session::early_error; -use syntax::{ast, errors, diagnostics}; -use syntax::codemap::{CodeMap, FileLoader, RealFileLoader, MultiSpan}; -use syntax::errors::emitter::Emitter; +use syntax::{ast, json}; +use syntax::codemap::{CodeMap, FileLoader, RealFileLoader}; use syntax::feature_gate::{GatedCfg, UnstableFeatures}; use syntax::parse::{self, PResult, token}; +use syntax_pos::MultiSpan; +use errors::emitter::Emitter; #[cfg(test)] pub mod test; @@ -290,7 +293,7 @@ pub trait CompilerCalls<'a> { fn early_callback(&mut self, _: &getopts::Matches, _: &config::Options, - _: &diagnostics::registry::Registry, + _: &errors::registry::Registry, _: ErrorOutputType) -> Compilation { Compilation::Continue @@ -329,7 +332,7 @@ pub trait CompilerCalls<'a> { _: &config::Options, _: &Option, _: &Option, - _: &diagnostics::registry::Registry) + _: &errors::registry::Registry) -> Option<(Input, Option)> { None } @@ -344,7 +347,7 @@ pub trait CompilerCalls<'a> { pub struct RustcDefaultCalls; fn handle_explain(code: &str, - descriptions: &diagnostics::registry::Registry, + descriptions: &errors::registry::Registry, output: ErrorOutputType) { let normalised = if code.starts_with("E") { code.to_string() @@ -374,7 +377,7 @@ fn check_cfg(sopts: &config::Options, config::ErrorOutputType::HumanReadable(color_config) => { Box::new(errors::emitter::BasicEmitter::stderr(color_config)) } - config::ErrorOutputType::Json => Box::new(errors::json::JsonEmitter::basic()), + config::ErrorOutputType::Json => Box::new(json::JsonEmitter::basic()), }; let mut saw_invalid_predicate = false; @@ -401,7 +404,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { fn early_callback(&mut self, matches: &getopts::Matches, sopts: &config::Options, - descriptions: &diagnostics::registry::Registry, + descriptions: &errors::registry::Registry, output: ErrorOutputType) -> Compilation { if let Some(ref code) = matches.opt_str("explain") { @@ -418,7 +421,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { sopts: &config::Options, odir: &Option, ofile: &Option, - descriptions: &diagnostics::registry::Registry) + descriptions: &errors::registry::Registry) -> Option<(Input, Option)> { match matches.free.len() { 0 => { @@ -1081,8 +1084,8 @@ fn exit_on_err() -> ! { panic!(); } -pub fn diagnostics_registry() -> diagnostics::registry::Registry { - use syntax::diagnostics::registry::Registry; +pub fn diagnostics_registry() -> errors::registry::Registry { + use errors::registry::Registry; let mut all_errors = Vec::new(); all_errors.extend_from_slice(&rustc::DIAGNOSTICS); diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 0a093887c5094..f7905e53101b0 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -31,12 +31,12 @@ use rustc_mir::pretty::write_mir_pretty; use rustc_mir::graphviz::write_mir_graphviz; use syntax::ast::{self, BlockCheckMode}; -use syntax::codemap; use syntax::fold::{self, Folder}; use syntax::print::{pp, pprust}; use syntax::print::pprust::PrintState; use syntax::ptr::P; use syntax::util::small_vector::SmallVector; +use syntax_pos; use graphviz as dot; @@ -661,7 +661,7 @@ impl fold::Folder for ReplaceBodyWithLoop { stmts: vec![], rules: rules, id: ast::DUMMY_NODE_ID, - span: codemap::DUMMY_SP, + span: syntax_pos::DUMMY_SP, }) } @@ -671,7 +671,7 @@ impl fold::Folder for ReplaceBodyWithLoop { let loop_expr = P(ast::Expr { node: ast::ExprKind::Loop(empty_block, None), id: ast::DUMMY_NODE_ID, - span: codemap::DUMMY_SP, + span: syntax_pos::DUMMY_SP, attrs: None, }); diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index c147a534e5ea7..0f5977cf06618 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -31,12 +31,13 @@ use rustc::session::{self, config}; use std::rc::Rc; use syntax::ast; use syntax::abi::Abi; -use syntax::codemap::{CodeMap, DUMMY_SP}; -use syntax::errors; -use syntax::errors::emitter::{CoreEmitter, Emitter}; -use syntax::errors::{Level, RenderSpan}; +use syntax::codemap::CodeMap; +use errors; +use errors::emitter::{CoreEmitter, Emitter}; +use errors::{Level, RenderSpan}; use syntax::parse::token; use syntax::feature_gate::UnstableFeatures; +use syntax_pos::DUMMY_SP; use rustc::hir; diff --git a/src/librustc_errors/Cargo.toml b/src/librustc_errors/Cargo.toml new file mode 100644 index 0000000000000..128c270eb359c --- /dev/null +++ b/src/librustc_errors/Cargo.toml @@ -0,0 +1,14 @@ +[package] +authors = ["The Rust Project Developers"] +name = "rustc_errors" +version = "0.0.0" + +[lib] +name = "rustc_errors" +path = "lib.rs" +crate-type = ["dylib"] + +[dependencies] +log = { path = "../liblog" } +serialize = { path = "../libserialize" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/libsyntax/errors/emitter.rs b/src/librustc_errors/emitter.rs similarity index 67% rename from src/libsyntax/errors/emitter.rs rename to src/librustc_errors/emitter.rs index 71a03e846a2b5..a7c68e3a87b31 100644 --- a/src/libsyntax/errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -10,14 +10,14 @@ use self::Destination::*; -use codemap::{self, COMMAND_LINE_SP, DUMMY_SP, Span, MultiSpan}; -use diagnostics; +use syntax_pos::{COMMAND_LINE_SP, DUMMY_SP, Span, MultiSpan, LineInfo}; +use registry; -use errors::check_old_skool; -use errors::{Level, RenderSpan, CodeSuggestion, DiagnosticBuilder}; -use errors::RenderSpan::*; -use errors::Level::*; -use errors::snippet::{RenderedLineKind, SnippetData, Style}; +use check_old_skool; +use {Level, RenderSpan, CodeSuggestion, DiagnosticBuilder, CodeMapper}; +use RenderSpan::*; +use Level::*; +use snippet::{RenderedLineKind, SnippetData, Style, FormatMode}; use std::{cmp, fmt}; use std::io::prelude::*; @@ -151,15 +151,15 @@ impl BasicEmitter { pub struct EmitterWriter { dst: Destination, - registry: Option, - cm: Rc, + registry: Option, + cm: Rc, /// Is this the first error emitted thus far? If not, we emit a /// `\n` before the top-level errors. first: bool, // For now, allow an old-school mode while we transition - old_school: bool, + format_mode: FormatMode } impl CoreEmitter for EmitterWriter { @@ -193,36 +193,36 @@ macro_rules! println_maybe_styled { impl EmitterWriter { pub fn stderr(color_config: ColorConfig, - registry: Option, - code_map: Rc) + registry: Option, + code_map: Rc, + format_mode: FormatMode) -> EmitterWriter { - let old_school = check_old_skool(); if color_config.use_color() { let dst = Destination::from_stderr(); EmitterWriter { dst: dst, registry: registry, cm: code_map, first: true, - old_school: old_school } + format_mode: format_mode.clone() } } else { EmitterWriter { dst: Raw(Box::new(io::stderr())), registry: registry, cm: code_map, first: true, - old_school: old_school } + format_mode: format_mode.clone() } } } pub fn new(dst: Box, - registry: Option, - code_map: Rc) + registry: Option, + code_map: Rc, + format_mode: FormatMode) -> EmitterWriter { - let old_school = check_old_skool(); EmitterWriter { dst: Raw(dst), registry: registry, cm: code_map, first: true, - old_school: old_school } + format_mode: format_mode.clone() } } fn emit_message_(&mut self, @@ -233,11 +233,17 @@ impl EmitterWriter { is_header: bool, show_snippet: bool) -> io::Result<()> { + let old_school = match self.format_mode { + FormatMode::NewErrorFormat => false, + FormatMode::OriginalErrorFormat => true, + FormatMode::EnvironmentSelected => check_old_skool() + }; + if is_header { if self.first { self.first = false; } else { - if !self.old_school { + if !old_school { write!(self.dst, "\n")?; } } @@ -248,7 +254,7 @@ impl EmitterWriter { .and_then(|registry| registry.find_description(code)) .is_some() => { let code_with_explain = String::from("--explain ") + code; - if self.old_school { + if old_school { let loc = match rsp.span().primary_span() { Some(COMMAND_LINE_SP) | Some(DUMMY_SP) => "".to_string(), Some(ps) => self.cm.span_to_string(ps), @@ -261,7 +267,7 @@ impl EmitterWriter { } } _ => { - if self.old_school { + if old_school { let loc = match rsp.span().primary_span() { Some(COMMAND_LINE_SP) | Some(DUMMY_SP) => "".to_string(), Some(ps) => self.cm.span_to_string(ps), @@ -303,7 +309,7 @@ impl EmitterWriter { } } } - if self.old_school { + if old_school { match code { Some(code) if self.registry.as_ref() .and_then(|registry| registry.find_description(code)) @@ -326,11 +332,13 @@ impl EmitterWriter { fn highlight_suggestion(&mut self, suggestion: &CodeSuggestion) -> io::Result<()> { + use std::borrow::Borrow; + let primary_span = suggestion.msp.primary_span().unwrap(); let lines = self.cm.span_to_lines(primary_span).unwrap(); assert!(!lines.lines.is_empty()); - let complete = suggestion.splice_lines(&self.cm); + let complete = suggestion.splice_lines(self.cm.borrow()); let line_count = cmp::min(lines.lines.len(), MAX_HIGHLIGHT_LINES); let display_lines = &lines.lines[..line_count]; @@ -356,19 +364,27 @@ impl EmitterWriter { Ok(()) } - fn highlight_lines(&mut self, + pub fn highlight_lines(&mut self, msp: &MultiSpan, lvl: Level) -> io::Result<()> { + let old_school = match self.format_mode { + FormatMode::NewErrorFormat => false, + FormatMode::OriginalErrorFormat => true, + FormatMode::EnvironmentSelected => check_old_skool() + }; + let mut snippet_data = SnippetData::new(self.cm.clone(), - msp.primary_span()); - if self.old_school { + msp.primary_span(), + self.format_mode.clone()); + if old_school { let mut output_vec = vec![]; for span_label in msp.span_labels() { let mut snippet_data = SnippetData::new(self.cm.clone(), - Some(span_label.span)); + Some(span_label.span), + self.format_mode.clone()); snippet_data.push(span_label.span, span_label.is_primary, @@ -430,7 +446,7 @@ impl EmitterWriter { } } -fn line_num_max_digits(line: &codemap::LineInfo) -> usize { +fn line_num_max_digits(line: &LineInfo) -> usize { let mut max_line_num = line.line_index + 1; let mut digits = 0; while max_line_num > 0 { @@ -617,255 +633,3 @@ impl Write for Destination { } } } - - -#[cfg(test)] -mod test { - use errors::{Level, CodeSuggestion}; - use super::EmitterWriter; - use codemap::{mk_sp, CodeMap, Span, MultiSpan, BytePos, NO_EXPANSION}; - use std::sync::{Arc, Mutex}; - use std::io::{self, Write}; - use std::str::from_utf8; - use std::rc::Rc; - - struct Sink(Arc>>); - impl Write for Sink { - fn write(&mut self, data: &[u8]) -> io::Result { - Write::write(&mut *self.0.lock().unwrap(), data) - } - fn flush(&mut self) -> io::Result<()> { Ok(()) } - } - - /// Given a string like " ^~~~~~~~~~~~ ", produces a span - /// coverting that range. The idea is that the string has the same - /// length as the input, and we uncover the byte positions. Note - /// that this can span lines and so on. - fn span_from_selection(input: &str, selection: &str) -> Span { - assert_eq!(input.len(), selection.len()); - let left_index = selection.find('~').unwrap() as u32; - let right_index = selection.rfind('~').map(|x|x as u32).unwrap_or(left_index); - Span { lo: BytePos(left_index), hi: BytePos(right_index + 1), expn_id: NO_EXPANSION } - } - - // Diagnostic doesn't align properly in span where line number increases by one digit - #[test] - fn test_hilight_suggestion_issue_11715() { - let data = Arc::new(Mutex::new(Vec::new())); - let cm = Rc::new(CodeMap::new()); - let mut ew = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone()); - let content = "abcdefg - koksi - line3 - line4 - cinq - line6 - line7 - line8 - line9 - line10 - e-lä-vän - tolv - dreizehn - "; - let file = cm.new_filemap_and_lines("dummy.txt", None, content); - let start = file.lines.borrow()[10]; - let end = file.lines.borrow()[11]; - let sp = mk_sp(start, end); - let lvl = Level::Error; - println!("highlight_lines"); - ew.highlight_lines(&sp.into(), lvl).unwrap(); - println!("done"); - let vec = data.lock().unwrap().clone(); - let vec: &[u8] = &vec; - let str = from_utf8(vec).unwrap(); - println!("r#\"\n{}\"#", str); - assert_eq!(str, &r#" - --> dummy.txt:11:1 - |> -11 |> e-lä-vän - |> ^ -"#[1..]); - } - - #[test] - fn test_single_span_splice() { - // Test that a `MultiSpan` containing a single span splices a substition correctly - let cm = CodeMap::new(); - let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n"; - let selection = " \n ~~\n~~~\n~~~~~ \n \n"; - cm.new_filemap_and_lines("blork.rs", None, inputtext); - let sp = span_from_selection(inputtext, selection); - let msp: MultiSpan = sp.into(); - - // check that we are extracting the text we thought we were extracting - assert_eq!(&cm.span_to_snippet(sp).unwrap(), "BB\nCCC\nDDDDD"); - - let substitute = "ZZZZZZ".to_owned(); - let expected = "bbbbZZZZZZddddd"; - let suggest = CodeSuggestion { - msp: msp, - substitutes: vec![substitute], - }; - assert_eq!(suggest.splice_lines(&cm), expected); - } - - #[test] - fn test_multi_span_splice() { - // Test that a `MultiSpan` containing multiple spans splices a substition correctly - let cm = CodeMap::new(); - let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n"; - let selection1 = " \n \n \n \n ~ \n"; // intentionally out of order - let selection2 = " \n ~~\n~~~\n~~~~~ \n \n"; - cm.new_filemap_and_lines("blork.rs", None, inputtext); - let sp1 = span_from_selection(inputtext, selection1); - let sp2 = span_from_selection(inputtext, selection2); - let msp: MultiSpan = MultiSpan::from_spans(vec![sp1, sp2]); - - let expected = "bbbbZZZZZZddddd\neXYZe"; - let suggest = CodeSuggestion { - msp: msp, - substitutes: vec!["ZZZZZZ".to_owned(), - "XYZ".to_owned()] - }; - - assert_eq!(suggest.splice_lines(&cm), expected); - } - - #[test] - fn test_multispan_highlight() { - let data = Arc::new(Mutex::new(Vec::new())); - let cm = Rc::new(CodeMap::new()); - let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone()); - - let inp = "_____aaaaaa____bbbbbb__cccccdd_"; - let sp1 = " ~~~~~~ "; - let sp2 = " ~~~~~~ "; - let sp3 = " ~~~~~ "; - let sp4 = " ~~~~ "; - let sp34 = " ~~~~~~~ "; - - let expect_start = &r#" - --> dummy.txt:1:6 - |> -1 |> _____aaaaaa____bbbbbb__cccccdd_ - |> ^^^^^^ ^^^^^^ ^^^^^^^ -"#[1..]; - - let span = |sp, expected| { - let sp = span_from_selection(inp, sp); - assert_eq!(&cm.span_to_snippet(sp).unwrap(), expected); - sp - }; - cm.new_filemap_and_lines("dummy.txt", None, inp); - let sp1 = span(sp1, "aaaaaa"); - let sp2 = span(sp2, "bbbbbb"); - let sp3 = span(sp3, "ccccc"); - let sp4 = span(sp4, "ccdd"); - let sp34 = span(sp34, "cccccdd"); - - let spans = vec![sp1, sp2, sp3, sp4]; - - let test = |expected, highlight: &mut FnMut()| { - data.lock().unwrap().clear(); - highlight(); - let vec = data.lock().unwrap().clone(); - let actual = from_utf8(&vec[..]).unwrap(); - println!("actual=\n{}", actual); - assert_eq!(actual, expected); - }; - - let msp = MultiSpan::from_spans(vec![sp1, sp2, sp34]); - test(expect_start, &mut || { - diag.highlight_lines(&msp, Level::Error).unwrap(); - }); - test(expect_start, &mut || { - let msp = MultiSpan::from_spans(spans.clone()); - diag.highlight_lines(&msp, Level::Error).unwrap(); - }); - } - - #[test] - fn test_huge_multispan_highlight() { - let data = Arc::new(Mutex::new(Vec::new())); - let cm = Rc::new(CodeMap::new()); - let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone()); - - let inp = "aaaaa\n\ - aaaaa\n\ - aaaaa\n\ - bbbbb\n\ - ccccc\n\ - xxxxx\n\ - yyyyy\n\ - _____\n\ - ddd__eee_\n\ - elided\n\ - __f_gg"; - let file = cm.new_filemap_and_lines("dummy.txt", None, inp); - - let span = |lo, hi, (off_lo, off_hi)| { - let lines = file.lines.borrow(); - let (mut lo, mut hi): (BytePos, BytePos) = (lines[lo], lines[hi]); - lo.0 += off_lo; - hi.0 += off_hi; - mk_sp(lo, hi) - }; - let sp0 = span(4, 6, (0, 5)); - let sp1 = span(0, 6, (0, 5)); - let sp2 = span(8, 8, (0, 3)); - let sp3 = span(8, 8, (5, 8)); - let sp4 = span(10, 10, (2, 3)); - let sp5 = span(10, 10, (4, 6)); - - let expect0 = &r#" - --> dummy.txt:5:1 - |> -5 |> ccccc - |> ^ -... -9 |> ddd__eee_ - |> ^^^ ^^^ -10 |> elided -11 |> __f_gg - |> ^ ^^ -"#[1..]; - - let expect = &r#" - --> dummy.txt:1:1 - |> -1 |> aaaaa - |> ^ -... -9 |> ddd__eee_ - |> ^^^ ^^^ -10 |> elided -11 |> __f_gg - |> ^ ^^ -"#[1..]; - - macro_rules! test { - ($expected: expr, $highlight: expr) => ({ - data.lock().unwrap().clear(); - $highlight(); - let vec = data.lock().unwrap().clone(); - let actual = from_utf8(&vec[..]).unwrap(); - println!("actual:"); - println!("{}", actual); - println!("expected:"); - println!("{}", $expected); - assert_eq!(&actual[..], &$expected[..]); - }); - } - - let msp0 = MultiSpan::from_spans(vec![sp0, sp2, sp3, sp4, sp5]); - let msp = MultiSpan::from_spans(vec![sp1, sp2, sp3, sp4, sp5]); - - test!(expect0, || { - diag.highlight_lines(&msp0, Level::Error).unwrap(); - }); - test!(expect, || { - diag.highlight_lines(&msp, Level::Error).unwrap(); - }); - } -} diff --git a/src/libsyntax/errors/mod.rs b/src/librustc_errors/lib.rs similarity index 92% rename from src/libsyntax/errors/mod.rs rename to src/librustc_errors/lib.rs index f06672fe111bf..18fc826f9aa4b 100644 --- a/src/libsyntax/errors/mod.rs +++ b/src/librustc_errors/lib.rs @@ -8,24 +8,50 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub use errors::emitter::ColorConfig; +#![crate_name = "rustc_errors"] +#![unstable(feature = "rustc_private", issue = "27812")] +#![crate_type = "dylib"] +#![crate_type = "rlib"] +#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", + html_favicon_url = "https://doc.rust-lang.org/favicon.ico", + html_root_url = "https://doc.rust-lang.org/nightly/")] +#![cfg_attr(not(stage0), deny(warnings))] + +#![feature(custom_attribute)] +#![allow(unused_attributes)] +#![feature(rustc_private)] +#![feature(staged_api)] +#![feature(question_mark)] +#![feature(range_contains)] +#![feature(libc)] +#![feature(unicode)] + +extern crate serialize; +extern crate term; +#[macro_use] extern crate log; +#[macro_use] extern crate libc; +extern crate rustc_unicode; +extern crate serialize as rustc_serialize; // used by deriving +extern crate syntax_pos; + +pub use emitter::ColorConfig; use self::Level::*; use self::RenderSpan::*; -use codemap::{self, CodeMap, MultiSpan, NO_EXPANSION, Span}; -use diagnostics; -use errors::emitter::{Emitter, EmitterWriter}; +use emitter::{Emitter, EmitterWriter}; use std::cell::{RefCell, Cell}; use std::{error, fmt}; use std::rc::Rc; use std::thread::panicking; -use term; pub mod emitter; -pub mod json; pub mod snippet; +pub mod registry; + +use syntax_pos::{BytePos, Loc, FileLinesResult, FileName, MultiSpan, Span, NO_EXPANSION }; +use syntax_pos::{MacroBacktrace}; #[derive(Clone)] pub enum RenderSpan { @@ -43,8 +69,16 @@ pub enum RenderSpan { #[derive(Clone)] pub struct CodeSuggestion { - msp: MultiSpan, - substitutes: Vec, + pub msp: MultiSpan, + pub substitutes: Vec, +} + +pub trait CodeMapper { + fn lookup_char_pos(&self, pos: BytePos) -> Loc; + fn span_to_lines(&self, sp: Span) -> FileLinesResult; + fn span_to_string(&self, sp: Span) -> String; + fn span_to_filename(&self, sp: Span) -> FileName; + fn macro_backtrace(&self, span: Span) -> Vec; } impl RenderSpan { @@ -59,8 +93,8 @@ impl RenderSpan { impl CodeSuggestion { /// Returns the assembled code suggestion. - pub fn splice_lines(&self, cm: &CodeMap) -> String { - use codemap::{CharPos, Loc, Pos}; + pub fn splice_lines(&self, cm: &CodeMapper) -> String { + use syntax_pos::{CharPos, Loc, Pos}; fn push_trailing(buf: &mut String, line_opt: Option<&str>, lo: &Loc, hi_opt: Option<&Loc>) { @@ -181,20 +215,20 @@ impl error::Error for ExplicitBug { #[derive(Clone)] pub struct DiagnosticBuilder<'a> { handler: &'a Handler, - level: Level, - message: String, - code: Option, - span: MultiSpan, - children: Vec, + pub level: Level, + pub message: String, + pub code: Option, + pub span: MultiSpan, + pub children: Vec, } /// For example a note attached to an error. #[derive(Clone)] -struct SubDiagnostic { - level: Level, - message: String, - span: MultiSpan, - render_span: Option, +pub struct SubDiagnostic { + pub level: Level, + pub message: String, + pub span: MultiSpan, + pub render_span: Option, } impl<'a> DiagnosticBuilder<'a> { @@ -386,12 +420,13 @@ pub struct Handler { impl Handler { pub fn with_tty_emitter(color_config: ColorConfig, - registry: Option, + registry: Option, can_emit_warnings: bool, treat_err_as_bug: bool, - cm: Rc) + cm: Rc) -> Handler { - let emitter = Box::new(EmitterWriter::stderr(color_config, registry, cm)); + let emitter = Box::new(EmitterWriter::stderr(color_config, registry, cm, + snippet::FormatMode::EnvironmentSelected)); Handler::with_emitter(can_emit_warnings, treat_err_as_bug, emitter) } @@ -662,7 +697,7 @@ impl fmt::Display for Level { } impl Level { - fn color(self) -> term::color::Color { + pub fn color(self) -> term::color::Color { match self { Bug | Fatal | PhaseFatal | Error => term::color::BRIGHT_RED, Warning => term::color::YELLOW, @@ -672,7 +707,7 @@ impl Level { } } - fn to_str(self) -> &'static str { + pub fn to_str(self) -> &'static str { match self { Bug => "error: internal compiler error", Fatal | PhaseFatal | Error => "error", diff --git a/src/libsyntax/diagnostics/registry.rs b/src/librustc_errors/registry.rs similarity index 100% rename from src/libsyntax/diagnostics/registry.rs rename to src/librustc_errors/registry.rs diff --git a/src/libsyntax/errors/snippet/mod.rs b/src/librustc_errors/snippet.rs similarity index 95% rename from src/libsyntax/errors/snippet/mod.rs rename to src/librustc_errors/snippet.rs index 2a43a14ddf873..33f40ffc71a9f 100644 --- a/src/libsyntax/errors/snippet/mod.rs +++ b/src/librustc_errors/snippet.rs @@ -10,18 +10,25 @@ // Code for annotating snippets. -use codemap::{CharPos, CodeMap, FileMap, LineInfo, Span}; -use errors::check_old_skool; +use syntax_pos::{Span, FileMap, CharPos, LineInfo}; +use check_old_skool; +use CodeMapper; use std::cmp; use std::rc::Rc; use std::mem; -mod test; +#[derive(Clone)] +pub enum FormatMode { + NewErrorFormat, + OriginalErrorFormat, + EnvironmentSelected +} #[derive(Clone)] pub struct SnippetData { - codemap: Rc, + codemap: Rc, files: Vec, + format_mode: FormatMode, } #[derive(Clone)] @@ -36,6 +43,10 @@ pub struct FileInfo { primary_span: Option, lines: Vec, + + /// The type of error format to render. We keep it here so that + /// it's easy to configure for both tests and regular usage + format_mode: FormatMode, } #[derive(Clone, Debug)] @@ -111,8 +122,9 @@ pub enum RenderedLineKind { } impl SnippetData { - pub fn new(codemap: Rc, - primary_span: Option) // (*) + pub fn new(codemap: Rc, + primary_span: Option, + format_mode: FormatMode) // (*) -> Self { // (*) The primary span indicates the file that must appear // first, and which will have a line number etc in its @@ -126,7 +138,8 @@ impl SnippetData { let mut data = SnippetData { codemap: codemap.clone(), - files: vec![] + files: vec![], + format_mode: format_mode.clone() }; if let Some(primary_span) = primary_span { let lo = codemap.lookup_char_pos(primary_span.lo); @@ -135,6 +148,7 @@ impl SnippetData { file: lo.file, primary_span: Some(primary_span), lines: vec![], + format_mode: format_mode.clone(), }); } data @@ -167,6 +181,7 @@ impl SnippetData { file: file_map.clone(), lines: vec![], primary_span: None, + format_mode: self.format_mode.clone() }); self.files.last_mut().unwrap() } @@ -178,7 +193,7 @@ impl SnippetData { self.files.iter() .flat_map(|f| f.render_file_lines(&self.codemap)) .collect(); - prepend_prefixes(&mut rendered_lines); + prepend_prefixes(&mut rendered_lines, &self.format_mode); trim_lines(&mut rendered_lines); rendered_lines } @@ -454,8 +469,12 @@ impl FileInfo { return line_index - first_line_index; } - fn render_file_lines(&self, codemap: &Rc) -> Vec { - let old_school = check_old_skool(); + fn render_file_lines(&self, codemap: &Rc) -> Vec { + let old_school = match self.format_mode { + FormatMode::OriginalErrorFormat => true, + FormatMode::NewErrorFormat => false, + FormatMode::EnvironmentSelected => check_old_skool() + }; // As a first step, we elide any instance of more than one // continuous unannotated line. @@ -591,7 +610,12 @@ impl FileInfo { } fn render_line(&self, line: &Line) -> Vec { - let old_school = check_old_skool(); + let old_school = match self.format_mode { + FormatMode::OriginalErrorFormat => true, + FormatMode::NewErrorFormat => false, + FormatMode::EnvironmentSelected => check_old_skool() + }; + let source_string = self.file.get_line(line.line_index) .unwrap_or(""); let source_kind = RenderedLineKind::SourceText { @@ -776,8 +800,12 @@ impl FileInfo { } } -fn prepend_prefixes(rendered_lines: &mut [RenderedLine]) { - let old_school = check_old_skool(); +fn prepend_prefixes(rendered_lines: &mut [RenderedLine], format_mode: &FormatMode) { + let old_school = match *format_mode { + FormatMode::OriginalErrorFormat => true, + FormatMode::NewErrorFormat => false, + FormatMode::EnvironmentSelected => check_old_skool() + }; if old_school { return; } diff --git a/src/librustc_incremental/Cargo.toml b/src/librustc_incremental/Cargo.toml index 927e4126472f6..7db1a6348b27c 100644 --- a/src/librustc_incremental/Cargo.toml +++ b/src/librustc_incremental/Cargo.toml @@ -16,3 +16,4 @@ rustc_data_structures = { path = "../librustc_data_structures" } serialize = { path = "../libserialize" } log = { path = "../liblog" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_incremental/assert_dep_graph.rs b/src/librustc_incremental/assert_dep_graph.rs index 1c0274cdcca9a..d38f979e33c5a 100644 --- a/src/librustc_incremental/assert_dep_graph.rs +++ b/src/librustc_incremental/assert_dep_graph.rs @@ -57,8 +57,8 @@ use std::fs::File; use std::io::Write; use syntax::ast; use syntax::attr::AttrMetaMethods; -use syntax::codemap::Span; use syntax::parse::token::InternedString; +use syntax_pos::Span; const IF_THIS_CHANGED: &'static str = "rustc_if_this_changed"; const THEN_THIS_WOULD_NEED: &'static str = "rustc_then_this_would_need"; diff --git a/src/librustc_incremental/calculate_svh.rs b/src/librustc_incremental/calculate_svh.rs index a039467c8afc0..cbc246ac2a11b 100644 --- a/src/librustc_incremental/calculate_svh.rs +++ b/src/librustc_incremental/calculate_svh.rs @@ -114,8 +114,8 @@ mod svh_visitor { pub use self::SawStmtComponent::*; use self::SawAbiComponent::*; use syntax::ast::{self, Name, NodeId}; - use syntax::codemap::Span; use syntax::parse::token; + use syntax_pos::Span; use rustc::ty::TyCtxt; use rustc::hir; use rustc::hir::*; diff --git a/src/librustc_incremental/lib.rs b/src/librustc_incremental/lib.rs index 005146d91eae4..ed31e0ba51056 100644 --- a/src/librustc_incremental/lib.rs +++ b/src/librustc_incremental/lib.rs @@ -30,6 +30,7 @@ extern crate serialize as rustc_serialize; #[macro_use] extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; mod assert_dep_graph; mod calculate_svh; diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs index 54e5824cbc786..7e9b6f561b984 100644 --- a/src/librustc_lint/bad_style.rs +++ b/src/librustc_lint/bad_style.rs @@ -15,7 +15,7 @@ use lint::{LintPass, LateLintPass}; use syntax::ast; use syntax::attr::{self, AttrMetaMethods}; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir::{self, PatKind}; use rustc::hir::intravisit::FnKind; diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 3ceca9218bdf5..18f9733040e0f 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -45,7 +45,7 @@ use std::collections::HashSet; use syntax::{ast}; use syntax::attr::{self, AttrMetaMethods}; -use syntax::codemap::{self, Span}; +use syntax_pos::{self, Span}; use rustc::hir::{self, PatKind}; use rustc::hir::intravisit::FnKind; @@ -1140,9 +1140,9 @@ impl LateLintPass for DropWithReprExtern { if hints.iter().any(|attr| *attr == attr::ReprExtern) && self_type_def.dtor_kind().has_drop_flag() { let drop_impl_span = ctx.tcx.map.def_id_span(drop_impl_did, - codemap::DUMMY_SP); + syntax_pos::DUMMY_SP); let self_defn_span = ctx.tcx.map.def_id_span(self_type_did, - codemap::DUMMY_SP); + syntax_pos::DUMMY_SP); ctx.span_lint_note(DROP_WITH_REPR_EXTERN, drop_impl_span, "implementing Drop adds hidden state to types, \ diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index ed12d0d9f3c11..37523645ceb25 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -45,6 +45,7 @@ extern crate rustc; extern crate log; extern crate rustc_back; extern crate rustc_const_eval; +extern crate syntax_pos; pub use rustc::lint as lint; pub use rustc::middle as middle; diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs index b7f14fffafb77..97f97a889edc3 100644 --- a/src/librustc_lint/types.rs +++ b/src/librustc_lint/types.rs @@ -27,7 +27,8 @@ use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64}; use syntax::ast; use syntax::abi::Abi; use syntax::attr; -use syntax::codemap::{self, Span}; +use syntax_pos::Span; +use syntax::codemap; use rustc::hir; diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index b765043da8853..70482a1c56b75 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -19,9 +19,9 @@ use std::collections::hash_map::Entry::{Occupied, Vacant}; use syntax::ast; use syntax::attr::{self, AttrMetaMethods}; -use syntax::codemap::Span; use syntax::feature_gate::{KNOWN_ATTRIBUTES, AttributeType}; use syntax::ptr::P; +use syntax_pos::Span; use rustc_back::slice; use rustc::hir; diff --git a/src/librustc_metadata/Cargo.toml b/src/librustc_metadata/Cargo.toml index 697cbe39c67fc..11896e176301b 100644 --- a/src/librustc_metadata/Cargo.toml +++ b/src/librustc_metadata/Cargo.toml @@ -16,6 +16,8 @@ rustc = { path = "../librustc" } rustc_back = { path = "../librustc_back" } rustc_bitflags = { path = "../librustc_bitflags" } rustc_const_math = { path = "../librustc_const_math" } +rustc_errors = { path = "../librustc_errors" } rustc_llvm = { path = "../librustc_llvm" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_metadata/astencode.rs b/src/librustc_metadata/astencode.rs index 78825aca4188e..dc37bdf6322af 100644 --- a/src/librustc_metadata/astencode.rs +++ b/src/librustc_metadata/astencode.rs @@ -37,9 +37,10 @@ use middle::region; use rustc::ty::subst; use rustc::ty::{self, Ty, TyCtxt}; -use syntax::{ast, codemap}; +use syntax::ast; use syntax::ast::NodeIdAssigner; use syntax::ptr::P; +use syntax_pos; use std::cell::Cell; use std::io::SeekFrom; @@ -115,7 +116,7 @@ impl<'a, 'b, 'c, 'tcx> ast_map::FoldOps for &'a DecodeContext<'b, 'c, 'tcx> { fn new_def_id(&self, def_id: DefId) -> DefId { self.tr_def_id(def_id) } - fn new_span(&self, span: codemap::Span) -> codemap::Span { + fn new_span(&self, span: syntax_pos::Span) -> syntax_pos::Span { self.tr_span(span) } } @@ -206,7 +207,7 @@ impl<'a, 'b, 'tcx> DecodeContext<'a, 'b, 'tcx> { /// Translates a `Span` from an extern crate to the corresponding `Span` /// within the local crate's codemap. - pub fn tr_span(&self, span: codemap::Span) -> codemap::Span { + pub fn tr_span(&self, span: syntax_pos::Span) -> syntax_pos::Span { decoder::translate_span(self.cdata, self.tcx.sess.codemap(), &self.last_filemap_index, @@ -226,8 +227,8 @@ impl tr for Option { } } -impl tr for codemap::Span { - fn tr(&self, dcx: &DecodeContext) -> codemap::Span { +impl tr for syntax_pos::Span { + fn tr(&self, dcx: &DecodeContext) -> syntax_pos::Span { dcx.tr_span(*self) } } @@ -1268,7 +1269,7 @@ fn decode_item_ast(item_doc: rbml::Doc) -> hir::Item { #[cfg(test)] trait FakeExtCtxt { - fn call_site(&self) -> codemap::Span; + fn call_site(&self) -> syntax_pos::Span; fn cfg(&self) -> ast::CrateConfig; fn ident_of(&self, st: &str) -> ast::Ident; fn name_of(&self, st: &str) -> ast::Name; @@ -1277,11 +1278,11 @@ trait FakeExtCtxt { #[cfg(test)] impl FakeExtCtxt for parse::ParseSess { - fn call_site(&self) -> codemap::Span { - codemap::Span { - lo: codemap::BytePos(0), - hi: codemap::BytePos(0), - expn_id: codemap::NO_EXPANSION, + fn call_site(&self) -> syntax_pos::Span { + syntax_pos::Span { + lo: syntax_pos::BytePos(0), + hi: syntax_pos::BytePos(0), + expn_id: syntax_pos::NO_EXPANSION, } } fn cfg(&self) -> ast::CrateConfig { Vec::new() } diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index 6c24384cddc57..07c985106a5ea 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -34,12 +34,13 @@ use std::fs; use syntax::ast; use syntax::abi::Abi; -use syntax::codemap::{self, Span, mk_sp, Pos}; +use syntax::codemap; use syntax::parse; use syntax::attr; use syntax::attr::AttrMetaMethods; use syntax::parse::token::InternedString; use syntax::visit; +use syntax_pos::{self, Span, mk_sp, Pos}; use log; struct LocalCrateReader<'a> { @@ -726,7 +727,7 @@ impl<'a> CrateReader<'a> { info!("panic runtime not found -- loading {}", name); let (cnum, data, _) = self.resolve_crate(&None, name, name, None, - codemap::DUMMY_SP, + syntax_pos::DUMMY_SP, PathKind::Crate, false); // Sanity check the loaded crate to ensure it is indeed a panic runtime @@ -807,7 +808,7 @@ impl<'a> CrateReader<'a> { &self.sess.target.target.options.exe_allocation_crate }; let (cnum, data, _) = self.resolve_crate(&None, name, name, None, - codemap::DUMMY_SP, + syntax_pos::DUMMY_SP, PathKind::Crate, false); // Sanity check the crate we loaded to ensure that it is indeed an @@ -1076,7 +1077,7 @@ pub fn import_codemap(local_codemap: &codemap::CodeMap, None => { // We can't reuse an existing FileMap, so allocate a new one // containing the information we need. - let codemap::FileMap { + let syntax_pos::FileMap { name, abs_path, start_pos, @@ -1118,8 +1119,8 @@ pub fn import_codemap(local_codemap: &codemap::CodeMap, return imported_filemaps; - fn are_equal_modulo_startpos(fm1: &codemap::FileMap, - fm2: &codemap::FileMap) + fn are_equal_modulo_startpos(fm1: &syntax_pos::FileMap, + fm2: &syntax_pos::FileMap) -> bool { if fm1.name != fm2.name { return false; diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs index 2e1bdf21c9a5a..e89f428c96f8c 100644 --- a/src/librustc_metadata/cstore.rs +++ b/src/librustc_metadata/cstore.rs @@ -36,6 +36,7 @@ use syntax::ast; use syntax::attr; use syntax::codemap; use syntax::parse::token::IdentInterner; +use syntax_pos; pub use middle::cstore::{NativeLibraryKind, LinkagePreference}; pub use middle::cstore::{NativeStatic, NativeFramework, NativeUnknown}; @@ -52,15 +53,15 @@ pub enum MetadataBlob { MetadataArchive(loader::ArchiveMetadata), } -/// Holds information about a codemap::FileMap imported from another crate. +/// Holds information about a syntax_pos::FileMap imported from another crate. /// See creader::import_codemap() for more information. pub struct ImportedFileMap { /// This FileMap's byte-offset within the codemap of its original crate - pub original_start_pos: codemap::BytePos, + pub original_start_pos: syntax_pos::BytePos, /// The end of this FileMap within the codemap of its original crate - pub original_end_pos: codemap::BytePos, + pub original_end_pos: syntax_pos::BytePos, /// The imported FileMap's representation within the local codemap - pub translated_filemap: Rc + pub translated_filemap: Rc } pub struct crate_metadata { diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 68387941b65ed..3efdf36acd973 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -56,10 +56,10 @@ use syntax::attr; use syntax::parse::token::{self, IdentInterner}; use syntax::ast; use syntax::abi::Abi; -use syntax::codemap::{self, Span, BytePos, NO_EXPANSION}; +use syntax::codemap; use syntax::print::pprust; use syntax::ptr::P; - +use syntax_pos::{self, Span, BytePos, NO_EXPANSION}; pub type Cmd<'a> = &'a crate_metadata; @@ -1230,7 +1230,7 @@ fn get_attributes(md: rbml::Doc) -> Vec { value: meta_item, is_sugared_doc: is_sugared_doc, }, - span: codemap::DUMMY_SP + span: syntax_pos::DUMMY_SP } }).collect() }, @@ -1380,8 +1380,8 @@ fn reverse_translate_def_id(cdata: Cmd, did: DefId) -> Option { pub fn translate_span(cdata: Cmd, codemap: &codemap::CodeMap, last_filemap_index_hint: &Cell, - span: codemap::Span) - -> codemap::Span { + span: syntax_pos::Span) + -> syntax_pos::Span { let span = if span.lo > span.hi { // Currently macro expansion sometimes produces invalid Span values // where lo > hi. In order not to crash the compiler when trying to @@ -1390,7 +1390,7 @@ pub fn translate_span(cdata: Cmd, // least some of the time). // This workaround is only necessary as long as macro expansion is // not fixed. FIXME(#23480) - codemap::mk_sp(span.lo, span.lo) + syntax_pos::mk_sp(span.lo, span.lo) } else { span }; @@ -1430,7 +1430,7 @@ pub fn translate_span(cdata: Cmd, let hi = (span.hi - filemap.original_start_pos) + filemap.translated_filemap.start_pos; - codemap::mk_sp(lo, hi) + syntax_pos::mk_sp(lo, hi) } pub fn each_inherent_implementation_for_type(cdata: Cmd, @@ -1733,7 +1733,7 @@ pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool { item_family(impl_doc) == Family::DefaultImpl } -pub fn get_imported_filemaps(metadata: &[u8]) -> Vec { +pub fn get_imported_filemaps(metadata: &[u8]) -> Vec { let crate_doc = rbml::Doc::new(metadata); let cm_doc = reader::get_doc(crate_doc, tag_codemap); diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index b14be158197e8..c23ad6d5f078f 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -44,10 +44,10 @@ use std::rc::Rc; use std::u32; use syntax::abi::Abi; use syntax::ast::{self, NodeId, Name, CRATE_NODE_ID, CrateNum}; -use syntax::codemap::BytePos; use syntax::attr; -use syntax::errors::Handler; +use errors::Handler; use syntax; +use syntax_pos::BytePos; use rbml::writer::Encoder; use rustc::hir::{self, PatKind}; diff --git a/src/librustc_metadata/lib.rs b/src/librustc_metadata/lib.rs index f7ea60c4078dc..1cf7282e9e95f 100644 --- a/src/librustc_metadata/lib.rs +++ b/src/librustc_metadata/lib.rs @@ -28,10 +28,11 @@ #[macro_use] extern crate log; #[macro_use] extern crate syntax; #[macro_use] #[no_link] extern crate rustc_bitflags; - +extern crate syntax_pos; extern crate flate; extern crate rbml; extern crate serialize as rustc_serialize; // used by deriving +extern crate rustc_errors as errors; #[macro_use] extern crate rustc; diff --git a/src/librustc_metadata/loader.rs b/src/librustc_metadata/loader.rs index a5b1c3d301b10..56393b79980f6 100644 --- a/src/librustc_metadata/loader.rs +++ b/src/librustc_metadata/loader.rs @@ -225,8 +225,8 @@ use rustc::util::common; use rustc_llvm as llvm; use rustc_llvm::{False, ObjectFile, mk_section_iter}; use rustc_llvm::archive_ro::ArchiveRO; -use syntax::codemap::Span; -use syntax::errors::DiagnosticBuilder; +use errors::DiagnosticBuilder; +use syntax_pos::Span; use rustc_back::target::Target; use std::cmp; diff --git a/src/librustc_metadata/macro_import.rs b/src/librustc_metadata/macro_import.rs index 1c7d37709c220..7dadf8d108a71 100644 --- a/src/librustc_metadata/macro_import.rs +++ b/src/librustc_metadata/macro_import.rs @@ -16,12 +16,12 @@ use cstore::CStore; use rustc::session::Session; use std::collections::{HashSet, HashMap}; -use syntax::codemap::Span; use syntax::parse::token; use syntax::ast; use syntax::attr; use syntax::attr::AttrMetaMethods; use syntax::ext; +use syntax_pos::Span; pub struct MacroLoader<'a> { sess: &'a Session, diff --git a/src/librustc_metadata/tyencode.rs b/src/librustc_metadata/tyencode.rs index 48811c68f5869..2b8ba107fefc6 100644 --- a/src/librustc_metadata/tyencode.rs +++ b/src/librustc_metadata/tyencode.rs @@ -29,7 +29,7 @@ use rustc::hir; use syntax::abi::Abi; use syntax::ast; -use syntax::errors::Handler; +use errors::Handler; use rbml::leb128; use encoder; diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs index ab7bc4eec91cc..f1487992cb522 100644 --- a/src/librustc_mir/build/expr/as_rvalue.rs +++ b/src/librustc_mir/build/expr/as_rvalue.rs @@ -24,7 +24,7 @@ use rustc::middle::const_val::ConstVal; use rustc::ty; use rustc::mir::repr::*; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { /// Compile `expr`, yielding an rvalue. diff --git a/src/librustc_mir/build/expr/stmt.rs b/src/librustc_mir/build/expr/stmt.rs index ad55a3d8b73f2..8ae23c9103b02 100644 --- a/src/librustc_mir/build/expr/stmt.rs +++ b/src/librustc_mir/build/expr/stmt.rs @@ -13,7 +13,7 @@ use build::scope::LoopScope; use hair::*; use rustc::middle::region::CodeExtent; use rustc::mir::repr::*; -use syntax::codemap::Span; +use syntax_pos::Span; impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { diff --git a/src/librustc_mir/build/matches/mod.rs b/src/librustc_mir/build/matches/mod.rs index b3315ab7d290f..a94adafa80213 100644 --- a/src/librustc_mir/build/matches/mod.rs +++ b/src/librustc_mir/build/matches/mod.rs @@ -21,7 +21,7 @@ use rustc::ty::{AdtDef, Ty}; use rustc::mir::repr::*; use hair::*; use syntax::ast::{Name, NodeId}; -use syntax::codemap::Span; +use syntax_pos::Span; // helper functions, broken out by category: mod simplify; diff --git a/src/librustc_mir/build/matches/test.rs b/src/librustc_mir/build/matches/test.rs index 668bdcf735802..8c9ed53c8ab4d 100644 --- a/src/librustc_mir/build/matches/test.rs +++ b/src/librustc_mir/build/matches/test.rs @@ -23,7 +23,7 @@ use rustc_data_structures::bitvec::BitVector; use rustc::middle::const_val::ConstVal; use rustc::ty::{self, Ty}; use rustc::mir::repr::*; -use syntax::codemap::Span; +use syntax_pos::Span; use std::cmp::Ordering; impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { diff --git a/src/librustc_mir/build/misc.rs b/src/librustc_mir/build/misc.rs index 0d7a502834881..79a4cf73041d7 100644 --- a/src/librustc_mir/build/misc.rs +++ b/src/librustc_mir/build/misc.rs @@ -19,7 +19,7 @@ use rustc::ty::{self, Ty}; use rustc::mir::repr::*; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { /// Add a new temporary value of type `ty` storing the result of diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs index 2626a02281f7d..362e1e26fdf1e 100644 --- a/src/librustc_mir/build/mod.rs +++ b/src/librustc_mir/build/mod.rs @@ -16,8 +16,8 @@ use rustc::util::nodemap::NodeMap; use rustc::hir; use syntax::abi::Abi; use syntax::ast; -use syntax::codemap::Span; use syntax::parse::token::keywords; +use syntax_pos::Span; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; diff --git a/src/librustc_mir/build/scope.rs b/src/librustc_mir/build/scope.rs index 65457a9cc80d6..1703fee9360cc 100644 --- a/src/librustc_mir/build/scope.rs +++ b/src/librustc_mir/build/scope.rs @@ -92,7 +92,7 @@ use rustc::middle::lang_items; use rustc::ty::subst::{Substs, Subst, VecPerParamSpace}; use rustc::ty::{Ty, TyCtxt}; use rustc::mir::repr::*; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::fnv::FnvHashMap; diff --git a/src/librustc_mir/hair/cx/pattern.rs b/src/librustc_mir/hair/cx/pattern.rs index 1bc3954a5fe75..b5da50792762f 100644 --- a/src/librustc_mir/hair/cx/pattern.rs +++ b/src/librustc_mir/hair/cx/pattern.rs @@ -17,8 +17,8 @@ use rustc::hir::pat_util::{EnumerateAndAdjustIterator, pat_is_resolved_const}; use rustc::ty::{self, Ty}; use rustc::mir::repr::*; use rustc::hir::{self, PatKind}; -use syntax::codemap::Span; use syntax::ptr::P; +use syntax_pos::Span; /// When there are multiple patterns in a single arm, each one has its /// own node-ids for the bindings. References to the variables always diff --git a/src/librustc_mir/hair/mod.rs b/src/librustc_mir/hair/mod.rs index 020fbb6fcd19c..a2746bf30c91f 100644 --- a/src/librustc_mir/hair/mod.rs +++ b/src/librustc_mir/hair/mod.rs @@ -23,7 +23,7 @@ use rustc::ty::subst::Substs; use rustc::ty::{self, AdtDef, ClosureSubsts, Region, Ty}; use rustc::hir; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use self::cx::Cx; pub mod cx; diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index 3d1ef31bd5c2a..3d01d49c53472 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -38,6 +38,7 @@ extern crate rustc_back; extern crate rustc_bitflags; #[macro_use] extern crate syntax; +extern crate syntax_pos; extern crate rustc_const_math; extern crate rustc_const_eval; diff --git a/src/librustc_mir/mir_map.rs b/src/librustc_mir/mir_map.rs index a55fbe3641c66..b7c5f35892b0b 100644 --- a/src/librustc_mir/mir_map.rs +++ b/src/librustc_mir/mir_map.rs @@ -33,7 +33,7 @@ use rustc::util::nodemap::NodeMap; use rustc::hir; use rustc::hir::intravisit::{self, FnKind, Visitor}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use std::mem; diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs index 3ebfef10d4311..4b551d6bb083c 100644 --- a/src/librustc_mir/transform/promote_consts.rs +++ b/src/librustc_mir/transform/promote_consts.rs @@ -26,7 +26,7 @@ use rustc::mir::repr::*; use rustc::mir::visit::{LvalueContext, MutVisitor, Visitor}; use rustc::mir::traversal::ReversePostorder; use rustc::ty::{self, TyCtxt}; -use syntax::codemap::Span; +use syntax_pos::Span; use build::Location; diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index 784ddc1ede4f1..1d00938fb25eb 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -30,8 +30,8 @@ use rustc::mir::transform::{Pass, MirMapPass, MirPassHook, MirSource}; use rustc::mir::visit::{LvalueContext, Visitor}; use rustc::util::nodemap::DefIdMap; use syntax::abi::Abi; -use syntax::codemap::Span; use syntax::feature_gate::UnstableFeatures; +use syntax_pos::Span; use std::collections::hash_map::Entry; use std::fmt; diff --git a/src/librustc_mir/transform/type_check.rs b/src/librustc_mir/transform/type_check.rs index e4398fcab3163..db49e1e040791 100644 --- a/src/librustc_mir/transform/type_check.rs +++ b/src/librustc_mir/transform/type_check.rs @@ -22,7 +22,7 @@ use rustc::mir::tcx::LvalueTy; use rustc::mir::transform::{MirPass, MirSource, Pass}; use rustc::mir::visit::{self, Visitor}; use std::fmt; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use rustc_data_structures::indexed_vec::Idx; diff --git a/src/librustc_passes/Cargo.toml b/src/librustc_passes/Cargo.toml index 0c85ffd2e9c39..cc710e0ac3563 100644 --- a/src/librustc_passes/Cargo.toml +++ b/src/librustc_passes/Cargo.toml @@ -14,3 +14,5 @@ rustc = { path = "../librustc" } rustc_const_eval = { path = "../librustc_const_eval" } rustc_const_math = { path = "../librustc_const_math" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } +rustc_errors = { path = "../librustc_errors" } \ No newline at end of file diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index 919c717f888ff..a337a9f94849b 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -19,10 +19,10 @@ use rustc::lint; use rustc::session::Session; use syntax::ast::*; -use syntax::codemap::Span; -use syntax::errors; use syntax::parse::token::{self, keywords}; use syntax::visit::{self, Visitor}; +use syntax_pos::Span; +use errors; struct AstValidator<'a> { session: &'a Session, diff --git a/src/librustc_passes/consts.rs b/src/librustc_passes/consts.rs index 75bfe7c0f2f95..27ce03b2d9390 100644 --- a/src/librustc_passes/consts.rs +++ b/src/librustc_passes/consts.rs @@ -46,7 +46,7 @@ use rustc::lint::builtin::CONST_ERR; use rustc::hir::{self, PatKind}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir::intravisit::{self, FnKind, Visitor}; use std::collections::hash_map::Entry; diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs index 1576ca6bdeaa4..650613f4844f5 100644 --- a/src/librustc_passes/lib.rs +++ b/src/librustc_passes/lib.rs @@ -34,6 +34,8 @@ extern crate rustc_const_math; #[macro_use] extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; +extern crate rustc_errors as errors; pub mod diagnostics; diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs index 2174d1cf9b82a..dd0f16baaa395 100644 --- a/src/librustc_passes/loops.rs +++ b/src/librustc_passes/loops.rs @@ -15,7 +15,7 @@ use rustc::dep_graph::DepNode; use rustc::hir::map::Map; use rustc::hir::intravisit::{self, Visitor}; use rustc::hir; -use syntax::codemap::Span; +use syntax_pos::Span; #[derive(Clone, Copy, PartialEq)] enum Context { diff --git a/src/librustc_passes/rvalues.rs b/src/librustc_passes/rvalues.rs index 137a50642fcf4..4684683f02501 100644 --- a/src/librustc_passes/rvalues.rs +++ b/src/librustc_passes/rvalues.rs @@ -20,7 +20,7 @@ use rustc::traits::ProjectionMode; use rustc::hir; use rustc::hir::intravisit; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { let mut rvcx = RvalueContext { tcx: tcx }; diff --git a/src/librustc_passes/static_recursion.rs b/src/librustc_passes/static_recursion.rs index 245960a04f030..d0938ad09a0da 100644 --- a/src/librustc_passes/static_recursion.rs +++ b/src/librustc_passes/static_recursion.rs @@ -18,8 +18,8 @@ use rustc::hir::def::{Def, DefMap}; use rustc::util::nodemap::NodeMap; use syntax::{ast}; -use syntax::codemap::Span; use syntax::feature_gate::{GateIssue, emit_feature_err}; +use syntax_pos::Span; use rustc::hir::intravisit::{self, Visitor}; use rustc::hir; diff --git a/src/librustc_plugin/Cargo.toml b/src/librustc_plugin/Cargo.toml index 6acd1e76ff2c2..150d2b67392d6 100644 --- a/src/librustc_plugin/Cargo.toml +++ b/src/librustc_plugin/Cargo.toml @@ -15,3 +15,4 @@ rustc_back = { path = "../librustc_back" } rustc_bitflags = { path = "../librustc_bitflags" } rustc_metadata = { path = "../librustc_metadata" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_plugin/build.rs b/src/librustc_plugin/build.rs index 4c7755b1b0937..ff3038c3d1175 100644 --- a/src/librustc_plugin/build.rs +++ b/src/librustc_plugin/build.rs @@ -12,8 +12,8 @@ use syntax::ast; use syntax::attr; -use syntax::codemap::Span; -use syntax::errors; +use errors; +use syntax_pos::Span; use rustc::dep_graph::DepNode; use rustc::hir::map::Map; use rustc::hir::intravisit::Visitor; diff --git a/src/librustc_plugin/lib.rs b/src/librustc_plugin/lib.rs index 7ef628e8f9b16..e60a657ba193d 100644 --- a/src/librustc_plugin/lib.rs +++ b/src/librustc_plugin/lib.rs @@ -70,6 +70,8 @@ extern crate rustc; extern crate rustc_back; extern crate rustc_metadata; +extern crate syntax_pos; +extern crate rustc_errors as errors; pub use self::registry::Registry; diff --git a/src/librustc_plugin/load.rs b/src/librustc_plugin/load.rs index 11e1841f7493e..a3cd9b5da02bc 100644 --- a/src/librustc_plugin/load.rs +++ b/src/librustc_plugin/load.rs @@ -20,9 +20,9 @@ use std::env; use std::mem; use std::path::PathBuf; use syntax::ast; -use syntax::codemap::{Span, COMMAND_LINE_SP}; use syntax::ptr::P; use syntax::attr::AttrMetaMethods; +use syntax_pos::{Span, COMMAND_LINE_SP}; /// Pointer to a registrar function. pub type PluginRegistrarFun = diff --git a/src/librustc_plugin/registry.rs b/src/librustc_plugin/registry.rs index dc5a38bb7647e..54fa0197de4fe 100644 --- a/src/librustc_plugin/registry.rs +++ b/src/librustc_plugin/registry.rs @@ -18,11 +18,11 @@ use rustc::mir::transform::MirMapPass; use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT}; use syntax::ext::base::{IdentTT, MultiModifier, MultiDecorator}; use syntax::ext::base::{MacroExpanderFn, MacroRulesTT}; -use syntax::codemap::Span; use syntax::parse::token; use syntax::ptr::P; use syntax::ast; use syntax::feature_gate::AttributeType; +use syntax_pos::Span; use std::collections::HashMap; use std::borrow::ToOwned; diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 918c149ef8589..85a6f732dd52e 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -23,6 +23,7 @@ extern crate rustc; #[macro_use] extern crate syntax; +extern crate syntax_pos; use rustc::dep_graph::DepNode; use rustc::hir::{self, PatKind}; @@ -35,7 +36,7 @@ use rustc::middle::privacy::{AccessLevel, AccessLevels}; use rustc::ty::{self, TyCtxt}; use rustc::util::nodemap::NodeSet; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use std::cmp; use std::mem::replace; diff --git a/src/librustc_resolve/Cargo.toml b/src/librustc_resolve/Cargo.toml index a63460d912d7d..5ce4c74e735fd 100644 --- a/src/librustc_resolve/Cargo.toml +++ b/src/librustc_resolve/Cargo.toml @@ -14,3 +14,5 @@ log = { path = "../liblog" } syntax = { path = "../libsyntax" } rustc = { path = "../librustc" } arena = { path = "../libarena" } +rustc_errors = { path = "../librustc_errors" } +syntax_pos = { path = "../libsyntax_pos" } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 775c24b6d4a67..a7c74b93ef5bc 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -29,7 +29,6 @@ use rustc::ty::{self, VariantKind}; use syntax::ast::Name; use syntax::attr; use syntax::parse::token; -use syntax::codemap::{Span, DUMMY_SP}; use syntax::ast::{Block, Crate, DeclKind}; use syntax::ast::{ForeignItem, ForeignItemKind, Item, ItemKind}; @@ -38,6 +37,8 @@ use syntax::ast::{Stmt, StmtKind, TraitItemKind}; use syntax::ast::{Variant, ViewPathGlob, ViewPathList, ViewPathSimple}; use syntax::visit::{self, Visitor}; +use syntax_pos::{Span, DUMMY_SP}; + trait ToNameBinding<'a> { fn to_name_binding(self) -> NameBinding<'a>; } diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 64347d7b84d3c..bcb14bc833575 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -27,7 +27,7 @@ use Namespace::{TypeNS, ValueNS}; use rustc::lint; use syntax::ast::{self, ViewPathGlob, ViewPathList, ViewPathSimple}; use syntax::visit::{self, Visitor}; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; struct UnusedImportCheckVisitor<'a, 'b: 'a> { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index e82b4e2fcd72f..7b24d8df65c63 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -27,6 +27,8 @@ extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; +extern crate rustc_errors as errors; extern crate arena; #[macro_use] extern crate rustc; @@ -54,8 +56,6 @@ use rustc::util::nodemap::{NodeMap, NodeSet, FnvHashMap, FnvHashSet}; use syntax::ext::mtwt; use syntax::ast::{self, FloatTy}; use syntax::ast::{CRATE_NODE_ID, Name, NodeId, CrateNum, IntTy, UintTy}; -use syntax::codemap::{self, Span}; -use syntax::errors::DiagnosticBuilder; use syntax::parse::token::{self, keywords}; use syntax::util::lev_distance::find_best_match_for_name; @@ -66,6 +66,9 @@ use syntax::ast::{Item, ItemKind, ImplItem, ImplItemKind}; use syntax::ast::{Local, Mutability, Pat, PatKind, Path}; use syntax::ast::{PathSegment, PathParameters, QSelf, TraitItemKind, TraitRef, Ty, TyKind}; +use syntax_pos::Span; +use errors::DiagnosticBuilder; + use std::collections::{HashMap, HashSet}; use std::cell::{Cell, RefCell}; use std::fmt; @@ -177,13 +180,13 @@ enum UnresolvedNameContext<'a> { } fn resolve_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, - span: syntax::codemap::Span, + span: syntax_pos::Span, resolution_error: ResolutionError<'c>) { resolve_struct_error(resolver, span, resolution_error).emit(); } fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>, - span: syntax::codemap::Span, + span: syntax_pos::Span, resolution_error: ResolutionError<'c>) -> DiagnosticBuilder<'a> { if !resolver.emit_errors { @@ -1804,10 +1807,10 @@ impl<'a> Resolver<'a> { self.resolve_crate_relative_path(trait_path.span, segments, TypeNS) } else { self.resolve_module_relative_path(trait_path.span, segments, TypeNS) - }.map(|binding| binding.span).unwrap_or(codemap::DUMMY_SP) + }.map(|binding| binding.span).unwrap_or(syntax_pos::DUMMY_SP) }; - if definition_site != codemap::DUMMY_SP { + if definition_site != syntax_pos::DUMMY_SP { err.span_label(definition_site, &format!("type aliases cannot be used for traits")); } @@ -3338,7 +3341,7 @@ impl<'a> Resolver<'a> { }, }; - if old_binding.span != codemap::DUMMY_SP { + if old_binding.span != syntax_pos::DUMMY_SP { err.span_label(old_binding.span, &format!("previous {} of `{}` here", noun, name)); } err.emit(); diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 3082a8b43076f..cb308f9120404 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -25,8 +25,8 @@ use rustc::lint; use rustc::hir::def::*; use syntax::ast::{NodeId, Name}; -use syntax::codemap::{Span, DUMMY_SP}; use syntax::util::lev_distance::find_best_match_for_name; +use syntax_pos::{Span, DUMMY_SP}; use std::cell::{Cell, RefCell}; diff --git a/src/librustc_save_analysis/Cargo.toml b/src/librustc_save_analysis/Cargo.toml index c786b4d711c39..3d66e5a300787 100644 --- a/src/librustc_save_analysis/Cargo.toml +++ b/src/librustc_save_analysis/Cargo.toml @@ -13,3 +13,4 @@ log = { path = "../liblog" } rustc = { path = "../librustc" } syntax = { path = "../libsyntax" } serialize = { path = "../libserialize" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_save_analysis/data.rs b/src/librustc_save_analysis/data.rs index 15aaa77cc3518..493f7669337fe 100644 --- a/src/librustc_save_analysis/data.rs +++ b/src/librustc_save_analysis/data.rs @@ -15,7 +15,7 @@ use rustc::hir::def_id::DefId; use syntax::ast::{CrateNum, NodeId}; -use syntax::codemap::Span; +use syntax_pos::Span; pub struct CrateData { pub name: String, diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 56c7436a8fe5c..0ac6584f59ae8 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -36,11 +36,12 @@ use std::collections::HashSet; use std::hash::*; use syntax::ast::{self, NodeId, PatKind}; -use syntax::codemap::*; use syntax::parse::token::{self, keywords}; use syntax::visit::{self, Visitor}; use syntax::print::pprust::{path_to_string, ty_to_string, bounds_to_string, generics_to_string}; use syntax::ptr::P; +use syntax::codemap::Spanned; +use syntax_pos::*; use super::{escape, generated_code, SaveContext, PathCollector}; use super::data::*; diff --git a/src/librustc_save_analysis/external_data.rs b/src/librustc_save_analysis/external_data.rs index 7efd2624561e7..65e4f7e869b0d 100644 --- a/src/librustc_save_analysis/external_data.rs +++ b/src/librustc_save_analysis/external_data.rs @@ -12,7 +12,8 @@ use rustc::hir::def_id::{DefId, DefIndex}; use rustc::hir::map::Map; use rustc::ty::TyCtxt; use syntax::ast::{CrateNum, NodeId}; -use syntax::codemap::{Span, CodeMap}; +use syntax::codemap::CodeMap; +use syntax_pos::Span; use data; diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 3335133816043..ca32a82d763e6 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -27,6 +27,7 @@ #[macro_use] extern crate log; #[macro_use] extern crate syntax; extern crate serialize as rustc_serialize; +extern crate syntax_pos; mod csv_dumper; mod json_dumper; @@ -49,10 +50,11 @@ use std::fs::{self, File}; use std::path::{Path, PathBuf}; use syntax::ast::{self, NodeId, PatKind}; -use syntax::codemap::*; use syntax::parse::token::{self, keywords}; use syntax::visit::{self, Visitor}; use syntax::print::pprust::{ty_to_string, arg_to_string}; +use syntax::codemap::MacroAttribute; +use syntax_pos::*; pub use self::csv_dumper::CsvDumper; pub use self::json_dumper::JsonDumper; diff --git a/src/librustc_save_analysis/span_utils.rs b/src/librustc_save_analysis/span_utils.rs index 4b3975faa8076..953c65549195a 100644 --- a/src/librustc_save_analysis/span_utils.rs +++ b/src/librustc_save_analysis/span_utils.rs @@ -17,9 +17,9 @@ use std::env; use std::path::Path; use syntax::ast; -use syntax::codemap::*; use syntax::parse::lexer::{self, Reader, StringReader}; use syntax::parse::token::{self, keywords, Token}; +use syntax_pos::*; #[derive(Clone)] pub struct SpanUtils<'a> { diff --git a/src/librustc_trans/Cargo.toml b/src/librustc_trans/Cargo.toml index 749ceda3db094..38f9e7ab0c51c 100644 --- a/src/librustc_trans/Cargo.toml +++ b/src/librustc_trans/Cargo.toml @@ -19,8 +19,10 @@ rustc_back = { path = "../librustc_back" } rustc_const_eval = { path = "../librustc_const_eval" } rustc_const_math = { path = "../librustc_const_math" } rustc_data_structures = { path = "../librustc_data_structures" } +rustc_errors = { path = "../librustc_errors" } rustc_incremental = { path = "../librustc_incremental" } rustc_llvm = { path = "../librustc_llvm" } rustc_platform_intrinsics = { path = "../librustc_platform_intrinsics" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } \ No newline at end of file diff --git a/src/librustc_trans/_match.rs b/src/librustc_trans/_match.rs index 8ad1ba2a61418..15beba0d9a6ee 100644 --- a/src/librustc_trans/_match.rs +++ b/src/librustc_trans/_match.rs @@ -230,7 +230,7 @@ use std::fmt; use std::rc::Rc; use rustc::hir::{self, PatKind}; use syntax::ast::{self, DUMMY_NODE_ID, NodeId}; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir::fold::Folder; use syntax::ptr::P; diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 4676b0a67e4ae..0ca59cfd7571b 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -42,8 +42,8 @@ use std::process::Command; use std::str; use flate; use syntax::ast; -use syntax::codemap::Span; use syntax::attr::AttrMetaMethods; +use syntax_pos::Span; // RLIB LLVM-BYTECODE OBJECT LAYOUT // Version 1 diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index cf81777be261d..d644fcca3bad8 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -19,9 +19,9 @@ use llvm::SMDiagnosticRef; use {CrateTranslation, ModuleTranslation}; use util::common::time; use util::common::path2cstr; -use syntax::codemap::MultiSpan; -use syntax::errors::{self, Handler, Level, RenderSpan}; -use syntax::errors::emitter::CoreEmitter; +use errors::{self, Handler, Level, RenderSpan}; +use errors::emitter::CoreEmitter; +use syntax_pos::MultiSpan; use std::collections::HashMap; use std::ffi::{CStr, CString}; @@ -357,7 +357,7 @@ struct HandlerFreeVars<'a> { unsafe extern "C" fn report_inline_asm<'a, 'b>(cgcx: &'a CodegenContext<'a>, msg: &'b str, cookie: c_uint) { - use syntax::codemap::ExpnId; + use syntax_pos::ExpnId; match cgcx.lto_ctxt { Some((sess, _)) => { diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index 5250361cd17ae..2998c834aca7a 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -101,7 +101,7 @@ use std::cell::{Cell, RefCell}; use std::collections::{HashMap, HashSet}; use std::str; use std::{i8, i16, i32, i64}; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use syntax::parse::token::InternedString; use syntax::attr::AttrMetaMethods; use syntax::attr; diff --git a/src/librustc_trans/build.rs b/src/librustc_trans/build.rs index 0185d1587625c..4a7a5736b13a6 100644 --- a/src/librustc_trans/build.rs +++ b/src/librustc_trans/build.rs @@ -16,7 +16,7 @@ use llvm::{AtomicBinOp, AtomicOrdering, SynchronizationScope, AsmDialect}; use llvm::{Opcode, IntPredicate, RealPredicate}; use llvm::{ValueRef, BasicBlockRef}; use common::*; -use syntax::codemap::Span; +use syntax_pos::Span; use builder::Builder; use type_::Type; diff --git a/src/librustc_trans/builder.rs b/src/librustc_trans/builder.rs index 9f032cdbfe513..d415698660000 100644 --- a/src/librustc_trans/builder.rs +++ b/src/librustc_trans/builder.rs @@ -24,7 +24,7 @@ use libc::{c_uint, c_char}; use std::ffi::CString; use std::ptr; -use syntax::codemap::Span; +use syntax_pos::Span; pub struct Builder<'a, 'tcx: 'a> { pub llbuilder: BuilderRef, diff --git a/src/librustc_trans/callee.rs b/src/librustc_trans/callee.rs index 7099246c6abde..9ea65532b35b6 100644 --- a/src/librustc_trans/callee.rs +++ b/src/librustc_trans/callee.rs @@ -53,8 +53,8 @@ use Disr; use rustc::ty::{self, Ty, TyCtxt, TypeFoldable}; use rustc::hir; -use syntax::codemap::DUMMY_SP; -use syntax::errors; +use syntax_pos::DUMMY_SP; +use errors; use syntax::ptr::P; #[derive(Debug)] diff --git a/src/librustc_trans/collector.rs b/src/librustc_trans/collector.rs index bbc01f0935f2b..eea6aec37260e 100644 --- a/src/librustc_trans/collector.rs +++ b/src/librustc_trans/collector.rs @@ -203,8 +203,8 @@ use rustc::mir::visit as mir_visit; use rustc::mir::visit::Visitor as MirVisitor; use syntax::abi::Abi; -use syntax::codemap::DUMMY_SP; -use syntax::errors; +use errors; +use syntax_pos::DUMMY_SP; use base::custom_coerce_unsize_info; use context::SharedCrateContext; use common::{fulfill_obligation, normalize_and_test_predicates, type_is_sized}; diff --git a/src/librustc_trans/common.rs b/src/librustc_trans/common.rs index 6b8198881c83c..d057f623383d3 100644 --- a/src/librustc_trans/common.rs +++ b/src/librustc_trans/common.rs @@ -52,9 +52,9 @@ use std::ffi::CString; use std::cell::{Cell, RefCell}; use syntax::ast; -use syntax::codemap::{DUMMY_SP, Span}; use syntax::parse::token::InternedString; use syntax::parse::token; +use syntax_pos::{DUMMY_SP, Span}; pub use context::{CrateContext, SharedCrateContext}; diff --git a/src/librustc_trans/consts.rs b/src/librustc_trans/consts.rs index e988d2e6ac314..4e12d3d5d8231 100644 --- a/src/librustc_trans/consts.rs +++ b/src/librustc_trans/consts.rs @@ -49,9 +49,9 @@ use std::borrow::Cow; use libc::c_uint; use syntax::ast::{self, LitKind}; use syntax::attr::{self, AttrMetaMethods}; -use syntax::codemap::Span; use syntax::parse::token; use syntax::ptr::P; +use syntax_pos::Span; pub type FnArgMap<'a> = Option<&'a NodeMap>; diff --git a/src/librustc_trans/datum.rs b/src/librustc_trans/datum.rs index eda3ce1d1062c..875f88e37c916 100644 --- a/src/librustc_trans/datum.rs +++ b/src/librustc_trans/datum.rs @@ -106,7 +106,7 @@ use rustc::ty::Ty; use std::fmt; use syntax::ast; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; /// A `Datum` encapsulates the result of evaluating an expression. It /// describes where the value is stored, what Rust type the value has, diff --git a/src/librustc_trans/debuginfo/create_scope_map.rs b/src/librustc_trans/debuginfo/create_scope_map.rs index b29ca515f8fc3..2b079e7dcc8d9 100644 --- a/src/librustc_trans/debuginfo/create_scope_map.rs +++ b/src/librustc_trans/debuginfo/create_scope_map.rs @@ -22,7 +22,7 @@ use rustc::util::nodemap::NodeMap; use libc::c_uint; use std::ptr; -use syntax::codemap::{Span, Pos}; +use syntax_pos::{Span, Pos}; use syntax::{ast, codemap}; use rustc_data_structures::bitvec::BitVector; diff --git a/src/librustc_trans/debuginfo/metadata.rs b/src/librustc_trans/debuginfo/metadata.rs index c6c28fc9ba6a5..34dedeede98e0 100644 --- a/src/librustc_trans/debuginfo/metadata.rs +++ b/src/librustc_trans/debuginfo/metadata.rs @@ -44,9 +44,9 @@ use std::ptr; use std::rc::Rc; use syntax; use syntax::util::interner::Interner; -use syntax::codemap::Span; -use syntax::{ast, codemap}; +use syntax::ast; use syntax::parse::token; +use syntax_pos::{self, Span}; // From DWARF 5. @@ -660,7 +660,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, &[], containing_scope, NO_FILE_METADATA, - codemap::DUMMY_SP) + syntax_pos::DUMMY_SP) } pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, @@ -1385,7 +1385,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> { &[sole_struct_member_description], self.containing_scope, self.file_metadata, - codemap::DUMMY_SP); + syntax_pos::DUMMY_SP); // Encode the information about the null variant in the union // member's name. @@ -1615,7 +1615,7 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let discriminant_base_type_metadata = type_metadata(cx, adt::ty_of_inttype(cx.tcx(), inttype), - codemap::DUMMY_SP); + syntax_pos::DUMMY_SP); let discriminant_name = get_enum_discriminant_name(cx, enum_def_id); let name = CString::new(discriminant_name.as_bytes()).unwrap(); @@ -1849,7 +1849,7 @@ pub fn create_global_var_metadata(cx: &CrateContext, let node_def_id = cx.tcx().map.local_def_id(node_id); let (var_scope, span) = get_namespace_and_span_for_item(cx, node_def_id); - let (file_metadata, line_number) = if span != codemap::DUMMY_SP { + let (file_metadata, line_number) = if span != syntax_pos::DUMMY_SP { let loc = span_start(cx, span); (file_metadata(cx, &loc.file.name, &loc.file.abs_path), loc.line as c_uint) } else { diff --git a/src/librustc_trans/debuginfo/mod.rs b/src/librustc_trans/debuginfo/mod.rs index 92b151c7c4076..8c5b3ed54c2f5 100644 --- a/src/librustc_trans/debuginfo/mod.rs +++ b/src/librustc_trans/debuginfo/mod.rs @@ -42,8 +42,8 @@ use std::cell::{Cell, RefCell}; use std::ffi::CString; use std::ptr; -use syntax::codemap::{Span, Pos}; -use syntax::{ast, codemap}; +use syntax_pos::{self, Span, Pos}; +use syntax::ast; use syntax::attr::IntType; pub mod gdb; @@ -242,7 +242,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (containing_scope, span) = get_containing_scope_and_span(cx, instance); // This can be the case for functions inlined from another crate - if span == codemap::DUMMY_SP { + if span == syntax_pos::DUMMY_SP { return FunctionDebugContext::FunctionWithoutDebugInfo; } @@ -327,7 +327,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, signature.push(match sig.output { ty::FnConverging(ret_ty) => match ret_ty.sty { ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(), - _ => type_metadata(cx, ret_ty, codemap::DUMMY_SP) + _ => type_metadata(cx, ret_ty, syntax_pos::DUMMY_SP) }, ty::FnDiverging => diverging_type_metadata(cx) }); @@ -340,13 +340,13 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // Arguments types for &argument_type in inputs { - signature.push(type_metadata(cx, argument_type, codemap::DUMMY_SP)); + signature.push(type_metadata(cx, argument_type, syntax_pos::DUMMY_SP)); } if abi == Abi::RustCall && !sig.inputs.is_empty() { if let ty::TyTuple(args) = sig.inputs[sig.inputs.len() - 1].sty { for &argument_type in args { - signature.push(type_metadata(cx, argument_type, codemap::DUMMY_SP)); + signature.push(type_metadata(cx, argument_type, syntax_pos::DUMMY_SP)); } } } @@ -386,7 +386,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let template_params: Vec<_> = if cx.sess().opts.debuginfo == FullDebugInfo { generics.types.as_slice().iter().enumerate().map(|(i, param)| { let actual_type = cx.tcx().normalize_associated_type(&actual_types[i]); - let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP); + let actual_type_metadata = type_metadata(cx, actual_type, syntax_pos::DUMMY_SP); let name = CString::new(param.name.as_str().as_bytes()).unwrap(); unsafe { llvm::LLVMDIBuilderCreateTemplateTypeParameter( @@ -420,7 +420,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let impl_self_ty = monomorphize::apply_param_substs(cx.tcx(), instance.substs, &impl_self_ty); - Some(type_metadata(cx, impl_self_ty, codemap::DUMMY_SP)) + Some(type_metadata(cx, impl_self_ty, syntax_pos::DUMMY_SP)) } else { // For trait method impls we still use the "parallel namespace" // strategy @@ -441,7 +441,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // Try to get some span information, if we have an inlined item. let definition_span = match cx.external().borrow().get(&instance.def) { Some(&Some(node_id)) => cx.tcx().map.span(node_id), - _ => cx.tcx().map.def_id_span(instance.def, codemap::DUMMY_SP) + _ => cx.tcx().map.def_id_span(instance.def, syntax_pos::DUMMY_SP) }; (containing_scope, definition_span) diff --git a/src/librustc_trans/debuginfo/namespace.rs b/src/librustc_trans/debuginfo/namespace.rs index a37fbdccc8f0a..167229ddfd985 100644 --- a/src/librustc_trans/debuginfo/namespace.rs +++ b/src/librustc_trans/debuginfo/namespace.rs @@ -22,7 +22,7 @@ use common::CrateContext; use libc::c_uint; use std::ffi::CString; use std::ptr; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; pub fn mangled_name_of_item(ccx: &CrateContext, def_id: DefId, extra: &str) -> String { fn fill_nested(ccx: &CrateContext, def_id: DefId, extra: &str, output: &mut String) { diff --git a/src/librustc_trans/debuginfo/source_loc.rs b/src/librustc_trans/debuginfo/source_loc.rs index 6b00c1bb1a855..9726001b4d42b 100644 --- a/src/librustc_trans/debuginfo/source_loc.rs +++ b/src/librustc_trans/debuginfo/source_loc.rs @@ -21,8 +21,8 @@ use common::{NodeIdAndSpan, CrateContext, FunctionContext}; use libc::c_uint; use std::ptr; -use syntax::codemap::{Span, Pos}; -use syntax::{ast, codemap}; +use syntax_pos::{self, Span, Pos}; +use syntax::ast; pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, node_id: ast::NodeId, @@ -70,7 +70,7 @@ pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, if !bytes.is_empty() && &bytes[bytes.len()-1..] == b"}" { cleanup_span = Span { - lo: node_span.hi - codemap::BytePos(1), + lo: node_span.hi - syntax_pos::BytePos(1), hi: node_span.hi, expn_id: node_span.expn_id }; diff --git a/src/librustc_trans/debuginfo/utils.rs b/src/librustc_trans/debuginfo/utils.rs index 3fd9793718434..1e0afa4534b15 100644 --- a/src/librustc_trans/debuginfo/utils.rs +++ b/src/librustc_trans/debuginfo/utils.rs @@ -21,8 +21,8 @@ use machine; use common::{CrateContext, FunctionContext}; use type_::Type; -use syntax::codemap::Span; -use syntax::{ast, codemap}; +use syntax_pos::{self, Span}; +use syntax::ast; pub fn is_node_local_to_unit(cx: &CrateContext, node_id: ast::NodeId) -> bool { @@ -44,8 +44,8 @@ pub fn create_DIArray(builder: DIBuilderRef, arr: &[DIDescriptor]) -> DIArray { }; } -/// Return codemap::Loc corresponding to the beginning of the span -pub fn span_start(cx: &CrateContext, span: Span) -> codemap::Loc { +/// Return syntax_pos::Loc corresponding to the beginning of the span +pub fn span_start(cx: &CrateContext, span: Span) -> syntax_pos::Loc { cx.sess().codemap().lookup_char_pos(span.lo) } @@ -88,7 +88,7 @@ pub fn get_namespace_and_span_for_item(cx: &CrateContext, def_id: DefId) // Try to get some span information, if we have an inlined item. let definition_span = match cx.external().borrow().get(&def_id) { Some(&Some(node_id)) => cx.tcx().map.span(node_id), - _ => cx.tcx().map.def_id_span(def_id, codemap::DUMMY_SP) + _ => cx.tcx().map.def_id_span(def_id, syntax_pos::DUMMY_SP) }; (containing_scope, definition_span) diff --git a/src/librustc_trans/expr.rs b/src/librustc_trans/expr.rs index 652886ff2a044..71c6cba9cc22a 100644 --- a/src/librustc_trans/expr.rs +++ b/src/librustc_trans/expr.rs @@ -81,8 +81,9 @@ use type_::Type; use rustc::hir; -use syntax::{ast, codemap}; +use syntax::ast; use syntax::parse::token::InternedString; +use syntax_pos; use std::fmt; use std::mem; @@ -454,7 +455,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, - span: codemap::Span, + span: syntax_pos::Span, source: Datum<'tcx, Rvalue>, target: Datum<'tcx, Rvalue>) -> Block<'blk, 'tcx> { @@ -1265,7 +1266,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, fn trans_struct<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, fields: &[hir::Field], base: Option<&hir::Expr>, - expr_span: codemap::Span, + expr_span: syntax_pos::Span, expr_id: ast::NodeId, ty: Ty<'tcx>, dest: Dest) -> Block<'blk, 'tcx> { diff --git a/src/librustc_trans/glue.rs b/src/librustc_trans/glue.rs index 211efeb4e4baa..ac23d713d2727 100644 --- a/src/librustc_trans/glue.rs +++ b/src/librustc_trans/glue.rs @@ -43,7 +43,7 @@ use type_::Type; use value::Value; use arena::TypedArena; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; pub fn trans_exchange_free_dyn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v: ValueRef, diff --git a/src/librustc_trans/intrinsic.rs b/src/librustc_trans/intrinsic.rs index 54c825fa5face..bd24647edf00b 100644 --- a/src/librustc_trans/intrinsic.rs +++ b/src/librustc_trans/intrinsic.rs @@ -44,7 +44,7 @@ use syntax::ptr::P; use syntax::parse::token; use rustc::session::Session; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use std::cmp::Ordering; diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index 8724945ed901b..c369858556d3a 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -55,6 +55,8 @@ extern crate rustc_const_eval; #[macro_use] extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; +extern crate rustc_errors as errors; pub use rustc::session; pub use rustc::middle; diff --git a/src/librustc_trans/meth.rs b/src/librustc_trans/meth.rs index 062b3d4a6e4bf..ac6af8d66e19f 100644 --- a/src/librustc_trans/meth.rs +++ b/src/librustc_trans/meth.rs @@ -36,7 +36,7 @@ use value::Value; use rustc::ty::{self, Ty, TyCtxt, TypeFoldable}; use syntax::ast::Name; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; // drop_glue pointer, size, align. const VTABLE_OFFSET: usize = 3; diff --git a/src/librustc_trans/mir/constant.rs b/src/librustc_trans/mir/constant.rs index 30be4a9737270..da72793abf6da 100644 --- a/src/librustc_trans/mir/constant.rs +++ b/src/librustc_trans/mir/constant.rs @@ -34,7 +34,7 @@ use type_of; use type_::Type; use value::Value; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use std::ptr; diff --git a/src/librustc_trans/mir/mod.rs b/src/librustc_trans/mir/mod.rs index 0db5d3ae4d131..0221232a77df5 100644 --- a/src/librustc_trans/mir/mod.rs +++ b/src/librustc_trans/mir/mod.rs @@ -21,7 +21,7 @@ use debuginfo::{self, declare_local, DebugLoc, VariableAccess, VariableKind}; use machine; use type_of; -use syntax::codemap::DUMMY_SP; +use syntax_pos::DUMMY_SP; use syntax::parse::token::keywords; use std::ops::Deref; diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs index 09b07c1440ec5..28bcd8a633c1c 100644 --- a/src/librustc_trans/mir/rvalue.rs +++ b/src/librustc_trans/mir/rvalue.rs @@ -133,8 +133,8 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> { if let mir::AggregateKind::Closure(def_id, substs) = *kind { use rustc::hir; use syntax::ast::DUMMY_NODE_ID; - use syntax::codemap::DUMMY_SP; use syntax::ptr::P; + use syntax_pos::DUMMY_SP; use closure; closure::trans_closure_expr(closure::Dest::Ignore(bcx.ccx()), diff --git a/src/librustc_trans/monomorphize.rs b/src/librustc_trans/monomorphize.rs index dad82167a76b3..fa00ea1e7801b 100644 --- a/src/librustc_trans/monomorphize.rs +++ b/src/librustc_trans/monomorphize.rs @@ -28,7 +28,7 @@ use rustc::util::ppaux; use rustc::hir; use syntax::attr; -use syntax::errors; +use errors; use std::fmt; diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 350ebf201653c..088ac1aac1a40 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -73,10 +73,10 @@ use util::nodemap::{NodeMap, FnvHashSet}; use rustc_const_math::ConstInt; use std::cell::RefCell; use syntax::{abi, ast}; -use syntax::codemap::{Span, Pos}; -use syntax::errors::DiagnosticBuilder; use syntax::feature_gate::{GateIssue, emit_feature_err}; use syntax::parse::token::{self, keywords}; +use syntax_pos::{Span, Pos}; +use errors::DiagnosticBuilder; pub trait AstConv<'gcx, 'tcx> { fn tcx<'a>(&'a self) -> TyCtxt<'a, 'gcx, 'tcx>; diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 1cff392cf8338..069a09183a738 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -21,8 +21,9 @@ use session::Session; use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::cmp; use syntax::ast; -use syntax::codemap::{Span, Spanned}; +use syntax::codemap::Spanned; use syntax::ptr::P; +use syntax_pos::Span; use rustc::hir::{self, PatKind}; use rustc::hir::print as pprust; diff --git a/src/librustc_typeck/check/assoc.rs b/src/librustc_typeck/check/assoc.rs index 04b0248ccdac2..41f34b9040e83 100644 --- a/src/librustc_typeck/check/assoc.rs +++ b/src/librustc_typeck/check/assoc.rs @@ -13,7 +13,7 @@ use rustc::traits::{self, FulfillmentContext, Normalized, MiscObligation, SelectionContext, ObligationCause}; use rustc::ty::fold::TypeFoldable; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; //FIXME(@jroesch): Ideally we should be able to drop the fulfillment_cx argument. pub fn normalize_associated_types_in<'a, 'gcx, 'tcx, T>( diff --git a/src/librustc_typeck/check/autoderef.rs b/src/librustc_typeck/check/autoderef.rs index 9e2b7cd034652..3c176744fca59 100644 --- a/src/librustc_typeck/check/autoderef.rs +++ b/src/librustc_typeck/check/autoderef.rs @@ -20,7 +20,7 @@ use rustc::ty::subst::Substs; use rustc::ty::{LvaluePreference, NoPreference, PreferMutLvalue}; use rustc::hir; -use syntax::codemap::Span; +use syntax_pos::Span; use syntax::parse::token; #[derive(Copy, Clone, Debug)] diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index 58abf8db2c33d..2c7e7d284fa16 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -17,9 +17,9 @@ use hir::def::Def; use hir::def_id::DefId; use rustc::infer; use rustc::ty::{self, LvaluePreference, Ty}; -use syntax::codemap::Span; use syntax::parse::token; use syntax::ptr::P; +use syntax_pos::Span; use rustc::hir; diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 690250edb8cb4..22ac8bc56907b 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -47,7 +47,7 @@ use rustc::traits; use rustc::ty::{self, Ty, TypeFoldable}; use rustc::ty::cast::{CastKind, CastTy}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use util::common::ErrorReported; /// Reifies a cast check to be checked once we have full type information for diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 20f82271b9cd6..35a5bc9c60967 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -15,7 +15,7 @@ use rustc::traits::{self, ProjectionMode}; use rustc::ty::subst::{self, Subst, Substs, VecPerParamSpace}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use CrateCtxt; use super::assoc; diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 7c8eb62b0e749..eeebd6a7f626b 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -13,7 +13,7 @@ use check::FnCtxt; use rustc::ty::Ty; use rustc::infer::{InferOk, TypeOrigin}; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir; impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index ae614d7b02157..56e4108153e1e 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -21,7 +21,7 @@ use rustc::traits::{self, ProjectionMode}; use util::nodemap::FnvHashSet; use syntax::ast; -use syntax::codemap::{self, Span}; +use syntax_pos::{self, Span}; /// check_drop_impl confirms that the Drop implementation identfied by /// `drop_impl_did` is not any more specialized than the type it is @@ -62,7 +62,7 @@ pub fn check_drop_impl(ccx: &CrateCtxt, drop_impl_did: DefId) -> Result<(), ()> _ => { // Destructors only work on nominal types. This was // already checked by coherence, so we can panic here. - let span = ccx.tcx.map.def_id_span(drop_impl_did, codemap::DUMMY_SP); + let span = ccx.tcx.map.def_id_span(drop_impl_did, syntax_pos::DUMMY_SP); span_bug!(span, "should have been rejected by coherence check: {}", dtor_self_type); @@ -91,7 +91,7 @@ fn ensure_drop_params_and_item_params_correspond<'a, 'tcx>( let named_type = tcx.lookup_item_type(self_type_did).ty; let named_type = named_type.subst(tcx, &infcx.parameter_environment.free_substs); - let drop_impl_span = tcx.map.def_id_span(drop_impl_did, codemap::DUMMY_SP); + let drop_impl_span = tcx.map.def_id_span(drop_impl_did, syntax_pos::DUMMY_SP); let fresh_impl_substs = infcx.fresh_substs_for_generics(drop_impl_span, drop_impl_generics); let fresh_impl_self_ty = drop_impl_ty.subst(tcx, &fresh_impl_substs); @@ -172,7 +172,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'a, 'tcx>( let self_type_node_id = tcx.map.as_local_node_id(self_type_did).unwrap(); - let drop_impl_span = tcx.map.def_id_span(drop_impl_did, codemap::DUMMY_SP); + let drop_impl_span = tcx.map.def_id_span(drop_impl_did, syntax_pos::DUMMY_SP); // We can assume the predicates attached to struct/enum definition // hold. diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs index f120e38630b8a..0fb08ec9855de 100644 --- a/src/librustc_typeck/check/intrinsic.rs +++ b/src/librustc_typeck/check/intrinsic.rs @@ -20,8 +20,8 @@ use {CrateCtxt, require_same_types}; use std::collections::{HashMap}; use syntax::abi::Abi; use syntax::ast; -use syntax::codemap::Span; use syntax::parse::token; +use syntax_pos::Span; use rustc::hir; diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 683a67ff07cf9..5fac65bbfd655 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -18,7 +18,7 @@ use rustc::ty::{self, LvaluePreference, NoPreference, PreferMutLvalue, Ty}; use rustc::ty::adjustment::{AdjustDerefRef, AutoDerefRef, AutoPtr}; use rustc::ty::fold::TypeFoldable; use rustc::infer::{self, InferOk, TypeOrigin}; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir; use std::ops::Deref; diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 00eeefa0449ce..e6401be5b3ef6 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -20,7 +20,7 @@ use rustc::ty::adjustment::{AdjustDerefRef, AutoDerefRef, AutoPtr}; use rustc::infer; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir; diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index d6b696a25483c..373fc83fa7444 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -22,7 +22,7 @@ use rustc::traits; use rustc::ty::{self, Ty, ToPolyTraitRef, TraitRef, TypeFoldable}; use rustc::infer::{InferOk, TypeOrigin}; use syntax::ast; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use rustc::hir; use std::collections::HashSet; use std::mem; diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 6f0d2bc0ca5e6..f20dcdc35aea5 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -24,10 +24,10 @@ use rustc::ty::subst::Substs; use rustc::traits::{Obligation, SelectionContext}; use util::nodemap::{FnvHashSet}; - use syntax::ast; -use syntax::codemap::Span; -use syntax::errors::DiagnosticBuilder; +use errors::DiagnosticBuilder; +use syntax_pos::Span; + use rustc::hir::print as pprust; use rustc::hir; use rustc::hir::Expr_; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 6f7f33fe24d16..83b5ab71cc224 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -115,11 +115,12 @@ use syntax::abi::Abi; use syntax::ast; use syntax::attr; use syntax::attr::AttrMetaMethods; -use syntax::codemap::{self, Span, Spanned}; -use syntax::errors::DiagnosticBuilder; +use syntax::codemap::{self, Spanned}; use syntax::parse::token::{self, InternedString, keywords}; use syntax::ptr::P; use syntax::util::lev_distance::find_best_match_for_name; +use syntax_pos::{self, Span}; +use errors::DiagnosticBuilder; use rustc::hir::intravisit::{self, Visitor}; use rustc::hir::{self, PatKind}; @@ -1908,7 +1909,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { for ty in &self.unsolved_variables() { if let ty::TyInfer(_) = self.shallow_resolve(ty).sty { debug!("default_type_parameters: defaulting `{:?}` to error", ty); - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx().types.err); + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err); } } return; @@ -1919,18 +1920,18 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { if self.type_var_diverges(resolved) { debug!("default_type_parameters: defaulting `{:?}` to `()` because it diverges", resolved); - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.mk_nil()); + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.mk_nil()); } else { match self.type_is_unconstrained_numeric(resolved) { UnconstrainedInt => { debug!("default_type_parameters: defaulting `{:?}` to `i32`", resolved); - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.types.i32) + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32) }, UnconstrainedFloat => { debug!("default_type_parameters: defaulting `{:?}` to `f32`", resolved); - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.types.f64) + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64) } Neither => { } } @@ -1993,7 +1994,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { for ty in &unsolved_variables { let resolved = self.resolve_type_vars_if_possible(ty); if self.type_var_diverges(resolved) { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.mk_nil()); + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.mk_nil()); } else { match self.type_is_unconstrained_numeric(resolved) { UnconstrainedInt | UnconstrainedFloat => { @@ -2051,14 +2052,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let _ = self.commit_if_ok(|_: &infer::CombinedSnapshot| { for ty in &unbound_tyvars { if self.type_var_diverges(ty) { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.mk_nil()); + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.mk_nil()); } else { match self.type_is_unconstrained_numeric(ty) { UnconstrainedInt => { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.types.i32) + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32) }, UnconstrainedFloat => { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.types.f64) + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64) } Neither => { if let Some(default) = default_map.get(ty) { @@ -2096,7 +2097,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { self.find_conflicting_default(&unbound_tyvars, &default_map, conflict) .unwrap_or(type_variable::Default { ty: self.next_ty_var(), - origin_span: codemap::DUMMY_SP, + origin_span: syntax_pos::DUMMY_SP, def_id: self.tcx.map.local_def_id(0) // what do I put here? }); @@ -2147,14 +2148,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // reporting for more then one conflict. for ty in &unbound_tyvars { if self.type_var_diverges(ty) { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.mk_nil()); + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.mk_nil()); } else { match self.type_is_unconstrained_numeric(ty) { UnconstrainedInt => { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.types.i32) + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32) }, UnconstrainedFloat => { - self.demand_eqtype(codemap::DUMMY_SP, *ty, self.tcx.types.f64) + self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64) }, Neither => { if let Some(default) = default_map.get(ty) { diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index a8cb21126c079..5a7038a056982 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -99,7 +99,7 @@ use rustc::ty::wf::ImpliedBound; use std::mem; use std::ops::Deref; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir::intravisit::{self, Visitor}; use rustc::hir::{self, PatKind}; diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index 19964d736f592..702dd5f8de58a 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -49,7 +49,7 @@ use rustc::ty::{self, Ty}; use rustc::infer::UpvarRegion; use std::collections::HashSet; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir; use rustc::hir::intravisit::{self, Visitor}; diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index e0a34189773b1..d101381e2565c 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -19,9 +19,10 @@ use rustc::ty::{self, Ty, TyCtxt}; use std::collections::HashSet; use syntax::ast; -use syntax::codemap::{Span}; -use syntax::errors::DiagnosticBuilder; use syntax::parse::token::keywords; +use syntax_pos::Span; +use errors::DiagnosticBuilder; + use rustc::hir::intravisit::{self, Visitor}; use rustc::hir; diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 205eaf1a38e14..7f5f3ae120b7a 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -25,7 +25,8 @@ use write_ty_to_tcx; use std::cell::Cell; use syntax::ast; -use syntax::codemap::{DUMMY_SP, Span}; +use syntax_pos::{DUMMY_SP, Span}; + use rustc::hir::print::pat_to_string; use rustc::hir::intravisit::{self, Visitor}; use rustc::hir::{self, PatKind}; diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs index c3538ace34749..2ee0927f3c8ea 100644 --- a/src/librustc_typeck/check_unused.rs +++ b/src/librustc_typeck/check_unused.rs @@ -13,7 +13,7 @@ use rustc::dep_graph::DepNode; use rustc::ty::TyCtxt; use syntax::ast; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use rustc::hir; use rustc::hir::intravisit::Visitor; diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 8bee0467f11b3..ade7806e71d12 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -34,7 +34,7 @@ use CrateCtxt; use rustc::infer::{self, InferCtxt, TypeOrigin}; use std::cell::RefCell; use std::rc::Rc; -use syntax::codemap::Span; +use syntax_pos::Span; use util::nodemap::{DefIdMap, FnvHashMap}; use rustc::dep_graph::DepNode; use rustc::hir::map as hir_map; diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index d9ad03222029d..15d4026254fa5 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -16,7 +16,7 @@ use hir::def_id::DefId; use rustc::traits; use rustc::ty::{self, TyCtxt}; use syntax::ast; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::dep_graph::DepNode; use rustc::hir::intravisit; use rustc::hir; diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 586c4f5c1858d..2c33d1a81556e 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -88,9 +88,10 @@ use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::rc::Rc; use syntax::{abi, ast, attr}; -use syntax::codemap::Span; use syntax::parse::token::keywords; use syntax::ptr::P; +use syntax_pos::Span; + use rustc::hir::{self, PatKind}; use rustc::hir::intravisit; use rustc::hir::print as pprust; diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index c6c575719c015..7ccff7ad3d87c 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -85,6 +85,7 @@ This API is completely unstable and subject to change. #[macro_use] extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; extern crate arena; extern crate fmt_macros; @@ -93,6 +94,7 @@ extern crate rustc_platform_intrinsics as intrinsics; extern crate rustc_back; extern crate rustc_const_math; extern crate rustc_const_eval; +extern crate rustc_errors as errors; pub use rustc::dep_graph; pub use rustc::hir; @@ -110,9 +112,9 @@ use rustc::traits::ProjectionMode; use session::{config, CompileResult}; use util::common::time; -use syntax::codemap::Span; use syntax::ast; use syntax::abi::Abi; +use syntax_pos::Span; use std::cell::RefCell; use util::nodemap::NodeMap; diff --git a/src/librustc_typeck/rscope.rs b/src/librustc_typeck/rscope.rs index 793dba1e3f5f8..336a61708683e 100644 --- a/src/librustc_typeck/rscope.rs +++ b/src/librustc_typeck/rscope.rs @@ -12,7 +12,7 @@ use rustc::ty; use std::cell::Cell; -use syntax::codemap::Span; +use syntax_pos::Span; #[derive(Clone)] pub struct ElisionFailureInfo { diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml index 9d76dd81e5f76..cf87aabdfdb5e 100644 --- a/src/librustdoc/Cargo.toml +++ b/src/librustdoc/Cargo.toml @@ -15,12 +15,14 @@ rustc = { path = "../librustc" } rustc_back = { path = "../librustc_back" } rustc_const_eval = { path = "../librustc_const_eval" } rustc_driver = { path = "../librustc_driver" } +rustc_errors = { path = "../librustc_errors" } rustc_lint = { path = "../librustc_lint" } rustc_metadata = { path = "../librustc_metadata" } rustc_resolve = { path = "../librustc_resolve" } rustc_trans = { path = "../librustc_trans" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } log = { path = "../liblog" } [build-dependencies] diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 0801da19c822e..659022053128e 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -24,15 +24,14 @@ pub use self::SelfTy::*; pub use self::FunctionRetTy::*; pub use self::Visibility::*; -use syntax; use syntax::abi::Abi; use syntax::ast; use syntax::attr; use syntax::attr::{AttributeMethods, AttrMetaMethods}; -use syntax::codemap; -use syntax::codemap::{DUMMY_SP, Pos, Spanned}; +use syntax::codemap::Spanned; use syntax::parse::token::{self, InternedString, keywords}; use syntax::ptr::P; +use syntax_pos::{self, DUMMY_SP, Pos}; use rustc_trans::back::link; use rustc::middle::cstore; @@ -533,7 +532,7 @@ impl attr::AttrMetaMethods for Attribute { } } fn meta_item_list<'a>(&'a self) -> Option<&'a [P]> { None } - fn span(&self) -> codemap::Span { unimplemented!() } + fn span(&self) -> syntax_pos::Span { unimplemented!() } } #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)] @@ -1977,7 +1976,7 @@ impl Span { } } -impl Clean for syntax::codemap::Span { +impl Clean for syntax_pos::Span { fn clean(&self, cx: &DocContext) -> Span { if *self == DUMMY_SP { return Span::empty(); @@ -2543,7 +2542,7 @@ trait ToSource { fn to_src(&self, cx: &DocContext) -> String; } -impl ToSource for syntax::codemap::Span { +impl ToSource for syntax_pos::Span { fn to_src(&self, cx: &DocContext) -> String { debug!("converting span {:?} to snippet", self.clean(cx)); let sn = match cx.sess().codemap().span_to_snippet(*self) { diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 73e0a529a45c6..f4da8167ea286 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -22,10 +22,11 @@ use rustc_trans::back::link; use rustc_resolve as resolve; use rustc_metadata::cstore::CStore; -use syntax::{ast, codemap, errors}; -use syntax::errors::emitter::ColorConfig; +use syntax::{ast, codemap}; use syntax::feature_gate::UnstableFeatures; use syntax::parse::token; +use errors; +use errors::emitter::ColorConfig; use std::cell::{RefCell, Cell}; use std::collections::{HashMap, HashSet}; diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 408782a698a2a..04d176c36c8cf 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -13,13 +13,13 @@ pub use self::StructType::*; pub use self::TypeBound::*; -use syntax; -use syntax::codemap::Span; use syntax::abi; use syntax::ast; use syntax::ast::{Name, NodeId}; use syntax::attr; use syntax::ptr::P; +use syntax_pos::{self, Span}; + use rustc::hir; pub struct Module { @@ -56,8 +56,8 @@ impl Module { vis: hir::Inherited, stab: None, depr: None, - where_outer: syntax::codemap::DUMMY_SP, - where_inner: syntax::codemap::DUMMY_SP, + where_outer: syntax_pos::DUMMY_SP, + where_inner: syntax_pos::DUMMY_SP, attrs : hir::HirVec::new(), extern_crates: Vec::new(), imports : Vec::new(), diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 321bc51f90386..2e2f99897733d 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -26,10 +26,11 @@ use std::fmt::Display; use std::io; use std::io::prelude::*; -use syntax::codemap::{CodeMap, Span}; +use syntax::codemap::CodeMap; use syntax::parse::lexer::{self, Reader, TokenAndSpan}; use syntax::parse::token; use syntax::parse; +use syntax_pos::Span; /// Highlights `src`, returning the HTML output. pub fn render_with_highlighting(src: &str, class: Option<&str>, id: Option<&str>) -> String { diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 86aad10e02fc7..2015bb295eabd 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -42,9 +42,11 @@ extern crate rustc_back; extern crate rustc_metadata; extern crate serialize; #[macro_use] extern crate syntax; +extern crate syntax_pos; extern crate test as testing; extern crate rustc_unicode; #[macro_use] extern crate log; +extern crate rustc_errors as errors; extern crate serialize as rustc_serialize; // used by deriving diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index c17af55ca10af..95d02d6ce4bee 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -35,8 +35,8 @@ use rustc_driver::driver::phase_2_configure_and_expand; use rustc_metadata::cstore::CStore; use rustc_resolve::MakeGlobMap; use syntax::codemap::CodeMap; -use syntax::errors; -use syntax::errors::emitter::ColorConfig; +use errors; +use errors::emitter::ColorConfig; use syntax::parse::token; use core; @@ -229,8 +229,9 @@ fn runtest(test: &str, cratename: &str, cfgs: Vec, libs: SearchPaths, let data = Arc::new(Mutex::new(Vec::new())); let codemap = Rc::new(CodeMap::new()); let emitter = errors::emitter::EmitterWriter::new(box Sink(data.clone()), - None, - codemap.clone()); + None, + codemap.clone(), + errors::snippet::FormatMode::EnvironmentSelected); let old = io::set_panic(box Sink(data.clone())); let _bomb = Bomb(data.clone(), old.unwrap_or(box io::stdout())); diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index b0b55a76e266e..92424f113f987 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -18,7 +18,7 @@ use syntax::abi; use syntax::ast; use syntax::attr; use syntax::attr::AttrMetaMethods; -use syntax::codemap::Span; +use syntax_pos::Span; use rustc::hir::map as hir_map; use rustc::hir::def::Def; diff --git a/src/libsyntax/Cargo.toml b/src/libsyntax/Cargo.toml index 964f2dcb6b6b7..80ed4cad10725 100644 --- a/src/libsyntax/Cargo.toml +++ b/src/libsyntax/Cargo.toml @@ -12,3 +12,5 @@ crate-type = ["dylib"] serialize = { path = "../libserialize" } log = { path = "../liblog" } rustc_bitflags = { path = "../librustc_bitflags" } +syntax_pos = { path = "../libsyntax_pos" } +rustc_errors = { path = "../librustc_errors" } \ No newline at end of file diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 8537fcc221c95..fdbc4477edb13 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -16,7 +16,8 @@ pub use self::ViewPath_::*; pub use self::PathParameters::*; use attr::{ThinAttributes, HasAttrs}; -use codemap::{mk_sp, respan, Span, Spanned, DUMMY_SP, ExpnId}; +use syntax_pos::{mk_sp, Span, DUMMY_SP, ExpnId}; +use codemap::{respan, Spanned}; use abi::Abi; use errors; use ext::base; diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index e36e15802f0ae..9f2566a381c91 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -18,8 +18,8 @@ use ast; use ast::{AttrId, Attribute, Attribute_, MetaItem, MetaItemKind}; use ast::{Stmt, StmtKind, DeclKind}; use ast::{Expr, Item, Local, Decl}; -use codemap::{Span, Spanned, spanned, dummy_spanned}; -use codemap::BytePos; +use codemap::{spanned, dummy_spanned, Spanned}; +use syntax_pos::{Span, BytePos}; use errors::Handler; use feature_gate::{Features, GatedCfg}; use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration}; diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 5e1335b45aa0c..743f96d737e2d 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -19,269 +19,18 @@ pub use self::ExpnFormat::*; -use std::cell::{Cell, RefCell}; -use std::ops::{Add, Sub}; +use std::cell::RefCell; use std::path::{Path,PathBuf}; use std::rc::Rc; -use std::cmp; use std::env; -use std::{fmt, fs}; +use std::fs; use std::io::{self, Read}; - -use serialize::{Encodable, Decodable, Encoder, Decoder}; +pub use syntax_pos::*; +use errors::CodeMapper; use ast::Name; -// _____________________________________________________________________________ -// Pos, BytePos, CharPos -// - -pub trait Pos { - fn from_usize(n: usize) -> Self; - fn to_usize(&self) -> usize; -} - -/// A byte offset. Keep this small (currently 32-bits), as AST contains -/// a lot of them. -#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] -pub struct BytePos(pub u32); - -/// A character offset. Because of multibyte utf8 characters, a byte offset -/// is not equivalent to a character offset. The CodeMap will convert BytePos -/// values to CharPos values as necessary. -#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] -pub struct CharPos(pub usize); - -// FIXME: Lots of boilerplate in these impls, but so far my attempts to fix -// have been unsuccessful - -impl Pos for BytePos { - fn from_usize(n: usize) -> BytePos { BytePos(n as u32) } - fn to_usize(&self) -> usize { let BytePos(n) = *self; n as usize } -} - -impl Add for BytePos { - type Output = BytePos; - - fn add(self, rhs: BytePos) -> BytePos { - BytePos((self.to_usize() + rhs.to_usize()) as u32) - } -} - -impl Sub for BytePos { - type Output = BytePos; - - fn sub(self, rhs: BytePos) -> BytePos { - BytePos((self.to_usize() - rhs.to_usize()) as u32) - } -} - -impl Encodable for BytePos { - fn encode(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u32(self.0) - } -} - -impl Decodable for BytePos { - fn decode(d: &mut D) -> Result { - Ok(BytePos(d.read_u32()?)) - } -} - -impl Pos for CharPos { - fn from_usize(n: usize) -> CharPos { CharPos(n) } - fn to_usize(&self) -> usize { let CharPos(n) = *self; n } -} - -impl Add for CharPos { - type Output = CharPos; - - fn add(self, rhs: CharPos) -> CharPos { - CharPos(self.to_usize() + rhs.to_usize()) - } -} - -impl Sub for CharPos { - type Output = CharPos; - - fn sub(self, rhs: CharPos) -> CharPos { - CharPos(self.to_usize() - rhs.to_usize()) - } -} - -// _____________________________________________________________________________ -// Span, MultiSpan, Spanned -// - -/// Spans represent a region of code, used for error reporting. Positions in spans -/// are *absolute* positions from the beginning of the codemap, not positions -/// relative to FileMaps. Methods on the CodeMap can be used to relate spans back -/// to the original source. -/// You must be careful if the span crosses more than one file - you will not be -/// able to use many of the functions on spans in codemap and you cannot assume -/// that the length of the span = hi - lo; there may be space in the BytePos -/// range between files. -#[derive(Clone, Copy, Hash, PartialEq, Eq)] -pub struct Span { - pub lo: BytePos, - pub hi: BytePos, - /// Information about where the macro came from, if this piece of - /// code was created by a macro expansion. - pub expn_id: ExpnId -} - -/// A collection of spans. Spans have two orthogonal attributes: -/// -/// - they can be *primary spans*. In this case they are the locus of -/// the error, and would be rendered with `^^^`. -/// - they can have a *label*. In this case, the label is written next -/// to the mark in the snippet when we render. -#[derive(Clone)] -pub struct MultiSpan { - primary_spans: Vec, - span_labels: Vec<(Span, String)>, -} - -#[derive(Clone, Debug)] -pub struct SpanLabel { - /// The span we are going to include in the final snippet. - pub span: Span, - - /// Is this a primary span? This is the "locus" of the message, - /// and is indicated with a `^^^^` underline, versus `----`. - pub is_primary: bool, - - /// What label should we attach to this span (if any)? - pub label: Option, -} - -pub const DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_id: NO_EXPANSION }; - -// Generic span to be used for code originating from the command line -pub const COMMAND_LINE_SP: Span = Span { lo: BytePos(0), - hi: BytePos(0), - expn_id: COMMAND_LINE_EXPN }; - -impl Span { - /// Returns a new span representing just the end-point of this span - pub fn end_point(self) -> Span { - let lo = cmp::max(self.hi.0 - 1, self.lo.0); - Span { lo: BytePos(lo), hi: self.hi, expn_id: self.expn_id} - } - - /// Returns `self` if `self` is not the dummy span, and `other` otherwise. - pub fn substitute_dummy(self, other: Span) -> Span { - if self.source_equal(&DUMMY_SP) { other } else { self } - } - - pub fn contains(self, other: Span) -> bool { - self.lo <= other.lo && other.hi <= self.hi - } - - /// Return true if the spans are equal with regards to the source text. - /// - /// Use this instead of `==` when either span could be generated code, - /// and you only care that they point to the same bytes of source text. - pub fn source_equal(&self, other: &Span) -> bool { - self.lo == other.lo && self.hi == other.hi - } - - /// Returns `Some(span)`, a union of `self` and `other`, on overlap. - pub fn merge(self, other: Span) -> Option { - if self.expn_id != other.expn_id { - return None; - } - - if (self.lo <= other.lo && self.hi > other.lo) || - (self.lo >= other.lo && self.lo < other.hi) { - Some(Span { - lo: cmp::min(self.lo, other.lo), - hi: cmp::max(self.hi, other.hi), - expn_id: self.expn_id, - }) - } else { - None - } - } - - /// Returns `Some(span)`, where the start is trimmed by the end of `other` - pub fn trim_start(self, other: Span) -> Option { - if self.hi > other.hi { - Some(Span { lo: cmp::max(self.lo, other.hi), .. self }) - } else { - None - } - } -} - -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] -pub struct Spanned { - pub node: T, - pub span: Span, -} - -impl Encodable for Span { - fn encode(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_struct("Span", 2, |s| { - s.emit_struct_field("lo", 0, |s| { - self.lo.encode(s) - })?; - - s.emit_struct_field("hi", 1, |s| { - self.hi.encode(s) - }) - }) - } -} - -impl Decodable for Span { - fn decode(d: &mut D) -> Result { - d.read_struct("Span", 2, |d| { - let lo = d.read_struct_field("lo", 0, |d| { - BytePos::decode(d) - })?; - - let hi = d.read_struct_field("hi", 1, |d| { - BytePos::decode(d) - })?; - - Ok(mk_sp(lo, hi)) - }) - } -} - -fn default_span_debug(span: Span, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Span {{ lo: {:?}, hi: {:?}, expn_id: {:?} }}", - span.lo, span.hi, span.expn_id) -} - -thread_local!(pub static SPAN_DEBUG: Cell fmt::Result> = - Cell::new(default_span_debug)); - -impl fmt::Debug for Span { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - SPAN_DEBUG.with(|span_debug| span_debug.get()(*self, f)) - } -} - -pub fn spanned(lo: BytePos, hi: BytePos, t: T) -> Spanned { - respan(mk_sp(lo, hi), t) -} - -pub fn respan(sp: Span, t: T) -> Spanned { - Spanned {node: t, span: sp} -} - -pub fn dummy_spanned(t: T) -> Spanned { - respan(DUMMY_SP, t) -} - -/* assuming that we're not in macro expansion */ -pub fn mk_sp(lo: BytePos, hi: BytePos) -> Span { - Span {lo: lo, hi: hi, expn_id: NO_EXPANSION} -} - /// Return the span itself if it doesn't come from a macro expansion, /// otherwise return the call site span up to the `enclosing_sp` by /// following the `expn_info` chain. @@ -295,123 +44,31 @@ pub fn original_sp(cm: &CodeMap, sp: Span, enclosing_sp: Span) -> Span { } } -impl MultiSpan { - pub fn new() -> MultiSpan { - MultiSpan { - primary_spans: vec![], - span_labels: vec![] - } - } - - pub fn from_span(primary_span: Span) -> MultiSpan { - MultiSpan { - primary_spans: vec![primary_span], - span_labels: vec![] - } - } - - pub fn from_spans(vec: Vec) -> MultiSpan { - MultiSpan { - primary_spans: vec, - span_labels: vec![] - } - } - - pub fn push_span_label(&mut self, span: Span, label: String) { - self.span_labels.push((span, label)); - } - - /// Selects the first primary span (if any) - pub fn primary_span(&self) -> Option { - self.primary_spans.first().cloned() - } - - /// Returns all primary spans. - pub fn primary_spans(&self) -> &[Span] { - &self.primary_spans - } - - /// Returns the strings to highlight. We always ensure that there - /// is an entry for each of the primary spans -- for each primary - /// span P, if there is at least one label with span P, we return - /// those labels (marked as primary). But otherwise we return - /// `SpanLabel` instances with empty labels. - pub fn span_labels(&self) -> Vec { - let is_primary = |span| self.primary_spans.contains(&span); - let mut span_labels = vec![]; - - for &(span, ref label) in &self.span_labels { - span_labels.push(SpanLabel { - span: span, - is_primary: is_primary(span), - label: Some(label.clone()) - }); - } - - for &span in &self.primary_spans { - if !span_labels.iter().any(|sl| sl.span == span) { - span_labels.push(SpanLabel { - span: span, - is_primary: true, - label: None - }); - } - } - - span_labels - } +/// The source of expansion. +#[derive(Clone, Hash, Debug, PartialEq, Eq)] +pub enum ExpnFormat { + /// e.g. #[derive(...)] + MacroAttribute(Name), + /// e.g. `format!()` + MacroBang(Name), } -impl From for MultiSpan { - fn from(span: Span) -> MultiSpan { - MultiSpan::from_span(span) - } +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +pub struct Spanned { + pub node: T, + pub span: Span, } -// _____________________________________________________________________________ -// Loc, LocWithOpt, FileMapAndLine, FileMapAndBytePos -// - -/// A source code location used for error reporting -#[derive(Debug)] -pub struct Loc { - /// Information about the original source - pub file: Rc, - /// The (1-based) line number - pub line: usize, - /// The (0-based) column offset - pub col: CharPos +pub fn spanned(lo: BytePos, hi: BytePos, t: T) -> Spanned { + respan(mk_sp(lo, hi), t) } -/// A source code location used as the result of lookup_char_pos_adj -// Actually, *none* of the clients use the filename *or* file field; -// perhaps they should just be removed. -#[derive(Debug)] -pub struct LocWithOpt { - pub filename: FileName, - pub line: usize, - pub col: CharPos, - pub file: Option>, +pub fn respan(sp: Span, t: T) -> Spanned { + Spanned {node: t, span: sp} } -// used to be structural records. Better names, anyone? -#[derive(Debug)] -pub struct FileMapAndLine { pub fm: Rc, pub line: usize } -#[derive(Debug)] -pub struct FileMapAndBytePos { pub fm: Rc, pub pos: BytePos } - - -// _____________________________________________________________________________ -// ExpnFormat, NameAndSpan, ExpnInfo, ExpnId -// - -/// The source of expansion. -#[derive(Clone, Hash, Debug, PartialEq, Eq)] -pub enum ExpnFormat { - /// e.g. #[derive(...)] - MacroAttribute(Name), - /// e.g. `format!()` - MacroBang(Name), +pub fn dummy_spanned(t: T) -> Spanned { + respan(DUMMY_SP, t) } #[derive(Clone, Hash, Debug)] @@ -454,257 +111,10 @@ pub struct ExpnInfo { pub callee: NameAndSpan } -#[derive(PartialEq, Eq, Clone, Debug, Hash, RustcEncodable, RustcDecodable, Copy)] -pub struct ExpnId(u32); - -pub const NO_EXPANSION: ExpnId = ExpnId(!0); -// For code appearing from the command line -pub const COMMAND_LINE_EXPN: ExpnId = ExpnId(!1); - -impl ExpnId { - pub fn from_u32(id: u32) -> ExpnId { - ExpnId(id) - } - - pub fn into_u32(self) -> u32 { - self.0 - } -} - // _____________________________________________________________________________ // FileMap, MultiByteChar, FileName, FileLines // -pub type FileName = String; - -#[derive(Copy, Clone, Debug, PartialEq, Eq)] -pub struct LineInfo { - /// Index of line, starting from 0. - pub line_index: usize, - - /// Column in line where span begins, starting from 0. - pub start_col: CharPos, - - /// Column in line where span ends, starting from 0, exclusive. - pub end_col: CharPos, -} - -pub struct FileLines { - pub file: Rc, - pub lines: Vec -} - -/// Identifies an offset of a multi-byte character in a FileMap -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Eq, PartialEq)] -pub struct MultiByteChar { - /// The absolute offset of the character in the CodeMap - pub pos: BytePos, - /// The number of bytes, >=2 - pub bytes: usize, -} - -/// A single source in the CodeMap. -pub struct FileMap { - /// The name of the file that the source came from, source that doesn't - /// originate from files has names between angle brackets by convention, - /// e.g. `` - pub name: FileName, - /// The absolute path of the file that the source came from. - pub abs_path: Option, - /// The complete source code - pub src: Option>, - /// The start position of this source in the CodeMap - pub start_pos: BytePos, - /// The end position of this source in the CodeMap - pub end_pos: BytePos, - /// Locations of lines beginnings in the source code - pub lines: RefCell>, - /// Locations of multi-byte characters in the source code - pub multibyte_chars: RefCell>, -} - -impl Encodable for FileMap { - fn encode(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_struct("FileMap", 6, |s| { - s.emit_struct_field("name", 0, |s| self.name.encode(s))?; - s.emit_struct_field("abs_path", 1, |s| self.abs_path.encode(s))?; - s.emit_struct_field("start_pos", 2, |s| self.start_pos.encode(s))?; - s.emit_struct_field("end_pos", 3, |s| self.end_pos.encode(s))?; - s.emit_struct_field("lines", 4, |s| { - let lines = self.lines.borrow(); - // store the length - s.emit_u32(lines.len() as u32)?; - - if !lines.is_empty() { - // In order to preserve some space, we exploit the fact that - // the lines list is sorted and individual lines are - // probably not that long. Because of that we can store lines - // as a difference list, using as little space as possible - // for the differences. - let max_line_length = if lines.len() == 1 { - 0 - } else { - lines.windows(2) - .map(|w| w[1] - w[0]) - .map(|bp| bp.to_usize()) - .max() - .unwrap() - }; - - let bytes_per_diff: u8 = match max_line_length { - 0 ... 0xFF => 1, - 0x100 ... 0xFFFF => 2, - _ => 4 - }; - - // Encode the number of bytes used per diff. - bytes_per_diff.encode(s)?; - - // Encode the first element. - lines[0].encode(s)?; - - let diff_iter = (&lines[..]).windows(2) - .map(|w| (w[1] - w[0])); - - match bytes_per_diff { - 1 => for diff in diff_iter { (diff.0 as u8).encode(s)? }, - 2 => for diff in diff_iter { (diff.0 as u16).encode(s)? }, - 4 => for diff in diff_iter { diff.0.encode(s)? }, - _ => unreachable!() - } - } - - Ok(()) - })?; - s.emit_struct_field("multibyte_chars", 5, |s| { - (*self.multibyte_chars.borrow()).encode(s) - }) - }) - } -} - -impl Decodable for FileMap { - fn decode(d: &mut D) -> Result { - - d.read_struct("FileMap", 6, |d| { - let name: String = d.read_struct_field("name", 0, |d| Decodable::decode(d))?; - let abs_path: Option = - d.read_struct_field("abs_path", 1, |d| Decodable::decode(d))?; - let start_pos: BytePos = d.read_struct_field("start_pos", 2, |d| Decodable::decode(d))?; - let end_pos: BytePos = d.read_struct_field("end_pos", 3, |d| Decodable::decode(d))?; - let lines: Vec = d.read_struct_field("lines", 4, |d| { - let num_lines: u32 = Decodable::decode(d)?; - let mut lines = Vec::with_capacity(num_lines as usize); - - if num_lines > 0 { - // Read the number of bytes used per diff. - let bytes_per_diff: u8 = Decodable::decode(d)?; - - // Read the first element. - let mut line_start: BytePos = Decodable::decode(d)?; - lines.push(line_start); - - for _ in 1..num_lines { - let diff = match bytes_per_diff { - 1 => d.read_u8()? as u32, - 2 => d.read_u16()? as u32, - 4 => d.read_u32()?, - _ => unreachable!() - }; - - line_start = line_start + BytePos(diff); - - lines.push(line_start); - } - } - - Ok(lines) - })?; - let multibyte_chars: Vec = - d.read_struct_field("multibyte_chars", 5, |d| Decodable::decode(d))?; - Ok(FileMap { - name: name, - abs_path: abs_path, - start_pos: start_pos, - end_pos: end_pos, - src: None, - lines: RefCell::new(lines), - multibyte_chars: RefCell::new(multibyte_chars) - }) - }) - } -} - -impl fmt::Debug for FileMap { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - write!(fmt, "FileMap({})", self.name) - } -} - -impl FileMap { - /// EFFECT: register a start-of-line offset in the - /// table of line-beginnings. - /// UNCHECKED INVARIANT: these offsets must be added in the right - /// order and must be in the right places; there is shared knowledge - /// about what ends a line between this file and parse.rs - /// WARNING: pos param here is the offset relative to start of CodeMap, - /// and CodeMap will append a newline when adding a filemap without a newline at the end, - /// so the safe way to call this is with value calculated as - /// filemap.start_pos + newline_offset_relative_to_the_start_of_filemap. - pub fn next_line(&self, pos: BytePos) { - // the new charpos must be > the last one (or it's the first one). - let mut lines = self.lines.borrow_mut(); - let line_len = lines.len(); - assert!(line_len == 0 || ((*lines)[line_len - 1] < pos)); - lines.push(pos); - } - - /// get a line from the list of pre-computed line-beginnings. - /// line-number here is 0-based. - pub fn get_line(&self, line_number: usize) -> Option<&str> { - match self.src { - Some(ref src) => { - let lines = self.lines.borrow(); - lines.get(line_number).map(|&line| { - let begin: BytePos = line - self.start_pos; - let begin = begin.to_usize(); - // We can't use `lines.get(line_number+1)` because we might - // be parsing when we call this function and thus the current - // line is the last one we have line info for. - let slice = &src[begin..]; - match slice.find('\n') { - Some(e) => &slice[..e], - None => slice - } - }) - } - None => None - } - } - - pub fn record_multibyte_char(&self, pos: BytePos, bytes: usize) { - assert!(bytes >=2 && bytes <= 4); - let mbc = MultiByteChar { - pos: pos, - bytes: bytes, - }; - self.multibyte_chars.borrow_mut().push(mbc); - } - - pub fn is_real_file(&self) -> bool { - !(self.name.starts_with("<") && - self.name.ends_with(">")) - } - - pub fn is_imported(&self) -> bool { - self.src.is_none() - } - - fn count_lines(&self) -> usize { - self.lines.borrow().len() - } -} - /// An abstraction over the fs operations used by the Parser. pub trait FileLoader { /// Query the existence of a file. @@ -1392,52 +802,24 @@ impl CodeMap { } } -pub struct MacroBacktrace { - /// span where macro was applied to generate this code - pub call_site: Span, - - /// name of macro that was applied (e.g., "foo!" or "#[derive(Eq)]") - pub macro_decl_name: String, - - /// span where macro was defined (if known) - pub def_site_span: Option, -} - -// _____________________________________________________________________________ -// SpanLinesError, SpanSnippetError, DistinctSources, MalformedCodemapPositions -// - -pub type FileLinesResult = Result; - -#[derive(Clone, PartialEq, Eq, Debug)] -pub enum SpanLinesError { - IllFormedSpan(Span), - DistinctSources(DistinctSources), -} - -#[derive(Clone, PartialEq, Eq, Debug)] -pub enum SpanSnippetError { - IllFormedSpan(Span), - DistinctSources(DistinctSources), - MalformedForCodemap(MalformedCodemapPositions), - SourceNotAvailable { filename: String } -} - -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct DistinctSources { - begin: (String, BytePos), - end: (String, BytePos) -} - -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct MalformedCodemapPositions { - name: String, - source_len: usize, - begin_pos: BytePos, - end_pos: BytePos +impl CodeMapper for CodeMap { + fn lookup_char_pos(&self, pos: BytePos) -> Loc { + self.lookup_char_pos(pos) + } + fn span_to_lines(&self, sp: Span) -> FileLinesResult { + self.span_to_lines(sp) + } + fn span_to_string(&self, sp: Span) -> String { + self.span_to_string(sp) + } + fn span_to_filename(&self, sp: Span) -> FileName { + self.span_to_filename(sp) + } + fn macro_backtrace(&self, span: Span) -> Vec { + self.macro_backtrace(span) + } } - // _____________________________________________________________________________ // Tests // @@ -1445,6 +827,13 @@ pub struct MalformedCodemapPositions { #[cfg(test)] mod tests { use super::*; + use errors::{Level, CodeSuggestion}; + use errors::emitter::EmitterWriter; + use errors::snippet::{SnippetData, RenderedLine, FormatMode}; + use std::sync::{Arc, Mutex}; + use std::io::{self, Write}; + use std::str::from_utf8; + use std::rc::Rc; #[test] fn t1 () { @@ -1688,6 +1077,69 @@ mod tests { blork.rs:1:1: 1:12\n `first line.`\n"); } + /// Returns the span corresponding to the `n`th occurrence of + /// `substring` in `source_text`. + trait CodeMapExtension { + fn span_substr(&self, + file: &Rc, + source_text: &str, + substring: &str, + n: usize) + -> Span; + } + + impl CodeMapExtension for CodeMap { + fn span_substr(&self, + file: &Rc, + source_text: &str, + substring: &str, + n: usize) + -> Span + { + println!("span_substr(file={:?}/{:?}, substring={:?}, n={})", + file.name, file.start_pos, substring, n); + let mut i = 0; + let mut hi = 0; + loop { + let offset = source_text[hi..].find(substring).unwrap_or_else(|| { + panic!("source_text `{}` does not have {} occurrences of `{}`, only {}", + source_text, n, substring, i); + }); + let lo = hi + offset; + hi = lo + substring.len(); + if i == n { + let span = Span { + lo: BytePos(lo as u32 + file.start_pos.0), + hi: BytePos(hi as u32 + file.start_pos.0), + expn_id: NO_EXPANSION, + }; + assert_eq!(&self.span_to_snippet(span).unwrap()[..], + substring); + return span; + } + i += 1; + } + } + } + + fn splice(start: Span, end: Span) -> Span { + Span { + lo: start.lo, + hi: end.hi, + expn_id: NO_EXPANSION, + } + } + + fn make_string(lines: &[RenderedLine]) -> String { + lines.iter() + .flat_map(|rl| { + rl.text.iter() + .map(|s| &s.text[..]) + .chain(Some("\n")) + }) + .collect() + } + fn init_expansion_chain(cm: &CodeMap) -> Span { // Creates an expansion chain containing two recursive calls // root -> expA -> expA -> expB -> expB -> end @@ -1767,4 +1219,761 @@ r"blork2.rs:2:1: 2:12 "; assert_eq!(sstr, res_str); } + + struct Sink(Arc>>); + impl Write for Sink { + fn write(&mut self, data: &[u8]) -> io::Result { + Write::write(&mut *self.0.lock().unwrap(), data) + } + fn flush(&mut self) -> io::Result<()> { Ok(()) } + } + + // Diagnostic doesn't align properly in span where line number increases by one digit + #[test] + fn test_hilight_suggestion_issue_11715() { + let data = Arc::new(Mutex::new(Vec::new())); + let cm = Rc::new(CodeMap::new()); + let mut ew = EmitterWriter::new(Box::new(Sink(data.clone())), + None, + cm.clone(), + FormatMode::NewErrorFormat); + let content = "abcdefg + koksi + line3 + line4 + cinq + line6 + line7 + line8 + line9 + line10 + e-lä-vän + tolv + dreizehn + "; + let file = cm.new_filemap_and_lines("dummy.txt", None, content); + let start = file.lines.borrow()[10]; + let end = file.lines.borrow()[11]; + let sp = mk_sp(start, end); + let lvl = Level::Error; + println!("highlight_lines"); + ew.highlight_lines(&sp.into(), lvl).unwrap(); + println!("done"); + let vec = data.lock().unwrap().clone(); + let vec: &[u8] = &vec; + let str = from_utf8(vec).unwrap(); + println!("r#\"\n{}\"#", str); + assert_eq!(str, &r#" + --> dummy.txt:11:1 + |> +11 |> e-lä-vän + |> ^ +"#[1..]); + } + + #[test] + fn test_single_span_splice() { + // Test that a `MultiSpan` containing a single span splices a substition correctly + let cm = CodeMap::new(); + let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n"; + let selection = " \n ~~\n~~~\n~~~~~ \n \n"; + cm.new_filemap_and_lines("blork.rs", None, inputtext); + let sp = span_from_selection(inputtext, selection); + let msp: MultiSpan = sp.into(); + + // check that we are extracting the text we thought we were extracting + assert_eq!(&cm.span_to_snippet(sp).unwrap(), "BB\nCCC\nDDDDD"); + + let substitute = "ZZZZZZ".to_owned(); + let expected = "bbbbZZZZZZddddd"; + let suggest = CodeSuggestion { + msp: msp, + substitutes: vec![substitute], + }; + assert_eq!(suggest.splice_lines(&cm), expected); + } + + #[test] + fn test_multi_span_splice() { + // Test that a `MultiSpan` containing multiple spans splices a substition correctly + let cm = CodeMap::new(); + let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n"; + let selection1 = " \n \n \n \n ~ \n"; // intentionally out of order + let selection2 = " \n ~~\n~~~\n~~~~~ \n \n"; + cm.new_filemap_and_lines("blork.rs", None, inputtext); + let sp1 = span_from_selection(inputtext, selection1); + let sp2 = span_from_selection(inputtext, selection2); + let msp: MultiSpan = MultiSpan::from_spans(vec![sp1, sp2]); + + let expected = "bbbbZZZZZZddddd\neXYZe"; + let suggest = CodeSuggestion { + msp: msp, + substitutes: vec!["ZZZZZZ".to_owned(), + "XYZ".to_owned()] + }; + + assert_eq!(suggest.splice_lines(&cm), expected); + } + + #[test] + fn test_multispan_highlight() { + let data = Arc::new(Mutex::new(Vec::new())); + let cm = Rc::new(CodeMap::new()); + let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())), + None, + cm.clone(), + FormatMode::NewErrorFormat); + + let inp = "_____aaaaaa____bbbbbb__cccccdd_"; + let sp1 = " ~~~~~~ "; + let sp2 = " ~~~~~~ "; + let sp3 = " ~~~~~ "; + let sp4 = " ~~~~ "; + let sp34 = " ~~~~~~~ "; + + let expect_start = &r#" + --> dummy.txt:1:6 + |> +1 |> _____aaaaaa____bbbbbb__cccccdd_ + |> ^^^^^^ ^^^^^^ ^^^^^^^ +"#[1..]; + + let span = |sp, expected| { + let sp = span_from_selection(inp, sp); + assert_eq!(&cm.span_to_snippet(sp).unwrap(), expected); + sp + }; + cm.new_filemap_and_lines("dummy.txt", None, inp); + let sp1 = span(sp1, "aaaaaa"); + let sp2 = span(sp2, "bbbbbb"); + let sp3 = span(sp3, "ccccc"); + let sp4 = span(sp4, "ccdd"); + let sp34 = span(sp34, "cccccdd"); + + let spans = vec![sp1, sp2, sp3, sp4]; + + let test = |expected, highlight: &mut FnMut()| { + data.lock().unwrap().clear(); + highlight(); + let vec = data.lock().unwrap().clone(); + let actual = from_utf8(&vec[..]).unwrap(); + println!("actual=\n{}", actual); + assert_eq!(actual, expected); + }; + + let msp = MultiSpan::from_spans(vec![sp1, sp2, sp34]); + test(expect_start, &mut || { + diag.highlight_lines(&msp, Level::Error).unwrap(); + }); + test(expect_start, &mut || { + let msp = MultiSpan::from_spans(spans.clone()); + diag.highlight_lines(&msp, Level::Error).unwrap(); + }); + } + + #[test] + fn test_huge_multispan_highlight() { + let data = Arc::new(Mutex::new(Vec::new())); + let cm = Rc::new(CodeMap::new()); + let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())), + None, + cm.clone(), + FormatMode::NewErrorFormat); + + let inp = "aaaaa\n\ + aaaaa\n\ + aaaaa\n\ + bbbbb\n\ + ccccc\n\ + xxxxx\n\ + yyyyy\n\ + _____\n\ + ddd__eee_\n\ + elided\n\ + __f_gg"; + let file = cm.new_filemap_and_lines("dummy.txt", None, inp); + + let span = |lo, hi, (off_lo, off_hi)| { + let lines = file.lines.borrow(); + let (mut lo, mut hi): (BytePos, BytePos) = (lines[lo], lines[hi]); + lo.0 += off_lo; + hi.0 += off_hi; + mk_sp(lo, hi) + }; + let sp0 = span(4, 6, (0, 5)); + let sp1 = span(0, 6, (0, 5)); + let sp2 = span(8, 8, (0, 3)); + let sp3 = span(8, 8, (5, 8)); + let sp4 = span(10, 10, (2, 3)); + let sp5 = span(10, 10, (4, 6)); + + let expect0 = &r#" + --> dummy.txt:5:1 + |> +5 |> ccccc + |> ^ +... +9 |> ddd__eee_ + |> ^^^ ^^^ +10 |> elided +11 |> __f_gg + |> ^ ^^ +"#[1..]; + + let expect = &r#" + --> dummy.txt:1:1 + |> +1 |> aaaaa + |> ^ +... +9 |> ddd__eee_ + |> ^^^ ^^^ +10 |> elided +11 |> __f_gg + |> ^ ^^ +"#[1..]; + + macro_rules! test { + ($expected: expr, $highlight: expr) => ({ + data.lock().unwrap().clear(); + $highlight(); + let vec = data.lock().unwrap().clone(); + let actual = from_utf8(&vec[..]).unwrap(); + println!("actual:"); + println!("{}", actual); + println!("expected:"); + println!("{}", $expected); + assert_eq!(&actual[..], &$expected[..]); + }); + } + + let msp0 = MultiSpan::from_spans(vec![sp0, sp2, sp3, sp4, sp5]); + let msp = MultiSpan::from_spans(vec![sp1, sp2, sp3, sp4, sp5]); + + test!(expect0, || { + diag.highlight_lines(&msp0, Level::Error).unwrap(); + }); + test!(expect, || { + diag.highlight_lines(&msp, Level::Error).unwrap(); + }); + } + + #[test] + fn tab() { + let file_text = " +fn foo() { +\tbar; +} +"; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + let span_bar = cm.span_substr(&foo, file_text, "bar", 0); + + let mut snippet = SnippetData::new(cm, Some(span_bar), FormatMode::NewErrorFormat); + snippet.push(span_bar, true, None); + + let lines = snippet.render_lines(); + let text = make_string(&lines); + assert_eq!(&text[..], &" + --> foo.rs:3:2 + |> +3 |> \tbar; + |> \t^^^ +"[1..]); + } + + #[test] + fn one_line() { + let file_text = r#" +fn foo() { + vec.push(vec.pop().unwrap()); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + let span_vec0 = cm.span_substr(&foo, file_text, "vec", 0); + let span_vec1 = cm.span_substr(&foo, file_text, "vec", 1); + let span_semi = cm.span_substr(&foo, file_text, ";", 0); + + let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat); + snippet.push(span_vec0, false, Some(format!("previous borrow of `vec` occurs here"))); + snippet.push(span_vec1, false, Some(format!("error occurs here"))); + snippet.push(span_semi, false, Some(format!("previous borrow ends here"))); + + let lines = snippet.render_lines(); + println!("{:#?}", lines); + + let text: String = make_string(&lines); + + println!("text=\n{}", text); + assert_eq!(&text[..], &r#" + ::: foo.rs + |> +3 |> vec.push(vec.pop().unwrap()); + |> --- --- - previous borrow ends here + |> | | + |> | error occurs here + |> previous borrow of `vec` occurs here +"#[1..]); + } + + #[test] + fn two_files() { + let file_text_foo = r#" +fn foo() { + vec.push(vec.pop().unwrap()); +} +"#; + + let file_text_bar = r#" +fn bar() { + // these blank links here + // serve to ensure that the line numbers + // from bar.rs + // require more digits + + + + + + + + + + + vec.push(); + + // this line will get elided + + vec.pop().unwrap()); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo_map = cm.new_filemap_and_lines("foo.rs", None, file_text_foo); + let span_foo_vec0 = cm.span_substr(&foo_map, file_text_foo, "vec", 0); + let span_foo_vec1 = cm.span_substr(&foo_map, file_text_foo, "vec", 1); + let span_foo_semi = cm.span_substr(&foo_map, file_text_foo, ";", 0); + + let bar_map = cm.new_filemap_and_lines("bar.rs", None, file_text_bar); + let span_bar_vec0 = cm.span_substr(&bar_map, file_text_bar, "vec", 0); + let span_bar_vec1 = cm.span_substr(&bar_map, file_text_bar, "vec", 1); + let span_bar_semi = cm.span_substr(&bar_map, file_text_bar, ";", 0); + + let mut snippet = SnippetData::new(cm, Some(span_foo_vec1), FormatMode::NewErrorFormat); + snippet.push(span_foo_vec0, false, Some(format!("a"))); + snippet.push(span_foo_vec1, true, Some(format!("b"))); + snippet.push(span_foo_semi, false, Some(format!("c"))); + snippet.push(span_bar_vec0, false, Some(format!("d"))); + snippet.push(span_bar_vec1, false, Some(format!("e"))); + snippet.push(span_bar_semi, false, Some(format!("f"))); + + let lines = snippet.render_lines(); + println!("{:#?}", lines); + + let text: String = make_string(&lines); + + println!("text=\n{}", text); + + // Note that the `|>` remain aligned across both files: + assert_eq!(&text[..], &r#" + --> foo.rs:3:14 + |> +3 |> vec.push(vec.pop().unwrap()); + |> --- ^^^ - c + |> | | + |> | b + |> a + ::: bar.rs + |> +17 |> vec.push(); + |> --- - f + |> | + |> d +... +21 |> vec.pop().unwrap()); + |> --- e +"#[1..]); + } + + #[test] + fn multi_line() { + let file_text = r#" +fn foo() { + let name = find_id(&data, 22).unwrap(); + + // Add one more item we forgot to the vector. Silly us. + data.push(Data { name: format!("Hera"), id: 66 }); + + // Print everything out. + println!("Name: {:?}", name); + println!("Data: {:?}", data); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + let span_data0 = cm.span_substr(&foo, file_text, "data", 0); + let span_data1 = cm.span_substr(&foo, file_text, "data", 1); + let span_rbrace = cm.span_substr(&foo, file_text, "}", 3); + + let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat); + snippet.push(span_data0, false, Some(format!("immutable borrow begins here"))); + snippet.push(span_data1, false, Some(format!("mutable borrow occurs here"))); + snippet.push(span_rbrace, false, Some(format!("immutable borrow ends here"))); + + let lines = snippet.render_lines(); + println!("{:#?}", lines); + + let text: String = make_string(&lines); + + println!("text=\n{}", text); + assert_eq!(&text[..], &r#" + ::: foo.rs + |> +3 |> let name = find_id(&data, 22).unwrap(); + |> ---- immutable borrow begins here +... +6 |> data.push(Data { name: format!("Hera"), id: 66 }); + |> ---- mutable borrow occurs here +... +11 |> } + |> - immutable borrow ends here +"#[1..]); + } + + #[test] + fn overlapping() { + let file_text = r#" +fn foo() { + vec.push(vec.pop().unwrap()); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + let span0 = cm.span_substr(&foo, file_text, "vec.push", 0); + let span1 = cm.span_substr(&foo, file_text, "vec", 0); + let span2 = cm.span_substr(&foo, file_text, "ec.push", 0); + let span3 = cm.span_substr(&foo, file_text, "unwrap", 0); + + let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat); + snippet.push(span0, false, Some(format!("A"))); + snippet.push(span1, false, Some(format!("B"))); + snippet.push(span2, false, Some(format!("C"))); + snippet.push(span3, false, Some(format!("D"))); + + let lines = snippet.render_lines(); + println!("{:#?}", lines); + let text: String = make_string(&lines); + + println!("text=r#\"\n{}\".trim_left()", text); + assert_eq!(&text[..], &r#" + ::: foo.rs + |> +3 |> vec.push(vec.pop().unwrap()); + |> -------- ------ D + |> || + |> |C + |> A + |> B +"#[1..]); + } + + #[test] + fn one_line_out_of_order() { + let file_text = r#" +fn foo() { + vec.push(vec.pop().unwrap()); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + let span_vec0 = cm.span_substr(&foo, file_text, "vec", 0); + let span_vec1 = cm.span_substr(&foo, file_text, "vec", 1); + let span_semi = cm.span_substr(&foo, file_text, ";", 0); + + // intentionally don't push the snippets left to right + let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat); + snippet.push(span_vec1, false, Some(format!("error occurs here"))); + snippet.push(span_vec0, false, Some(format!("previous borrow of `vec` occurs here"))); + snippet.push(span_semi, false, Some(format!("previous borrow ends here"))); + + let lines = snippet.render_lines(); + println!("{:#?}", lines); + let text: String = make_string(&lines); + + println!("text=r#\"\n{}\".trim_left()", text); + assert_eq!(&text[..], &r#" + ::: foo.rs + |> +3 |> vec.push(vec.pop().unwrap()); + |> --- --- - previous borrow ends here + |> | | + |> | error occurs here + |> previous borrow of `vec` occurs here +"#[1..]); + } + + #[test] + fn elide_unnecessary_lines() { + let file_text = r#" +fn foo() { + let mut vec = vec![0, 1, 2]; + let mut vec2 = vec; + vec2.push(3); + vec2.push(4); + vec2.push(5); + vec2.push(6); + vec.push(7); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + let span_vec0 = cm.span_substr(&foo, file_text, "vec", 3); + let span_vec1 = cm.span_substr(&foo, file_text, "vec", 8); + + let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat); + snippet.push(span_vec0, false, Some(format!("`vec` moved here because it \ + has type `collections::vec::Vec`"))); + snippet.push(span_vec1, false, Some(format!("use of moved value: `vec`"))); + + let lines = snippet.render_lines(); + println!("{:#?}", lines); + let text: String = make_string(&lines); + println!("text=r#\"\n{}\".trim_left()", text); + assert_eq!(&text[..], &r#" + ::: foo.rs + |> +4 |> let mut vec2 = vec; + |> --- `vec` moved here because it has type `collections::vec::Vec` +... +9 |> vec.push(7); + |> --- use of moved value: `vec` +"#[1..]); + } + + #[test] + fn spans_without_labels() { + let file_text = r#" +fn foo() { + let mut vec = vec![0, 1, 2]; + let mut vec2 = vec; + vec2.push(3); + vec2.push(4); + vec2.push(5); + vec2.push(6); + vec.push(7); +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + + let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat); + for i in 0..4 { + let span_veci = cm.span_substr(&foo, file_text, "vec", i); + snippet.push(span_veci, false, None); + } + + let lines = snippet.render_lines(); + let text: String = make_string(&lines); + println!("text=&r#\"\n{}\n\"#[1..]", text); + assert_eq!(text, &r#" + ::: foo.rs + |> +3 |> let mut vec = vec![0, 1, 2]; + |> --- --- +4 |> let mut vec2 = vec; + |> --- --- +"#[1..]); + } + + #[test] + fn span_long_selection() { + let file_text = r#" +impl SomeTrait for () { + fn foo(x: u32) { + // impl 1 + // impl 2 + // impl 3 + } +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + + let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat); + let fn_span = cm.span_substr(&foo, file_text, "fn", 0); + let rbrace_span = cm.span_substr(&foo, file_text, "}", 0); + snippet.push(splice(fn_span, rbrace_span), false, None); + let lines = snippet.render_lines(); + let text: String = make_string(&lines); + println!("r#\"\n{}\"", text); + assert_eq!(text, &r#" + ::: foo.rs + |> +3 |> fn foo(x: u32) { + |> - +"#[1..]); + } + + #[test] + fn span_overlap_label() { + // Test that we don't put `x_span` to the right of its highlight, + // since there is another highlight that overlaps it. + + let file_text = r#" + fn foo(x: u32) { + } +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + + let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat); + let fn_span = cm.span_substr(&foo, file_text, "fn foo(x: u32)", 0); + let x_span = cm.span_substr(&foo, file_text, "x", 0); + snippet.push(fn_span, false, Some(format!("fn_span"))); + snippet.push(x_span, false, Some(format!("x_span"))); + let lines = snippet.render_lines(); + let text: String = make_string(&lines); + println!("r#\"\n{}\"", text); + assert_eq!(text, &r#" + ::: foo.rs + |> +2 |> fn foo(x: u32) { + |> -------------- + |> | | + |> | x_span + |> fn_span +"#[1..]); + } + + #[test] + fn span_overlap_label2() { + // Test that we don't put `x_span` to the right of its highlight, + // since there is another highlight that overlaps it. In this + // case, the overlap is only at the beginning, but it's still + // better to show the beginning more clearly. + + let file_text = r#" + fn foo(x: u32) { + } +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + + let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat); + let fn_span = cm.span_substr(&foo, file_text, "fn foo(x", 0); + let x_span = cm.span_substr(&foo, file_text, "x: u32)", 0); + snippet.push(fn_span, false, Some(format!("fn_span"))); + snippet.push(x_span, false, Some(format!("x_span"))); + let lines = snippet.render_lines(); + let text: String = make_string(&lines); + println!("r#\"\n{}\"", text); + assert_eq!(text, &r#" + ::: foo.rs + |> +2 |> fn foo(x: u32) { + |> -------------- + |> | | + |> | x_span + |> fn_span +"#[1..]); + } + + #[test] + fn span_overlap_label3() { + // Test that we don't put `x_span` to the right of its highlight, + // since there is another highlight that overlaps it. In this + // case, the overlap is only at the beginning, but it's still + // better to show the beginning more clearly. + + let file_text = r#" + fn foo() { + let closure = || { + inner + }; + } +} +"#; + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + + let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat); + + let closure_span = { + let closure_start_span = cm.span_substr(&foo, file_text, "||", 0); + let closure_end_span = cm.span_substr(&foo, file_text, "}", 0); + splice(closure_start_span, closure_end_span) + }; + + let inner_span = cm.span_substr(&foo, file_text, "inner", 0); + + snippet.push(closure_span, false, Some(format!("foo"))); + snippet.push(inner_span, false, Some(format!("bar"))); + + let lines = snippet.render_lines(); + let text: String = make_string(&lines); + println!("r#\"\n{}\"", text); + assert_eq!(text, &r#" + ::: foo.rs + |> +3 |> let closure = || { + |> - foo +4 |> inner + |> ----- bar +"#[1..]); + } + + #[test] + fn span_empty() { + // In one of the unit tests, we found that the parser sometimes + // gives empty spans, and in particular it supplied an EOF span + // like this one, which points at the very end. We want to + // fallback gracefully in this case. + + let file_text = r#" +fn main() { + struct Foo; + + impl !Sync for Foo {} + + unsafe impl Send for &'static Foo { + // error: cross-crate traits with a default impl, like `core::marker::Send`, + // can only be implemented for a struct/enum type, not + // `&'static Foo` +}"#; + + + let cm = Rc::new(CodeMap::new()); + let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); + + let mut rbrace_span = cm.span_substr(&foo, file_text, "}", 1); + rbrace_span.lo = rbrace_span.hi; + + let mut snippet = SnippetData::new(cm.clone(), + Some(rbrace_span), + FormatMode::NewErrorFormat); + snippet.push(rbrace_span, false, None); + let lines = snippet.render_lines(); + let text: String = make_string(&lines); + println!("r#\"\n{}\"", text); + assert_eq!(text, &r#" + --> foo.rs:11:2 + |> +11 |> } + |> - +"#[1..]); + } } diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 0e5d6841c8258..cc5a68eae3bb5 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -11,7 +11,8 @@ use attr::{AttrMetaMethods, HasAttrs}; use feature_gate::{emit_feature_err, EXPLAIN_STMT_ATTR_SYNTAX, Features, get_features, GateIssue}; use fold::Folder; -use {ast, fold, attr}; +use {fold, attr}; +use ast; use codemap::{Spanned, respan}; use parse::{ParseSess, token}; use ptr::P; diff --git a/src/libsyntax/diagnostics/metadata.rs b/src/libsyntax/diagnostics/metadata.rs index 181b32594f127..5bbd18bd9ee2e 100644 --- a/src/libsyntax/diagnostics/metadata.rs +++ b/src/libsyntax/diagnostics/metadata.rs @@ -20,7 +20,7 @@ use std::io::Write; use std::error::Error; use rustc_serialize::json::as_json; -use codemap::Span; +use syntax_pos::Span; use ext::base::ExtCtxt; use diagnostics::plugin::{ErrorMap, ErrorInfo}; diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs index 26088b1242e2a..abf2b39d5c6de 100644 --- a/src/libsyntax/diagnostics/plugin.rs +++ b/src/libsyntax/diagnostics/plugin.rs @@ -14,7 +14,7 @@ use std::env; use ast; use ast::{Ident, Name, TokenTree}; -use codemap::Span; +use syntax_pos::Span; use ext::base::{ExtCtxt, MacEager, MacResult}; use ext::build::AstBuilder; use parse::token; @@ -23,6 +23,8 @@ use util::small_vector::SmallVector; use diagnostics::metadata::output_metadata; +pub use errors::*; + // Maximum width of any line in an extended error description (inclusive). const MAX_DESCRIPTION_WIDTH: usize = 80; diff --git a/src/libsyntax/errors/snippet/test.rs b/src/libsyntax/errors/snippet/test.rs deleted file mode 100644 index 79e40a091659e..0000000000000 --- a/src/libsyntax/errors/snippet/test.rs +++ /dev/null @@ -1,597 +0,0 @@ -// Copyright 2016 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// Code for testing annotated snippets. - -#![cfg(test)] - -use codemap::{BytePos, CodeMap, FileMap, NO_EXPANSION, Span}; -use std::rc::Rc; -use super::{RenderedLine, SnippetData}; - -/// Returns the span corresponding to the `n`th occurrence of -/// `substring` in `source_text`. -trait CodeMapExtension { - fn span_substr(&self, - file: &Rc, - source_text: &str, - substring: &str, - n: usize) - -> Span; -} - -impl CodeMapExtension for CodeMap { - fn span_substr(&self, - file: &Rc, - source_text: &str, - substring: &str, - n: usize) - -> Span - { - println!("span_substr(file={:?}/{:?}, substring={:?}, n={})", - file.name, file.start_pos, substring, n); - let mut i = 0; - let mut hi = 0; - loop { - let offset = source_text[hi..].find(substring).unwrap_or_else(|| { - panic!("source_text `{}` does not have {} occurrences of `{}`, only {}", - source_text, n, substring, i); - }); - let lo = hi + offset; - hi = lo + substring.len(); - if i == n { - let span = Span { - lo: BytePos(lo as u32 + file.start_pos.0), - hi: BytePos(hi as u32 + file.start_pos.0), - expn_id: NO_EXPANSION, - }; - assert_eq!(&self.span_to_snippet(span).unwrap()[..], - substring); - return span; - } - i += 1; - } - } -} - -fn splice(start: Span, end: Span) -> Span { - Span { - lo: start.lo, - hi: end.hi, - expn_id: NO_EXPANSION, - } -} - -fn make_string(lines: &[RenderedLine]) -> String { - lines.iter() - .flat_map(|rl| { - rl.text.iter() - .map(|s| &s.text[..]) - .chain(Some("\n")) - }) - .collect() -} - -#[test] -fn tab() { - let file_text = " -fn foo() { -\tbar; -} -"; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - let span_bar = cm.span_substr(&foo, file_text, "bar", 0); - - let mut snippet = SnippetData::new(cm, Some(span_bar)); - snippet.push(span_bar, true, None); - - let lines = snippet.render_lines(); - let text = make_string(&lines); - assert_eq!(&text[..], &" - --> foo.rs:3:2 - |> -3 |> \tbar; - |> \t^^^ -"[1..]); -} - -#[test] -fn one_line() { - let file_text = r#" -fn foo() { - vec.push(vec.pop().unwrap()); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - let span_vec0 = cm.span_substr(&foo, file_text, "vec", 0); - let span_vec1 = cm.span_substr(&foo, file_text, "vec", 1); - let span_semi = cm.span_substr(&foo, file_text, ";", 0); - - let mut snippet = SnippetData::new(cm, None); - snippet.push(span_vec0, false, Some(format!("previous borrow of `vec` occurs here"))); - snippet.push(span_vec1, false, Some(format!("error occurs here"))); - snippet.push(span_semi, false, Some(format!("previous borrow ends here"))); - - let lines = snippet.render_lines(); - println!("{:#?}", lines); - - let text: String = make_string(&lines); - - println!("text=\n{}", text); - assert_eq!(&text[..], &r#" - ::: foo.rs - |> -3 |> vec.push(vec.pop().unwrap()); - |> --- --- - previous borrow ends here - |> | | - |> | error occurs here - |> previous borrow of `vec` occurs here -"#[1..]); -} - -#[test] -fn two_files() { - let file_text_foo = r#" -fn foo() { - vec.push(vec.pop().unwrap()); -} -"#; - - let file_text_bar = r#" -fn bar() { - // these blank links here - // serve to ensure that the line numbers - // from bar.rs - // require more digits - - - - - - - - - - - vec.push(); - - // this line will get elided - - vec.pop().unwrap()); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo_map = cm.new_filemap_and_lines("foo.rs", None, file_text_foo); - let span_foo_vec0 = cm.span_substr(&foo_map, file_text_foo, "vec", 0); - let span_foo_vec1 = cm.span_substr(&foo_map, file_text_foo, "vec", 1); - let span_foo_semi = cm.span_substr(&foo_map, file_text_foo, ";", 0); - - let bar_map = cm.new_filemap_and_lines("bar.rs", None, file_text_bar); - let span_bar_vec0 = cm.span_substr(&bar_map, file_text_bar, "vec", 0); - let span_bar_vec1 = cm.span_substr(&bar_map, file_text_bar, "vec", 1); - let span_bar_semi = cm.span_substr(&bar_map, file_text_bar, ";", 0); - - let mut snippet = SnippetData::new(cm, Some(span_foo_vec1)); - snippet.push(span_foo_vec0, false, Some(format!("a"))); - snippet.push(span_foo_vec1, true, Some(format!("b"))); - snippet.push(span_foo_semi, false, Some(format!("c"))); - snippet.push(span_bar_vec0, false, Some(format!("d"))); - snippet.push(span_bar_vec1, false, Some(format!("e"))); - snippet.push(span_bar_semi, false, Some(format!("f"))); - - let lines = snippet.render_lines(); - println!("{:#?}", lines); - - let text: String = make_string(&lines); - - println!("text=\n{}", text); - - // Note that the `|>` remain aligned across both files: - assert_eq!(&text[..], &r#" - --> foo.rs:3:14 - |> -3 |> vec.push(vec.pop().unwrap()); - |> --- ^^^ - c - |> | | - |> | b - |> a - ::: bar.rs - |> -17 |> vec.push(); - |> --- - f - |> | - |> d -... -21 |> vec.pop().unwrap()); - |> --- e -"#[1..]); -} - -#[test] -fn multi_line() { - let file_text = r#" -fn foo() { - let name = find_id(&data, 22).unwrap(); - - // Add one more item we forgot to the vector. Silly us. - data.push(Data { name: format!("Hera"), id: 66 }); - - // Print everything out. - println!("Name: {:?}", name); - println!("Data: {:?}", data); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - let span_data0 = cm.span_substr(&foo, file_text, "data", 0); - let span_data1 = cm.span_substr(&foo, file_text, "data", 1); - let span_rbrace = cm.span_substr(&foo, file_text, "}", 3); - - let mut snippet = SnippetData::new(cm, None); - snippet.push(span_data0, false, Some(format!("immutable borrow begins here"))); - snippet.push(span_data1, false, Some(format!("mutable borrow occurs here"))); - snippet.push(span_rbrace, false, Some(format!("immutable borrow ends here"))); - - let lines = snippet.render_lines(); - println!("{:#?}", lines); - - let text: String = make_string(&lines); - - println!("text=\n{}", text); - assert_eq!(&text[..], &r#" - ::: foo.rs - |> -3 |> let name = find_id(&data, 22).unwrap(); - |> ---- immutable borrow begins here -... -6 |> data.push(Data { name: format!("Hera"), id: 66 }); - |> ---- mutable borrow occurs here -... -11 |> } - |> - immutable borrow ends here -"#[1..]); -} - -#[test] -fn overlapping() { - let file_text = r#" -fn foo() { - vec.push(vec.pop().unwrap()); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - let span0 = cm.span_substr(&foo, file_text, "vec.push", 0); - let span1 = cm.span_substr(&foo, file_text, "vec", 0); - let span2 = cm.span_substr(&foo, file_text, "ec.push", 0); - let span3 = cm.span_substr(&foo, file_text, "unwrap", 0); - - let mut snippet = SnippetData::new(cm, None); - snippet.push(span0, false, Some(format!("A"))); - snippet.push(span1, false, Some(format!("B"))); - snippet.push(span2, false, Some(format!("C"))); - snippet.push(span3, false, Some(format!("D"))); - - let lines = snippet.render_lines(); - println!("{:#?}", lines); - let text: String = make_string(&lines); - - println!("text=r#\"\n{}\".trim_left()", text); - assert_eq!(&text[..], &r#" - ::: foo.rs - |> -3 |> vec.push(vec.pop().unwrap()); - |> -------- ------ D - |> || - |> |C - |> A - |> B -"#[1..]); -} - -#[test] -fn one_line_out_of_order() { - let file_text = r#" -fn foo() { - vec.push(vec.pop().unwrap()); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - let span_vec0 = cm.span_substr(&foo, file_text, "vec", 0); - let span_vec1 = cm.span_substr(&foo, file_text, "vec", 1); - let span_semi = cm.span_substr(&foo, file_text, ";", 0); - - // intentionally don't push the snippets left to right - let mut snippet = SnippetData::new(cm, None); - snippet.push(span_vec1, false, Some(format!("error occurs here"))); - snippet.push(span_vec0, false, Some(format!("previous borrow of `vec` occurs here"))); - snippet.push(span_semi, false, Some(format!("previous borrow ends here"))); - - let lines = snippet.render_lines(); - println!("{:#?}", lines); - let text: String = make_string(&lines); - - println!("text=r#\"\n{}\".trim_left()", text); - assert_eq!(&text[..], &r#" - ::: foo.rs - |> -3 |> vec.push(vec.pop().unwrap()); - |> --- --- - previous borrow ends here - |> | | - |> | error occurs here - |> previous borrow of `vec` occurs here -"#[1..]); -} - -#[test] -fn elide_unnecessary_lines() { - let file_text = r#" -fn foo() { - let mut vec = vec![0, 1, 2]; - let mut vec2 = vec; - vec2.push(3); - vec2.push(4); - vec2.push(5); - vec2.push(6); - vec.push(7); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - let span_vec0 = cm.span_substr(&foo, file_text, "vec", 3); - let span_vec1 = cm.span_substr(&foo, file_text, "vec", 8); - - let mut snippet = SnippetData::new(cm, None); - snippet.push(span_vec0, false, Some(format!("`vec` moved here because it \ - has type `collections::vec::Vec`"))); - snippet.push(span_vec1, false, Some(format!("use of moved value: `vec`"))); - - let lines = snippet.render_lines(); - println!("{:#?}", lines); - let text: String = make_string(&lines); - println!("text=r#\"\n{}\".trim_left()", text); - assert_eq!(&text[..], &r#" - ::: foo.rs - |> -4 |> let mut vec2 = vec; - |> --- `vec` moved here because it has type `collections::vec::Vec` -... -9 |> vec.push(7); - |> --- use of moved value: `vec` -"#[1..]); -} - -#[test] -fn spans_without_labels() { - let file_text = r#" -fn foo() { - let mut vec = vec![0, 1, 2]; - let mut vec2 = vec; - vec2.push(3); - vec2.push(4); - vec2.push(5); - vec2.push(6); - vec.push(7); -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - - let mut snippet = SnippetData::new(cm.clone(), None); - for i in 0..4 { - let span_veci = cm.span_substr(&foo, file_text, "vec", i); - snippet.push(span_veci, false, None); - } - - let lines = snippet.render_lines(); - let text: String = make_string(&lines); - println!("text=&r#\"\n{}\n\"#[1..]", text); - assert_eq!(text, &r#" - ::: foo.rs - |> -3 |> let mut vec = vec![0, 1, 2]; - |> --- --- -4 |> let mut vec2 = vec; - |> --- --- -"#[1..]); -} - -#[test] -fn span_long_selection() { - let file_text = r#" -impl SomeTrait for () { - fn foo(x: u32) { - // impl 1 - // impl 2 - // impl 3 - } -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - - let mut snippet = SnippetData::new(cm.clone(), None); - let fn_span = cm.span_substr(&foo, file_text, "fn", 0); - let rbrace_span = cm.span_substr(&foo, file_text, "}", 0); - snippet.push(splice(fn_span, rbrace_span), false, None); - let lines = snippet.render_lines(); - let text: String = make_string(&lines); - println!("r#\"\n{}\"", text); - assert_eq!(text, &r#" - ::: foo.rs - |> -3 |> fn foo(x: u32) { - |> - -"#[1..]); -} - -#[test] -fn span_overlap_label() { - // Test that we don't put `x_span` to the right of its highlight, - // since there is another highlight that overlaps it. - - let file_text = r#" - fn foo(x: u32) { - } -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - - let mut snippet = SnippetData::new(cm.clone(), None); - let fn_span = cm.span_substr(&foo, file_text, "fn foo(x: u32)", 0); - let x_span = cm.span_substr(&foo, file_text, "x", 0); - snippet.push(fn_span, false, Some(format!("fn_span"))); - snippet.push(x_span, false, Some(format!("x_span"))); - let lines = snippet.render_lines(); - let text: String = make_string(&lines); - println!("r#\"\n{}\"", text); - assert_eq!(text, &r#" - ::: foo.rs - |> -2 |> fn foo(x: u32) { - |> -------------- - |> | | - |> | x_span - |> fn_span -"#[1..]); -} - -#[test] -fn span_overlap_label2() { - // Test that we don't put `x_span` to the right of its highlight, - // since there is another highlight that overlaps it. In this - // case, the overlap is only at the beginning, but it's still - // better to show the beginning more clearly. - - let file_text = r#" - fn foo(x: u32) { - } -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - - let mut snippet = SnippetData::new(cm.clone(), None); - let fn_span = cm.span_substr(&foo, file_text, "fn foo(x", 0); - let x_span = cm.span_substr(&foo, file_text, "x: u32)", 0); - snippet.push(fn_span, false, Some(format!("fn_span"))); - snippet.push(x_span, false, Some(format!("x_span"))); - let lines = snippet.render_lines(); - let text: String = make_string(&lines); - println!("r#\"\n{}\"", text); - assert_eq!(text, &r#" - ::: foo.rs - |> -2 |> fn foo(x: u32) { - |> -------------- - |> | | - |> | x_span - |> fn_span -"#[1..]); -} - -#[test] -fn span_overlap_label3() { - // Test that we don't put `x_span` to the right of its highlight, - // since there is another highlight that overlaps it. In this - // case, the overlap is only at the beginning, but it's still - // better to show the beginning more clearly. - - let file_text = r#" - fn foo() { - let closure = || { - inner - }; - } -} -"#; - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - - let mut snippet = SnippetData::new(cm.clone(), None); - - let closure_span = { - let closure_start_span = cm.span_substr(&foo, file_text, "||", 0); - let closure_end_span = cm.span_substr(&foo, file_text, "}", 0); - splice(closure_start_span, closure_end_span) - }; - - let inner_span = cm.span_substr(&foo, file_text, "inner", 0); - - snippet.push(closure_span, false, Some(format!("foo"))); - snippet.push(inner_span, false, Some(format!("bar"))); - - let lines = snippet.render_lines(); - let text: String = make_string(&lines); - println!("r#\"\n{}\"", text); - assert_eq!(text, &r#" - ::: foo.rs - |> -3 |> let closure = || { - |> - foo -4 |> inner - |> ----- bar -"#[1..]); -} - -#[test] -fn span_empty() { - // In one of the unit tests, we found that the parser sometimes - // gives empty spans, and in particular it supplied an EOF span - // like this one, which points at the very end. We want to - // fallback gracefully in this case. - - let file_text = r#" -fn main() { - struct Foo; - - impl !Sync for Foo {} - - unsafe impl Send for &'static Foo { - // error: cross-crate traits with a default impl, like `core::marker::Send`, - // can only be implemented for a struct/enum type, not - // `&'static Foo` -}"#; - - - let cm = Rc::new(CodeMap::new()); - let foo = cm.new_filemap_and_lines("foo.rs", None, file_text); - - let mut rbrace_span = cm.span_substr(&foo, file_text, "}", 1); - rbrace_span.lo = rbrace_span.hi; - - let mut snippet = SnippetData::new(cm.clone(), Some(rbrace_span)); - snippet.push(rbrace_span, false, None); - let lines = snippet.render_lines(); - let text: String = make_string(&lines); - println!("r#\"\n{}\"", text); - assert_eq!(text, &r#" - --> foo.rs:11:2 - |> -11 |> } - |> - -"#[1..]); -} diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index f2a005573d561..d760980b96f61 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -13,8 +13,8 @@ pub use self::SyntaxExtension::*; use ast; use ast::{Name, PatKind}; use attr::HasAttrs; -use codemap; -use codemap::{CodeMap, Span, ExpnId, ExpnInfo, NO_EXPANSION}; +use codemap::{self, CodeMap, ExpnInfo}; +use syntax_pos::{Span, ExpnId, NO_EXPANSION}; use errors::DiagnosticBuilder; use ext; use ext::expand; diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index 3a1cdae9bfbd0..abcfadf5630ef 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -11,7 +11,8 @@ use abi::Abi; use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp, PatKind}; use attr; -use codemap::{Span, respan, Spanned, DUMMY_SP, Pos}; +use syntax_pos::{Span, DUMMY_SP, Pos}; +use codemap::{respan, Spanned}; use ext::base::ExtCtxt; use parse::token::{self, keywords, InternedString}; use ptr::P; diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 5beb49372077e..aa5fe4fe2fa18 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -18,8 +18,8 @@ use ext::mtwt; use ext::build::AstBuilder; use attr; use attr::{AttrMetaMethods, WithAttrs, ThinAttributesExt}; -use codemap; -use codemap::{Span, Spanned, ExpnInfo, ExpnId, NameAndSpan, MacroBang, MacroAttribute}; +use codemap::{Spanned, ExpnInfo, NameAndSpan, MacroBang, MacroAttribute}; +use syntax_pos::{self, Span, ExpnId}; use config::StripUnconfigured; use ext::base::*; use feature_gate::{self, Features}; @@ -1040,7 +1040,7 @@ impl<'a, 'b> Folder for MacroExpander<'a, 'b> { result = expand_item(item, self); self.pop_mod_path(); } else { - let filename = if inner != codemap::DUMMY_SP { + let filename = if inner != syntax_pos::DUMMY_SP { Some(self.cx.parse_sess.codemap().span_to_filename(inner)) } else { None }; let orig_filename = replace(&mut self.cx.filename, filename); @@ -1229,7 +1229,7 @@ mod tests { use super::{PatIdentFinder, IdentRenamer, PatIdentRenamer, ExpansionConfig}; use ast; use ast::Name; - use codemap; + use syntax_pos; use ext::base::{ExtCtxt, DummyMacroLoader}; use ext::mtwt; use fold::Folder; @@ -1271,7 +1271,7 @@ mod tests { } impl<'v> Visitor<'v> for IdentFinder { - fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){ + fn visit_ident(&mut self, _: syntax_pos::Span, id: ast::Ident){ self.ident_accumulator.push(id); } } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 871b0d4b1c023..db22eb7901cd4 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -9,7 +9,7 @@ // except according to those terms. use ast::{self, Arg, Arm, Block, Expr, Item, Pat, Stmt, TokenTree, Ty}; -use codemap::Span; +use syntax_pos::Span; use ext::base::ExtCtxt; use ext::base; use ext::build::AstBuilder; @@ -36,7 +36,8 @@ pub mod rt { use ast::TokenTree; pub use parse::new_parser_from_tts; - pub use codemap::{BytePos, Span, dummy_spanned, DUMMY_SP}; + pub use syntax_pos::{BytePos, Span, DUMMY_SP}; + pub use codemap::{dummy_spanned}; pub trait ToTokens { fn to_tokens(&self, _cx: &ExtCtxt) -> Vec; diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index fd229d77966b7..a9b90dcbb7c28 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -9,8 +9,7 @@ // except according to those terms. use ast; -use codemap::{Pos, Span}; -use codemap; +use syntax_pos::{self, Pos, Span}; use ext::base::*; use ext::base; use ext::build::AstBuilder; @@ -194,7 +193,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) // resolve a file-system path to an absolute file-system path (if it // isn't already) -fn res_rel_file(cx: &mut ExtCtxt, sp: codemap::Span, arg: &Path) -> PathBuf { +fn res_rel_file(cx: &mut ExtCtxt, sp: syntax_pos::Span, arg: &Path) -> PathBuf { // NB: relative paths are resolved relative to the compilation unit if !arg.is_absolute() { let mut cu = PathBuf::from(&cx.codemap().span_to_filename(sp)); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index ca5eb8f8003bb..2230da10552e7 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -80,8 +80,8 @@ use self::TokenTreeOrTokenTreeVec::*; use ast; use ast::{TokenTree, Name, Ident}; -use codemap::{BytePos, mk_sp, Span, Spanned}; -use codemap; +use syntax_pos::{self, BytePos, mk_sp, Span}; +use codemap::Spanned; use errors::FatalError; use parse::lexer::*; //resolve bug? use parse::ParseSess; @@ -196,7 +196,7 @@ pub fn initial_matcher_pos(ms: Rc>, sep: Option, lo: ByteP /// token tree it was derived from. pub enum NamedMatch { - MatchedSeq(Vec>, codemap::Span), + MatchedSeq(Vec>, syntax_pos::Span), MatchedNonterminal(Nonterminal) } @@ -204,7 +204,7 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc]) -> ParseResult>> { fn n_rec(p_s: &ParseSess, m: &TokenTree, res: &[Rc], ret_val: &mut HashMap>, idx: &mut usize) - -> Result<(), (codemap::Span, String)> { + -> Result<(), (syntax_pos::Span, String)> { match *m { TokenTree::Sequence(_, ref seq) => { for next_m in &seq.tts { @@ -251,9 +251,9 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc]) pub enum ParseResult { Success(T), /// Arm failed to match - Failure(codemap::Span, String), + Failure(syntax_pos::Span, String), /// Fatal error (malformed macro?). Abort compilation. - Error(codemap::Span, String) + Error(syntax_pos::Span, String) } pub type NamedParseResult = ParseResult>>; diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index bbe989b0f40ab..a21c9eb76545f 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -9,7 +9,7 @@ // except according to those terms. use ast::{self, TokenTree}; -use codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use ext::base::{DummyResult, ExtCtxt, MacResult, SyntaxExtension}; use ext::base::{NormalTT, TTMacroExpander}; use ext::tt::macro_parser::{Success, Error, Failure}; diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 6b3b5ce9de914..8b5ecd10fcb6f 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -11,7 +11,7 @@ use self::LockstepIterSize::*; use ast; use ast::{TokenTree, Ident, Name}; -use codemap::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP}; use errors::{Handler, DiagnosticBuilder}; use ext::tt::macro_parser::{NamedMatch, MatchedSeq, MatchedNonterminal}; use parse::token::{DocComment, MatchNt, SubstNt}; diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 550eb0a56d98c..bb72dadcaf635 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -30,10 +30,10 @@ use ast::{NodeId, PatKind}; use ast; use attr; use attr::AttrMetaMethods; -use codemap::{CodeMap, Span}; +use codemap::CodeMap; +use syntax_pos::Span; use errors::Handler; -use visit; -use visit::{FnKind, Visitor}; +use visit::{self, FnKind, Visitor}; use parse::ParseSess; use parse::token::InternedString; diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index edf418e33325b..69c3cd5c59268 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -21,7 +21,8 @@ use ast::*; use ast; use attr::{ThinAttributes, ThinAttributesExt}; -use codemap::{respan, Span, Spanned}; +use syntax_pos::Span; +use codemap::{Spanned, respan}; use parse::token::{self, keywords}; use ptr::P; use util::small_vector::SmallVector; diff --git a/src/libsyntax/errors/json.rs b/src/libsyntax/json.rs similarity index 97% rename from src/libsyntax/errors/json.rs rename to src/libsyntax/json.rs index 93c6268ccaea1..dc9a5ee46645f 100644 --- a/src/libsyntax/errors/json.rs +++ b/src/libsyntax/json.rs @@ -19,10 +19,10 @@ // FIXME spec the JSON output properly. - -use codemap::{self, MacroBacktrace, Span, SpanLabel, MultiSpan, CodeMap}; -use diagnostics::registry::Registry; -use errors::{Level, DiagnosticBuilder, SubDiagnostic, RenderSpan, CodeSuggestion}; +use codemap::CodeMap; +use syntax_pos::{self, MacroBacktrace, Span, SpanLabel, MultiSpan}; +use errors::registry::Registry; +use errors::{Level, DiagnosticBuilder, SubDiagnostic, RenderSpan, CodeSuggestion, CodeMapper}; use errors::emitter::Emitter; use std::rc::Rc; @@ -34,7 +34,7 @@ use rustc_serialize::json::as_json; pub struct JsonEmitter { dst: Box, registry: Option, - cm: Rc, + cm: Rc, } impl JsonEmitter { @@ -303,7 +303,7 @@ impl DiagnosticSpan { } impl DiagnosticSpanLine { - fn line_from_filemap(fm: &codemap::FileMap, + fn line_from_filemap(fm: &syntax_pos::FileMap, index: usize, h_start: usize, h_end: usize) @@ -354,12 +354,14 @@ impl DiagnosticCode { impl JsonEmitter { fn render(&self, render_span: &RenderSpan) -> Option { + use std::borrow::Borrow; + match *render_span { RenderSpan::FullSpan(_) => { None } RenderSpan::Suggestion(ref suggestion) => { - Some(suggestion.splice_lines(&self.cm)) + Some(suggestion.splice_lines(self.cm.borrow())) } } } diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 420a41e03b914..ae61801c65bb8 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -33,7 +33,6 @@ #![feature(str_escape)] #![feature(unicode)] #![feature(question_mark)] -#![feature(range_contains)] extern crate serialize; extern crate term; @@ -41,9 +40,12 @@ extern crate libc; #[macro_use] extern crate log; #[macro_use] #[no_link] extern crate rustc_bitflags; extern crate rustc_unicode; +pub extern crate rustc_errors as errors; +extern crate syntax_pos; extern crate serialize as rustc_serialize; // used by deriving + // A variant of 'try!' that panics on an Err. This is used as a crutch on the // way towards a non-panic!-prone parser. It should be used for fatal parsing // errors; eventually we plan to convert all code using panictry to just use @@ -53,7 +55,7 @@ extern crate serialize as rustc_serialize; // used by deriving macro_rules! panictry { ($e:expr) => ({ use std::result::Result::{Ok, Err}; - use $crate::errors::FatalError; + use errors::FatalError; match $e { Ok(e) => e, Err(mut e) => { @@ -78,11 +80,10 @@ pub mod util { pub mod diagnostics { pub mod macros; pub mod plugin; - pub mod registry; pub mod metadata; } -pub mod errors; +pub mod json; pub mod syntax { pub use ext; diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index db643eb0df07a..f6e94b7caeabe 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -10,7 +10,8 @@ use attr; use ast; -use codemap::{spanned, Spanned, mk_sp, Span}; +use syntax_pos::{mk_sp, Span}; +use codemap::{spanned, Spanned}; use parse::common::SeqSep; use parse::PResult; use parse::token; diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index 06d255d5c0f92..5eb5605ea71a0 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -11,7 +11,8 @@ pub use self::CommentStyle::*; use ast; -use codemap::{BytePos, CharPos, CodeMap, Pos}; +use codemap::CodeMap; +use syntax_pos::{BytePos, CharPos, Pos}; use errors; use parse::lexer::is_block_doc_comment; use parse::lexer::{StringReader, TokenAndSpan}; diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index d78a81dec83db..809f4daa3616d 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -9,8 +9,8 @@ // except according to those terms. use ast; -use codemap::{BytePos, CharPos, CodeMap, Pos, Span}; -use codemap; +use syntax_pos::{self, BytePos, CharPos, Pos, Span}; +use codemap::CodeMap; use errors::{FatalError, Handler, DiagnosticBuilder}; use ext::tt::transcribe::tt_next_token; use parse::token::{self, keywords, str_to_ident}; @@ -84,7 +84,7 @@ pub struct StringReader<'a> { pub col: CharPos, /// The last character to be read pub curr: Option, - pub filemap: Rc, + pub filemap: Rc, // cached: pub peek_tok: token::Token, pub peek_span: Span, @@ -162,7 +162,7 @@ impl<'a> Reader for TtReader<'a> { impl<'a> StringReader<'a> { /// For comments.rs, which hackily pokes into pos and curr pub fn new_raw<'b>(span_diagnostic: &'b Handler, - filemap: Rc) + filemap: Rc) -> StringReader<'b> { if filemap.src.is_none() { span_diagnostic.bug(&format!("Cannot lex filemap \ @@ -181,7 +181,7 @@ impl<'a> StringReader<'a> { filemap: filemap, // dummy values; not read peek_tok: token::Eof, - peek_span: codemap::DUMMY_SP, + peek_span: syntax_pos::DUMMY_SP, source_text: source_text, fatal_errs: Vec::new(), }; @@ -190,7 +190,7 @@ impl<'a> StringReader<'a> { } pub fn new<'b>(span_diagnostic: &'b Handler, - filemap: Rc) + filemap: Rc) -> StringReader<'b> { let mut sr = StringReader::new_raw(span_diagnostic, filemap); if let Err(_) = sr.advance_token() { @@ -217,12 +217,12 @@ impl<'a> StringReader<'a> { /// Report a fatal error spanning [`from_pos`, `to_pos`). fn fatal_span_(&self, from_pos: BytePos, to_pos: BytePos, m: &str) -> FatalError { - self.fatal_span(codemap::mk_sp(from_pos, to_pos), m) + self.fatal_span(syntax_pos::mk_sp(from_pos, to_pos), m) } /// Report a lexical error spanning [`from_pos`, `to_pos`). fn err_span_(&self, from_pos: BytePos, to_pos: BytePos, m: &str) { - self.err_span(codemap::mk_sp(from_pos, to_pos), m) + self.err_span(syntax_pos::mk_sp(from_pos, to_pos), m) } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending an @@ -246,7 +246,7 @@ impl<'a> StringReader<'a> { for c in c.escape_default() { m.push(c) } - self.span_diagnostic.struct_span_fatal(codemap::mk_sp(from_pos, to_pos), &m[..]) + self.span_diagnostic.struct_span_fatal(syntax_pos::mk_sp(from_pos, to_pos), &m[..]) } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending an @@ -270,7 +270,7 @@ impl<'a> StringReader<'a> { for c in c.escape_default() { m.push(c) } - self.span_diagnostic.struct_span_err(codemap::mk_sp(from_pos, to_pos), &m[..]) + self.span_diagnostic.struct_span_err(syntax_pos::mk_sp(from_pos, to_pos), &m[..]) } /// Report a lexical error spanning [`from_pos`, `to_pos`), appending the @@ -294,11 +294,11 @@ impl<'a> StringReader<'a> { None => { if self.is_eof() { self.peek_tok = token::Eof; - self.peek_span = codemap::mk_sp(self.filemap.end_pos, self.filemap.end_pos); + self.peek_span = syntax_pos::mk_sp(self.filemap.end_pos, self.filemap.end_pos); } else { let start_bytepos = self.last_pos; self.peek_tok = self.next_token_inner()?; - self.peek_span = codemap::mk_sp(start_bytepos, self.last_pos); + self.peek_span = syntax_pos::mk_sp(start_bytepos, self.last_pos); }; } } @@ -473,7 +473,7 @@ impl<'a> StringReader<'a> { match self.curr { Some(c) => { if c.is_whitespace() { - self.span_diagnostic.span_err(codemap::mk_sp(self.last_pos, self.last_pos), + self.span_diagnostic.span_err(syntax_pos::mk_sp(self.last_pos, self.last_pos), "called consume_any_line_comment, but there \ was whitespace"); } @@ -524,13 +524,13 @@ impl<'a> StringReader<'a> { Some(TokenAndSpan { tok: tok, - sp: codemap::mk_sp(start_bpos, self.last_pos), + sp: syntax_pos::mk_sp(start_bpos, self.last_pos), }) }) } else { Some(TokenAndSpan { tok: token::Comment, - sp: codemap::mk_sp(start_bpos, self.last_pos), + sp: syntax_pos::mk_sp(start_bpos, self.last_pos), }) }; } @@ -563,7 +563,7 @@ impl<'a> StringReader<'a> { } return Some(TokenAndSpan { tok: token::Shebang(self.name_from(start)), - sp: codemap::mk_sp(start, self.last_pos), + sp: syntax_pos::mk_sp(start, self.last_pos), }); } } @@ -591,7 +591,7 @@ impl<'a> StringReader<'a> { } let c = Some(TokenAndSpan { tok: token::Whitespace, - sp: codemap::mk_sp(start_bpos, self.last_pos), + sp: syntax_pos::mk_sp(start_bpos, self.last_pos), }); debug!("scanning whitespace: {:?}", c); c @@ -653,7 +653,7 @@ impl<'a> StringReader<'a> { Some(TokenAndSpan { tok: tok, - sp: codemap::mk_sp(start_bpos, self.last_pos), + sp: syntax_pos::mk_sp(start_bpos, self.last_pos), }) }) } @@ -850,7 +850,7 @@ impl<'a> StringReader<'a> { let valid = if self.curr_is('{') { self.scan_unicode_escape(delim) && !ascii_only } else { - let span = codemap::mk_sp(start, self.last_pos); + let span = syntax_pos::mk_sp(start, self.last_pos); self.span_diagnostic .struct_span_err(span, "incorrect unicode escape sequence") .span_help(span, @@ -888,13 +888,13 @@ impl<'a> StringReader<'a> { }, c); if e == '\r' { - err.span_help(codemap::mk_sp(escaped_pos, last_pos), + err.span_help(syntax_pos::mk_sp(escaped_pos, last_pos), "this is an isolated carriage return; consider \ checking your editor and version control \ settings"); } if (e == '{' || e == '}') && !ascii_only { - err.span_help(codemap::mk_sp(escaped_pos, last_pos), + err.span_help(syntax_pos::mk_sp(escaped_pos, last_pos), "if used in a formatting string, curly braces \ are escaped with `{{` and `}}`"); } @@ -1677,7 +1677,8 @@ fn ident_continue(c: Option) -> bool { mod tests { use super::*; - use codemap::{BytePos, CodeMap, Span, NO_EXPANSION}; + use syntax_pos::{BytePos, Span, NO_EXPANSION}; + use codemap::CodeMap; use errors; use parse::token; use parse::token::str_to_ident; @@ -1686,7 +1687,10 @@ mod tests { fn mk_sh(cm: Rc) -> errors::Handler { // FIXME (#22405): Replace `Box::new` with `box` here when/if possible. - let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()), None, cm); + let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()), + None, + cm, + errors::snippet::FormatMode::EnvironmentSelected); errors::Handler::with_emitter(true, false, Box::new(emitter)) } @@ -1889,7 +1893,7 @@ mod tests { let mut lexer = setup(&cm, &sh, "// test\r\n/// test\r\n".to_string()); let comment = lexer.next_token(); assert_eq!(comment.tok, token::Comment); - assert_eq!(comment.sp, ::codemap::mk_sp(BytePos(0), BytePos(7))); + assert_eq!(comment.sp, ::syntax_pos::mk_sp(BytePos(0), BytePos(7))); assert_eq!(lexer.next_token().tok, token::Whitespace); assert_eq!(lexer.next_token().tok, token::DocComment(token::intern("/// test"))); diff --git a/src/libsyntax/parse/lexer/unicode_chars.rs b/src/libsyntax/parse/lexer/unicode_chars.rs index d337c78bee8b5..dab97d1d5a6ff 100644 --- a/src/libsyntax/parse/lexer/unicode_chars.rs +++ b/src/libsyntax/parse/lexer/unicode_chars.rs @@ -11,7 +11,7 @@ // Characters and their corresponding confusables were collected from // http://www.unicode.org/Public/security/revision-06/confusables.txt -use codemap::mk_sp as make_span; +use syntax_pos::mk_sp as make_span; use errors::DiagnosticBuilder; use super::StringReader; diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 2e4d46bc98318..0796f298be1a1 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -11,7 +11,8 @@ //! The main parser interface use ast; -use codemap::{self, Span, CodeMap, FileMap}; +use codemap::CodeMap; +use syntax_pos::{self, Span, FileMap}; use errors::{Handler, ColorConfig, DiagnosticBuilder}; use parse::parser::Parser; use parse::token::InternedString; @@ -211,8 +212,8 @@ pub fn filemap_to_parser<'a>(sess: &'a ParseSess, let end_pos = filemap.end_pos; let mut parser = tts_to_parser(sess, filemap_to_tts(sess, filemap), cfg); - if parser.token == token::Eof && parser.span == codemap::DUMMY_SP { - parser.span = codemap::mk_sp(end_pos, end_pos); + if parser.token == token::Eof && parser.span == syntax_pos::DUMMY_SP { + parser.span = syntax_pos::mk_sp(end_pos, end_pos); } parser @@ -661,7 +662,8 @@ pub fn integer_lit(s: &str, mod tests { use super::*; use std::rc::Rc; - use codemap::{Span, BytePos, Pos, Spanned, NO_EXPANSION}; + use syntax_pos::{Span, BytePos, Pos, NO_EXPANSION}; + use codemap::Spanned; use ast::{self, TokenTree, PatKind}; use abi::Abi; use attr::{first_attr_value_str_by_name, AttrMetaMethods}; @@ -673,7 +675,7 @@ mod tests { use util::parser_testing::{string_to_tts, string_to_parser}; use util::parser_testing::{string_to_expr, string_to_item, string_to_stmt}; - // produce a codemap::span + // produce a syntax_pos::span fn sp(a: u32, b: u32) -> Span { Span {lo: BytePos(a), hi: BytePos(b), expn_id: NO_EXPANSION} } diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 75f1ac49c9acc..a1d7ddcdf4bdf 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -13,7 +13,7 @@ //! //! Obsolete syntax that becomes too hard to parse can be removed. -use codemap::Span; +use syntax_pos::Span; use parse::parser; /// The specific types of unsupported syntax diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 341b076e7cf30..a8597c99a569c 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -40,7 +40,8 @@ use ast::{Visibility, WhereClause}; use attr::{ThinAttributes, ThinAttributesExt, AttributesExt}; use ast::{BinOpKind, UnOp}; use ast; -use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, CodeMap}; +use codemap::{self, CodeMap, Spanned, spanned}; +use syntax_pos::{self, Span, BytePos, mk_sp}; use errors::{self, DiagnosticBuilder}; use ext::tt::macro_parser; use parse; @@ -344,7 +345,7 @@ impl<'a> Parser<'a> { { let tok0 = rdr.real_token(); let span = tok0.sp; - let filename = if span != codemap::DUMMY_SP { + let filename = if span != syntax_pos::DUMMY_SP { Some(sess.codemap().span_to_filename(span)) } else { None }; let placeholder = TokenAndSpan { @@ -3500,7 +3501,7 @@ impl<'a> Parser<'a> { } /// Parse the fields of a struct-like pattern - fn parse_pat_fields(&mut self) -> PResult<'a, (Vec> , bool)> { + fn parse_pat_fields(&mut self) -> PResult<'a, (Vec>, bool)> { let mut fields = Vec::new(); let mut etc = false; let mut first = true; @@ -3570,9 +3571,9 @@ impl<'a> Parser<'a> { }; fields.push(codemap::Spanned { span: mk_sp(lo, hi), - node: ast::FieldPat { ident: fieldname, - pat: subpat, - is_shorthand: is_shorthand }}); + node: ast::FieldPat { ident: fieldname, + pat: subpat, + is_shorthand: is_shorthand }}); } return Ok((fields, etc)); } @@ -3663,7 +3664,7 @@ impl<'a> Parser<'a> { SeqSep::none(), |p| p.parse_token_tree())?; let mac = Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT }; pat = PatKind::Mac(codemap::Spanned {node: mac, - span: mk_sp(lo, self.last_span.hi)}); + span: mk_sp(lo, self.last_span.hi)}); } else { // Parse ident @ pat // This can give false positives and parse nullary enums, @@ -4915,8 +4916,8 @@ impl<'a> Parser<'a> { |p| p.parse_token_tree())?; let m_ = Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT }; let m: ast::Mac = codemap::Spanned { node: m_, - span: mk_sp(lo, - self.last_span.hi) }; + span: mk_sp(lo, + self.last_span.hi) }; if delim != token::Brace { self.expect(&token::Semi)? } @@ -5255,7 +5256,7 @@ impl<'a> Parser<'a> { return Err(self.fatal(&format!("expected item, found `{}`", token_str))); } - let hi = if self.span == codemap::DUMMY_SP { + let hi = if self.span == syntax_pos::DUMMY_SP { inner_lo } else { self.last_span.hi @@ -6001,8 +6002,8 @@ impl<'a> Parser<'a> { // single-variant-enum... : let m = Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT }; let m: ast::Mac = codemap::Spanned { node: m, - span: mk_sp(mac_lo, - self.last_span.hi) }; + span: mk_sp(mac_lo, + self.last_span.hi) }; if delim != token::Brace { if !self.eat(&token::Semi) { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index a2ee5bf609053..d254d3a71cf79 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -18,7 +18,8 @@ use attr::ThinAttributesExt; use util::parser::AssocOp; use attr; use attr::{AttrMetaMethods, AttributeMethods}; -use codemap::{self, CodeMap, BytePos}; +use codemap::{self, CodeMap}; +use syntax_pos::{self, BytePos}; use errors; use parse::token::{self, keywords, BinOpToken, Token, InternedString}; use parse::lexer::comments; @@ -842,11 +843,11 @@ impl<'a> State<'a> { self.end() // close the head-box } - pub fn bclose_(&mut self, span: codemap::Span, + pub fn bclose_(&mut self, span: syntax_pos::Span, indented: usize) -> io::Result<()> { self.bclose_maybe_open(span, indented, true) } - pub fn bclose_maybe_open(&mut self, span: codemap::Span, + pub fn bclose_maybe_open(&mut self, span: syntax_pos::Span, indented: usize, close_box: bool) -> io::Result<()> { try!(self.maybe_print_comment(span.hi)); try!(self.break_offset_if_not_bol(1, -(indented as isize))); @@ -856,7 +857,7 @@ impl<'a> State<'a> { } Ok(()) } - pub fn bclose(&mut self, span: codemap::Span) -> io::Result<()> { + pub fn bclose(&mut self, span: syntax_pos::Span) -> io::Result<()> { self.bclose_(span, INDENT_UNIT) } @@ -900,7 +901,7 @@ impl<'a> State<'a> { mut op: F, mut get_span: G) -> io::Result<()> where F: FnMut(&mut State, &T) -> io::Result<()>, - G: FnMut(&T) -> codemap::Span, + G: FnMut(&T) -> syntax_pos::Span, { try!(self.rbox(0, b)); let len = elts.len(); @@ -1352,7 +1353,7 @@ impl<'a> State<'a> { pub fn print_enum_def(&mut self, enum_definition: &ast::EnumDef, generics: &ast::Generics, ident: ast::Ident, - span: codemap::Span, + span: syntax_pos::Span, visibility: &ast::Visibility) -> io::Result<()> { try!(self.head(&visibility_qualified(visibility, "enum"))); try!(self.print_ident(ident)); @@ -1364,7 +1365,7 @@ impl<'a> State<'a> { pub fn print_variants(&mut self, variants: &[ast::Variant], - span: codemap::Span) -> io::Result<()> { + span: syntax_pos::Span) -> io::Result<()> { try!(self.bopen()); for v in variants { try!(self.space_if_not_bol()); @@ -1393,7 +1394,7 @@ impl<'a> State<'a> { struct_def: &ast::VariantData, generics: &ast::Generics, ident: ast::Ident, - span: codemap::Span, + span: syntax_pos::Span, print_finalizer: bool) -> io::Result<()> { try!(self.print_ident(ident)); try!(self.print_generics(generics)); @@ -2999,7 +3000,7 @@ impl<'a> State<'a> { self.end() } - pub fn maybe_print_trailing_comment(&mut self, span: codemap::Span, + pub fn maybe_print_trailing_comment(&mut self, span: syntax_pos::Span, next_pos: Option) -> io::Result<()> { let cm = match self.cm { @@ -3104,6 +3105,7 @@ mod tests { use ast; use codemap; use parse::token; + use syntax_pos; #[test] fn test_fun_to_string() { @@ -3111,7 +3113,7 @@ mod tests { let decl = ast::FnDecl { inputs: Vec::new(), - output: ast::FunctionRetTy::Default(codemap::DUMMY_SP), + output: ast::FunctionRetTy::Default(syntax_pos::DUMMY_SP), variadic: false }; let generics = ast::Generics::default(); @@ -3125,7 +3127,7 @@ mod tests { fn test_variant_to_string() { let ident = token::str_to_ident("principal_skinner"); - let var = codemap::respan(codemap::DUMMY_SP, ast::Variant_ { + let var = codemap::respan(syntax_pos::DUMMY_SP, ast::Variant_ { name: ident, attrs: Vec::new(), // making this up as I go.... ? diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index 8834c026067c8..d1454ab06cbc8 100644 --- a/src/libsyntax/std_inject.rs +++ b/src/libsyntax/std_inject.rs @@ -10,8 +10,8 @@ use ast; use attr; -use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute}; -use codemap; +use syntax_pos::{DUMMY_SP, Span}; +use codemap::{self, ExpnInfo, NameAndSpan, MacroAttribute}; use parse::token::{intern, InternedString, keywords}; use parse::{token, ParseSess}; use ptr::P; diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index ca6ed76d5499b..cc3fff09617f4 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -12,6 +12,7 @@ #![allow(dead_code)] #![allow(unused_imports)] + use self::HasTestSignature::*; use std::iter; @@ -20,9 +21,12 @@ use std::mem; use std::vec; use attr::AttrMetaMethods; use attr; -use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute}; -use codemap; +use syntax_pos::{self, DUMMY_SP, NO_EXPANSION, Span, FileMap, BytePos}; +use std::rc::Rc; + +use codemap::{self, CodeMap, ExpnInfo, NameAndSpan, MacroAttribute}; use errors; +use errors::snippet::{RenderedLine, SnippetData}; use config; use entry::{self, EntryPointType}; use ext::base::{ExtCtxt, DummyMacroLoader}; diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs index 919dd84b11799..ad6145f86183a 100644 --- a/src/libsyntax/util/node_count.rs +++ b/src/libsyntax/util/node_count.rs @@ -12,7 +12,7 @@ use visit::*; use ast::*; -use codemap::Span; +use syntax_pos::Span; pub struct NodeCounter { pub count: usize, diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 07a6317706b84..b98f88d632ba8 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -26,7 +26,8 @@ use abi::Abi; use ast::*; use attr::ThinAttributesExt; -use codemap::{Span, Spanned}; +use syntax_pos::Span; +use codemap::Spanned; #[derive(Copy, Clone, PartialEq, Eq)] pub enum FnKind<'a> { diff --git a/src/libsyntax_ext/Cargo.toml b/src/libsyntax_ext/Cargo.toml index 671f3e4a7e330..040c6c8ebff26 100644 --- a/src/libsyntax_ext/Cargo.toml +++ b/src/libsyntax_ext/Cargo.toml @@ -12,3 +12,5 @@ crate-type = ["dylib"] fmt_macros = { path = "../libfmt_macros" } log = { path = "../liblog" } syntax = { path = "../libsyntax" } +syntax_pos = { path = "../libsyntax_pos" } +rustc_errors = { path = "../librustc_errors" } \ No newline at end of file diff --git a/src/libsyntax_ext/asm.rs b/src/libsyntax_ext/asm.rs index 50d2b9d31fe01..a8f5171f800e8 100644 --- a/src/libsyntax_ext/asm.rs +++ b/src/libsyntax_ext/asm.rs @@ -15,7 +15,6 @@ use self::State::*; use syntax::ast; use syntax::codemap; -use syntax::codemap::Span; use syntax::ext::base; use syntax::ext::base::*; use syntax::feature_gate; @@ -23,6 +22,7 @@ use syntax::parse::token::intern; use syntax::parse::{self, token}; use syntax::ptr::P; use syntax::ast::AsmDialect; +use syntax_pos::Span; enum State { Asm, diff --git a/src/libsyntax_ext/cfg.rs b/src/libsyntax_ext/cfg.rs index 593bf14a0182f..201c9f38978f2 100644 --- a/src/libsyntax_ext/cfg.rs +++ b/src/libsyntax_ext/cfg.rs @@ -13,12 +13,12 @@ /// current compilation environment. use syntax::ast; -use syntax::codemap::Span; use syntax::ext::base::*; use syntax::ext::base; use syntax::ext::build::AstBuilder; use syntax::attr; use syntax::parse::token; +use syntax_pos::Span; pub fn expand_cfg<'cx>(cx: &mut ExtCtxt, sp: Span, diff --git a/src/libsyntax_ext/concat.rs b/src/libsyntax_ext/concat.rs index db731adf7943b..c754cb14b671f 100644 --- a/src/libsyntax_ext/concat.rs +++ b/src/libsyntax_ext/concat.rs @@ -9,15 +9,15 @@ // except according to those terms. use syntax::ast; -use syntax::codemap; use syntax::ext::base; use syntax::ext::build::AstBuilder; use syntax::parse::token; +use syntax_pos; use std::string::String; pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, - sp: codemap::Span, + sp: syntax_pos::Span, tts: &[ast::TokenTree]) -> Box { let es = match base::get_exprs_from_tts(cx, sp, tts) { diff --git a/src/libsyntax_ext/concat_idents.rs b/src/libsyntax_ext/concat_idents.rs index 09c23682cd73f..5a98925ba8234 100644 --- a/src/libsyntax_ext/concat_idents.rs +++ b/src/libsyntax_ext/concat_idents.rs @@ -9,13 +9,13 @@ // except according to those terms. use syntax::ast::{self, TokenTree}; -use syntax::codemap::Span; use syntax::ext::base::*; use syntax::ext::base; use syntax::feature_gate; use syntax::parse::token; use syntax::parse::token::str_to_ident; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[TokenTree]) -> Box { diff --git a/src/libsyntax_ext/deriving/bounds.rs b/src/libsyntax_ext/deriving/bounds.rs index 9bc0e08811071..36818e000b55b 100644 --- a/src/libsyntax_ext/deriving/bounds.rs +++ b/src/libsyntax_ext/deriving/bounds.rs @@ -12,8 +12,8 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::MetaItem; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax_pos::Span; pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs index 30fe0f2db8a1c..0071400287591 100644 --- a/src/libsyntax_ext/deriving/clone.rs +++ b/src/libsyntax_ext/deriving/clone.rs @@ -13,11 +13,11 @@ use deriving::generic::ty::*; use syntax::ast::{Expr, ItemKind, Generics, MetaItem, VariantData}; use syntax::attr; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; +use syntax_pos::Span; #[derive(PartialEq)] enum Mode { Deep, Shallow } diff --git a/src/libsyntax_ext/deriving/cmp/eq.rs b/src/libsyntax_ext/deriving/cmp/eq.rs index 8bd12c393370d..4258e152088e5 100644 --- a/src/libsyntax_ext/deriving/cmp/eq.rs +++ b/src/libsyntax_ext/deriving/cmp/eq.rs @@ -12,11 +12,11 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_eq(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/cmp/ord.rs b/src/libsyntax_ext/deriving/cmp/ord.rs index 6133adb8fc5d1..cbd7ac0eadad0 100644 --- a/src/libsyntax_ext/deriving/cmp/ord.rs +++ b/src/libsyntax_ext/deriving/cmp/ord.rs @@ -12,11 +12,11 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr, self}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_ord(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/cmp/partial_eq.rs b/src/libsyntax_ext/deriving/cmp/partial_eq.rs index e5890d7213bed..b5a8167fb5550 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_eq.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_eq.rs @@ -12,11 +12,11 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr, BinOpKind}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/cmp/partial_ord.rs b/src/libsyntax_ext/deriving/cmp/partial_ord.rs index cfc6dbe5cd030..26c14ae934f72 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_ord.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_ord.rs @@ -14,11 +14,11 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr, BinOpKind, self}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/debug.rs b/src/libsyntax_ext/deriving/debug.rs index d86eae820a884..c26a7784084a7 100644 --- a/src/libsyntax_ext/deriving/debug.rs +++ b/src/libsyntax_ext/deriving/debug.rs @@ -13,11 +13,12 @@ use deriving::generic::ty::*; use syntax::ast; use syntax::ast::{MetaItem, Expr}; -use syntax::codemap::{Span, respan, DUMMY_SP}; +use syntax::codemap::respan; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token; use syntax::ptr::P; +use syntax_pos::{Span, DUMMY_SP}; pub fn expand_deriving_debug(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/decodable.rs b/src/libsyntax_ext/deriving/decodable.rs index 04888d046ad2d..488402c48f70a 100644 --- a/src/libsyntax_ext/deriving/decodable.rs +++ b/src/libsyntax_ext/deriving/decodable.rs @@ -16,12 +16,12 @@ use deriving::generic::ty::*; use syntax::ast; use syntax::ast::{MetaItem, Expr, Mutability}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::parse::token; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_rustc_decodable(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/default.rs b/src/libsyntax_ext/deriving/default.rs index a6a4830fab7f8..2711ccba81914 100644 --- a/src/libsyntax_ext/deriving/default.rs +++ b/src/libsyntax_ext/deriving/default.rs @@ -12,11 +12,11 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_default(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/encodable.rs b/src/libsyntax_ext/deriving/encodable.rs index 66672305829b9..07a52105debe6 100644 --- a/src/libsyntax_ext/deriving/encodable.rs +++ b/src/libsyntax_ext/deriving/encodable.rs @@ -93,11 +93,11 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr, ExprKind, Mutability}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt,Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_rustc_encodable(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index d6adec84e8440..b5a9b00421037 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -197,12 +197,12 @@ use syntax::attr; use syntax::attr::AttrMetaMethods; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; -use syntax::codemap::{self, respan, DUMMY_SP}; -use syntax::codemap::Span; -use syntax::errors::Handler; +use syntax::codemap::{self, respan}; use syntax::util::move_map::MoveMap; use syntax::parse::token::{keywords, InternedString}; use syntax::ptr::P; +use syntax_pos::{Span, DUMMY_SP}; +use errors::Handler; use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty}; diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs index b581f5267eaac..626fbaada5cbf 100644 --- a/src/libsyntax_ext/deriving/generic/ty.rs +++ b/src/libsyntax_ext/deriving/generic/ty.rs @@ -18,8 +18,9 @@ use syntax::ast; use syntax::ast::{Expr, Generics, Ident, SelfKind}; use syntax::ext::base::ExtCtxt; use syntax::ext::build::AstBuilder; -use syntax::codemap::{Span,respan}; +use syntax::codemap::respan; use syntax::ptr::P; +use syntax_pos::Span; /// The types of pointers #[derive(Clone, Eq, PartialEq)] diff --git a/src/libsyntax_ext/deriving/hash.rs b/src/libsyntax_ext/deriving/hash.rs index fd449372cb376..245d3f0efa303 100644 --- a/src/libsyntax_ext/deriving/hash.rs +++ b/src/libsyntax_ext/deriving/hash.rs @@ -13,10 +13,10 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::{MetaItem, Expr, Mutability}; -use syntax::codemap::Span; use syntax::ext::base::{ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; +use syntax_pos::Span; pub fn expand_deriving_hash(cx: &mut ExtCtxt, span: Span, diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs index 6fb6dee94ed35..f9e0d2c2eaeba 100644 --- a/src/libsyntax_ext/deriving/mod.rs +++ b/src/libsyntax_ext/deriving/mod.rs @@ -16,9 +16,10 @@ use syntax::ext::base::{ExtCtxt, SyntaxEnv, Annotatable}; use syntax::ext::base::{MultiDecorator, MultiItemDecorator, MultiModifier}; use syntax::ext::build::AstBuilder; use syntax::feature_gate; -use syntax::codemap::{self, Span}; +use syntax::codemap; use syntax::parse::token::{intern, intern_and_get_ident}; use syntax::ptr::P; +use syntax_pos::Span; macro_rules! pathvec { ($($x:ident)::+) => ( diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs index 63ec9cac07317..de18153d962c4 100644 --- a/src/libsyntax_ext/env.rs +++ b/src/libsyntax_ext/env.rs @@ -15,11 +15,11 @@ */ use syntax::ast; -use syntax::codemap::Span; use syntax::ext::base::*; use syntax::ext::base; use syntax::ext::build::AstBuilder; use syntax::parse::token; +use syntax_pos::Span; use std::env; diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs index abfa65580646d..f928e577d311a 100644 --- a/src/libsyntax_ext/format.rs +++ b/src/libsyntax_ext/format.rs @@ -14,13 +14,14 @@ use self::Position::*; use fmt_macros as parse; use syntax::ast; -use syntax::codemap::{Span, respan, DUMMY_SP}; +use syntax::codemap::respan; use syntax::ext::base::*; use syntax::ext::base; use syntax::ext::build::AstBuilder; use syntax::fold::Folder; use syntax::parse::token::{self, keywords}; use syntax::ptr::P; +use syntax_pos::{Span, DUMMY_SP}; use std::collections::HashMap; diff --git a/src/libsyntax_ext/lib.rs b/src/libsyntax_ext/lib.rs index 8f5362b4d2895..17b200bac58c5 100644 --- a/src/libsyntax_ext/lib.rs +++ b/src/libsyntax_ext/lib.rs @@ -26,6 +26,8 @@ extern crate fmt_macros; #[macro_use] extern crate log; #[macro_use] extern crate syntax; +extern crate syntax_pos; +extern crate rustc_errors as errors; use syntax::ext::base::{MacroExpanderFn, NormalTT}; use syntax::ext::base::{SyntaxEnv, SyntaxExtension}; diff --git a/src/libsyntax_ext/log_syntax.rs b/src/libsyntax_ext/log_syntax.rs index ee944abb645dc..a84dc9d619fe9 100644 --- a/src/libsyntax_ext/log_syntax.rs +++ b/src/libsyntax_ext/log_syntax.rs @@ -9,13 +9,13 @@ // except according to those terms. use syntax::ast; -use syntax::codemap; use syntax::ext::base; use syntax::feature_gate; use syntax::print; +use syntax_pos; pub fn expand_syntax_ext<'cx>(cx: &'cx mut base::ExtCtxt, - sp: codemap::Span, + sp: syntax_pos::Span, tts: &[ast::TokenTree]) -> Box { if !cx.ecfg.enable_log_syntax() { diff --git a/src/libsyntax_ext/trace_macros.rs b/src/libsyntax_ext/trace_macros.rs index 7b1e985442adb..13892d53092d4 100644 --- a/src/libsyntax_ext/trace_macros.rs +++ b/src/libsyntax_ext/trace_macros.rs @@ -9,12 +9,11 @@ // except according to those terms. use syntax::ast::TokenTree; -use syntax::codemap::Span; use syntax::ext::base::ExtCtxt; use syntax::ext::base; use syntax::feature_gate; use syntax::parse::token::keywords; - +use syntax_pos::Span; pub fn expand_trace_macros(cx: &mut ExtCtxt, sp: Span, diff --git a/src/libsyntax_pos/Cargo.toml b/src/libsyntax_pos/Cargo.toml new file mode 100644 index 0000000000000..760aaa8a95784 --- /dev/null +++ b/src/libsyntax_pos/Cargo.toml @@ -0,0 +1,12 @@ +[package] +authors = ["The Rust Project Developers"] +name = "syntax_pos" +version = "0.0.0" + +[lib] +name = "syntax_pos" +path = "lib.rs" +crate-type = ["dylib"] + +[dependencies] +serialize = { path = "../libserialize" } diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs new file mode 100644 index 0000000000000..39bb5956312bc --- /dev/null +++ b/src/libsyntax_pos/lib.rs @@ -0,0 +1,667 @@ +// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! The source positions and related helper functions +//! +//! # Note +//! +//! This API is completely unstable and subject to change. + +#![crate_name = "syntax_pos"] +#![unstable(feature = "rustc_private", issue = "27812")] +#![crate_type = "dylib"] +#![crate_type = "rlib"] +#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", + html_favicon_url = "https://doc.rust-lang.org/favicon.ico", + html_root_url = "https://doc.rust-lang.org/nightly/")] +#![cfg_attr(not(stage0), deny(warnings))] + +#![feature(custom_attribute)] +#![allow(unused_attributes)] +#![feature(rustc_private)] +#![feature(staged_api)] +#![feature(question_mark)] + +use std::cell::{Cell, RefCell}; +use std::ops::{Add, Sub}; +use std::rc::Rc; +use std::cmp; + +use std::fmt; + +use serialize::{Encodable, Decodable, Encoder, Decoder}; + +extern crate serialize; +extern crate serialize as rustc_serialize; // used by deriving + +pub type FileName = String; + +/// Spans represent a region of code, used for error reporting. Positions in spans +/// are *absolute* positions from the beginning of the codemap, not positions +/// relative to FileMaps. Methods on the CodeMap can be used to relate spans back +/// to the original source. +/// You must be careful if the span crosses more than one file - you will not be +/// able to use many of the functions on spans in codemap and you cannot assume +/// that the length of the span = hi - lo; there may be space in the BytePos +/// range between files. +#[derive(Clone, Copy, Hash, PartialEq, Eq)] +pub struct Span { + pub lo: BytePos, + pub hi: BytePos, + /// Information about where the macro came from, if this piece of + /// code was created by a macro expansion. + pub expn_id: ExpnId +} + +/// A collection of spans. Spans have two orthogonal attributes: +/// +/// - they can be *primary spans*. In this case they are the locus of +/// the error, and would be rendered with `^^^`. +/// - they can have a *label*. In this case, the label is written next +/// to the mark in the snippet when we render. +#[derive(Clone)] +pub struct MultiSpan { + primary_spans: Vec, + span_labels: Vec<(Span, String)>, +} + +impl Span { + /// Returns a new span representing just the end-point of this span + pub fn end_point(self) -> Span { + let lo = cmp::max(self.hi.0 - 1, self.lo.0); + Span { lo: BytePos(lo), hi: self.hi, expn_id: self.expn_id} + } + + /// Returns `self` if `self` is not the dummy span, and `other` otherwise. + pub fn substitute_dummy(self, other: Span) -> Span { + if self.source_equal(&DUMMY_SP) { other } else { self } + } + + pub fn contains(self, other: Span) -> bool { + self.lo <= other.lo && other.hi <= self.hi + } + + /// Return true if the spans are equal with regards to the source text. + /// + /// Use this instead of `==` when either span could be generated code, + /// and you only care that they point to the same bytes of source text. + pub fn source_equal(&self, other: &Span) -> bool { + self.lo == other.lo && self.hi == other.hi + } + + /// Returns `Some(span)`, a union of `self` and `other`, on overlap. + pub fn merge(self, other: Span) -> Option { + if self.expn_id != other.expn_id { + return None; + } + + if (self.lo <= other.lo && self.hi > other.lo) || + (self.lo >= other.lo && self.lo < other.hi) { + Some(Span { + lo: cmp::min(self.lo, other.lo), + hi: cmp::max(self.hi, other.hi), + expn_id: self.expn_id, + }) + } else { + None + } + } + + /// Returns `Some(span)`, where the start is trimmed by the end of `other` + pub fn trim_start(self, other: Span) -> Option { + if self.hi > other.hi { + Some(Span { lo: cmp::max(self.lo, other.hi), .. self }) + } else { + None + } + } +} + +#[derive(Clone, Debug)] +pub struct SpanLabel { + /// The span we are going to include in the final snippet. + pub span: Span, + + /// Is this a primary span? This is the "locus" of the message, + /// and is indicated with a `^^^^` underline, versus `----`. + pub is_primary: bool, + + /// What label should we attach to this span (if any)? + pub label: Option, +} + +impl Encodable for Span { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_struct("Span", 2, |s| { + s.emit_struct_field("lo", 0, |s| { + self.lo.encode(s) + })?; + + s.emit_struct_field("hi", 1, |s| { + self.hi.encode(s) + }) + }) + } +} + +impl Decodable for Span { + fn decode(d: &mut D) -> Result { + d.read_struct("Span", 2, |d| { + let lo = d.read_struct_field("lo", 0, |d| { + BytePos::decode(d) + })?; + + let hi = d.read_struct_field("hi", 1, |d| { + BytePos::decode(d) + })?; + + Ok(mk_sp(lo, hi)) + }) + } +} + +fn default_span_debug(span: Span, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Span {{ lo: {:?}, hi: {:?}, expn_id: {:?} }}", + span.lo, span.hi, span.expn_id) +} + +impl fmt::Debug for Span { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + SPAN_DEBUG.with(|span_debug| span_debug.get()(*self, f)) + } +} + +pub const DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_id: NO_EXPANSION }; + +// Generic span to be used for code originating from the command line +pub const COMMAND_LINE_SP: Span = Span { lo: BytePos(0), + hi: BytePos(0), + expn_id: COMMAND_LINE_EXPN }; + +impl MultiSpan { + pub fn new() -> MultiSpan { + MultiSpan { + primary_spans: vec![], + span_labels: vec![] + } + } + + pub fn from_span(primary_span: Span) -> MultiSpan { + MultiSpan { + primary_spans: vec![primary_span], + span_labels: vec![] + } + } + + pub fn from_spans(vec: Vec) -> MultiSpan { + MultiSpan { + primary_spans: vec, + span_labels: vec![] + } + } + + pub fn push_span_label(&mut self, span: Span, label: String) { + self.span_labels.push((span, label)); + } + + /// Selects the first primary span (if any) + pub fn primary_span(&self) -> Option { + self.primary_spans.first().cloned() + } + + /// Returns all primary spans. + pub fn primary_spans(&self) -> &[Span] { + &self.primary_spans + } + + /// Returns the strings to highlight. We always ensure that there + /// is an entry for each of the primary spans -- for each primary + /// span P, if there is at least one label with span P, we return + /// those labels (marked as primary). But otherwise we return + /// `SpanLabel` instances with empty labels. + pub fn span_labels(&self) -> Vec { + let is_primary = |span| self.primary_spans.contains(&span); + let mut span_labels = vec![]; + + for &(span, ref label) in &self.span_labels { + span_labels.push(SpanLabel { + span: span, + is_primary: is_primary(span), + label: Some(label.clone()) + }); + } + + for &span in &self.primary_spans { + if !span_labels.iter().any(|sl| sl.span == span) { + span_labels.push(SpanLabel { + span: span, + is_primary: true, + label: None + }); + } + } + + span_labels + } +} + +impl From for MultiSpan { + fn from(span: Span) -> MultiSpan { + MultiSpan::from_span(span) + } +} + +#[derive(PartialEq, Eq, Clone, Debug, Hash, RustcEncodable, RustcDecodable, Copy)] +pub struct ExpnId(pub u32); + +pub const NO_EXPANSION: ExpnId = ExpnId(!0); +// For code appearing from the command line +pub const COMMAND_LINE_EXPN: ExpnId = ExpnId(!1); + +impl ExpnId { + pub fn from_u32(id: u32) -> ExpnId { + ExpnId(id) + } + + pub fn into_u32(self) -> u32 { + self.0 + } +} + +/// Identifies an offset of a multi-byte character in a FileMap +#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Eq, PartialEq)] +pub struct MultiByteChar { + /// The absolute offset of the character in the CodeMap + pub pos: BytePos, + /// The number of bytes, >=2 + pub bytes: usize, +} + +/// A single source in the CodeMap. +pub struct FileMap { + /// The name of the file that the source came from, source that doesn't + /// originate from files has names between angle brackets by convention, + /// e.g. `` + pub name: FileName, + /// The absolute path of the file that the source came from. + pub abs_path: Option, + /// The complete source code + pub src: Option>, + /// The start position of this source in the CodeMap + pub start_pos: BytePos, + /// The end position of this source in the CodeMap + pub end_pos: BytePos, + /// Locations of lines beginnings in the source code + pub lines: RefCell>, + /// Locations of multi-byte characters in the source code + pub multibyte_chars: RefCell>, +} + +impl Encodable for FileMap { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_struct("FileMap", 6, |s| { + s.emit_struct_field("name", 0, |s| self.name.encode(s))?; + s.emit_struct_field("abs_path", 1, |s| self.abs_path.encode(s))?; + s.emit_struct_field("start_pos", 2, |s| self.start_pos.encode(s))?; + s.emit_struct_field("end_pos", 3, |s| self.end_pos.encode(s))?; + s.emit_struct_field("lines", 4, |s| { + let lines = self.lines.borrow(); + // store the length + s.emit_u32(lines.len() as u32)?; + + if !lines.is_empty() { + // In order to preserve some space, we exploit the fact that + // the lines list is sorted and individual lines are + // probably not that long. Because of that we can store lines + // as a difference list, using as little space as possible + // for the differences. + let max_line_length = if lines.len() == 1 { + 0 + } else { + lines.windows(2) + .map(|w| w[1] - w[0]) + .map(|bp| bp.to_usize()) + .max() + .unwrap() + }; + + let bytes_per_diff: u8 = match max_line_length { + 0 ... 0xFF => 1, + 0x100 ... 0xFFFF => 2, + _ => 4 + }; + + // Encode the number of bytes used per diff. + bytes_per_diff.encode(s)?; + + // Encode the first element. + lines[0].encode(s)?; + + let diff_iter = (&lines[..]).windows(2) + .map(|w| (w[1] - w[0])); + + match bytes_per_diff { + 1 => for diff in diff_iter { (diff.0 as u8).encode(s)? }, + 2 => for diff in diff_iter { (diff.0 as u16).encode(s)? }, + 4 => for diff in diff_iter { diff.0.encode(s)? }, + _ => unreachable!() + } + } + + Ok(()) + })?; + s.emit_struct_field("multibyte_chars", 5, |s| { + (*self.multibyte_chars.borrow()).encode(s) + }) + }) + } +} + +impl Decodable for FileMap { + fn decode(d: &mut D) -> Result { + + d.read_struct("FileMap", 6, |d| { + let name: String = d.read_struct_field("name", 0, |d| Decodable::decode(d))?; + let abs_path: Option = + d.read_struct_field("abs_path", 1, |d| Decodable::decode(d))?; + let start_pos: BytePos = d.read_struct_field("start_pos", 2, |d| Decodable::decode(d))?; + let end_pos: BytePos = d.read_struct_field("end_pos", 3, |d| Decodable::decode(d))?; + let lines: Vec = d.read_struct_field("lines", 4, |d| { + let num_lines: u32 = Decodable::decode(d)?; + let mut lines = Vec::with_capacity(num_lines as usize); + + if num_lines > 0 { + // Read the number of bytes used per diff. + let bytes_per_diff: u8 = Decodable::decode(d)?; + + // Read the first element. + let mut line_start: BytePos = Decodable::decode(d)?; + lines.push(line_start); + + for _ in 1..num_lines { + let diff = match bytes_per_diff { + 1 => d.read_u8()? as u32, + 2 => d.read_u16()? as u32, + 4 => d.read_u32()?, + _ => unreachable!() + }; + + line_start = line_start + BytePos(diff); + + lines.push(line_start); + } + } + + Ok(lines) + })?; + let multibyte_chars: Vec = + d.read_struct_field("multibyte_chars", 5, |d| Decodable::decode(d))?; + Ok(FileMap { + name: name, + abs_path: abs_path, + start_pos: start_pos, + end_pos: end_pos, + src: None, + lines: RefCell::new(lines), + multibyte_chars: RefCell::new(multibyte_chars) + }) + }) + } +} + +impl fmt::Debug for FileMap { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + write!(fmt, "FileMap({})", self.name) + } +} + +impl FileMap { + /// EFFECT: register a start-of-line offset in the + /// table of line-beginnings. + /// UNCHECKED INVARIANT: these offsets must be added in the right + /// order and must be in the right places; there is shared knowledge + /// about what ends a line between this file and parse.rs + /// WARNING: pos param here is the offset relative to start of CodeMap, + /// and CodeMap will append a newline when adding a filemap without a newline at the end, + /// so the safe way to call this is with value calculated as + /// filemap.start_pos + newline_offset_relative_to_the_start_of_filemap. + pub fn next_line(&self, pos: BytePos) { + // the new charpos must be > the last one (or it's the first one). + let mut lines = self.lines.borrow_mut(); + let line_len = lines.len(); + assert!(line_len == 0 || ((*lines)[line_len - 1] < pos)); + lines.push(pos); + } + + /// get a line from the list of pre-computed line-beginnings. + /// line-number here is 0-based. + pub fn get_line(&self, line_number: usize) -> Option<&str> { + match self.src { + Some(ref src) => { + let lines = self.lines.borrow(); + lines.get(line_number).map(|&line| { + let begin: BytePos = line - self.start_pos; + let begin = begin.to_usize(); + // We can't use `lines.get(line_number+1)` because we might + // be parsing when we call this function and thus the current + // line is the last one we have line info for. + let slice = &src[begin..]; + match slice.find('\n') { + Some(e) => &slice[..e], + None => slice + } + }) + } + None => None + } + } + + pub fn record_multibyte_char(&self, pos: BytePos, bytes: usize) { + assert!(bytes >=2 && bytes <= 4); + let mbc = MultiByteChar { + pos: pos, + bytes: bytes, + }; + self.multibyte_chars.borrow_mut().push(mbc); + } + + pub fn is_real_file(&self) -> bool { + !(self.name.starts_with("<") && + self.name.ends_with(">")) + } + + pub fn is_imported(&self) -> bool { + self.src.is_none() + } + + pub fn count_lines(&self) -> usize { + self.lines.borrow().len() + } +} + +// _____________________________________________________________________________ +// Pos, BytePos, CharPos +// + +pub trait Pos { + fn from_usize(n: usize) -> Self; + fn to_usize(&self) -> usize; +} + +/// A byte offset. Keep this small (currently 32-bits), as AST contains +/// a lot of them. +#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +pub struct BytePos(pub u32); + +/// A character offset. Because of multibyte utf8 characters, a byte offset +/// is not equivalent to a character offset. The CodeMap will convert BytePos +/// values to CharPos values as necessary. +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +pub struct CharPos(pub usize); + +// FIXME: Lots of boilerplate in these impls, but so far my attempts to fix +// have been unsuccessful + +impl Pos for BytePos { + fn from_usize(n: usize) -> BytePos { BytePos(n as u32) } + fn to_usize(&self) -> usize { let BytePos(n) = *self; n as usize } +} + +impl Add for BytePos { + type Output = BytePos; + + fn add(self, rhs: BytePos) -> BytePos { + BytePos((self.to_usize() + rhs.to_usize()) as u32) + } +} + +impl Sub for BytePos { + type Output = BytePos; + + fn sub(self, rhs: BytePos) -> BytePos { + BytePos((self.to_usize() - rhs.to_usize()) as u32) + } +} + +impl Encodable for BytePos { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_u32(self.0) + } +} + +impl Decodable for BytePos { + fn decode(d: &mut D) -> Result { + Ok(BytePos(d.read_u32()?)) + } +} + +impl Pos for CharPos { + fn from_usize(n: usize) -> CharPos { CharPos(n) } + fn to_usize(&self) -> usize { let CharPos(n) = *self; n } +} + +impl Add for CharPos { + type Output = CharPos; + + fn add(self, rhs: CharPos) -> CharPos { + CharPos(self.to_usize() + rhs.to_usize()) + } +} + +impl Sub for CharPos { + type Output = CharPos; + + fn sub(self, rhs: CharPos) -> CharPos { + CharPos(self.to_usize() - rhs.to_usize()) + } +} + +// _____________________________________________________________________________ +// Loc, LocWithOpt, FileMapAndLine, FileMapAndBytePos +// + +/// A source code location used for error reporting +#[derive(Debug)] +pub struct Loc { + /// Information about the original source + pub file: Rc, + /// The (1-based) line number + pub line: usize, + /// The (0-based) column offset + pub col: CharPos +} + +/// A source code location used as the result of lookup_char_pos_adj +// Actually, *none* of the clients use the filename *or* file field; +// perhaps they should just be removed. +#[derive(Debug)] +pub struct LocWithOpt { + pub filename: FileName, + pub line: usize, + pub col: CharPos, + pub file: Option>, +} + +// used to be structural records. Better names, anyone? +#[derive(Debug)] +pub struct FileMapAndLine { pub fm: Rc, pub line: usize } +#[derive(Debug)] +pub struct FileMapAndBytePos { pub fm: Rc, pub pos: BytePos } + +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub struct LineInfo { + /// Index of line, starting from 0. + pub line_index: usize, + + /// Column in line where span begins, starting from 0. + pub start_col: CharPos, + + /// Column in line where span ends, starting from 0, exclusive. + pub end_col: CharPos, +} + +pub struct FileLines { + pub file: Rc, + pub lines: Vec +} + +thread_local!(pub static SPAN_DEBUG: Cell fmt::Result> = + Cell::new(default_span_debug)); + +/* assuming that we're not in macro expansion */ +pub fn mk_sp(lo: BytePos, hi: BytePos) -> Span { + Span {lo: lo, hi: hi, expn_id: NO_EXPANSION} +} + +pub struct MacroBacktrace { + /// span where macro was applied to generate this code + pub call_site: Span, + + /// name of macro that was applied (e.g., "foo!" or "#[derive(Eq)]") + pub macro_decl_name: String, + + /// span where macro was defined (if known) + pub def_site_span: Option, +} + +// _____________________________________________________________________________ +// SpanLinesError, SpanSnippetError, DistinctSources, MalformedCodemapPositions +// + +pub type FileLinesResult = Result; + +#[derive(Clone, PartialEq, Eq, Debug)] +pub enum SpanLinesError { + IllFormedSpan(Span), + DistinctSources(DistinctSources), +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub enum SpanSnippetError { + IllFormedSpan(Span), + DistinctSources(DistinctSources), + MalformedForCodemap(MalformedCodemapPositions), + SourceNotAvailable { filename: String } +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct DistinctSources { + pub begin: (String, BytePos), + pub end: (String, BytePos) +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct MalformedCodemapPositions { + pub name: String, + pub source_len: usize, + pub begin_pos: BytePos, + pub end_pos: BytePos +} + diff --git a/src/test/compile-fail-fulldeps/auxiliary/macro_crate_test.rs b/src/test/compile-fail-fulldeps/auxiliary/macro_crate_test.rs index 3516f566e8a1f..5fdca58dec273 100644 --- a/src/test/compile-fail-fulldeps/auxiliary/macro_crate_test.rs +++ b/src/test/compile-fail-fulldeps/auxiliary/macro_crate_test.rs @@ -13,14 +13,15 @@ #![feature(plugin_registrar, quote, rustc_private)] extern crate syntax; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; use syntax::ast::{self, TokenTree, Item, MetaItem, ImplItem, TraitItem, ItemKind}; -use syntax::codemap::Span; use syntax::ext::base::*; use syntax::parse::{self, token}; use syntax::ptr::P; +use syntax_pos::Span; use rustc_plugin::Registry; #[macro_export] diff --git a/src/test/compile-fail-fulldeps/gated-quote.rs b/src/test/compile-fail-fulldeps/gated-quote.rs index cd801fbcd889b..dade0e946c5bf 100644 --- a/src/test/compile-fail-fulldeps/gated-quote.rs +++ b/src/test/compile-fail-fulldeps/gated-quote.rs @@ -22,8 +22,8 @@ extern crate syntax; use syntax::ast; -use syntax::codemap::Span; use syntax::parse; +use syntax_pos::Span; struct ParseSess; diff --git a/src/test/compile-fail-fulldeps/qquote.rs b/src/test/compile-fail-fulldeps/qquote.rs index 89a4869bd6975..e29ded8a052c6 100644 --- a/src/test/compile-fail-fulldeps/qquote.rs +++ b/src/test/compile-fail-fulldeps/qquote.rs @@ -13,11 +13,12 @@ #![feature(quote, rustc_private)] extern crate syntax; +extern crate syntax_pos; use syntax::ast; -use syntax::codemap::{self, DUMMY_SP}; use syntax::parse; use syntax::print::pprust; +use syntax_pos::DUMMY_SP; fn main() { let ps = syntax::parse::ParseSess::new(); diff --git a/src/test/compile-fail/bad-format-args.rs b/src/test/compile-fail/bad-format-args.rs index 816c696a89566..8c58c8c60627d 100644 --- a/src/test/compile-fail/bad-format-args.rs +++ b/src/test/compile-fail/bad-format-args.rs @@ -9,11 +9,11 @@ // except according to those terms. // error-pattern: requires at least a format string argument -// error-pattern: bad-format-args.rs:19:5: 19:15 note: in this expansion +// error-pattern: in this expansion // error-pattern: expected token: `,` -// error-pattern: bad-format-args.rs:20:5: 20:19 note: in this expansion -// error-pattern: bad-format-args.rs:21:5: 21:22 note: in this expansion +// error-pattern: in this expansion +// error-pattern: in this expansion fn main() { format!(); diff --git a/src/test/run-fail-fulldeps/qquote.rs b/src/test/run-fail-fulldeps/qquote.rs index 560b742f8a6c7..e1461c7847e4c 100644 --- a/src/test/run-fail-fulldeps/qquote.rs +++ b/src/test/run-fail-fulldeps/qquote.rs @@ -15,11 +15,13 @@ #![feature(quote, rustc_private)] extern crate syntax; +extern crate syntax_pos; use syntax::ast; -use syntax::codemap::{self, DUMMY_SP}; +use syntax::codemap; use syntax::parse; use syntax::print::pprust; +use syntax_pos::DUMMY_SP; fn main() { let ps = syntax::parse::ParseSess::new(); diff --git a/src/test/run-make/execution-engine/test.rs b/src/test/run-make/execution-engine/test.rs index 8a7959212f54a..a94b2a85c7754 100644 --- a/src/test/run-make/execution-engine/test.rs +++ b/src/test/run-make/execution-engine/test.rs @@ -18,6 +18,8 @@ extern crate rustc_lint; extern crate rustc_llvm as llvm; extern crate rustc_metadata; extern crate rustc_resolve; +extern crate rustc_errors; +extern crate rustc_errors as errors; #[macro_use] extern crate syntax; use std::ffi::{CStr, CString}; @@ -38,7 +40,7 @@ use rustc_metadata::creader::read_local_crates; use rustc_metadata::cstore::CStore; use libc::c_void; -use syntax::diagnostics::registry::Registry; +use rustc_errors::registry::Registry; use syntax::parse::token; fn main() { diff --git a/src/test/run-make/issue-19371/foo.rs b/src/test/run-make/issue-19371/foo.rs index 41d250eadec4e..aa3495ec5eebb 100644 --- a/src/test/run-make/issue-19371/foo.rs +++ b/src/test/run-make/issue-19371/foo.rs @@ -14,6 +14,7 @@ extern crate rustc; extern crate rustc_driver; extern crate rustc_lint; extern crate rustc_metadata; +extern crate rustc_errors; extern crate syntax; use rustc::dep_graph::DepGraph; @@ -21,7 +22,7 @@ use rustc::session::{build_session, Session}; use rustc::session::config::{basic_options, build_configuration, Input, OutputType}; use rustc_driver::driver::{compile_input, CompileController, anon_src}; use rustc_metadata::cstore::CStore; -use syntax::diagnostics::registry::Registry; +use rustc_errors::registry::Registry; use syntax::parse::token; use std::path::PathBuf; diff --git a/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin.rs b/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin.rs index 0132014de0ab5..42135703b75a4 100644 --- a/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin.rs +++ b/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin.rs @@ -16,17 +16,18 @@ extern crate syntax; extern crate syntax_ext; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; use syntax::ast; -use syntax::codemap::Span; use syntax::ext::base::{MultiDecorator, ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token; use syntax::ptr::P; use syntax_ext::deriving::generic::{cs_fold, TraitDef, MethodDef, combine_substructure}; use syntax_ext::deriving::generic::ty::{Literal, LifetimeBounds, Path, borrowed_explicit_self}; +use syntax_pos::Span; use rustc_plugin::Registry; #[plugin_registrar] diff --git a/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin_attr.rs b/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin_attr.rs index 6fa78913839b7..eeecd0b24e29e 100644 --- a/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin_attr.rs +++ b/src/test/run-pass-fulldeps/auxiliary/custom_derive_plugin_attr.rs @@ -16,12 +16,12 @@ extern crate syntax; extern crate syntax_ext; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; use syntax::ast; use syntax::attr::AttrMetaMethods; -use syntax::codemap::Span; use syntax::ext::base::{MultiDecorator, ExtCtxt, Annotatable}; use syntax::ext::build::AstBuilder; use syntax::parse::token; @@ -29,6 +29,7 @@ use syntax::ptr::P; use syntax_ext::deriving::generic::{cs_fold, TraitDef, MethodDef, combine_substructure}; use syntax_ext::deriving::generic::{Substructure, Struct, EnumMatching}; use syntax_ext::deriving::generic::ty::{Literal, LifetimeBounds, Path, borrowed_explicit_self}; +use syntax_pos::Span; use rustc_plugin::Registry; #[plugin_registrar] diff --git a/src/test/run-pass-fulldeps/auxiliary/issue_16723_multiple_items_syntax_ext.rs b/src/test/run-pass-fulldeps/auxiliary/issue_16723_multiple_items_syntax_ext.rs index 25a75c2d2952e..9f0c8d4d64949 100644 --- a/src/test/run-pass-fulldeps/auxiliary/issue_16723_multiple_items_syntax_ext.rs +++ b/src/test/run-pass-fulldeps/auxiliary/issue_16723_multiple_items_syntax_ext.rs @@ -16,9 +16,9 @@ extern crate syntax; extern crate rustc; extern crate rustc_plugin; +extern crate syntax_pos; use syntax::ast; -use syntax::codemap; use syntax::ext::base::{ExtCtxt, MacResult, MacEager}; use syntax::util::small_vector::SmallVector; use rustc_plugin::Registry; @@ -28,7 +28,7 @@ pub fn plugin_registrar(reg: &mut Registry) { reg.register_macro("multiple_items", expand) } -fn expand(cx: &mut ExtCtxt, _: codemap::Span, _: &[ast::TokenTree]) -> Box { +fn expand(cx: &mut ExtCtxt, _: syntax_pos::Span, _: &[ast::TokenTree]) -> Box { MacEager::items(SmallVector::many(vec![ quote_item!(cx, struct Struct1;).unwrap(), quote_item!(cx, struct Struct2;).unwrap() diff --git a/src/test/run-pass-fulldeps/auxiliary/macro_crate_test.rs b/src/test/run-pass-fulldeps/auxiliary/macro_crate_test.rs index a22c3ba484926..e32c83472a1cf 100644 --- a/src/test/run-pass-fulldeps/auxiliary/macro_crate_test.rs +++ b/src/test/run-pass-fulldeps/auxiliary/macro_crate_test.rs @@ -15,12 +15,13 @@ extern crate syntax; extern crate rustc; extern crate rustc_plugin; +extern crate syntax_pos; use syntax::ast::{self, TokenTree, Item, MetaItem, ImplItem, TraitItem, ItemKind}; -use syntax::codemap::Span; use syntax::ext::base::*; use syntax::parse::{self, token}; use syntax::ptr::P; +use syntax_pos::Span; use rustc_plugin::Registry; #[macro_export] diff --git a/src/test/run-pass-fulldeps/auxiliary/plugin_args.rs b/src/test/run-pass-fulldeps/auxiliary/plugin_args.rs index 99321ad42418d..e47e38bb31872 100644 --- a/src/test/run-pass-fulldeps/auxiliary/plugin_args.rs +++ b/src/test/run-pass-fulldeps/auxiliary/plugin_args.rs @@ -14,17 +14,18 @@ #![feature(box_syntax, rustc_private)] extern crate syntax; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; use std::borrow::ToOwned; use syntax::ast; -use syntax::codemap::Span; use syntax::ext::build::AstBuilder; use syntax::ext::base::{TTMacroExpander, ExtCtxt, MacResult, MacEager, NormalTT}; use syntax::parse::token; use syntax::print::pprust; use syntax::ptr::P; +use syntax_pos::Span; use rustc_plugin::Registry; struct Expander { diff --git a/src/test/run-pass-fulldeps/auxiliary/procedural_mbe_matching.rs b/src/test/run-pass-fulldeps/auxiliary/procedural_mbe_matching.rs index 713a7d1e811a2..5566692a4e283 100644 --- a/src/test/run-pass-fulldeps/auxiliary/procedural_mbe_matching.rs +++ b/src/test/run-pass-fulldeps/auxiliary/procedural_mbe_matching.rs @@ -14,10 +14,10 @@ #![feature(plugin_registrar, quote, rustc_private)] extern crate syntax; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; -use syntax::codemap::Span; use syntax::parse::token::{self, str_to_ident, NtExpr, NtPat}; use syntax::ast::{TokenTree, Pat}; use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager}; @@ -25,6 +25,7 @@ use syntax::ext::build::AstBuilder; use syntax::ext::tt::macro_parser::{MatchedSeq, MatchedNonterminal}; use syntax::ext::tt::macro_parser::{Success, Failure, Error}; use syntax::ptr::P; +use syntax_pos::Span; use rustc_plugin::Registry; fn expand_mbe_matches(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree]) diff --git a/src/test/run-pass-fulldeps/auxiliary/roman_numerals.rs b/src/test/run-pass-fulldeps/auxiliary/roman_numerals.rs index 839ece49c3eb5..7a3729015c19f 100644 --- a/src/test/run-pass-fulldeps/auxiliary/roman_numerals.rs +++ b/src/test/run-pass-fulldeps/auxiliary/roman_numerals.rs @@ -15,14 +15,15 @@ #![feature(slice_patterns)] extern crate syntax; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; -use syntax::codemap::Span; use syntax::ast::TokenTree; use syntax::parse::token; use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager}; use syntax::ext::build::AstBuilder; // trait for expr_usize +use syntax_pos::Span; use rustc_plugin::Registry; // WARNING WARNING WARNING WARNING WARNING diff --git a/src/test/run-pass-fulldeps/auxiliary/syntax_extension_with_dll_deps_2.rs b/src/test/run-pass-fulldeps/auxiliary/syntax_extension_with_dll_deps_2.rs index 7281698a7fb34..7581e43f12ed7 100644 --- a/src/test/run-pass-fulldeps/auxiliary/syntax_extension_with_dll_deps_2.rs +++ b/src/test/run-pass-fulldeps/auxiliary/syntax_extension_with_dll_deps_2.rs @@ -15,12 +15,13 @@ extern crate syntax_extension_with_dll_deps_1 as other; extern crate syntax; +extern crate syntax_pos; extern crate rustc; extern crate rustc_plugin; use syntax::ast::{TokenTree, Item, MetaItem}; -use syntax::codemap::Span; use syntax::ext::base::*; +use syntax_pos::Span; use rustc_plugin::Registry; #[plugin_registrar] diff --git a/src/test/run-pass-fulldeps/compiler-calls.rs b/src/test/run-pass-fulldeps/compiler-calls.rs index af641d717edd9..ff57e9d6b7368 100644 --- a/src/test/run-pass-fulldeps/compiler-calls.rs +++ b/src/test/run-pass-fulldeps/compiler-calls.rs @@ -19,11 +19,11 @@ extern crate getopts; extern crate rustc; extern crate rustc_driver; extern crate syntax; +extern crate rustc_errors as errors; use rustc::session::Session; use rustc::session::config::{self, Input}; use rustc_driver::{driver, CompilerCalls, Compilation}; -use syntax::{diagnostics, errors}; use std::path::PathBuf; @@ -35,7 +35,7 @@ impl<'a> CompilerCalls<'a> for TestCalls { fn early_callback(&mut self, _: &getopts::Matches, _: &config::Options, - _: &diagnostics::registry::Registry, + _: &errors::registry::Registry, _: config::ErrorOutputType) -> Compilation { self.count *= 2; @@ -64,7 +64,7 @@ impl<'a> CompilerCalls<'a> for TestCalls { _: &config::Options, _: &Option, _: &Option, - _: &diagnostics::registry::Registry) + _: &errors::registry::Registry) -> Option<(Input, Option)> { panic!("This shouldn't happen"); } diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs index 65c642a1eca59..a4f0e35cc5ac7 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -13,10 +13,11 @@ #![feature(quote, rustc_private)] extern crate syntax; +extern crate syntax_pos; -use syntax::codemap::DUMMY_SP; use syntax::print::pprust::*; use syntax::parse::token::intern; +use syntax_pos::DUMMY_SP; fn main() { let ps = syntax::parse::ParseSess::new(); diff --git a/src/tools/compiletest/src/json.rs b/src/tools/compiletest/src/json.rs index 84b78547ab9a4..e5b628bb00295 100644 --- a/src/tools/compiletest/src/json.rs +++ b/src/tools/compiletest/src/json.rs @@ -15,7 +15,7 @@ use std::path::Path; use runtest::{ProcRes}; // These structs are a subset of the ones found in -// `syntax::errors::json`. +// `syntax::json`. #[derive(RustcEncodable, RustcDecodable)] struct Diagnostic {