Merge pull request rust-lang#80 from gnzlbg/soft

Add flag --api-guidelines to silence non-technical breaking changes.

Author: ibabushkin

src/bin/cargo_semver.rs

@@ -252,11 +252,21 @@ fn do_main(config: &Config, matches: &Matches, explain: bool) -> CargoResult<()>
         child.args(&["--target", &target]);
     }
 
-    let mut child = child
+    let child = child
         .arg("-")
         .stdin(Stdio::piped())
         .env("RUST_SEMVER_CRATE_VERSION", stable_version)
         .env("RUST_SEMVER_VERBOSE", format!("{}", explain))
+        .env(
+            "RUST_SEMVER_API_GUIDELINES",
+            if matches.opt_present("a") {
+                "true"
+            } else {
+                "false"
+            },
+        );
+
+    let mut child = child
         .spawn()
         .map_err(|e| Error(format!("could not spawn rustc: {}", e)))?;
 
@@ -311,6 +321,11 @@ fn main() {
     opts.optflag("V", "version", "print version information and exit");
     opts.optflag("e", "explain", "print detailed error explanations");
     opts.optflag("d", "debug", "print command to debug and exit");
+    opts.optflag(
+        "a",
+        "api-guidelines",
+        "report only changes that are breaking according to the API-guidelines",
+    );
     opts.optopt(
         "s",
         "stable-path",

src/bin/rust_semverver.rs

@@ -32,7 +32,7 @@ use std::{
 use syntax::{ast, source_map::Pos};
 
 /// After the typechecker has finished it's work, perform our checks.
-fn callback(state: &driver::CompileState, version: &str, verbose: bool) {
+fn callback(state: &driver::CompileState, version: &str, verbose: bool, api_guidelines: bool) {
     let tcx = state.tcx.unwrap();
 
     // To select the old and new crates we look at the position of the declaration in the
@@ -62,8 +62,7 @@ fn callback(state: &driver::CompileState, version: &str, verbose: bool) {
     if let [(_, old_def_id), (_, new_def_id)] = *crates.as_slice() {
         debug!("running semver analysis");
         let changes = run_analysis(tcx, old_def_id, new_def_id);
-
-        changes.output(tcx.sess, version, verbose);
+        changes.output(tcx.sess, version, verbose, api_guidelines);
     } else {
         tcx.sess.err("could not find crate old and new crates");
     }
@@ -77,15 +76,18 @@ struct SemVerVerCompilerCalls {
     version: String,
     /// The output mode.
     verbose: bool,
+    /// Output only changes that are breaking according to the API guidelines.
+    api_guidelines: bool,
 }
 
 impl SemVerVerCompilerCalls {
     /// Construct a new compilation wrapper, given a version string.
-    pub fn new(version: String, verbose: bool) -> Box<Self> {
+    pub fn new(version: String, verbose: bool, api_guidelines: bool) -> Box<Self> {
         Box::new(Self {
             default: Box::new(RustcDefaultCalls),
             version,
             verbose,
+            api_guidelines,
         })
     }
 
@@ -96,6 +98,10 @@ impl SemVerVerCompilerCalls {
     pub fn get_version(&self) -> &String {
         &self.version
     }
+
+    pub fn get_api_guidelines(&self) -> bool {
+        self.api_guidelines
+    }
 }
 
 impl<'a> CompilerCalls<'a> for SemVerVerCompilerCalls {
@@ -148,13 +154,14 @@ impl<'a> CompilerCalls<'a> for SemVerVerCompilerCalls {
     ) -> driver::CompileController<'a> {
         let default = self.get_default();
         let version = self.get_version().clone();
+        let api_guidelines = self.get_api_guidelines();
         let Self { verbose, .. } = *self;
         let mut controller = CompilerCalls::build_controller(default, sess, matches);
         let old_callback = std::mem::replace(&mut controller.after_analysis.callback, box |_| {});
 
         controller.after_analysis.callback = box move |state| {
             debug!("running rust-semverver after_analysis callback");
-            callback(state, &version, verbose);
+            callback(state, &version, verbose, api_guidelines);
             debug!("running other after_analysis callback");
             old_callback(state);
         };
@@ -217,8 +224,9 @@ fn main() {
         };
 
         let verbose = std::env::var("RUST_SEMVER_VERBOSE") == Ok("true".to_string());
+        let api_guidelines = std::env::var("RUST_SEMVER_API_GUIDELINES") == Ok("true".to_string());
 
-        let cc = SemVerVerCompilerCalls::new(version, verbose);
+        let cc = SemVerVerCompilerCalls::new(version, verbose, api_guidelines);
         rustc_driver::run_compiler(&args, cc, None, None)
     });
 

src/semcheck/changes.rs

@@ -879,7 +879,7 @@ impl<'tcx> ChangeSet<'tcx> {
     }
 
     /// Format the contents of a change set for user output.
-    pub fn output(&self, session: &Session, version: &str, verbose: bool) {
+    pub fn output(&self, session: &Session, version: &str, verbose: bool, api_guidelines: bool) {
         if let Ok(mut new_version) = Version::parse(version) {
             if new_version.major == 0 {
                 new_version.increment_patch();
@@ -901,11 +901,25 @@ impl<'tcx> ChangeSet<'tcx> {
 
         for key in self.spans.values() {
             if let Some(change) = self.path_changes.get(key) {
-                change.report(session);
+                if api_guidelines {
+                    match change.to_category() {
+                        Patch | Breaking => change.report(session),
+                        _ => (),
+                    }
+                } else {
+                    change.report(session);
+                }
             }
 
             if let Some(change) = self.changes.get(key) {
-                change.report(session, verbose);
+                if api_guidelines {
+                    match change.to_category() {
+                        Patch | Breaking => change.report(session, verbose),
+                        _ => (),
+                    }
+                } else {
+                    change.report(session, verbose);
+                }
             }
         }
     }

tests/cases/addition/stdout_api_guidelines

@@ -0,0 +1 @@
+version bump: 1.0.0 -> (technically breaking) -> 1.1.0

tests/cases/addition_path/stdout_api_guidelines

@@ -0,0 +1 @@
+version bump: 1.0.0 -> (technically breaking) -> 1.1.0

tests/cases/addition_use/stdout_api_guidelines

@@ -0,0 +1,15 @@
+version bump: 1.0.0 -> (breaking) -> 2.0.0
+error: breaking changes in `Def`
+ --> $REPO_PATH/tests/cases/addition_use/new.rs:5:1
+  |
+5 | / pub struct Def<'a> {
+6 | |     pub field1: Abc,
+7 | |     pub field2: &'a Bcd,
+8 | | }
+  | |_^
+  |
+  = warning: type error: expected (), found struct `new::Abc` (breaking)
+  = warning: type error: expected (), found trait new::Bcd (breaking)
+
+error: aborting due to previous error
+

tests/examples.rs

@@ -5,10 +5,9 @@ mod features {
         process::{Command, Stdio},
     };
 
-    fn test_example(path: &Path) {
+    fn test_example(path: &Path, out_file: &Path) {
         let mut success = true;
 
-        let out_file = path.join("stdout");
         let old_rlib = path.join("libold.rlib").to_str().unwrap().to_owned();
         let new_rlib = path.join("libnew.rlib").to_str().unwrap().to_owned();
 
@@ -78,6 +77,10 @@ mod features {
                 cmd.args(target_args);
             }
 
+            if out_file.to_str().unwrap().contains("stdout_api_guidelines") {
+                cmd.env("RUST_SEMVER_API_GUIDELINES", "true");
+            }
+
             success &= cmd
                 .status()
                 .expect("could not run rust-semverver")
@@ -144,7 +147,12 @@ mod features {
             #[test]
             fn $name() {
                 let path = Path::new("tests").join("cases").join(stringify!($name));
-                test_example(&path);
+                test_example(&path, &path.join("stdout"));
+
+                if path.join("stdout_api_guidelines").exists() {
+                    eprintln!("api-guidelines");
+                    test_example(&path, &path.join("stdout_api_guidelines"));
+                }
             }
         };
         ($($name:ident),*) => {