Merge pull request #386 from Pivot-Studio/feat/check_before_compile-2

feature: support check command

Author: Chronostasys

Cargo.lock

@@ -45,7 +45,7 @@ derivative = "2.2"
 console = "0.15"
 anstyle = "1.0"
 regex = "1.9"
-ena = "0.2"
+ena = "0.14"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen = "0.2"

Cargo.toml

@@ -4,7 +4,7 @@ use super::node::program::ASSET_PATH;
 #[cfg(feature = "llvm")]
 use crate::ast::jit_config::IS_JIT;
 use crate::{
-    ast::{accumulators::ModBuffer, diag::ensure_no_error, node::program::Program},
+    ast::{accumulators::ModBuffer, node::program::Program},
     lsp::mem_docs::{FileCompileInput, MemDocsInput},
     nomparser::parse,
     utils::read_config::search_config_file,
@@ -77,6 +77,7 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) {
     }
 
     let ctx = Context::create();
+    // ensure_no_error(db, docs);
     let (llvmmod, files) = process_llvm_ir(db, docs, &ctx, op);
 
     pl_link(llvmmod, files, out.clone(), op);
@@ -162,7 +163,6 @@ pub fn process_llvm_ir<'a>(
     op: Options,
 ) -> (Module<'a>, Vec<PathBuf>) {
     let mods = compile_dry::accumulated::<ModBuffer>(db, docs);
-    ensure_no_error(db, docs);
 
     let total_steps = 3;
     let pb = ProgressBar::hidden();

src/ast/compiler.rs

@@ -8,6 +8,7 @@ use lazy_static::lazy_static;
 
 lazy_static! {
     pub static ref COMPILE_PROGRESS: ProgressBar = ProgressBar::hidden();
+    pub static ref CHECK_PROGRESS: ProgressBar = ProgressBar::hidden();
 }
 
 pub(crate) static LOOKING_GLASS: Emoji<'_, '_> = Emoji("🔍  ", ":-)");

src/ast/compiler/progress.rs

@@ -35,6 +35,7 @@ use crate::utils::read_config::Config;
 use crate::Db;
 
 use crate::ast::node::function::generator::GeneratorCtxData;
+use ena::unify::InPlace;
 use ena::unify::UnificationTable;
 use indexmap::IndexMap;
 
@@ -180,7 +181,7 @@ pub struct Ctx<'a> {
     as_root: bool,
 
     macro_expand_depth: Arc<RefCell<u64>>,
-    pub unify_table: Arc<RefCell<UnificationTable<TyVariable>>>,
+    pub unify_table: Arc<RefCell<UnificationTable<InPlace<TyVariable>>>>,
     pub disable_diag: bool,
 
     pub macro_vars: FxHashMap<String, MacroReplaceNode>,

src/ast/ctx.rs

@@ -102,11 +102,17 @@ impl<'a> Ctx<'a> {
                 if lg.curpltype.is_some() {
                     return self.eq(lg.curpltype.as_ref().unwrap().clone(), r);
                 }
+                // set the real type of generic type to the type of the right
                 lg.set_type(r.clone());
+                // in this case, we need to check if the right type
+                // satisfies the trait constraints of the generic type
+                // so we don't return here
             }
             if let PLType::Generic(lg) = &*l.borrow() {
                 if lg.trait_impl.is_some() {
                     if let PLType::Generic(r) = &*r.borrow() {
+                        // in case checking equality of two generic types,
+                        // we need to check if the trait impls of them are equal
                         if let Some(reason) = self.diff_trait_impl(lg, r) {
                             return EqRes {
                                 eq: false,
@@ -123,6 +129,8 @@ impl<'a> Ctx<'a> {
                         .iter()
                         .any(|lt| !self.eq(lt.clone(), r.clone()).eq)
                     {
+                        // try to pass normal type as generic type, check if it contains
+                        // all the trait expected by the generic type
                         return EqRes {
                             eq: false,
                             need_up_cast: false,

src/ast/ctx/generic.rs

@@ -94,6 +94,9 @@ impl Ctx<'_> {
         if self.need_highlight.borrow().ne(&0) || self.in_macro {
             return;
         }
+        if range.start.line > 200 {
+            eprintln!();
+        }
         self.get_root_ctx()
             .plmod
             .semantic_tokens_builder

src/ast/ctx/lsp.rs

@@ -77,6 +77,18 @@ impl<'a> Ctx<'a> {
             return;
         }
         let root = self.get_root_ctx();
+        if root.get_file() != self.get_file() {
+            return;
+        }
+        if range.start.line == 1 && range.start.column == 12 && root.get_file().contains("iter.pi")
+        {
+            eprintln!(
+                "{}:{}:{}",
+                root.get_file(),
+                range.start.line,
+                range.start.column
+            );
+        }
         root.plmod
             .glob_refs
             .borrow_mut()

src/ast/ctx/references.rs

@@ -516,14 +516,14 @@ pub(crate) fn ensure_no_error(db: &dyn Db, docs: MemDocsInput) {
             if errs_num == 1 {
                 log::error!(
                     "{}",
-                    format!("compile failed: there is {} error", errs_num).bright_red()
+                    format!("check failed: there is {} error", errs_num).bright_red()
                 );
                 println!("{}", dot::ERROR);
                 exit(1);
             }
             log::error!(
                 "{}",
-                format!("compile failed: there are {} errors", errs_num).bright_red()
+                format!("check failed: there are {} errors", errs_num).bright_red()
             );
             println!("{}", dot::TOOMANYERROR);
             exit(1);

src/ast/diag.rs

@@ -214,6 +214,9 @@ impl Node for FuncCallNode {
             _ => return Err(ctx.add_diag(self.range.new_err(ErrorCode::FUNCTION_NOT_FOUND))),
         };
 
+        if let Some(p) = &self.generic_params {
+            p.emit_highlight(ctx);
+        }
         generic_tp_apply(&fnvalue, self, ctx, builder)?;
         let mut skip = 0;
         let mut para_values = vec![];
@@ -299,6 +302,7 @@ impl Node for FuncCallNode {
         res
     }
 }
+
 /// # generic_tp_apply
 ///
 /// This method will apply generic parameter types to a generic custom type.
@@ -308,13 +312,24 @@ pub fn generic_tp_apply<'a, 'b, T: Generic + CustomType, N: GenericInferenceAble
     ctx: &'b mut Ctx<'a>,
     builder: &'b BuilderEnum<'a, '_>,
 ) -> Result<(), PLDiag> {
-    // disable highlight
-    *ctx.need_highlight.borrow_mut() += 1;
     let generic_size = tp.get_generic_size();
     let generic_params = node.get_generic_params();
+    // disable highlight
+    *ctx.need_highlight.borrow_mut() += 1;
     let range = node.range();
-    let mut generic_types = preprocess_generics(generic_params, generic_size, range, ctx, builder)?;
-
+    let re = preprocess_generics(
+        generic_params,
+        generic_size,
+        tp.get_user_generic_size(),
+        range,
+        ctx,
+        builder,
+    );
+    if let Err(diag) = re {
+        *ctx.need_highlight.borrow_mut() -= 1;
+        return Err(diag);
+    }
+    let mut generic_types = re.unwrap();
     let re = ctx.run_in_type_mod(tp, |ctx, t| {
         ctx.protect_generic_context(t.get_generic_map(), |ctx| {
             for (i, (_, pltype)) in t.get_generic_map().iter().enumerate() {
@@ -329,7 +344,7 @@ pub fn generic_tp_apply<'a, 'b, T: Generic + CustomType, N: GenericInferenceAble
                         .unwrap_or_default()
                         .get(i)
                         .map(|v| {
-                            let ty = ctx.unify_table.borrow_mut().probe(*v);
+                            let ty = ctx.unify_table.borrow_mut().probe_value(*v);
                             ty.get_type(ctx, builder, &mut ctx.unify_table.clone().borrow_mut())
                         });
                     if let Some(ty) = ty {
@@ -355,6 +370,14 @@ pub fn generic_tp_apply<'a, 'b, T: Generic + CustomType, N: GenericInferenceAble
                         format_label!("parameter `{}` defined in `{}`", g.0, t.get_name()),
                     );
                     return Err(diag.add_to_ctx(ctx));
+                } else if i < t.get_user_generic_size() {
+                    ctx.set_if_refs_tp(
+                        generic_types[i].as_ref().unwrap().clone(),
+                        generic_params
+                            .as_ref()
+                            .and_then(|v| v.generics[i].as_ref().map(|v| v.range()))
+                            .unwrap_or_default(),
+                    );
                 }
             }
             Ok(())
@@ -370,14 +393,15 @@ pub fn generic_tp_apply<'a, 'b, T: Generic + CustomType, N: GenericInferenceAble
 fn preprocess_generics<'a, 'b>(
     generic_params: &Option<Box<GenericParamNode>>,
     generic_size: usize,
+    usr_generic_size: usize,
     range: Range,
     ctx: &'b mut Ctx<'a>,
     builder: &'b BuilderEnum<'a, '_>,
 ) -> Result<Vec<Option<Arc<RefCell<PLType>>>>, PLDiag> {
     let generic_params = if let Some(generic_params) = generic_params {
         generic_params.emit_highlight(ctx);
         let generic_params_range = generic_params.range;
-        if generic_params.generics.len() != generic_size {
+        if generic_params.generics.len() != usr_generic_size {
             return Err(
                 ctx.add_diag(generic_params_range.new_err(ErrorCode::GENERIC_PARAM_LEN_MISMATCH))
             );
@@ -389,7 +413,10 @@ fn preprocess_generics<'a, 'b>(
             range,
         })
     };
-    let generic_types = generic_params.get_generic_types(ctx, builder)?;
+    let mut generic_types = generic_params.get_generic_types(ctx, builder)?;
+    if generic_types.len() != generic_size {
+        generic_types.resize(generic_size, None);
+    }
     Ok(generic_types)
 }
 
@@ -1034,7 +1061,7 @@ impl Node for ClosureNode {
                 typenode.emit_highlight(ctx);
                 typenode.get_type(ctx, builder, true)?
             } else if let Some(id) = v.id {
-                let vv = ctx.unify_table.borrow_mut().probe(id);
+                let vv = ctx.unify_table.borrow_mut().probe_value(id);
                 let tp = vv.get_type(ctx, builder, &mut ctx.unify_table.clone().borrow_mut());
                 if *tp.borrow() == PLType::Unknown {
                     v.range()
@@ -1078,7 +1105,7 @@ impl Node for ClosureNode {
             ret.emit_highlight(ctx);
             ret.get_type(ctx, builder, true)?
         } else if let Some(ty) = self.ret_id {
-            let v = ctx.unify_table.borrow_mut().probe(ty);
+            let v = ctx.unify_table.borrow_mut().probe_value(ty);
             let tp = v.get_type(ctx, builder, &mut ctx.unify_table.clone().borrow_mut());
             tp
         } else if let Some(exp_ty) = &ctx.expect_ty {