Rollup of 5 pull requests

src/libcore/ptr/mod.rs

@@ -259,7 +259,8 @@ pub(crate) struct FatPtr<T> {
 /// ```
 #[inline]
 #[unstable(feature = "slice_from_raw_parts", reason = "recently added", issue = "36925")]
-pub fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
+#[rustc_const_unstable(feature = "const_slice_from_raw_parts", issue = "67456")]
+pub const fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
     unsafe { Repr { raw: FatPtr { data, len } }.rust }
 }
 
@@ -275,7 +276,8 @@ pub fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
 /// [`from_raw_parts_mut`]: ../../std/slice/fn.from_raw_parts_mut.html
 #[inline]
 #[unstable(feature = "slice_from_raw_parts", reason = "recently added", issue = "36925")]
-pub fn slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] {
+#[rustc_const_unstable(feature = "const_slice_from_raw_parts", issue = "67456")]
+pub const fn slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] {
     unsafe { Repr { raw: FatPtr { data, len } }.rust_mut }
 }
 

src/libcore/tests/lib.rs

@@ -36,6 +36,9 @@
 #![feature(iter_is_partitioned)]
 #![feature(iter_order_by)]
 #![feature(cmp_min_max_by)]
+#![feature(slice_from_raw_parts)]
+#![feature(const_slice_from_raw_parts)]
+#![feature(const_raw_ptr_deref)]
 
 extern crate test;
 

src/libcore/tests/ptr.rs

@@ -1,6 +1,17 @@
 use core::cell::RefCell;
 use core::ptr::*;
 
+#[test]
+fn test_const_from_raw_parts() {
+    const SLICE: &[u8] = &[1, 2, 3, 4];
+    const FROM_RAW: &[u8] = unsafe { &*slice_from_raw_parts(SLICE.as_ptr(), SLICE.len()) };
+    assert_eq!(SLICE, FROM_RAW);
+
+    let slice = &[1, 2, 3, 4, 5];
+    let from_raw = unsafe { &*slice_from_raw_parts(slice.as_ptr(), 2) } ;
+    assert_eq!(&slice[..2], from_raw);
+}
+
 #[test]
 fn test() {
     unsafe {

src/librustc_codegen_llvm/llvm_util.rs

@@ -3,6 +3,7 @@ use crate::llvm;
 use syntax_pos::symbol::Symbol;
 use rustc::session::Session;
 use rustc::session::config::PrintRequest;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_target::spec::{MergeFunctions, PanicStrategy};
 use libc::c_int;
 use std::ffi::CString;
@@ -51,43 +52,60 @@ unsafe fn configure_llvm(sess: &Session) {
 
     llvm::LLVMRustInstallFatalErrorHandler();
 
+    fn llvm_arg_to_arg_name(full_arg: &str) -> &str {
+        full_arg.trim().split(|c: char| {
+            c == '=' || c.is_whitespace()
+        }).next().unwrap_or("")
+    }
+
+    let user_specified_args: FxHashSet<_> = sess
+        .opts
+        .cg
+        .llvm_args
+        .iter()
+        .map(|s| llvm_arg_to_arg_name(s))
+        .filter(|s| s.len() > 0)
+        .collect();
+
     {
-        let mut add = |arg: &str| {
-            let s = CString::new(arg).unwrap();
-            llvm_args.push(s.as_ptr());
-            llvm_c_strs.push(s);
+        // This adds the given argument to LLVM. Unless `force` is true
+        // user specified arguments are *not* overridden.
+        let mut add = |arg: &str, force: bool| {
+            if force || !user_specified_args.contains(llvm_arg_to_arg_name(arg)) {
+                let s = CString::new(arg).unwrap();
+                llvm_args.push(s.as_ptr());
+                llvm_c_strs.push(s);
+            }
         };
-        add("rustc"); // fake program name
-        if sess.time_llvm_passes() { add("-time-passes"); }
-        if sess.print_llvm_passes() { add("-debug-pass=Structure"); }
-        if sess.opts.debugging_opts.disable_instrumentation_preinliner {
-            add("-disable-preinline");
-        }
+        add("rustc", true); // fake program name
+        if sess.time_llvm_passes() { add("-time-passes", false); }
+        if sess.print_llvm_passes() { add("-debug-pass=Structure", false); }
+
         if sess.opts.debugging_opts.generate_arange_section {
-            add("-generate-arange-section");
+            add("-generate-arange-section", false);
         }
         if get_major_version() >= 8 {
             match sess.opts.debugging_opts.merge_functions
                   .unwrap_or(sess.target.target.options.merge_functions) {
                 MergeFunctions::Disabled |
                 MergeFunctions::Trampolines => {}
                 MergeFunctions::Aliases => {
-                    add("-mergefunc-use-aliases");
+                    add("-mergefunc-use-aliases", false);
                 }
             }
         }
 
         if sess.target.target.target_os == "emscripten" &&
             sess.panic_strategy() == PanicStrategy::Unwind {
-            add("-enable-emscripten-cxx-exceptions");
+            add("-enable-emscripten-cxx-exceptions", false);
         }
 
         // HACK(eddyb) LLVM inserts `llvm.assume` calls to preserve align attributes
         // during inlining. Unfortunately these may block other optimizations.
-        add("-preserve-alignment-assumptions-during-inlining=false");
+        add("-preserve-alignment-assumptions-during-inlining=false", false);
 
         for arg in &sess.opts.cg.llvm_args {
-            add(&(*arg));
+            add(&(*arg), true);
         }
     }
 

src/librustc_error_codes/error_codes/E0120.md

@@ -1,5 +1,7 @@
-An attempt was made to implement Drop on a trait, which is not allowed: only
-structs and enums can implement Drop. An example causing this error:
+Drop was implemented on a trait, which is not allowed: only structs and
+enums can implement Drop.
+
+Erroneous code example:
 
 ```compile_fail,E0120
 trait MyTrait {}
@@ -10,7 +12,7 @@ impl Drop for MyTrait {
 ```
 
 A workaround for this problem is to wrap the trait up in a struct, and implement
-Drop on that. An example is shown below:
+Drop on that:
 
 ```
 trait MyTrait {}
@@ -22,7 +24,7 @@ impl <T: MyTrait> Drop for MyWrapper<T> {
 
 ```
 
-Alternatively, wrapping trait objects requires something like the following:
+Alternatively, wrapping trait objects requires something:
 
 ```
 trait MyTrait {}

src/librustc_error_codes/error_codes/E0121.md

@@ -1,10 +1,24 @@
-In order to be consistent with Rust's lack of global type inference,
-type and const placeholders are disallowed by design in item signatures.
+The type placeholder `_` was used within a type on an item's signature.
 
-Examples of this error include:
+Erroneous code example:
 
 ```compile_fail,E0121
-fn foo() -> _ { 5 } // error, explicitly write out the return type instead
+fn foo() -> _ { 5 } // error
 
-static BAR: _ = "test"; // error, explicitly write out the type instead
+static BAR: _ = "test"; // error
+```
+
+In those cases, you need to provide the type explicitly:
+
+```
+fn foo() -> i32 { 5 } // ok!
+
+static BAR: &str = "test"; // ok!
+```
+
+The type placeholder `_` can be used outside item's signature as follows:
+
+```
+let x = "a4a".split('4')
+    .collect::<Vec<_>>(); // No need to precise the Vec's generic type.
 ```

src/librustc_parse/parser/expr.rs

@@ -91,6 +91,10 @@ impl<'a> Parser<'a> {
         self.parse_expr_res(Restrictions::empty(), None)
     }
 
+    pub(super) fn parse_anon_const_expr(&mut self) -> PResult<'a, AnonConst> {
+        self.parse_expr().map(|value| AnonConst { id: DUMMY_NODE_ID, value })
+    }
+
     fn parse_paren_expr_seq(&mut self) -> PResult<'a, Vec<P<Expr>>> {
         self.parse_paren_comma_seq(|p| {
             match p.parse_expr() {
@@ -883,10 +887,7 @@ impl<'a> Parser<'a> {
                     let first_expr = self.parse_expr()?;
                     if self.eat(&token::Semi) {
                         // Repeating array syntax: `[ 0; 512 ]`
-                        let count = AnonConst {
-                            id: DUMMY_NODE_ID,
-                            value: self.parse_expr()?,
-                        };
+                        let count = self.parse_anon_const_expr()?;
                         self.expect(&token::CloseDelim(token::Bracket))?;
                         ex = ExprKind::Repeat(first_expr, count);
                     } else if self.eat(&token::Comma) {

src/librustc_parse/parser/item.rs

@@ -5,7 +5,7 @@ use crate::maybe_whole;
 
 use rustc_errors::{PResult, Applicability, DiagnosticBuilder, StashKey};
 use rustc_error_codes::*;
-use syntax::ast::{self, DUMMY_NODE_ID, Ident, Attribute, AttrKind, AttrStyle, AnonConst, Item};
+use syntax::ast::{self, DUMMY_NODE_ID, Ident, Attribute, AttrKind, AttrStyle, Item};
 use syntax::ast::{AssocItem, AssocItemKind, ItemKind, UseTree, UseTreeKind};
 use syntax::ast::{PathSegment, IsAuto, Constness, IsAsync, Unsafety, Defaultness, Extern, StrLit};
 use syntax::ast::{Visibility, VisibilityKind, Mutability, FnHeader, ForeignItem, ForeignItemKind};
@@ -1318,10 +1318,7 @@ impl<'a> Parser<'a> {
         };
 
         let disr_expr = if self.eat(&token::Eq) {
-            Some(AnonConst {
-                id: DUMMY_NODE_ID,
-                value: self.parse_expr()?,
-            })
+            Some(self.parse_anon_const_expr()?)
         } else {
             None
         };