---

yaml
---
r: 42634
b: refs/heads/try
c: 86b8bf3
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: d912d53ea9921c4fc9044c657ddcb3e044617fa9
+refs/heads/try: 86b8bf37bbd5c83953933c9c38a20567843c3a7f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/AUTHORS.txt

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

branches/try/doc/rust.md

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

branches/try/src/libcore/hashmap.rs

@@ -60,10 +60,6 @@ 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();
@@ -351,7 +347,8 @@ pub mod linear {
         }
     }
 
-    impl<K:Hash IterBytes Eq,V> LinearMap<K,V> {
+    pub impl<K:Hash IterBytes Eq,V> LinearMap<K,V> {
+        /// Create an empty LinearMap
         static fn new() -> LinearMap<K, V> {
             linear_map_with_capacity(INITIAL_CAPACITY)
         }
@@ -495,7 +492,7 @@ pub mod linear {
 
     pub impl <T: Hash IterBytes Eq> LinearSet<T> {
         /// Create an empty LinearSet
-        static fn new() -> LinearSet<T> { LinearSet{map: LinearMap()} }
+        static fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} }
     }
 }
 

branches/try/src/librustc/middle/resolve.rs

@@ -10,6 +10,7 @@
 
 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};
@@ -3931,7 +3932,10 @@ 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.
-                if !self.session.building_library {
+                // FIXME #4404 android JNI hacks
+                if !self.session.building_library ||
+                    self.session.targ_cfg.os == session::os_android {
+
                     if self.attr_main_fn.is_none() &&
                            item.ident == special_idents::main {
 

branches/try/src/librustc/middle/trans/base.rs

@@ -62,7 +62,6 @@ 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;
 
@@ -2191,14 +2190,9 @@ 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) {
-
-    if ccx.main_fn != None::<ValueRef> {
-        ccx.sess.span_fatal(sp, ~"multiple 'main' functions");
-    }
+fn create_main_wrapper(ccx: @crate_ctxt, _sp: span, main_llfn: ValueRef) {
 
     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 {
@@ -3008,7 +3002,6 @@ 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(),

branches/try/src/librustc/middle/trans/common.rs

@@ -163,7 +163,6 @@ 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>,

branches/try/src/librustc/middle/ty.rs

@@ -1659,13 +1659,13 @@ fn subst(cx: ctxt,
     }
 }
 
-// Performs substitutions on a set of substitutions (result = super(sub)) to
+// Performs substitutions on a set of substitutions (result = sup(sub)) to
 // yield a new set of substitutions. This is used in trait inheritance.
-fn subst_substs(cx: ctxt, super: &substs, sub: &substs) -> substs {
+fn subst_substs(cx: ctxt, sup: &substs, sub: &substs) -> substs {
     {
-        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))
+        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))
     }
 }
 

branches/try/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,23 +2207,33 @@ 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(_) => (),
+              result::Ok(_) =>
+                  ty::mk_fn(tcx, FnTyBase {
+                      meta: (*fty).meta,
+                      sig: FnSig {output: ty::mk_nil(tcx),
+                                  ../*bad*/copy (*fty).sig}
+                  }),
               result::Err(_) => {
                    fcx.type_error_message(expr.span,
                       |actual| {
-                          fmt!("a `loop` function's last argument \
-                                should return `bool`, not `%s`", 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 { "" } )
                       },
                       (*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 {
@@ -2245,14 +2255,22 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
               }
         };
         match b.node {
-          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"
+                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"
         }
         let block_ty = structurally_resolved_type(
             fcx, expr.span, fcx.node_ty(b.id));

branches/try/src/librustc/util/common.rs

@@ -101,12 +101,6 @@ 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"]) }

branches/try/src/libstd/priority_queue.rs

@@ -47,6 +47,9 @@ 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) }
 
@@ -59,7 +62,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_empty() { item <-> self.data[0]; self.siftdown(0); }
+        if self.is_not_empty() { item <-> self.data[0]; self.siftdown(0); }
         item
     }
 
@@ -77,7 +80,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_empty() && self.data[0] > item {
+        if self.is_not_empty() && self.data[0] > item {
             item <-> self.data[0];
             self.siftdown(0);
         }
@@ -186,7 +189,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_empty() {
+        while heap.is_not_empty() {
             assert *heap.top() == sorted.last();
             assert heap.pop() == sorted.pop();
         }

branches/try/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()}
+        Context{db: db, logger: lg, cfg: cfg, freshness: LinearMap::new()}
     }
 
     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()});
+                           declared_inputs: LinearMap::new()});
         blk(p)
     }
 }

branches/try/src/libsyntax/parse/parser.rs

@@ -1660,43 +1660,45 @@ 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]);
-            @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));
-          }
+            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));
+            }
         }
     }
 

branches/try/src/libsyntax/parse/token.rs

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

branches/try/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 should return `bool`
+    for baz |_e| { } //~ ERROR A `for` loop iterator should expect a closure that returns `bool`
 }