feat: added util conversion functions on GlobalStorageEntry

Author: Zffu

compiler/compiler_global_scope/src/entry.rs

@@ -2,6 +2,8 @@
 
 use std::fmt::Display;
 
+use diagnostics::{DiagnosticResult, DiagnosticSpanOrigin, builders::make_expected_simple_error};
+
 use crate::GlobalStorageIdentifier;
 
 #[derive(Clone, Debug)]
@@ -16,6 +18,56 @@ pub enum GlobalStorageEntryType<T, R> {
 	Type(R)
 }
 
+impl<T: Clone, R: Clone> GlobalStorageEntry<T, R> {
+	pub fn as_function<K: DiagnosticSpanOrigin>(&self, origin: &K) -> DiagnosticResult<(usize, usize)> {
+		match self.entry_type {
+			GlobalStorageEntryType::Function { descriptor_ind, impl_ind } => Ok((descriptor_ind, impl_ind)),
+
+			_ =>  Err(make_expected_simple_error(origin, &"function".to_string(), &self.entry_type).into())
+		}
+	}
+
+	pub fn as_implless_function<K: DiagnosticSpanOrigin>(&self, origin: &K) -> DiagnosticResult<usize> {
+		match self.entry_type {
+			GlobalStorageEntryType::ImplLessFunction(ind) => Ok(ind),
+
+			_ =>  Err(make_expected_simple_error(origin, &"implless function".to_string(), &self.entry_type).into())
+		}
+	}
+
+	pub fn as_struct_function<K: DiagnosticSpanOrigin>(&self, origin: &K) -> DiagnosticResult<(usize, usize, GlobalStorageIdentifier)> {
+		match self.entry_type {
+			GlobalStorageEntryType::StructFunction { descriptor_ind, impl_ind, struct_type } => Ok((descriptor_ind, impl_ind, struct_type)),
+
+			_ =>  Err(make_expected_simple_error(origin, &"struct function".to_string(), &self.entry_type).into())
+		}
+	}
+
+	pub fn as_static_variable<K: DiagnosticSpanOrigin>(&self, origin: &K) -> DiagnosticResult<T> {
+		match &self.entry_type {
+			GlobalStorageEntryType::StaticVariable(t) => Ok(t.clone()),
+
+			_ =>  Err(make_expected_simple_error(origin, &"static variable".to_string(), &self.entry_type).into())
+		}
+	}
+
+	pub fn as_type_alias<K: DiagnosticSpanOrigin>(&self, origin: &K) -> DiagnosticResult<T> {
+		match &self.entry_type {
+			GlobalStorageEntryType::TypeAlias(t) => Ok(t.clone()),
+
+			_ =>  Err(make_expected_simple_error(origin, &"type alias".to_string(), &self.entry_type).into())
+		}
+	}
+
+	pub fn as_type<K: DiagnosticSpanOrigin>(&self, origin: &K) -> DiagnosticResult<R> {
+		match &self.entry_type {
+			GlobalStorageEntryType::Type(t) => Ok(t.clone()),
+
+			_ =>  Err(make_expected_simple_error(origin, &"type".to_string(), &self.entry_type).into())
+		}
+	}
+}
+
 #[derive(Debug)]
 pub struct GlobalStorageEntry<T, R> {
 	pub entry_type: GlobalStorageEntryType<T, R>,

compiler/compiler_typing/src/lib.rs

@@ -18,7 +18,7 @@ pub mod storage;
 pub mod transmutation;
 pub mod bounds;
 
-pub type TypedGlobalScope<F, I> = GlobalScopeStorage<Type, RawType, F, I>;
+pub type TypedGlobalScope = GlobalScopeStorage<Type, RawType>;
 
 /// A function contained within a type.
 pub type TypedFunction = (Vec<(u64, TypeReference)>, Option<TypeReference>);
@@ -31,7 +31,7 @@ pub type RawTypeReference = usize;
 /// Represents a basic type that has a size. 
 pub trait SizedType {
 	/// Obtains the size of the type. The `compacted_size` parameter determines if the compacted size should be returned or not
-	fn get_size(&self, t: &Type, compacted_size: bool, storage: &TypeStorage) -> usize;
+	fn get_size(&self, t: &Type, compacted_size: bool, storage: &TypedGlobalScope) -> usize;
 }
 
 /// Represents a type that contains type parameters
@@ -46,20 +46,20 @@ pub trait TypeParamType {
 /// Represents types that can contain functions and more
 pub trait StructuredType {
 	#[must_use = "Must set the diagnostic position beforehand"]
-	fn get_function(&self, hash: u64, storage: &TypeStorage) -> DiagnosticResult<TypedFunction>;
+	fn get_function(&self, hash: u64, storage: &TypedGlobalScope) -> DiagnosticResult<TypedFunction>;
 
 	#[must_use = "Must set the diagnostic position beforehand"]
-	fn get_function_hash(&self, hash: u64, storage: &TypeStorage) -> DiagnosticResult<usize>;
+	fn get_function_hash(&self, hash: u64, storage: &TypedGlobalScope) -> DiagnosticResult<usize>;
 
 	#[must_use = "Must set the diagnostic position beforehand"]
-	fn get_field(&self, hash: u64, storage: &TypeStorage) -> DiagnosticResult<TypeReference>;
+	fn get_field(&self, hash: u64, storage: &TypedGlobalScope) -> DiagnosticResult<TypeReference>;
 
 	#[must_use = "Must set the diagnostic position beforehand"]
-	fn get_field_hash(&self, hash: u64, storage: &TypeStorage) -> DiagnosticResult<usize>;
+	fn get_field_hash(&self, hash: u64, storage: &TypedGlobalScope) -> DiagnosticResult<usize>;
 
 	#[must_use = "Must set the diagnostic position beforehand"]
-	fn get_fields(&self, storage: &TypeStorage) -> Vec<u64>;
+	fn get_fields(&self, storage: &TypedGlobalScope) -> Vec<u64>;
 
 	#[must_use = "Must set the diagnostic position beforehand"]
-	fn get_functions(&self, storage: &TypeStorage) -> Vec<u64>;
+	fn get_functions(&self, storage: &TypedGlobalScope) -> Vec<u64>;
 }

compiler/compiler_typing/src/raw.rs

@@ -2,7 +2,7 @@
 
 use std::{fmt::Display, hash::Hash};
 
-use crate::{SizedType, bounds::traits::Trait, enums::{RawEnumEntryContainer, RawEnumTypeContainer}, storage::TypeStorage, structs::{LoweredStructTypeContainer, RawStructTypeContainer}, tree::Type, utils::get_pointer_size};
+use crate::{SizedType, TypedGlobalScope, bounds::traits::Trait, enums::{RawEnumEntryContainer, RawEnumTypeContainer}, storage::TypeStorage, structs::{LoweredStructTypeContainer, RawStructTypeContainer}, tree::Type, utils::get_pointer_size};
 
 /// The raw types. Are also named generics
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -37,10 +37,10 @@ impl RawType {
 		return RawType::Integer(bits, false)
 	}
 
-	pub fn get_type_params_count(&self, storage: &TypeStorage) -> usize {
+	pub fn get_type_params_count(&self, storage: &TypedGlobalScope) -> usize {
 		match self {
 			RawType::Enum(container) => container.type_params.len(),
-			RawType::EnumEntry(container) => storage.types.vals[container.parent].get_type_params_count(storage),
+			RawType::EnumEntry(container),
 			RawType::Struct(_, container) => container.type_params.len(),
 
 			_ => 0
@@ -180,7 +180,7 @@ impl RawType {
 }
 
 impl SizedType for RawType {
-	fn get_size(&self, t: &Type, compacted_size: bool, storage: &TypeStorage) -> usize {
+	fn get_size(&self, t: &Type, compacted_size: bool, storage: &TypedGlobalScope) -> usize {
 		match self {
 			RawType::Integer(size, _) => *size,
 			RawType::Floating(size, _) => *size,

compiler/compiler_typing/src/storage.rs

@@ -58,6 +58,7 @@ pub const BOOLEAN_TYPE: u64 = hash!("bool");
 pub const RESULT_TYPE: u64 = hash!("result");
 
 #[derive(Debug)]
+#[deprecated = "Deprecated to use global scope"]
 pub struct TypeStorage {
 	pub types: IndexStorage<RawType>,
 	pub type_to_ind: HashMap<RawType, usize>