Merge branch 'main' into chore/lint

lib/app/src/build/error.rs

@@ -24,8 +24,7 @@ impl std::fmt::Display for BuildError {
         match self {
             Self::ExternalPackageConfigurationFileNotFound { package_name } => write!(
                 formatter,
-                "package configuration file not found in external package \"{}\"",
-                package_name
+                "package configuration file not found in external package \"{package_name}\""
             ),
             Self::MainFunctionModuleNotFound {
                 main_function_module_name,
@@ -38,17 +37,15 @@ impl std::fmt::Display for BuildError {
             ),
             Self::ModuleCircularDependency(file_path) => write!(
                 formatter,
-                "circular module dependency detected: {}",
-                file_path
+                "circular module dependency detected: {file_path}"
             ),
             Self::ModuleNotFound {
                 module_path,
                 source_file_path,
             } => {
                 write!(
                     formatter,
-                    "module \"{}\" not found imported by \"{}\"",
-                    module_path, source_file_path
+                    "module \"{module_path}\" not found imported by \"{source_file_path}\""
                 )
             }
             Self::PackageCircularDependency(external_package) => write!(

lib/app/src/common/file_path.rs

@@ -27,7 +27,7 @@ impl FilePath {
         let replacement = if extension.is_empty() {
             "".into()
         } else {
-            format!(".{}", extension)
+            format!(".{extension}")
         };
 
         Self::new(self.components().take(self.components.len() - 1).chain(

lib/app/src/infra/file_path_displayer.rs

@@ -18,6 +18,6 @@ impl FakeFilePathDisplayer {
 #[cfg(test)]
 impl FilePathDisplayer for FakeFilePathDisplayer {
     fn display(&self, file_path: &FilePath) -> String {
-        format!("{}", file_path)
+        format!("{file_path}")
     }
 }

lib/app/src/infra/file_system.rs

@@ -47,7 +47,7 @@ impl FileSystem for FakeFileSystem {
         directory_path: &FilePath,
     ) -> Result<Option<Repository>, Box<dyn std::error::Error>> {
         Ok(Some(Repository::new(
-            url::Url::parse(&format!("{}", directory_path))?,
+            url::Url::parse(&format!("{directory_path}"))?,
             "v1",
         )))
     }

lib/infra/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 [dependencies]
 app = { path = "../app" }
 lang = { path = "../lang" }
-git2 = "0.16"
+git2 = "0.17"
 termcolor = "1"
 url = "2"
 which = "4"

lib/infra/src/error.rs

@@ -45,7 +45,7 @@ impl Display for InfrastructureError {
         match self {
             Self::CommandExit { status_code } => match status_code {
                 Some(status_code) => {
-                    write!(formatter, "command exited with status code {}", status_code)
+                    write!(formatter, "command exited with status code {status_code}")
                 }
                 None => write!(formatter, "command exited without status code"),
             },

lib/infra/src/logger.rs

@@ -24,7 +24,7 @@ impl Logger {
         writeln!(
             &mut stderr,
             ": {}",
-            format!("{}", error).replace('\n', "\n  ").trim()
+            format!("{error}").replace('\n', "\n  ").trim()
         )?;
 
         if let Some(error) = error.source() {
@@ -43,7 +43,7 @@ impl app::Logger for Logger {
         write!(&mut stderr, "info")?;
         stderr.set_color(ColorSpec::new().set_fg(None))?;
 
-        writeln!(&mut stderr, ": {}", log)?;
+        writeln!(&mut stderr, ": {log}")?;
 
         Ok(())
     }

lib/lang/src/compile/error.rs

@@ -29,27 +29,23 @@ impl Display for CompileError {
         match self {
             Self::AnyEqualOperation(source_information) => write!(
                 formatter,
-                "cannot compare Any type values\n{}",
-                source_information
+                "cannot compare Any type values\n{source_information}"
             ),
             Self::CaseArgumentTypeInvalid(source_information) => write!(
                 formatter,
-                "invalid argument type of case expression\n{}",
-                source_information
+                "invalid argument type of case expression\n{source_information}"
             ),
             Self::ExportedNameNotFound { name } => {
-                write!(formatter, "exported name \"{}\" not found", name)
+                write!(formatter, "exported name \"{name}\" not found")
             }
             Self::DuplicateNames(one, other) => {
-                write!(formatter, "duplicate names\n{}\n{}", one, other)
+                write!(formatter, "duplicate names\n{one}\n{other}")
+            }
+            Self::FunctionEqualOperation(source_information) => {
+                write!(formatter, "cannot compare functions\n{source_information}")
             }
-            Self::FunctionEqualOperation(source_information) => write!(
-                formatter,
-                "cannot compare functions\n{}",
-                source_information
-            ),
             Self::FunctionExpected(source_information) => {
-                write!(formatter, "function expected\n{}", source_information)
+                write!(formatter, "function expected\n{source_information}")
             }
             Self::MainFunctionNotFound(path) => write!(
                 formatter,
@@ -64,11 +60,10 @@ impl Display for CompileError {
             ),
             Self::RecordEqualOperation(source_information) => write!(
                 formatter,
-                "cannot compare records including functions or Any values\n{}",
-                source_information
+                "cannot compare records including functions or Any values\n{source_information}"
             ),
             Self::EirFmmCompile(error) => {
-                write!(formatter, "failed to compile eir to fmm: {:?}", error)
+                write!(formatter, "failed to compile eir to fmm: {error:?}")
             }
             Self::TypeNotFound(reference) => write!(
                 formatter,
@@ -77,12 +72,11 @@ impl Display for CompileError {
                 reference.source_information()
             ),
             Self::TypeNotInferred(source_information) => {
-                write!(formatter, "failed to infer type\n{}", source_information)
+                write!(formatter, "failed to infer type\n{source_information}")
             }
             Self::TypesNotMatched(lhs_source_information, rhs_source_information) => write!(
                 formatter,
-                "types not matched\n{}\n{}",
-                lhs_source_information, rhs_source_information
+                "types not matched\n{lhs_source_information}\n{rhs_source_information}"
             ),
             Self::VariableNotFound(variable) => write!(
                 formatter,

lib/lang/src/compile/module_compiler.rs

@@ -162,7 +162,7 @@ impl ModuleCompiler {
         body: &Expression,
         function_type: &eir::types::Function,
     ) -> Result<Vec<eir::ir::Definition>, CompileError> {
-        let thunk_name = format!("{}.thunk", name);
+        let thunk_name = format!("{name}.thunk");
         const ARGUMENT_NAME: &str = "$arg";
 
         Ok(vec![

lib/lang/src/parse/error.rs

@@ -10,7 +10,7 @@ impl ParseError {
     pub fn new(source_name: &str, errors: &impl std::error::Error) -> Self {
         Self {
             source_name: source_name.into(),
-            details: format!("{}", errors),
+            details: format!("{errors}"),
         }
     }
 }

lib/lang/src/path/unresolved_module_path.rs

@@ -25,8 +25,8 @@ impl From<InternalUnresolvedModulePath> for UnresolvedModulePath {
 impl std::fmt::Display for UnresolvedModulePath {
     fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            Self::External(external_module_path) => write!(formatter, "{}", external_module_path),
-            Self::Internal(internal_module_path) => write!(formatter, "{}", internal_module_path),
+            Self::External(external_module_path) => write!(formatter, "{external_module_path}"),
+            Self::Internal(internal_module_path) => write!(formatter, "{internal_module_path}"),
         }
     }
 }