First pass on splitting stratum and opacity off of effects. WIP.

4 files changed, 57 insertions, 57 deletions

diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index 67c26f9b..920b47d2 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -11,7 +11,7 @@ import std.util.none;
 import std._str;
 import std._vec;
 
-io fn compile_input(session.session sess, str input, str output) {
+impure fn compile_input(session.session sess, str input, str output) {
           auto p = parser.new_parser(sess, 0, input);
           auto crate = parser.parse_crate(p);
           crate = resolve.resolve_crate(sess, crate);
@@ -36,7 +36,7 @@ fn usage(session.session sess, str argv0) {
     log "";
 }
 
-io fn main(vec[str] args) {
+impure fn main(vec[str] args) {
 
   auto sess = session.session();
   let option[str] input_file = none[str];
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index 9ff12f1c..fbeee8cb 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -9,7 +9,7 @@ state type reader = state obj {
                           fn is_eof() -> bool;
                           fn curr() -> char;
                           fn next() -> char;
-                          io fn bump();
+                          impure fn bump();
                           fn mark();
                           fn get_filename() -> str;
                           fn get_mark_pos() -> common.pos;
@@ -55,7 +55,7 @@ fn new_reader(stdio_reader rdr, str filename) -> reader
                 ret n;
             }
 
-            io fn bump() {
+            impure fn bump() {
                 c = n;
 
                 if (c == (-1) as char) {
@@ -247,14 +247,14 @@ fn is_whitespace(char c) -> bool {
     ret c == ' ' || c == '\t' || c == '\r' || c == '\n';
 }
 
-io fn consume_any_whitespace(reader rdr) {
+impure fn consume_any_whitespace(reader rdr) {
     while (is_whitespace(rdr.curr())) {
         rdr.bump();
     }
     be consume_any_line_comment(rdr);
 }
 
-io fn consume_any_line_comment(reader rdr) {
+impure fn consume_any_line_comment(reader rdr) {
     if (rdr.curr() == '/') {
         alt (rdr.next()) {
             case ('/') {
@@ -277,7 +277,7 @@ io fn consume_any_line_comment(reader rdr) {
 }
 
 
-io fn consume_block_comment(reader rdr) {
+impure fn consume_block_comment(reader rdr) {
     let int level = 1;
     while (level > 0) {
         if (rdr.curr() == '/' && rdr.next() == '*') {
@@ -298,7 +298,7 @@ io fn consume_block_comment(reader rdr) {
     be consume_any_whitespace(rdr);
 }
 
-io fn next_token(reader rdr) -> token.token {
+impure fn next_token(reader rdr) -> token.token {
     auto accum_str = "";
     auto accum_int = 0;
 
@@ -359,7 +359,7 @@ io fn next_token(reader rdr) -> token.token {
         ret token.LIT_INT(accum_int);
     }
 
-    io fn binop(reader rdr, token.binop op) -> token.token {
+    impure fn binop(reader rdr, token.binop op) -> token.token {
         rdr.bump();
         if (rdr.next() == '=') {
             rdr.bump();
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index ceb68609..fd3bd1c0 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -13,14 +13,14 @@ import util.common.new_str_hash;
 state type parser =
     state obj {
           fn peek() -> token.token;
-          io fn bump();
-          io fn err(str s);
+          impure fn bump();
+          impure fn err(str s);
           fn get_session() -> session.session;
           fn get_span() -> common.span;
           fn next_def_id() -> ast.def_id;
     };
 
-io fn new_parser(session.session sess,
+impure fn new_parser(session.session sess,
                  ast.crate_num crate, str path) -> parser {
     state obj stdio_parser(session.session sess,
                            mutable token.token tok,
@@ -35,13 +35,13 @@ io fn new_parser(session.session sess,
                 ret tok;
             }
 
-            io fn bump() {
+            impure fn bump() {
                 tok = lexer.next_token(rdr);
                 lo = rdr.get_mark_pos();
                 hi = rdr.get_curr_pos();
             }
 
-            io fn err(str m) {
+            impure fn err(str m) {
                 auto span = rec(filename = rdr.get_filename(),
                                 lo = lo, hi = hi);
                 sess.span_err(span, m);
@@ -68,7 +68,7 @@ io fn new_parser(session.session sess,
                      npos, npos, 0, crate, rdr);
 }
 
-io fn expect(parser p, token.token t) {
+impure fn expect(parser p, token.token t) {
     if (p.peek() == t) {
         p.bump();
     } else {
@@ -86,7 +86,7 @@ fn spanned[T](&span lo, &span hi, &T node) -> ast.spanned[T] {
                                 hi=hi.hi));
 }
 
-io fn parse_ident(parser p) -> ast.ident {
+impure fn parse_ident(parser p) -> ast.ident {
     alt (p.peek()) {
         case (token.IDENT(?i)) { p.bump(); ret i; }
         case (_) {
@@ -96,7 +96,7 @@ io fn parse_ident(parser p) -> ast.ident {
     }
 }
 
-io fn parse_possibly_mutable_ty(parser p) -> tup(bool, @ast.ty) {
+impure fn parse_possibly_mutable_ty(parser p) -> tup(bool, @ast.ty) {
     auto mut;
     if (p.peek() == token.MUTABLE) {
         p.bump();
@@ -108,7 +108,7 @@ io fn parse_possibly_mutable_ty(parser p) -> tup(bool, @ast.ty) {
     ret tup(mut, parse_ty(p));
 }
 
-io fn parse_ty(parser p) -> @ast.ty {
+impure fn parse_ty(parser p) -> @ast.ty {
     auto lo = p.get_span();
     let ast.ty_ t;
     alt (p.peek()) {
@@ -144,7 +144,7 @@ io fn parse_ty(parser p) -> @ast.ty {
     ret @spanned(lo, lo, t);
 }
 
-io fn parse_arg(parser p) -> ast.arg {
+impure fn parse_arg(parser p) -> ast.arg {
     let ast.mode m = ast.val;
     if (p.peek() == token.BINOP(token.AND)) {
         m = ast.alias;
@@ -155,10 +155,10 @@ io fn parse_arg(parser p) -> ast.arg {
     ret rec(mode=m, ty=t, ident=i, id=p.next_def_id());
 }
 
-io fn parse_seq[T](token.token bra,
+impure fn parse_seq[T](token.token bra,
                       token.token ket,
                       option[token.token] sep,
-                      (io fn(parser) -> T) f,
+                      (impure fn(parser) -> T) f,
                       parser p) -> util.common.spanned[vec[T]] {
     let bool first = true;
     auto lo = p.get_span();
@@ -185,7 +185,7 @@ io fn parse_seq[T](token.token bra,
     ret spanned(lo, hi, v);
 }
 
-io fn parse_lit(parser p) -> option[ast.lit] {
+impure fn parse_lit(parser p) -> option[ast.lit] {
     auto lo = p.get_span();
     let ast.lit_ lit;
     alt (p.peek()) {
@@ -217,7 +217,7 @@ io fn parse_lit(parser p) -> option[ast.lit] {
     ret some(spanned(lo, lo, lit));
 }
 
-io fn parse_name(parser p, ast.ident id) -> ast.name {
+impure fn parse_name(parser p, ast.ident id) -> ast.name {
 
     auto lo = p.get_span();
 
@@ -240,7 +240,7 @@ io fn parse_name(parser p, ast.ident id) -> ast.name {
     ret spanned(lo, tys.span, rec(ident=id, types=tys.node));
 }
 
-io fn parse_possibly_mutable_expr(parser p) -> tup(bool, @ast.expr) {
+impure fn parse_possibly_mutable_expr(parser p) -> tup(bool, @ast.expr) {
     auto mut;
     if (p.peek() == token.MUTABLE) {
         p.bump();
@@ -252,7 +252,7 @@ io fn parse_possibly_mutable_expr(parser p) -> tup(bool, @ast.expr) {
     ret tup(mut, parse_expr(p));
 }
 
-io fn parse_bottom_expr(parser p) -> @ast.expr {
+impure fn parse_bottom_expr(parser p) -> @ast.expr {
 
     auto lo = p.get_span();
     auto hi = lo;
@@ -315,7 +315,7 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
 
         case (token.REC) {
             p.bump();
-            io fn parse_entry(parser p) ->
+            impure fn parse_entry(parser p) ->
                 tup(ast.ident, @ast.expr) {
                 auto i = parse_ident(p);
                 expect(p, token.EQ);
@@ -348,7 +348,7 @@ io fn parse_bottom_expr(parser p) -> @ast.expr {
     ret @spanned(lo, hi, ex);
 }
 
-io fn parse_path_expr(parser p) -> @ast.expr {
+impure fn parse_path_expr(parser p) -> @ast.expr {
     auto lo = p.get_span();
     auto e = parse_bottom_expr(p);
     auto hi = e.span;
@@ -381,7 +381,7 @@ io fn parse_path_expr(parser p) -> @ast.expr {
     ret e;
 }
 
-io fn parse_prefix_expr(parser p) -> @ast.expr {
+impure fn parse_prefix_expr(parser p) -> @ast.expr {
 
     auto lo = p.get_span();
     auto hi = lo;
@@ -443,8 +443,8 @@ io fn parse_prefix_expr(parser p) -> @ast.expr {
     ret @spanned(lo, hi, ex);
 }
 
-io fn parse_binops(parser p,
-                   (io fn(parser) -> @ast.expr) sub,
+impure fn parse_binops(parser p,
+                   (impure fn(parser) -> @ast.expr) sub,
                    vec[tup(token.binop, ast.binop)] ops)
     -> @ast.expr {
     auto lo = p.get_span();
@@ -472,8 +472,8 @@ io fn parse_binops(parser p,
     ret e;
 }
 
-io fn parse_binary_exprs(parser p,
-                            (io fn(parser) -> @ast.expr) sub,
+impure fn parse_binary_exprs(parser p,
+                            (impure fn(parser) -> @ast.expr) sub,
                             vec[tup(token.token, ast.binop)] ops)
     -> @ast.expr {
     auto lo = p.get_span();
@@ -496,42 +496,42 @@ io fn parse_binary_exprs(parser p,
     ret e;
 }
 
-io fn parse_factor_expr(parser p) -> @ast.expr {
+impure fn parse_factor_expr(parser p) -> @ast.expr {
     auto sub = parse_prefix_expr;
     ret parse_binops(p, sub, vec(tup(token.STAR, ast.mul),
                                  tup(token.SLASH, ast.div),
                                  tup(token.PERCENT, ast.rem)));
 }
 
-io fn parse_term_expr(parser p) -> @ast.expr {
+impure fn parse_term_expr(parser p) -> @ast.expr {
     auto sub = parse_factor_expr;
     ret parse_binops(p, sub, vec(tup(token.PLUS, ast.add),
                                  tup(token.MINUS, ast.sub)));
 }
 
-io fn parse_shift_expr(parser p) -> @ast.expr {
+impure fn parse_shift_expr(parser p) -> @ast.expr {
     auto sub = parse_term_expr;
     ret parse_binops(p, sub, vec(tup(token.LSL, ast.lsl),
                                  tup(token.LSR, ast.lsr),
                                  tup(token.ASR, ast.asr)));
 }
 
-io fn parse_bitand_expr(parser p) -> @ast.expr {
+impure fn parse_bitand_expr(parser p) -> @ast.expr {
     auto sub = parse_shift_expr;
     ret parse_binops(p, sub, vec(tup(token.AND, ast.bitand)));
 }
 
-io fn parse_bitxor_expr(parser p) -> @ast.expr {
+impure fn parse_bitxor_expr(parser p) -> @ast.expr {
     auto sub = parse_bitand_expr;
     ret parse_binops(p, sub, vec(tup(token.CARET, ast.bitxor)));
 }
 
-io fn parse_bitor_expr(parser p) -> @ast.expr {
+impure fn parse_bitor_expr(parser p) -> @ast.expr {
     auto sub = parse_bitxor_expr;
     ret parse_binops(p, sub, vec(tup(token.OR, ast.bitor)));
 }
 
-io fn parse_cast_expr(parser p) -> @ast.expr {
+impure fn parse_cast_expr(parser p) -> @ast.expr {
     auto lo = p.get_span();
     auto e = parse_bitor_expr(p);
     auto hi = e.span;
@@ -552,7 +552,7 @@ io fn parse_cast_expr(parser p) -> @ast.expr {
     ret e;
 }
 
-io fn parse_relational_expr(parser p) -> @ast.expr {
+impure fn parse_relational_expr(parser p) -> @ast.expr {
     auto sub = parse_cast_expr;
     ret parse_binary_exprs(p, sub, vec(tup(token.LT, ast.lt),
                                        tup(token.LE, ast.le),
@@ -561,23 +561,23 @@ io fn parse_relational_expr(parser p) -> @ast.expr {
 }
 
 
-io fn parse_equality_expr(parser p) -> @ast.expr {
+impure fn parse_equality_expr(parser p) -> @ast.expr {
     auto sub = parse_relational_expr;
     ret parse_binary_exprs(p, sub, vec(tup(token.EQEQ, ast.eq),
                                        tup(token.NE, ast.ne)));
 }
 
-io fn parse_and_expr(parser p) -> @ast.expr {
+impure fn parse_and_expr(parser p) -> @ast.expr {
     auto sub = parse_equality_expr;
     ret parse_binary_exprs(p, sub, vec(tup(token.ANDAND, ast.and)));
 }
 
-io fn parse_or_expr(parser p) -> @ast.expr {
+impure fn parse_or_expr(parser p) -> @ast.expr {
     auto sub = parse_and_expr;
     ret parse_binary_exprs(p, sub, vec(tup(token.OROR, ast.or)));
 }
 
-io fn parse_assign_expr(parser p) -> @ast.expr {
+impure fn parse_assign_expr(parser p) -> @ast.expr {
     auto lo = p.get_span();
     auto lhs = parse_or_expr(p);
     alt (p.peek()) {
@@ -591,7 +591,7 @@ io fn parse_assign_expr(parser p) -> @ast.expr {
     ret lhs;
 }
 
-io fn parse_if_expr(parser p) -> @ast.expr {
+impure fn parse_if_expr(parser p) -> @ast.expr {
     auto lo = p.get_span();
     auto hi = lo;
 
@@ -613,7 +613,7 @@ io fn parse_if_expr(parser p) -> @ast.expr {
     ret @spanned(lo, hi, ast.expr_if(cond, thn, els, none[@ast.ty]));
 }
 
-io fn parse_expr(parser p) -> @ast.expr {
+impure fn parse_expr(parser p) -> @ast.expr {
     alt (p.peek()) {
         case (token.LBRACE) {
             auto blk = parse_block(p);
@@ -630,7 +630,7 @@ io fn parse_expr(parser p) -> @ast.expr {
     }
 }
 
-io fn parse_initializer(parser p) -> option[@ast.expr] {
+impure fn parse_initializer(parser p) -> option[@ast.expr] {
     if (p.peek() == token.EQ) {
         p.bump();
         ret some(parse_expr(p));
@@ -639,7 +639,7 @@ io fn parse_initializer(parser p) -> option[@ast.expr] {
     ret none[@ast.expr];
 }
 
-io fn parse_let(parser p) -> @ast.decl {
+impure fn parse_let(parser p) -> @ast.decl {
     auto lo = p.get_span();
 
     expect(p, token.LET);
@@ -659,7 +659,7 @@ io fn parse_let(parser p) -> @ast.decl {
     ret @spanned(lo, hi, ast.decl_local(@local));
 }
 
-io fn parse_auto(parser p) -> @ast.decl {
+impure fn parse_auto(parser p) -> @ast.decl {
     auto lo = p.get_span();
 
     expect(p, token.AUTO);
@@ -678,7 +678,7 @@ io fn parse_auto(parser p) -> @ast.decl {
     ret @spanned(lo, hi, ast.decl_local(@local));
 }
 
-io fn parse_stmt(parser p) -> @ast.stmt {
+impure fn parse_stmt(parser p) -> @ast.stmt {
     auto lo = p.get_span();
     alt (p.peek()) {
 
@@ -760,7 +760,7 @@ io fn parse_stmt(parser p) -> @ast.stmt {
     fail;
 }
 
-io fn parse_block(parser p) -> ast.block {
+impure fn parse_block(parser p) -> ast.block {
     auto f = parse_stmt;
     // FIXME: passing parse_stmt as an lval doesn't work at the moment.
     auto stmts = parse_seq[@ast.stmt](token.LBRACE,
@@ -800,7 +800,7 @@ io fn parse_block(parser p) -> ast.block {
     ret spanned(stmts.span, stmts.span, b);
 }
 
-io fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
+impure fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
     auto lo = p.get_span();
     expect(p, token.FN);
     auto id = parse_ident(p);
@@ -832,7 +832,7 @@ io fn parse_fn(parser p) -> tup(ast.ident, @ast.item) {
     ret tup(id, @spanned(lo, body.span, item));
 }
 
-io fn parse_mod_items(parser p, token.token term) -> ast._mod {
+impure fn parse_mod_items(parser p, token.token term) -> ast._mod {
    let vec[@ast.item] items = vec();
     let hashmap[ast.ident,uint] index = new_str_hash[uint]();
     let uint u = 0u;
@@ -845,7 +845,7 @@ io fn parse_mod_items(parser p, token.token term) -> ast._mod {
     ret rec(items=items, index=index);
  }
 
-io fn parse_mod(parser p) -> tup(ast.ident, @ast.item) {
+impure fn parse_mod(parser p) -> tup(ast.ident, @ast.item) {
     auto lo = p.get_span();
     expect(p, token.MOD);
     auto id = parse_ident(p);
@@ -857,7 +857,7 @@ io fn parse_mod(parser p) -> tup(ast.ident, @ast.item) {
     ret tup(id, @spanned(lo, hi, item));
 }
 
-io fn parse_item(parser p) -> tup(ast.ident, @ast.item) {
+impure fn parse_item(parser p) -> tup(ast.ident, @ast.item) {
     alt (p.peek()) {
         case (token.FN) {
             ret parse_fn(p);
@@ -870,7 +870,7 @@ io fn parse_item(parser p) -> tup(ast.ident, @ast.item) {
     fail;
 }
 
-io fn parse_crate(parser p) -> @ast.crate {
+impure fn parse_crate(parser p) -> @ast.crate {
     auto lo = p.get_span();
     auto hi = lo;
     auto m = parse_mod_items(p, token.EOF);
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index cce0d38f..f9f3b0a6 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -30,7 +30,7 @@ mod util {
     mod common;
 }
 
-auth driver.rustc.main = state;
+auth driver.rustc.main = impure;
 auth middle.trans = unsafe;
 auth lib.llvm = unsafe;