fix a bunch of lints

site/src/editor/mod.rs

@@ -133,7 +133,6 @@ pub fn Editor<'a>(
  future: Vec::new(),
  challenge,
  loading_module: false,
- min_height: format!("{code_height_em}em"),
  curr: {
  let code = initial_code.get_untracked().unwrap();
  let len = code.chars().count() as u32;

site/src/editor/utils.rs

@@ -44,7 +44,6 @@ pub struct State {
  pub curr: Record,
  pub challenge: Option<ChallengeDef>,
  pub loading_module: bool,
- pub min_height: String,
 }
 
 /// A record of a code change

src/array.rs

@@ -514,7 +514,7 @@ impl<T: Clone> Array<T> {
  U: Clone + 'static,
  {
  if TypeId::of::<T>() == TypeId::of::<U>() {
- unsafe { std::mem::transmute(self) }
+ unsafe { std::mem::transmute::<Array<T>, Array<U>>(self) }
  } else {
  self.convert_with(Into::into)
  }

src/ffi.rs

@@ -1135,23 +1135,29 @@ mod enabled {
  bytes.copy_from_slice(
  &repr[offset..offset + size_of::<*const c_char>()],
  );
- let ptr = unsafe { transmute::<_, *const c_char>(bytes) };
+ let ptr = unsafe {
+ transmute::<[u8; size_of::<*const c_char>()], *const c_char>(bytes)
+ };
  let c_str = unsafe { CStr::from_ptr(ptr) };
  let s = c_str.to_str().map_err(|e| e.to_string())?;
  rows.push(Value::from(s));
  }
  FfiType::Struct { fields } => {
  let mut bytes: [u8; size_of::<*const u8>()] = Default::default();
  bytes.copy_from_slice(&repr[offset..offset + size_of::<*const u8>()]);
- let ptr = unsafe { transmute::<_, *const u8>(bytes) };
+ let ptr = unsafe {
+ transmute::<[u8; size_of::<*const u8>()], *const u8>(bytes)
+ };
  let (size, _) = struct_fields_size_align(fields);
  let inner_repr = unsafe { slice::from_raw_parts(ptr, size) };
  rows.push(self.struct_repr_to_value(inner_repr, fields)?);
  }
  inner => {
  let mut bytes: [u8; size_of::<*const u8>()] = Default::default();
  bytes.copy_from_slice(&repr[offset..offset + size_of::<*const u8>()]);
- let ptr = unsafe { transmute::<_, *const u8>(bytes) };
+ let ptr = unsafe {
+ transmute::<[u8; size_of::<*const u8>()], *const u8>(bytes)
+ };
  let (size, _) = inner.size_align();
  let inner_repr = unsafe { slice::from_raw_parts(ptr, size) };
  let mut row = self

src/grid_fmt.rs

@@ -1,10 +1,7 @@
 //! Pretty printing Uiua arrays
 
 use std::{
- f64::{
- consts::{PI, TAU},
- INFINITY,
- },
+ f64::consts::{PI, TAU},
  iter::once,
  mem::take,
 };
@@ -65,7 +62,7 @@ impl GridFmt for f64 {
  format!("{minus}τ")
  } else if (positive - PI / 2.0).abs() <= f64::EPSILON {
  format!("{minus}η")
- } else if positive == INFINITY {
+ } else if positive == f64::INFINITY {
  format!("{minus}∞")
  } else if f.to_bits() == EMPTY_NAN.to_bits() || f.to_bits() == TOMBSTONE_NAN.to_bits() {
  return vec![vec!['⋅']];

src/primitive/defs.rs

@@ -106,7 +106,7 @@ constant!(
  /// The imaginary unit
  ("i", crate::Complex::I),
  /// IEEE 754-2008's `NaN`
- ("NaN", std::f64::NAN),
+ ("NaN", f64::NAN),
  /// The wildcard `NaN` value that equals any other number
  ("W", WILDCARD_NAN),
  /// The maximum integer that can be represented exactly

src/primitive/mod.rs

@@ -11,10 +11,7 @@ use std::{
  borrow::{BorrowMut, Cow},
  cell::RefCell,
  collections::HashMap,
- f64::{
- consts::{PI, TAU},
- INFINITY,
- },
+ f64::consts::{PI, TAU},
  fmt,
  sync::{
  atomic::{self, AtomicUsize},
@@ -274,7 +271,7 @@ macro_rules! constant {
 constant!(eta, PI / 2.0);
 constant!(pi, PI);
 constant!(tau, TAU);
-constant!(inf, INFINITY);
+constant!(inf, f64::INFINITY);
 
 /// A wrapper that nicely prints a `Primitive`
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
@@ -351,7 +348,7 @@ impl Primitive {
  Eta => Some(PI / 2.0),
  Pi => Some(PI),
  Tau => Some(TAU),
- Infinity => Some(INFINITY),
+ Infinity => Some(f64::INFINITY),
  _ => None,
  }
  }