Streamline format

src/check/context/clss/generic.rs

@@ -160,7 +160,7 @@ impl TryFrom<&AST> for GenericClass {
                     })
                     .flat_map(|(pos, parent)| {
                         if temp_parents.contains(&parent) {
-                            Some((pos, format!("Duplicate parent: {}", parent)))
+                            Some((pos, format!("Duplicate parent: {parent}")))
                         } else {
                             temp_parents.insert(parent);
                             None
@@ -178,10 +178,8 @@ impl TryFrom<&AST> for GenericClass {
                     if class_args.is_empty() {
                         class_args.append(&mut function.arguments.clone())
                     } else {
-                        return Err(vec![TypeErr::new(
-                            class.pos,
-                            "Cannot have constructor and class arguments",
-                        )]);
+                        let msg = "Cannot have constructor and class arguments";
+                        return Err(vec![TypeErr::new(class.pos, &msg)]);
                     }
                 }
 
@@ -298,8 +296,7 @@ fn get_fields_and_functions(
 
                 for generic_field in &stmt_fields {
                     if generic_field.ty.is_none() {
-                        let msg =
-                            format!("Class field '{}' was not assigned a type", generic_field.name);
+                        let msg = format!("Class field '{}' was not assigned a type", generic_field.name);
                         return Err(vec![TypeErr::new(generic_field.pos, &msg)]);
                     }
                 }

src/check/context/clss/union.rs

@@ -54,7 +54,7 @@ impl GetField<FieldUnion> for ClassUnion {
             self.union.iter().map(|c| c.field(name, ctx, pos)).collect::<Result<_, _>>()?;
 
         if union.is_empty() {
-            let msg = format!("'{}' does not define attribute '{}'", Name::from(self), name);
+            let msg = format!("'{}' does not define attribute '{name}'", Name::from(self));
             return Err(vec![TypeErr::new(pos, &msg)]);
         }
 
@@ -69,7 +69,7 @@ impl GetFun<FunUnion> for ClassUnion {
             self.union.iter().map(|c| c.fun(name, ctx, pos)).collect::<Result<_, _>>()?;
 
         if union.is_empty() {
-            let msg = format!("'{}' does not define function '{}'", Name::from(self), name);
+            let msg = format!("'{}' does not define function '{name}'", Name::from(self));
             return Err(vec![TypeErr::new(pos, &msg)]);
         }
         Ok(FunUnion::from(&union))
@@ -137,7 +137,7 @@ impl LookupClass<&Name, ClassUnion> for Context {
     /// If NameUnion is empty.
     fn class(&self, name: &Name, pos: Position) -> TypeResult<ClassUnion> {
         if name.is_empty() {
-            return Err(vec![TypeErr::new(pos, &format!("Unexpected '{}'", name))]);
+            return Err(vec![TypeErr::new(pos, &format!("Unexpected '{name}'"))]);
         }
 
         let union = name.names.iter().map(|n| self.class(n, pos)).collect::<Result<_, _>>()?;

src/check/context/field/mod.rs

@@ -31,7 +31,7 @@ pub struct Field {
 impl Display for Field {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         let ty = if self.ty.is_empty() { String::new() } else { format!(": {}", self.ty) };
-        write!(f, "{}{}", &self.name, ty)
+        write!(f, "{}{ty}", &self.name)
     }
 }
 
@@ -42,7 +42,7 @@ impl LookupField<&str, Field> for Context {
             let generics = HashMap::new();
             Field::try_from((generic_field, &generics, pos))
         } else {
-            let msg = format!("Field {} is undefined.", field);
+            let msg = format!("Field {field} is undefined.");
             Err(vec![TypeErr::new(pos, &msg)])
         }
     }

src/check/context/field/union.rs

@@ -51,7 +51,7 @@ impl TryFromPos<&FieldUnion> for Field {
         if field_union.union.len() == (1_usize) {
             Ok(field_union.union.iter().next().unwrap().clone())
         } else {
-            let msg = format!("Expected single field but was {}", field_union);
+            let msg = format!("Expected single field but was {field_union}");
             Err(vec![TypeErr::new(pos, &msg)])
         }
     }

src/check/context/function/generic.rs

@@ -85,11 +85,8 @@ impl TryFrom<&AST> for GenericFunction {
                         let mut has_default = false;
                         for arg in args.clone() {
                             if has_default && !arg.has_default {
-                                return Err(vec![TypeErr::new(
-                                    arg.pos,
-                                    "Cannot have argument with default followed by argument with \
-                                     no default.",
-                                )]);
+                                let msg = "Cannot have argument with default followed by argument with no default.";
+                                return Err(vec![TypeErr::new(arg.pos, &msg)]);
                             }
                             has_default = arg.has_default;
                         }

src/check/context/function/union.rs

@@ -51,7 +51,7 @@ impl TryFromPos<&FunUnion> for Function {
         if fun_union.union.len() == (1_usize) {
             Ok(fun_union.union.iter().next().unwrap().clone())
         } else {
-            let msg = format!("Expected single function but was {}", fun_union);
+            let msg = format!("Expected single function but was {fun_union}");
             Err(vec![TypeErr::new(pos, &msg)])
         }
     }

src/check/context/parameter/generic.rs

@@ -16,11 +16,7 @@ impl Display for GenericParameter {
             f,
             "{}{}",
             self.name,
-            if let Some(parent) = &self.parent {
-                format!(" isa {}", parent)
-            } else {
-                String::new()
-            }
+            if let Some(parent) = &self.parent { format!(" isa {parent}") } else { String::new() }
         )
     }
 }