Introduce a ty_infer ast node and use it instead of option::t[ty].

This actually basically makes things worse, since we get less nice
type system guarentees but it will make doing type inferred blocks a
fair deal less painful. I'm not /really/ happy about this...

Author: msullivan

src/comp/middle/typeck.rs

@@ -408,6 +408,10 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
         }
         typ = ty::mk_constr(tcx, ast_ty_to_ty(tcx, getter, t), out_cs);
       }
+      ast::ty_infer. {
+        tcx.sess.span_bug(ast_ty.span,
+                          "found ty_infer in unexpected place");
+      }
     }
     alt cname {
       none. {/* no-op */ }
@@ -429,6 +433,23 @@ fn ast_ty_to_ty_crate(ccx: @crate_ctxt, ast_ty: &@ast::ty) -> ty::t {
     ret ast_ty_to_ty(ccx.tcx, f, ast_ty);
 }
 
+// A wrapper around ast_ty_to_ty_crate that handles ty_infer.
+fn ast_ty_to_ty_crate_infer(ccx: @crate_ctxt, ast_ty: &@ast::ty)
+    -> option::t[ty::t] {
+    alt ast_ty.node {
+      ast::ty_infer. { none }
+      _ { some(ast_ty_to_ty_crate(ccx, ast_ty)) }
+    }
+}
+// A wrapper around ast_ty_to_ty_infer that generates a new type variable if
+// there isn't a fixed type.
+fn ast_ty_to_ty_crate_tyvar(fcx: &@fn_ctxt, ast_ty: &@ast::ty) -> ty::t {
+    alt ast_ty_to_ty_crate_infer(fcx.ccx, ast_ty) {
+      some(ty) { ty }
+      none. { next_ty_var(fcx) }
+    }
+}
+
 
 // Functions that write types into the node type table.
 mod write {
@@ -1269,17 +1290,8 @@ fn gather_locals(ccx: &@crate_ctxt, f: &ast::_fn, id: &ast::node_id,
 
     // Add explicitly-declared locals.
     let visit_local = lambda(local: &@ast::local, e: &(), v: &visit::vt[()]) {
-        alt local.node.ty {
-          none. {
-            // Auto slot.
-            assign(local.node.id, ident_for_local(local), none);
-          }
-          some(ast_ty) {
-            // Explicitly typed slot.
-            let local_ty = ast_ty_to_ty_crate(ccx, ast_ty);
-            assign(local.node.id, ident_for_local(local), some(local_ty));
-          }
-        }
+        let local_ty = ast_ty_to_ty_crate_infer(ccx, local.node.ty);
+        assign(local.node.id, ident_for_local(local), local_ty);
         visit::visit_local(local, e, v);
     };
 
@@ -2339,10 +2351,9 @@ fn check_expr(fcx: &@fn_ctxt, expr: &@ast::expr) -> bool {
       }
       ast::expr_port(typ) {
         let t = next_ty_var(fcx);
-        alt typ {
+        alt ast_ty_to_ty_crate_infer(fcx.ccx, typ) {
           some(_t) {
-            demand::simple(fcx, expr.span, ast_ty_to_ty_crate(fcx.ccx, _t),
-                           t);
+            demand::simple(fcx, expr.span, _t, t);
           }
           none. { }
         }

src/comp/syntax/ast.rs

@@ -260,7 +260,7 @@ tag init_op { init_assign; init_move; }
 
 type initializer = {op: init_op, expr: @expr};
 
-type local_ = {ty: option::t[@ty],
+type local_ = {ty: @ty,
                pat: @pat,
                init: option::t[initializer],
                id: node_id};
@@ -335,7 +335,7 @@ tag expr_ {
     /* FIXME Would be nice if expr_check desugared
        to expr_if_check. */
     expr_if_check(@expr, blk, option::t[@expr]);
-    expr_port(option::t[@ty]);
+    expr_port(@ty);
     expr_chan(@expr);
     expr_anon_obj(anon_obj);
     expr_mac(mac);
@@ -451,6 +451,10 @@ tag ty_ {
     ty_type;
     ty_constr(@ty, [@ty_constr]);
     ty_mac(mac);
+    // ty_infer means the type should be inferred instead of it having been
+    // specified. This should only appear at the "top level" of a type and not
+    // nested in one.
+    ty_infer;
 }
 
 

src/comp/syntax/fold.rs

@@ -421,11 +421,8 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
             expr_if_check(fld.fold_expr(cond), fld.fold_block(tr),
                           option::map(fld.fold_expr, fl))
           }
-          expr_port(ot) {
-            expr_port(alt ot {
-                        option::some(t) { option::some(fld.fold_ty(t)) }
-                        option::none. { option::none }
-                      })
+          expr_port(t) {
+            expr_port(fld.fold_ty(t))
           }
           expr_chan(e) { expr_chan(fld.fold_expr(e)) }
           expr_anon_obj(ao) { expr_anon_obj(fold_anon_obj(ao)) }
@@ -487,7 +484,7 @@ fn noop_fold_path(p: &path_, fld: ast_fold) -> path_ {
 }
 
 fn noop_fold_local(l: &local_, fld: ast_fold) -> local_ {
-    ret {ty: option::map(fld.fold_ty, l.ty),
+    ret {ty: fld.fold_ty(l.ty),
          pat: fld.fold_pat(l.pat),
          init: alt l.init {
            option::none[initializer]. { l.init }

src/comp/syntax/parse/parser.rs

@@ -952,10 +952,10 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
             ex = ast::expr_be(e);
         } else { p.fatal("Non-call expression in tail call"); }
     } else if (eat_word(p, "port")) {
-        let ty = none;
+        let ty = @spanned(lo, hi, ast::ty_infer);
         if token::LBRACKET == p.peek() {
             expect(p, token::LBRACKET);
-            ty = some(parse_ty(p));
+            ty = parse_ty(p);
             expect(p, token::RBRACKET);
         }
         expect(p, token::LPAREN);
@@ -1481,8 +1481,8 @@ fn parse_pat(p: &parser) -> @ast::pat {
 fn parse_local(p: &parser, allow_init: bool) -> @ast::local {
     let lo = p.get_lo_pos();
     let pat = parse_pat(p);
-    let ty = none;
-    if eat(p, token::COLON) { ty = some(parse_ty(p)); }
+    let ty = @spanned(lo, lo, ast::ty_infer);
+    if eat(p, token::COLON) { ty = parse_ty(p); }
     let init = if allow_init { parse_initializer(p) } else { none };
     ret @spanned(lo, p.get_last_hi_pos(),
                  {ty: ty,

src/comp/syntax/print/pprust.rs

@@ -966,11 +966,11 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         pclose(s);
       }
       ast::expr_mac(m) { print_mac(s, m); }
-      ast::expr_port(ot) {
+      ast::expr_port(t) {
         word(s.s, "port");
-        alt ot {
-          some(t) { word(s.s, "["); print_type(s, *t); word(s.s, "]"); }
-          none. { }
+        alt t.node {
+          ast::ty_infer. { }
+          _ { word(s.s, "["); print_type(s, *t); word(s.s, "]"); }
         }
         popen(s);
         pclose(s);
@@ -1040,6 +1040,14 @@ fn print_expr_parens_if_unary(s: &ps, ex: &@ast::expr) {
     if parens { pclose(s); }
 }
 
+fn print_local_decl(s: &ps, loc: &@ast::local) {
+    print_pat(s, loc.node.pat);
+    alt loc.node.ty.node {
+      ast::ty_infer. { }
+      _ { word_space(s, ":"); print_type(s, *loc.node.ty); }
+    }
+}
+
 fn print_decl(s: &ps, decl: &@ast::decl) {
     maybe_print_comment(s, decl.span.lo);
     alt decl.node {
@@ -1049,14 +1057,7 @@ fn print_decl(s: &ps, decl: &@ast::decl) {
         word_nbsp(s, "let");
         fn print_local(s: &ps, loc: &@ast::local) {
             ibox(s, indent_unit);
-            print_pat(s, loc.node.pat);
-            alt loc.node.ty {
-              some(ty) {
-                word_space(s, ":");
-                print_type(s, *ty);
-              }
-              _ { }
-            }
+            print_local_decl(s, loc);
             end(s);
             alt loc.node.init {
               some(init) {
@@ -1080,11 +1081,7 @@ fn print_decl(s: &ps, decl: &@ast::decl) {
 fn print_ident(s: &ps, ident: &ast::ident) { word(s.s, ident); }
 
 fn print_for_decl(s: &ps, loc: &@ast::local, coll: &@ast::expr) {
-    print_pat(s, loc.node.pat);
-    alt loc.node.ty {
-      some(t) { word_space(s, ":"); print_type(s, *t); }
-      none. { }
-    }
+    print_local_decl(s, loc);
     space(s.s);
     word_space(s, "in");
     print_expr(s, coll);

src/comp/syntax/visit.rs

@@ -79,7 +79,7 @@ fn visit_view_item[E](vi: &@view_item, e: &E, v: &vt[E]) { }
 
 fn visit_local[E](loc: &@local, e: &E, v: &vt[E]) {
     v.visit_pat(loc.node.pat, e, v);
-    alt loc.node.ty { none. { } some(t) { v.visit_ty(t, e, v); } }
+    v.visit_ty(loc.node.ty, e, v);
     alt loc.node.init { none. { } some(i) { v.visit_expr(i.expr, e, v); } }
 }
 
@@ -154,13 +154,10 @@ fn visit_ty[E](t: &@ty, e: &E, v: &vt[E]) {
             v.visit_constr(tc.node.path, tc.span, tc.node.id, e, v);
         }
       }
+      ty_infer. {/* no-op */ }
     }
 }
 
-fn visit_ty_opt[E](ot: &option::t[@ty], e: &E, v: &vt[E]) {
-    alt ot { none. { } some(t) { v.visit_ty(t, e, v); } }
-}
-
 fn visit_constr[E](operator: &path, sp: &span, id: node_id, e: &E,
                    v: &vt[E]) {
     // default
@@ -313,7 +310,7 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
       expr_log(_, x) { v.visit_expr(x, e, v); }
       expr_check(_, x) { v.visit_expr(x, e, v); }
       expr_assert(x) { v.visit_expr(x, e, v); }
-      expr_port(t) { visit_ty_opt(t, e, v); }
+      expr_port(t) { v.visit_ty(t, e, v); }
       expr_chan(x) { v.visit_expr(x, e, v); }
       expr_anon_obj(anon_obj) {
         alt anon_obj.fields {