Auto merge of #52355 - pietroalbini:zfeature, r=<try>

Add the -Zfeature=foo unstable rustc option

This PR adds a new unstable option to `rustc`: `-Zfeature=foo`. The option can be used to enable nightly features from the CLI, and it's meant to be used by tools like Crater to try enabling features without changing the crate's source code.

The exact reason I need this is to implement "edition runs" in Crater: we need to add the preview feature flag to every crate, and editing the crates' source code on the fly might produce unexpected results, while a compiler flag is more reliable. Obviously this won't be stabilized in the future.

cc rust-lang/crater#282 @Mark-Simulacrum

Author: bors

Diff for: src/librustc/session/config.rs

@@ -1351,6 +1351,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
           "generate build artifacts that are compatible with linker-based LTO."),
     no_parallel_llvm: bool = (false, parse_bool, [UNTRACKED],
           "don't run LLVM in parallel (while keeping codegen-units and ThinLTO)"),
+    feature: Vec<String> = (Vec::new(), parse_string_push, [TRACKED],
+        "enable the provided nightly feature (can be used multiple times)"),
 }
 
 pub fn default_lib_output() -> CrateType {

Diff for: src/librustc_driver/driver.rs

@@ -812,6 +812,7 @@ where
     let (mut krate, features) = syntax::config::features(
         krate,
         &sess.parse_sess,
+        &sess.opts.debugging_opts.feature,
         sess.opts.test,
         sess.edition(),
     );

Diff for: src/libsyntax/config.rs

@@ -27,8 +27,8 @@ pub struct StripUnconfigured<'a> {
 }
 
 // `cfg_attr`-process the crate's attributes and compute the crate's features.
-pub fn features(mut krate: ast::Crate, sess: &ParseSess, should_test: bool, edition: Edition)
-                -> (ast::Crate, Features) {
+pub fn features(mut krate: ast::Crate, sess: &ParseSess, z_features: &[String], should_test: bool,
+                edition: Edition) -> (ast::Crate, Features) {
     let features;
     {
         let mut strip_unconfigured = StripUnconfigured {
@@ -47,7 +47,7 @@ pub fn features(mut krate: ast::Crate, sess: &ParseSess, should_test: bool, edit
             return (krate, Features::new());
         }
 
-        features = get_features(&sess.span_diagnostic, &krate.attrs, edition);
+        features = get_features(&sess.span_diagnostic, &krate.attrs, &z_features, edition);
 
         // Avoid reconfiguring malformed `cfg_attr`s
         if err_count == sess.span_diagnostic.err_count() {

Diff for: src/libsyntax/feature_gate.rs

@@ -1874,16 +1874,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
     }
 }
 
-pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute],
+pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute], z_features: &[String],
                     crate_edition: Edition) -> Features {
-    fn feature_removed(span_handler: &Handler, span: Span, reason: Option<&str>) {
-        let mut err = struct_span_err!(span_handler, span, E0557, "feature has been removed");
-        if let Some(reason) = reason {
-            err.span_note(span, reason);
-        }
-        err.emit();
-    }
-
     let mut features = Features::new();
 
     let mut feature_checker = FeatureChecker::default();
@@ -1919,49 +1911,76 @@ pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute],
                 continue
             };
 
-            if let Some((.., set)) = ACTIVE_FEATURES.iter().find(|f| name == f.0) {
-                set(&mut features, mi.span);
-                feature_checker.collect(&features, mi.span);
-                continue
-            }
-
-            let removed = REMOVED_FEATURES.iter().find(|f| name == f.0);
-            let stable_removed = STABLE_REMOVED_FEATURES.iter().find(|f| name == f.0);
-            if let Some((.., reason)) = removed.or(stable_removed) {
-                feature_removed(span_handler, mi.span, *reason);
-                continue
-            }
+            set_feature(
+                name,
+                mi.span,
+                span_handler,
+                &mut features,
+                &mut feature_checker,
+                crate_edition,
+            );
+        }
+    }
 
-            if ACCEPTED_FEATURES.iter().any(|f| name == f.0) {
-                features.declared_stable_lang_features.push((name, mi.span));
-                continue
-            }
+    for z_feature in z_features {
+        set_feature(
+            Symbol::intern(&z_feature),
+            DUMMY_SP,
+            span_handler,
+            &mut features,
+            &mut feature_checker,
+            crate_edition,
+        );
+    }
 
-            if let Some(edition) = ALL_EDITIONS.iter().find(|e| name == e.feature_name()) {
-                if *edition <= crate_edition {
-                    continue
-                }
+    feature_checker.check(span_handler);
 
-                for &(.., f_edition, set) in ACTIVE_FEATURES.iter() {
-                    if let Some(f_edition) = f_edition {
-                        if *edition >= f_edition {
-                            // FIXME(Manishearth) there is currently no way to set
-                            // lib features by edition
-                            set(&mut features, DUMMY_SP);
-                        }
-                    }
-                }
+    features
+}
 
-                continue
-            }
+fn set_feature(name: Symbol, span: Span, span_handler: &Handler, features: &mut Features,
+               feature_checker: &mut FeatureChecker, crate_edition: Edition) {
+    if let Some((.., set)) = ACTIVE_FEATURES.iter().find(|f| name == f.0) {
+        set(features, span);
+        feature_checker.collect(&features, span);
+        return;
+    }
 
-            features.declared_lib_features.push((name, mi.span));
+    let removed = REMOVED_FEATURES.iter().find(|f| name == f.0);
+    let stable_removed = STABLE_REMOVED_FEATURES.iter().find(|f| name == f.0);
+    if let Some((.., reason)) = removed.or(stable_removed) {
+        let mut err = struct_span_err!(span_handler, span, E0557, "feature has been removed");
+        if let Some(reason) = reason {
+            err.span_note(span, reason);
         }
+        err.emit();
+        return;
     }
 
-    feature_checker.check(span_handler);
+    if ACCEPTED_FEATURES.iter().any(|f| name == f.0) {
+        features.declared_stable_lang_features.push((name, span));
+        return;
+    }
 
-    features
+    if let Some(edition) = ALL_EDITIONS.iter().find(|e| name == e.feature_name()) {
+        if *edition <= crate_edition {
+            return;
+        }
+
+        for &(.., f_edition, set) in ACTIVE_FEATURES.iter() {
+            if let Some(f_edition) = f_edition {
+                if *edition >= f_edition {
+                    // FIXME(Manishearth) there is currently no way to set
+                    // lib features by edition
+                    set(features, DUMMY_SP);
+                }
+            }
+        }
+
+        return;
+    }
+
+    features.declared_lib_features.push((name, span));
 }
 
 /// A collector for mutually exclusive and interdependent features and their flag spans.

Diff for: src/test/run-pass/z-feature.rs

@@ -0,0 +1,21 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This test checks if an unstable feature is enabled with the -Zfeature=foo
+// flag. If the exact feature used here is causing problems feel free to
+// replace it with another perma-unstable feature.
+
+// compile-flags: -Zfeature=abi_unadjusted
+
+#![allow(dead_code)]
+
+extern "unadjusted" fn foo() {}
+
+fn main() {}