style: add semicolon at the end of expressions used as statements

Cargo.toml

···
 
 [workspace.lints.clippy]
 explicit_iter_loop = "warn"
+semicolon_if_nothing_returned = "warn"
 uninlined_format_args = "warn"
  
 # Insta suggests compiling these packages in opt mode for faster testing.

cli/src/cli_util.rs

···
             .modify(|filter| {
                 *filter = tracing_subscriber::EnvFilter::builder()
                     .with_default_directive(tracing::metadata::LevelFilter::DEBUG.into())
-                    .from_env_lossy()
+                    .from_env_lossy();
             })
             .map_err(|err| internal_error_with_message("failed to enable debug logging", err))?;
         tracing::info!("debug logging enabled");

cli/src/commands/config/set.rs

···
             AuthorChange::Email => &author.email,
         };
         if new_value.as_str() != Some(orig_value) {
-            warn_wc_author(ui, &author.name, &author.email)?
+            warn_wc_author(ui, &author.name, &author.email)?;
         }
     }
     Ok(())

cli/src/commands/init.rs

···
             ui.warning_default(),
             "`--git` and `--git-repo` are deprecated.
 Use `jj git init` instead"
-        )?
+        )?;
     } else {
         if !command.settings().allow_native_backend() {
             return Err(user_error_with_hint(

cli/src/commands/operation/abandon.rs

···
         let mut locked_ws = workspace.start_working_copy_mutation()?;
         let old_op_id = locked_ws.locked_wc().old_operation_id();
         if let Some((_, new_id)) = reparented_head_ops().find(|(old, _)| old.id() == old_op_id) {
-            locked_ws.finish(new_id.clone())?
+            locked_ws.finish(new_id.clone())?;
         } else {
             writeln!(
                 ui.warning_default(),

cli/src/commands/status.rs

···
                 formatter.labeled("conflict"),
                 "There are unresolved conflicts at these paths:"
             )?;
-            print_conflicted_paths(&conflicts, formatter, &workspace_command)?
+            print_conflicted_paths(&conflicts, formatter, &workspace_command)?;
         }
 
         let template = workspace_command.commit_summary_template();

cli/src/config.rs

···
         .add_source(from_toml!("config/revsets.toml"))
         .add_source(from_toml!("config/templates.toml"));
     if cfg!(unix) {
-        builder = builder.add_source(from_toml!("config/unix.toml"))
+        builder = builder.add_source(from_toml!("config/unix.toml"));
     }
     if cfg!(windows) {
-        builder = builder.add_source(from_toml!("config/windows.toml"))
+        builder = builder.add_source(from_toml!("config/windows.toml"));
     }
     builder.build().unwrap()
 }

cli/src/diff_util.rs

···
         match token_type {
             DiffTokenType::Matching => formatter.write_all(content)?,
             DiffTokenType::Different => {
-                formatter.with_label("token", |formatter| formatter.write_all(content))?
+                formatter.with_label("token", |formatter| formatter.write_all(content))?;
             }
         }
     }
···
                     CopyOperation::Rename => ("renamed", "R"),
                 };
                 let path = path_converter.format_copied_path(before_path, after_path);
-                writeln!(formatter.labeled(label), "{sigil} {path}")?
+                writeln!(formatter.labeled(label), "{sigil} {path}")?;
             } else {
                 let path = path_converter.format_file_path(after_path);
                 match (before.is_present(), after.is_present()) {

cli/src/formatter.rs

···
     fn pop_label(&mut self) -> io::Result<()> {
         self.labels.pop();
         if self.labels.is_empty() {
-            self.write_new_style()?
+            self.write_new_style()?;
         }
         Ok(())
     }

cli/src/merge_tools/builtin.rs

···
                         .split_inclusive('\n')
                         .map(|line| Cow::Owned(line.to_owned()))
                         .collect(),
-                })
+                });
             }
             DiffHunk::Different(sides) => {
                 assert_eq!(sides.len(), 2, "only two inputs were provided to the diff");
···
                         make_section_changed_lines(right_side, scm_record::ChangeType::Added),
                     ]
                     .concat(),
-                })
+                });
             }
         }
     }
···
                     is_checked: false,
                     old_description: None,
                     new_description: Some(Cow::Owned(describe_binary(hash.as_deref(), num_bytes))),
-                })
+                });
             }
 
             (
···
                     is_checked: false,
                     old_description: Some(Cow::Owned(describe_binary(hash.as_deref(), num_bytes))),
                     new_description: None,
-                })
+                });
             }
         }
 
···
                         executable: file.get_file_mode()
                             == Some(scm_record::FileMode(mode::EXECUTABLE)),
                     }),
-                )
+                );
             }
         }
     }

cli/src/movement_util.rs

···
                     write!(formatter, "Working copy parent: ")?;
                 }
                 template.format(commit, formatter)
-            })
+            });
         });
 
         cmd_err

cli/src/templater.rs

···
 impl<T: Template> Template for ConcatTemplate<T> {
     fn format(&self, formatter: &mut TemplateFormatter) -> io::Result<()> {
         for template in &self.0 {
-            template.format(formatter)?
+            template.format(formatter)?;
         }
         Ok(())
     }

cli/tests/test_git_colocated.rs

···
     let git_check_out_ref = |name| {
         git_repo
             .set_head_detached(git_repo.find_reference(name).unwrap().target().unwrap())
-            .unwrap()
+            .unwrap();
     };
 
     test_env.jj_cmd_ok(&repo_path, &["git", "init", "--git-repo=."]);

cli/tests/test_log_command.rs

···
     insta::assert_debug_snapshot!(
         stdout,
         @r###""commit 3 line 1\n\ncommit 3 line 2\n\0commit 2 line 1\n\ncommit 2 line 2\n\0commit 1 line 1\n\ncommit 1 line 2\n\0""###
-    )
+    );
 }
 
 #[test]

cli/tests/test_next_prev_commands.rs

···
     Hint: Working copy parent: mzvwutvl bc4f4fe3 (empty) third
     Hint: Working copy parent: kkmpptxz b0d21db3 (empty) second
     Hint: Working copy parent: qpvuntsm fa15625b (empty) first
-    "###)
+    "###);
 }
 
 #[test]

cli/tests/test_parallelize_command.rs

···
     │ ○  14ca4df576b3 4 parents:
     ├─╯
     ◆  000000000000 parents:
-    "###)
+    "###);
 }
 
 fn get_log_output(test_env: &TestEnvironment, cwd: &Path) -> String {

cli/tests/test_util_command.rs

···
                 [...]
             }
         }
-        "###)
+        "###);
     });
 }
 

lib/benches/diff_bench.rs

···
 }
 "##,
             ])
-        })
+        });
     });
 }
 

lib/src/commit.rs

···
 
 impl Hash for Commit {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state)
+        self.id.hash(state);
     }
 }
 

lib/src/content_hash.rs

···
 
 impl<T: ContentHash> ContentHash for Vec<T> {
     fn hash(&self, state: &mut impl DigestUpdate) {
-        self.as_slice().hash(state)
+        self.as_slice().hash(state);
     }
 }
 
···
             None => state.update(&0u32.to_le_bytes()),
             Some(x) => {
                 state.update(&1u32.to_le_bytes());
-                x.hash(state)
+                x.hash(state);
             }
         }
     }

lib/src/default_index/entry.rs

···
 
 impl Hash for IndexEntry<'_> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.pos.hash(state)
+        self.pos.hash(state);
     }
 }
 

lib/src/default_index/revset_graph_iterator.rs

···
                         parent_edges
                             .iter()
                             .filter(|edge| known_ancestors.insert(edge.target)),
-                    )
+                    );
                 }
             }
         }

lib/src/default_index/store.rs

···
                     change_id_length,
                 )?;
                 maybe_parent_file = Some(parent_file.clone());
-                mutable_index = DefaultMutableIndex::incremental(parent_file)
+                mutable_index = DefaultMutableIndex::incremental(parent_file);
             }
         }
 

lib/src/diff.rs

···
 
     #[test]
     fn test_find_word_ranges_multibyte() {
-        assert_eq!(find_word_ranges("⊢".as_bytes()), vec![0..3])
+        assert_eq!(find_word_ranges("⊢".as_bytes()), vec![0..3]);
     }
 
     #[test]

lib/src/fileset.rs

···
                     FilePattern::FilePath(path) => file_paths.push(path),
                     FilePattern::PrefixPath(path) => prefix_paths.push(path),
                     FilePattern::FileGlob { dir, pattern } => {
-                        file_globs.push((dir, pattern.clone()))
+                        file_globs.push((dir, pattern.clone()));
                     }
                 }
                 continue;

lib/src/git.rs

···
             // TODO Git warns when a duplicate config entry is found, we should
             // consider doing the same.
             ("path", PartialSubmoduleConfig { path: None, .. }) => {
-                map_entry.path = Some(config_value.to_string())
+                map_entry.path = Some(config_value.to_string());
             }
             ("url", PartialSubmoduleConfig { url: None, .. }) => {
-                map_entry.url = Some(config_value.to_string())
+                map_entry.url = Some(config_value.to_string());
             }
             _ => (),
         };

lib/src/graph.rs

···
                 reverse_edges.entry(target).or_default().push(GraphEdge {
                     target: node.clone(),
                     edge_type,
-                })
+                });
             }
             entries.push(node);
         }

lib/src/local_backend.rs

···
 fn conflict_from_proto(proto: crate::protos::local_store::Conflict) -> Conflict {
     let mut conflict = Conflict::default();
     for term in proto.removes {
-        conflict.removes.push(conflict_term_from_proto(term))
+        conflict.removes.push(conflict_term_from_proto(term));
     }
     for term in proto.adds {
-        conflict.adds.push(conflict_term_from_proto(term))
+        conflict.adds.push(conflict_term_from_proto(term));
     }
     conflict
 }

lib/src/merge.rs

···
 
 impl<T> Extend<T> for MergeBuilder<T> {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        self.values.extend(iter)
+        self.values.extend(iter);
     }
 }
 
···
 
 impl<T: ContentHash> ContentHash for Merge<T> {
     fn hash(&self, state: &mut impl DigestUpdate) {
-        self.values.hash(state)
+        self.values.hash(state);
     }
 }
 

lib/src/operation.rs

···
 
 impl Hash for Operation {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state)
+        self.id.hash(state);
     }
 }
 

lib/src/simple_op_heads_store.rs

···
         assert!(!old_ids.contains(new_id));
         self.add_op_head(new_id);
         for old_id in old_ids {
-            self.remove_op_head(old_id)
+            self.remove_op_head(old_id);
         }
     }
 

lib/tests/test_bad_locking.rs

···
         let base_name = child_src.file_name().unwrap();
         let child_dst = dst.join(base_name);
         if child_src.is_dir() {
-            copy_directory(&child_src, &child_dst)
+            copy_directory(&child_src, &child_dst);
         } else {
             std::fs::copy(&child_src, &child_dst).unwrap();
         }

lib/tests/test_conflicts.rs

···
             2
         ),
         None
-    )
+    );
 }
 
 #[test]
···
             2
         ),
         @"None"
-    )
+    );
 }
 
 #[test]
···
             3
         ),
         None
-    )
+    );
 }
 
 #[test]
···
             2
         ),
         None
-    )
+    );
 }
 
 #[test]
···
             2
         ),
         None
-    )
+    );
 }
 
 #[test]
···
             2
         ),
         None
-    )
+    );
 }
 
 #[test]

lib/tests/test_index.rs

···
         // u32: number of local change ids
         // u32: number of overflow parent entries
         // u32: number of overflow change id positions
-        fs::write(entry.path(), b"\0".repeat(24)).unwrap()
+        fs::write(entry.path(), b"\0".repeat(24)).unwrap();
     }
 
     let repo = load_repo_at_head(&settings, test_repo.repo_path());

lib/tests/test_merged_tree.rs

···
             vec![expected_base1],
             vec![expected_side1, expected_side2]
         ))
-    )
+    );
 }
 
 #[test]