misc: setup and start fixing Clippy lints

Author: Serial-ATA

Cargo.toml

@@ -23,6 +23,67 @@ repository = "https://github.com/Serial-ATA/jvm"
 edition = "2024"
 license = "MIT OR APACHE-2.0"
 
+[workspace.lints.rust]
+rust_2018_idioms = { level = "deny", priority = -1 }
+rust_2021_compatibility = { level = "deny", priority = -1 }
+rust_2024_compatibility = { level = "deny", priority = -1 }
+trivial_casts = "deny"
+trivial_numeric_casts = "deny"
+unused_import_braces = "deny"
+explicit_outlives_requirements = "deny"
+unknown_lints = "allow"
+
+[workspace.lints.clippy]
+# Doc stuff
+missing_panics_doc = "allow"
+missing_errors_doc = "allow"
+tabs_in_doc_comments = "allow"
+
+string_to_string = "deny"
+pedantic = { level = "deny", priority = -1 }
+all = { level = "deny", priority = -1 }
+too_many_lines = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+cast_possible_wrap = "allow"
+cast_possible_truncation = "allow"
+module_name_repetitions = "allow"
+must_use_candidate = "allow"
+doc_markdown = "allow"
+match_wildcard_for_single_variants = "allow"
+semicolon_if_nothing_returned = "allow"
+from_over_into = "allow"
+upper_case_acronyms = "allow"
+single_match_else = "allow"
+similar_names = "allow"
+len_without_is_empty = "allow"
+needless_late_init = "allow"
+type_complexity = "allow"
+return_self_not_must_use = "allow"
+bool_to_int_with_if = "allow"
+uninlined_format_args = "allow" # This should be changed for any normal "{}", but I'm not a fan of it for any debug or width specific formatting
+let_underscore_untyped = "allow"
+field_reassign_with_default = "allow"
+manual_range_patterns = "allow" # This is not at all clearer as it suggests
+no_effect_underscore_binding = "allow"
+used_underscore_binding = "allow"
+ignored_unit_patterns = "allow" # Not a fan of this lint, doesn't make anything clearer as it claims
+needless_return = "allow" # Explicit returns are needed from time to time for clarity
+redundant_guards = "allow" # Currently broken for some cases, might enable later
+into_iter_without_iter = "allow" # This is only going to fire on some internal types, doesn't matter much
+struct_excessive_bools = "allow" # I have yet to find one case of this being useful
+needless_continue = "allow" # All occurences of this lint are just for clarity in large loops
+unbuffered_bytes = "allow" # It is up to the caller to wrap their data in `BufReader`s
+struct_field_names = "allow"
+new_ret_no_self = "allow" # Violations of this lint are intentional
+inline_always = "allow"
+wildcard_imports = "allow"
+linkedlist = "allow"
+new_without_default = "allow" # Doesn't matter, not building a public API
+cast_ptr_alignment = "allow"
+transmute_bytes_to_str = "allow" # This is only done on guaranteed UTF-8 inputs
+too_many_arguments = "allow" # Rarely in our control
+
 [workspace.dependencies]
 runtime = { path = "runtime" }
 classfile = { path = "classfile" }

classfile/Cargo.toml

@@ -10,4 +10,7 @@ repository.workspace = true
 
 [dependencies]
 common.workspace = true
-paste.workspace = true
+paste.workspace = true
+
+[lints]
+workspace = true

classfile/src/attribute/resolved.rs

@@ -154,7 +154,7 @@ impl Debug for ResolvedBootstrapMethod {
 		f.debug_struct("ResolvedBoostrapMethod")
 			.field("method_handle_info", &self.method_handle_info)
 			.field("arguments", &self.arguments)
-			.finish()
+			.finish_non_exhaustive()
 	}
 }
 

classfile/src/constant_pool/types.rs

@@ -19,7 +19,7 @@ pub enum LoadableConstantPoolValueInner<'a> {
 	Dynamic(<raw::RawDynamic as CpEntry<'a>>::Entry),
 }
 
-impl<'a> LoadableConstantPoolValueInner<'a> {
+impl LoadableConstantPoolValueInner<'_> {
 	pub fn into_owned(self) -> LoadableConstantPoolValueInner<'static> {
 		match self {
 			LoadableConstantPoolValueInner::Integer(val) => {
@@ -57,7 +57,7 @@ pub struct LoadableConstantPoolValue<'a> {
 	pub value: LoadableConstantPoolValueInner<'a>,
 }
 
-impl<'a> LoadableConstantPoolValue<'a> {
+impl LoadableConstantPoolValue<'_> {
 	pub fn into_owned(self) -> LoadableConstantPoolValue<'static> {
 		LoadableConstantPoolValue {
 			index: self.index,
@@ -74,7 +74,7 @@ pub struct FieldRefEntry<'a> {
 	pub name_and_type: <raw::RawNameAndType as super::CpEntry<'a>>::Entry,
 }
 
-impl<'a> FieldRefEntry<'a> {
+impl FieldRefEntry<'_> {
 	pub fn into_owned(self) -> FieldRefEntry<'static> {
 		FieldRefEntry {
 			class_index: self.class_index,
@@ -155,7 +155,7 @@ pub enum ReferenceEntry<'a> {
 	MethodRef(<raw::RawMethodRef as CpEntry<'a>>::Entry),
 }
 
-impl<'a> ReferenceEntry<'a> {
+impl ReferenceEntry<'_> {
 	pub fn into_owned(self) -> ReferenceEntry<'static> {
 		match self {
 			ReferenceEntry::FieldRef(field) => ReferenceEntry::FieldRef(field.into_owned()),
@@ -178,7 +178,7 @@ impl Debug for ClassNameEntry<'_> {
 	}
 }
 
-impl<'a> ClassNameEntry<'a> {
+impl ClassNameEntry<'_> {
 	pub fn into_owned(self) -> ClassNameEntry<'static> {
 		ClassNameEntry {
 			name_index: self.name_index,
@@ -194,7 +194,7 @@ pub struct MethodHandleEntry<'a> {
 	pub reference: ReferenceEntry<'a>,
 }
 
-impl<'a> MethodHandleEntry<'a> {
+impl MethodHandleEntry<'_> {
 	pub fn into_owned(self) -> MethodHandleEntry<'static> {
 		MethodHandleEntry {
 			reference_kind: self.reference_kind,
@@ -213,7 +213,7 @@ pub struct MethodRefEntry<'a> {
 	pub name_and_type: <raw::RawNameAndType as CpEntry<'a>>::Entry,
 }
 
-impl<'a> MethodRefEntry<'a> {
+impl MethodRefEntry<'_> {
 	pub fn into_owned(self) -> MethodRefEntry<'static> {
 		MethodRefEntry {
 			is_interface: self.is_interface,
@@ -242,7 +242,7 @@ impl Debug for NameAndTypeEntry<'_> {
 	}
 }
 
-impl<'a> NameAndTypeEntry<'a> {
+impl NameAndTypeEntry<'_> {
 	pub fn into_owned(self) -> NameAndTypeEntry<'static> {
 		NameAndTypeEntry {
 			name_index: self.name_index,
@@ -260,7 +260,7 @@ pub struct InvokeDynamicEntry<'a> {
 	pub name_and_type: <raw::RawNameAndType as CpEntry<'a>>::Entry,
 }
 
-impl<'a> InvokeDynamicEntry<'a> {
+impl InvokeDynamicEntry<'_> {
 	pub fn into_owned(self) -> InvokeDynamicEntry<'static> {
 		InvokeDynamicEntry {
 			bootstrap_method_attr_index: self.bootstrap_method_attr_index,
@@ -277,7 +277,7 @@ pub struct DynamicEntry<'a> {
 	pub name_and_type: <raw::RawNameAndType as CpEntry<'a>>::Entry,
 }
 
-impl<'a> DynamicEntry<'a> {
+impl DynamicEntry<'_> {
 	pub fn into_owned(self) -> DynamicEntry<'static> {
 		DynamicEntry {
 			bootstrap_method_attr_index: self.bootstrap_method_attr_index,
@@ -386,9 +386,9 @@ pub mod raw {
 
 		#[inline]
 		fn handle(_: &ConstantPool, args: Self::HandleArgs) -> Self::Entry {
-			let high = (args.0 as u64) << 32;
+			let high = u64::from(args.0) << 32;
 			let low = args.1;
-			f64::from_bits(high | low as u64)
+			f64::from_bits(high | u64::from(low))
 		}
 	}
 

classfile/src/fieldinfo.rs

@@ -20,9 +20,7 @@ pub struct FieldInfo {
 
 impl FieldInfo {
 	pub fn get_constant_value_attribute(&self) -> Option<ConstantValue> {
-		self.attributes
-			.iter()
-			.find_map(|attr| attr.constant_value())
+		self.attributes.iter().find_map(Attribute::constant_value)
 	}
 }
 
@@ -95,10 +93,7 @@ impl FieldType {
 	}
 
 	pub fn is_primitive(&self) -> bool {
-		match self {
-			Self::Object(_) | Self::Array(_) => false,
-			_ => true,
-		}
+		!matches!(self, Self::Object(_) | Self::Array(_))
 	}
 
 	pub fn is_byte(&self) -> bool {
@@ -184,9 +179,7 @@ impl FieldType {
 			Self::Short => "short".into(),
 			Self::Boolean => "boolean".into(),
 			Self::Void => "void".into(),
-			Self::Object(name) => {
-				format!("{}", String::from_utf8_lossy(name).replace('/', ".")).into()
-			},
+			Self::Object(name) => String::from_utf8_lossy(name).replace('/', ".").into(),
 			Self::Array(component) => format!("[{}", component.as_java_type()).into(),
 		}
 	}
@@ -224,12 +217,11 @@ impl FieldType {
 	pub fn size(&self) -> usize {
 		match self {
 			FieldType::Byte => size_of::<s1>(),
-			FieldType::Character => size_of::<u2>(),
+			FieldType::Character | FieldType::Short => size_of::<u2>(),
 			FieldType::Double => size_of::<f64>(),
 			FieldType::Float => size_of::<f32>(),
 			FieldType::Integer => size_of::<s4>(),
 			FieldType::Long => size_of::<s8>(),
-			FieldType::Short => size_of::<u2>(),
 			FieldType::Boolean => size_of::<bool>(),
 			FieldType::Void => 0,
 			FieldType::Object(_) | FieldType::Array(_) => size_of::<*const ()>(),
@@ -239,12 +231,11 @@ impl FieldType {
 	pub fn align(&self) -> usize {
 		match self {
 			FieldType::Byte => align_of::<s1>(),
-			FieldType::Character => align_of::<u2>(),
+			FieldType::Character | FieldType::Short => align_of::<u2>(),
 			FieldType::Double => align_of::<f64>(),
 			FieldType::Float => align_of::<f32>(),
 			FieldType::Integer => align_of::<s4>(),
 			FieldType::Long => align_of::<s8>(),
-			FieldType::Short => align_of::<u2>(),
 			FieldType::Boolean => align_of::<bool>(),
 			FieldType::Void => 0,
 			FieldType::Object(_) | FieldType::Array(_) => align_of::<*const ()>(),

classfile/src/parse/mod.rs

@@ -8,7 +8,7 @@ use crate::accessflags::ClassAccessFlags;
 use crate::classfile::ClassFile;
 use crate::constant_pool::ConstantPool;
 use crate::parse::attributes::Location;
-use crate::parse::error::Result;
+use crate::parse::error::{ClassFileParseError, Result};
 
 use std::io::Read;
 
@@ -20,7 +20,9 @@ where
 	R: Read,
 {
 	let magic = reader.read_u4()?;
-	assert_eq!(magic, 0xCAFE_BABE, "No magic found!");
+	if magic != 0xCAFE_BABE {
+		return Err(ClassFileParseError::InvalidMagic);
+	}
 
 	let minor_version = reader.read_u2()?;
 	let major_version = reader.read_u2()?;

common/Cargo.toml

@@ -9,4 +9,7 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-byteorder.workspace = true
+byteorder.workspace = true
+
+[lints]
+workspace = true

common/src/atomic.rs

@@ -20,6 +20,7 @@ impl AtomicF32 {
 		let as_u32 = self.inner.load(ordering);
 		f32::from_bits(as_u32)
 	}
+	#[allow(clippy::missing_errors_doc)]
 	pub fn compare_exchange(
 		&self,
 		current: f32,
@@ -54,6 +55,7 @@ impl AtomicF64 {
 		let as_u64 = self.inner.load(ordering);
 		f64::from_bits(as_u64)
 	}
+	#[allow(clippy::missing_errors_doc)]
 	pub fn compare_exchange(
 		&self,
 		current: f64,

common/src/endian.rs

@@ -65,13 +65,23 @@ impl Endian {
 }
 
 impl Endian {
+	/// Read a 1-byte unsigned integer from `reader`
+	///
+	/// # Errors
+	///
+	/// See [`JavaLittleEndianRead::read_u1()`] and [`JavaReadExt::read_u1()`]
 	pub fn read_u1<R>(self, reader: &mut R) -> Result<u1>
 	where
 		R: Read,
 	{
 		JavaReadExt::read_u1(reader)
 	}
 
+	/// Read a 4-byte, big-endian unsigned integer from `reader`
+	///
+	/// # Errors
+	///
+	/// See [`JavaLittleEndianRead::read_u4()`] and [`JavaReadExt::read_u4()`]
 	pub fn read_u4<R>(self, reader: &mut R) -> Result<u4>
 	where
 		R: Read,
@@ -82,6 +92,11 @@ impl Endian {
 		}
 	}
 
+	/// Read an 8-byte, big-endian unsigned integer from `reader`
+	///
+	/// # Errors
+	///
+	/// See [`JavaLittleEndianRead::read_u8()`] and [`JavaReadExt::read_u8()`]
 	pub fn read_u8<R>(self, reader: &mut R) -> Result<u8>
 	where
 		R: Read,
@@ -92,6 +107,11 @@ impl Endian {
 		}
 	}
 
+	/// Read a 4-byte signed integer from `reader`
+	///
+	/// # Errors
+	///
+	/// See [`JavaLittleEndianRead::read_s4()`] and [`JavaReadExt::read_s4()`]
 	pub fn read_s4<R>(self, reader: &mut R) -> Result<s4>
 	where
 		R: Read,
@@ -102,6 +122,11 @@ impl Endian {
 		}
 	}
 
+	/// Read a 4-byte signed integer from `reader`, into `dst`
+	///
+	/// # Errors
+	///
+	/// See [`JavaLittleEndianRead::read_s4_into()`] and [`JavaReadExt::read_s4_into()`]
 	pub fn read_s4_into<R>(self, reader: &mut R, dst: &mut [s4]) -> Result<()>
 	where
 		R: Read,
@@ -112,6 +137,11 @@ impl Endian {
 		}
 	}
 
+	/// Read a 4-byte unsigned integer from `reader`, into `dst`
+	///
+	/// # Errors
+	///
+	/// See [`JavaLittleEndianRead::read_u4_into()`] and [`JavaReadExt::read_u4_into()`]
 	pub fn read_u4_into<R>(self, reader: &mut R, dst: &mut [u4]) -> Result<()>
 	where
 		R: Read,