---

yaml
---
r: 41967
b: refs/heads/master
c: d912d53
h: refs/heads/master
i:
  41965: 61ae8be
  41963: 1f2a5eb
  41959: fef9b59
  41951: 7f7d825
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 69fff85ec83029d8889a0c2877ee5a9798140d1f
+refs/heads/master: d912d53ea9921c4fc9044c657ddcb3e044617fa9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/AUTHORS.txt

@@ -148,5 +148,4 @@ Vincent Belliard <[email protected]>
 Wade Mealing <[email protected]>
 William Ting <[email protected]>
 Yasuhiro Fujii <[email protected]>
-Youngsoo Son <[email protected]>
 Zack Corr <[email protected]>

trunk/doc/rust.md

@@ -222,7 +222,7 @@ let log loop
 match mod move mut
 priv pub pure
 ref return
-self static struct super
+self static struct
 true trait type
 unsafe use
 while

trunk/src/libcore/hashmap.rs

@@ -60,6 +60,10 @@ pub mod linear {
         ((capacity as float) * 3. / 4.) as uint
     }
 
+    pub fn LinearMap<K:Eq Hash,V>() -> LinearMap<K,V> {
+        linear_map_with_capacity(INITIAL_CAPACITY)
+    }
+
     pub fn linear_map_with_capacity<K:Eq Hash,V>(
         initial_capacity: uint) -> LinearMap<K,V> {
         let r = rand::Rng();
@@ -347,8 +351,7 @@ pub mod linear {
         }
     }
 
-    pub impl<K:Hash IterBytes Eq,V> LinearMap<K,V> {
-        /// Create an empty LinearMap
+    impl<K:Hash IterBytes Eq,V> LinearMap<K,V> {
         static fn new() -> LinearMap<K, V> {
             linear_map_with_capacity(INITIAL_CAPACITY)
         }
@@ -492,7 +495,7 @@ pub mod linear {
 
     pub impl <T: Hash IterBytes Eq> LinearSet<T> {
         /// Create an empty LinearSet
-        static fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} }
+        static fn new() -> LinearSet<T> { LinearSet{map: LinearMap()} }
     }
 }
 

trunk/src/librustc/middle/resolve.rs

@@ -10,7 +10,6 @@
 
 use core::prelude::*;
 
-use driver::session;
 use driver::session::Session;
 use metadata::csearch::{each_path, get_method_names_if_trait};
 use metadata::csearch::{get_static_methods_if_impl, get_type_name_if_impl};
@@ -3932,10 +3931,7 @@ impl Resolver {
             item_fn(ref fn_decl, _, ref ty_params, ref block) => {
                 // If this is the main function, we must record it in the
                 // session.
-                // FIXME #4404 android JNI hacks
-                if !self.session.building_library ||
-                    self.session.targ_cfg.os == session::os_android {
-
+                if !self.session.building_library {
                     if self.attr_main_fn.is_none() &&
                            item.ident == special_idents::main {
 

trunk/src/librustc/middle/trans/base.rs

@@ -62,6 +62,7 @@ use middle::trans::shape::*;
 use middle::trans::tvec;
 use middle::trans::type_of::*;
 use util::common::indenter;
+use util::common::is_main_name;
 use util::ppaux::{ty_to_str, ty_to_short_str};
 use util::ppaux;
 
@@ -2190,9 +2191,14 @@ fn is_main_fn(sess: &Session, node_id: ast::node_id) -> bool {
 
 // Create a _rust_main(args: ~[str]) function which will be called from the
 // runtime rust_start function
-fn create_main_wrapper(ccx: @crate_ctxt, _sp: span, main_llfn: ValueRef) {
+fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef) {
+
+    if ccx.main_fn != None::<ValueRef> {
+        ccx.sess.span_fatal(sp, ~"multiple 'main' functions");
+    }
 
     let llfn = create_main(ccx, main_llfn);
+    ccx.main_fn = Some(llfn);
     create_entry_fn(ccx, llfn);
 
     fn create_main(ccx: @crate_ctxt, main_llfn: ValueRef) -> ValueRef {
@@ -3002,6 +3008,7 @@ fn trans_crate(sess: session::Session,
               exp_map2: emap2,
               reachable: reachable,
               item_symbols: HashMap(),
+              mut main_fn: None::<ValueRef>,
               link_meta: link_meta,
               enum_sizes: ty::new_ty_hash(),
               discrims: HashMap(),

trunk/src/librustc/middle/trans/common.rs

@@ -163,6 +163,7 @@ struct crate_ctxt {
      exp_map2: resolve::ExportMap2,
      reachable: reachable::map,
      item_symbols: HashMap<ast::node_id, ~str>,
+     mut main_fn: Option<ValueRef>,
      link_meta: link_meta,
      enum_sizes: HashMap<ty::t, uint>,
      discrims: HashMap<ast::def_id, ValueRef>,

trunk/src/librustc/middle/ty.rs

@@ -1659,13 +1659,13 @@ fn subst(cx: ctxt,
     }
 }
 
-// Performs substitutions on a set of substitutions (result = sup(sub)) to
+// Performs substitutions on a set of substitutions (result = super(sub)) to
 // yield a new set of substitutions. This is used in trait inheritance.
-fn subst_substs(cx: ctxt, sup: &substs, sub: &substs) -> substs {
+fn subst_substs(cx: ctxt, super: &substs, sub: &substs) -> substs {
     {
-        self_r: sup.self_r,
-        self_ty: sup.self_ty.map(|typ| subst(cx, sub, *typ)),
-        tps: sup.tps.map(|typ| subst(cx, sub, *typ))
+        self_r: super.self_r,
+        self_ty: super.self_ty.map(|typ| subst(cx, sub, *typ)),
+        tps: super.tps.map(|typ| subst(cx, sub, *typ))
     }
 }
 

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -1497,7 +1497,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
           match ty::get(lhs_resolved_t).sty {
             ty::ty_fn(_) => {
               tcx.sess.span_note(
-                  ex.span, ~"did you forget the `do` keyword for the call?");
+                  ex.span, ~"did you forget the 'do' keyword for the call?");
             }
             _ => ()
           }
@@ -2207,33 +2207,23 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
           Some(ty::ty_fn(ref fty)) => {
             match fcx.mk_subty(false, expr.span,
                                (*fty).sig.output, ty::mk_bool(tcx)) {
-              result::Ok(_) =>
-                  ty::mk_fn(tcx, FnTyBase {
-                      meta: (*fty).meta,
-                      sig: FnSig {output: ty::mk_nil(tcx),
-                                  ../*bad*/copy (*fty).sig}
-                  }),
+              result::Ok(_) => (),
               result::Err(_) => {
                    fcx.type_error_message(expr.span,
                       |actual| {
-                          fmt!("A `for` loop iterator should expect a \
-                                closure that returns `bool`. This iterator \
-                                expects a closure that returns `%s`. %s",
-                               actual, if ty::type_is_nil((*fty).sig.output) {
-                                   "\nDid you mean to use `do` instead of \
-                                        `for`?" } else { "" } )
+                          fmt!("a `loop` function's last argument \
+                                should return `bool`, not `%s`", actual)
                       },
                       (*fty).sig.output, None);
                 err_happened = true;
-                // Kind of a hack: create a function type with the result
-                // replaced with ty_err, to suppress derived errors.
-                let t = ty::replace_fn_return_type(tcx, ty::mk_fn(tcx,
-                                                                  copy *fty),
-                                                   ty::mk_err(tcx));
                 fcx.write_ty(id, ty::mk_err(tcx));
-                t
               }
             }
+            ty::mk_fn(tcx, FnTyBase {
+                meta: (*fty).meta,
+                sig: FnSig {output: ty::mk_nil(tcx),
+                            ../*bad*/copy (*fty).sig}
+            })
           }
           _ =>
               match expected {
@@ -2255,22 +2245,14 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
               }
         };
         match b.node {
-                ast::expr_fn_block(ref decl, ref body, cap_clause) => {
-                    // If an error occurred, we pretend this isn't a for
-                    // loop, so as to assign types to all nodes while also
-                    // propagating ty_err throughout so as to suppress
-                    // derived errors. If we passed in ForLoop in the
-                    // error case, we'd potentially emit a spurious error
-                    // message because of the indirect_ret_ty.
-                    let fn_kind = if err_happened { Vanilla }
-                                  else { ForLoop };
-                    check_expr_fn(fcx, b, None,
-                                  decl, *body, fn_kind, Some(inner_ty));
-                    demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b));
-                    capture::check_capture_clause(tcx, b.id, cap_clause);
-                }
-                // argh
-                _ => fail ~"expr_fn_block"
+          ast::expr_fn_block(ref decl, ref body, cap_clause) => {
+            check_expr_fn(fcx, b, None,
+                          decl, *body, ForLoop, Some(inner_ty));
+            demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b));
+            capture::check_capture_clause(tcx, b.id, cap_clause);
+          }
+          // argh
+          _ => fail ~"expr_fn_block"
         }
         let block_ty = structurally_resolved_type(
             fcx, expr.span, fcx.node_ty(b.id));

trunk/src/librustc/util/common.rs

@@ -101,6 +101,12 @@ fn local_rhs_span(l: @ast::local, def: span) -> span {
     }
 }
 
+fn is_main_name(path: syntax::ast_map::path) -> bool {
+    vec::last(path) == syntax::ast_map::path_name(
+        syntax::parse::token::special_idents::main
+    )
+}
+
 fn pluralize(n: uint, +s: ~str) -> ~str {
     if n == 1 { s }
     else { str::concat([s, ~"s"]) }

trunk/src/libstd/priority_queue.rs

@@ -47,9 +47,6 @@ impl <T: Ord> PriorityQueue<T> {
         if self.is_empty() { None } else { Some(self.top()) }
     }
 
-    /// Returns true if a queue contains some elements
-    pure fn is_not_empty(&self) -> bool { self.data.is_not_empty() }
-
     /// Returns the number of elements the queue can hold without reallocating
     pure fn capacity(&self) -> uint { vec::capacity(&self.data) }
 
@@ -62,7 +59,7 @@ impl <T: Ord> PriorityQueue<T> {
     /// Pop the greatest item from the queue - fails if empty
     fn pop(&mut self) -> T {
         let mut item = self.data.pop();
-        if self.is_not_empty() { item <-> self.data[0]; self.siftdown(0); }
+        if !self.is_empty() { item <-> self.data[0]; self.siftdown(0); }
         item
     }
 
@@ -80,7 +77,7 @@ impl <T: Ord> PriorityQueue<T> {
     /// Optimized version of a push followed by a pop
     fn push_pop(&mut self, item: T) -> T {
         let mut item = item;
-        if self.is_not_empty() && self.data[0] > item {
+        if !self.is_empty() && self.data[0] > item {
             item <-> self.data[0];
             self.siftdown(0);
         }
@@ -189,7 +186,7 @@ mod tests {
         let data = ~[2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
         let mut sorted = merge_sort(data, le);
         let mut heap = from_vec(data);
-        while heap.is_not_empty() {
+        while !heap.is_empty() {
             assert *heap.top() == sorted.last();
             assert heap.pop() == sorted.pop();
         }

trunk/src/libstd/workcache.rs

@@ -259,7 +259,7 @@ impl Context {
     static fn new(db: @Mut<Database>,
                   lg: @Mut<Logger>,
                   cfg: @json::Object) -> Context {
-        Context{db: db, logger: lg, cfg: cfg, freshness: LinearMap::new()}
+        Context {db: db, logger: lg, cfg: cfg, freshness: LinearMap()}
     }
 
     fn prep<T:Owned
@@ -270,7 +270,7 @@ impl Context {
                   blk: fn(@Mut<Prep>)->Work<T>) -> Work<T> {
         let p = @Mut(Prep {ctxt: self,
                            fn_name: fn_name.to_owned(),
-                           declared_inputs: LinearMap::new()});
+                           declared_inputs: LinearMap()});
         blk(p)
     }
 }

trunk/src/libsyntax/parse/parser.rs

@@ -1660,45 +1660,43 @@ impl Parser {
         // them as the lambda arguments
         let e = self.parse_expr_res(RESTRICT_NO_BAR_OR_DOUBLEBAR_OP);
         match e.node {
-            expr_call(f, args, false) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                let args = vec::append(args, ~[last_arg]);
-                self.mk_expr(lo.lo, block.span.hi, expr_call(f, args, true))
-            }
-            expr_method_call(f, i, tps, args, false) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                let args = vec::append(args, ~[last_arg]);
-                self.mk_expr(lo.lo, block.span.hi,
-                             expr_method_call(f, i, tps, args, true))
-            }
-            expr_field(f, i, tps) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                self.mk_expr(lo.lo, block.span.hi,
-                             expr_method_call(f, i, tps, ~[last_arg], true))
-            }
-            expr_path(*) | expr_call(*) | expr_method_call(*) |
-                expr_paren(*) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                self.mk_expr(lo.lo, last_arg.span.hi,
-                             expr_call(e, ~[last_arg], true))
-            }
-            _ => {
-                // There may be other types of expressions that can
-                // represent the callee in `for` and `do` expressions
-                // but they aren't represented by tests
-                debug!("sugary call on %?", e.node);
-                self.span_fatal(
-                    lo, fmt!("`%s` must be followed by a block call",
-                             keyword));
-            }
+          expr_call(f, args, false) => {
+            let block = self.parse_lambda_block_expr();
+            let last_arg = self.mk_expr(block.span.lo, block.span.hi,
+                                    ctor(block));
+            let args = vec::append(args, ~[last_arg]);
+            @expr {node: expr_call(f, args, true), .. *e}
+          }
+          expr_method_call(f, i, tps, args, false) => {
+            let block = self.parse_lambda_block_expr();
+            let last_arg = self.mk_expr(block.span.lo, block.span.hi,
+                                    ctor(block));
+            let args = vec::append(args, ~[last_arg]);
+            @expr {node: expr_method_call(f, i, tps, args, true), .. *e}
+          }
+          expr_field(f, i, tps) => {
+            let block = self.parse_lambda_block_expr();
+            let last_arg = self.mk_expr(block.span.lo, block.span.hi,
+                                    ctor(block));
+            @expr {node: expr_method_call(f, i, tps, ~[last_arg], true),
+                   .. *e}
+          }
+          expr_path(*) | expr_call(*) | expr_method_call(*) |
+          expr_paren(*) => {
+            let block = self.parse_lambda_block_expr();
+            let last_arg = self.mk_expr(block.span.lo, block.span.hi,
+                                    ctor(block));
+            self.mk_expr(lo.lo, last_arg.span.hi,
+                         expr_call(e, ~[last_arg], true))
+          }
+          _ => {
+            // There may be other types of expressions that can
+            // represent the callee in `for` and `do` expressions
+            // but they aren't represented by tests
+            debug!("sugary call on %?", e.node);
+            self.span_fatal(
+                lo, fmt!("`%s` must be followed by a block call", keyword));
+          }
         }
     }
 

trunk/src/libsyntax/parse/token.rs

@@ -493,7 +493,7 @@ fn strict_keyword_table() -> HashMap<~str, ()> {
         ~"once",
         ~"priv", ~"pub", ~"pure",
         ~"ref", ~"return",
-        ~"struct", ~"super",
+        ~"struct",
         ~"true", ~"trait", ~"type",
         ~"unsafe", ~"use",
         ~"while"

trunk/src/test/compile-fail/bad-for-loop.rs

@@ -10,5 +10,5 @@
 
 fn main() {
     fn baz(_x: fn(y: int) -> int) {}
-    for baz |_e| { } //~ ERROR A `for` loop iterator should expect a closure that returns `bool`
+    for baz |_e| { } //~ ERROR should return `bool`
 }

trunk/src/test/compile-fail/issue-2817-2.rs

@@ -14,12 +14,13 @@ fn main() {
     for uint::range(0, 100000) |_i| { //~ ERROR A for-loop body must return (), but
         false
     };
-    for not_bool |_i| { //~ ERROR a `for` loop iterator should expect a closure that returns `bool`
+    for not_bool |_i| { //~ ERROR a `loop` function's last argument should return `bool`
+        //~^ ERROR A for-loop body must return (), but
         ~"hi"
     };
     for uint::range(0, 100000) |_i| { //~ ERROR A for-loop body must return (), but
         ~"hi"
     };
-    for not_bool() |_i| { //~ ERROR a `for` loop iterator should expect a closure that returns `bool`
+    for not_bool() |_i| { //~ ERROR a `loop` function's last argument
     };
 }