---

yaml
---
r: 68585
b: refs/heads/auto
c: 77b9824
h: refs/heads/master
i:
  68583: 0e71cd4
v: v3

Author: brson

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: ef5c439fb006875d3d54b3b100f5411efc2c40f3
+refs/heads/auto: 77b98247a26dcba11bd04f27ff8f5252ecd97df5
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/librustc/middle/region.rs

@@ -15,9 +15,6 @@ pass builds up the `scope_map`, which describes the parent links in
 the region hierarchy.  The second pass infers which types must be
 region parameterized.
 
-Most of the documentation on regions can be found in
-`middle/typeck/infer/region_inference.rs`
-
 */
 
 

branches/auto/src/librustc/middle/typeck/check/_match.rs

@@ -15,7 +15,6 @@ use middle::typeck::check::demand;
 use middle::typeck::check::{check_block, check_expr_has_type, FnCtxt};
 use middle::typeck::check::{instantiate_path, lookup_def};
 use middle::typeck::check::{structure_of, valid_range_bounds};
-use middle::typeck::infer;
 use middle::typeck::require_same_types;
 
 use std::hashmap::{HashMap, HashSet};
@@ -30,31 +29,26 @@ pub fn check_match(fcx: @mut FnCtxt,
                    arms: &[ast::arm]) {
     let tcx = fcx.ccx.tcx;
 
-    let discrim_ty = fcx.infcx().next_ty_var();
-    check_expr_has_type(fcx, discrim, discrim_ty);
+    let pattern_ty = fcx.infcx().next_ty_var();
+    check_expr_has_type(fcx, discrim, pattern_ty);
 
     // Typecheck the patterns first, so that we get types for all the
     // bindings.
     for arms.iter().advance |arm| {
         let pcx = pat_ctxt {
             fcx: fcx,
             map: pat_id_map(tcx.def_map, arm.pats[0]),
+            match_region: ty::re_scope(expr.id),
+            block_region: ty::re_scope(arm.body.node.id)
         };
 
-        for arm.pats.iter().advance |p| { check_pat(&pcx, *p, discrim_ty);}
+        for arm.pats.iter().advance |p| { check_pat(&pcx, *p, pattern_ty);}
     }
 
-    // The result of the match is the common supertype of all the
-    // arms. Start out the value as bottom, since it's the, well,
-    // bottom the type lattice, and we'll be moving up the lattice as
-    // we process each arm. (Note that any match with 0 arms is matching
-    // on any empty type and is therefore unreachable; should the flow
-    // of execution reach it, we will fail, so bottom is an appropriate
-    // type in that case)
-    let mut result_ty = ty::mk_bot();
-
     // Now typecheck the blocks.
-    let mut saw_err = ty::type_is_error(discrim_ty);
+    let mut result_ty = fcx.infcx().next_ty_var();
+    let mut arm_non_bot = false;
+    let mut saw_err = false;
     for arms.iter().advance |arm| {
         let mut guard_err = false;
         let mut guard_bot = false;
@@ -81,28 +75,26 @@ pub fn check_match(fcx: @mut FnCtxt,
         else if guard_bot {
             fcx.write_bot(arm.body.node.id);
         }
-
-        result_ty =
-            infer::common_supertype(
-                fcx.infcx(),
-                infer::MatchExpression(expr.span),
-                true, // result_ty is "expected" here
-                result_ty,
-                bty);
+        else if !ty::type_is_bot(bty) {
+            arm_non_bot = true; // If the match *may* evaluate to a non-_|_
+                                // expr, the whole thing is non-_|_
+        }
+        demand::suptype(fcx, arm.body.span, result_ty, bty);
     }
-
     if saw_err {
         result_ty = ty::mk_err();
-    } else if ty::type_is_bot(discrim_ty) {
+    }
+    else if !arm_non_bot {
         result_ty = ty::mk_bot();
     }
-
     fcx.write_ty(expr.id, result_ty);
 }
 
 pub struct pat_ctxt {
     fcx: @mut FnCtxt,
     map: PatIdMap,
+    match_region: ty::Region, // Region for the match as a whole
+    block_region: ty::Region, // Region for the block of the arm
 }
 
 pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
@@ -450,8 +442,8 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
             // then the type of x is &M T where M is the mutability
             // and T is the expected type
             let region_var =
-                fcx.infcx().next_region_var(
-                    infer::PatternRegion(pat.span));
+                fcx.infcx().next_region_var_with_lb(
+                    pat.span, pcx.block_region);
             let mt = ty::mt {ty: expected, mutbl: mutbl};
             let region_ty = ty::mk_rptr(tcx, region_var, mt);
             demand::eqtype(fcx, pat.span, region_ty, typ);
@@ -552,8 +544,9 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
       }
       ast::pat_vec(ref before, slice, ref after) => {
         let default_region_var =
-            fcx.infcx().next_region_var(
-                infer::PatternRegion(pat.span));
+            fcx.infcx().next_region_var_with_lb(
+                pat.span, pcx.block_region
+            );
 
         let (elt_type, region_var) = match structure_of(
           fcx, pat.span, expected
@@ -658,4 +651,3 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
 
 #[deriving(Eq)]
 enum PointerKind { Managed, Send, Borrowed }
-

branches/auto/src/librustc/middle/typeck/check/demand.rs

@@ -35,7 +35,7 @@ pub fn suptype_with_fn(fcx: @mut FnCtxt,
                        ty_a: ty::t, ty_b: ty::t,
                        handle_err: &fn(span, ty::t, ty::t, &ty::type_err)) {
     // n.b.: order of actual, expected is reversed
-    match infer::mk_subty(fcx.infcx(), b_is_expected, infer::Misc(sp),
+    match infer::mk_subty(fcx.infcx(), b_is_expected, sp,
                           ty_b, ty_a) {
       result::Ok(()) => { /* ok */ }
       result::Err(ref err) => {
@@ -45,7 +45,7 @@ pub fn suptype_with_fn(fcx: @mut FnCtxt,
 }
 
 pub fn eqtype(fcx: @mut FnCtxt, sp: span, expected: ty::t, actual: ty::t) {
-    match infer::mk_eqty(fcx.infcx(), false, infer::Misc(sp), actual, expected) {
+    match infer::mk_eqty(fcx.infcx(), false, sp, actual, expected) {
         Ok(()) => { /* ok */ }
         Err(ref err) => {
             fcx.report_mismatched_types(sp, expected, actual, err);

branches/auto/src/librustc/middle/typeck/check/method.rs

@@ -619,18 +619,14 @@ impl<'self> LookupContext<'self> {
                      autoref: None}))
             }
             ty::ty_rptr(_, self_mt) => {
-                let region =
-                    self.infcx().next_region_var(
-                        infer::Autoref(self.expr.span));
+                let region = self.infcx().next_region_var_nb(self.expr.span);
                 (ty::mk_rptr(tcx, region, self_mt),
                  ty::AutoDerefRef(ty::AutoDerefRef {
                      autoderefs: autoderefs+1,
                      autoref: Some(ty::AutoPtr(region, self_mt.mutbl))}))
             }
             ty::ty_evec(self_mt, vstore_slice(_)) => {
-                let region =
-                    self.infcx().next_region_var(
-                        infer::Autoref(self.expr.span));
+                let region = self.infcx().next_region_var_nb(self.expr.span);
                 (ty::mk_evec(tcx, self_mt, vstore_slice(region)),
                  ty::AutoDerefRef(ty::AutoDerefRef {
                      autoderefs: autoderefs,
@@ -762,9 +758,7 @@ impl<'self> LookupContext<'self> {
         -> Option<method_map_entry> {
         // This is hokey. We should have mutability inference as a
         // variable.  But for now, try &const, then &, then &mut:
-        let region =
-            self.infcx().next_region_var(
-                infer::Autoref(self.expr.span));
+        let region = self.infcx().next_region_var_nb(self.expr.span);
         for mutbls.iter().advance |mutbl| {
             let autoref_ty = mk_autoref_ty(*mutbl, region);
             match self.search_for_method(autoref_ty) {
@@ -976,8 +970,7 @@ impl<'self> LookupContext<'self> {
         let (_, opt_transformed_self_ty, fn_sig) =
             replace_bound_regions_in_fn_sig(
                 tcx, @Nil, Some(transformed_self_ty), &bare_fn_ty.sig,
-                |br| self.fcx.infcx().next_region_var(
-                    infer::BoundRegionInFnCall(self.expr.span, br)));
+                |_br| self.fcx.infcx().next_region_var_nb(self.expr.span));
         let transformed_self_ty = opt_transformed_self_ty.get();
         let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {sig: fn_sig, ..bare_fn_ty});
         debug!("after replacing bound regions, fty=%s", self.ty_to_str(fty));
@@ -989,7 +982,7 @@ impl<'self> LookupContext<'self> {
         // variables to unify etc).  Since we checked beforehand, and
         // nothing has changed in the meantime, this unification
         // should never fail.
-        match self.fcx.mk_subty(false, infer::Misc(self.self_expr.span),
+        match self.fcx.mk_subty(false, self.self_expr.span,
                                 rcvr_ty, transformed_self_ty) {
             result::Ok(_) => (),
             result::Err(_) => {