Stop inferring bot/static when types/regions are unconstrained.

Also, some other changes that came up along the way:
- add a 'blk' region for the current block.
- detect unused type/region variables.

Author: nikomatsakis

src/libcore/priv.rs

@@ -14,15 +14,15 @@ native mod rustrt {
     fn rust_task_unweaken(ch: rust_port_id);
 }
 
-type global_ptr<T: send> = *libc::uintptr_t;
+type global_ptr = *libc::uintptr_t;
 
 #[doc = "
 Atomically gets a channel from a pointer to a pointer-sized memory location
 or, if no channel exists creates and installs a new channel and sets up a new
 task to receive from it.
 "]
 unsafe fn chan_from_global_ptr<T: send>(
-    global: global_ptr<T>,
+    global: global_ptr,
     builder: fn() -> task::builder,
     f: fn~(comm::port<T>)
 ) -> comm::chan<T> {

src/libcore/vec.rs

@@ -1168,7 +1168,9 @@ mod unsafe {
     #[inline(always)]
     unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn([T]/&) -> U) -> U {
         let pair = (p, len * sys::size_of::<T>());
-        let v : *([T]/&) = ::unsafe::reinterpret_cast(ptr::addr_of(pair));
+        // FIXME: should use &blk not &static here, but a snapshot is req'd
+        let v : *([T]/&static) =
+            ::unsafe::reinterpret_cast(ptr::addr_of(pair));
         f(*v)
     }
 }

src/librustsyntax/ast.rs

@@ -452,11 +452,7 @@ enum prim_ty {
 type region = {id: node_id, node: region_};
 
 #[auto_serialize]
-enum region_ {
-    re_anon,
-    re_named(ident),
-    re_static
-}
+enum region_ { re_anon, re_named(ident) }
 
 #[auto_serialize]
 enum ty_ {

src/librustsyntax/parse/parser.rs

@@ -250,16 +250,7 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
 
 fn region_from_name(p: parser, s: option<str>) -> @ast::region {
     let r = alt s {
-      some (string) {
-        // FIXME: To be consistent with our type resolution, the
-        // static region should probably be resolved during type
-        // checking, not in the parser. (Issue #2256)
-        if string == "static" {
-            ast::re_static
-        } else {
-            ast::re_named(string)
-        }
-      }
+      some (string) { ast::re_named(string) }
       none { ast::re_anon }
     };
 

src/librustsyntax/print/pprust.rs

@@ -329,7 +329,6 @@ fn print_native_mod(s: ps, nmod: ast::native_mod, attrs: [ast::attribute]) {
 fn print_region(s: ps, region: @ast::region) {
     alt region.node {
       ast::re_anon { word_space(s, "&"); }
-      ast::re_static { word_space(s, "&static"); }
       ast::re_named(name) {
         word(s.s, "&");
         word_space(s, name);

src/rustc/metadata/creader.rs

@@ -251,23 +251,23 @@ fn find_library_crate_aux(sess: session::session,
         if !(str::starts_with(f, prefix) && str::ends_with(f, suffix)) {
             #debug("skipping %s, doesn't look like %s*%s", path, prefix,
                    suffix);
-            option::none
+            option::none::<()>
         } else {
             #debug("%s is a candidate", path);
             alt get_metadata_section(sess, path) {
               option::some(cvec) {
                 if !crate_matches(cvec, metas, hash) {
                     #debug("skipping %s, metadata doesn't match", path);
-                    option::none
+                    option::none::<()>
                 } else {
                     #debug("found %s with matching metadata", path);
                     matches += [{ident: path, data: cvec}];
-                    option::none
+                    option::none::<()>
                 }
               }
               _ {
                 #debug("could not load metadata for %s", path);
-                option::none
+                option::none::<()>
               }
             }
         }

src/rustc/middle/infer.rs

@@ -579,11 +579,8 @@ impl unify_methods for infer_ctxt {
 // [B].  Deep resolution, on the other hand, would yield [int].
 //
 // But there is one more knob: the force_vars variable controls the
-// behavior in the face of unconstrained variables.  If we have A, B
-// and only the constraint that A <: B, then the result is [_|_] if
-// force_vars is true and [B] otherwise.  We use force_vars == true
-// when resolving types after typeck, but false otherwise (for
-// example, when pretty-printing them for errors).
+// behavior in the face of unconstrained variables.  If it is true,
+// then unconstrained variables result in an error.
 
 type resolve_state = @{
     infcx: infer_ctxt,
@@ -673,8 +670,12 @@ impl methods for resolve_state {
             let r1 = alt bounds {
               { ub:_, lb:some(t) } { self.resolve_region(t) }
               { ub:some(t), lb:_ } { self.resolve_region(t) }
-              { ub:none, lb:none } if self.force_vars { ty::re_static }
-              { ub:none, lb:none } { ty::re_var(rid) }
+              { ub:none, lb:none } {
+                if self.force_vars {
+                    self.err = some(unresolved_region(rid));
+                }
+                ty::re_var(rid)
+              }
             };
             vec::pop(self.r_seen);
             ret r1;
@@ -700,8 +701,12 @@ impl methods for resolve_state {
               { ub:_, lb:some(t) } if !type_is_bot(t) { self.resolve1(t) }
               { ub:some(t), lb:_ } { self.resolve1(t) }
               { ub:_, lb:some(t) } { self.resolve1(t) }
-              { ub:none, lb:none } if self.force_vars { ty::mk_bot(tcx) }
-              { ub:none, lb:none } { ty::mk_var(tcx, vid) }
+              { ub:none, lb:none } {
+                if self.force_vars {
+                    self.err = some(unresolved_ty(vid));
+                }
+                ty::mk_var(tcx, vid)
+              }
             };
             vec::pop(self.v_seen);
             ret t1;

src/rustc/middle/kind.rs

@@ -4,6 +4,7 @@ import syntax::codemap::span;
 import ty::{kind, kind_copyable, kind_sendable, kind_noncopyable};
 import driver::session::session;
 import std::map::hashmap;
+import syntax::print::pprust::expr_to_str;
 
 // Kind analysis pass. There are three kinds:
 //
@@ -138,6 +139,7 @@ fn check_block(b: blk, cx: ctx, v: visit::vt<ctx>) {
 }
 
 fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
+    #debug["kind::check_expr(%s)", expr_to_str(e)];
     alt e.node {
       expr_assign(_, ex) | expr_assign_op(_, _, ex) |
       expr_unary(box(_), ex) | expr_unary(uniq(_), ex) |

src/rustc/middle/ty.rs

@@ -37,7 +37,7 @@ export expr_ty_params_and_ty;
 export expr_is_lval;
 export field_ty;
 export fold_ty, fold_sty_to_ty, fold_region, fold_regions, fold_ty_var;
-export fold_regions_and_ty;
+export fold_regions_and_ty, walk_regions_and_ty;
 export field;
 export field_idx;
 export get_field;
@@ -97,7 +97,7 @@ export ty_tup, mk_tup;
 export ty_type, mk_type;
 export ty_uint, mk_uint, mk_mach_uint;
 export ty_uniq, mk_uniq, mk_imm_uniq, type_is_unique_box;
-export ty_var, mk_var;
+export ty_var, mk_var, type_is_var;
 export ty_self, mk_self;
 export region, bound_region;
 export get, type_has_params, type_has_vars, type_has_regions;
@@ -818,6 +818,21 @@ fn fold_ty_var(cx: ctxt, t0: t, fldop: fn(ty_vid) -> t) -> t {
     }
 }
 
+fn walk_regions_and_ty(
+    cx: ctxt,
+    ty: t,
+    walkr: fn(r: region),
+    walkt: fn(t: t) -> bool) {
+
+    if (walkt(ty)) {
+        fold_regions_and_ty(
+            cx, ty,
+            { |r| walkr(r); r },
+            { |t| walkt(t); walk_regions_and_ty(cx, t, walkr, walkt); t },
+            { |t| walkt(t); walk_regions_and_ty(cx, t, walkr, walkt); t });
+    }
+}
+
 fn fold_regions_and_ty(
     cx: ctxt,
     ty: t,
@@ -1000,6 +1015,13 @@ fn type_is_nil(ty: t) -> bool { get(ty).struct == ty_nil }
 
 fn type_is_bot(ty: t) -> bool { get(ty).struct == ty_bot }
 
+fn type_is_var(ty: t) -> bool {
+    alt get(ty).struct {
+      ty_var(_) { true }
+      _ { false }
+    }
+}
+
 fn type_is_bool(ty: t) -> bool { get(ty).struct == ty_bool }
 
 fn type_is_structural(ty: t) -> bool {