Merge branch 'master' of github.com:graydon/rust

Author: pcwalton

doc/rust.texi

@@ -120,7 +120,7 @@ table. The task ahead involves combining, trimming, and implementing.
 @end quotation
 @sp 2
 
-Rust is a curly-brace, block-structured statement language. It visually
+Rust is a curly-brace, block-structured expression language. It visually
 resembles the C language family, but differs significantly in syntactic and
 semantic details. Its design is oriented toward concerns of ``programming in
 the large'', that is, of creating and maintaining @emph{boundaries} -- both
@@ -334,7 +334,7 @@ The Rust type system is primarily structural, and contains the standard
 assortment of useful ``algebraic'' type constructors from functional
 languages, such as function types, tuples, record types, vectors, and
 nominally-tagged disjoint unions. Such values may be @emph{pattern-matched} in
-an @code{alt} statement.
+an @code{alt} expression.
 
 @sp 1
 @item Generic code
@@ -394,8 +394,8 @@ the surrounding text by skipping over the bracketed ``extension text''.
 @sp 1
 @item Idempotent failure
 
-If a task fails due to a signal, or if it executes the special @code{fail}
-statement, it enters the @emph{failing} state. A failing task unwinds its
+If a task fails due to a signal, or if it evaluates the special @code{fail}
+expression, it enters the @emph{failing} state. A failing task unwinds its
 control stack, frees all of its owned resources (executing destructors) and
 enters the @emph{dead} state. Failure is idempotent and non-recoverable.
 
@@ -1486,8 +1486,8 @@ operating-system processes.
 @cindex Port
 @cindex Channel
 @cindex Message passing
-@cindex Send statement
-@cindex Receive statement
+@cindex Send expression
+@cindex Receive expression
 
 With the exception of @emph{unsafe} constructs, Rust tasks are isolated from
 interfering with one another's memory directly. Instead of manipulating shared
@@ -1563,14 +1563,14 @@ A task begins its lifecycle -- once it has been spawned -- in the
 function, and any functions called by the entry function.
 
 A task may transition from the @emph{running} state to the @emph{blocked}
-state any time it executes a communication statement on a port or channel that
-cannot be immediately completed.  When the communication statement can be
+state any time it evaluates a communication expression on a port or channel that
+cannot be immediately completed.  When the communication expression can be
 completed -- when a message arrives at a sender, or a queue drains
 sufficiently to complete a semi-synchronous send -- then the blocked task will
 unblock and transition back to @emph{running}.
 
 A task may transition to the @emph{failing} state at any time, due to an
-un-trapped signal or the execution of a @code{fail} statement. Once
+un-trapped signal or the evaluation of a @code{fail} expression. Once
 @emph{failing}, a task unwinds its stack and transitions to the @emph{dead}
 state. Unwinding the stack of a task is done by the task itself, on its own
 control stack. If a value with a destructor is freed during unwinding, the
@@ -1804,8 +1804,8 @@ otherwise exactly as a function item (with a minor additional cost of calling
 the function, as such a call is indirect). @xref{Ref.Type.Fn}.
 
 Every control path in a function ends with either a @code{ret} or @code{be}
-statement. If a control path lacks a @code{ret} statement in source code, an
-implicit @code{ret} statement is appended to the end of the control path
+expression. If a control path lacks a @code{ret} expression in source code, an
+implicit @code{ret} expression is appended to the end of the control path
 during compilation, returning the implicit @code{()} value.
 
 A function may have an @emph{effect}, which may be either @code{impure} or
@@ -1827,9 +1827,9 @@ fn add(int x, int y) -> int @{
 @c * Ref.Item.Iter::          Items defining iterators.
 
 @cindex Iterators
-@cindex Put statement
-@cindex Put each statement
-@cindex Foreach statement
+@cindex Put expression
+@cindex Put each expression
+@cindex Foreach expression
 
 Iterators are function-like items that can @code{put} multiple values during
 their execution before returning or tail-calling.
@@ -1841,11 +1841,11 @@ but the iterator frame is only @emph{suspended} during the put, and will be
 the caller's loop.
 
 The output type of an iterator is the type of value that the function will
-@code{put}, before it eventually executes a @code{ret} or @code{be} statement
+@code{put}, before it eventually evaluates a @code{ret} or @code{be} expression
 of type @code{()} and completes its execution.
 
 An iterator can only be called in the loop header of a matching @code{for
-each} loop or as the argument in a @code{put each} statement.
+each} loop or as the argument in a @code{put each} expression.
 @xref{Ref.Stmt.Foreach}.
 
 An example of an iterator:
@@ -2052,13 +2052,13 @@ Rust; they cannot be used as user-defined identifiers in any context.
 @cindex Any type
 @cindex Dynamic type, see @i{Any type}
 @cindex Reflection
-@cindex Alt type statement
+@cindex Alt type expression
 
 The type @code{any} is the union of all possible Rust types. A value of type
 @code{any} is represented in memory as a pair consisting of a boxed value of
 some non-@code{any} type @var{T} and a reflection of the type @var{T}.
 
-Values of type @code{any} can be used in an @code{alt type} statement, in
+Values of type @code{any} can be used in an @code{alt type} expression, in
 which the reflection is used to select a block corresponding to a particular
 type extraction. @xref{Ref.Stmt.Alt}.
 
@@ -2549,7 +2549,7 @@ right hand side of copy statements, @xref{Ref.Stmt.Copy}.
 @c * Ref.Stmt::               Executable statements.
 @cindex Statements
 
-A @dfn{statement} is a component of a block, which is in turn a components of
+A @dfn{statement} is a component of a block, which is in turn a component of
 an outer block, a function or an iterator. When a function is spawned into a
 task, the task @emph{executes} statements in an order determined by the body
 of the enclosing structure. Each statement causes the task to perform certain

src/comp/front/ast.rs

@@ -188,7 +188,7 @@ fn binop_to_str(binop op) -> str {
 
 
 tag unop {
-    box;
+    box(mutability);
     deref;
     bitnot;
     not;
@@ -197,7 +197,10 @@ tag unop {
 
 fn unop_to_str(unop op) -> str {
     alt (op) {
-        case (box) {ret "@";}
+        case (box(?mt)) {
+            if (mt == mut) { ret "@mutable"; }
+            ret "@";
+        }
         case (deref) {ret "*";}
         case (bitnot) {ret "~";}
         case (not) {ret "!";}
@@ -255,7 +258,7 @@ tag expr_ {
     expr_tup(vec[elt], ann);
     expr_rec(vec[field], option.t[@expr], ann);
     expr_call(@expr, vec[@expr], ann);
-    expr_call_self(@expr, vec[@expr], ann);
+    expr_call_self(ident, vec[@expr], ann);
     expr_bind(@expr, vec[option.t[@expr]], ann);
     expr_spawn(spawn_dom, option.t[str], @expr, vec[@expr], ann);
     expr_binary(binop, @expr, @expr, ann);

src/comp/front/parser.rs

@@ -887,17 +887,19 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
         }
 
         case (token.SELF) {
+            log "parsing a self-call...";
+
             p.bump();
             expect(p, token.DOT);
             // The rest is a call expression.
-            auto e = parse_bottom_expr(p);
+            auto e = parse_ident(p);
             auto pf = parse_expr;
             auto es = parse_seq[@ast.expr](token.LPAREN,
                                            token.RPAREN,
                                            some(token.COMMA),
                                            pf, p);
             hi = es.span;
-            auto ex = ast.expr_call_self(e, es.node, ast.ann_none);
+            ex = ast.expr_call_self(e, es.node, ast.ann_none);
         }
 
         case (_) {
@@ -1074,9 +1076,10 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
 
         case (token.AT) {
             p.bump();
+            auto m = parse_mutability(p);
             auto e = parse_prefix_expr(p);
             hi = e.span;
-            ex = ast.expr_unary(ast.box, e, ast.ann_none);
+            ex = ast.expr_unary(ast.box(m), e, ast.ann_none);
         }
 
         case (_) {

src/comp/front/token.rs

@@ -348,6 +348,8 @@ fn to_str(token t) -> str {
 
         /* Object type */
         case (OBJ) { ret "obj"; }
+        case (SELF) { ret "self"; }
+
 
         /* Comm and task types */
         case (CHAN) { ret "chan"; }

src/comp/middle/fold.rs

@@ -88,7 +88,7 @@ type ast_fold[ENV] =
          ann a) -> @expr)                         fold_expr_call,
 
      (fn(&ENV e, &span sp,
-         @expr f, vec[@expr] args,
+         ident id, vec[@expr] args,
          ann a) -> @expr)                         fold_expr_call_self,
 
      (fn(&ENV e, &span sp,
@@ -566,10 +566,9 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
             ret fld.fold_expr_call(env_, e.span, ff, aargs, t);
         }
 
-        case (ast.expr_call_self(?f, ?args, ?t)) {
-            auto ff = fold_expr(env_, fld, f);
+        case (ast.expr_call_self(?ident, ?args, ?t)) {
             auto aargs = fold_exprs(env_, fld, args);
-            ret fld.fold_expr_call_self(env_, e.span, ff, aargs, t);
+            ret fld.fold_expr_call_self(env_, e.span, ident, aargs, t);
         }
 
         case (ast.expr_bind(?f, ?args_opt, ?t)) {
@@ -1185,9 +1184,9 @@ fn identity_fold_expr_call[ENV](&ENV env, &span sp, @expr f,
     ret @respan(sp, ast.expr_call(f, args, a));
 }
 
-fn identity_fold_expr_call_self[ENV](&ENV env, &span sp, @expr f,
+fn identity_fold_expr_call_self[ENV](&ENV env, &span sp, ident id,
                                 vec[@expr] args, ann a) -> @expr {
-    ret @respan(sp, ast.expr_call_self(f, args, a));
+    ret @respan(sp, ast.expr_call_self(id, args, a));
 }
 
 fn identity_fold_expr_bind[ENV](&ENV env, &span sp, @expr f,