Remove trivial cast checker

I consider the added complexity not justified at this point, and it
interacts badly with the patches for issue #828. Feel free to discuss.

Author: marijnh

src/comp/middle/check_const.rs

@@ -43,7 +43,6 @@ fn check_expr(sess: session, e: @expr, &&is_const: bool, v: visit::vt<bool>) {
                           "disallowed operator in constant expression");
             ret;
           }
-          expr_cast(_, _) { }
           expr_lit(@{node: lit_str(_), _}) {
             sess.span_err(e.span,
                           "string constants are not supported");

src/comp/middle/trans.rs

@@ -3581,12 +3581,7 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
         }
         else { ret lval_to_dps(bcx, a, dest); }
       }
-      ast::expr_cast(val, _) {
-        alt tcx.cast_map.find(e.id) {
-          some(ty::triv_cast.) { ret trans_expr(bcx, val, dest); }
-          _ { ret trans_cast(bcx, val, e.id, dest); }
-        }
-      }
+      ast::expr_cast(val, _) { ret trans_cast(bcx, val, e.id, dest); }
       ast::expr_anon_obj(anon_obj) {
         ret trans_anon_obj(bcx, e.span, anon_obj, e.id, dest);
       }
@@ -3615,7 +3610,7 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
         // that is_call_expr(ex) -- but we don't support that
         // yet
         // FIXME
-        check (ast_util::is_tail_call_expr(ex));
+        check (ast_util::is_call_expr(ex));
         ret trans_be(bcx, ex);
       }
       ast::expr_fail(expr) {
@@ -3952,8 +3947,7 @@ fn trans_ret(bcx: @block_ctxt, e: option::t<@ast::expr>) -> @block_ctxt {
 fn build_return(bcx: @block_ctxt) { Br(bcx, bcx_fcx(bcx).llreturn); }
 
 // fn trans_be(cx: &@block_ctxt, e: &@ast::expr) -> result {
-fn trans_be(cx: @block_ctxt, e: @ast::expr) :
-ast_util::is_tail_call_expr(e) ->
+fn trans_be(cx: @block_ctxt, e: @ast::expr) : ast_util::is_call_expr(e) ->
    @block_ctxt {
     // FIXME: Turn this into a real tail call once
     // calling convention issues are settled
@@ -4728,16 +4722,6 @@ fn trans_impl(cx: @local_ctxt, name: ast::ident, methods: [@ast::method],
 // that does so later on?
 fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
     alt e.node {
-      ast::expr_cast(e1, _) {
-        alt ccx_tcx(cx).cast_map.find(e.id) {
-          some(ty::triv_cast.) { trans_const_expr(cx, e1) }
-          _ {
-              cx.sess.span_err(e.span,
-                               "non-trivial cast in constant expression");
-              fail;
-            }
-        }
-      }
       ast::expr_lit(lit) { ret trans_crate_lit(cx, *lit); }
       ast::expr_binary(b, e1, e2) {
         let te1 = trans_const_expr(cx, e1);

src/comp/middle/ty.rs

@@ -31,7 +31,6 @@ export ast_constr_to_constr;
 export bind_params_in_type;
 export block_ty;
 export constr;
-export cast_type;
 export constr_general;
 export constr_table;
 export count_ty_params;
@@ -106,8 +105,6 @@ export substitute_type_params;
 export t;
 export tag_variants;
 export tag_variant_with_id;
-export triv_cast;
-export triv_eq_ty;
 export ty_param_substs_opt_and_ty;
 export ty_param_kinds_and_ty;
 export ty_native_fn;
@@ -133,7 +130,6 @@ export ty_param;
 export ty_ptr;
 export ty_rec;
 export ty_tag;
-export ty_to_machine_ty;
 export ty_tup;
 export ty_type;
 export ty_send_type;
@@ -214,17 +210,10 @@ type creader_cache = hashmap<{cnum: int, pos: uint, len: uint}, ty::t>;
 type tag_var_cache =
     @smallintmap::smallintmap<@mutable [variant_info]>;
 
-tag cast_type {
-    /* cast may be ignored after substituting primitive with machine types
-       since expr already has the right type */
-    triv_cast;
-}
-
 type ctxt =
     @{ts: @type_store,
       sess: session::session,
       def_map: resolve::def_map,
-      cast_map: hashmap<ast::node_id, cast_type>,
       node_types: node_type_table,
       items: ast_map::map,
       freevars: freevars::freevar_map,
@@ -420,7 +409,6 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
         @{ts: ts,
           sess: s,
           def_map: dm,
-          cast_map: ast_util::new_node_hash(),
           node_types: ntt,
           items: amap,
           freevars: freevars,
@@ -1423,42 +1411,6 @@ fn eq_raw_ty(&&a: @raw_t, &&b: @raw_t) -> bool {
 // the types are interned.
 fn eq_ty(&&a: t, &&b: t) -> bool { a == b }
 
-
-// Convert type to machine type
-// (i.e. replace uint, int, float with target architecture machine types)
-//
-// FIXME somewhat expensive but this should only be called rarely
-fn ty_to_machine_ty(cx: ctxt, ty: t) -> t {
-    fn sub_fn(cx: ctxt, uint_ty: t, int_ty: t, float_ty: t, in: t) -> t {
-        alt struct(cx, in) {
-          ty_uint(ast::ty_u.) { ret uint_ty; }
-          ty_int(ast::ty_i.) { ret int_ty; }
-          ty_float(ast::ty_f.) { ret float_ty; }
-          _ { ret in; }
-        }
-    }
-
-    let cfg      = cx.sess.get_targ_cfg();
-    let uint_ty  = mk_mach_uint(cx, cfg.uint_type);
-    let int_ty   = mk_mach_int(cx, cfg.int_type);
-    let float_ty = mk_mach_float(cx, cfg.float_type);
-    let fold_m   = fm_general(bind sub_fn(cx, uint_ty, int_ty, float_ty, _));
-
-    ret fold_ty(cx, fold_m, ty);
-}
-
-// Two types are trivially equal if they are either
-// equal or if they are equal after substituting all occurences of
-//  machine independent primitive types by their machine type equivalents
-// for the current target architecture
-fn triv_eq_ty(cx: ctxt, &&a: t, &&b: t) -> bool {
-    let a = alt interner::get(*cx.ts, a).struct
-        { ty_named(t, _) { t } _ { a } };
-    let b = alt interner::get(*cx.ts, b).struct
-        { ty_named(t, _) { t } _ { b } };
-    a == b || ty_to_machine_ty(cx, a) == ty_to_machine_ty(cx, b)
-}
-
 // Type lookups
 fn node_id_to_ty_param_substs_opt_and_ty(cx: ctxt, id: ast::node_id) ->
    ty_param_substs_opt_and_ty {

src/comp/middle/typeck.rs

@@ -1850,21 +1850,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
       }
       ast::expr_be(e) {
         // FIXME: prove instead of assert
-        assert (ast_util::is_tail_call_expr(e));
+        assert (ast_util::is_call_expr(e));
         check_expr_with(fcx, e, fcx.ret_ty);
-
-        alt e.node {
-          ast::expr_cast(_, _) {
-            alt tcx.cast_map.find(e.id) {
-              option::some(ty::triv_cast.) { }
-              _ { tcx.sess.span_err(expr.span,
-                    "non-trivial cast of tail-call return value");
-                }
-            }
-          }
-          _ { /* regular tail call */ }
-        }
-
         bot = true;
         write::nil_ty(tcx, id);
       }
@@ -2066,19 +2053,19 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
       ast::expr_cast(e, t) {
         bot = check_expr(fcx, e);
         let t_1 = ast_ty_to_ty_crate(fcx.ccx, t);
-        let t_e = expr_ty(tcx, e);
+        let t_e = ty::expr_ty(tcx, e);
 
         if ty::type_is_nil(tcx, t_e) {
             tcx.sess.span_err(expr.span,
                               "cast from nil: " +
-                                  ty_to_str(tcx, expr_ty(tcx, e)) + " as " +
+                                  ty_to_str(tcx, t_e) + " as " +
                                   ty_to_str(tcx, t_1));
         }
 
         if ty::type_is_nil(tcx, t_1) {
             tcx.sess.span_err(expr.span,
                               "cast to nil: " +
-                                  ty_to_str(tcx, expr_ty(tcx, e)) + " as " +
+                                  ty_to_str(tcx, t_e) + " as " +
                                   ty_to_str(tcx, t_1));
         }
 
@@ -2087,14 +2074,9 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
              && type_is_scalar(fcx, expr.span, t_1)) {
             tcx.sess.span_err(expr.span,
                               "non-scalar cast: " +
-                                  ty_to_str(tcx, expr_ty(tcx, e)) + " as " +
+                                  ty_to_str(tcx, t_e) + " as " +
                                   ty_to_str(tcx, t_1));
         }
-
-        // mark as triv_cast for later dropping in trans
-        if ty::triv_eq_ty(tcx, t_1, t_e)
-            { tcx.cast_map.insert(expr.id, ty::triv_cast); }
-
         write::ty_only_fixup(fcx, id, t_1);
       }
       ast::expr_vec(args, mut) {

src/comp/syntax/ast_util.rs

@@ -1,19 +1,10 @@
-import core::{str, option, int};
-import std::map;
 import codemap::span;
 import ast::*;
 
 fn respan<copy T>(sp: span, t: T) -> spanned<T> {
     ret {node: t, span: sp};
 }
 
-fn new_node_hash<copy V>() -> map::hashmap<node_id, V> {
-    fn node_id_hash(&&i: node_id) -> uint { ret int::hash(i as int); }
-    fn node_id_eq(&&a: node_id, &&b: node_id) -> bool
-        { ret int::eq(a as int, b as int); }
-    ret map::mk_hashmap(node_id_hash, node_id_eq);
-}
-
 /* assuming that we're not in macro expansion */
 fn mk_sp(lo: uint, hi: uint) -> span {
     ret {lo: lo, hi: hi, expanded_from: codemap::os_none};
@@ -198,14 +189,6 @@ pure fn is_call_expr(e: @expr) -> bool {
     alt e.node { expr_call(_, _, _) { true } _ { false } }
 }
 
-pure fn is_tail_call_expr(e: @expr) -> bool {
-    alt e.node {
-      expr_call(_, _, _) { true }
-      expr_cast(inner_e, _) { is_call_expr(inner_e) }
-      _ { false }
-    }
-}
-
 fn is_constraint_arg(e: @expr) -> bool {
     alt e.node {
       expr_lit(_) { ret true; }

src/comp/syntax/parse/parser.rs

@@ -958,7 +958,7 @@ fn parse_bottom_expr(p: parser) -> @ast::expr {
         let e = parse_expr(p);
 
         // FIXME: Is this the right place for this check?
-        if /*check*/ ast_util::is_tail_call_expr(e) {
+        if /*check*/ast_util::is_call_expr(e) {
             hi = e.span.hi;
             ex = ast::expr_be(e);
         } else { p.fatal("Non-call expression in tail call"); }