Adding TypeAlias to TypeDefinition

Cargo.toml

@@ -51,12 +51,12 @@ ligen-gui-runtime       = { path = "tools/editor/dependencies/gui-runtime" }
 is-tree                 = "0.9.7"
 serde                   = { version = "1", features = ["derive"] }
 enum-as-inner           = "0.6.0"
-serde_json              = "^1.0.0"
+serde_json              = "1"
 shrinkwraprs            = "0.3"
 derive_more             = "0.99"
 lazy_static             = "1.4.0"
 pretty_assertions       = "1.4.0"
-syn                     = { version = "2.0.76", features = [ "full" ] }
+syn                     = { version = "2.0.77", features = [ "full" ] }
 regex = "1"
 
 # If you want to use the bleeding edge version of egui and eframe:

ecosystem/rust/parser/src/module/mod.rs

@@ -6,6 +6,7 @@ use syn::spanned::Spanned;
 use ligen::ir::Object;
 use ligen::parser::{Parser, ParserConfig};
 use crate::prelude::*;
+use crate::types::type_alias::TypeAliasParser;
 use ligen::ir::{Function, Module, Import, TypeDefinition, Interface};
 use crate::object::ObjectParser;
 use crate::function::FunctionParser;
@@ -77,8 +78,8 @@ impl ModuleParser {
                     types.push(EnumerationParser::new().parse(enumeration.clone(), config)?),
                 syn::Item::Struct(structure) =>
                     types.push(StructureParser::new().parse(structure.clone(), config)?),
-                syn::Item::Type(_type) => {
-                    todo!("Type object isn't implemented yet.")
+                syn::Item::Type(type_) => {
+                    types.push(TypeAliasParser::new().parse(type_.clone(), config)?);
                 },
                 syn::Item::Union(_union) => {
                     todo!("Union object isn't implemented yet.")

ecosystem/rust/parser/src/types/type_definition/mod.rs

@@ -2,3 +2,4 @@
 
 pub mod structure;
 pub mod enumeration;
+pub mod type_alias;

ecosystem/rust/parser/src/types/type_definition/type_alias/mod.rs

@@ -0,0 +1,65 @@
+//! Structure representation.
+
+use crate::prelude::*;
+use crate::types::{GenericsParser, TypeParser};
+use ligen::ir::{TypeAlias, TypeDefinition};
+use ligen::parser::{Parser, ParserConfig};
+use crate::identifier::IdentifierParser;
+use crate::macro_attributes::attributes::AttributesParser;
+use crate::visibility::VisibilityParser;
+
+#[derive(Default)]
+pub struct TypeAliasParser;
+
+impl TypeAliasParser {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl Parser<proc_macro::TokenStream> for TypeAliasParser {
+    type Output = TypeDefinition;
+    fn parse(&self, token_stream: proc_macro::TokenStream, config: &ParserConfig) -> Result<Self::Output> {
+        self.parse(proc_macro2::TokenStream::from(token_stream), config)
+    }
+}
+
+impl Parser<proc_macro2::TokenStream> for TypeAliasParser {
+    type Output = TypeDefinition;
+    fn parse(&self, tokenstream: proc_macro2::TokenStream, config: &ParserConfig) -> Result<Self::Output> {
+        syn::parse2::<syn::ItemType>(tokenstream)
+            .map_err(|e| Error::Message(format!("Failed to parse to structure: {:?}", e)))
+            .and_then(|structure| self.parse(structure, config))
+    }
+}
+
+impl Parser<syn::ItemType> for TypeAliasParser {
+    type Output = TypeDefinition;
+    fn parse(&self, type_alias: syn::ItemType, config: &ParserConfig) -> Result<Self::Output> {
+        let attributes = AttributesParser::default().parse(type_alias.attrs, config)?;
+        let identifier = IdentifierParser::new().parse(type_alias.ident, config)?;
+        let visibility = VisibilityParser::new().parse(type_alias.vis, config)?;
+        let interfaces = Default::default();
+        let type_ = TypeParser::default().parse(*type_alias.ty, config)?;
+        let definition = TypeAlias { type_ }.into();
+        let generics = GenericsParser::default().parse(type_alias.generics, config)?;
+        Ok(Self::Output { attributes, visibility, identifier, generics, interfaces, definition })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::*;
+
+    use ligen::parser::assert::*;
+    use ligen::ir::type_alias::mock;
+
+    use super::TypeAliasParser;
+
+    #[test]
+    fn type_alias() -> Result<()> {
+        assert_eq(TypeAliasParser, mock::type_alias(), quote! {
+            pub type Integer = i32;
+        })
+    }
+}

ligen/ir/src/types/mod.rs

@@ -2,6 +2,6 @@ pub mod type_definition;
 pub mod type_;
 pub mod generics;
 
-pub use type_definition::{TypeDefinition, KindDefinition, Enumeration, Structure, Field, Variant, structure, enumeration};
+pub use type_definition::{TypeDefinition, KindDefinition, Enumeration, Structure, TypeAlias, Field, Variant, structure, enumeration, type_alias};
 pub use type_::*;
 pub use generics::*;

ligen/ir/src/types/type_definition/kind_definition/mod.rs

@@ -1,40 +1,46 @@
 pub mod structure;
 pub mod enumeration;
+pub mod type_alias;
 
 use crate::prelude::*;
 
 pub use structure::{Structure, Field};
 pub use enumeration::{Enumeration, Variant};
+pub use type_alias::TypeAlias;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[allow(missing_docs)]
 pub enum KindDefinition {
     Structure(Structure),
-    Enumeration(Enumeration)
+    Enumeration(Enumeration),
+    TypeAlias(TypeAlias)
 }
 
 impl KindDefinition {
     /// Returns the name of the kind.
     pub fn kind_name(&self) -> &'static str {
         match self {
             Self::Structure(_) => "Structure",
-            Self::Enumeration(_) => "Enumeration"
+            Self::Enumeration(_) => "Enumeration",
+            Self::TypeAlias(_) => "TypeAlias"
         }
     }
 
     /// Returns `true` if the kind is empty.
     pub fn is_empty(&self) -> bool {
         match self {
             Self::Structure(structure) => structure.fields.is_empty(),
-            Self::Enumeration(enumeration) => enumeration.variants.is_empty()
+            Self::Enumeration(enumeration) => enumeration.variants.is_empty(),
+            Self::TypeAlias(_) => false
         }
     }
 
     /// Returns the number of items in the kind.
     pub fn count(&self) -> usize {
         match self {
             Self::Structure(structure) => structure.fields.len(),
-            Self::Enumeration(enumeration) => enumeration.variants.len()
+            Self::Enumeration(enumeration) => enumeration.variants.len(),
+            Self::TypeAlias(_) => 0
         }
 
     }
@@ -57,3 +63,9 @@ impl From<Enumeration> for KindDefinition {
         Self::Enumeration(enumeration)
     }
 }
+
+impl From<TypeAlias> for KindDefinition {
+    fn from(value: TypeAlias) -> Self {
+        Self::TypeAlias(value)
+    }
+}

ligen/ir/src/types/type_definition/kind_definition/type_alias/mock.rs

@@ -0,0 +1,11 @@
+use crate::{Type, TypeAlias, TypeDefinition};
+
+pub fn type_alias() -> TypeDefinition {
+    TypeDefinition {
+        identifier: "Integer".into(),
+        definition: TypeAlias {
+            type_: Type::i32()
+        }.into(),
+        ..Default::default()
+    }
+}

ligen/ir/src/types/type_definition/kind_definition/type_alias/mod.rs

@@ -0,0 +1,11 @@
+//! Type alias module.
+use crate::{prelude::*, Type};
+
+#[cfg(any(test, feature = "mocks"))]
+pub mod mock;
+
+/// Type alias representation.
+#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TypeAlias {
+    pub type_: Type
+}

ligen/parser/src/parser/universal/attributes/mod.rs

@@ -3,7 +3,7 @@ pub mod attribute;
 use crate::prelude::*;
 use crate::parser::{Parser, ParserConfig};
 use attribute::intermediary_attribute::IntermediaryAttribute;
-use ligen_ir::Attributes;
+use ligen_ir::{Attribute, Attributes, Literal};
 use attribute::AttributeParser;
 use crate::parser::universal::literal::LiteralParser;
 
@@ -29,9 +29,14 @@ impl<L: LiteralParser> Parser<&str> for AttributesParser<L>
 {
     type Output = Attributes;
     fn parse(&self, input: &str, config: &ParserConfig) -> Result<Self::Output> {
-        syn::parse_str::<syn2::punctuated::Punctuated<IntermediaryAttribute, syn::token::Comma>>(input)
+        let attributes = syn::parse_str::<syn2::punctuated::Punctuated<IntermediaryAttribute, syn::token::Comma>>(input)
             .map_err(|e| Error::Message(format!("Failed to parse attributes: {}. Input: {}", e, input)))
-            .and_then(|input| self.parse(input.0, config))
+            .and_then(|input| self.parse(input.0, config));
+        if let Ok(attributes) = attributes {
+            Ok(attributes)
+        } else {
+            Ok(Attributes::from(Attribute::from(Literal::from(input))))
+        }
     }
 }
 

tools/editor/src/gui/ui/layout/editor/ir/type_/type_definition/kind_definition/mod.rs

@@ -2,9 +2,11 @@ use ligen_gui_runtime::egui::ComboBox;
 
 mod structure;
 mod enumeration;
+mod type_alias;
 
 pub use structure::*;
 pub use enumeration::*;
+pub use type_alias::*;
 use crate::gui::ui::TextPrinter;
 use crate::gui::ui::editor::settings::Settings;
 use crate::prelude::*;
@@ -43,7 +45,8 @@ impl Widget for KindDefinition {
     fn show(&mut self, settings: &Settings, ui: &mut egui::Ui, definition: &mut Self::Input) {
         match definition {
             ligen_ir::KindDefinition::Structure(structure) => Structure::new().show(settings, ui, structure),
-            ligen_ir::KindDefinition::Enumeration(enumeration) => Enumeration::new().show(settings, ui, enumeration)
+            ligen_ir::KindDefinition::Enumeration(enumeration) => Enumeration::new().show(settings, ui, enumeration),
+            ligen_ir::KindDefinition::TypeAlias(type_alias) => TypeAlias::new().show(settings, ui, type_alias),
         }
     }
 }

tools/editor/src/gui/ui/layout/editor/ir/type_/type_definition/kind_definition/type_alias/mod.rs

@@ -0,0 +1,22 @@
+pub use crate::prelude::*;
+
+
+use crate::gui::ui::{EditableList, editor::{ir::{Visibility, Identifier, Attributes, Path}, widget::Widget, settings::Settings}};
+
+#[derive(Default)]
+pub struct TypeAlias;
+
+impl TypeAlias {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl Widget for TypeAlias {
+    type Input = ligen_ir::TypeAlias;
+    fn show(&mut self, settings: &Settings, ui: &mut egui::Ui, type_alias: &mut ligen_ir::TypeAlias) {
+        // EditableList::new("Variants", "Add variant").show(settings, ui, &mut enumeration.variants, |ui, variant| {
+        //     Variant::new().show(settings, ui, variant);
+        // });
+    }
+}