WIP on issue #1425: mostly infrastructure changes.

Author: lkuper

src/rustc/metadata/tydecode.rs

@@ -346,7 +346,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         ret ty::mk_res(st.tcx, def, inner, substs);
       }
       'X' {
-        ret ty::mk_var(st.tcx, ty::ty_vid(parse_int(st) as uint));
+        ret ty::mk_var(st.tcx, ty::tv_vid(parse_int(st) as uint));
       }
       'Y' { ret ty::mk_type(st.tcx); }
       'C' {

src/rustc/middle/ty.rs

@@ -17,7 +17,7 @@ import middle::lint::{get_warning_level, vecs_not_implicitly_copyable,
 import syntax::ast::*;
 import syntax::print::pprust::*;
 
-export ty_vid, region_vid, vid;
+export tv_vid, tvi_vid, region_vid, vid;
 export br_hashmap;
 export is_instantiable;
 export node_id_to_type;
@@ -302,11 +302,6 @@ enum closure_kind {
     ck_uniq,
 }
 
-enum ty_var_kind {
-    tvk_regular,
-    tvk_integral,
-}
-
 type fn_ty = {purity: ast::purity,
               proto: ast::proto,
               inputs: [arg],
@@ -372,9 +367,9 @@ enum sty {
     ty_res(def_id, t, substs),
     ty_tup([t]),
 
-    ty_var(ty_vid), // type variable during typechecking
-    ty_var_integral(ty_vid), // type variable during typechecking, for
-                             // integral types only
+    ty_var(tv_vid), // type variable during typechecking
+    ty_var_integral(tvi_vid), // type variable during typechecking, for
+                              // integral types only
     ty_param(uint, def_id), // type parameter
     ty_self, // special, implicit `self` type parameter
     ty_constr(t, [@type_constr]),
@@ -429,19 +424,25 @@ enum param_bound {
     bound_iface(t),
 }
 
-enum ty_vid = uint;
+enum tv_vid = uint;
+enum tvi_vid = uint;
 enum region_vid = uint;
 
 iface vid {
     fn to_uint() -> uint;
     fn to_str() -> str;
 }
 
-impl of vid for ty_vid {
+impl of vid for tv_vid {
     fn to_uint() -> uint { *self }
     fn to_str() -> str { #fmt["<V%u>", self.to_uint()] }
 }
 
+impl of vid for tvi_vid {
+    fn to_uint() -> uint { *self }
+    fn to_str() -> str { #fmt["<V (integral) %u>", self.to_uint()] }
+}
+
 impl of vid for region_vid {
     fn to_uint() -> uint { *self }
     fn to_str() -> str { #fmt["<R%u>", self.to_uint()] }
@@ -693,9 +694,11 @@ fn mk_res(cx: ctxt, did: ast::def_id,
     mk_t(cx, ty_res(did, inner, substs))
 }
 
-fn mk_var(cx: ctxt, v: ty_vid) -> t { mk_t(cx, ty_var(v)) }
+fn mk_var(cx: ctxt, v: tv_vid) -> t { mk_t(cx, ty_var(v)) }
 
-fn mk_var_integral(cx: ctxt, v: ty_vid) -> t { mk_t(cx, ty_var_integral(v)) }
+fn mk_var_integral(cx: ctxt, v: tvi_vid) -> t {
+    mk_t(cx, ty_var_integral(v))
+}
 
 fn mk_self(cx: ctxt) -> t { mk_t(cx, ty_self) }
 
@@ -1911,29 +1914,6 @@ fn type_param(ty: t) -> option<uint> {
     ret none;
 }
 
-// Returns a vec of all the type variables of kind `tvk` occurring in `ty`. It
-// may contain duplicates.
-fn vars_in_type(ty: t, tvk: ty_var_kind) -> [ty_vid] {
-    let mut rslt = [];
-    walk_ty(ty) {|ty|
-        alt get(ty).struct {
-          ty_var(v) {
-            alt tvk {
-              tvk_regular { rslt += [v]; }
-              _ { }
-            }
-          }
-          ty_var_integral(v) {
-            alt tvk {
-              tvk_integral { rslt += [v]; }
-              _ { }
-            }
-          }
-          _ { } }
-    }
-    rslt
-}
-
 // Returns the type and mutability of *t.
 //
 // The parameter `expl` indicates if this is an *explicit* dereference.  Some
@@ -2229,13 +2209,21 @@ fn is_pred_ty(fty: t) -> bool {
     is_fn_ty(fty) && type_is_bool(ty_fn_ret(fty))
 }
 
-fn ty_var_id(typ: t) -> ty_vid {
+fn ty_var_id(typ: t) -> tv_vid {
     alt get(typ).struct {
-      ty_var(vid) | ty_var_integral(vid) { ret vid; }
+      ty_var(vid) { ret vid; }
       _ { #error("ty_var_id called on non-var ty"); fail; }
     }
 }
 
+fn ty_var_integral_id(typ: t) -> tvi_vid {
+    alt get(typ).struct {
+      ty_var_integral(vid) { ret vid; }
+      _ { #error("ty_var_integral_id called on ty other than \
+                  ty_var_integral");
+         fail; }
+    }
+}
 
 // Type accessors for AST nodes
 fn block_ty(cx: ctxt, b: ast::blk) -> t {
@@ -2311,12 +2299,23 @@ fn method_idx(id: ast::ident, meths: [method]) -> option<uint> {
     ret none;
 }
 
-fn occurs_check(tcx: ctxt, sp: span, vid: ty_vid, rt: t) {
+fn occurs_check(tcx: ctxt, sp: span, vid: tv_vid, rt: t) {
+
+    // Returns a vec of all the type variables occurring in `ty`. It may
+    // contain duplicates.  (Integral type vars aren't counted.)
+    fn vars_in_type(ty: t) -> [tv_vid] {
+        let mut rslt = [];
+        walk_ty(ty) {|ty|
+            alt get(ty).struct { ty_var(v) { rslt += [v]; } _ { } }
+        }
+        rslt
+    }
+
     // Fast path
     if !type_needs_infer(rt) { ret; }
 
     // Occurs check!
-    if vec::contains(vars_in_type(rt, tvk_regular), vid) {
+    if vec::contains(vars_in_type(rt), vid) {
             // Maybe this should be span_err -- however, there's an
             // assertion later on that the type doesn't contain
             // variables, so in this case we have to be sure to die.

src/rustc/middle/typeck.rs

@@ -52,7 +52,6 @@ import pat_util::{pat_is_variant, pat_id_map};
 import middle::ty;
 import middle::ty::{arg, field, node_type_table, mk_nil,
                     ty_param_bounds_and_ty, lookup_public_fields};
-import middle::ty::{ty_vid, region_vid, vid};
 import middle::typeck::infer::methods;
 import util::ppaux::{ty_to_str, tys_to_str, region_to_str,
                      bound_region_to_str, vstore_to_str};

src/rustc/middle/typeck/check.rs

@@ -69,10 +69,15 @@ type parameter).
 import astconv::{ast_conv, ast_ty_to_ty};
 import collect::{methods}; // ccx.to_ty()
 import method::{methods};  // methods for method::lookup
-import middle::ty::tys_in_fn_ty;
+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 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
@@ -84,7 +89,7 @@ type fn_ctxt =
      indirect_ret_ty: option<ty::t>,
      purity: ast::purity,
      infcx: infer::infer_ctxt,
-     locals: hashmap<ast::node_id, ty_vid>,
+     locals: hashmap<ast::node_id, tv_vid>,
 
      mut blocks: [ast::node_id], // stack of blocks in scope, may be empty
      in_scope_regions: isr_alist,
@@ -618,22 +623,49 @@ fn are_compatible(fcx: @fn_ctxt, expected: ty::t, actual: ty::t) -> bool {
     }
 }
 
-// Local variable gathering. We gather up all locals and create variable IDs
-// for them before typechecking the function.
-type gather_result =
-    {infcx: infer::infer_ctxt,
-     locals: hashmap<ast::node_id, ty_vid>,
-     ty_var_counter: @mut uint};
-
 // AST fragment checking
-fn check_lit(ccx: @crate_ctxt, lit: @ast::lit) -> ty::t {
+fn check_lit(fcx: @fn_ctxt, lit: @ast::lit) -> ty::t {
+    let tcx = fcx.ccx.tcx;
+
     alt lit.node {
-      ast::lit_str(_) { ty::mk_str(ccx.tcx) }
-      ast::lit_int(_, t) { ty::mk_mach_int(ccx.tcx, t) }
-      ast::lit_uint(_, t) { ty::mk_mach_uint(ccx.tcx, t) }
-      ast::lit_float(_, t) { ty::mk_mach_float(ccx.tcx, t) }
-      ast::lit_nil { ty::mk_nil(ccx.tcx) }
-      ast::lit_bool(_) { ty::mk_bool(ccx.tcx) }
+      ast::lit_str(_) { ty::mk_str(tcx) }
+      ast::lit_int(v, t) {
+        alt t {
+          ty_char | ty_i8 | ty_i16 | ty_i32 | ty_i64 {
+            // If it's a char or has an explicit suffix, give it the
+            // appropriate integral type.
+            ty::mk_mach_int(tcx, t)
+          }
+          ty_i {
+            // Otherwise, an unsuffixed integer literal parses to a
+            // `ty_i`.  In that case, it could have any integral type,
+            // so create an integral type variable for it.
+            let vid = fcx.infcx.next_ty_var_integral_id();
+
+            // We need to sniff at the value `v` provided and figure
+            // out how big of an int it is; that determines the set of
+            // possibly types it 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
+            fcx.infcx.set(fcx.infcx.tvib, vid,
+                          root(possible_types));
+            ty::mk_var_integral(tcx, vid);
+
+            // FIXME: remove me when #1425 is finished.
+            ty::mk_mach_int(tcx, t)
+          }
+        }
+      }
+      ast::lit_uint(_, t) { ty::mk_mach_uint(tcx, t) }
+      ast::lit_float(_, t) { ty::mk_mach_float(tcx, t) }
+      ast::lit_nil { ty::mk_nil(tcx) }
+      ast::lit_bool(_) { ty::mk_bool(tcx) }
     }
 }
 
@@ -1107,7 +1139,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
       }
 
       ast::expr_lit(lit) {
-        let typ = check_lit(fcx.ccx, lit);
+        let typ = check_lit(fcx, lit);
         fcx.write_ty(id, typ);
       }
 
@@ -2067,7 +2099,7 @@ fn self_ref(fcx: @fn_ctxt, id: ast::node_id) -> bool {
                         ast_util::is_self)
 }
 
-fn lookup_local(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> ty_vid {
+fn lookup_local(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> tv_vid {
     alt fcx.locals.find(id) {
       some(x) { x }
       _ {