---

yaml
---
r: 131774
b: refs/heads/dist-snap
c: f26c31d
h: refs/heads/master
v: v3

Author: adrientetar

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 457a3c991d79b971be07fce75f9d0c12848fb37c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: cdd6346f458084ef9f9e6e1b640225be4a8aca70
+refs/heads/dist-snap: f26c31d695666a6863f86bfeede2bea91f4ba942
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/man/rustc.1

@@ -11,9 +11,6 @@ This program is a compiler for the Rust language, available at
 
 .SH OPTIONS
 
-.TP
-\fB\-\-crate-name NAME\fR
-Specify the name of the crate being built
 .TP
 \fB\-\-crate-type=[bin|lib|dylib|rlib|staticlib]\fR
 Configure the flavor of rust crate that is generated (default `bin`)

branches/dist-snap/mk/install.mk

@@ -14,18 +14,16 @@ else
 MAYBE_DISABLE_VERIFY=
 endif
 
-install: dist-install-dir-$(CFG_BUILD)-with-target-libs | tmp/empty_dir
-	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
+install: dist-install-dir-$(CFG_BUILD)-with-target-libs
+	$(Q)sh tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
 # Remove tmp files while we can because they may have been created under sudo
 	$(Q)rm -R tmp/dist
 
-uninstall: dist-install-dir-$(CFG_BUILD)-with-target-libs | tmp/empty_dir
-	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
+uninstall: dist-install-dir-$(CFG_BUILD)-with-target-libs
+	$(Q)sh tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
 # Remove tmp files while we can because they may have been created under sudo
 	$(Q)rm -R tmp/dist
 
-tmp/empty_dir:
-	mkdir -p $@
 
 ######################################################################
 # Android remote installation

branches/dist-snap/src/etc/install.sh

@@ -466,17 +466,6 @@ while read p; do
 # The manifest lists all files to install
 done < "${CFG_SRC_DIR}/${CFG_LIBDIR_RELATIVE}/rustlib/manifest.in"
 
-# Run ldconfig to make dynamic libraries available to the linker
-if [ "$CFG_OSTYPE" = "Linux" ]
-    then
-    ldconfig
-    if [ $? -ne 0 ]
-    then
-        warn "failed to run ldconfig."
-        warn "this may happen when not installing as root and may be fine"
-    fi
-fi
-
 # Sanity check: can we run the installed binaries?
 #
 # As with the verification above, make sure the right LD_LIBRARY_PATH-equivalent
@@ -500,11 +489,13 @@ then
             err "${ERR}"
         else
             echo
-            echo "    Note: please ensure '${CFG_PREFIX}/lib' is added to ${CFG_LD_PATH_VAR}"
+            echo "    please ensure '${CFG_PREFIX}/lib' is added to ${CFG_LD_PATH_VAR}"
+            echo
         fi
     fi
 fi
 
+
 echo
 echo "    Rust is ready to roll."
 echo

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

@@ -9,12 +9,10 @@ _rustc_opts_switches=(
     -c'[Compile and assemble, but do not link]'
     --cfg'[Configure the compilation environment]'
     --crate-id'[Output the crate id and exit]'
-    --crate-file-name'[deprecated in favor of --print-file-name]'
-    --crate-name'[Specify the name of the crate being built]'
-    --crate-type'[Specify the type of crate to crate]'
-    --debuginfo'[Emit DWARF debug info to the objects created: 0 = no debug info, 1 = line-tables only (for stacktraces and breakpoints), 2 = full debug info with variable and type information (same as -g)]'
+    --crate-file-name'[Output the file(s) that would be written if compilation continued and exit]'
+    --crate-name'[Output the crate name and exit]'
     --dep-info'[Output dependency info to <filename> after compiling]'
-    -g'[Equivalent to --debuginfo=2]'
+    --crate-type'[Specify the type of crate to crate]'
     {-h,--help}'[Display this message]'
     -L'[Add a directory to the library search path]'
     --linker'[Program to use for linking instead of the default.]'
@@ -31,8 +29,6 @@ _rustc_opts_switches=(
     --parse-only'[Parse only; do not compile, assemble, or link]'
     --passes'[Comma or space separated list of pass names to use]'
     --pretty'[Pretty-print the input instead of compiling]'
-    --print-crate-name'[Output the crate name and exit]'
-    --print-file-name'[Output the file(s) that would be written if compilation continued and exit]'
     --save-temps'[Write intermediate files (.bc, .opt.bc, .o) in addition to normal output]'
     --sysroot'[Override the system root]'
     --test'[Build a test harness]'

branches/dist-snap/src/libcore/atomics.rs

@@ -141,7 +141,7 @@ impl AtomicBool {
     ///
     /// fn with_lock(spinlock: &Arc<AtomicBool>, f: || -> ()) {
     ///     // CAS loop until we are able to replace `false` with `true`
-    ///     while spinlock.compare_and_swap(false, true, SeqCst) != false {
+    ///     while spinlock.compare_and_swap(false, true, SeqCst) == false {
     ///         // Since tasks may not be preemptive (if they are green threads)
     ///         // yield to the scheduler to let the other task run. Low level
     ///         // concurrent code needs to take into account Rust's two threading

branches/dist-snap/src/libgreen/lib.rs

@@ -164,18 +164,10 @@
 //! possibly pinned to a particular scheduler thread:
 //!
 //! ```rust
-//! extern crate green;
-//! extern crate rustuv;
-//!
-//! # fn main() {
 //! use std::task::TaskBuilder;
 //! use green::{SchedPool, PoolConfig, GreenTaskBuilder};
 //!
-//! let mut config = PoolConfig::new();
-//!
-//! // Optional: Set the event loop to be rustuv's to allow I/O to work
-//! config.event_loop_factory = rustuv::event_loop;
-//!
+//! let config = PoolConfig::new();
 //! let mut pool = SchedPool::new(config);
 //!
 //! // Spawn tasks into the pool of schedulers
@@ -203,7 +195,6 @@
 //! // Required to shut down this scheduler pool.
 //! // The task will fail if `shutdown` is not called.
 //! pool.shutdown();
-//! # }
 //! ```
 
 #![crate_name = "green"]

branches/dist-snap/src/libgreen/stack.rs

@@ -8,15 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::ptr;
 use std::sync::atomics;
 use std::os::{errno, page_size, MemoryMap, MapReadable, MapWritable,
-              MapNonStandardFlags, getenv};
+              MapNonStandardFlags, MapVirtual, getenv};
 use libc;
 
 /// A task's stack. The name "Stack" is a vestige of segmented stacks.
 pub struct Stack {
-    buf: Option<MemoryMap>,
+    buf: MemoryMap,
     min_size: uint,
     valgrind_id: libc::c_uint,
 }
@@ -53,11 +52,11 @@ impl Stack {
         // guaranteed to be aligned properly.
         if !protect_last_page(&stack) {
             fail!("Could not memory-protect guard page. stack={}, errno={}",
-                  stack.data(), errno());
+                  stack.data, errno());
         }
 
         let mut stk = Stack {
-            buf: Some(stack),
+            buf: stack,
             min_size: size,
             valgrind_id: 0
         };
@@ -72,23 +71,22 @@ impl Stack {
     /// Create a 0-length stack which starts (and ends) at 0.
     pub unsafe fn dummy_stack() -> Stack {
         Stack {
-            buf: None,
+            buf: MemoryMap { data: 0 as *mut u8, len: 0, kind: MapVirtual },
             min_size: 0,
             valgrind_id: 0
         }
     }
 
     /// Point to the low end of the allocated stack
     pub fn start(&self) -> *const uint {
-        self.buf.as_ref().map(|m| m.data() as *const uint)
-            .unwrap_or(ptr::null())
+        self.buf.data as *const uint
     }
 
     /// Point one uint beyond the high end of the allocated stack
     pub fn end(&self) -> *const uint {
-        self.buf.as_ref().map(|buf| unsafe {
-            buf.data().offset(buf.len() as int) as *const uint
-        }).unwrap_or(ptr::null())
+        unsafe {
+            self.buf.data.offset(self.buf.len as int) as *const uint
+        }
     }
 }
 
@@ -98,7 +96,7 @@ fn protect_last_page(stack: &MemoryMap) -> bool {
         // This may seem backwards: the start of the segment is the last page?
         // Yes! The stack grows from higher addresses (the end of the allocated
         // block) to lower addresses (the start of the allocated block).
-        let last_page = stack.data() as *mut libc::c_void;
+        let last_page = stack.data as *mut libc::c_void;
         libc::mprotect(last_page, page_size() as libc::size_t,
                        libc::PROT_NONE) != -1
     }
@@ -108,7 +106,7 @@ fn protect_last_page(stack: &MemoryMap) -> bool {
 fn protect_last_page(stack: &MemoryMap) -> bool {
     unsafe {
         // see above
-        let last_page = stack.data() as *mut libc::c_void;
+        let last_page = stack.data as *mut libc::c_void;
         let mut old_prot: libc::DWORD = 0;
         libc::VirtualProtect(last_page, page_size() as libc::SIZE_T,
                              libc::PAGE_NOACCESS,

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

@@ -270,8 +270,6 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         }
     );
 
-    // JBC: make CFG processing part of expansion to avoid this problem:
-
     // strip again, in case expansion added anything with a #[cfg].
     krate = time(time_passes, "configuration 2", krate, |krate|
                  front::config::strip_unconfigured_items(krate));
@@ -292,9 +290,6 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         krate.encode(&mut json).unwrap();
     }
 
-    time(time_passes, "checking that all macro invocations are gone", &krate, |krate|
-         syntax::ext::expand::check_for_macros(&sess.parse_sess, krate));
-
     Some((krate, map))
 }
 
@@ -307,14 +302,14 @@ pub struct CrateAnalysis {
     pub name: String,
 }
 
-
 /// Run the resolution, typechecking, region checking and other
 /// miscellaneous analysis passes on the crate. Return various
 /// structures carrying the results of the analysis.
 pub fn phase_3_run_analysis_passes(sess: Session,
                                    krate: &ast::Crate,
                                    ast_map: syntax::ast_map::Map,
                                    name: String) -> CrateAnalysis {
+
     let time_passes = sess.time_passes();
 
     time(time_passes, "external crate/lib resolution", (), |_|

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

@@ -29,8 +29,7 @@ use syntax::{ast, codemap};
 use std::os;
 use std::cell::{Cell, RefCell};
 
-// Represents the data associated with a compilation
-// session for a single crate.
+
 pub struct Session {
     pub targ_cfg: config::Config,
     pub opts: config::Options,

branches/dist-snap/src/librustc/front/config.rs

@@ -14,8 +14,6 @@ use syntax::codemap;
 
 use std::gc::{Gc, GC};
 
-/// A folder that strips out items that do not belong in the current
-/// configuration.
 struct Context<'a> {
     in_cfg: |attrs: &[ast::Attribute]|: 'a -> bool,
 }
@@ -43,9 +41,6 @@ impl<'a> fold::Folder for Context<'a> {
     fn fold_expr(&mut self, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
         fold_expr(self, expr)
     }
-    fn fold_mac(&mut self, mac: &ast::Mac) -> ast::Mac {
-        fold::fold_mac(mac, self)
-    }
 }
 
 pub fn strip_items(krate: ast::Crate,

branches/dist-snap/src/librustc/metadata/creader.rs

@@ -446,7 +446,7 @@ impl<'a> PluginMetadataReader<'a> {
             should_match_name: true,
         };
         let library = match load_ctxt.maybe_load_library_crate() {
-            Some(l) => l,
+            Some (l) => l,
             None if is_cross => {
                 // try loading from target crates (only valid if there are
                 // no syntax extensions)
@@ -473,14 +473,6 @@ impl<'a> PluginMetadataReader<'a> {
         let registrar = decoder::get_plugin_registrar_fn(library.metadata.as_slice()).map(|id| {
             decoder::get_symbol(library.metadata.as_slice(), id)
         });
-        if library.dylib.is_none() && registrar.is_some() {
-            let message = format!("plugin crate `{}` only found in rlib format, \
-                                   but must be available in dylib format",
-                                  info.ident);
-            self.env.sess.span_err(krate.span, message.as_slice());
-            // No need to abort because the loading code will just ignore this
-            // empty dylib.
-        }
         let pc = PluginMetadata {
             lib: library.dylib.clone(),
             macros: macros,

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -693,10 +693,6 @@ fn encode_info_for_struct(ecx: &EncodeContext,
         encode_name(ebml_w, nm);
         encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
         encode_def_id(ebml_w, local_def(id));
-
-        let stab = stability::lookup(ecx.tcx, field.id);
-        encode_stability(ebml_w, stab);
-
         ebml_w.end_tag();
     }
     index
@@ -1588,25 +1584,37 @@ fn encode_plugin_registrar_fn(ecx: &EncodeContext, ebml_w: &mut Encoder) {
     }
 }
 
-/// Given a span, write the text of that span into the output stream
-/// as an exported macro
-fn encode_macro_def(ecx: &EncodeContext,
-                    ebml_w: &mut Encoder,
-                    span: &syntax::codemap::Span) {
-    let def = ecx.tcx.sess.codemap().span_to_snippet(*span)
-        .expect("Unable to find source for macro");
-    ebml_w.start_tag(tag_macro_def);
-    ebml_w.wr_str(def.as_slice());
-    ebml_w.end_tag();
+struct MacroDefVisitor<'a, 'b, 'c> {
+    ecx: &'a EncodeContext<'b>,
+    ebml_w: &'a mut Encoder<'c>
+}
+
+impl<'a, 'b, 'c> Visitor<()> for MacroDefVisitor<'a, 'b, 'c> {
+    fn visit_item(&mut self, item: &Item, _: ()) {
+        match item.node {
+            ItemMac(..) => {
+                let def = self.ecx.tcx.sess.codemap().span_to_snippet(item.span)
+                    .expect("Unable to find source for macro");
+                self.ebml_w.start_tag(tag_macro_def);
+                self.ebml_w.wr_str(def.as_slice());
+                self.ebml_w.end_tag();
+            }
+            _ => {}
+        }
+        visit::walk_item(self, item, ());
+    }
 }
 
-/// Serialize the text of the exported macros
-fn encode_macro_defs(ecx: &EncodeContext,
-                     krate: &Crate,
-                     ebml_w: &mut Encoder) {
+fn encode_macro_defs<'a>(ecx: &'a EncodeContext,
+                         krate: &Crate,
+                         ebml_w: &'a mut Encoder) {
     ebml_w.start_tag(tag_exported_macros);
-    for span in krate.exported_macros.iter() {
-        encode_macro_def(ecx, ebml_w, span);
+    {
+        let mut visitor = MacroDefVisitor {
+            ecx: ecx,
+            ebml_w: ebml_w,
+        };
+        visit::walk_crate(&mut visitor, krate, ());
     }
     ebml_w.end_tag();
 }