fix(let-impl): improve scope resolution and LSP type checking

- Fix incorrect module scope resolution for `let impl` statements
- Ensure LSP type-checks all `if let impl` branch bodies regardless of compile-time result

Previously:
- `let impl` statements incorrectly searched for implementations in wrong modules
- LSP would skip type-checking `if let impl` branch bodies when compile-time result was false

Author: Chronostasys

src/ast/ctx.rs

@@ -1118,6 +1118,25 @@ impl<'a, 'ctx> Ctx<'a> {
         res
     }
 
+    pub fn try_run_in_type_mod<'b, R, F: FnMut(&mut Ctx<'a>, &PLType) -> R>(
+        &'b mut self,
+        ty: &PLType,
+        mut f: F,
+    ) -> R {
+        match ty {
+            PLType::Struct(sttype) => {
+                self.run_in_type_mod(sttype, |ctx, tp| f(ctx, &PLType::Struct(tp.clone())))
+            }
+            PLType::Trait(sttype) => {
+                self.run_in_type_mod(sttype, |ctx, tp| f(ctx, &PLType::Struct(tp.clone())))
+            }
+            PLType::Union(union_type) => {
+                self.run_in_type_mod(union_type, |ctx, tp| f(ctx, &PLType::Union(tp.clone())))
+            }
+            _ => f(self, ty),
+        }
+    }
+
     /// # run_in_type_mod
     ///
     /// it executes the function f under the module of the custom_type

src/ast/node/cast.rs

@@ -671,7 +671,9 @@ impl Node for ImplCastNode {
         let mut satisfy_bound = true;
         for t in &t {
             if let PLType::Trait(trait_ty) = &*t.borrow() {
-                if !ty.borrow().implements_trait(trait_ty, ctx) {
+                if ctx.try_run_in_type_mod(&ty.borrow(), |ctx, ty| {
+                    !ty.implements_trait(trait_ty, ctx)
+                }) {
                     satisfy_bound = false;
                     break;
                 }

src/ast/node/control.rs

@@ -154,7 +154,7 @@ impl Node for IfNode {
         let mut then_terminator = TerminatorEnum::None;
         // emit the code inside a child context because it belongs to a sub-block
         let mut child = ctx.new_child(self.then.range().start, builder);
-        if !skip_body {
+        if !skip_body || matches!(builder, BuilderEnum::NoOp(_)) {
             if let Some(mut def) = gen_def {
                 def.emit(&mut child, builder)?;
             }

src/ast/pltype.rs

@@ -520,7 +520,6 @@ impl PLType {
 
     pub fn implements_trait(&self, tp: &STType, ctx: &Ctx) -> bool {
         let name = &self.get_full_elm_name_without_generic();
-
         match self {
             PLType::Struct(s) => s.implements_trait(tp, ctx),
             PLType::Union(u) => u.implements_trait(tp, ctx),

src/ast/pltype/method.rs

@@ -265,8 +265,9 @@ pub trait TraitImplAbleWithGeneric: Generic + TraitImplAble {
         false
     }
     fn implements_trait(&self, tp: &STType, ctx: &Ctx) -> bool {
-        if tp.path == ctx.plmod.path {
-            let plmod = &ctx.plmod;
+        let origin_mod = unsafe { ctx.origin_mod.as_ref().unwrap() };
+        if tp.path == origin_mod.path {
+            let plmod = origin_mod;
             if self.implements_trait_curr_mod(tp, plmod) {
                 return true;
             }

test/test/std_test.pi

@@ -209,6 +209,7 @@ pub async fn test_delay() Task<()> {
 
 use std::json::encode::encode;
 use std::cols::hashtable;
+use std::json::encode::JSONSerializable;
 
 pub fn test_json() void {
     let nested = JSONObj{
@@ -222,7 +223,6 @@ pub fn test_json() void {
     let table = hashtable::new_hash_table(10 as u64, 0  as u64);
     table.insert(1, "abc");
     table.insert(2, "bcd");
-    table.to_json();
     re = encode(table);
     println!(re);
     // hash table is special, it's directly encoded as json object