chore: Fix formatter issues

Author: Dave Lucia

lib/lua/compiler/codegen.ex

@@ -650,7 +650,8 @@ defmodule Lua.Compiler.Codegen do
 
         last_field = List.last(rest)
 
-        {closure_instructions ++ final_instructions ++ [Instruction.set_field(final_table_reg, last_field, closure_reg)], ctx}
+        {closure_instructions ++ final_instructions ++ [Instruction.set_field(final_table_reg, last_field, closure_reg)],
+         ctx}
     end
   end
 

lib/lua/compiler/scope.ex

@@ -455,8 +455,7 @@ defmodule Lua.Compiler.Scope do
 
         func = %{
           func
-          | upvalue_descriptors:
-              func.upvalue_descriptors ++ [{:parent_local, reg, name}]
+          | upvalue_descriptors: func.upvalue_descriptors ++ [{:parent_local, reg, name}]
         }
 
         state = %{state | functions: Map.put(state.functions, for_function, func)}

lib/lua/lexer.ex

@@ -652,6 +652,7 @@ defmodule Lua.Lexer do
       normalized = if String.ends_with?(normalized, "."), do: normalized <> "0", else: normalized
       # "2.E-1" → "2.0E-1"
       normalized = String.replace(normalized, ~r/\.([eE])/, ".0\\1")
+
       case Float.parse(normalized) do
         {num, ""} -> {:ok, num}
         _ -> {:error, :invalid_number}

lib/lua/vm/executor.ex

@@ -331,8 +331,7 @@ defmodule Lua.VM.Executor do
       # so each iteration gets fresh upvalue cells for its own variables
       state = %{
         state
-        | open_upvalues:
-            Map.reject(state.open_upvalues, fn {reg, _} -> reg >= loop_var end)
+        | open_upvalues: Map.reject(state.open_upvalues, fn {reg, _} -> reg >= loop_var end)
       }
 
       # Execute body
@@ -387,8 +386,7 @@ defmodule Lua.VM.Executor do
 
       state = %{
         state
-        | open_upvalues:
-            Map.reject(state.open_upvalues, fn {reg, _} -> reg >= first_var_reg end)
+        | open_upvalues: Map.reject(state.open_upvalues, fn {reg, _} -> reg >= first_var_reg end)
       }
 
       # Execute body
@@ -798,7 +796,7 @@ defmodule Lua.VM.Executor do
 
     {result, new_state} =
       try_binary_metamethod("__band", val_a, val_b, state, fn ->
-        Bitwise.band(to_integer!(val_a), to_integer!(val_b)) |> to_signed_int64()
+        val_a |> to_integer!() |> Bitwise.band(to_integer!(val_b)) |> to_signed_int64()
       end)
 
     regs = put_elem(regs, dest, result)
@@ -811,7 +809,7 @@ defmodule Lua.VM.Executor do
 
     {result, new_state} =
       try_binary_metamethod("__bor", val_a, val_b, state, fn ->
-        Bitwise.bor(to_integer!(val_a), to_integer!(val_b)) |> to_signed_int64()
+        val_a |> to_integer!() |> Bitwise.bor(to_integer!(val_b)) |> to_signed_int64()
       end)
 
     regs = put_elem(regs, dest, result)
@@ -824,7 +822,7 @@ defmodule Lua.VM.Executor do
 
     {result, new_state} =
       try_binary_metamethod("__bxor", val_a, val_b, state, fn ->
-        Bitwise.bxor(to_integer!(val_a), to_integer!(val_b)) |> to_signed_int64()
+        val_a |> to_integer!() |> Bitwise.bxor(to_integer!(val_b)) |> to_signed_int64()
       end)
 
     regs = put_elem(regs, dest, result)
@@ -862,7 +860,7 @@ defmodule Lua.VM.Executor do
 
     {result, new_state} =
       try_unary_metamethod("__bnot", val, state, fn ->
-        Bitwise.bnot(to_integer!(val)) |> to_signed_int64()
+        val |> to_integer!() |> Bitwise.bnot() |> to_signed_int64()
       end)
 
     regs = put_elem(regs, dest, result)
@@ -1754,7 +1752,7 @@ defmodule Lua.VM.Executor do
   defp lua_shift_left(val, shift) when shift < 0, do: lua_shift_right(val, -shift)
 
   defp lua_shift_left(val, shift) do
-    Bitwise.bsl(val, shift) |> to_signed_int64()
+    val |> Bitwise.bsl(shift) |> to_signed_int64()
   end
 
   defp lua_shift_right(_val, shift) when shift >= 64, do: 0
@@ -1764,7 +1762,7 @@ defmodule Lua.VM.Executor do
   defp lua_shift_right(val, shift) do
     # Unsigned right shift - mask to 64-bit unsigned first
     unsigned_val = Bitwise.band(val, 0xFFFFFFFFFFFFFFFF)
-    Bitwise.bsr(unsigned_val, shift) |> to_signed_int64()
+    unsigned_val |> Bitwise.bsr(shift) |> to_signed_int64()
   end
 
   # Wrap an arbitrary-precision integer to a signed 64-bit integer