---

yaml
---
r: 79861
b: refs/heads/master
c: 67ed30c
h: refs/heads/master
i:
  79859: 32f1f51
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 491ce71453499f61eeb24d891b28a07ea9ae532b
+refs/heads/master: 67ed30cd5eab9af1976a994c50d146a3dbeccad4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 54ae2800ffb30513f89ce13d27ac3c8d095d98ac
 refs/heads/try: 71bebebc37fbb229877da88dde13c2f35913bd77

trunk/src/libextra/rl.rs

@@ -8,10 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// FIXME #3921. This is unsafe because linenoise uses global mutable
+// state without mutexes.
+
 use std::c_str::ToCStr;
 use std::libc::{c_char, c_int};
-use std::{local_data, str, rt};
-use std::unstable::finally::Finally;
+use std::local_data;
+use std::str;
 
 #[cfg(stage0)]
 pub mod rustrt {
@@ -25,9 +28,6 @@ pub mod rustrt {
         fn linenoiseHistoryLoad(file: *c_char) -> c_int;
         fn linenoiseSetCompletionCallback(callback: *u8);
         fn linenoiseAddCompletion(completions: *(), line: *c_char);
-
-        fn rust_take_linenoise_lock();
-        fn rust_drop_linenoise_lock();
     }
 }
 
@@ -42,107 +42,65 @@ pub mod rustrt {
     externfn!(fn linenoiseHistoryLoad(file: *c_char) -> c_int)
     externfn!(fn linenoiseSetCompletionCallback(callback: extern "C" fn(*i8, *())))
     externfn!(fn linenoiseAddCompletion(completions: *(), line: *c_char))
-
-    externfn!(fn rust_take_linenoise_lock())
-    externfn!(fn rust_drop_linenoise_lock())
-}
-
-macro_rules! locked {
-    ($expr:expr) => {
-        unsafe {
-            // FIXME #9105: can't use a static mutex in pure Rust yet.
-            rustrt::rust_take_linenoise_lock();
-            let x = $expr;
-            rustrt::rust_drop_linenoise_lock();
-            x
-        }
-    }
 }
 
 /// Add a line to history
-pub fn add_history(line: &str) -> bool {
+pub unsafe fn add_history(line: &str) -> bool {
     do line.with_c_str |buf| {
-        (locked!(rustrt::linenoiseHistoryAdd(buf))) == 1 as c_int
+        rustrt::linenoiseHistoryAdd(buf) == 1 as c_int
     }
 }
 
 /// Set the maximum amount of lines stored
-pub fn set_history_max_len(len: int) -> bool {
-    (locked!(rustrt::linenoiseHistorySetMaxLen(len as c_int))) == 1 as c_int
+pub unsafe fn set_history_max_len(len: int) -> bool {
+    rustrt::linenoiseHistorySetMaxLen(len as c_int) == 1 as c_int
 }
 
 /// Save line history to a file
-pub fn save_history(file: &str) -> bool {
+pub unsafe fn save_history(file: &str) -> bool {
     do file.with_c_str |buf| {
-        // 0 on success, -1 on failure
-        (locked!(rustrt::linenoiseHistorySave(buf))) == 0 as c_int
+        rustrt::linenoiseHistorySave(buf) == 1 as c_int
     }
 }
 
 /// Load line history from a file
-pub fn load_history(file: &str) -> bool {
+pub unsafe fn load_history(file: &str) -> bool {
     do file.with_c_str |buf| {
-        // 0 on success, -1 on failure
-        (locked!(rustrt::linenoiseHistoryLoad(buf))) == 0 as c_int
+        rustrt::linenoiseHistoryLoad(buf) == 1 as c_int
     }
 }
 
 /// Print out a prompt and then wait for input and return it
-pub fn read(prompt: &str) -> Option<~str> {
+pub unsafe fn read(prompt: &str) -> Option<~str> {
     do prompt.with_c_str |buf| {
-        let line = locked!(rustrt::linenoise(buf));
+        let line = rustrt::linenoise(buf);
 
         if line.is_null() { None }
-        else {
-            unsafe {
-                do (|| {
-                    Some(str::raw::from_c_str(line))
-                }).finally {
-                    // linenoise's return value is from strdup, so we
-                    // better not leak it.
-                    rt::global_heap::exchange_free(line);
-                }
-            }
-        }
+        else { Some(str::raw::from_c_str(line)) }
     }
 }
 
 pub type CompletionCb = @fn(~str, @fn(~str));
 
-static complete_key: local_data::Key<CompletionCb> = &local_data::Key;
-
-/// Bind to the main completion callback in the current task.
-///
-/// The completion callback should not call any `extra::rl` functions
-/// other than the closure that it receives as its second
-/// argument. Calling such a function will deadlock on the mutex used
-/// to ensure that the calls are thread-safe.
-pub fn complete(cb: CompletionCb) {
-    local_data::set(complete_key, cb);
-
-    extern fn callback(c_line: *c_char, completions: *()) {
-        do local_data::get(complete_key) |opt_cb| {
-            // only fetch completions if a completion handler has been
-            // registered in the current task.
-            match opt_cb {
-                None => {},
-                Some(cb) => {
-                    let line = unsafe { str::raw::from_c_str(c_line) };
-                    do (*cb)(line) |suggestion| {
-                        do suggestion.with_c_str |buf| {
-                            // This isn't locked, because `callback` gets
-                            // called inside `rustrt::linenoise`, which
-                            // *is* already inside the mutex, so
-                            // re-locking would be a deadlock.
-                            unsafe {
-                                rustrt::linenoiseAddCompletion(completions, buf);
-                            }
-                        }
+static complete_key: local_data::Key<@CompletionCb> = &local_data::Key;
+
+/// Bind to the main completion callback
+pub unsafe fn complete(cb: CompletionCb) {
+    local_data::set(complete_key, @cb);
+
+    extern fn callback(line: *c_char, completions: *()) {
+        do local_data::get(complete_key) |cb| {
+            let cb = **cb.unwrap();
+
+            unsafe {
+                do cb(str::raw::from_c_str(line)) |suggestion| {
+                    do suggestion.with_c_str |buf| {
+                        rustrt::linenoiseAddCompletion(completions, buf);
                     }
                 }
             }
         }
     }
 
-    locked!(rustrt::linenoiseSetCompletionCallback(callback));
+    rustrt::linenoiseSetCompletionCallback(callback);
 }

trunk/src/librustc/lib/llvm.rs

@@ -2109,6 +2109,14 @@ pub mod llvm {
             ArgNo: c_uint)
             -> ValueRef;
 
+        #[fast_ffi]
+        pub fn LLVMDIBuilderCreateNameSpace(Builder: DIBuilderRef,
+                                            Scope: ValueRef,
+                                            Name: *c_char,
+                                            File: ValueRef,
+                                            LineNo: c_uint)
+                                            -> ValueRef;
+
         #[fast_ffi]
         pub fn LLVMIsAArgument(value_ref: ValueRef) -> ValueRef;
 

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

@@ -3021,6 +3021,10 @@ pub fn trans_crate(sess: session::Session,
                                      link_meta,
                                      analysis.reachable);
 
+    if ccx.sess.opts.debuginfo {
+        debuginfo::initialize(ccx, crate);
+    }
+
     {
         let _icx = push_ctxt("text");
         trans_mod(ccx, &crate.module);