Add the span of the operator itself to ast::BinOp.

Author: huonw

src/librustc/lint/builtin.rs

@@ -44,7 +44,7 @@ use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
 use syntax::{abi, ast, ast_map};
 use syntax::ast_util::is_shift_binop;
 use syntax::attr::{self, AttrMetaMethods};
-use syntax::codemap::{Span, DUMMY_SP};
+use syntax::codemap::{self, Span, DUMMY_SP};
 use syntax::parse::token;
 use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
 use syntax::ast_util;
@@ -185,7 +185,7 @@ impl LintPass for TypeLimits {
  "comparison is useless due to type limits");
  }
 
- if is_shift_binop(binop) {
+ if is_shift_binop(binop.node) {
  let opt_ty_bits = match ty::expr_ty(cx.tcx, &**l).sty {
  ty::ty_int(t) => Some(int_ty_bits(t, cx.sess().target.int_type)),
  ty::ty_uint(t) => Some(uint_ty_bits(t, cx.sess().target.uint_type)),
@@ -272,7 +272,7 @@ impl LintPass for TypeLimits {
 
  fn is_valid<T:cmp::PartialOrd>(binop: ast::BinOp, v: T,
  min: T, max: T) -> bool {
- match binop {
+ match binop.node {
  ast::BiLt => v > min && v <= max,
  ast::BiLe => v >= min && v < max,
  ast::BiGt => v >= min && v < max,
@@ -283,13 +283,13 @@ impl LintPass for TypeLimits {
  }
 
  fn rev_binop(binop: ast::BinOp) -> ast::BinOp {
- match binop {
+ codemap::respan(binop.span, match binop.node {
  ast::BiLt => ast::BiGt,
  ast::BiLe => ast::BiGe,
  ast::BiGt => ast::BiLt,
  ast::BiGe => ast::BiLe,
- _ => binop
- }
+ _ => return binop
+ })
  }
 
  // for int & uint, be conservative with the warnings, so that the
@@ -382,7 +382,7 @@ impl LintPass for TypeLimits {
  }
 
  fn is_comparison(binop: ast::BinOp) -> bool {
- match binop {
+ match binop.node {
  ast::BiEq | ast::BiLt | ast::BiLe |
  ast::BiNe | ast::BiGe | ast::BiGt => true,
  _ => false

src/librustc/middle/cfg/construct.rs

@@ -372,7 +372,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
  expr_exit
  }
 
- ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => {
+ ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op.node) => {
  //
  // [pred]
  // |

src/librustc/middle/const_eval.rs

@@ -400,7 +400,7 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
  match (eval_const_expr_partial(tcx, &**a),
  eval_const_expr_partial(tcx, &**b)) {
  (Ok(const_float(a)), Ok(const_float(b))) => {
- match op {
+ match op.node {
  ast::BiAdd => Ok(const_float(a + b)),
  ast::BiSub => Ok(const_float(a - b)),
  ast::BiMul => Ok(const_float(a * b)),
@@ -416,7 +416,7 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
  }
  }
  (Ok(const_int(a)), Ok(const_int(b))) => {
- match op {
+ match op.node {
  ast::BiAdd => Ok(const_int(a + b)),
  ast::BiSub => Ok(const_int(a - b)),
  ast::BiMul => Ok(const_int(a * b)),
@@ -443,7 +443,7 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
  }
  }
  (Ok(const_uint(a)), Ok(const_uint(b))) => {
- match op {
+ match op.node {
  ast::BiAdd => Ok(const_uint(a + b)),
  ast::BiSub => Ok(const_uint(a - b)),
  ast::BiMul => Ok(const_uint(a * b)),
@@ -471,21 +471,21 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
  }
  // shifts can have any integral type as their rhs
  (Ok(const_int(a)), Ok(const_uint(b))) => {
- match op {
+ match op.node {
  ast::BiShl => Ok(const_int(a << b as uint)),
  ast::BiShr => Ok(const_int(a >> b as uint)),
  _ => Err("can't do this op on an int and uint".to_string())
  }
  }
  (Ok(const_uint(a)), Ok(const_int(b))) => {
- match op {
+ match op.node {
  ast::BiShl => Ok(const_uint(a << b as uint)),
  ast::BiShr => Ok(const_uint(a >> b as uint)),
  _ => Err("can't do this op on a uint and int".to_string())
  }
  }
  (Ok(const_bool(a)), Ok(const_bool(b))) => {
- Ok(const_bool(match op {
+ Ok(const_bool(match op.node {
  ast::BiAnd => a && b,
  ast::BiOr => a || b,
  ast::BiBitXor => a ^ b,

src/librustc/middle/expr_use_visitor.rs

@@ -568,7 +568,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
  }
 
  ast::ExprBinary(op, ref lhs, ref rhs) => {
- let pass_args = if ast_util::is_by_value_binop(op) {
+ let pass_args = if ast_util::is_by_value_binop(op.node) {
  PassArgs::ByValue
  } else {
  PassArgs::ByRef

src/librustc/middle/liveness.rs

@@ -504,7 +504,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
  ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
  visit::walk_expr(ir, expr);
  }
- ast::ExprBinary(op, _, _) if ast_util::lazy_binop(op) => {
+ ast::ExprBinary(op, _, _) if ast_util::lazy_binop(op.node) => {
  ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
  visit::walk_expr(ir, expr);
  }
@@ -1177,7 +1177,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
  self.propagate_through_exprs(&exprs[], succ)
  }
 
- ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => {
+ ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op.node) => {
  let r_succ = self.propagate_through_expr(&**r, succ);
 
  let ln = self.live_node(expr.id, expr.span);

src/librustc/middle/region.rs

@@ -22,7 +22,7 @@ use util::nodemap::{FnvHashMap, FnvHashSet, NodeMap};
 use util::common::can_reach;
 
 use std::cell::RefCell;
-use syntax::codemap::Span;
+use syntax::codemap::{self, Span};
 use syntax::{ast, visit};
 use syntax::ast::{Block, Item, FnDecl, NodeId, Arm, Pat, Stmt, Expr, Local};
 use syntax::ast_util::{stmt_id};
@@ -496,8 +496,8 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) {
  // scopes, meaning that temporaries cannot outlive them.
  // This ensures fixed size stacks.
 
- ast::ExprBinary(ast::BiAnd, _, ref r) |
- ast::ExprBinary(ast::BiOr, _, ref r) => {
+ ast::ExprBinary(codemap::Spanned { node: ast::BiAnd, .. }, _, ref r) |
+ ast::ExprBinary(codemap::Spanned { node: ast::BiOr, .. }, _, ref r) => {
  // For shortcircuiting operators, mark the RHS as a terminating
  // scope since it only executes conditionally.
  terminating(r.id);

src/librustc/middle/ty.rs

@@ -5716,7 +5716,7 @@ pub fn is_binopable<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, op: ast::BinOp) -> bool
  static opcat_mod: int = 8;
 
  fn opcat(op: ast::BinOp) -> int {
- match op {
+ match op.node {
  ast::BiAdd => opcat_add,
  ast::BiSub => opcat_sub,
  ast::BiMul => opcat_mult,

src/librustc_back/svh.rs

@@ -231,7 +231,7 @@ mod svh_visitor {
  SawExprCall,
  SawExprMethodCall,
  SawExprTup,
- SawExprBinary(ast::BinOp),
+ SawExprBinary(ast::BinOp_),
  SawExprUnary(ast::UnOp),
  SawExprLit(ast::Lit_),
  SawExprCast,
@@ -241,7 +241,7 @@ mod svh_visitor {
  SawExprClosure,
  SawExprBlock,
  SawExprAssign,
- SawExprAssignOp(ast::BinOp),
+ SawExprAssignOp(ast::BinOp_),
  SawExprIndex,
  SawExprRange,
  SawExprPath,
@@ -262,7 +262,7 @@ mod svh_visitor {
  ExprCall(..) => SawExprCall,
  ExprMethodCall(..) => SawExprMethodCall,
  ExprTup(..) => SawExprTup,
- ExprBinary(op, _, _) => SawExprBinary(op),
+ ExprBinary(op, _, _) => SawExprBinary(op.node),
  ExprUnary(op, _) => SawExprUnary(op),
  ExprLit(ref lit) => SawExprLit(lit.node.clone()),
  ExprCast(..) => SawExprCast,
@@ -273,7 +273,7 @@ mod svh_visitor {
  ExprClosure(..) => SawExprClosure,
  ExprBlock(..) => SawExprBlock,
  ExprAssign(..) => SawExprAssign,
- ExprAssignOp(op, _, _) => SawExprAssignOp(op),
+ ExprAssignOp(op, _, _) => SawExprAssignOp(op.node),
  ExprField(_, id) => SawExprField(content(id.node)),
  ExprTupField(_, id) => SawExprTupField(id.node),
  ExprIndex(..) => SawExprIndex,

src/librustc_trans/trans/base.rs

@@ -540,7 +540,7 @@ pub fn compare_scalar_types<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
  lhs: ValueRef,
  rhs: ValueRef,
  t: Ty<'tcx>,
- op: ast::BinOp)
+ op: ast::BinOp_)
  -> Result<'blk, 'tcx> {
  let f = |&: a| Result::new(cx, compare_scalar_values(cx, lhs, rhs, a, op));
 
@@ -561,7 +561,7 @@ pub fn compare_scalar_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
  lhs: ValueRef,
  rhs: ValueRef,
  nt: scalar_type,
- op: ast::BinOp)
+ op: ast::BinOp_)
  -> ValueRef {
  let _icx = push_ctxt("compare_scalar_values");
  fn die(cx: Block) -> ! {
@@ -635,7 +635,7 @@ pub fn compare_simd_types<'blk, 'tcx>(
  not supported for floating point SIMD types")
  },
  ty::ty_uint(_) | ty::ty_int(_) => {
- let cmp = match op {
+ let cmp = match op.node {
  ast::BiEq => llvm::IntEQ,
  ast::BiNe => llvm::IntNE,
  ast::BiLt => llvm::IntSLT,
@@ -823,7 +823,7 @@ pub fn cast_shift_rhs<F, G>(op: ast::BinOp,
  G: FnOnce(ValueRef, Type) -> ValueRef,
 {
  // Shifts may have any size int on the rhs
- if ast_util::is_shift_binop(op) {
+ if ast_util::is_shift_binop(op.node) {
  let mut rhs_llty = val_ty(rhs);
  let mut lhs_llty = val_ty(lhs);
  if rhs_llty.kind() == Vector { rhs_llty = rhs_llty.element_type() }
@@ -852,7 +852,7 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>(
  rhs: ValueRef,
  rhs_t: Ty<'tcx>)
  -> Block<'blk, 'tcx> {
- let (zero_text, overflow_text) = if divrem == ast::BiDiv {
+ let (zero_text, overflow_text) = if divrem.node == ast::BiDiv {
  ("attempted to divide by zero",
  "attempted to divide with overflow")
  } else {

src/librustc_trans/trans/consts.rs

@@ -310,7 +310,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
  let ty = ty::expr_ty(cx.tcx(), &**e1);
  let is_float = ty::type_is_fp(ty);
  let signed = ty::type_is_signed(ty);
- return match b {
+ return match b.node {
  ast::BiAdd => {
  if is_float { llvm::LLVMConstFAdd(te1, te2) }
  else { llvm::LLVMConstAdd(te1, te2) }