Remove some .expect() (#1495)

Author: j178

.github/workflows/performance.yml

@@ -20,7 +20,7 @@ env:
 jobs:
   bloat-check:
     runs-on: ubuntu-latest
-    name: "cargo | bloat check"
+    name: "bloat check"
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

crates/prek/src/hook.rs

@@ -254,24 +254,6 @@ impl HookBuilder {
         }
     }
 
-    /// Fill in the default values for the hook configuration.
-    fn fill_in_defaults(&mut self) {
-        let options = &mut self.hook_spec.options;
-        options.language_version.get_or_insert_default();
-        options.alias.get_or_insert_default();
-        options.args.get_or_insert_default();
-        options.env.get_or_insert_default();
-        options.types.get_or_insert(vec!["file".to_string()]);
-        options.types_or.get_or_insert_default();
-        options.exclude_types.get_or_insert_default();
-        options.always_run.get_or_insert(false);
-        options.fail_fast.get_or_insert(false);
-        options.pass_filenames.get_or_insert(true);
-        options.require_serial.get_or_insert(false);
-        options.verbose.get_or_insert(false);
-        options.additional_dependencies.get_or_insert_default();
-    }
-
     /// Check the hook configuration.
     fn check(&self) -> Result<(), Error> {
         let language = self.hook_spec.language;
@@ -332,10 +314,26 @@ impl HookBuilder {
         self.hook_spec.apply_project_defaults(self.project.config());
 
         self.check()?;
-        self.fill_in_defaults();
 
         let options = self.hook_spec.options;
-        let language_version = options.language_version.expect("language_version not set");
+        let language_version = options.language_version.unwrap_or_default();
+        let alias = options.alias.unwrap_or_default();
+        let args = options.args.unwrap_or_default();
+        let env = options.env.unwrap_or_default();
+        let types = options.types.unwrap_or_else(|| vec!["file".to_string()]);
+        let types_or = options.types_or.unwrap_or_default();
+        let exclude_types = options.exclude_types.unwrap_or_default();
+        let always_run = options.always_run.unwrap_or_default();
+        let fail_fast = options.fail_fast.unwrap_or_default();
+        let pass_filenames = options.pass_filenames.unwrap_or(true);
+        let require_serial = options.require_serial.unwrap_or(false);
+        let verbose = options.verbose.unwrap_or(false);
+        let additional_dependencies = options
+            .additional_dependencies
+            .unwrap_or_default()
+            .into_iter()
+            .collect::<FxHashSet<_>>();
+
         let language_request = LanguageRequest::parse(self.hook_spec.language, &language_version)
             .map_err(|e| Error::Hook {
             hook: self.hook_spec.id.clone(),
@@ -344,12 +342,6 @@ impl HookBuilder {
 
         let entry = Entry::new(self.hook_spec.id.clone(), self.hook_spec.entry);
 
-        let additional_dependencies = options
-            .additional_dependencies
-            .expect("additional_dependencies should not be None")
-            .into_iter()
-            .collect::<FxHashSet<_>>();
-
         let stages = match options.stages {
             Some(stages) => {
                 let stages: FxHashSet<_> = stages.into_iter().collect();
@@ -368,34 +360,35 @@ impl HookBuilder {
             .unwrap_or(u32::try_from(self.idx).expect("idx too large"));
 
         let mut hook = Hook {
-            entry,
-            stages,
-            language_request,
-            additional_dependencies,
             dependencies: OnceLock::new(),
             project: self.project,
             repo: self.repo,
             idx: self.idx,
             id: self.hook_spec.id,
             name: self.hook_spec.name,
             language: self.hook_spec.language,
-            alias: options.alias.expect("alias not set"),
+
+            priority,
+            entry,
+            stages,
+            language_request,
+            additional_dependencies,
+            alias,
+            types,
+            types_or,
+            exclude_types,
+            args,
+            env,
+            always_run,
+            fail_fast,
+            pass_filenames,
+            require_serial,
+            verbose,
             files: options.files,
             exclude: options.exclude,
-            types: options.types.expect("types not set"),
-            types_or: options.types_or.expect("types_or not set"),
-            exclude_types: options.exclude_types.expect("exclude_types not set"),
-            args: options.args.expect("args not set"),
-            env: options.env.expect("env not set"),
-            always_run: options.always_run.expect("always_run not set"),
-            fail_fast: options.fail_fast.expect("fail_fast not set"),
-            pass_filenames: options.pass_filenames.expect("pass_filenames not set"),
             description: options.description,
             log_file: options.log_file,
-            require_serial: options.require_serial.expect("require_serial not set"),
-            verbose: options.verbose.expect("verbose not set"),
             minimum_prek_version: options.minimum_prek_version,
-            priority,
         };
 
         if let Err(err) = extract_metadata_from_entry(&mut hook).await {
@@ -754,6 +747,14 @@ impl InstalledHook {
         }
     }
 
+    /// Get the directory the toolchain is installed in.
+    pub(crate) fn toolchain_dir(&self) -> Option<&Path> {
+        match self {
+            InstalledHook::Installed { info, .. } => info.toolchain.parent(),
+            InstalledHook::NoNeedInstall(_) => None,
+        }
+    }
+
     /// Get the install info of the hook if it is installed.
     pub(crate) fn install_info(&self) -> Option<&InstallInfo> {
         match self {

crates/prek/src/languages/bun/bun.rs

@@ -126,13 +126,7 @@ impl LanguageImpl for Bun {
         let progress = reporter.on_run_start(hook, filenames.len());
 
         let env_dir = hook.env_path().expect("Bun must have env path");
-        let info = hook
-            .install_info()
-            .expect("Bun hook must have install info");
-        let bun_bin = info
-            .toolchain
-            .parent()
-            .expect("Bun binary must have parent");
+        let bun_bin = hook.toolchain_dir().expect("Bun binary must have parent");
         let new_path =
             prepend_paths(&[&bin_dir(env_dir), bun_bin]).context("Failed to join PATH")?;
 

crates/prek/src/languages/golang/golang.rs

@@ -127,11 +127,10 @@ impl LanguageImpl for Golang {
         let progress = reporter.on_run_start(hook, filenames.len());
 
         let env_dir = hook.env_path().expect("Node hook must have env path");
-        let info = hook.install_info().expect("Node hook must be installed");
 
         let go_bin = bin_dir(env_dir);
         let go_tools = store.tools_path(ToolBucket::Go);
-        let go_root_bin = info.toolchain.parent().expect("Go root should exist");
+        let go_root_bin = hook.toolchain_dir().expect("Go root should exist");
         let go_root = go_root_bin.parent().expect("Go root should exist");
         let go_cache = store.cache_path(CacheBucket::Go);
 

crates/prek/src/languages/node/node.rs

@@ -143,13 +143,7 @@ impl LanguageImpl for Node {
         let progress = reporter.on_run_start(hook, filenames.len());
 
         let env_dir = hook.env_path().expect("Node must have env path");
-        let info = hook
-            .install_info()
-            .expect("Node hook must have install info");
-        let node_bin = info
-            .toolchain
-            .parent()
-            .expect("Node binary must have parent");
+        let node_bin = hook.toolchain_dir().expect("Node binary must have parent");
         let new_path =
             prepend_paths(&[&bin_dir(env_dir), node_bin]).context("Failed to join PATH")?;
 

crates/prek/src/languages/ruby/ruby.rs

@@ -148,14 +148,12 @@ impl LanguageImpl for Ruby {
         let progress = reporter.on_run_start(hook, filenames.len());
 
         let env_dir = hook.env_path().expect("Ruby hook must have env path");
-        let info = hook.install_info().expect("Ruby hook must be installed");
 
         // Prepare PATH
         let gem_home = gem_home(env_dir);
         let gem_bin = gem_home.join("bin");
-        let ruby_bin = info
-            .toolchain
-            .parent()
+        let ruby_bin = hook
+            .toolchain_dir()
             .expect("Ruby toolchain should have parent");
 
         let new_path = prepend_paths(&[&gem_bin, ruby_bin]).context("Failed to join PATH")?;