fix clippy warnings

src/hl/engine.rs

@@ -137,10 +137,10 @@ impl Engine {
                 identifier: &str,
             ) -> Gc<DispatchTable> {
                 let fields = identifier.split('+').enumerate().map(|(index, name)| (name, index));
-                let type_name = if identifier.len() == 0 {
+                let type_name = if identifier.is_empty() {
                     String::from("Record{}")
                 } else {
-                    format!("Record{{{}}}", identifier.replace("+", ", "))
+                    format!("Record{{{}}}", identifier.replace('+', ", "))
                 };
                 self.corelib
                     .define_record(fields, TypeBuilder::new(type_name))

src/hl/value.rs

@@ -170,9 +170,7 @@ pub mod into_value {
     impl EngineUse for DoesNotUseEngine {
         type EngineState<'a> = ();
 
-        fn change_type<'a>(_: &Library, _: &mut Memory) -> Self::EngineState<'static> {
-            ()
-        }
+        fn change_type<'a>(_: &Library, _: &mut Memory) -> Self::EngineState<'static> {}
     }
 }
 

src/ll/bytecode/library.rs

@@ -93,7 +93,7 @@ impl Library {
             );
             self.builtin_dtables.records.push(Rc::new(RecordType {
                 dtable,
-                identifier: Rc::clone(&identifier),
+                identifier: Rc::clone(identifier),
                 field_count: if identifier.len() > 0 {
                     identifier.chars().filter(|&c| c == '+').count() + 1
                 } else {
@@ -112,7 +112,7 @@ pub fn make_record_identifier<'a>(fields: impl Iterator<Item = &'a str>) -> Rc<s
     let mut identifier = fields.fold(String::new(), |mut a, b| {
         a.reserve(b.len() + 1);
         a.push_str(b);
-        a.push_str("+");
+        a.push('+');
         a
     });
     identifier.pop();

src/ll/codegen/tuples.rs

@@ -66,7 +66,7 @@ impl<'e> CodeGenerator<'e> {
         let identifier = make_record_identifier(fields.iter().map(|&rc| rc.deref()));
         let record_type_index = self
             .library
-            .get_or_generate_record(&mut self.env, &mut self.gc, &identifier)
+            .get_or_generate_record(self.env, self.gc, &identifier)
             .map_err(|_| ast.error(node, LanguageErrorKind::TooManyRecords))?;
 
         self.chunk.emit((Opcode::CreateRecord, record_type_index.to_opr24()));
@@ -90,7 +90,12 @@ impl<'e> CodeGenerator<'e> {
         let is_non_exhaustive =
             !pairs.is_empty() && ast.kind(*pairs.last().unwrap()) == NodeKind::Rest;
 
-        fn destructure_member(generator: &mut CodeGenerator, ast: &Ast, key: NodeId, value: NodeId) -> Result<(), LanguageError> {
+        fn destructure_member(
+            generator: &mut CodeGenerator,
+            ast: &Ast,
+            key: NodeId,
+            value: NodeId,
+        ) -> Result<(), LanguageError> {
             let pattern = if value == NodeId::EMPTY { key } else { value };
             if ast.kind(pattern) == NodeKind::DiscardPattern {
                 generator.chunk.emit(Opcode::Discard);

src/ll/gc.rs

@@ -439,7 +439,7 @@ impl<T> GcRaw<T> {
 
 impl<T> Clone for GcRaw<T> {
     fn clone(&self) -> Self {
-        Self(self.0)
+        *self
     }
 }
 

src/ll/parser.rs

@@ -181,7 +181,7 @@ impl Parser {
             match &token.kind {
                 TokenKind::Eof => return Err(self.error(&token, LanguageErrorKind::UnexpectedEof)),
                 kind if is_end(kind) => {
-                    return Ok(self.lexer.next_token()?);
+                    return self.lexer.next_token();
                 }
                 _ => (),
             }

src/ll/value.rs

@@ -101,7 +101,7 @@ impl RawValue {
                 .to_owned()
                 .into(),
             ValueKind::UserData => unsafe {
-                self.0.get_raw_user_data_unchecked().get().type_name().into()
+                self.0.get_raw_user_data_unchecked().get().type_name()
             },
         }
     }

xtask/src/codegen/function_variants.rs

@@ -266,8 +266,7 @@ fn generate_variant(
         SelfMode::Disabled => None,
         SelfMode::Enabled { .. } => Some("arg_self".to_string()),
     };
-    let variable_list: Vec<_> =
-        self_variable.into_iter().chain(variable_list.into_iter()).collect();
+    let variable_list: Vec<_> = self_variable.into_iter().chain(variable_list).collect();
 
     let args = variable_list.join(", ");
     write!(