chore: removed all of the warnings

Zffu · Zffu · commit d83934e42535 · 2026-04-14T00:31:34.000+02:00
diff --git a/compiler/ast_parser/src/structs/enums.rs b/compiler/ast_parser/src/structs/enums.rs
@@ -1,9 +1,9 @@
 use ast::{tree::{ASTTreeNode, ASTTreeNodeKind}, types::ASTType};
 use compiler_utils::hash::HashedString;
-use diagnostics::{DiagnosticResult, diagnostic::Diagnostic};
+use diagnostics::{DiagnosticResult};
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{functions::parse_function_declaraction, structs::members::parse_types_field_member, types::{parse_type_generic, parse_type_parameters_declaration}};
+use crate::{functions::parse_function_declaraction, structs::members::parse_types_field_member, types::{parse_type_parameters_declaration}};
 
 pub fn parse_enum_entry(tokens: &Vec<LexerToken>, ind: &mut usize) -> DiagnosticResult<Box<ASTTreeNode>> {
 	let start = tokens[*ind].pos.clone();
diff --git a/compiler/ast_parser/src/use_statements.rs b/compiler/ast_parser/src/use_statements.rs
@@ -40,5 +40,5 @@ pub fn parse_use_statement(tokens: &Vec<LexerToken>, ind: &mut usize) -> Diagnos
 
 	*ind += 1;
 
-	return Ok((Box::new(ASTTreeNode::new(ASTTreeNodeKind::UseStatement { shards: steps, use_clauses: uses }, start, tokens[*ind].get_end_pos()))))
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::UseStatement { shards: steps, use_clauses: uses }, start, tokens[*ind].get_end_pos())))
 }
diff --git a/compiler/astoir_hir/src/nodes.rs b/compiler/astoir_hir/src/nodes.rs
@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 
-use compiler_typing::{enums::{RawEnumEntryContainer, RawEnumTypeContainer}, raw::RawType, references::TypeReference, storage::{BOOLEAN_TYPE, STATIC_STR}, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
+use compiler_typing::{enums::{RawEnumTypeContainer}, raw::RawType, references::TypeReference, structs::RawStructTypeContainer, transmutation::array::can_transmute_inner, tree::Type};
 use compiler_utils::{Position, hash::SelfHash};
 use diagnostics::{DiagnosticSpanOrigin, builders::{make_diff_type, make_diff_type_val}, diagnostic::{Diagnostic, Span, SpanKind, SpanPosition}, unsure_panic};
 use lexer::toks::{comp::ComparingOperator, math::MathOperator};
diff --git a/compiler/astoir_hir_lowering/src/enums.rs b/compiler/astoir_hir_lowering/src/enums.rs
@@ -29,7 +29,7 @@ pub fn lower_ast_enum_entry(context: &mut HIRContext, node: Box<ASTTreeNode>, co
 }
 
 pub fn lower_ast_enum(context: &mut HIRContext, node: Box<ASTTreeNode>) -> DiagnosticResult<Box<HIRNode>> {
-	if let ASTTreeNodeKind::EnumDeclaration { name, entries, functions, type_params } = node.kind.clone() {
+	if let ASTTreeNodeKind::EnumDeclaration { name, entries, functions: _, type_params } = node.kind.clone() {
 		let mut container = RawEnumTypeContainer::new(context.type_storage.types.vals.len(), type_params);
 
 		for entry in entries {
diff --git a/compiler/astoir_mir/src/builder.rs b/compiler/astoir_mir/src/builder.rs
@@ -1,7 +1,7 @@
 //! Utility functions to build instructions and more
 
 use compiler_typing::{SizedType, raw::RawType, storage::TypeStorage, tree::Type};
-use diagnostics::{DiagnosticResult, MaybeDiagnostic, diagnostic::Diagnostic, unsure_panic};
+use diagnostics::{DiagnosticResult, MaybeDiagnostic, unsure_panic};
 
 use crate::{blocks::{hints::MIRValueHint, refer::MIRBlockReference}, ctx::MIRContext, insts::MIRInstruction, vals::{arrays::MIRArrayValue, base::BaseMIRValue, float::MIRFloatValue, int::MIRIntValue, ptr::MIRPointerValue, structs::MIRStructValue}};
 
diff --git a/compiler/astoir_mir_lowering/src/casts.rs b/compiler/astoir_mir_lowering/src/casts.rs
@@ -5,7 +5,7 @@ use diagnostics::DiagnosticResult;
 use crate::{MIRLoweringContext, lower_hir_type, values::lower_hir_value};
 
 pub fn lower_cast(block: MIRBlockReference, node: Box<HIRNode>, ctx: &mut MIRLoweringContext) -> DiagnosticResult<BaseMIRValue> {
-	if let HIRNodeKind::CastValue { intentional, value, old_type, new_type } = node.kind.clone() {
+	if let HIRNodeKind::CastValue { intentional: _, value, old_type, new_type } = node.kind.clone() {
 		let value = lower_hir_value(block, value, ctx)?;
 		let old_type = lower_hir_type(ctx, old_type)?;
 
diff --git a/compiler/astoir_mir_lowering/src/introductions.rs b/compiler/astoir_mir_lowering/src/introductions.rs
@@ -13,7 +13,7 @@ pub fn handle_var_introduction_queue(block: MIRBlockReference, node: Box<HIRNode
 		let new_var = new_var.unwrap();
 		let eligible = ctx.hir_ctx.function_contexts[func].as_ref().unwrap().is_eligible_for_ssa(new_var);
 
-		let casted = cast_to_enum_child(block, original, new_type.as_generic(&ctx.hir_ctx.type_storage), ctx, &*node)?;
+		let casted = cast_to_enum_child(block, original, new_type.as_generic(), ctx, &*node)?;
 
 		if eligible {
 			ctx.mir_ctx.blocks[block].variables.insert(new_var, MIRBlockVariableSSAHint { kind: MIRBlockVariableType::SSA, hint: Some(casted) });
diff --git a/compiler/astoir_mir_lowering/src/lib.rs b/compiler/astoir_mir_lowering/src/lib.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, hash::Hash};
+use std::{collections::HashMap};
 
 use astoir_hir::{ctx::HIRContext, nodes::{HIRNode, HIRNodeKind}};
 use astoir_mir::ctx::MIRContext;
diff --git a/compiler/astoir_mir_lowering/src/type_tools.rs b/compiler/astoir_mir_lowering/src/type_tools.rs
@@ -1,13 +1,11 @@
-use std::clone;
-
 use astoir_hir::nodes::{HIRNode, HIRNodeKind};
 use astoir_mir::{blocks::refer::MIRBlockReference, builder::{build_comp_eq, build_field_pointer, build_ir_cast, build_load, build_unsigned_int_const}, vals::{base::BaseMIRValue, int::MIRIntValue}};
 use compiler_typing::{SizedType, raw::RawType, tree::Type};
 use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::{make_req_type_kind, make_type_not_partof}};
 
 use crate::{MIRLoweringContext, lower_hir_type, values::lower_hir_value, vars::lower_hir_variable_reference};
 
-pub fn is_enum_value_of_kind<K: DiagnosticSpanOrigin>(block: MIRBlockReference, val: BaseMIRValue, enum_entry: RawType, ctx: &mut MIRLoweringContext, origin: &K) -> DiagnosticResult<MIRIntValue> {
+pub fn is_enum_value_of_kind<K: DiagnosticSpanOrigin>(_block: MIRBlockReference, val: BaseMIRValue, enum_entry: RawType, ctx: &mut MIRLoweringContext, origin: &K) -> DiagnosticResult<MIRIntValue> {
 	let enum_type = match ctx.mir_ctx.ssa_hints.get_hint(val.get_ssa_index()).get_type().as_generic_lowered_safe(origin)? {
 		RawType::Enum(v) => v,
 		RawType::LoweredStruct(_, container) => {
@@ -48,7 +46,7 @@ pub fn is_enum_value_of_kind<K: DiagnosticSpanOrigin>(block: MIRBlockReference,
 	return build_comp_eq(&mut ctx.mir_ctx, hint_val, hint_true);
 }
 
-pub fn cast_to_enum_child<K: DiagnosticSpanOrigin>(block: MIRBlockReference, val: BaseMIRValue, enum_entry: RawType, ctx: &mut MIRLoweringContext, origin: &K) -> DiagnosticResult<BaseMIRValue> {
+pub fn cast_to_enum_child<K: DiagnosticSpanOrigin>(_block: MIRBlockReference, val: BaseMIRValue, enum_entry: RawType, ctx: &mut MIRLoweringContext, origin: &K) -> DiagnosticResult<BaseMIRValue> {
 	let enum_type = match ctx.mir_ctx.ssa_hints.get_hint(val.get_ssa_index()).get_type().as_generic_lowered_safe(origin)? {
 		RawType::Enum(v) => v,
 		RawType::LoweredStruct(_, container) => {
@@ -107,7 +105,7 @@ pub fn lower_hir_unwrap_cond(block: MIRBlockReference, node: Box<HIRNode>, ctx:
 }
 
 pub fn lower_hir_unwrap_value(block: MIRBlockReference, node: Box<HIRNode>, ctx: &mut MIRLoweringContext) -> DiagnosticResult<BaseMIRValue> {
-	if let HIRNodeKind::UnwrapValue { original, new_type, unsafe_unwrap } = node.kind.clone() {
+	if let HIRNodeKind::UnwrapValue { original, new_type, unsafe_unwrap: _ } = node.kind.clone() {
 		let original = lower_hir_value(block, original, ctx)?;
 		let new_type = lower_hir_type(ctx, new_type)?;
 
diff --git a/compiler/compiler_main/Cargo.toml b/compiler/compiler_main/Cargo.toml
@@ -8,7 +8,7 @@ astoir = { path = "../astoir" }
 ast = { path = "../ast" }
 ast_parser = { path = "../ast_parser" }
 lexer = { path = "../lexer" }
-llvm_ir_bridge = { path = "../llvm_ir_bridge", optional = true }
+llvm_ir_bridge = { path = "../llvm_ir_bridge", optional = true, default-features = false}
 diagnostics = { path = "../diagnostics" }
 compiler_utils = { path = "../compiler_utils" }
 
diff --git a/compiler/compiler_main/src/cmds/astoir.rs b/compiler/compiler_main/src/cmds/astoir.rs
@@ -43,7 +43,7 @@ pub fn parse_astoir_command(arguments: Vec<String>) {
 
 				dump_diagnostics();
 
-				fs::write(res_path, format!("{}", ctx.unwrap()));
+				let _ = fs::write(res_path, format!("{}", ctx.unwrap()));
 			},
 
 			IRLevel::LLVM => {
@@ -57,7 +57,7 @@ pub fn parse_astoir_command(arguments: Vec<String>) {
 	
 					dump_diagnostics();
 	
-					ctx.module.print_to_file(res_path);
+					let _ = ctx.module.print_to_file(res_path);
 				}
 
 				#[cfg(not(feature = "llvm_ir_bridge"))] {
@@ -79,7 +79,7 @@ fn parse_astoir_level(str: &String) -> DiagnosticResult<IRLevel> {
 
 		_ => {
 			println!("Invalid level");
-			std::process::exit(0);
+			exit(0);
 		}
 	};
 
diff --git a/compiler/compiler_typing/src/bounds/traits.rs b/compiler/compiler_typing/src/bounds/traits.rs
@@ -24,7 +24,7 @@ use std::fmt::Display;
 use compiler_utils::hash;
 use diagnostics::{MaybeDiagnostic, builders::make_bound_trait};
 
-use crate::{storage::TypeStorage, tree::Type};
+use crate::{tree::Type};
 
 pub const TRAIT_NUMERIC: u64 = hash!("numeric");
 pub const TRAIT_SIGNED: u64 = hash!("signed");
@@ -81,17 +81,17 @@ pub struct TraitBound {
 }
 
 impl TraitBound {
-	pub fn check(&self, t: &Type, storage: &TypeStorage) -> MaybeDiagnostic {
+	pub fn check(&self, t: &Type) -> MaybeDiagnostic {
 		for member in &self.members {
 			match member {
 				TraitBoundMember::Select(tt) => {
-					if !t.as_generic(storage).has_trait(tt.clone(), t) {
+					if !t.as_generic().has_trait(tt.clone(), t) {
 						return Err(make_bound_trait(tt, t).into())
 					}
 				},
 
 				TraitBoundMember::Exclude(tt) => {
-					if t.as_generic(storage).has_trait(tt.clone(), t) {
+					if t.as_generic().has_trait(tt.clone(), t) {
 						return Err(make_bound_trait(&format!("~{}", tt), t).into())
 					}
 				}
diff --git a/compiler/compiler_typing/src/enums.rs b/compiler/compiler_typing/src/enums.rs
@@ -1,6 +1,6 @@
 //! Declarations for enum-kind types.
 
-use std::{collections::HashMap, f32::consts::E};
+use std::{collections::HashMap};
 
 use compiler_utils::{hash::{HashedString}, utils::indexed::IndexStorage};
 use diagnostics::{DiagnosticResult, builders::{make_cannot_find_type_field, make_cannot_find_type_function, make_cannot_find_type_pos, make_enum_parent_fields}};
diff --git a/compiler/compiler_typing/src/tree.rs b/compiler/compiler_typing/src/tree.rs
@@ -4,7 +4,7 @@ use std::fmt::Display;
 
 use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::make_req_type_kind, unsure_panic};
 
-use crate::{RawTypeReference, SizedType, StructuredType, TypedFunction, raw::RawType, references::TypeReference, storage::{TypeStorage}, utils::get_pointer_size};
+use crate::{SizedType, StructuredType, TypedFunction, raw::RawType, references::TypeReference, storage::{TypeStorage}, utils::get_pointer_size};
 
 #[derive(Clone, PartialEq, Debug, Eq, Hash)]
 /// The node-based typing system of Quickfall. Allows for very specific types.
@@ -133,7 +133,7 @@ impl Type {
 		}
 	}	
  
-	pub fn as_generic(&self, storage: &TypeStorage) -> RawType {
+	pub fn as_generic(&self) -> RawType {
 		match self {
 			Self::GenericLowered(a) => return a.clone(),
 			Self::Generic(a, _, _) => {
diff --git a/compiler/diagnostics/src/diagnostic.rs b/compiler/diagnostics/src/diagnostic.rs
@@ -86,11 +86,13 @@ impl Diagnostic {
         }
 	}
 
-	pub fn maybe_display_backtrace(&self, fmt: &mut std::fmt::Formatter<'_>) {
+	pub fn maybe_display_backtrace(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		if cfg!(debug_assertions) {
-			writeln!(fmt, "Internally captured in:");
-			writeln!(fmt, "{}", self.backtrace.as_ref().unwrap());
+			writeln!(fmt, "Internally captured in:")?;
+			writeln!(fmt, "{}", self.backtrace.as_ref().unwrap())?;
 		}
+
+		Ok(())
 	}
 
 	pub fn new(level: Level, decl: (usize, &str), primary_span: Span, spans: Vec<Span>, note: Vec<String>, help: Vec<String>) -> Self {
@@ -247,7 +249,7 @@ impl Display for Diagnostic {
 			ind += 1;
 		}
 
-		self.maybe_display_backtrace(f);
+		self.maybe_display_backtrace(f)?;
 		
 		Ok(())
 	}
diff --git a/compiler/diagnostics/src/lib.rs b/compiler/diagnostics/src/lib.rs
@@ -24,7 +24,7 @@ thread_local! {
 #[macro_export]
 macro_rules! unsure_panic {
 	($msg: expr) => { {
-		diagnostics::builders::make_unsure_panic(&$msg.to_string());
+		_ = diagnostics::builders::make_unsure_panic(&$msg.to_string());
 		diagnostics::dump_diagnostics();
 		panic!($msg);
 	}
diff --git a/compiler/llvm_ir_bridge/src/lib.rs b/compiler/llvm_ir_bridge/src/lib.rs
@@ -30,7 +30,7 @@ macro_rules! llvm_to_base  {
 	($exp:expr) => {
 		match $exp {
 			Ok(v) => v,
-			Err(e) => panic!("inkwell function failed")
+			Err(_) => panic!("inkwell function failed")
 		}
 	};
 }
@@ -40,7 +40,7 @@ macro_rules! llvm_to_base_returnless  {
 	($exp:expr) => {
 		match $exp {
 			Ok(_) => {},
-			Err(e) => panic!("inkwell function failed")
+			Err(_) => panic!("inkwell function failed")
 		}
 	};
 }

Original file line number	Diff line number	Diff line change
`@@ -40,5 +40,5 @@ pub fn parse_use_statement(tokens: &Vec<LexerToken>, ind: &mut usize) -> Diagnos`
`40`	`40`
`41`	`41`	`*ind += 1;`
`42`	`42`
`43`		`- return Ok((Box::new(ASTTreeNode::new(ASTTreeNodeKind::UseStatement { shards: steps, use_clauses: uses }, start, tokens[*ind].get_end_pos()))))`
	`43`	`+ return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::UseStatement { shards: steps, use_clauses: uses }, start, tokens[*ind].get_end_pos())))`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ pub fn lower_ast_enum_entry(context: &mut HIRContext, node: Box<ASTTreeNode>, co`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`pub fn lower_ast_enum(context: &mut HIRContext, node: Box<ASTTreeNode>) -> DiagnosticResult<Box<HIRNode>> {`
`32`		`- if let ASTTreeNodeKind::EnumDeclaration { name, entries, functions, type_params } = node.kind.clone() {`
	`32`	`+ if let ASTTreeNodeKind::EnumDeclaration { name, entries, functions: _, type_params } = node.kind.clone() {`
`33`	`33`	`let mut container = RawEnumTypeContainer::new(context.type_storage.types.vals.len(), type_params);`
`34`	`34`
`35`	`35`	`for entry in entries {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use std::{collections::HashMap, hash::Hash};`
	`1`	`+use std::{collections::HashMap};`
`2`	`2`
`3`	`3`	`use astoir_hir::{ctx::HIRContext, nodes::{HIRNode, HIRNodeKind}};`
`4`	`4`	`use astoir_mir::ctx::MIRContext;`