---

yaml
---
r: 65467
b: refs/heads/master
c: 6fcb483
h: refs/heads/master
i:
  65465: 5db25c3
  65463: 9323095
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e86ac24e7ba71c488c243d2715b825ec1935aa33
+refs/heads/master: 6fcb483609dec71ec6fd13aaf9bea9080990043a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/etc/zsh/_rust

@@ -0,0 +1,102 @@
+#compdef rustc
+
+local -a _rustc_opts_switches _rustc_opts_lint _rustc_opts_debug
+
+typeset -A opt_args
+
+_rustc_opts_switches=(
+    --bin'[Compile an executable crate (default)]'
+    -c'[Compile and assemble, but do not link]'
+    --cfg'[Configure the compilation environment]'
+    --emit-llvm'[Produce an LLVM bitcode file]'
+    {-h,--help}'[Display this message]'
+    -L'[Add a directory to the library search path]'
+    --lib'[Compile a library crate]'
+    --linker'[Program to use for linking instead of the default.]'
+    --link-args'[FLAGS is a space-separated list of flags passed to the linker]'
+    --ls'[List the symbols defined by a library crate]'
+    --no-trans'[Run all passes except translation; no output]'
+    -O'[Equivalent to --opt-level=2]'
+    -o'[Write output to <filename>]'
+    --opt-level'[Optimize with possible levels 0-3]'
+    --out-dir'[Write output to compiler-chosen filename in <dir>]'
+    --parse-only'[Parse only; do not compile, assemble, or link]'
+    --pretty'[Pretty-print the input instead of compiling]'
+    -S'[Compile only; do not assemble or link]'
+    --save-temps'[Write intermediate files (.bc, .opt.bc, .o) in addition to normal output]'
+    --sysroot'[Override the system root]'
+    --test'[Build a test harness]'
+    --target'[Target triple cpu-manufacturer-kernel\[-os\] to compile]'
+    --target-feature'[Target specific attributes (llc -mattr=help for detail)]'
+    --android-cross-path'[The path to the Android NDK]'
+    {-W,--warn}'[Set lint warnings]'
+    {-A,--allow}'[Set lint allowed]'
+    {-D,--deny}'[Set lint denied]'
+    {-F,--forbid}'[Set lint forbidden]'
+    -Z'[Set internal debugging options]'
+    {-v,--version}'[Print version info and exit]'
+)
+
+_rustc_opts_lint=(
+    'path-statement:path statements with no effect'
+    'deprecated-pattern:warn about deprecated uses of pattern bindings'
+    'non-implicitly-copyable-typarams:passing non implicitly copyable types as copy type params'
+    'missing-trait-doc:detects missing documentation for traits'
+    'missing-struct-doc:detects missing documentation for structs'
+    'ctypes:proper use of core::libc types in foreign modules'
+    'implicit-copies:implicit copies of non implicitly copyable data'
+    "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'
+    'default-methods:allow default methods'
+    'unused-variable:detect variables which are not used in any way'
+    'dead-assignment:detect assignments that will never be read'
+    'unrecognized-lint:unrecognized lint attribute'
+    'type-limits:comparisons made useless by limits of the types involved'
+    'unused-unsafe:unnecessary use of an `unsafe` block'
+    'while-true:suggest using loop { } instead of while(true) { }'
+    'non-camel-case-types:types, variants and traits should have camel case names'
+    'managed-heap-memory:use of managed (@ type) heap memory'
+    'unnecessary-allocation:detects unnecessary allocations that can be eliminated'
+    'owned-heap-memory:use of owned (~ type) heap memory'
+)
+
+_rustc_opts_debug=(
+    'verbose:in general, enable more debug printouts'
+    'time-passes:measure time of each rustc pass'
+    'count-llvm-insns:count where LLVM instrs originate'
+    'time-llvm-passes:measure time of each LLVM pass'
+    'trans-stats:gather trans statistics'
+    'asm-comments:generate comments into the assembly (may change behavior)'
+    'no-verify:skip LLVM verification'
+    'trace:emit trace logs'
+    'coherence:perform coherence checking'
+    'borrowck-stats:gather borrowck statistics'
+    "borrowck-note-pure:note where purity is req'd"
+    "borrowck-note-loan:note where loans are req'd"
+    'no-landing-pads:omit landing pads for unwinding'
+    'debug-llvm:enable debug output from LLVM'
+    'count-type-sizes:count the sizes of aggregate types'
+    'meta-stats:gather metadata statistics'
+    'no-opt:do not optimize, even if -O is passed'
+    'no-monomorphic-collapse:do not collapse template instantiations'
+    'print-link-args:Print the arguments passed to the linker'
+    'gc:Garbage collect shared data (experimental)'
+    'jit:Execute using JIT (experimental)'
+    'extra-debug-info:Extra debugging info (experimental)'
+    'debug-info:Produce debug info (experimental)'
+    'static:Use or produce static libraries or binaries (experimental)'
+    'no-debug-borrows:do not show where borrow checks fail'
+    'lint-llvm:Run the LLVM lint pass on the pre-optimization IR'
+)
+
+_rustc() {
+    case $words[2] in
+        -[WADF]) _describe 'options' _rustc_opts_lint ;;
+        -Z) _describe 'options' _rustc_opts_debug ;;
+        -)  _arguments -s -w : "$_rustc_opts_switches[@]" ;;
+        *) _files -g "*.rs" ;;
+  esac
+}
+
+_rustc "$@"

trunk/src/libextra/ebml.rs

@@ -51,34 +51,32 @@ pub enum EbmlEncoderTag {
     EsI16,      // 8
     EsI8,       // 9
     EsBool,     // 10
-    EsChar,     // 11
-    EsStr,      // 12
-    EsF64,      // 13
-    EsF32,      // 14
-    EsFloat,    // 15
-    EsEnum,     // 16
-    EsEnumVid,  // 17
-    EsEnumBody, // 18
-    EsVec,      // 19
-    EsVecLen,   // 20
-    EsVecElt,   // 21
-    EsMap,      // 22
-    EsMapLen,   // 23
-    EsMapKey,   // 24
-    EsMapVal,   // 25
+    EsStr,      // 11
+    EsF64,      // 12
+    EsF32,      // 13
+    EsFloat,    // 14
+    EsEnum,     // 15
+    EsEnumVid,  // 16
+    EsEnumBody, // 17
+    EsVec,      // 18
+    EsVecLen,   // 19
+    EsVecElt,   // 20
 
     EsOpaque,
 
-    EsLabel, // Used only when debugging
+    EsLabel // Used only when debugging
 }
 // --------------------------------------
 
 pub mod reader {
-    use super::*;
+    use core::prelude::*;
 
+    use ebml::{Doc, EbmlEncoderTag, EsBool, EsEnum, EsEnumBody, EsEnumVid};
+    use ebml::{EsI16, EsI32, EsI64, EsI8, EsInt};
+    use ebml::{EsLabel, EsOpaque, EsStr, EsU16, EsU32, EsU64, EsU8, EsUint};
+    use ebml::{EsVec, EsVecElt, EsVecLen, TaggedDoc};
     use serialize;
 
-    use core::prelude::*;
     use core::cast::transmute;
     use core::int;
     use core::io;
@@ -323,14 +321,12 @@ pub mod reader {
             r_doc
         }
 
-        fn push_doc<T>(&mut self, exp_tag: EbmlEncoderTag,
-                       f: &fn(&mut Decoder) -> T) -> T {
-            let d = self.next_doc(exp_tag);
+        fn push_doc<T>(&mut self, d: Doc, f: &fn() -> T) -> T {
             let old_parent = self.parent;
             let old_pos = self.pos;
             self.parent = d;
             self.pos = d.start;
-            let r = f(self);
+            let r = f();
             self.parent = old_parent;
             self.pos = old_pos;
             r
@@ -399,21 +395,10 @@ pub mod reader {
             doc_as_u8(self.next_doc(EsBool)) as bool
         }
 
-        fn read_f64(&mut self) -> f64 {
-            let bits = doc_as_u64(self.next_doc(EsF64));
-            unsafe { transmute(bits) }
-        }
-        fn read_f32(&mut self) -> f32 {
-            let bits = doc_as_u32(self.next_doc(EsF32));
-            unsafe { transmute(bits) }
-        }
-        fn read_float(&mut self) -> float {
-            let bits = doc_as_u64(self.next_doc(EsFloat));
-            (unsafe { transmute::<u64, f64>(bits) }) as float
-        }
-        fn read_char(&mut self) -> char {
-            doc_as_u32(self.next_doc(EsChar)) as char
-        }
+        fn read_f64(&mut self) -> f64 { fail!("read_f64()"); }
+        fn read_f32(&mut self) -> f32 { fail!("read_f32()"); }
+        fn read_float(&mut self) -> float { fail!("read_float()"); }
+        fn read_char(&mut self) -> char { fail!("read_char()"); }
         fn read_str(&mut self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
 
         // Compound types:
@@ -556,50 +541,66 @@ pub mod reader {
 
         fn read_seq<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
             debug!("read_seq()");
-            do self.push_doc(EsVec) |d| {
-                let len = d._next_uint(EsVecLen);
-                debug!("  len=%u", len);
-                f(d, len)
-            }
+            let doc = self.next_doc(EsVec);
+
+            let (old_parent, old_pos) = (self.parent, self.pos);
+            self.parent = doc;
+            self.pos = self.parent.start;
+
+            let len = self._next_uint(EsVecLen);
+            debug!("  len=%u", len);
+            let result = f(self, len);
+
+            self.parent = old_parent;
+            self.pos = old_pos;
+            result
         }
 
         fn read_seq_elt<T>(&mut self, idx: uint, f: &fn(&mut Decoder) -> T)
                            -> T {
             debug!("read_seq_elt(idx=%u)", idx);
-            self.push_doc(EsVecElt, f)
+            let doc = self.next_doc(EsVecElt);
+
+            let (old_parent, old_pos) = (self.parent, self.pos);
+            self.parent = doc;
+            self.pos = self.parent.start;
+
+            let result = f(self);
+
+            self.parent = old_parent;
+            self.pos = old_pos;
+            result
         }
 
-        fn read_map<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
+        fn read_map<T>(&mut self, _: &fn(&mut Decoder, uint) -> T) -> T {
             debug!("read_map()");
-            do self.push_doc(EsMap) |d| {
-                let len = d._next_uint(EsMapLen);
-                debug!("  len=%u", len);
-                f(d, len)
-            }
+            fail!("read_map is unimplemented");
         }
 
         fn read_map_elt_key<T>(&mut self,
                                idx: uint,
-                               f: &fn(&mut Decoder) -> T)
+                               _: &fn(&mut Decoder) -> T)
                                -> T {
             debug!("read_map_elt_key(idx=%u)", idx);
-            self.push_doc(EsMapKey, f)
+            fail!("read_map_elt_val is unimplemented");
         }
 
         fn read_map_elt_val<T>(&mut self,
                                idx: uint,
-                               f: &fn(&mut Decoder) -> T)
+                               _: &fn(&mut Decoder) -> T)
                                -> T {
             debug!("read_map_elt_val(idx=%u)", idx);
-            self.push_doc(EsMapVal, f)
+            fail!("read_map_elt_val is unimplemented");
         }
     }
 }
 
 pub mod writer {
-    use super::*;
+    use ebml::{EbmlEncoderTag, EsBool, EsEnum, EsEnumBody, EsEnumVid};
+    use ebml::{EsI16, EsI32, EsI64, EsI8, EsInt};
+    use ebml::{EsLabel, EsOpaque, EsStr, EsU16, EsU32, EsU64, EsU8, EsUint};
+    use ebml::{EsVec, EsVecElt, EsVecLen};
 
-    use core::cast;
     use core::io;
     use core::str;
 
@@ -805,21 +806,19 @@ pub mod writer {
             self.wr_tagged_u8(EsBool as uint, v as u8)
         }
 
-        fn emit_f64(&mut self, v: f64) {
-            let bits = unsafe { cast::transmute(v) };
-            self.wr_tagged_u64(EsF64 as uint, bits);
+        // FIXME (#2742): implement these
+        fn emit_f64(&mut self, _v: f64) {
+            fail!("Unimplemented: serializing an f64");
         }
-        fn emit_f32(&mut self, v: f32) {
-            let bits = unsafe { cast::transmute(v) };
-            self.wr_tagged_u32(EsF32 as uint, bits);
+        fn emit_f32(&mut self, _v: f32) {
+            fail!("Unimplemented: serializing an f32");
         }
-        fn emit_float(&mut self, v: float) {
-            let bits = unsafe { cast::transmute(v as f64) };
-            self.wr_tagged_u64(EsFloat as uint, bits);
+        fn emit_float(&mut self, _v: float) {
+            fail!("Unimplemented: serializing a float");
         }
 
-        fn emit_char(&mut self, v: char) {
-            self.wr_tagged_u32(EsChar as uint, v as u32);
+        fn emit_char(&mut self, _v: char) {
+            fail!("Unimplemented: serializing a char");
         }
 
         fn emit_str(&mut self, v: &str) {
@@ -915,23 +914,16 @@ pub mod writer {
             self.end_tag();
         }
 
-        fn emit_map(&mut self, len: uint, f: &fn(&mut Encoder)) {
-            self.start_tag(EsMap as uint);
-            self._emit_tagged_uint(EsMapLen, len);
-            f(self);
-            self.end_tag();
+        fn emit_map(&mut self, _len: uint, _f: &fn(&mut Encoder)) {
+            fail!("emit_map is unimplemented");
         }
 
-        fn emit_map_elt_key(&mut self, _idx: uint, f: &fn(&mut Encoder)) {
-            self.start_tag(EsMapKey as uint);
-            f(self);
-            self.end_tag();
+        fn emit_map_elt_key(&mut self, _idx: uint, _f: &fn(&mut Encoder)) {
+            fail!("emit_map_elt_key is unimplemented");
         }
 
-        fn emit_map_elt_val(&mut self, _idx: uint, f: &fn(&mut Encoder)) {
-            self.start_tag(EsMapVal as uint);
-            f(self);
-            self.end_tag();
+        fn emit_map_elt_val(&mut self, _idx: uint, _f: &fn(&mut Encoder)) {
+            fail!("emit_map_elt_val is unimplemented");
         }
     }
 }

trunk/src/libextra/serialize.rs

@@ -375,18 +375,6 @@ impl<D:Decoder> Decodable<D> for bool {
     }
 }
 
-impl<S:Encoder> Encodable<S> for char {
-    fn encode(&self, s: &mut S) {
-        s.emit_char(*self)
-    }
-}
-
-impl<D:Decoder> Decodable<D> for char {
-    fn decode(d: &mut D) -> char {
-        d.read_char()
-    }
-}
-
 impl<S:Encoder> Encodable<S> for () {
     fn encode(&self, s: &mut S) {
         s.emit_nil()

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

@@ -563,6 +563,7 @@ fn build_const_struct(ccx: @CrateContext, st: &Struct, vals: &[ValueRef])
             vals[i]
         };
         cfields.push(val);
+        offset += machine::llsize_of_alloc(ccx, llty) as u64
     }
 
     return cfields;