---

yaml
---
r: 13579
b: refs/heads/master
c: 8395305
h: refs/heads/master
i:
  13577: 2782cca
  13575: 37e1e34
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 60a658250ea2ee6dd10425d7070c373262762b1c
+refs/heads/master: 8395305e71895b152e3f0abefb6cbc9e74f15a16
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/rust.css

@@ -51,3 +51,9 @@ h3 a:link, h3 a:visited { color: black; }
 .cm-s-default span.cm-bracket {color: #cc7;}
 .cm-s-default span.cm-tag {color: #170;}
 .cm-s-default span.cm-attribute {color: #00c;}
+
+h1.title {
+  background-image: url('http://www.rust-lang.org/logos/rust-logo-32x32-blk.png');
+  background-repeat: no-repeat;
+  background-position: right;
+}

trunk/src/rustc/middle/lint.rs

@@ -331,7 +331,7 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
                 alt cond.node {
                     ast::expr_lit(@{node: ast::lit_bool(true),_}) {
                             cx.sess.span_lint(
-                                while_true, e.id, it.id,
+                                while_true, it.id, e.id,
                                 e.span,
                                 "denote infinite loops with loop { ... }");
                     }
@@ -357,14 +357,14 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
                 alt cx.def_map.get(id) {
                   ast::def_prim_ty(ast::ty_int(ast::ty_i)) {
                     cx.sess.span_lint(
-                        ctypes, id, fn_id,
+                        ctypes, fn_id, id,
                         ty.span,
                         "found rust type `int` in native module, while \
                          libc::c_int or libc::c_long should be used");
                   }
                   ast::def_prim_ty(ast::ty_uint(ast::ty_u)) {
                     cx.sess.span_lint(
-                        ctypes, id, fn_id,
+                        ctypes, fn_id, id,
                         ty.span,
                         "found rust type `uint` in native module, while \
                          libc::c_uint or libc::c_ulong should be used");
@@ -400,7 +400,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) {
                                node: ast::expr_path(@path),
                                span: _}, _) {
                 cx.sess.span_lint(
-                    path_statement, id, it.id,
+                    path_statement, it.id, id,
                     s.span,
                     "path statement with no effect");
               }
@@ -423,7 +423,7 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
               ast::expr_lit(@{node: ast::lit_str(_), span:_})
               if ! uses_vstore.contains_key(e.id) {
                 cx.sess.span_lint(
-                    old_vecs, e.id, it.id,
+                    old_vecs, it.id, e.id,
                     e.span, "deprecated vec/str expr");
               }
               ast::expr_vstore(@inner, _) {
@@ -438,15 +438,15 @@ fn check_item_old_vecs(cx: ty::ctxt, it: @ast::item) {
               ast::ty_vec(_)
               if ! uses_vstore.contains_key(t.id) {
                 cx.sess.span_lint(
-                    old_vecs, t.id, it.id,
+                    old_vecs, it.id, t.id,
                     t.span, "deprecated vec type");
               }
 
               ast::ty_path(@{span: _, global: _, idents: ids,
                              rp: none, types: _}, _)
               if ids == [@"str"] && (! uses_vstore.contains_key(t.id)) {
                 cx.sess.span_lint(
-                    old_vecs, t.id, it.id,
+                    old_vecs, it.id, t.id,
                     t.span, "deprecated str type");
               }
 

trunk/src/rustc/middle/typeck/check.rs

@@ -1132,7 +1132,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         // and so forth. - Niko
         fcx.write_nil(expr.id);
       }
-      ast::expr_unary(unop, oprnd) {
+      ast::expr_unary(unop, oper) {
         let exp_inner = unpack_expected(fcx, expected) {|sty|
             alt unop {
               ast::box(_) | ast::uniq(_) {
@@ -1145,17 +1145,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
               ast::deref { none }
             }
         };
-        bot = check_expr(fcx, oprnd, exp_inner);
-        let mut oprnd_t = fcx.expr_ty(oprnd);
+        bot = check_expr(fcx, oper, exp_inner);
+        let mut oper_t = fcx.expr_ty(oper);
         alt unop {
           ast::box(mutbl) {
-            oprnd_t = ty::mk_box(tcx, {ty: oprnd_t, mutbl: mutbl});
+            oper_t = ty::mk_box(tcx, {ty: oper_t, mutbl: mutbl});
           }
           ast::uniq(mutbl) {
-            oprnd_t = ty::mk_uniq(tcx, {ty: oprnd_t, mutbl: mutbl});
+            oper_t = ty::mk_uniq(tcx, {ty: oper_t, mutbl: mutbl});
           }
           ast::deref {
-            let sty = structure_of(fcx, expr.span, oprnd_t);
+            let sty = structure_of(fcx, expr.span, oper_t);
 
             // deref'ing an unsafe pointer requires that we be in an unsafe
             // context
@@ -1169,7 +1169,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
             }
 
             alt ty::deref_sty(tcx, sty, true) {
-              some(mt) { oprnd_t = mt.ty }
+              some(mt) { oper_t = mt.ty }
               none {
                 alt sty {
                   ty::ty_enum(*) {
@@ -1183,46 +1183,39 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
                     tcx.sess.span_err(
                         expr.span,
                         #fmt["type %s cannot be dereferenced",
-                             fcx.infcx.ty_to_str(oprnd_t)]);
+                             fcx.infcx.ty_to_str(oper_t)]);
                   }
                 }
               }
             }
           }
           ast::not {
-            oprnd_t = structurally_resolved_type(fcx, oprnd.span, oprnd_t);
-            if !(ty::type_is_integral(oprnd_t) ||
-                 ty::get(oprnd_t).struct == ty::ty_bool) {
-                oprnd_t = check_user_unop(fcx, "!", "!", expr,
-                                         oprnd, oprnd_t);
+            oper_t = structurally_resolved_type(fcx, oper.span, oper_t);
+            if !(ty::type_is_integral(oper_t) ||
+                 ty::get(oper_t).struct == ty::ty_bool) {
+                oper_t = check_user_unop(fcx, "!", "!", expr,
+                                         oper, oper_t);
             }
           }
           ast::neg {
-            // If the operand's type is an integral type variable, we
-            // don't want to resolve it yet, because the rest of the
-            // typing context might not have had the opportunity to
-            // constrain it yet.
-            if !(ty::type_is_var_integral(oprnd_t)) {
-                oprnd_t = structurally_resolved_type(fcx, oprnd.span,
-                                                     oprnd_t);
-            }
-            if !(ty::type_is_integral(oprnd_t) ||
-                 ty::type_is_fp(oprnd_t)) {
-                oprnd_t = check_user_unop(fcx, "-", "unary-", expr,
-                                         oprnd, oprnd_t);
+            oper_t = structurally_resolved_type(fcx, oper.span, oper_t);
+            if !(ty::type_is_integral(oper_t) ||
+                 ty::type_is_fp(oper_t)) {
+                oper_t = check_user_unop(fcx, "-", "unary-", expr,
+                                         oper, oper_t);
             }
           }
         }
-        fcx.write_ty(id, oprnd_t);
+        fcx.write_ty(id, oper_t);
       }
-      ast::expr_addr_of(mutbl, oprnd) {
-        bot = check_expr(fcx, oprnd, unpack_expected(fcx, expected) {|ty|
+      ast::expr_addr_of(mutbl, oper) {
+        bot = check_expr(fcx, oper, unpack_expected(fcx, expected) {|ty|
             alt ty { ty::ty_rptr(_, mt) { some(mt.ty) } _ { none } }
         });
-        let region = region_of(fcx, oprnd);
-        let tm = { ty: fcx.expr_ty(oprnd), mutbl: mutbl };
-        let oprnd_t = ty::mk_rptr(tcx, region, tm);
-        fcx.write_ty(id, oprnd_t);
+        let region = region_of(fcx, oper);
+        let tm = { ty: fcx.expr_ty(oper), mutbl: mutbl };
+        let oper_t = ty::mk_rptr(tcx, region, tm);
+        fcx.write_ty(id, oper_t);
       }
       ast::expr_path(pth) {
         let defn = lookup_def(fcx, pth.span, id);

trunk/src/rustc/middle/typeck/infer.rs

@@ -119,28 +119,6 @@ is valid.  This basically corresponds to the block nesting structure:
 the regions for outer block scopes are superregions of those for inner
 block scopes.
 
-## Integral type variables
-
-There is a third variety of type variable that we use only for
-inferring the types of unsuffixed integer literals.  Integral type
-variables differ from general-purpose type variables in that there's
-no subtyping relationship among the various integral types, so instead
-of associating each variable with an upper and lower bound, we
-represent the set of possible integral types it can take on with an
-`int_ty_set`, which is a bitvector with one bit for each integral
-type.  Because intersecting these sets with each other is simpler than
-merging bounds, we don't need to do so transactionally as we do for
-general-purpose type variables.
-
-We could conceivably define a subtyping relationship among integral
-types based on their ranges, but we choose not to open that particular
-can of worms.  Our strategy is to treat integral type variables as
-unknown until the typing context constrains them to a unique integral
-type, at which point they take on that type.  If the typing context
-overconstrains the type, it's a type error; if we reach the point at
-which type variables must be resolved and an integral type variable is
-still underconstrained, it defaults to `int` as a last resort.
-
 ## GLB/LUB
 
 Computing the greatest-lower-bound and least-upper-bound of two
@@ -851,7 +829,7 @@ impl unify_methods for infer_ctxt {
             }
         } else if nde_a.rank < nde_b.rank {
             #debug["vars(): b has smaller rank"];
-            // b has greater rank, so a should redirect to b.
+            // b has geater rank, so a should redirect to b.
             self.set(vb, a_id, redirect(b_id));
             self.set_var_to_merged_bounds(
                 vb, b_id, a_bounds, b_bounds, nde_b.rank).then {||

trunk/src/test/run-pass/integer-literal-suffix-inference.rs

@@ -16,22 +16,22 @@ fn main() {
 
     let _i: i8 = -128;
     let j = -128;
-    id_i8(j);
+    // id_i8(j);
     id_i8(-128);
 
     let _i: i16 = -32_768;
     let j = -32_768;
-    id_i16(j);
+    // id_i16(j);
     id_i16(-32_768);
 
     let _i: i32 = -2_147_483_648;
     let j = -2_147_483_648;
-    id_i32(j);
+    // id_i32(j);
     id_i32(-2_147_483_648);
 
     let _i: i64 = -9_223_372_036_854_775_808;
     let j = -9_223_372_036_854_775_808;
-    id_i64(j);
+    // id_i64(j);
     id_i64(-9_223_372_036_854_775_808);
 
     let _i: uint = 1;