[WIP] [Refactor] Defining clippy rules

checker/specification/build.rs

@@ -63,13 +63,14 @@ fn markdown_lines_append_test_to_rust(
 		let blocks = {
 			let mut blocks = Vec::new();
 			let mut current_filename = None;
-			while let Some((_, line)) = lines.next() {
+			for (_, line) in lines.by_ref() {
 				if line == "```ts" {
 					break;
 				}
 			}
 			let mut code = String::new();
-			while let Some((_, line)) = lines.next() {
+
+			for (_, line) in lines.by_ref() {
 				if let Some(path) = line.strip_prefix("// in ") {
 					if !code.trim().is_empty() {
 						blocks.push((
@@ -93,7 +94,7 @@ fn markdown_lines_append_test_to_rust(
 		};
 		let errors = {
 			let mut errors = Vec::new();
-			while let Some((_, line)) = lines.next() {
+			for (_, line) in lines.by_ref() {
 				if line.is_empty() || !line.starts_with('-') {
 					if !errors.is_empty() {
 						break;

checker/specification/test.rs

@@ -59,15 +59,13 @@ fn check_errors(
 		|path| {
 			if path == std::path::Path::new(checker::INTERNAL_DEFINITION_FILE_PATH) {
 				Some(checker::INTERNAL_DEFINITION_FILE.to_owned())
+			} else if code.len() == 1 {
+				Some(code[0].1.to_owned())
 			} else {
-				if code.len() == 1 {
-					Some(code[0].1.to_owned())
-				} else {
-					code.iter().find_map(|(code_path, content)| {
-						(std::path::Path::new(code_path) == path)
-							.then_some(content.to_owned().to_owned())
-					})
-				}
+				code.iter().find_map(|(code_path, content)| {
+					(std::path::Path::new(code_path) == path)
+						.then_some(content.to_owned().to_owned())
+				})
 			}
 		},
 		type_check_options,
@@ -91,7 +89,7 @@ fn check_errors(
 		})
 		.collect();
 
-	if &diagnostics != expected_diagnostics {
+	if diagnostics != expected_diagnostics {
 		panic!(
 			"{}",
 			pretty_assertions::Comparison::new(expected_diagnostics, &diagnostics).to_string()

checker/src/behavior/assignments.rs

@@ -39,6 +39,7 @@ pub enum AssignmentReturnStatus {
 }
 
 impl Reference {
+	#[must_use]
 	pub fn get_position(&self) -> SpanWithSource {
 		match self {
 			Reference::Variable(_, span) | Reference::Property { span, .. } => span.clone(),

checker/src/behavior/constant_functions.rs

@@ -46,7 +46,7 @@ pub(crate) fn call_constant_function(
 					.last()
 					.ok_or(ConstantFunctionError::BadCall)?
 					.to_type()
-					.map_err(|_| ConstantFunctionError::BadCall)?,
+					.map_err(|()| ConstantFunctionError::BadCall)?,
 			);
 
 			let Type::Constant(Constant::Number(num)) = second_argument_type else {
@@ -115,7 +115,7 @@ pub(crate) fn call_constant_function(
 				.first()
 				.ok_or(ConstantFunctionError::BadCall)?
 				.to_type()
-				.map_err(|_| ConstantFunctionError::BadCall)?;
+				.map_err(|()| ConstantFunctionError::BadCall)?;
 			let ty_as_string = print_type(ty, types, &environment.as_general_context(), debug);
 			Ok(ConstantOutput::Diagnostic(format!("Type is: {ty_as_string}")))
 		}
@@ -124,14 +124,14 @@ pub(crate) fn call_constant_function(
 				.first()
 				.ok_or(ConstantFunctionError::BadCall)?
 				.to_type()
-				.map_err(|_| ConstantFunctionError::BadCall)?;
+				.map_err(|()| ConstantFunctionError::BadCall)?;
 			if let Type::Function(func, _) | Type::FunctionReference(func, _) =
 				types.get_type_by_id(ty)
 			{
 				let effects =
 					&types.functions.get(func).ok_or(ConstantFunctionError::BadCall)?.effects;
 				// TODO print using a different function
-				Ok(ConstantOutput::Diagnostic(format!("{:#?}", effects)))
+				Ok(ConstantOutput::Diagnostic(format!("{effects:#?}")))
 			} else {
 				Ok(ConstantOutput::Diagnostic("not a function".to_owned()))
 			}
@@ -145,7 +145,7 @@ pub(crate) fn call_constant_function(
 				Some(this_ty),
 			) = (on, first_argument)
 			{
-				let type_id = this_ty.to_type().map_err(|_| ConstantFunctionError::BadCall)?;
+				let type_id = this_ty.to_type().map_err(|()| ConstantFunctionError::BadCall)?;
 				let value = types.register_type(Type::Function(*func, ThisValue::Passed(type_id)));
 				Ok(ConstantOutput::Value(value))
 			} else {
@@ -171,7 +171,7 @@ pub(crate) fn call_constant_function(
 					.facts
 					.prototypes
 					.get(&first.to_type().unwrap())
-					.cloned()
+					.copied()
 					.unwrap_or(TypeId::NULL_TYPE);
 				Ok(ConstantOutput::Value(prototype))
 			} else {
@@ -197,7 +197,7 @@ pub(crate) fn call_constant_function(
 				.first()
 				.ok_or(ConstantFunctionError::BadCall)?
 				.to_type()
-				.map_err(|_| ConstantFunctionError::BadCall)?;
+				.map_err(|()| ConstantFunctionError::BadCall)?;
 			// TODO temp!!!
 			let arg = call_site_type_args
 				.iter()
@@ -235,7 +235,7 @@ pub(crate) fn call_constant_function(
 						.first()
 						.ok_or(ConstantFunctionError::BadCall)?
 						.to_type()
-						.map_err(|_| ConstantFunctionError::BadCall)?
+						.map_err(|()| ConstantFunctionError::BadCall)?
 				)
 				.is_dependent()
 		))),

checker/src/behavior/functions.rs

@@ -28,20 +28,20 @@ pub enum ThisValue {
 
 impl ThisValue {
 	pub(crate) fn get(
-		&self,
+		self,
 		environment: &mut Environment,
 		types: &TypeStore,
-		position: SpanWithSource,
+		position: &SpanWithSource,
 	) -> TypeId {
 		match self {
-			ThisValue::Passed(value) => *value,
+			ThisValue::Passed(value) => value,
 			ThisValue::UseParent => environment.get_value_of_this(types, position),
 		}
 	}
 
-	pub(crate) fn get_passed(&self) -> Option<TypeId> {
+	pub(crate) fn get_passed(self) -> Option<TypeId> {
 		match self {
-			ThisValue::Passed(value) => Some(*value),
+			ThisValue::Passed(value) => Some(value),
 			ThisValue::UseParent => None,
 		}
 	}
@@ -115,7 +115,7 @@ pub fn synthesise_hoisted_statement_function<T: crate::ReadFromFS, M: crate::AST
 }
 
 pub fn function_to_property(
-	getter_setter: GetterSetter,
+	getter_setter: &GetterSetter,
 	function: FunctionType,
 	types: &mut TypeStore,
 ) -> PropertyValue {
@@ -210,7 +210,7 @@ pub trait SynthesisableFunction<M: crate::ASTImplementation> {
 	);
 }
 
-/// TODO might be generic if FunctionBehavior becomes generic
+/// TODO might be generic if `FunctionBehavior` becomes generic
 pub enum FunctionRegisterBehavior<'a, M: crate::ASTImplementation> {
 	ArrowFunction {
 		expecting: TypeId,
@@ -252,6 +252,7 @@ pub enum FunctionRegisterBehavior<'a, M: crate::ASTImplementation> {
 pub struct ClassPropertiesToRegister<'a, M: ASTImplementation>(pub Vec<ClassValue<'a, M>>);
 
 impl<'a, M: crate::ASTImplementation> FunctionRegisterBehavior<'a, M> {
+	#[must_use]
 	pub fn is_async(&self) -> bool {
 		match self {
 			FunctionRegisterBehavior::ArrowFunction { is_async, .. }
@@ -263,6 +264,7 @@ impl<'a, M: crate::ASTImplementation> FunctionRegisterBehavior<'a, M> {
 		}
 	}
 
+	#[must_use]
 	pub fn is_generator(&self) -> bool {
 		match self {
 			FunctionRegisterBehavior::ExpressionFunction { is_generator, .. }

checker/src/behavior/objects.rs

@@ -32,9 +32,10 @@ impl ObjectBuilder {
 		value: PropertyValue,
 		position: Option<SpanWithSource>,
 	) {
-		environment.facts.register_property(self.object, publicity, under, value, true, position)
+		environment.facts.register_property(self.object, publicity, under, value, true, position);
 	}
 
+	#[must_use]
 	pub fn build_object(self) -> TypeId {
 		self.object
 	}

checker/src/behavior/operations.rs

@@ -63,7 +63,7 @@ pub fn evaluate_pure_binary_operation_handle_errors<T: crate::ReadFromFS, M: AST
 		PureBinaryOperation::EqualityAndInequality(operator) => {
 			evaluate_equality_inequality_operation(
 				lhs,
-				operator,
+				&operator,
 				rhs,
 				&mut checking_data.types,
 				checking_data.options.strict_casts,
@@ -82,7 +82,7 @@ pub fn evaluate_mathematical_operation(
 ) -> Result<TypeId, ()> {
 	fn attempt_constant_math_operator(
 		lhs: TypeId,
-		operator: MathematicalAndBitwise,
+		operator: &MathematicalAndBitwise,
 		rhs: TypeId,
 		types: &mut TypeStore,
 		strict_casts: bool,
@@ -153,7 +153,7 @@ pub fn evaluate_mathematical_operation(
 		return Ok(types.register_type(crate::Type::Constructor(constructor)));
 	}
 
-	attempt_constant_math_operator(lhs, operator, rhs, types, strict_casts)
+	attempt_constant_math_operator(lhs, &operator, rhs, types, strict_casts)
 }
 
 /// Not canonical / reducible
@@ -178,7 +178,7 @@ pub enum CanonicalEqualityAndInequality {
 
 pub fn evaluate_equality_inequality_operation(
 	lhs: TypeId,
-	operator: EqualityAndInequality,
+	operator: &EqualityAndInequality,
 	rhs: TypeId,
 	types: &mut TypeStore,
 	strict_casts: bool,
@@ -202,7 +202,7 @@ pub fn evaluate_equality_inequality_operation(
 
 			match attempt_constant_equality(lhs, rhs, types) {
 				Ok(ty) => Ok(ty),
-				Err(_) => {
+				Err(()) => {
 					unreachable!("should have been caught by above")
 				}
 			}
@@ -248,7 +248,7 @@ pub fn evaluate_equality_inequality_operation(
 		EqualityAndInequality::StrictNotEqual => {
 			let equality_result = evaluate_equality_inequality_operation(
 				rhs,
-				EqualityAndInequality::StrictEqual,
+				&EqualityAndInequality::StrictEqual,
 				lhs,
 				types,
 				strict_casts,
@@ -267,7 +267,7 @@ pub fn evaluate_equality_inequality_operation(
 		EqualityAndInequality::NotEqual => {
 			let equality_result = evaluate_equality_inequality_operation(
 				rhs,
-				EqualityAndInequality::Equal,
+				&EqualityAndInequality::Equal,
 				lhs,
 				types,
 				strict_casts,
@@ -281,15 +281,15 @@ pub fn evaluate_equality_inequality_operation(
 		}
 		EqualityAndInequality::GreaterThan => evaluate_equality_inequality_operation(
 			rhs,
-			EqualityAndInequality::LessThan,
+			&EqualityAndInequality::LessThan,
 			lhs,
 			types,
 			strict_casts,
 		),
 		EqualityAndInequality::LessThanEqual => {
 			let lhs = evaluate_equality_inequality_operation(
 				rhs,
-				EqualityAndInequality::StrictEqual,
+				&EqualityAndInequality::StrictEqual,
 				lhs,
 				types,
 				strict_casts,
@@ -300,15 +300,15 @@ pub fn evaluate_equality_inequality_operation(
 			} else if lhs == TypeId::FALSE {
 				evaluate_equality_inequality_operation(
 					rhs,
-					EqualityAndInequality::LessThan,
+					&EqualityAndInequality::LessThan,
 					lhs,
 					types,
 					strict_casts,
 				)
 			} else {
 				let rhs = evaluate_equality_inequality_operation(
 					rhs,
-					EqualityAndInequality::LessThan,
+					&EqualityAndInequality::LessThan,
 					lhs,
 					types,
 					strict_casts,
@@ -318,7 +318,7 @@ pub fn evaluate_equality_inequality_operation(
 		}
 		EqualityAndInequality::GreaterThanEqual => evaluate_equality_inequality_operation(
 			rhs,
-			EqualityAndInequality::LessThanEqual,
+			&EqualityAndInequality::LessThanEqual,
 			lhs,
 			types,
 			strict_casts,
@@ -339,7 +339,7 @@ pub fn evaluate_logical_operation_with_expression<
 	M: crate::ASTImplementation,
 >(
 	lhs: TypeId,
-	operator: Logical,
+	operator: &Logical,
 	rhs: &M::Expression,
 	checking_data: &mut CheckingData<T, M>,
 	environment: &mut Environment,
@@ -399,7 +399,7 @@ pub fn evaluate_logical_operation_with_expression<
 		Logical::NullCoalescing => {
 			let is_lhs_null = evaluate_equality_inequality_operation(
 				lhs,
-				EqualityAndInequality::StrictEqual,
+				&EqualityAndInequality::StrictEqual,
 				TypeId::NULL_TYPE,
 				&mut checking_data.types,
 				checking_data.options.strict_casts,