Replace setters with new interface

Author: topecongiro

src/bin/main.rs

@@ -194,7 +194,7 @@ fn execute(opts: &Options) -> Result<i32, FailureError> {
             Ok(0)
         }
         Operation::Help(HelpOp::Config) => {
-            Config::print_docs(&mut stdout(), options.unstable_features);
+            Config::print_docs(&mut stdout(), options.unstable_features)?;
             Ok(0)
         }
         Operation::Help(HelpOp::FileLines) => {
@@ -206,7 +206,7 @@ fn execute(opts: &Options) -> Result<i32, FailureError> {
             Ok(0)
         }
         Operation::ConfigOutputDefault { path } => {
-            let toml = Config::default().all_options().to_toml().map_err(err_msg)?;
+            let toml = Config::all_options().to_toml().map_err(err_msg)?;
             if let Some(path) = path {
                 let mut file = File::create(path)?;
                 file.write_all(toml.as_bytes())?;
@@ -225,8 +225,7 @@ fn execute(opts: &Options) -> Result<i32, FailureError> {
             let file = file.canonicalize().unwrap_or(file);
 
             let (config, _) = load_config(Some(file.parent().unwrap()), Some(options.clone()))?;
-            let toml = config.all_options().to_toml().map_err(err_msg)?;
-            io::stdout().write_all(toml.as_bytes())?;
+            io::stdout().write_all(config.to_toml()?.as_bytes())?;
 
             Ok(0)
         }
@@ -243,11 +242,11 @@ fn format_string(input: String, options: GetOptsOptions) -> Result<i32, FailureE
     let (mut config, _) = load_config(Some(Path::new(".")), Some(options.clone()))?;
 
     // emit mode is always Stdout for Stdin.
-    config.set().emit_mode(EmitMode::Stdout);
-    config.set().verbose(Verbosity::Quiet);
+    config.set_emit_mode(EmitMode::Stdout);
+    config.set_verbose(Verbosity::Quiet);
 
     // parse file_lines
-    config.set().file_lines(options.file_lines);
+    config.set_file_lines(options.file_lines);
     for f in config.file_lines().files() {
         match *f {
             FileName::Stdin => {}
@@ -624,40 +623,40 @@ impl GetOptsOptions {
 impl CliOptions for GetOptsOptions {
     fn apply_to(self, config: &mut Config) {
         if self.verbose {
-            config.set().verbose(Verbosity::Verbose);
+            config.set_verbose(Verbosity::Verbose);
         } else if self.quiet {
-            config.set().verbose(Verbosity::Quiet);
+            config.set_verbose(Verbosity::Quiet);
         } else {
-            config.set().verbose(Verbosity::Normal);
+            config.set_verbose(Verbosity::Normal);
         }
-        config.set().file_lines(self.file_lines);
-        config.set().unstable_features(self.unstable_features);
+        config.set_file_lines(self.file_lines);
+        config.set_unstable_features(self.unstable_features);
         if let Some(skip_children) = self.skip_children {
-            config.set().skip_children(skip_children);
+            config.set_skip_children(skip_children);
         }
         if let Some(error_on_unformatted) = self.error_on_unformatted {
-            config.set().error_on_unformatted(error_on_unformatted);
+            config.set_error_on_unformatted(error_on_unformatted);
         }
         if let Some(edition) = self.edition {
-            config.set().edition(edition);
+            config.set_edition(edition);
         }
         if self.check {
-            config.set().emit_mode(EmitMode::Diff);
+            config.set_emit_mode(EmitMode::Diff);
         } else {
-            config.set().emit_mode(self.emit_mode);
+            config.set_emit_mode(self.emit_mode);
         }
         if self.backup {
-            config.set().make_backup(true);
+            config.set_make_backup(true);
         }
         if let Some(color) = self.color {
-            config.set().color(color);
+            config.set_color(color);
         }
         if self.print_misformatted_file_names {
-            config.set().print_misformatted_file_names(true);
+            config.set_print_misformatted_file_names(true);
         }
 
         for (key, val) in self.inline_config {
-            config.override_value(&key, &val);
+            config.override_value(&key, &val).unwrap();
         }
     }
 

src/comment.rs

@@ -655,7 +655,7 @@ impl<'a> CommentRewrite<'a> {
                     _ if self.code_block_buffer.is_empty() => String::new(),
                     _ => {
                         let mut config = self.fmt.config.clone();
-                        config.set().wrap_comments(false);
+                        config.set_wrap_comments(false);
                         if config.format_code_in_doc_comments() {
                             if let Some(s) =
                                 crate::format_code_block(&self.code_block_buffer, &config)
@@ -1744,11 +1744,11 @@ mod test {
     #[rustfmt::skip]
     fn format_doc_comments() {
         let mut wrap_normalize_config: crate::config::Config = Default::default();
-        wrap_normalize_config.set().wrap_comments(true);
-        wrap_normalize_config.set().normalize_comments(true);
+        wrap_normalize_config.set_wrap_comments(true);
+        wrap_normalize_config.set_normalize_comments(true);
 
         let mut wrap_config: crate::config::Config = Default::default();
-        wrap_config.set().wrap_comments(true);
+        wrap_config.set_wrap_comments(true);
 
         let comment = rewrite_comment(" //test",
                                       true,

src/emitter/diff.rs

@@ -79,7 +79,7 @@ mod tests {
 
         let mut writer = Vec::new();
         let mut config = Config::default();
-        config.set().print_misformatted_file_names(true);
+        config.set_print_misformatted_file_names(true);
         let mut emitter = DiffEmitter::new(config);
         let _ = emitter
             .emit_formatted_file(

src/lib.rs

@@ -283,9 +283,9 @@ fn format_snippet(snippet: &str, config: &Config) -> Option<FormattedSnippet> {
     let mut config = config.clone();
     panic::catch_unwind(|| {
         let mut out: Vec<u8> = Vec::with_capacity(snippet.len() * 2);
-        config.set().emit_mode(config::EmitMode::Stdout);
-        config.set().verbose(Verbosity::Quiet);
-        config.set().hide_parse_errors(true);
+        config.emit_mode = config::EmitMode::Stdout;
+        config.verbose = Verbosity::Quiet;
+        config.set_hide_parse_errors(true);
 
         let (formatting_error, result) = {
             let input = Input::Text(snippet.into());
@@ -346,9 +346,7 @@ fn format_code_block(code_snippet: &str, config: &Config) -> Option<FormattedSni
     // not directly outputted by rustfmt command, but used by the comment formatter's input.
     // We have output-file-wide "\n" ==> "\r\n" conversion process after here if it's necessary.
     let mut config_with_unix_newline = config.clone();
-    config_with_unix_newline
-        .set()
-        .newline_style(NewlineStyle::Unix);
+    config_with_unix_newline.set_newline_style(NewlineStyle::Unix);
     let mut formatted = format_snippet(&snippet, &config_with_unix_newline)?;
     // Remove wrapping main block
     formatted.unwrap_code_block();

src/macros.rs

@@ -1334,7 +1334,7 @@ impl MacroBranch {
         let has_block_body = old_body.starts_with('{');
 
         let mut config = context.config.clone();
-        config.set().hide_parse_errors(true);
+        config.set_hide_parse_errors(true);
 
         result += " {";
 
@@ -1344,14 +1344,14 @@ impl MacroBranch {
             shape.indent.block_indent(&config)
         };
         let new_width = config.max_width() - body_indent.width();
-        config.set().max_width(new_width);
+        config.set_max_width(new_width);
 
         // First try to format as items, then as statements.
         let new_body_snippet = match crate::format_snippet(&body_str, &config) {
             Some(new_body) => new_body,
             None => {
                 let new_width = new_width + config.tab_spaces();
-                config.set().max_width(new_width);
+                config.set_max_width(new_width);
                 match crate::format_code_block(&body_str, &config) {
                     Some(new_body) => new_body,
                     None => return None,

src/missed_spans.rs

@@ -174,7 +174,7 @@ impl<'a> FmtVisitor<'a> {
         let snippet = &*transform_missing_snippet(self.config, old_snippet);
 
         let slice_within_file_lines_range =
-            |file_lines: FileLines, cur_line, s| -> (usize, usize, bool) {
+            |file_lines: &FileLines, cur_line, s| -> (usize, usize, bool) {
                 let (lf_count, crlf_count) = count_lf_crlf(s);
                 let newline_count = lf_count + crlf_count;
                 let within_file_lines_range = file_lines.contains_range(

src/shape.rs

@@ -325,7 +325,7 @@ mod test {
     #[test]
     fn indent_to_string_hard_tabs() {
         let mut config = Config::default();
-        config.set().hard_tabs(true);
+        config.set_hard_tabs(true);
         let indent = Indent::new(8, 4);
 
         // 2 tabs + 4 spaces

src/string.rs

@@ -466,7 +466,7 @@ mod test {
         );
 
         let mut config: Config = Default::default();
-        config.set().max_width(27);
+        config.set_max_width(27);
         let fmt = StringFormat::new(Shape::legacy(25, Indent::empty()), &config);
         let rewritten_string = rewrite_string(string, &fmt, 27);
         assert_eq!(

src/test/configuration_snippet.rs

@@ -95,12 +95,14 @@ impl ConfigCodeBlock {
 
     fn get_block_config(&self) -> Config {
         let mut config = Config::default();
-        config.set().verbose(Verbosity::Quiet);
+        config.set_verbose(Verbosity::Quiet);
         if self.config_name.is_some() && self.config_value.is_some() {
-            config.override_value(
-                self.config_name.as_ref().unwrap(),
-                self.config_value.as_ref().unwrap(),
-            );
+            config
+                .override_value(
+                    self.config_name.as_ref().unwrap(),
+                    self.config_value.as_ref().unwrap(),
+                )
+                .unwrap();
         }
         config
     }
@@ -184,7 +186,7 @@ impl ConfigCodeBlock {
 
         let input = Input::Text(self.code_block.as_ref().unwrap().to_owned());
         let mut config = self.get_block_config();
-        config.set().emit_mode(EmitMode::Stdout);
+        config.set_emit_mode(EmitMode::Stdout);
         let mut buf: Vec<u8> = vec![];
 
         {
@@ -210,7 +212,7 @@ impl ConfigCodeBlock {
     fn extract<I: Iterator<Item = String>>(
         file: &mut Enumerate<I>,
         prev: Option<&ConfigCodeBlock>,
-        hash_set: &mut HashSet<String>,
+        hash_set: &mut HashSet<&str>,
     ) -> Option<ConfigCodeBlock> {
         let mut code_block = ConfigCodeBlock::new();
         code_block.config_name = prev.and_then(|cb| cb.config_name.clone());
@@ -228,7 +230,7 @@ impl ConfigCodeBlock {
                         name
                     );
                     assert!(
-                        hash_set.remove(&name),
+                        hash_set.remove(name.as_str()),
                         "multiple configuration guides found for option {}",
                         name
                     );

src/test/mod.rs

@@ -413,8 +413,8 @@ fn stdin_works_with_modified_lines() {
 
     let input = Input::Text(input.to_owned());
     let mut config = Config::default();
-    config.set().newline_style(NewlineStyle::Unix);
-    config.set().emit_mode(EmitMode::ModifiedLines);
+    config.set_newline_style(NewlineStyle::Unix);
+    config.set_emit_mode(EmitMode::ModifiedLines);
     let mut buf: Vec<u8> = vec![];
     {
         let mut session = Session::new(config, Some(&mut buf));
@@ -463,7 +463,7 @@ fn format_lines_errors_are_reported() {
     let long_identifier = String::from_utf8(vec![b'a'; 239]).unwrap();
     let input = Input::Text(format!("fn {}() {{}}", long_identifier));
     let mut config = Config::default();
-    config.set().error_on_line_overflow(true);
+    config.set_error_on_line_overflow(true);
     let mut session = Session::<io::Stdout>::new(config, None);
     session.format(input).unwrap();
     assert!(session.has_formatting_errors());
@@ -475,8 +475,8 @@ fn format_lines_errors_are_reported_with_tabs() {
     let long_identifier = String::from_utf8(vec![b'a'; 97]).unwrap();
     let input = Input::Text(format!("fn a() {{\n\t{}\n}}", long_identifier));
     let mut config = Config::default();
-    config.set().error_on_line_overflow(true);
-    config.set().hard_tabs(true);
+    config.set_error_on_line_overflow(true);
+    config.set_hard_tabs(true);
     let mut session = Session::<io::Stdout>::new(config, None);
     session.format(input).unwrap();
     assert!(session.has_formatting_errors());