feat: supports tuple type

src/ast/builder/llvmbuilder.rs

@@ -222,8 +222,8 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> {
                 size_val,
             )
             .unwrap();
-        if let PLType::Struct(_) = pltype {
-            let f = self.get_or_insert_st_visit_fn_handle(&p);
+        if let PLType::Struct(tp) = pltype {
+            let f = self.get_or_insert_st_visit_fn_handle(&p, tp);
             let i = self.builder.build_ptr_to_int(
                 f.as_global_value().as_pointer_value(),
                 self.context.i64_type(),
@@ -526,10 +526,13 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> {
             PriType::BOOL => self.context.bool_type().as_basic_type_enum(),
         }
     }
-    fn get_or_insert_st_visit_fn_handle(&self, p: &PointerValue<'ctx>) -> FunctionValue<'ctx> {
+    fn get_or_insert_st_visit_fn_handle(
+        &self,
+        p: &PointerValue<'ctx>,
+        st: &STType,
+    ) -> FunctionValue<'ctx> {
         let ptrtp = p.get_type();
-        let ty = ptrtp.get_element_type().into_struct_type();
-        let llvmname = ty.get_name().unwrap().to_str().unwrap().to_string() + "@";
+        let llvmname = st.get_st_full_name() + "@";
         if let Some(v) = self.module.get_function(&llvmname) {
             return v;
         }
@@ -948,32 +951,37 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> {
         self.module
             .add_function(&llvmname, fn_type, Some(Linkage::External))
     }
+    fn get_fields(&self, pltp: &STType, ctx: &mut Ctx<'a>) -> Vec<BasicTypeEnum> {
+        ctx.run_in_type_mod(pltp, |ctx, pltp| {
+            pltp.get_all_field()
+                .iter()
+                .map(|order_field| {
+                    self.get_basic_type_op(
+                        &order_field
+                            .typenode
+                            .get_type(ctx, &self.clone().into())
+                            .unwrap()
+                            .borrow(),
+                        ctx,
+                    )
+                    .unwrap()
+                })
+                .collect::<Vec<_>>()
+        })
+    }
+
     fn struct_type(&self, pltp: &STType, ctx: &mut Ctx<'a>) -> StructType<'ctx> {
         let st = self.module.get_struct_type(&pltp.get_st_full_name());
         if let Some(st) = st {
             return st;
         }
+
+        if pltp.is_tuple {
+            let fields = &self.get_fields(pltp, ctx);
+            return self.context.struct_type(fields, false);
+        }
         let st = self.context.opaque_struct_type(&pltp.get_st_full_name());
-        ctx.run_in_type_mod(pltp, |ctx, pltp| {
-            st.set_body(
-                &pltp
-                    .get_all_field()
-                    .iter()
-                    .map(|order_field| {
-                        self.get_basic_type_op(
-                            &order_field
-                                .typenode
-                                .get_type(ctx, &self.clone().into())
-                                .unwrap()
-                                .borrow(),
-                            ctx,
-                        )
-                        .unwrap()
-                    })
-                    .collect::<Vec<_>>(),
-                false,
-            );
-        });
+        st.set_body(&self.get_fields(pltp, ctx), false);
         st
     }
 
@@ -1716,11 +1724,9 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> {
         let ptrtp = self.struct_type(v, ctx).ptr_type(AddressSpace::default());
         let ty = ptrtp.get_element_type().into_struct_type();
         let ftp = self.mark_fn_tp(ptrtp);
-        let f = self.module.add_function(
-            &(ty.get_name().unwrap().to_str().unwrap().to_string() + "@"),
-            ftp,
-            None,
-        );
+        let f = self
+            .module
+            .add_function(&(v.get_st_full_name() + "@"), ftp, None);
         let bb = self.context.append_basic_block(f, "entry");
         self.builder.position_at_end(bb);
         let fieldn = ty.count_fields();

src/ast/ctx.rs

@@ -633,6 +633,9 @@ impl<'a, 'ctx> Ctx<'a> {
     }
 
     pub fn send_if_go_to_def(&self, range: Range, destrange: Range, file: String) {
+        if range == Default::default() {
+            return;
+        }
         self.plmod.defs.borrow_mut().insert(
             range,
             LSPDef::Scalar(Location {

src/ast/diag.rs

@@ -7,6 +7,7 @@ use rustc_hash::FxHashMap;
 use std::{
     collections::HashMap,
     fmt::{Display, Formatter},
+    process::exit,
 };
 macro_rules! define_error {
     ($(
@@ -476,13 +477,14 @@ pub(crate) fn handle_errors(db: &dyn Db, docs: MemDocsInput) {
                     format!("compile failed: there is {} error", errs_num).bright_red()
                 );
                 println!("{}", dot::ERROR);
-                return;
+                exit(1);
             }
             log::error!(
                 "{}",
                 format!("compile failed: there are {} errors", errs_num).bright_red()
             );
             println!("{}", dot::TOOMANYERROR);
+            exit(1);
         }
     }
 }

src/ast/fmt.rs

@@ -22,6 +22,7 @@ use super::{
         ret::RetNode,
         statement::{AssignNode, DefNode, EmptyNode, StatementsNode},
         string_literal::StringNode,
+        tuple::{TupleInitNode, TupleTypeNode},
         types::{
             ArrayInitNode, ArrayTypeNameNode, GenericDefNode, GenericParamNode, PointerTypeNode,
             StructDefNode, StructInitFieldNode, StructInitNode, TypeNameNode, TypedIdentifierNode,
@@ -745,4 +746,26 @@ impl FmtBuilder {
         self.space();
         node.ty.format(self);
     }
+    pub fn parse_tuple_init_node(&mut self, node: &TupleInitNode) {
+        self.l_paren();
+        for (i, expr) in node.exprs.iter().enumerate() {
+            if i > 0 {
+                self.comma();
+                self.space();
+            }
+            expr.format(self);
+        }
+        self.r_paren();
+    }
+    pub fn parse_tuple_type_node(&mut self, node: &TupleTypeNode) {
+        self.l_paren();
+        for (i, ty) in node.tps.iter().enumerate() {
+            if i > 0 {
+                self.comma();
+                self.space();
+            }
+            ty.format(self);
+        }
+        self.r_paren();
+    }
 }

src/ast/node/interface.rs

@@ -41,6 +41,7 @@ impl MultiTraitNode {
             modifier: None,
             body_range: Default::default(),
             is_trait: true,
+            is_tuple: false,
         };
         builder.opaque_struct_type(&ctx.plmod.get_full_name(&name));
         builder.add_body_to_struct_type(&ctx.plmod.get_full_name(&name), &st, ctx);
@@ -164,6 +165,7 @@ impl TraitDefNode {
             modifier: self.modifier,
             body_range: self.range(),
             is_trait: true,
+            is_tuple: false,
         })));
         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/node/mod.rs

@@ -32,6 +32,8 @@ use self::primary::*;
 use self::ret::*;
 use self::statement::*;
 use self::string_literal::StringNode;
+use self::tuple::TupleInitNode;
+use self::tuple::TupleTypeNode;
 use self::types::*;
 use self::union::UnionDefNode;
 
@@ -60,6 +62,7 @@ pub mod program;
 pub mod ret;
 pub mod statement;
 pub mod string_literal;
+pub mod tuple;
 pub mod types;
 pub mod union;
 
@@ -70,6 +73,7 @@ pub enum TypeNodeEnum {
     Array(ArrayTypeNameNode),
     Pointer(PointerTypeNode),
     Func(FuncDefNode),
+    Tuple(TupleTypeNode),
 }
 #[enum_dispatch]
 pub trait TypeNode: RangeTrait + FmtTrait + PrintTrait {
@@ -134,6 +138,7 @@ pub enum NodeEnum {
     UnionDefNode(UnionDefNode),
     AsNode(AsNode),
     IsNode(IsNode),
+    TupleInitNode(TupleInitNode),
 }
 // ANCHOR: range
 #[enum_dispatch]