From 0bbf100eb261e6994b085a6da6d846b6ff718675 Mon Sep 17 00:00:00 2001
From: Andrew Morris <voltrevo@gmail.com>
Date: Tue, 16 Jul 2024 11:22:12 +0900
Subject: [PATCH] cargo clippy --fix

---
 valuescript_compiler/src/gather_modules.rs    |  4 +-
 valuescript_compiler/src/scope_analysis.rs    | 10 +--
 valuescript_vm/src/array_methods.rs           | 18 ++---
 valuescript_vm/src/bigint_methods.rs          |  2 +-
 valuescript_vm/src/builtins/array_builtin.rs  |  4 +-
 valuescript_vm/src/builtins/bigint_builtin.rs |  2 +-
 .../src/builtins/boolean_builtin.rs           |  2 +-
 valuescript_vm/src/builtins/error_builtin.rs  |  4 +-
 .../src/builtins/internal_error_builtin.rs    |  4 +-
 valuescript_vm/src/builtins/math_builtin.rs   | 68 +++++++++----------
 valuescript_vm/src/builtins/number_builtin.rs | 14 ++--
 .../src/builtins/range_error_builtin.rs       |  4 +-
 valuescript_vm/src/builtins/string_builtin.rs |  2 +-
 .../src/builtins/type_error_builtin.rs        |  4 +-
 valuescript_vm/src/number_methods.rs          |  6 +-
 valuescript_vm/src/string_methods.rs          | 26 +++----
 vstc/src/db_command.rs                        |  6 +-
 17 files changed, 90 insertions(+), 90 deletions(-)

diff --git a/valuescript_compiler/src/gather_modules.rs b/valuescript_compiler/src/gather_modules.rs
index abfdd626..15dc0e86 100644
--- a/valuescript_compiler/src/gather_modules.rs
+++ b/valuescript_compiler/src/gather_modules.rs
@@ -61,7 +61,7 @@ where
         // FIXME: This diagnostic should really be attached to the import statement
         gm.diagnostics
           .entry(dependency.path.clone())
-          .or_insert(vec![])
+          .or_default()
           .push(Diagnostic {
             level: DiagnosticLevel::Error,
             message: match dependency.reason {
@@ -82,7 +82,7 @@ where
 
     gm.diagnostics
       .entry(dependency.path.clone())
-      .or_insert(vec![])
+      .or_default()
       .append(&mut compiler_output.diagnostics);
 
     let path_and_module = PathAndModule {
diff --git a/valuescript_compiler/src/scope_analysis.rs b/valuescript_compiler/src/scope_analysis.rs
index 5295c79b..75dc55e7 100644
--- a/valuescript_compiler/src/scope_analysis.rs
+++ b/valuescript_compiler/src/scope_analysis.rs
@@ -180,7 +180,7 @@ impl ScopeAnalysis {
     self
       .reg_allocators
       .entry(scope.clone())
-      .or_insert_with(RegAllocator::default)
+      .or_default()
       .allocate(based_on_name)
   }
 
@@ -232,7 +232,7 @@ impl ScopeAnalysis {
     self
       .owners
       .entry(name.owner_id.clone())
-      .or_insert_with(HashSet::new)
+      .or_default()
       .insert(origin_ident.span);
 
     scope.set(
@@ -336,7 +336,7 @@ impl ScopeAnalysis {
     let inserted = self
       .captures
       .entry(captor_id.clone())
-      .or_insert_with(HashSet::new)
+      .or_default()
       .insert(name_id.clone());
 
     if inserted {
@@ -347,7 +347,7 @@ impl ScopeAnalysis {
         let reg = self
           .reg_allocators
           .entry(captor_id.clone())
-          .or_insert_with(RegAllocator::default)
+          .or_default()
           .allocate(&name.sym);
 
         self.capture_values.insert(key, Value::Register(reg));
@@ -1895,7 +1895,7 @@ impl ScopeAnalysis {
               let reg = self
                 .reg_allocators
                 .entry(captor.clone())
-                .or_insert_with(RegAllocator::default)
+                .or_default()
                 .allocate(&name.sym);
 
               Value::Register(reg)
diff --git a/valuescript_vm/src/array_methods.rs b/valuescript_vm/src/array_methods.rs
index 155add32..fe11ae0d 100644
--- a/valuescript_vm/src/array_methods.rs
+++ b/valuescript_vm/src/array_methods.rs
@@ -89,7 +89,7 @@ pub fn op_sub_array_index(array: &mut Rc<VsArray>, index: usize) -> Result<Val,
 
 static AT: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
-    Val::Array(array_data) => match to_wrapping_index(params.get(0), array_data.elements.len()) {
+    Val::Array(array_data) => match to_wrapping_index(params.first(), array_data.elements.len()) {
       None => Val::Undefined,
       Some(i) => array_data.elements[i].clone(),
     },
@@ -133,7 +133,7 @@ static COPY_WITHIN: NativeFunction = native_fn(|mut this, params| {
         return Err("TODO: array len exceeds isize".to_internal_error());
       }
 
-      let mut target = match params.get(0) {
+      let mut target = match params.first() {
         None => 0,
         Some(p) => to_wrapping_index_clamped(p, ulen),
       };
@@ -205,7 +205,7 @@ static FILL: NativeFunction = native_fn(|mut this, params| {
       let array_data_mut = Rc::make_mut(array_data);
       let len = array_data_mut.elements.len();
 
-      let fill_val = params.get(0).unwrap_or(&Val::Undefined);
+      let fill_val = params.first().unwrap_or(&Val::Undefined);
 
       let start = match params.get(1) {
         None => 0,
@@ -258,7 +258,7 @@ static FLAT: NativeFunction = native_fn(|this, params| {
 static INCLUDES: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::Array(array_data) => {
-      let search_param = params.get(0).unwrap_or(&Val::Undefined);
+      let search_param = params.first().unwrap_or(&Val::Undefined);
 
       for elem in &array_data.elements {
         let is_eq = op_triple_eq_impl(elem, search_param)
@@ -279,7 +279,7 @@ static INCLUDES: NativeFunction = native_fn(|this, params| {
 static INDEX_OF: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::Array(array_data) => {
-      let search_param = params.get(0).unwrap_or(&Val::Undefined);
+      let search_param = params.first().unwrap_or(&Val::Undefined);
 
       for i in 0..array_data.elements.len() {
         let is_eq = op_triple_eq_impl(&array_data.elements[i], search_param)
@@ -308,7 +308,7 @@ static JOIN: NativeFunction = native_fn(|this, params| {
         return Ok(vals.elements[0].clone().to_val_string());
       }
 
-      let separator = match params.get(0) {
+      let separator = match params.first() {
         None => ",".to_string(),
         Some(v) => v.to_string(),
       };
@@ -336,7 +336,7 @@ static JOIN: NativeFunction = native_fn(|this, params| {
 static LAST_INDEX_OF: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::Array(array_data) => {
-      let search_param = params.get(0).unwrap_or(&Val::Undefined);
+      let search_param = params.first().unwrap_or(&Val::Undefined);
 
       for i in (0..array_data.elements.len()).rev() {
         let is_eq = op_triple_eq_impl(&array_data.elements[i], search_param)
@@ -440,7 +440,7 @@ static SLICE: NativeFunction = native_fn(|this, params| {
     Val::Array(array_data) => {
       let mut new_elems = Vec::<Val>::new();
 
-      let start = match params.get(0) {
+      let start = match params.first() {
         None => 0,
         Some(v) => to_wrapping_index_clamped(v, array_data.elements.len()),
       };
@@ -468,7 +468,7 @@ static SPLICE: NativeFunction = native_fn(|mut this, params| {
       let array_data_mut = Rc::make_mut(array_data);
       let len = array_data_mut.elements.len();
 
-      let start = match params.get(0) {
+      let start = match params.first() {
         None => 0,
         Some(v) => to_wrapping_index_clamped(v, len),
       } as usize;
diff --git a/valuescript_vm/src/bigint_methods.rs b/valuescript_vm/src/bigint_methods.rs
index 3af051e0..99501ff7 100644
--- a/valuescript_vm/src/bigint_methods.rs
+++ b/valuescript_vm/src/bigint_methods.rs
@@ -19,7 +19,7 @@ pub fn op_sub_bigint(_bigint: &BigInt, subscript: &Val) -> Val {
 
 static TO_STRING: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
-    Val::BigInt(bigint) => match params.get(0) {
+    Val::BigInt(bigint) => match params.first() {
       Some(_) => {
         return Err("TODO: toString with radix".to_internal_error());
       }
diff --git a/valuescript_vm/src/builtins/array_builtin.rs b/valuescript_vm/src/builtins/array_builtin.rs
index 04bf5f70..a689b172 100644
--- a/valuescript_vm/src/builtins/array_builtin.rs
+++ b/valuescript_vm/src/builtins/array_builtin.rs
@@ -45,7 +45,7 @@ impl fmt::Display for ArrayBuiltin {
 }
 
 static IS_ARRAY: NativeFunction = native_fn(|_this, params| {
-  Ok(match params.get(0) {
+  Ok(match params.first() {
     None => Val::Bool(false),
     Some(p) => match p.as_array_data() {
       None => Val::Bool(false),
@@ -55,7 +55,7 @@ static IS_ARRAY: NativeFunction = native_fn(|_this, params| {
 });
 
 static FROM: NativeFunction = native_fn(|_this, params| {
-  let mut first_param = match params.get(0) {
+  let mut first_param = match params.first() {
     None => return Err("undefined is not iterable".to_type_error()),
     Some(p) => p.clone(),
   };
diff --git a/valuescript_vm/src/builtins/bigint_builtin.rs b/valuescript_vm/src/builtins/bigint_builtin.rs
index 2a489e2a..19d97c47 100644
--- a/valuescript_vm/src/builtins/bigint_builtin.rs
+++ b/valuescript_vm/src/builtins/bigint_builtin.rs
@@ -27,7 +27,7 @@ impl BuiltinObject for BigIntBuiltin {
 
   fn bo_load_function() -> LoadFunctionResult {
     LoadFunctionResult::NativeFunction(|_: ThisWrapper, params: Vec<Val>| -> Result<Val, Val> {
-      match params.get(0) {
+      match params.first() {
         Some(Val::Number(value)) => {
           if *value != f64::floor(*value) {
             Err(
diff --git a/valuescript_vm/src/builtins/boolean_builtin.rs b/valuescript_vm/src/builtins/boolean_builtin.rs
index 87f725a3..9708f7df 100644
--- a/valuescript_vm/src/builtins/boolean_builtin.rs
+++ b/valuescript_vm/src/builtins/boolean_builtin.rs
@@ -22,7 +22,7 @@ impl BuiltinObject for BooleanBuiltin {
 
   fn bo_load_function() -> LoadFunctionResult {
     LoadFunctionResult::NativeFunction(|_: ThisWrapper, params: Vec<Val>| -> Result<Val, Val> {
-      Ok(if let Some(value) = params.get(0) {
+      Ok(if let Some(value) = params.first() {
         Val::Bool(value.is_truthy())
       } else {
         Val::Bool(false)
diff --git a/valuescript_vm/src/builtins/error_builtin.rs b/valuescript_vm/src/builtins/error_builtin.rs
index 62c96f52..58a965b1 100644
--- a/valuescript_vm/src/builtins/error_builtin.rs
+++ b/valuescript_vm/src/builtins/error_builtin.rs
@@ -29,7 +29,7 @@ impl BuiltinObject for ErrorBuiltin {
   fn bo_load_function() -> LoadFunctionResult {
     LoadFunctionResult::NativeFunction(|_: ThisWrapper, params: Vec<Val>| -> Result<Val, Val> {
       Ok(
-        match params.get(0) {
+        match params.first() {
           Some(param) => param.clone().to_val_string(),
           None => "".to_val(),
         }
@@ -96,7 +96,7 @@ fn make_error_prototype() -> Val {
 }
 
 static SET_MESSAGE: NativeFunction = native_fn(|mut this, params| {
-  let message = match params.get(0) {
+  let message = match params.first() {
     Some(param) => param.to_string(),
     None => "".to_string(),
   };
diff --git a/valuescript_vm/src/builtins/internal_error_builtin.rs b/valuescript_vm/src/builtins/internal_error_builtin.rs
index 3fe020b7..c0ac37d1 100644
--- a/valuescript_vm/src/builtins/internal_error_builtin.rs
+++ b/valuescript_vm/src/builtins/internal_error_builtin.rs
@@ -28,7 +28,7 @@ impl BuiltinObject for InternalErrorBuiltin {
   fn bo_load_function() -> LoadFunctionResult {
     LoadFunctionResult::NativeFunction(|_: ThisWrapper, params: Vec<Val>| -> Result<Val, Val> {
       Ok(
-        match params.get(0) {
+        match params.first() {
           Some(param) => param.clone().to_val_string(),
           None => "".to_val(),
         }
@@ -68,7 +68,7 @@ fn make_internal_error_prototype() -> Val {
 }
 
 static SET_MESSAGE: NativeFunction = native_fn(|mut this, params| {
-  let message = match params.get(0) {
+  let message = match params.first() {
     Some(param) => param.to_string(),
     None => "".to_string(),
   };
diff --git a/valuescript_vm/src/builtins/math_builtin.rs b/valuescript_vm/src/builtins/math_builtin.rs
index 43eb6a2c..40e2cbcd 100644
--- a/valuescript_vm/src/builtins/math_builtin.rs
+++ b/valuescript_vm/src/builtins/math_builtin.rs
@@ -89,178 +89,178 @@ fn param_to_number(param: Option<&Val>) -> f64 {
 }
 
 static ABS: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.abs()))
 });
 
 static ACOS: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.acos()))
 });
 
 static ACOSH: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.acosh()))
 });
 
 static ASIN: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.asin()))
 });
 
 static ASINH: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.sinh()))
 });
 
 static ATAN: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.atan()))
 });
 
 static ATAN2: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   let y = param_to_number(params.get(1));
 
   Ok(Val::Number(x.atan2(y)))
 });
 
 static ATANH: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.atanh()))
 });
 
 static CBRT: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.cbrt()))
 });
 
 static CEIL: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.ceil()))
 });
 
 static CLZ32: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(to_u32(x).leading_zeros() as f64))
 });
 
 static COS: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.cos()))
 });
 
 static COSH: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.cosh()))
 });
 
 static EXP: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.exp()))
 });
 
 static EXPM1: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.exp_m1()))
 });
 
 static FLOOR: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.floor()))
 });
 
 static FROUND: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x as f32 as f64))
 });
 
 static HYPOT: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   let y = param_to_number(params.get(1));
   Ok(Val::Number(x.hypot(y)))
 });
 
 static IMUL: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   let y = param_to_number(params.get(1));
   Ok(Val::Number((to_u32(x) * to_u32(y)) as i32 as f64))
 });
 
 static LOG: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.ln()))
 });
 
 static LOG10: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.log10()))
 });
 
 static LOG1P: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.ln_1p()))
 });
 
 static LOG2: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.log2()))
 });
 
 static MAX: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   let y = param_to_number(params.get(1));
   Ok(Val::Number(x.max(y)))
 });
 
 static MIN: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   let y = param_to_number(params.get(1));
   Ok(Val::Number(x.min(y)))
 });
 
 static POW: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   let y = param_to_number(params.get(1));
   Ok(Val::Number(x.powf(y)))
 });
 
 static ROUND: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.round()))
 });
 
 static SIGN: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.signum()))
 });
 
 static SIN: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.sin()))
 });
 
 static SINH: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.sinh()))
 });
 
 static SQRT: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.sqrt()))
 });
 
 static TAN: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.tan()))
 });
 
 static TANH: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.tanh()))
 });
 
 static TRUNC: NativeFunction = native_fn(|_this, params| {
-  let x = param_to_number(params.get(0));
+  let x = param_to_number(params.first());
   Ok(Val::Number(x.trunc()))
 });
diff --git a/valuescript_vm/src/builtins/number_builtin.rs b/valuescript_vm/src/builtins/number_builtin.rs
index 32da9510..0fc95861 100644
--- a/valuescript_vm/src/builtins/number_builtin.rs
+++ b/valuescript_vm/src/builtins/number_builtin.rs
@@ -41,7 +41,7 @@ impl BuiltinObject for NumberBuiltin {
 
   fn bo_load_function() -> LoadFunctionResult {
     LoadFunctionResult::NativeFunction(|_: ThisWrapper, params: Vec<Val>| -> Result<Val, Val> {
-      Ok(if let Some(value) = params.get(0) {
+      Ok(if let Some(value) = params.first() {
         Val::Number(value.to_number())
       } else {
         Val::Number(0.0)
@@ -61,7 +61,7 @@ impl fmt::Display for NumberBuiltin {
 }
 
 pub static IS_FINITE: NativeFunction = native_fn(|_this, params| {
-  Ok(if let Some(value) = params.get(0) {
+  Ok(if let Some(value) = params.first() {
     let number = value.to_number();
     Val::Bool(number.is_finite())
   } else {
@@ -70,7 +70,7 @@ pub static IS_FINITE: NativeFunction = native_fn(|_this, params| {
 });
 
 static IS_INTEGER: NativeFunction = native_fn(|_this, params| {
-  let num = match params.get(0) {
+  let num = match params.first() {
     Some(n) => n.to_number(),
     None => return Ok(Val::Bool(false)),
   };
@@ -82,7 +82,7 @@ static IS_INTEGER: NativeFunction = native_fn(|_this, params| {
 });
 
 pub static IS_NAN: NativeFunction = native_fn(|_this, params| {
-  Ok(if let Some(value) = params.get(0) {
+  Ok(if let Some(value) = params.first() {
     let number = value.to_number();
     Val::Bool(number.is_nan())
   } else {
@@ -91,7 +91,7 @@ pub static IS_NAN: NativeFunction = native_fn(|_this, params| {
 });
 
 static IS_SAFE_INTEGER: NativeFunction = native_fn(|_this, params| {
-  let num = match params.get(0) {
+  let num = match params.first() {
     Some(n) => n.to_number(),
     None => return Ok(Val::Bool(false)),
   };
@@ -106,7 +106,7 @@ static IS_SAFE_INTEGER: NativeFunction = native_fn(|_this, params| {
 });
 
 pub static PARSE_FLOAT: NativeFunction = native_fn(|_this, params| {
-  Ok(if let Some(value) = params.get(0) {
+  Ok(if let Some(value) = params.first() {
     let string_value = value.to_string().trim().to_string();
 
     match string_value.parse::<f64>() {
@@ -119,7 +119,7 @@ pub static PARSE_FLOAT: NativeFunction = native_fn(|_this, params| {
 });
 
 pub static PARSE_INT: NativeFunction = native_fn(|_this, params| {
-  Ok(if let Some(value) = params.get(0) {
+  Ok(if let Some(value) = params.first() {
     let string_value = value.to_string().trim_start().to_string();
     let radix = params.get(1).and_then(|v| v.to_index()).unwrap_or(10);
 
diff --git a/valuescript_vm/src/builtins/range_error_builtin.rs b/valuescript_vm/src/builtins/range_error_builtin.rs
index ff00e2c1..480693f9 100644
--- a/valuescript_vm/src/builtins/range_error_builtin.rs
+++ b/valuescript_vm/src/builtins/range_error_builtin.rs
@@ -60,7 +60,7 @@ fn make_range_error_prototype() -> Val {
 }
 
 static SET_MESSAGE: NativeFunction = native_fn(|mut this, params| {
-  let message = match params.get(0) {
+  let message = match params.first() {
     Some(param) => param.to_string(),
     None => "".to_string(),
   };
@@ -75,7 +75,7 @@ pub fn to_range_error(_: ThisWrapper, params: Vec<Val>) -> Result<Val, Val> {
     VsObject {
       string_map: BTreeMap::from([(
         "message".to_string(),
-        match params.get(0) {
+        match params.first() {
           Some(param) => param.clone().to_val_string(),
           None => "".to_val(),
         },
diff --git a/valuescript_vm/src/builtins/string_builtin.rs b/valuescript_vm/src/builtins/string_builtin.rs
index 5b5f30fb..68fb43bf 100644
--- a/valuescript_vm/src/builtins/string_builtin.rs
+++ b/valuescript_vm/src/builtins/string_builtin.rs
@@ -65,7 +65,7 @@ static FROM_CODE_POINT: NativeFunction = native_fn(|_this, params| {
 });
 
 fn to_string(_: ThisWrapper, params: Vec<Val>) -> Result<Val, Val> {
-  Ok(if let Some(value) = params.get(0) {
+  Ok(if let Some(value) = params.first() {
     value.clone().to_val_string()
   } else {
     "".to_val()
diff --git a/valuescript_vm/src/builtins/type_error_builtin.rs b/valuescript_vm/src/builtins/type_error_builtin.rs
index 1062691d..1164a1b3 100644
--- a/valuescript_vm/src/builtins/type_error_builtin.rs
+++ b/valuescript_vm/src/builtins/type_error_builtin.rs
@@ -28,7 +28,7 @@ impl BuiltinObject for TypeErrorBuiltin {
   fn bo_load_function() -> LoadFunctionResult {
     LoadFunctionResult::NativeFunction(|_: ThisWrapper, params: Vec<Val>| -> Result<Val, Val> {
       Ok(
-        match params.get(0) {
+        match params.first() {
           Some(param) => param.clone().to_val_string(),
           None => "".to_val(),
         }
@@ -68,7 +68,7 @@ fn make_type_error_prototype() -> Val {
 }
 
 static SET_MESSAGE: NativeFunction = native_fn(|mut this, params| {
-  let message = match params.get(0) {
+  let message = match params.first() {
     Some(param) => param.to_string(),
     None => "".to_string(),
   };
diff --git a/valuescript_vm/src/number_methods.rs b/valuescript_vm/src/number_methods.rs
index 166abe19..aeccff7f 100644
--- a/valuescript_vm/src/number_methods.rs
+++ b/valuescript_vm/src/number_methods.rs
@@ -35,7 +35,7 @@ static TO_FIXED: NativeFunction = native_fn(|this, params| {
         );
       }
 
-      let mut precision = match params.get(0) {
+      let mut precision = match params.first() {
         Some(p) => p.to_number(),
         _ => return Ok(number.to_val().to_string().to_val()),
       };
@@ -54,7 +54,7 @@ static TO_FIXED: NativeFunction = native_fn(|this, params| {
 
 static TO_EXPONENTIAL: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
-    Val::Number(number) => match params.get(0) {
+    Val::Number(number) => match params.first() {
       Some(p) => {
         let mut precision = p.to_number();
         precision = f64::floor(precision);
@@ -78,7 +78,7 @@ static TODO_LOCALE: NativeFunction = native_fn(|this, _params| match this.get()
 
 static TO_STRING: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
-    Val::Number(number) => match params.get(0) {
+    Val::Number(number) => match params.first() {
       Some(_) => {
         return Err("TODO: toString with radix".to_internal_error());
       }
diff --git a/valuescript_vm/src/string_methods.rs b/valuescript_vm/src/string_methods.rs
index 69fbf6ef..f55197cf 100644
--- a/valuescript_vm/src/string_methods.rs
+++ b/valuescript_vm/src/string_methods.rs
@@ -94,7 +94,7 @@ static AT: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let index = match to_wrapping_index(params.get(0), string_bytes.len()) {
+      let index = match to_wrapping_index(params.first(), string_bytes.len()) {
         None => return Ok(Val::Undefined),
         Some(i) => i,
       };
@@ -113,7 +113,7 @@ static CODE_POINT_AT: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let index = match params.get(0) {
+      let index = match params.first() {
         Some(i) => match i.to_index() {
           None => return Ok(Val::Undefined),
           Some(i) => i,
@@ -153,7 +153,7 @@ static ENDS_WITH: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let search_string = match params.get(0) {
+      let search_string = match params.first() {
         Some(s) => s.to_string(),
         _ => return Ok(Val::Bool(false)),
       };
@@ -194,7 +194,7 @@ static INCLUDES: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let search_string = match params.get(0) {
+      let search_string = match params.first() {
         Some(s) => s.to_string(),
         _ => return Ok(Val::Bool(false)),
       };
@@ -224,7 +224,7 @@ static INDEX_OF: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let search_string = match params.get(0) {
+      let search_string = match params.first() {
         Some(s) => s.to_string(),
         _ => return Ok(Val::Number(-1.0)),
       };
@@ -254,7 +254,7 @@ static LAST_INDEX_OF: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let search_string = match params.get(0) {
+      let search_string = match params.first() {
         Some(s) => s.to_string(),
         _ => return Ok(Val::Number(-1.0)),
       };
@@ -310,7 +310,7 @@ static NORMALIZE: NativeFunction = native_fn(|this, _params| {
 static PAD_END: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::String(string_data) => {
-      let target_length = match params.get(0) {
+      let target_length = match params.first() {
         Some(p) => match p.to_index() {
           Some(i) => i,
           None => return Ok(Val::String(string_data.clone())),
@@ -362,7 +362,7 @@ static PAD_END: NativeFunction = native_fn(|this, params| {
 static PAD_START: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::String(string_data) => {
-      let target_length = match params.get(0) {
+      let target_length = match params.first() {
         Some(p) => match p.to_index() {
           Some(i) => i,
           None => return Ok(Val::String(string_data.clone())),
@@ -415,7 +415,7 @@ static PAD_START: NativeFunction = native_fn(|this, params| {
 static REPEAT: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::String(string_data) => {
-      let count = match params.get(0) {
+      let count = match params.first() {
         Some(p) => match p.to_index() {
           Some(i) => i,
           None => return Ok(Val::String(string_data.clone())),
@@ -440,7 +440,7 @@ static SLICE: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let start = match params.get(0) {
+      let start = match params.first() {
         None => 0,
         Some(v) => to_wrapping_index_clamped(v, string_bytes.len()),
       };
@@ -469,7 +469,7 @@ static SLICE: NativeFunction = native_fn(|this, params| {
 static SPLIT: NativeFunction = native_fn(|this, params| {
   Ok(match this.get() {
     Val::String(string_data) => {
-      let separator = match params.get(0) {
+      let separator = match params.first() {
         Some(s) => s.to_string(), // TODO: Regexes
         None => return Ok(Val::String(string_data.clone())),
       };
@@ -535,7 +535,7 @@ static STARTS_WITH: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let search_string = match params.get(0) {
+      let search_string = match params.first() {
         Some(s) => s.to_string(),
         _ => return Ok(Val::Bool(false)),
       };
@@ -574,7 +574,7 @@ static SUBSTRING: NativeFunction = native_fn(|this, params| {
     Val::String(string_data) => {
       let string_bytes = string_data.as_bytes();
 
-      let start = match params.get(0) {
+      let start = match params.first() {
         Some(v) => match v.to_index() {
           Some(i) => std::cmp::min(i, string_bytes.len()),
           None => 0,
diff --git a/vstc/src/db_command.rs b/vstc/src/db_command.rs
index 597beb48..cb302574 100644
--- a/vstc/src/db_command.rs
+++ b/vstc/src/db_command.rs
@@ -90,7 +90,7 @@ fn make_storage(path: &String) -> Storage<SledBackend> {
 }
 
 fn db_new(path: &String, args: &[String]) {
-  let class_path = match args.get(0) {
+  let class_path = match args.first() {
     Some(class_path) => class_path,
     None => {
       exit_command_failed(args, Some("Missing class file"), "vstc db help");
@@ -110,7 +110,7 @@ fn db_new(path: &String, args: &[String]) {
 }
 
 fn db_call(path: &String, args: &[String]) {
-  let fn_file = match args.get(0) {
+  let fn_file = match args.first() {
     Some(fn_file) => fn_file,
     None => exit_command_failed(args, Some("Missing function file"), "vstc db help"),
   };
@@ -211,7 +211,7 @@ fn db_interactive(path: &String) {
 
     let args = parse_command_line(&input);
 
-    match args.get(0).map(|s| s.as_str()) {
+    match args.first().map(|s| s.as_str()) {
       Some("help") => {
         // TODO: help (it's a bit different - code isn't quoted (TODO: quoted should work too))
         println!("TODO: help");