feat: trait derive

Author: Chronostasys

README.md

@@ -168,6 +168,8 @@ use_statement = "use" identifier ("::" identifier)* ";" ;
 
 string_literal = "\"" [^"]* "\"" ;
 
-trait_def = "trait" identifier generic_type_def? "{" function_def* "}" ;
+trait_def = "trait" identifier generic_type_def? (":" type_add)? "{" function_def* "}" ;
+
+type_add = type_name ("+" type_name)* ;
 
 ```

src/ast/node/implement.rs

@@ -63,7 +63,8 @@ impl Node for ImplNode {
                             .add_label(t.range(), Some(("type {}".to_string(), vec![name])))
                             .add_to_ctx(ctx);
                     };
-                    sttp.impls.push(trait_tp);
+                    sttp.impls
+                        .insert(trait_tp.clone().borrow().get_full_elm_name(), trait_tp);
                 }
                 ctx.send_if_go_to_def(self.target.range(), sttp.range, sttp.path.clone());
             }

src/ast/node/interface.rs

@@ -15,6 +15,7 @@ pub struct TraitDefNode {
     pub id: Box<VarNode>,
     pub generics: Option<Box<GenericDefNode>>,
     pub methods: Vec<FuncDefNode>,
+    pub derives: Vec<Box<TypeNodeEnum>>,
 }
 
 impl PrintTrait for TraitDefNode {
@@ -39,8 +40,11 @@ impl Node for TraitDefNode {
         for g in &mut self.generics {
             g.emit(ctx, builder)?;
         }
-        for method in &mut self.methods {
-            method.emit(ctx, builder)?;
+        for de in &self.derives {
+            de.emit_highlight(ctx);
+        }
+        for method in &self.methods {
+            method.emit_highlight(ctx);
         }
         Ok((None, None, TerminatorEnum::NONE))
     }
@@ -65,7 +69,8 @@ impl TraitDefNode {
             refs: Rc::new(RefCell::new(vec![])),
             doc: vec![],
             generic_map,
-            impls: vec![],
+            impls: FxHashMap::default(),
+            derives: vec![],
         })));
         builder.opaque_struct_type(&ctx.plmod.get_full_name(&self.id.name));
         _ = ctx.add_type(self.id.name.clone(), stu, self.id.range);
@@ -90,6 +95,10 @@ impl TraitDefNode {
                 );
             }
         }
+        let mut derives = vec![];
+        for de in &self.derives {
+            derives.push(de.get_type(ctx, builder)?);
+        }
         // type hash
         order_fields.push(Field {
             index: i,
@@ -125,6 +134,7 @@ impl TraitDefNode {
                 range: field.range,
                 refs: Rc::new(RefCell::new(vec![])),
             };
+            field.get_type(ctx, builder)?;
 
             ctx.set_if_refs(f.refs.clone(), field.id.range);
             fields.insert(id.name.to_string(), f.clone());
@@ -143,6 +153,7 @@ impl TraitDefNode {
         if let PLType::TRAIT(st) = &mut *pltype.borrow_mut() {
             st.fields = fields;
             st.ordered_fields = newf;
+            st.derives = derives;
             // st.doc = self.doc.clone();
         }
         ctx.set_if_refs_tp(pltype.clone(), self.id.range);

src/ast/node/mod.rs

@@ -243,6 +243,7 @@ impl<'a, 'ctx> Ctx<'a> {
         let expect = expect.unwrap();
         let range = node.range();
         let pri: Result<PrimaryNode, _> = (*node.clone()).try_into();
+        // basic type implicit cast
         if let Ok(pri) = pri {
             let num: Result<NumNode, _> = (*pri.value.clone()).try_into();
             if let Ok(numnode) = num {
@@ -333,16 +334,7 @@ impl<'a, 'ctx> Ctx<'a> {
                         // struct to trait
                         (PLType::TRAIT(t), PLType::STRUCT(st)) => {
                             let handle = builder.alloc("tmp_traitv", &expect.borrow(), self);
-                            if st
-                                .impls
-                                .iter()
-                                .find(|i| {
-                                    let ty1: &PLType = &i.borrow();
-                                    let ty2: &PLType = &expect.borrow();
-                                    ty1 == ty2
-                                })
-                                .is_none()
-                            {
+                            if !st.implements_trait(t) {
                                 return Err(mismatch_err!(
                                     self,
                                     range,

src/ast/node/types.rs

@@ -408,7 +408,8 @@ impl StructDefNode {
             refs: Rc::new(RefCell::new(vec![])),
             doc: vec![],
             generic_map,
-            impls: vec![],
+            impls: FxHashMap::default(),
+            derives: vec![],
         })));
         builder.opaque_struct_type(&ctx.plmod.get_full_name(&self.id.name));
         _ = ctx.add_type(self.id.name.clone(), stu, self.id.range);

src/ast/pltype.rs

@@ -632,10 +632,27 @@ pub struct STType {
     pub refs: Rc<RefCell<Vec<Location>>>,
     pub doc: Vec<Box<NodeEnum>>,
     pub generic_map: IndexMap<String, Rc<RefCell<PLType>>>,
-    pub impls: Vec<Rc<RefCell<PLType>>>,
+    pub impls: FxHashMap<String, Rc<RefCell<PLType>>>,
+    pub derives: Vec<Rc<RefCell<PLType>>>,
 }
 
 impl STType {
+    pub fn implements(&self, tp: &PLType) -> bool {
+        self.impls.get(&tp.get_full_elm_name()).is_some()
+    }
+    pub fn implements_trait(&self, tp: &STType) -> bool {
+        let re = self.impls.get(&tp.get_st_full_name()).is_some();
+        if !re {
+            return re;
+        }
+        for de in &tp.derives {
+            let re = self.implements(&de.borrow());
+            if !re {
+                return re;
+            }
+        }
+        true
+    }
     pub fn get_type_code(&self) -> u64 {
         let full_name = self.get_st_full_name();
         get_hash_code(full_name)

src/nomparser/types.rs

@@ -12,6 +12,7 @@ use crate::{
     },
 };
 use internal_macro::{test_parser, test_parser_error};
+use nom::sequence::preceded;
 use nom::{
     branch::alt,
     bytes::complete::tag,
@@ -156,12 +157,19 @@ pub fn trait_def(input: Span) -> IResult<Span, Box<TraitDefNode>> {
             tag_token_word(TokenType::TRAIT),
             identifier,
             opt(generic_type_def),
+            opt(preceded(tag_token_symbol(TokenType::COLON), type_add)),
             del_newline_or_space!(tag_token_symbol(TokenType::LBRACE)),
             many0(del_newline_or_space!(function_def)),
             del_newline_or_space!(tag_token_symbol(TokenType::RBRACE)),
         )),
-        |(_, id, generics, _, defs, (_, rr))| {
+        |(_, id, generics, derives, _, defs, (_, rr))| {
             let range = id.range().start.to(rr.end);
+            let mut de = vec![];
+            if let Some(derives) = derives {
+                for d in derives {
+                    de.push(d);
+                }
+            }
             Ok::<_, Error>(Box::new(TraitDefNode {
                 id,
                 generics,
@@ -173,7 +181,25 @@ pub fn trait_def(input: Span) -> IResult<Span, Box<TraitDefNode>> {
                     })
                     .collect(),
                 range,
+                derives: de,
             }))
         },
     )(input)
 }
+
+/// ```enbf
+/// type_add = type_name ("+" type_name)* ;
+/// ```
+#[test_parser("a+b+c")]
+#[test_parser("a")]
+#[test_parser(
+    "a + b
+    +
+    c"
+)]
+fn type_add(input: Span) -> IResult<Span, Vec<Box<TypeNodeEnum>>> {
+    separated_list1(
+        del_newline_or_space!(tag_token_symbol(TokenType::PLUS)),
+        type_name,
+    )(input)
+}

test/main.pi

@@ -152,6 +152,9 @@ impl TestTrait for mod1::Mod1 {
         return i;
     }
 
+}
+impl TestTrait2 for mod1::Mod1 {
+
 }
 
 fn test_trait() void {
@@ -381,11 +384,15 @@ fn main() i64 {
     test_trait();
     return 0;
 }
-trait TestTrait {
+trait TestTrait:TestTrait2 {
     fn name() void;
     fn test_ret(i:i64) i64;
 }
 
+trait TestTrait2 {
+
+}
+
 fn test_many_params(a: i64, b: i64, c: i64, d: i64) void {
     return;
 }