---

yaml
---
r: 85503
b: refs/heads/dist-snap
c: ed6694a
h: refs/heads/master
i:
  85501: 9e5551b
  85499: 3d24669
  85495: d1dfcb8
  85487: 8841bd5
  85471: a6e5cd6
  85439: 65d3e81
  85375: 20d38de
  85247: bb765cb
  84991: 97420ac
v: v3

Author: vadimcn

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: e185b049af214cc7900beaae557a12863f4b3ce3
+refs/heads/dist-snap: ed6694a9b5049ec066db45965b40351744df80bc
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -582,7 +582,7 @@ a referencing source file, or by the name of the crate itself.
 
 Each source file contains a sequence of zero or more `item` definitions,
 and may optionally begin with any number of `attributes` that apply to the containing module.
-Attributes on the anonymous crate module define important metadata that influences
+Atributes on the anonymous crate module define important metadata that influences
 the behavior of the compiler.
 
 ~~~~~~~~
@@ -1273,7 +1273,7 @@ since the typechecker checks that any type with an implementation of `Circle` al
 
 In type-parameterized functions,
 methods of the supertrait may be called on values of subtrait-bound type parameters.
-Referring to the previous example of `trait Circle : Shape`:
+Refering to the previous example of `trait Circle : Shape`:
 
 ~~~
 # trait Shape { fn area(&self) -> float; }
@@ -1914,7 +1914,7 @@ A field access on a record is an [lvalue](#lvalues-rvalues-and-temporaries) refe
 When the field is mutable, it can be [assigned](#assignment-expressions) to.
 
 When the type of the expression to the left of the dot is a pointer to a record or structure,
-it is automatically dereferenced to make the field access possible.
+it is automatically derferenced to make the field access possible.
 
 
 ### Vector expressions

branches/dist-snap/src/etc/cmathconsts.c

@@ -13,7 +13,7 @@
 #include <math.h>
 #include <stdio.h>
 
-// must match std::ctypes
+// must match core::ctypes
 
 #define C_FLT(x) (float)x
 #define C_DBL(x) (double)x

branches/dist-snap/src/etc/ziggurat_tables.py

@@ -2,7 +2,7 @@
 # xfail-license
 
 # This creates the tables used for distributions implemented using the
-# ziggurat algorithm in `std::rand::distributions;`. They are
+# ziggurat algorithm in `core::rand::distributions;`. They are
 # (basically) the tables as used in the ZIGNOR variant (Doornik 2005).
 # They are changed rarely, so the generated file should be checked in
 # to git.

branches/dist-snap/src/etc/zsh/_rust

@@ -36,7 +36,7 @@ _rustc_opts_lint=(
     'path-statement[path statements with no effect]'
     'missing-trait-doc[detects missing documentation for traits]'
     'missing-struct-doc[detects missing documentation for structs]'
-    'ctypes[proper use of std::libc types in foreign modules]'
+    'ctypes[proper use of core::libc types in foreign modules]'
     "unused-mut[detect mut variables which don't need to be mutable]"
     'unused-imports[imports that are never used]'
     'heap-memory[use of any (~ type or @ type) heap memory]'

branches/dist-snap/src/libextra/crypto/cryptoutil.rs

@@ -176,7 +176,7 @@ pub fn add_bytes_to_bits_tuple
 /// method that modifies the buffer directory or provides the caller with bytes that can be modifies
 /// results in those bytes being marked as used by the buffer.
 pub trait FixedBuffer {
-    /// Input a vector of bytes. If the buffer becomes full, process it with the provided
+    /// Input a vector of bytes. If the buffer becomes full, proccess it with the provided
     /// function and then clear the buffer.
     fn input(&mut self, input: &[u8], func: &fn(&[u8]));
 

branches/dist-snap/src/libextra/crypto/digest.rs

@@ -47,18 +47,18 @@ pub trait Digest {
     fn output_bits(&self) -> uint;
 
     /**
-     * Convenience function that feeds a string into a digest.
+     * Convenience functon that feeds a string into a digest
      *
      * # Arguments
      *
-     * * `input` The string to feed into the digest
+     * * in The string to feed into the digest
      */
     fn input_str(&mut self, input: &str) {
         self.input(input.as_bytes());
     }
 
     /**
-     * Convenience function that retrieves the result of a digest as a
+     * Convenience functon that retrieves the result of a digest as a
      * ~str in hexadecimal format.
      */
     fn result_str(&mut self) -> ~str {

branches/dist-snap/src/libextra/enum_set.rs

@@ -18,7 +18,7 @@ pub struct EnumSet<E> {
     priv bits: uint
 }
 
-/// An interface for casting C-like enum to uint and back.
+/// An iterface for casting C-like enum to uint and back.
 pub trait CLike {
     /// Converts C-like enum to uint.
     fn to_uint(&self) -> uint;

branches/dist-snap/src/libextra/fileinput.rs

@@ -156,7 +156,7 @@ impl FileInput {
     /**
     Create a `FileInput` object from a vec of files. An empty
     vec means lines are read from `stdin` (use `from_vec_raw` to stop
-    this behaviour). Any occurrence of `None` represents `stdin`.
+    this behaviour). Any occurence of `None` represents `stdin`.
     */
     pub fn from_vec(files: ~[Option<Path>]) -> FileInput {
         FileInput::from_vec_raw(

branches/dist-snap/src/libextra/flatpipes.rs

@@ -166,7 +166,7 @@ Constructors for flat pipes that send POD types using memcpy.
 
 This module is currently unsafe because it uses `Clone + Send` as a type
 parameter bounds meaning POD (plain old data), but `Clone + Send` and
-POD are not equivalent.
+POD are not equivelant.
 
 */
 pub mod pod {

branches/dist-snap/src/libextra/stats.rs

@@ -365,7 +365,7 @@ pub fn write_boxplot(w: @io::Writer, s: &Summary, width_hint: uint) {
     w.write_str(histr);
 }
 
-/// Returns a HashMap with the number of occurrences of every element in the
+/// Returns a HashMap with the number of occurences of every element in the
 /// sequence that the iterator exposes.
 pub fn freq_count<T: Iterator<U>, U: Eq+Hash>(mut iter: T) -> hashmap::HashMap<U, uint> {
     let mut map = hashmap::HashMap::new::<U, uint>();

branches/dist-snap/src/libextra/term.rs

@@ -157,7 +157,7 @@ impl Terminal {
     /// If the color is a bright color, but the terminal only supports 8 colors,
     /// the corresponding normal color will be used instead.
     ///
-    /// Returns true if the color was set, false otherwise.
+    /// Rturns true if the color was set, false otherwise.
     pub fn bg(&self, color: color::Color) -> bool {
         let color = self.dim_if_necessary(color);
         if self.num_colors > color {

branches/dist-snap/src/libextra/time.rs

@@ -34,7 +34,7 @@ pub mod rustrt {
 }
 
 /// A record specifying a time value in seconds and nanoseconds.
-#[deriving(Clone, DeepClone, Eq, Encodable, Decodable)]
+#[deriving(Eq, Encodable, Decodable)]
 pub struct Timespec { sec: i64, nsec: i32 }
 
 /*
@@ -100,7 +100,7 @@ pub fn tzset() {
     }
 }
 
-#[deriving(Clone, DeepClone, Eq, Encodable, Decodable)]
+#[deriving(Eq, Encodable, Decodable)]
 pub struct Tm {
     tm_sec: i32, // seconds after the minute ~[0-60]
     tm_min: i32, // minutes after the hour ~[0-59]

branches/dist-snap/src/librustc/back/link.rs

@@ -26,6 +26,7 @@ use std::c_str::ToCStr;
 use std::char;
 use std::hash::Streaming;
 use std::hash;
+use std::io;
 use std::libc::{c_int, c_uint};
 use std::os::consts::{macos, freebsd, linux, android, win32};
 use std::os;
@@ -858,6 +859,10 @@ pub fn link_binary(sess: Session,
     debug!("output: %s", output.to_str());
     let cc_args = link_args(sess, obj_filename, out_filename, lm);
     debug!("%s link args: %s", cc_prog, cc_args.connect(" "));
+    if (sess.opts.debugging_opts & session::print_link_args) != 0 { 
+        io::println(fmt!("%s link args: %s", cc_prog, cc_args.connect(" ")));
+    }
+    
     // We run 'cc' here
     let prog = run::process_output(cc_prog, cc_args);
     if 0 != prog.status {

branches/dist-snap/src/librustc/driver/driver.rs

@@ -691,14 +691,6 @@ pub fn build_session_options(binary: @str,
     let extra_debuginfo = debugging_opts & session::extra_debug_info != 0;
     let debuginfo = debugging_opts & session::debug_info != 0 ||
         extra_debuginfo;
-
-    // If debugging info is generated, do not collapse monomorphized function instances.
-    // Functions with equivalent llvm code still need separate debugging descriptions because names
-    // might differ.
-    if debuginfo {
-        debugging_opts |= session::no_monomorphic_collapse;
-    }
-
     let statik = debugging_opts & session::statik != 0;
 
     let addl_lib_search_paths = getopts::opt_strs(matches, "L").map(|s| Path(*s));

branches/dist-snap/src/librustc/lib/llvm.rs

@@ -2086,16 +2086,6 @@ pub mod llvm {
 
         #[fast_ffi]
         pub fn LLVMSetUnnamedAddr(GlobalVar: ValueRef, UnnamedAddr: Bool);
-
-        #[fast_ffi]
-        pub fn LLVMDIBuilderCreateTemplateTypeParameter(Builder: DIBuilderRef,
-                                                        Scope: ValueRef,
-                                                        Name: *c_char,
-                                                        Ty: ValueRef,
-                                                        File: ValueRef,
-                                                        LineNo: c_uint,
-                                                        ColumnNo: c_uint)
-                                                        -> ValueRef;
     }
 }
 

branches/dist-snap/src/librustc/middle/trans/_match.rs

@@ -399,17 +399,10 @@ struct ArmData<'self> {
     bindings_map: @BindingsMap
 }
 
-/**
- * Info about Match.
- * If all `pats` are matched then arm `data` will be executed.
- * As we proceed `bound_ptrs` are filled with pointers to values to be bound,
- * these pointers are stored in llmatch variables just before executing `data` arm.
- */
 #[deriving(Clone)]
 struct Match<'self> {
     pats: ~[@ast::pat],
-    data: ArmData<'self>,
-    bound_ptrs: ~[(ident, ValueRef)]
+    data: ArmData<'self>
 }
 
 impl<'self> Repr for Match<'self> {
@@ -454,13 +447,14 @@ fn expand_nested_bindings<'r>(bcx: @mut Block,
                                 br.pats.slice(col + 1u,
                                            br.pats.len())));
 
-                let mut res = Match {
+                let binding_info =
+                    br.data.bindings_map.get(&path_to_ident(path));
+
+                Store(bcx, val, binding_info.llmatch);
+                Match {
                     pats: pats,
-                    data: br.data.clone(),
-                    bound_ptrs: br.bound_ptrs.clone()
-                };
-                res.bound_ptrs.push((path_to_ident(path), val));
-                res
+                    data: br.data.clone()
+                }
             }
             _ => (*br).clone(),
         }
@@ -502,20 +496,21 @@ fn enter_match<'r>(bcx: @mut Block,
                         br.pats.slice(col + 1u, br.pats.len()));
 
                 let this = br.pats[col];
-                let mut bound_ptrs = br.bound_ptrs.clone();
                 match this.node {
                     ast::pat_ident(_, ref path, None) => {
                         if pat_is_binding(dm, this) {
-                            bound_ptrs.push((path_to_ident(path), val));
+                            let binding_info =
+                                br.data.bindings_map.get(
+                                    &path_to_ident(path));
+                            Store(bcx, val, binding_info.llmatch);
                         }
                     }
                     _ => {}
                 }
 
                 result.push(Match {
                     pats: pats,
-                    data: br.data.clone(),
-                    bound_ptrs: bound_ptrs
+                    data: br.data.clone()
                 });
             }
             None => ()
@@ -1299,14 +1294,18 @@ fn store_non_ref_bindings(bcx: @mut Block,
 
 fn insert_lllocals(bcx: @mut Block,
                    bindings_map: &BindingsMap,
+                   binding_mode: IrrefutablePatternBindingMode,
                    add_cleans: bool) -> @mut Block {
     /*!
      * For each binding in `data.bindings_map`, adds an appropriate entry into
      * the `fcx.lllocals` map.  If add_cleans is true, then adds cleanups for
      * the bindings.
      */
 
-    let llmap = bcx.fcx.lllocals;
+    let llmap = match binding_mode {
+        BindLocal => bcx.fcx.lllocals,
+        BindArgument => bcx.fcx.llargs
+    };
 
     for (&ident, &binding_info) in bindings_map.iter() {
         let llval = match binding_info.trmode {
@@ -1359,7 +1358,7 @@ fn compile_guard(bcx: @mut Block,
     bcx = store_non_ref_bindings(bcx,
                                  data.bindings_map,
                                  Some(&mut temp_cleanups));
-    bcx = insert_lllocals(bcx, data.bindings_map, false);
+    bcx = insert_lllocals(bcx, data.bindings_map, BindLocal, false);
 
     let val = unpack_result!(bcx, {
         do with_scope_result(bcx, guard_expr.info(),
@@ -1419,10 +1418,6 @@ fn compile_submatch(bcx: @mut Block,
     }
     if m[0].pats.len() == 0u {
         let data = &m[0].data;
-        for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() {
-            let llmatch = data.bindings_map.get(ident).llmatch;
-            Store(bcx, *value_ptr, llmatch);
-        }
         match data.arm.guard {
             Some(guard_expr) => {
                 bcx = compile_guard(bcx,
@@ -1848,7 +1843,6 @@ fn trans_match_inner(scope_cx: @mut Block,
             matches.push(Match {
                 pats: ~[*p],
                 data: arm_data.clone(),
-                bound_ptrs: ~[],
             });
         }
     }
@@ -1881,7 +1875,7 @@ fn trans_match_inner(scope_cx: @mut Block,
         }
 
         // insert bindings into the lllocals map and add cleanups
-        bcx = insert_lllocals(bcx, arm_data.bindings_map, true);
+        bcx = insert_lllocals(bcx, arm_data.bindings_map, BindLocal, true);
 
         bcx = controlflow::trans_block(bcx, &arm_data.arm.body, dest);
         bcx = trans_block_cleanups(bcx, block_cleanups(arm_data.bodycx));

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -133,7 +133,7 @@ pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
 
 fn fcx_has_nonzero_span(fcx: &FunctionContext) -> bool {
     match fcx.span {
-        None => false,
+        None => true,
         Some(span) => *span.lo != 0 || *span.hi != 0
     }
 }
@@ -1739,10 +1739,6 @@ pub fn copy_args_to_allocas(fcx: @mut FunctionContext,
 
             fcx.llself = Some(ValSelfData {v: self_val, ..slf});
             add_clean(bcx, self_val, slf.t);
-
-            if fcx.ccx.sess.opts.extra_debuginfo && fcx_has_nonzero_span(fcx) {
-                debuginfo::create_self_argument_metadata(bcx, slf.t, self_val);
-            }
         }
         _ => {}
     }
@@ -1863,10 +1859,6 @@ pub fn trans_closure(ccx: @mut CrateContext,
         set_fixed_stack_segment(fcx.llfn);
     }
 
-    if ccx.sess.opts.debuginfo && fcx_has_nonzero_span(fcx) {
-        debuginfo::create_function_metadata(fcx);
-    }
-
     // Create the first basic block in the function and keep a handle on it to
     //  pass to finish_fn later.
     let bcx_top = fcx.entry_bcx.unwrap();
@@ -1937,7 +1929,12 @@ pub fn trans_fn(ccx: @mut CrateContext,
                   id,
                   attrs,
                   output_type,
-                  |_fcx| { });
+                  |fcx| {
+                      if ccx.sess.opts.debuginfo
+                          && fcx_has_nonzero_span(fcx) {
+                          debuginfo::create_function_metadata(fcx);
+                      }
+                  });
 }
 
 fn insert_synthetic_type_entries(bcx: @mut Block,