Merge pull request #107 from Pivot-Studio/Chronostasys/issue103

Chronostasys/issue103

Author: RINNE-TAN

src/ast/ctx.rs

@@ -4,7 +4,8 @@ use inkwell::{
     AddressSpace,
 };
 
-use super::ctx::{Ctx, FNType, Mod};
+use super::ctx::{Ctx, Mod};
+use super::pltype::FNType;
 
 impl<'a, 'ctx> Ctx<'a, 'ctx> {
     pub fn mv2heap(&self, val: BasicValueEnum<'ctx>) -> BasicValueEnum<'ctx> {

src/ast/gcapi.rs

@@ -5,5 +5,6 @@ pub mod diag;
 pub mod dot;
 pub mod gcapi;
 pub mod node;
+pub mod pltype;
 pub mod range;
 pub mod tokens;

src/ast/mod.rs

@@ -1,7 +1,8 @@
 use super::statement::StatementsNode;
 use super::*;
-use crate::ast::ctx::{Ctx, PriType};
+use crate::ast::ctx::Ctx;
 use crate::ast::diag::ErrorCode;
+use crate::ast::pltype::PriType;
 use internal_macro::range;
 
 #[range]

src/ast/node/control.rs

@@ -1,9 +1,9 @@
 use super::statement::StatementsNode;
 use super::*;
 use super::{alloc, types::TypedIdentifierNode, Node, TypeNode};
-use crate::ast::ctx::{FNType, PLType};
 use crate::ast::diag::ErrorCode;
 use crate::ast::node::{deal_line, tab};
+use crate::ast::pltype::{FNType, PLType};
 use crate::utils::read_config::enter;
 use inkwell::debug_info::*;
 use inkwell::values::FunctionValue;
@@ -354,6 +354,7 @@ pub struct FuncTypeNode {
     pub ret: Box<TypeNodeEnum>,
     pub doc: Vec<Box<NodeEnum>>,
     pub declare: bool,
+    pub generics: Option<Box<GenericDefNode>>,
 }
 impl FuncTypeNode {
     pub fn emit_func_type<'a, 'ctx>(

src/ast/node/function.rs

@@ -26,8 +26,9 @@ use self::ret::*;
 use self::statement::*;
 use self::types::*;
 
-use super::ctx::{PLDiag, PLType};
+use super::ctx::PLDiag;
 use super::diag::ErrorCode;
+use super::pltype::PLType;
 use super::range::{Pos, Range};
 
 pub mod comment;

src/ast/node/mod.rs

@@ -1,8 +1,8 @@
 use super::primary::VarNode;
 use super::*;
 use crate::ast::ctx::Ctx;
-use crate::ast::ctx::PLType;
-use crate::ast::ctx::PriType;
+use crate::ast::pltype::PLType;
+use crate::ast::pltype::PriType;
 use crate::ast::tokens::TokenType;
 
 use crate::ast::diag::ErrorCode;

src/ast/node/operator.rs

@@ -5,9 +5,10 @@ use lsp_types::SemanticTokenType;
 
 use crate::{
     ast::{
-        ctx::{get_ns_path_completions, Ctx, PLType},
+        ctx::{get_ns_path_completions, Ctx},
         diag::ErrorCode,
         node::{deal_line, tab},
+        pltype::PLType,
     },
     utils::read_config::enter,
 };

src/ast/node/pkg.rs

@@ -1,6 +1,7 @@
 use super::*;
-use crate::ast::ctx::{Ctx, PLType, PriType};
+use crate::ast::ctx::Ctx;
 use crate::ast::diag::ErrorCode;
+use crate::ast::pltype::{PLType, PriType};
 use internal_macro::range;
 use lsp_types::SemanticTokenType;
 

src/ast/node/primary.rs

@@ -3,8 +3,9 @@ use std::rc::Rc;
 
 use super::primary::VarNode;
 use super::*;
-use crate::ast::ctx::{ARRType, Ctx, Field, PLType, STType};
+use crate::ast::ctx::Ctx;
 use crate::ast::diag::ErrorCode;
+use crate::ast::pltype::{ARRType, Field, PLType, STType};
 use crate::ast::range::Range;
 use crate::utils::read_config::enter;
 use inkwell::types::{AnyType, BasicType};
@@ -248,7 +249,13 @@ impl StructDefNode {
             refs: Rc::new(RefCell::new(vec![])),
             doc: vec![],
             methods: FxHashMap::default(),
+            generics: None,
+            is_generic_place_holder: false,
         })));
+        // skip generics
+        if self.generics.is_some() {
+            return;
+        }
         ctx.context
             .opaque_struct_type(&ctx.plmod.get_full_name(&self.id.name));
         _ = ctx.add_type(self.id.name.clone(), stu, self.range);
@@ -289,30 +296,34 @@ impl StructDefNode {
             i = i + 1;
         }
         let name = self.id.name.as_str();
-        let st = ctx
-            .module
-            .get_struct_type(&ctx.plmod.get_full_name(name))
-            .unwrap();
         let newf = order_fields.clone();
-        st.set_body(
-            &order_fields
-                .into_iter()
-                .map(|order_field| {
-                    order_field
-                        .pltype
-                        .get_type(ctx)
-                        .unwrap()
-                        .borrow()
-                        .get_basic_type(&ctx)
-                })
-                .collect::<Vec<_>>(),
-            false,
-        );
+        // skip generics
+        if self.generics.is_none() {
+            let st = ctx
+                .module
+                .get_struct_type(&ctx.plmod.get_full_name(name))
+                .unwrap();
+            st.set_body(
+                &order_fields
+                    .into_iter()
+                    .map(|order_field| {
+                        order_field
+                            .pltype
+                            .get_type(ctx)
+                            .unwrap()
+                            .borrow()
+                            .get_basic_type(&ctx)
+                    })
+                    .collect::<Vec<_>>(),
+                false,
+            );
+        }
         let tp = ctx.get_type(&self.id.name.as_str(), self.range).unwrap();
         if let PLType::STRUCT(st) = &mut *tp.borrow_mut() {
             st.fields = fields;
             st.ordered_fields = newf;
             st.doc = self.doc.clone();
+            st.generics = self.generics.clone();
         }
         ctx.set_if_refs_tp(tp.clone(), self.range);
         ctx.add_doc_symbols(tp.clone());
@@ -521,3 +532,33 @@ impl Node for ArrayInitNode {
 pub struct GenericDefNode {
     pub generics: Vec<Box<VarNode>>,
 }
+
+impl GenericDefNode {
+    pub fn child_ctx<'a, 'ctx>(&'a mut self, ctx: &'a mut Ctx<'a, 'ctx>) -> Ctx<'a, 'ctx> {
+        let mut child = ctx.new_child(self.range.start);
+        for gen in self.generics.iter() {
+            let range = gen.range();
+            let name = "__generic__".to_string() + gen.name.clone().as_str();
+            let pltype = PLType::STRUCT(STType {
+                name,
+                path: ctx.plmod.path.clone(),
+                fields: FxHashMap::default(),
+                ordered_fields: vec![],
+                range,
+                refs: Rc::new(RefCell::new(vec![])),
+                doc: vec![],
+                methods: FxHashMap::default(),
+                generics: None,
+                is_generic_place_holder: true,
+            });
+            _ = child.add_type(gen.name.clone(), Rc::new(RefCell::new(pltype)), range);
+        }
+        child
+    }
+}
+
+#[range]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct GenericParamNode {
+    pub generics: Vec<Box<NodeEnum>>,
+}