// `sp` only covers `T`, change it so that it covers
// `T:` when appropriate
let sp = if has_lifetimes {
- sp.to(sp.next_point().next_point())
+ sp.to(self.tcx.sess.codemap().next_point(
+ self.tcx.sess.codemap().next_point(sp)))
} else {
sp
};
// 3. Where does old loan expire.
let previous_end_span =
- Some(old_loan.kill_scope.span(self.tcx(), &self.bccx.region_scope_tree)
- .end_point());
+ Some(self.tcx().sess.codemap().end_point(
+ old_loan.kill_scope.span(self.tcx(), &self.bccx.region_scope_tree)));
let mut err = match (new_loan.kind, old_loan.kind) {
(ty::MutBorrow, ty::MutBorrow) =>
fn region_end_span(&self, region: ty::Region<'tcx>) -> Option<Span> {
match *region {
ty::ReScope(scope) => {
- Some(scope.span(self.tcx, &self.region_scope_tree).end_point())
+ Some(self.tcx.sess.codemap().end_point(
+ scope.span(self.tcx, &self.region_scope_tree)))
}
_ => None
}
debug!("check_for_invalidation_at_exit({:?}): INVALID", place);
// FIXME: should be talking about the region lifetime instead
// of just a span here.
+ let span = self.tcx.sess.codemap().end_point(span);
self.report_borrowed_value_does_not_live_long_enough(
context,
borrow,
- span.end_point(),
+ span,
flow_state.borrows.operator(),
)
}
let region_scope_span = region_scope.span(self.hir.tcx(),
&self.hir.region_scope_tree);
// Attribute scope exit drops to scope's closing brace.
- let scope_end = region_scope_span.end_point();
+ let scope_end = self.hir.tcx().sess.codemap().end_point(region_scope_span);
scope.drops.push(DropData {
span: scope_end,
Some(_) => None,
None => {
match self.0.region_span_map.get(region) {
- Some(span) => Some(span.end_point()),
- None => Some(self.0.mir.span.end_point())
+ Some(span) => Some(self.0.tcx.sess.codemap().end_point(*span)),
+ None => Some(self.0.tcx.sess.codemap().end_point(self.0.mir.span))
}
}
}
if let Some(sp) = self.current_type_ascription.last() {
let mut sp = *sp;
loop { // try to find the `:`, bail on first non-':'/non-whitespace
- sp = sp.next_point();
- if let Ok(snippet) = cm.span_to_snippet(sp.to(sp.next_point())) {
+ sp = cm.next_point(sp);
+ if let Ok(snippet) = cm.span_to_snippet(sp.to(cm.next_point(sp))) {
debug!("snippet {:?}", snippet);
let line_sp = cm.lookup_char_pos(sp.hi()).line;
let line_base_sp = cm.lookup_char_pos(base_span.lo()).line;
err.span_label(def_s, "defined here");
}
if sugg_unit {
- let sugg_span = expr_sp.end_point();
+ let sugg_span = sess.codemap().end_point(expr_sp);
// remove closing `)` from the span
let sugg_span = sugg_span.with_hi(sugg_span.lo());
err.span_suggestion(
/// statement and the return type has been left as default or has been specified as `()`. If so,
/// it suggests adding a semicolon.
fn suggest_missing_semicolon(&self,
- err: &mut DiagnosticBuilder<'tcx>,
- expression: &'gcx hir::Expr,
- expected: Ty<'tcx>,
- cause_span: Span) {
+ err: &mut DiagnosticBuilder<'tcx>,
+ expression: &'gcx hir::Expr,
+ expected: Ty<'tcx>,
+ cause_span: Span) {
if expected.is_nil() {
// `BlockTailExpression` only relevant if the tail expr would be
// useful on its own.
hir::ExprLoop(..) |
hir::ExprMatch(..) |
hir::ExprBlock(..) => {
- let sp = cause_span.next_point();
+ let sp = self.tcx.sess.codemap().next_point(cause_span);
err.span_suggestion(sp,
"try adding a semicolon",
";".to_string());
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::StableHasher;
use std::cell::{RefCell, Ref};
+use std::cmp;
use std::hash::Hash;
use std::path::{Path, PathBuf};
use std::rc::Rc;
self.span_until_char(sp, '{')
}
+ /// Returns a new span representing just the end-point of this span
+ pub fn end_point(&self, sp: Span) -> Span {
+ let hi = sp.hi().0.checked_sub(1).unwrap_or(sp.hi().0);
+ let hi = self.get_start_of_char_bytepos(BytePos(hi));
+ let lo = cmp::max(hi.0, sp.lo().0);
+ sp.with_lo(BytePos(lo))
+ }
+
+ /// Returns a new span representing the next character after the end-point of this span
+ pub fn next_point(&self, sp: Span) -> Span {
+ let hi = sp.lo().0.checked_add(1).unwrap_or(sp.lo().0);
+ let hi = self.get_start_of_char_bytepos(BytePos(hi));
+ let lo = cmp::max(sp.hi().0, hi.0);
+ Span::new(BytePos(lo), BytePos(lo), sp.ctxt())
+ }
+
+ fn get_start_of_char_bytepos(&self, bpos: BytePos) -> BytePos {
+ let idx = self.lookup_filemap_idx(bpos);
+ let files = self.files.borrow();
+ let map = &(*files)[idx];
+
+ for mbc in map.multibyte_chars.borrow().iter() {
+ if mbc.pos < bpos {
+ if bpos.to_usize() >= mbc.pos.to_usize() + mbc.bytes {
+ // If we do, then return the start of the character.
+ return mbc.pos;
+ }
+ } else {
+ break;
+ }
+ }
+
+ // If this isn't a multibyte character, return the original position.
+ return bpos;
+ }
+
pub fn get_filemap(&self, filename: &FileName) -> Option<Rc<FileMap>> {
for fm in self.files.borrow().iter() {
if *filename == fm.name {
expect.clone()
};
(format!("expected one of {}, found `{}`", expect, actual),
- (self.prev_span.next_point(), format!("expected one of {} here", short_expect)))
+ (self.sess.codemap().next_point(self.prev_span),
+ format!("expected one of {} here", short_expect)))
} else if expected.is_empty() {
(format!("unexpected token: `{}`", actual),
(self.prev_span, "unexpected token after this".to_string()))
} else {
(format!("expected {}, found `{}`", expect, actual),
- (self.prev_span.next_point(), format!("expected {} here", expect)))
+ (self.sess.codemap().next_point(self.prev_span),
+ format!("expected {} here", expect)))
};
let mut err = self.fatal(&msg_exp);
let sp = if self.token == token::Token::Eof {
// return. This won't catch blocks with an explicit `return`, but that would be caught by
// the dead code lint.
if self.eat_keyword(keywords::Else) || !cond.returns() {
- let sp = lo.next_point();
+ let sp = self.sess.codemap().next_point(lo);
let mut err = self.diagnostic()
.struct_span_err(sp, "missing condition for `if` statemement");
err.span_label(sp, "expected if condition here");
self.data().with_ctxt(ctxt)
}
- /// Returns a new span representing just the end-point of this span
- pub fn end_point(self) -> Span {
- let span = self.data();
- // We can avoid an ICE by checking if subtraction would cause an overflow.
- let hi = if span.hi.0 == u32::min_value() { span.hi.0 } else { span.hi.0 - 1 };
- let lo = cmp::max(hi, span.lo.0);
- span.with_lo(BytePos(lo))
- }
-
- /// Returns a new span representing the next character after the end-point of this span
- pub fn next_point(self) -> Span {
- let span = self.data();
- let lo = cmp::max(span.hi.0, span.lo.0 + 1);
- Span::new(BytePos(lo), BytePos(lo), span.ctxt)
- }
-
/// 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 }
projects / rust.git / commitdiff