save

xiyuzhai-husky-lang · Jun 24, 2024 · ffc9110 · ffc9110
1 parent 2719c35
commit ffc9110
Show file tree

Hide file tree

Showing 59 changed files with 441 additions and 92 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/abstractions/idx-arena/src/ordered_map.rs b/crates/abstractions/idx-arena/src/ordered_map.rs
@@ -52,6 +52,12 @@ impl<T, V> std::ops::Index<ArenaIdx<T>> for ArenaOrderedMap<T, V> {
     }
 }
 
+impl<T, V> std::ops::IndexMut<ArenaIdx<T>> for ArenaOrderedMap<T, V> {
+    fn index_mut(&mut self, index: ArenaIdx<T>) -> &mut Self::Output {
+        &mut self.data[index.index()]
+    }
+}
+
 impl<T, V> salsa::DebugWithDb for ArenaOrderedMap<T, V>
 where
     T: salsa::DebugWithDb,

diff --git a/crates/devtime/husky-trace/src/trace/lazy_stmt.rs b/crates/devtime/husky-trace/src/trace/lazy_stmt.rs
@@ -436,7 +436,7 @@ impl Trace {
                 SemStmtData::ForBetween {
                     for_token: _,
                     particulars: _,
-                    for_loop_var_symbol_idx: _,
+                    for_loop_varible_idx: _,
                     eol_colon: _,
                     stmts: _,
                 } => todo!(),

diff --git a/crates/hir/husky-hir-eager-expr/src/pattern_root.rs b/crates/hir/husky-hir-eager-expr/src/pattern_root.rs
@@ -4,4 +4,4 @@ pub mod let_variable;
 
 use crate::*;
 use husky_hir_ty::HirType;
-use husky_sem_expr::LetVariableObelisk;
+use husky_sem_expr::obelisks::let_variable::LetVariableObelisk;
diff --git a/crates/hir/husky-hir-eager-expr/src/stmt.rs b/crates/hir/husky-hir-eager-expr/src/stmt.rs
@@ -37,7 +37,7 @@ pub enum HirEagerStmtData {
     },
     ForBetween {
         particulars: HirEagerForBetweenParticulars,
-        // frame_variable_idx: CurrentHirEagerSymbolIdx,
+        // for_loop_varible_idx: CurrentHirEagerSymbolIdx,
         stmts: HirEagerStmtIdxRange,
     },
     Forext {
@@ -126,7 +126,7 @@ impl ToHirEager for SemStmtIdx {
             },
             SemStmtData::ForBetween {
                 ref particulars,
-                for_loop_var_symbol_idx: _frame_variable_idx,
+                for_loop_varible_idx: _for_loop_varible_idx,
                 stmts: ref block,
                 ..
             } => HirEagerStmtData::ForBetween {

diff --git a/crates/hir/husky-hir-eager-expr/src/variable/runtime.rs b/crates/hir/husky-hir-eager-expr/src/variable/runtime.rs
@@ -65,7 +65,7 @@ impl HirEagerRuntimeVariableRegionData {
             {
                 let hir_eager_runtime_symbol_idx = arena.alloc_one(hir_eager_runtime_symbol);
                 variable_to_hir_eager_runtime_symbol_map
-                    .push_inherited(inherited_variable_idx, hir_eager_runtime_symbol_idx)
+                    .insert_new_inherited(inherited_variable_idx, hir_eager_runtime_symbol_idx)
             }
         }
         for (current_variable_idx, current_variable) in variable_region.indexed_current_variables()
@@ -75,7 +75,7 @@ impl HirEagerRuntimeVariableRegionData {
             {
                 let hir_eager_runtime_symbol_idx = arena.alloc_one(hir_eager_runtime_symbol);
                 variable_to_hir_eager_runtime_symbol_map
-                    .push_current(current_variable_idx, hir_eager_runtime_symbol_idx)
+                    .insert_new_current(current_variable_idx, hir_eager_runtime_symbol_idx)
             }
         }
         (

diff --git a/crates/hir/husky-hir-lazy-expr/src/expr.rs b/crates/hir/husky-hir-lazy-expr/src/expr.rs
@@ -170,10 +170,11 @@ impl ToHirLazy for SemExprIdx {
                     .unwrap(),
             ),
             SemExprData::FrameVarDecl {
-                frame_variable_idx, ..
+                for_loop_varible_idx,
+                ..
             } => HirLazyExprData::Variable(
                 builder
-                    .current_variable_to_hir_lazy_variable(frame_variable_idx)
+                    .current_variable_to_hir_lazy_variable(for_loop_varible_idx)
                     .unwrap(),
             ),
             SemExprData::SelfType(_) => todo!(),

diff --git a/crates/hir/husky-hir-lazy-expr/src/pattern.rs b/crates/hir/husky-hir-lazy-expr/src/pattern.rs
@@ -1,6 +1,6 @@
 use crate::*;
 use husky_hir_ty::HirType;
-use husky_sem_expr::LetVariableObelisk;
+use husky_sem_expr::obelisks::let_variable::LetVariableObelisk;
 use husky_syn_expr::{pattern::SynPatternData, syndicates::BePatternSyndicate};
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]

diff --git a/crates/hir/husky-hir-lazy-expr/src/variable.rs b/crates/hir/husky-hir-lazy-expr/src/variable.rs
@@ -142,7 +142,7 @@ impl HirLazyVariableRegion {
             {
                 let hir_eager_runtime_symbol_idx = arena.alloc_one(hir_eager_runtime_symbol);
                 variable_to_hir_eager_runtime_symbol_map
-                    .push_inherited(inherited_variable_idx, hir_eager_runtime_symbol_idx)
+                    .insert_new_inherited(inherited_variable_idx, hir_eager_runtime_symbol_idx)
             }
         }
         for (current_variable_idx, current_variable) in variable_region.indexed_current_variables()
@@ -152,7 +152,7 @@ impl HirLazyVariableRegion {
             {
                 let hir_eager_runtime_symbol_idx = arena.alloc_one(hir_eager_runtime_symbol);
                 variable_to_hir_eager_runtime_symbol_map
-                    .push_current(current_variable_idx, hir_eager_runtime_symbol_idx)
+                    .insert_new_current(current_variable_idx, hir_eager_runtime_symbol_idx)
             }
         }
         (Self { arena }, variable_to_hir_eager_runtime_symbol_map)

diff --git a/crates/ide/husky-token-info/src/engine.rs b/crates/ide/husky-token-info/src/engine.rs
@@ -232,7 +232,7 @@ impl<'a, 'b> DeclTokenInfoEngine<'a, 'b> {
             }
             | SemExprData::FrameVarDecl {
                 regional_token_idx,
-                frame_variable_idx: current_variable_idx,
+                for_loop_varible_idx: current_variable_idx,
                 current_variable_kind,
                 ..
             } => self.add(

diff --git a/crates/semantics/husky-sem-expr/src/expr.rs b/crates/semantics/husky-sem-expr/src/expr.rs
@@ -143,7 +143,7 @@ pub enum SemExprData {
     FrameVarDecl {
         regional_token_idx: RegionalTokenIdx,
         ident: Ident,
-        frame_variable_idx: CurrentVariableIdx,
+        for_loop_varible_idx: CurrentVariableIdx,
         current_variable_kind: CurrentVariableKind,
     },
     SelfType(RegionalTokenIdx),
@@ -887,16 +887,16 @@ impl<'a> SemExprBuilder<'a> {
             SynExprData::FrameVarDecl {
                 ident,
                 regional_token_idx,
-                frame_variable_idx,
+                for_loop_varible_idx,
                 current_variable_kind,
             } => (
                 Ok(SemExprData::FrameVarDecl {
                     ident,
                     regional_token_idx,
-                    frame_variable_idx,
+                    for_loop_varible_idx,
                     current_variable_kind,
                 }),
-                self.get_current_variable_ty(syn_expr_idx, frame_variable_idx),
+                self.get_current_variable_ty(syn_expr_idx, for_loop_varible_idx),
             ),
             SynExprData::SelfType(regional_token_idx) => (
                 Ok(SemExprData::SelfType(regional_token_idx)),
@@ -1554,7 +1554,7 @@ impl<'a> SemExprBuilder<'a> {
             SemExprData::FrameVarDecl {
                 regional_token_idx,
                 ident,
-                frame_variable_idx,
+                for_loop_varible_idx,
                 current_variable_kind,
             } => todo!(),
             SemExprData::SelfType(regional_token_idx) => match self.self_ty() {

diff --git a/crates/semantics/husky-sem-expr/src/helpers/visitor.rs b/crates/semantics/husky-sem-expr/src/helpers/visitor.rs
@@ -1,6 +1,7 @@
 use super::region::sem_expr_region_from_region_path;
 use super::*;
 use crate::{SemExprData, SemExprIdx, SemExprRegionData, SemStmtIdx, SemStmtIdxRange};
+use closure_parameter::ClosureParameterObelisk;
 use condition::SemCondition;
 use husky_entity_path::region::RegionPath;
 use husky_entity_tree::{
@@ -17,19 +18,31 @@ pub trait VisitSemExpr<'db>: Sized {
     fn db(&self) -> &'db ::salsa::Db;
     fn sem_expr_region_data(&self) -> &'db SemExprRegionData;
     fn visit_expr(&mut self, expr: SemExprIdx, f: impl FnOnce(&mut Self));
-    fn visit_expr_inner(&mut self, expr: SemExprIdx);
+    fn visit_expr_itself(&mut self, expr: SemExprIdx);
+    fn visit_closure_inner(
+        &mut self,
+        expr: SemExprIdx,
+        parameters: &[ClosureParameterObelisk],
+        f: impl FnOnce(&mut Self),
+    );
     fn visit_stmts(&mut self, stmts: SemStmtIdxRange, f: impl FnOnce(&mut Self));
     /// `f` is a closure in which
     /// - first the subexpression and substatements of `stmt` will be simulated in evaluation order
     /// - then `visit_stmt_inner` will be invoked
     ///
     /// this method `visit_stmt` should set up the proper environment and invoke `f`
     fn visit_stmt(&mut self, stmt: SemStmtIdx, f: impl FnOnce(&mut Self));
-    fn visit_stmt_inner(&mut self, stmt: SemStmtIdx);
+    fn visit_stmt_itself(&mut self, stmt: SemStmtIdx);
     /// `f` is a closure that can be called for arbitrary times, in which
     /// - the precondition is simulated if it exists
     /// - the loop body is simulated
     /// - the postcondition is simulated if it exists
+    fn visit_for_loop_stmt_inner(
+        &mut self,
+        stmt: SemStmtIdx,
+        for_loop_varible_idx: CurrentVariableIdx,
+        f: impl Fn(&mut Self),
+    );
     fn visit_loop(&mut self, stmt: SemStmtIdx, f: impl Fn(&mut Self));
     fn visit_branches(&mut self, f: impl Fn(&mut Self));
     fn visit_branch(&mut self, f: impl Fn(&mut Self));
@@ -204,15 +217,19 @@ impl SemExprIdx {
                     rvert_regional_token,
                     return_ty,
                     body,
-                } => body.simulate(visitor),
+                } => {
+                    visitor.visit_closure_inner(self, parameter_obelisks, |visitor| {
+                        body.simulate(visitor)
+                    });
+                }
                 SemExprData::Sorry { regional_token_idx } => todo!(),
                 // ad hoc
                 SemExprData::Todo { .. } => (),
                 // ad hoc
                 SemExprData::Unreachable { .. } => (),
                 SemExprData::NestedBlock { stmts, .. } => stmts.simulate(visitor),
             }
-            visitor.visit_expr_inner(self)
+            visitor.visit_expr_itself(self)
         });
     }
 }
@@ -275,11 +292,10 @@ impl SemStmtIdx {
                 SemStmtData::ForBetween {
                     for_token,
                     ref particulars,
-                    for_loop_var_symbol_idx,
+                    for_loop_varible_idx,
                     eol_colon,
                     stmts,
                 } => {
-                    // ad hoc
                     let range = particulars.range();
                     range
                         .initial_boundary
@@ -289,7 +305,9 @@ impl SemStmtIdx {
                         .final_boundary
                         .bound_expr
                         .map(|bound_expr| bound_expr.simulate(visitor));
-                    visitor.visit_loop(self, |visitor| stmts.simulate(visitor));
+                    visitor.visit_for_loop_stmt_inner(self, for_loop_varible_idx, |visitor| {
+                        visitor.visit_loop(self, |visitor| stmts.simulate(visitor))
+                    })
                 }
                 SemStmtData::ForIn {
                     for_token,
@@ -360,7 +378,7 @@ impl SemStmtIdx {
                 // ad hoc
                 SemStmtData::Narrate { .. } => (),
             };
-            visitor.visit_stmt_inner(self);
+            visitor.visit_stmt_itself(self);
         })
     }
 }
@@ -450,13 +468,22 @@ fn visit_sem_expr_works() {
             f(self)
         }
 
-        fn visit_expr_inner(&mut self, expr: SemExprIdx) {
+        fn visit_expr_itself(&mut self, expr: SemExprIdx) {
             let token_idx_range =
                 self.sem_expr_range_region_data[expr].token_idx_range(self.base.unwrap());
             let text_range = self.ranged_token_sheet.tokens_text_range(token_idx_range);
             self.visits.push(self.text.text_within(text_range));
         }
 
+        fn visit_closure_inner(
+            &mut self,
+            expr: SemExprIdx,
+            parameters: &[ClosureParameterObelisk],
+            f: impl FnOnce(&mut Self),
+        ) {
+            f(self)
+        }
+
         fn visit_stmts(&mut self, stmts: SemStmtIdxRange, f: impl FnOnce(&mut Self)) {
             f(self)
         }
@@ -465,13 +492,22 @@ fn visit_sem_expr_works() {
             f(self)
         }
 
-        fn visit_stmt_inner(&mut self, stmt: SemStmtIdx) {
+        fn visit_stmt_itself(&mut self, stmt: SemStmtIdx) {
             let token_idx_range =
                 self.sem_expr_range_region_data[stmt].token_idx_range(self.base.unwrap());
             let text_range = self.ranged_token_sheet.tokens_text_range(token_idx_range);
             self.visits.push(self.text.text_within(text_range));
         }
 
+        fn visit_for_loop_stmt_inner(
+            &mut self,
+            stmt: SemStmtIdx,
+            for_loop_varible_idx: CurrentVariableIdx,
+            f: impl Fn(&mut Self),
+        ) {
+            f(self)
+        }
+
         fn visit_loop(&mut self, stmt: SemStmtIdx, f: impl Fn(&mut Self)) {
             f(self)
         }

diff --git a/crates/semantics/husky-sem-expr/src/lib.rs b/crates/semantics/husky-sem-expr/src/lib.rs
@@ -21,11 +21,11 @@ pub use self::builder::*;
 pub use self::error::*;
 pub use self::expr::*;
 pub use self::jar::*;
-pub use self::obelisks::*;
 pub use self::region::*;
 pub use self::stmt::*;
 
 use self::jar::SemExprJar as Jar;
+use self::obelisks::*;
 use either::*;
 use husky_dec_signature::*;
 use husky_entity_kind::*;

diff --git a/crates/semantics/husky-sem-expr/src/obelisks/closure_parameter.rs b/crates/semantics/husky-sem-expr/src/obelisks/closure_parameter.rs
@@ -12,6 +12,14 @@ pub enum ClosureParameterObelisk {
     },
 }
 
+impl ClosureParameterObelisk {
+    pub fn variables(self) -> CurrentVariableIdxRange {
+        match self {
+            ClosureParameterObelisk::Simple { variables, .. } => variables,
+        }
+    }
+}
+
 impl<'a> SemExprBuilder<'a> {
     pub(crate) fn build_closure_parameter_obelisk(
         &mut self,

diff --git a/crates/semantics/husky-sem-expr/src/stmt.rs b/crates/semantics/husky-sem-expr/src/stmt.rs
@@ -56,7 +56,7 @@ pub enum SemStmtData {
     ForBetween {
         for_token: StmtForRegionalToken,
         particulars: SemaForBetweenParticulars,
-        for_loop_var_symbol_idx: CurrentVariableIdx,
+        for_loop_varible_idx: CurrentVariableIdx,
         eol_colon: EolRegionalToken,
         stmts: SemStmtIdxRange,
     },
@@ -443,13 +443,13 @@ impl<'a> SemExprBuilder<'a> {
             SynStmtData::ForBetween {
                 for_token,
                 ref particulars,
-                for_loop_var_symbol_idx,
+                for_loop_varible_idx,
                 ref block,
                 ref eol_colon,
             } => {
                 let expr_expectation = self.expect_unit();
                 let Ok(particulars) =
-                    self.build_sem_for_between_particulars(particulars, for_loop_var_symbol_idx)
+                    self.build_sem_for_between_particulars(particulars, for_loop_varible_idx)
                 else {
                     todo!()
                 };
@@ -459,7 +459,7 @@ impl<'a> SemExprBuilder<'a> {
                     Ok(SemStmtData::ForBetween {
                         for_token,
                         particulars,
-                        for_loop_var_symbol_idx,
+                        for_loop_varible_idx,
                         eol_colon,
                         stmts: block,
                     }),

diff --git a/crates/semantics/husky-sem-expr/src/stmt/loop_stmt.rs b/crates/semantics/husky-sem-expr/src/stmt/loop_stmt.rs
@@ -35,7 +35,7 @@ impl<'a> SemExprBuilder<'a> {
     pub(crate) fn build_sem_for_between_particulars(
         &mut self,
         particulars: &'a SynForBetweenParticulars,
-        for_loop_var_symbol_idx: CurrentVariableIdx,
+        for_loop_varible_idx: CurrentVariableIdx,
     ) -> SynExprResultRef<'a, SemaForBetweenParticulars> {
         let Ok(ref range) = particulars.range else {
             todo!()
@@ -76,18 +76,18 @@ impl<'a> SemExprBuilder<'a> {
             todo!()
         };
         // let place = FlyPlace::ImmutableOnStack {
-        //     location: for_loop_var_symbol_idx
+        //     location: for_loop_varible_idx
         //         .into_local_symbol_idx(self.syn_expr_region_data())
         //         .into(),
         // };
         let frame_var_symbol_ty = SymbolType::new_variable_ty(
             self,
-            for_loop_var_symbol_idx,
+            for_loop_varible_idx,
             VariableModifier::Pure,
             expected_frame_var_ty,
         )
         .unwrap();
-        self.add_symbol_ty(for_loop_var_symbol_idx, frame_var_symbol_ty);
+        self.add_symbol_ty(for_loop_varible_idx, frame_var_symbol_ty);
         let for_between_loop_var_expr_idx = self.build_sem_expr(
             particulars.for_between_loop_var_expr_idx,
             ExpectCoercion::new_pure(self, frame_var_symbol_ty.term()),