Further work on integer literal suffix inference (#1425)

In this commit:

  * Change the lit_int_unsuffixed AST node to not carry a type, since
    it doesn't need one

  * Don't print "(unsuffixed)" when pretty-printing unsuffixed integer
    literals

  * Just print "I" instead of "(integral)" for integral type variables

  * Set up trans to use the information that will be gathered during
    typeck to construct the appropriate constants for unsuffixed int
    literals

  * Add logic for handling int_ty_sets in typeck::infer

  * Clean up unnecessary code in typeck::infer

  * Add missing mk_ functions to middle::ty

  * Add ty_var_integral to a few of the type utility functions it was
    missing from in middle::ty

Author: lkuper

src/libsyntax/ast.rs

@@ -402,7 +402,7 @@ enum lit_ {
     lit_str(@str),
     lit_int(i64, int_ty),
     lit_uint(u64, uint_ty),
-    lit_int_unsuffixed(i64, int_ty),
+    lit_int_unsuffixed(i64),
     lit_float(@str, float_ty),
     lit_nil,
     lit_bool(bool),

src/libsyntax/parse/classify.rs

@@ -54,7 +54,7 @@ fn ends_in_lit_int(ex: @ast::expr) -> bool {
       ast::expr_lit(node) {
         alt node {
           @{node: ast::lit_int(_, ast::ty_i), _} |
-          @{node: ast::lit_int_unsuffixed(_, ast::ty_i), _}
+          @{node: ast::lit_int_unsuffixed(_), _}
           { true }
           _ { false }
         }

src/libsyntax/parse/lexer.rs

@@ -285,7 +285,7 @@ fn scan_number(c: char, rdr: reader) -> token::token {
 
         #debug["lexing %s as an unsuffixed integer literal",
                num_str];
-        ret token::LIT_INT_UNSUFFIXED(parsed as i64, ast::ty_i);
+        ret token::LIT_INT_UNSUFFIXED(parsed as i64);
     }
 }
 

src/libsyntax/parse/parser.rs

@@ -501,7 +501,7 @@ class parser {
             let lo = self.span.lo;
             self.bump();
             alt copy self.token {
-              token::LIT_INT_UNSUFFIXED(num, _) {
+              token::LIT_INT_UNSUFFIXED(num) {
                 self.bump();
                 some(mac_var(num as uint))
               }
@@ -534,7 +534,7 @@ class parser {
               token::UNDERSCORE {
                 self.bump(); some(vstore_fixed(none))
               }
-              token::LIT_INT_UNSUFFIXED(i, _) if i >= 0i64 {
+              token::LIT_INT_UNSUFFIXED(i) if i >= 0i64 {
                 self.bump(); some(vstore_fixed(some(i as uint)))
               }
               token::BINOP(token::AND) {
@@ -553,7 +553,7 @@ class parser {
         alt tok {
           token::LIT_INT(i, it) { lit_int(i, it) }
           token::LIT_UINT(u, ut) { lit_uint(u, ut) }
-          token::LIT_INT_UNSUFFIXED(i, it) { lit_int_unsuffixed(i, it) }
+          token::LIT_INT_UNSUFFIXED(i) { lit_int_unsuffixed(i) }
           token::LIT_FLOAT(s, ft) { lit_float(self.get_str(s), ft) }
           token::LIT_STR(s) { lit_str(self.get_str(s)) }
           token::LPAREN { self.expect(token::RPAREN); lit_nil }

src/libsyntax/parse/token.rs

@@ -57,7 +57,7 @@ enum token {
     /* Literals */
     LIT_INT(i64, ast::int_ty),
     LIT_UINT(u64, ast::uint_ty),
-    LIT_INT_UNSUFFIXED(i64, ast::int_ty),
+    LIT_INT_UNSUFFIXED(i64),
     LIT_FLOAT(str_num, ast::float_ty),
     LIT_STR(str_num),
 
@@ -129,8 +129,8 @@ fn to_str(in: interner<@str>, t: token) -> str {
       LIT_UINT(u, t) {
         uint::to_str(u as uint, 10u) + ast_util::uint_ty_to_str(t)
       }
-      LIT_INT_UNSUFFIXED(i, t) {
-        int::to_str(i as int, 10u) + ast_util::int_ty_to_str(t)
+      LIT_INT_UNSUFFIXED(i) {
+        int::to_str(i as int, 10u)
       }
       LIT_FLOAT(s, t) {
         *interner::get(in, s) +
@@ -160,7 +160,7 @@ pure fn can_begin_expr(t: token) -> bool {
       TILDE { true }
       LIT_INT(_, _) { true }
       LIT_UINT(_, _) { true }
-      LIT_INT_UNSUFFIXED(_, _) { true }
+      LIT_INT_UNSUFFIXED(_) { true }
       LIT_FLOAT(_, _) { true }
       LIT_STR(_) { true }
       POUND { true }
@@ -178,7 +178,7 @@ fn is_lit(t: token) -> bool {
     alt t {
       LIT_INT(_, _) { true }
       LIT_UINT(_, _) { true }
-      LIT_INT_UNSUFFIXED(_, _) { true }
+      LIT_INT_UNSUFFIXED(_) { true }
       LIT_FLOAT(_, _) { true }
       LIT_STR(_) { true }
       _ { false }

src/libsyntax/print/pprust.rs

@@ -1628,15 +1628,11 @@ fn print_literal(s: ps, &&lit: @ast::lit) {
              u64::to_str(u, 10u)
              + ast_util::uint_ty_to_str(t));
       }
-      ast::lit_int_unsuffixed(i, t) {
+      ast::lit_int_unsuffixed(i) {
         if i < 0_i64 {
-            word(s.s,
-                 "-" + u64::to_str(-i as u64, 10u)
-                 + ast_util::int_ty_to_str(t));
+            word(s.s, "-" + u64::to_str(-i as u64, 10u));
         } else {
-            word(s.s,
-                 u64::to_str(i as u64, 10u)
-                 + ast_util::int_ty_to_str(t));
+            word(s.s, u64::to_str(i as u64, 10u));
         }
       }
       ast::lit_float(f, t) {

src/rustc/metadata/tyencode.rs

@@ -278,10 +278,9 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         w.write_uint(id.to_uint());
       }
       ty::ty_var_integral(id) {
-        // TODO: should we have a different character for these? (Issue #1425)
         w.write_char('X');
+        w.write_char('I');
         w.write_uint(id.to_uint());
-        w.write_str("(integral)");
       }
       ty::ty_param(id, did) {
         w.write_char('p');

src/rustc/middle/const_eval.rs

@@ -111,7 +111,7 @@ fn lit_to_const(lit: @lit) -> const_val {
       lit_str(s) { const_str(*s) }
       lit_int(n, _) { const_int(n) }
       lit_uint(n, _) { const_uint(n) }
-      lit_int_unsuffixed(n, _) { const_int(n) }
+      lit_int_unsuffixed(n) { const_int(n) }
       lit_float(n, _) { const_float(option::get(float::from_str(*n)) as f64) }
       lit_nil { const_int(0i64) }
       lit_bool(b) { const_int(b as i64) }

src/rustc/middle/trans/base.rs

@@ -1473,15 +1473,25 @@ fn store_temp_expr(cx: block, action: copy_action, dst: ValueRef,
     ret move_val(cx, action, dst, src, t);
 }
 
-fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef {
+fn trans_crate_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit)
+    -> ValueRef {
     let _icx = cx.insn_ctxt("trans_crate_lit");
     alt lit.node {
       ast::lit_int(i, t) { C_integral(T_int_ty(cx, t), i as u64, True) }
       ast::lit_uint(u, t) { C_integral(T_uint_ty(cx, t), u, False) }
-      ast::lit_int_unsuffixed(i, t) {
-        // FIXME (#1425): should we be using cx.fcx.infcx to figure out what
-        // to actually generate from this?
-        C_integral(T_int_ty(cx, t), i as u64, True)
+      ast::lit_int_unsuffixed(i) {
+        let lit_int_ty = ty::node_id_to_type(cx.tcx, e.id);
+        alt ty::get(lit_int_ty).struct {
+          ty::ty_int(t) {
+            C_integral(T_int_ty(cx, t), i as u64, True)
+          }
+          ty::ty_uint(t) {
+            C_integral(T_uint_ty(cx, t), i as u64, False)
+          }
+          _ { cx.sess.span_bug(lit.span,
+                               "integer literal doesn't have a type");
+            }
+        }
       }
       ast::lit_float(fs, t) { C_floating(*fs, T_float_ty(cx, t)) }
       ast::lit_bool(b) { C_bool(b) }
@@ -1492,13 +1502,13 @@ fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef {
     }
 }
 
-fn trans_lit(cx: block, lit: ast::lit, dest: dest) -> block {
+fn trans_lit(cx: block, e: @ast::expr, lit: ast::lit, dest: dest) -> block {
     let _icx = cx.insn_ctxt("trans_lit");
     if dest == ignore { ret cx; }
     alt lit.node {
       ast::lit_str(s) { tvec::trans_estr(cx, s, ast::vstore_uniq, dest) }
       _ {
-        store_in_dest(cx, trans_crate_lit(cx.ccx(), lit), dest)
+        store_in_dest(cx, trans_crate_lit(cx.ccx(), e, lit), dest)
       }
     }
 }
@@ -3584,7 +3594,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
           }
           ast::expr_tup(args) { ret trans_tup(bcx, args, dest); }
           ast::expr_vstore(e, v) { ret tvec::trans_vstore(bcx, e, v, dest); }
-          ast::expr_lit(lit) { ret trans_lit(bcx, *lit, dest); }
+          ast::expr_lit(lit) { ret trans_lit(bcx, e, *lit, dest); }
           ast::expr_vec(args, _) {
             ret tvec::trans_evec(bcx, args, ast::vstore_uniq, e.id, dest);
           }
@@ -4684,7 +4694,7 @@ fn trans_enum_variant(ccx: @crate_ctxt, enum_id: ast::node_id,
 fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
     let _icx = cx.insn_ctxt("trans_const_expr");
     alt e.node {
-      ast::expr_lit(lit) { ret trans_crate_lit(cx, *lit); }
+      ast::expr_lit(lit) { ret trans_crate_lit(cx, e, *lit); }
       ast::expr_binary(b, e1, e2) {
         let te1 = trans_const_expr(cx, e1);
         let te2 = trans_const_expr(cx, e2);

src/rustc/middle/ty.rs

@@ -84,6 +84,7 @@ export ty_float, mk_float, mk_mach_float, type_is_fp;
 export ty_fn, fn_ty, mk_fn;
 export ty_fn_proto, ty_fn_ret, ty_fn_ret_style, tys_in_fn_ty;
 export ty_int, mk_int, mk_mach_int, mk_char;
+export mk_i8, mk_u8, mk_i16, mk_u16, mk_i32, mk_u32, mk_i64, mk_u64;
 export ty_str, mk_str, type_is_str;
 export ty_vec, mk_vec, type_is_vec;
 export ty_estr, mk_estr;
@@ -416,7 +417,8 @@ enum type_err {
     terr_vstores_differ(terr_vstore_kind, vstore, vstore),
     terr_in_field(@type_err, ast::ident),
     terr_sorts(t, t),
-    terr_self_substs
+    terr_self_substs,
+    terr_no_integral_type,
 }
 
 enum param_bound {
@@ -442,7 +444,7 @@ impl of vid for tv_vid {
 
 impl of vid for tvi_vid {
     fn to_uint() -> uint { *self }
-    fn to_str() -> str { #fmt["<V (integral) %u>", self.to_uint()] }
+    fn to_str() -> str { #fmt["<VI%u>", self.to_uint()] }
 }
 
 impl of vid for region_vid {
@@ -619,12 +621,26 @@ fn mk_bool(cx: ctxt) -> t { mk_t(cx, ty_bool) }
 
 fn mk_int(cx: ctxt) -> t { mk_t(cx, ty_int(ast::ty_i)) }
 
+fn mk_i8(cx: ctxt) -> t { mk_t(cx, ty_int(ast::ty_i8)) }
+
+fn mk_i16(cx: ctxt) -> t { mk_t(cx, ty_int(ast::ty_i16)) }
+
+fn mk_i32(cx: ctxt) -> t { mk_t(cx, ty_int(ast::ty_i32)) }
+
+fn mk_i64(cx: ctxt) -> t { mk_t(cx, ty_int(ast::ty_i64)) }
+
 fn mk_float(cx: ctxt) -> t { mk_t(cx, ty_float(ast::ty_f)) }
 
 fn mk_uint(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u)) }
 
 fn mk_u8(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u8)) }
 
+fn mk_u16(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u16)) }
+
+fn mk_u32(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u32)) }
+
+fn mk_u64(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u64)) }
+
 fn mk_mach_int(cx: ctxt, tm: ast::int_ty) -> t { mk_t(cx, ty_int(tm)) }
 
 fn mk_mach_uint(cx: ctxt, tm: ast::uint_ty) -> t { mk_t(cx, ty_uint(tm)) }
@@ -1188,7 +1204,7 @@ pure fn type_is_unique(ty: t) -> bool {
 pure fn type_is_scalar(ty: t) -> bool {
     alt get(ty).struct {
       ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_type | ty_ptr(_) | ty_rptr(_, _) { true }
+      ty_var_integral(_) | ty_type | ty_ptr(_) | ty_rptr(_, _) { true }
       _ { false }
     }
 }
@@ -1827,7 +1843,7 @@ fn type_structurally_contains_uniques(cx: ctxt, ty: t) -> bool {
 
 fn type_is_integral(ty: t) -> bool {
     alt get(ty).struct {
-      ty_int(_) | ty_uint(_) | ty_bool { true }
+      ty_var_integral(_) | ty_int(_) | ty_uint(_) | ty_bool { true }
       _ { false }
     }
 }
@@ -2531,6 +2547,10 @@ fn type_err_to_str(cx: ctxt, err: type_err) -> str {
       terr_self_substs {
         ret "inconsistent self substitution"; // XXX this is more of a bug
       }
+      terr_no_integral_type {
+        ret "couldn't determine an appropriate integral type for integer \
+             literal";
+      }
     }
 }
 
@@ -2966,7 +2986,7 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
     fn tycat(ty: t) -> int {
         alt get(ty).struct {
           ty_bool { tycat_bool }
-          ty_int(_) | ty_uint(_) { tycat_int }
+          ty_int(_) | ty_uint(_) | ty_var_integral(_) { tycat_int }
           ty_float(_) { tycat_float }
           ty_estr(_) | ty_str { tycat_str }
           ty_evec(_, _) | ty_vec(_) { tycat_vec }

src/rustc/middle/typeck/check.rs

@@ -73,11 +73,9 @@ import middle::ty::{tv_vid, vid};
 import regionmanip::{replace_bound_regions_in_fn_ty, region_of};
 import rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope};
 import rscope::{in_binding_rscope, region_scope, type_rscope};
-import syntax::ast::{ty_char, ty_i8, ty_i16, ty_i32, ty_i64, ty_i};
+import syntax::ast::{ty_char, ty_i};
 import typeck::infer::{root, to_str};
 import typeck::infer::{unify_methods}; // infcx.set()
-import typeck::infer::{min_8bit_tys, min_16bit_tys, min_32bit_tys,
-                       min_64bit_tys};
 
 type fn_ctxt =
     // var_bindings, locals and next_var_id are shared
@@ -623,29 +621,13 @@ fn check_lit(fcx: @fn_ctxt, lit: @ast::lit) -> ty::t {
       ast::lit_str(_) { ty::mk_str(tcx) }
       ast::lit_int(_, t) { ty::mk_mach_int(tcx, t) }
       ast::lit_uint(_, t) { ty::mk_mach_uint(tcx, t) }
-      ast::lit_int_unsuffixed(v, t) {
+      ast::lit_int_unsuffixed(v) {
         // An unsuffixed integer literal could have any integral type,
         // so we create an integral type variable for it.
-        let vid = fcx.infcx.next_ty_var_integral_id();
-
-        // We need to sniff at the value `v` and figure out how big of
-        // an int it is; that determines the range of possible types
-        // that the integral type variable could take on.
-        let possible_types = alt v {
-          0i64 to 127i64 { min_8bit_tys() }
-          128i64 to 65535i64 { min_16bit_tys() }
-          65536i64 to 4294967295i64 { min_32bit_tys() }
-          _ { min_64bit_tys() }
-        };
-
-        // Store the set of possible types and return the integral
-        // type variable.
-        fcx.infcx.set(fcx.infcx.tvib, vid,
-                      root(possible_types));
-        ty::mk_var_integral(tcx, vid);
+        ty::mk_var_integral(tcx, fcx.infcx.next_ty_var_integral_id());
 
         // FIXME: remove me when #1425 is finished.
-        ty::mk_mach_int(tcx, t)
+        ty::mk_mach_int(tcx, ty_i)
       }
       ast::lit_float(_, t) { ty::mk_mach_float(tcx, t) }
       ast::lit_nil { ty::mk_nil(tcx) }