src/librustc_typeck/check/op.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Code related to processing overloaded binary and unary operators.
  12
  13 use super::{
  14     check_expr,
  15     check_expr_coercable_to_type,
  16     check_expr_with_lvalue_pref,
  17     demand,
  18     method,
  19     FnCtxt,
  20 };
  21 use middle::def_id::DefId;
  22 use middle::ty::{Ty, HasTypeFlags, PreferMutLvalue};
  23 use syntax::ast;
  24 use syntax::parse::token;
  25 use rustc_front::hir;
  26 use rustc_front::util as hir_util;
  27
  28 /// Check a `a <op>= b`
  29 pub fn check_binop_assign<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
  30                                    expr: &'tcx hir::Expr,
  31                                    op: hir::BinOp,
  32                                    lhs_expr: &'tcx hir::Expr,
  33                                    rhs_expr: &'tcx hir::Expr)
  34 {
  35     check_expr_with_lvalue_pref(fcx, lhs_expr, PreferMutLvalue);
  36
  37     let lhs_ty = fcx.resolve_type_vars_if_possible(fcx.expr_ty(lhs_expr));
  38     let (rhs_ty, return_ty) =
  39         check_overloaded_binop(fcx, expr, lhs_expr, lhs_ty, rhs_expr, op, true);
  40     let rhs_ty = fcx.resolve_type_vars_if_possible(rhs_ty);
  41
  42     if !lhs_ty.is_ty_var() && !rhs_ty.is_ty_var() && is_builtin_binop(lhs_ty, rhs_ty, op) {
  43         enforce_builtin_binop_types(fcx, lhs_expr, lhs_ty, rhs_expr, rhs_ty, op);
  44         fcx.write_nil(expr.id);
  45     } else {
  46         fcx.write_ty(expr.id, return_ty);
  47     }
  48
  49     let tcx = fcx.tcx();
  50     if !tcx.expr_is_lval(lhs_expr) {
  51         span_err!(tcx.sess, lhs_expr.span, E0067, "invalid left-hand side expression");
  52     }
  53 }
  54
  55 /// Check a potentially overloaded binary operator.
  56 pub fn check_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
  57                              expr: &'tcx hir::Expr,
  58                              op: hir::BinOp,
  59                              lhs_expr: &'tcx hir::Expr,
  60                              rhs_expr: &'tcx hir::Expr)
  61 {
  62     let tcx = fcx.ccx.tcx;
  63
  64     debug!("check_binop(expr.id={}, expr={:?}, op={:?}, lhs_expr={:?}, rhs_expr={:?})",
  65            expr.id,
  66            expr,
  67            op,
  68            lhs_expr,
  69            rhs_expr);
  70
  71     check_expr(fcx, lhs_expr);
  72     let lhs_ty = fcx.resolve_type_vars_if_possible(fcx.expr_ty(lhs_expr));
  73
  74     match BinOpCategory::from(op) {
  75         BinOpCategory::Shortcircuit => {
  76             // && and || are a simple case.
  77             demand::suptype(fcx, lhs_expr.span, tcx.mk_bool(), lhs_ty);
  78             check_expr_coercable_to_type(fcx, rhs_expr, tcx.mk_bool());
  79             fcx.write_ty(expr.id, tcx.mk_bool());
  80         }
  81         _ => {
  82             // Otherwise, we always treat operators as if they are
  83             // overloaded. This is the way to be most flexible w/r/t
  84             // types that get inferred.
  85             let (rhs_ty, return_ty) =
  86                 check_overloaded_binop(fcx, expr, lhs_expr, lhs_ty, rhs_expr, op, false);
  87
  88             // Supply type inference hints if relevant. Probably these
  89             // hints should be enforced during select as part of the
  90             // `consider_unification_despite_ambiguity` routine, but this
  91             // more convenient for now.
  92             //
  93             // The basic idea is to help type inference by taking
  94             // advantage of things we know about how the impls for
  95             // scalar types are arranged. This is important in a
  96             // scenario like `1_u32 << 2`, because it lets us quickly
  97             // deduce that the result type should be `u32`, even
  98             // though we don't know yet what type 2 has and hence
  99             // can't pin this down to a specific impl.
 100             let rhs_ty = fcx.resolve_type_vars_if_possible(rhs_ty);
 101             if
 102                 !lhs_ty.is_ty_var() && !rhs_ty.is_ty_var() &&
 103                 is_builtin_binop(lhs_ty, rhs_ty, op)
 104             {
 105                 let builtin_return_ty =
 106                     enforce_builtin_binop_types(fcx, lhs_expr, lhs_ty, rhs_expr, rhs_ty, op);
 107                 demand::suptype(fcx, expr.span, builtin_return_ty, return_ty);
 108             }
 109
 110             fcx.write_ty(expr.id, return_ty);
 111         }
 112     }
 113 }
 114
 115 fn enforce_builtin_binop_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 116                                          lhs_expr: &'tcx hir::Expr,
 117                                          lhs_ty: Ty<'tcx>,
 118                                          rhs_expr: &'tcx hir::Expr,
 119                                          rhs_ty: Ty<'tcx>,
 120                                          op: hir::BinOp)
 121                                          -> Ty<'tcx>
 122 {
 123     debug_assert!(is_builtin_binop(lhs_ty, rhs_ty, op));
 124
 125     let tcx = fcx.tcx();
 126     match BinOpCategory::from(op) {
 127         BinOpCategory::Shortcircuit => {
 128             demand::suptype(fcx, lhs_expr.span, tcx.mk_bool(), lhs_ty);
 129             demand::suptype(fcx, rhs_expr.span, tcx.mk_bool(), rhs_ty);
 130             tcx.mk_bool()
 131         }
 132
 133         BinOpCategory::Shift => {
 134             // result type is same as LHS always
 135             lhs_ty
 136         }
 137
 138         BinOpCategory::Math |
 139         BinOpCategory::Bitwise => {
 140             // both LHS and RHS and result will have the same type
 141             demand::suptype(fcx, rhs_expr.span, lhs_ty, rhs_ty);
 142             lhs_ty
 143         }
 144
 145         BinOpCategory::Comparison => {
 146             // both LHS and RHS and result will have the same type
 147             demand::suptype(fcx, rhs_expr.span, lhs_ty, rhs_ty);
 148             tcx.mk_bool()
 149         }
 150     }
 151 }
 152
 153 fn check_overloaded_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 154                                     expr: &'tcx hir::Expr,
 155                                     lhs_expr: &'tcx hir::Expr,
 156                                     lhs_ty: Ty<'tcx>,
 157                                     rhs_expr: &'tcx hir::Expr,
 158                                     op: hir::BinOp,
 159                                     assign: bool)
 160                                     -> (Ty<'tcx>, Ty<'tcx>)
 161 {
 162     debug!("check_overloaded_binop(expr.id={}, lhs_ty={:?}, assign={})",
 163            expr.id,
 164            lhs_ty,
 165            assign);
 166
 167     let (name, trait_def_id) = name_and_trait_def_id(fcx, op, assign);
 168
 169     // NB: As we have not yet type-checked the RHS, we don't have the
 170     // type at hand. Make a variable to represent it. The whole reason
 171     // for this indirection is so that, below, we can check the expr
 172     // using this variable as the expected type, which sometimes lets
 173     // us do better coercions than we would be able to do otherwise,
 174     // particularly for things like `String + &String`.
 175     let rhs_ty_var = fcx.infcx().next_ty_var();
 176
 177     let return_ty = match lookup_op_method(fcx, expr, lhs_ty, vec![rhs_ty_var],
 178                                            token::intern(name), trait_def_id,
 179                                            lhs_expr) {
 180         Ok(return_ty) => return_ty,
 181         Err(()) => {
 182             // error types are considered "builtin"
 183             if !lhs_ty.references_error() {
 184                 if assign {
 185                     span_err!(fcx.tcx().sess, lhs_expr.span, E0368,
 186                               "binary assignment operation `{}=` cannot be applied to type `{}`",
 187                               hir_util::binop_to_string(op.node),
 188                               lhs_ty);
 189                 } else {
 190                     span_err!(fcx.tcx().sess, lhs_expr.span, E0369,
 191                               "binary operation `{}` cannot be applied to type `{}`",
 192                               hir_util::binop_to_string(op.node),
 193                               lhs_ty);
 194                 }
 195             }
 196             fcx.tcx().types.err
 197         }
 198     };
 199
 200     // see `NB` above
 201     check_expr_coercable_to_type(fcx, rhs_expr, rhs_ty_var);
 202
 203     (rhs_ty_var, return_ty)
 204 }
 205
 206 pub fn check_user_unop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 207                                  op_str: &str,
 208                                  mname: &str,
 209                                  trait_did: Option<DefId>,
 210                                  ex: &'tcx hir::Expr,
 211                                  operand_expr: &'tcx hir::Expr,
 212                                  operand_ty: Ty<'tcx>,
 213                                  op: hir::UnOp)
 214                                  -> Ty<'tcx>
 215 {
 216     assert!(hir_util::is_by_value_unop(op));
 217     match lookup_op_method(fcx, ex, operand_ty, vec![],
 218                            token::intern(mname), trait_did,
 219                            operand_expr) {
 220         Ok(t) => t,
 221         Err(()) => {
 222             fcx.type_error_message(ex.span, |actual| {
 223                 format!("cannot apply unary operator `{}` to type `{}`",
 224                         op_str, actual)
 225             }, operand_ty, None);
 226             fcx.tcx().types.err
 227         }
 228     }
 229 }
 230
 231 fn name_and_trait_def_id(fcx: &FnCtxt,
 232                          op: hir::BinOp,
 233                          assign: bool)
 234                          -> (&'static str, Option<DefId>) {
 235     let lang = &fcx.tcx().lang_items;
 236
 237     if assign {
 238         match op.node {
 239             hir::BiAdd => ("add_assign", lang.add_assign_trait()),
 240             hir::BiSub => ("sub_assign", lang.sub_assign_trait()),
 241             hir::BiMul => ("mul_assign", lang.mul_assign_trait()),
 242             hir::BiDiv => ("div_assign", lang.div_assign_trait()),
 243             hir::BiRem => ("rem_assign", lang.rem_assign_trait()),
 244             hir::BiBitXor => ("bitxor_assign", lang.bitxor_assign_trait()),
 245             hir::BiBitAnd => ("bitand_assign", lang.bitand_assign_trait()),
 246             hir::BiBitOr => ("bitor_assign", lang.bitor_assign_trait()),
 247             hir::BiShl => ("shl_assign", lang.shl_assign_trait()),
 248             hir::BiShr => ("shr_assign", lang.shr_assign_trait()),
 249             hir::BiLt | hir::BiLe | hir::BiGe | hir::BiGt | hir::BiEq | hir::BiNe | hir::BiAnd |
 250             hir::BiOr => {
 251                 fcx.tcx().sess.span_bug(op.span, &format!("impossible assignment operation: {}=",
 252                                         hir_util::binop_to_string(op.node)))
 253             }
 254         }
 255     } else {
 256         match op.node {
 257             hir::BiAdd => ("add", lang.add_trait()),
 258             hir::BiSub => ("sub", lang.sub_trait()),
 259             hir::BiMul => ("mul", lang.mul_trait()),
 260             hir::BiDiv => ("div", lang.div_trait()),
 261             hir::BiRem => ("rem", lang.rem_trait()),
 262             hir::BiBitXor => ("bitxor", lang.bitxor_trait()),
 263             hir::BiBitAnd => ("bitand", lang.bitand_trait()),
 264             hir::BiBitOr => ("bitor", lang.bitor_trait()),
 265             hir::BiShl => ("shl", lang.shl_trait()),
 266             hir::BiShr => ("shr", lang.shr_trait()),
 267             hir::BiLt => ("lt", lang.ord_trait()),
 268             hir::BiLe => ("le", lang.ord_trait()),
 269             hir::BiGe => ("ge", lang.ord_trait()),
 270             hir::BiGt => ("gt", lang.ord_trait()),
 271             hir::BiEq => ("eq", lang.eq_trait()),
 272             hir::BiNe => ("ne", lang.eq_trait()),
 273             hir::BiAnd | hir::BiOr => {
 274                 fcx.tcx().sess.span_bug(op.span, "&& and || are not overloadable")
 275             }
 276         }
 277     }
 278 }
 279
 280 fn lookup_op_method<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
 281                               expr: &'tcx hir::Expr,
 282                               lhs_ty: Ty<'tcx>,
 283                               other_tys: Vec<Ty<'tcx>>,
 284                               opname: ast::Name,
 285                               trait_did: Option<DefId>,
 286                               lhs_expr: &'a hir::Expr)
 287                               -> Result<Ty<'tcx>,()>
 288 {
 289     debug!("lookup_op_method(expr={:?}, lhs_ty={:?}, opname={:?}, trait_did={:?}, lhs_expr={:?})",
 290            expr,
 291            lhs_ty,
 292            opname,
 293            trait_did,
 294            lhs_expr);
 295
 296     let method = match trait_did {
 297         Some(trait_did) => {
 298             method::lookup_in_trait_adjusted(fcx,
 299                                              expr.span,
 300                                              Some(lhs_expr),
 301                                              opname,
 302                                              trait_did,
 303                                              0,
 304                                              false,
 305                                              lhs_ty,
 306                                              Some(other_tys))
 307         }
 308         None => None
 309     };
 310
 311     match method {
 312         Some(method) => {
 313             let method_ty = method.ty;
 314
 315             // HACK(eddyb) Fully qualified path to work around a resolve bug.
 316             let method_call = ::middle::ty::MethodCall::expr(expr.id);
 317             fcx.inh.tables.borrow_mut().method_map.insert(method_call, method);
 318
 319             // extract return type for method; all late bound regions
 320             // should have been instantiated by now
 321             let ret_ty = method_ty.fn_ret();
 322             Ok(fcx.tcx().no_late_bound_regions(&ret_ty).unwrap().unwrap())
 323         }
 324         None => {
 325             Err(())
 326         }
 327     }
 328 }
 329
 330 // Binary operator categories. These categories summarize the behavior
 331 // with respect to the builtin operationrs supported.
 332 enum BinOpCategory {
 333     /// &&, || -- cannot be overridden
 334     Shortcircuit,
 335
 336     /// <<, >> -- when shifting a single integer, rhs can be any
 337     /// integer type. For simd, types must match.
 338     Shift,
 339
 340     /// +, -, etc -- takes equal types, produces same type as input,
 341     /// applicable to ints/floats/simd
 342     Math,
 343
 344     /// &, |, ^ -- takes equal types, produces same type as input,
 345     /// applicable to ints/floats/simd/bool
 346     Bitwise,
 347
 348     /// ==, !=, etc -- takes equal types, produces bools, except for simd,
 349     /// which produce the input type
 350     Comparison,
 351 }
 352
 353 impl BinOpCategory {
 354     fn from(op: hir::BinOp) -> BinOpCategory {
 355         match op.node {
 356             hir::BiShl | hir::BiShr =>
 357                 BinOpCategory::Shift,
 358
 359             hir::BiAdd |
 360             hir::BiSub |
 361             hir::BiMul |
 362             hir::BiDiv |
 363             hir::BiRem =>
 364                 BinOpCategory::Math,
 365
 366             hir::BiBitXor |
 367             hir::BiBitAnd |
 368             hir::BiBitOr =>
 369                 BinOpCategory::Bitwise,
 370
 371             hir::BiEq |
 372             hir::BiNe |
 373             hir::BiLt |
 374             hir::BiLe |
 375             hir::BiGe |
 376             hir::BiGt =>
 377                 BinOpCategory::Comparison,
 378
 379             hir::BiAnd |
 380             hir::BiOr =>
 381                 BinOpCategory::Shortcircuit,
 382         }
 383     }
 384 }
 385
 386 /// Returns true if this is a built-in arithmetic operation (e.g. u32
 387 /// + u32, i16x4 == i16x4) and false if these types would have to be
 388 /// overloaded to be legal. There are two reasons that we distinguish
 389 /// builtin operations from overloaded ones (vs trying to drive
 390 /// everything uniformly through the trait system and intrinsics or
 391 /// something like that):
 392 ///
 393 /// 1. Builtin operations can trivially be evaluated in constants.
 394 /// 2. For comparison operators applied to SIMD types the result is
 395 ///    not of type `bool`. For example, `i16x4==i16x4` yields a
 396 ///    type like `i16x4`. This means that the overloaded trait
 397 ///    `PartialEq` is not applicable.
 398 ///
 399 /// Reason #2 is the killer. I tried for a while to always use
 400 /// overloaded logic and just check the types in constants/trans after
 401 /// the fact, and it worked fine, except for SIMD types. -nmatsakis
 402 fn is_builtin_binop<'tcx>(lhs: Ty<'tcx>,
 403                           rhs: Ty<'tcx>,
 404                           op: hir::BinOp)
 405                           -> bool
 406 {
 407     match BinOpCategory::from(op) {
 408         BinOpCategory::Shortcircuit => {
 409             true
 410         }
 411
 412         BinOpCategory::Shift => {
 413             lhs.references_error() || rhs.references_error() ||
 414                 lhs.is_integral() && rhs.is_integral()
 415         }
 416
 417         BinOpCategory::Math => {
 418             lhs.references_error() || rhs.references_error() ||
 419                 lhs.is_integral() && rhs.is_integral() ||
 420                 lhs.is_floating_point() && rhs.is_floating_point()
 421         }
 422
 423         BinOpCategory::Bitwise => {
 424             lhs.references_error() || rhs.references_error() ||
 425                 lhs.is_integral() && rhs.is_integral() ||
 426                 lhs.is_floating_point() && rhs.is_floating_point() ||
 427                 lhs.is_bool() && rhs.is_bool()
 428         }
 429
 430         BinOpCategory::Comparison => {
 431             lhs.references_error() || rhs.references_error() ||
 432                 lhs.is_scalar() && rhs.is_scalar()
 433         }
 434     }
 435 }