---

yaml
---
r: 48603
b: refs/heads/snap-stage3
c: a363862
h: refs/heads/master
i:
  48601: 08e5c5a
  48599: 1e8654e
v: v3

Author: wanderview

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 1d8596d400b245143df4a421654d7a94a8b4c1e1
+refs/heads/snap-stage3: a36386210293cf12f771adb6bc775a45cab6b4da
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -162,17 +162,7 @@ pub struct inherited {
     adjustments: HashMap<ast::node_id, @ty::AutoAdjustment>
 }
 
-pub enum FnKind {
-    // This is a for-closure.  The ty::t is the return type of the
-    // enclosing function.
-    ForLoop(ty::t),
-
-    // A do-closure.
-    DoBlock,
-
-    // A normal closure or fn item.
-    Vanilla
-}
+pub enum FnKind { ForLoop, DoBlock, Vanilla }
 
 pub struct FnCtxt {
     // var_bindings, locals and next_var_id are shared
@@ -260,14 +250,8 @@ pub fn check_bare_fn(ccx: @mut CrateCtxt,
     let fty = ty::node_id_to_type(ccx.tcx, id);
     match ty::get(fty).sty {
         ty::ty_bare_fn(ref fn_ty) => {
-            let fcx =
-                check_fn(ccx, self_info, fn_ty.purity,
-                         &fn_ty.sig, decl, body, Vanilla,
-                         @Nil, blank_inherited(ccx));;
-
-            vtable::resolve_in_block(fcx, body);
-            regionck::regionck_fn(fcx, body);
-            writeback::resolve_type_vars_in_fn(fcx, decl, body, self_info);
+            check_fn(ccx, self_info, fn_ty.purity, None,
+                     &fn_ty.sig, decl, body, Vanilla, None)
         }
         _ => ccx.tcx.sess.impossible_case(body.span,
                                  "check_bare_fn: function type expected")
@@ -277,34 +261,26 @@ pub fn check_bare_fn(ccx: @mut CrateCtxt,
 pub fn check_fn(ccx: @mut CrateCtxt,
                 +self_info: Option<SelfInfo>,
                 purity: ast::purity,
+                sigil: Option<ast::Sigil>,
                 fn_sig: &ty::FnSig,
                 decl: &ast::fn_decl,
                 body: &ast::blk,
                 fn_kind: FnKind,
-                inherited_isr: isr_alist,
-                inherited: @inherited) -> @mut FnCtxt
-{
-    /*!
-     *
-     * Helper used by check_bare_fn and check_expr_fn.  Does the
-     * grungy work of checking a function body and returns the
-     * function context used for that purpose, since in the case of a
-     * fn item there is still a bit more to do.
-     *
-     * - ...
-     * - inherited_isr: regions in scope from the enclosing fn (if any)
-     * - inherited: other fields inherited from the enclosing fn (if any)
-     */
-
+                old_fcx: Option<@mut FnCtxt>) {
     let tcx = ccx.tcx;
+    let indirect_ret = match fn_kind {
+        ForLoop => true, _ => false
+    };
 
     // ______________________________________________________________________
     // First, we have to replace any bound regions in the fn and self
     // types with free ones.  The free region references will be bound
     // the node_id of the body block.
 
     let (isr, self_info, fn_sig) = {
-        replace_bound_regions_in_fn_sig(tcx, inherited_isr, self_info, fn_sig,
+        let old_isr = option::map_default(&old_fcx, @Nil,
+                                          |fcx| fcx.in_scope_regions);
+        replace_bound_regions_in_fn_sig(tcx, old_isr, self_info, fn_sig,
                                         |br| ty::re_free(body.node.id, br))
     };
 
@@ -320,13 +296,23 @@ pub fn check_fn(ccx: @mut CrateCtxt,
     // Create the function context.  This is either derived from scratch or,
     // in the case of function expressions, based on the outer context.
     let fcx: @mut FnCtxt = {
-        // In a for-loop, you have an 'indirect return' because return
-        // does not return out of the directly enclosing fn
-        let indirect_ret_ty = match fn_kind {
-            ForLoop(t) => Some(t),
-            DoBlock | Vanilla => None
+        let (purity, inherited) = match old_fcx {
+            None => (purity, blank_inherited(ccx)),
+            Some(fcx) => {
+                (ty::determine_inherited_purity(fcx.purity, purity,
+                                                sigil.get()),
+                 fcx.inh)
+            }
         };
 
+        let indirect_ret_ty = if indirect_ret {
+            let ofcx = old_fcx.get();
+            match ofcx.indirect_ret_ty {
+              Some(t) => Some(t),
+              None => Some(ofcx.ret_ty)
+            }
+        } else { None };
+
         @mut FnCtxt {
             self_info: self_info,
             ret_ty: ret_ty,
@@ -384,7 +370,15 @@ pub fn check_fn(ccx: @mut CrateCtxt,
         fcx.write_ty(input.id, *arg);
     }
 
-    return fcx;
+    // If we don't have any enclosing function scope, it is time to
+    // force any remaining type vars to be resolved.
+    // If we have an enclosing function scope, our type variables will be
+    // resolved when the enclosing scope finishes up.
+    if old_fcx.is_none() {
+        vtable::resolve_in_block(fcx, body);
+        regionck::regionck_fn(fcx, body);
+        writeback::resolve_type_vars_in_fn(fcx, decl, body, self_info);
+    }
 
     fn gather_locals(fcx: @mut FnCtxt,
                      decl: &ast::fn_decl,
@@ -909,7 +903,7 @@ pub impl FnCtxt {
                                       a: ty::t,
                                       err: &ty::type_err) {
         match self.fn_kind {
-            ForLoop(_) if !ty::type_is_bool(e) && !ty::type_is_nil(a) =>
+            ForLoop if !ty::type_is_bool(e) && !ty::type_is_nil(a) =>
                     self.tcx().sess.span_err(sp, fmt!("A for-loop body must \
                         return (), but it returns %s here. \
                         Perhaps you meant to write a `do`-block?",
@@ -1673,15 +1667,10 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
 
         fcx.write_ty(expr.id, fty);
 
-        let inherited_purity =
-            ty::determine_inherited_purity(fcx.purity, purity,
-                                           fn_ty.sigil);
-
         // We inherit the same self info as the enclosing scope,
         // since the function we're checking might capture `self`
-        check_fn(fcx.ccx, fcx.self_info, inherited_purity,
-                 &fn_ty.sig, decl, body, fn_kind,
-                 fcx.in_scope_regions, fcx.inh);
+        check_fn(fcx.ccx, fcx.self_info, fn_ty.purity, Some(fn_ty.sigil),
+                 &fn_ty.sig, decl, body, fn_kind, Some(fcx));
     }
 
 
@@ -2091,13 +2080,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                 // 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 {
-                    let indirect_ret_ty =
-                        fcx.indirect_ret_ty.get_or_default(fcx.ret_ty);
-                    ForLoop(indirect_ret_ty)
-                };
+                let fn_kind = if err_happened {Vanilla} else {ForLoop};
                 check_expr_fn(fcx, loop_body, None,
                               decl, body, fn_kind, Some(inner_ty));
                 demand::suptype(fcx, loop_body.span,

branches/snap-stage3/src/libstd/getopts.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2011-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -29,8 +29,10 @@
  * The following example shows simple command line parsing for an application
  * that requires an input file to be specified, accepts an optional output
  * file name following -o, and accepts both -h and --help as optional flags.
- * extern mod std;
- * use std::getopts::*;
+ *
+ * ```
+ *    extern mod std;
+ *    use std::getopts::*;
  *
  *    fn do_work(in: &str, out: Option<~str>) {
  *      io::println(in);
@@ -58,21 +60,22 @@
  *        ];
  *        let matches = match getopts(vec::tail(args), opts) {
  *            result::Ok(m) => { m }
- *            result::Err(f) => { fail fail_str(f) }
+ *            result::Err(f) => { fail!(fail_str(f)) }
  *        };
  *        if opt_present(&matches, "h") || opt_present(&matches, "help") {
  *            print_usage(program, opts);
  *            return;
  *        }
  *        let output = opt_maybe_str(&matches, "o");
  *        let input: &str = if !matches.free.is_empty() {
- *            matches.free[0]
+ *            copy matches.free[0]
  *        } else {
  *            print_usage(program, opts);
  *            return;
  *        };
  *        do_work(input, output);
  *    }
+ * ```
  */
 
 use core::cmp::Eq;