---

yaml
---
r: 2001
b: refs/heads/master
c: 86d4601
h: refs/heads/master
i:
  1999: b2adcd9
v: v3

Author: catamorphism

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4fc8de196977a0e5bb4f733f7aaeb1162e880eaa
+refs/heads/master: 86d4601827812b4b069e44feec1b1ea64cd34f4e

trunk/src/comp/middle/typeck.rs

@@ -23,6 +23,7 @@ import middle.ty.ty_to_str;
 import middle.ty.type_is_integral;
 import middle.ty.type_is_scalar;
 import middle.ty.ty_params_opt_and_ty;
+import middle.ty.ty_nil;
 
 import std._str;
 import std._uint;
@@ -62,6 +63,12 @@ fn triv_ann(@ty.t t) -> ann {
     ret ast.ann_type(t, none[vec[@ty.t]], none[@ts_ann]);
 }
 
+// Used to fill in the annotation for things that have uninteresting
+// types
+fn boring_ann() -> ann {
+    ret triv_ann(plain_ty(ty_nil));
+}
+
 // Replaces parameter types inside a type with type variables.
 fn generalize_ty(@crate_ctxt cx, @ty.t t) -> @ty.t {
     state obj ty_generalizer(@crate_ctxt cx,
@@ -1361,7 +1368,7 @@ fn demand_expr_full(&@fn_ctxt fcx, @ty.t expected, @ast.expr e,
                                  ann_to_type(ann), adk);
             e_1 = ast.expr_ext(p, args, body, expanded, triv_ann(t));
         }
-        /* FIXME: this should probably check the type annotations */
+        /* FIXME: should this check the type annotations? */
         case (ast.expr_fail(_))  { e_1 = e.node; } 
         case (ast.expr_log(_,_)) { e_1 = e.node; } 
         case (ast.expr_break(_)) { e_1 = e.node; }
@@ -1771,16 +1778,19 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                                      ann));
         }
 
-        case (ast.expr_fail(_)) { // ??? ignoring ann
-            ret expr;
+        case (ast.expr_fail(_)) {
+            ret @fold.respan[ast.expr_](expr.span,
+                                        ast.expr_fail(boring_ann()));
         }
 
         case (ast.expr_break(_)) {
-            ret expr;
+            ret @fold.respan[ast.expr_](expr.span,
+                                        ast.expr_break(boring_ann()));
         }
 
         case (ast.expr_cont(_)) {
-            ret expr;
+            ret @fold.respan[ast.expr_](expr.span,
+                                        ast.expr_cont(boring_ann()));
         }
 
         case (ast.expr_ret(?expr_opt, _)) {
@@ -1792,14 +1802,16 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                          + "returning non-nil");
                     }
 
-                    ret expr;
+                    ret @fold.respan[ast.expr_]
+                        (expr.span,
+                         ast.expr_ret(none[@ast.expr], boring_ann()));
                 }
 
                 case (some[@ast.expr](?e)) {
                     auto expr_0 = check_expr(fcx, e);
                     auto expr_1 = demand_expr(fcx, fcx.ret_ty, expr_0);
                     ret @fold.respan[ast.expr_]
-                        (expr.span, ast.expr_ret(some(expr_1), ann_none));
+                        (expr.span, ast.expr_ret(some(expr_1), boring_ann()));
                 }
             }
         }
@@ -1813,14 +1825,16 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                          + "putting non-nil");
                     }
 
-                    ret expr;
+                    ret @fold.respan[ast.expr_]
+                        (expr.span, ast.expr_put(none[@ast.expr],
+                                                 boring_ann()));
                 }
 
                 case (some[@ast.expr](?e)) {
                     auto expr_0 = check_expr(fcx, e);
                     auto expr_1 = demand_expr(fcx, fcx.ret_ty, expr_0);
                     ret @fold.respan[ast.expr_]
-                        (expr.span, ast.expr_put(some(expr_1), ann_none));
+                        (expr.span, ast.expr_put(some(expr_1), boring_ann()));
                 }
             }
         }
@@ -1831,20 +1845,21 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
             auto expr_0 = check_expr(fcx, e);
             auto expr_1 = demand_expr(fcx, fcx.ret_ty, expr_0);
             ret @fold.respan[ast.expr_](expr.span,
-                                        ast.expr_be(expr_1, ann_none));
+                                        ast.expr_be(expr_1,
+                                                    boring_ann()));
         }
 
         case (ast.expr_log(?e,_)) {
             auto expr_t = check_expr(fcx, e);
             ret @fold.respan[ast.expr_]
-                (expr.span, ast.expr_log(expr_t, ann_none));
+                (expr.span, ast.expr_log(expr_t, boring_ann()));
         }
 
         case (ast.expr_check_expr(?e, _)) {
             auto expr_t = check_expr(fcx, e);
             demand(fcx, expr.span, plain_ty(ty.ty_bool), expr_ty(expr_t));
             ret @fold.respan[ast.expr_]
-                (expr.span, ast.expr_check_expr(expr_t, ann_none));
+                (expr.span, ast.expr_check_expr(expr_t, boring_ann()));
         }
 
         case (ast.expr_assign(?lhs, ?rhs, _)) {