compiler: minor refactoring

src/julec/obj/cxx/expr.jule

@@ -6,6 +6,7 @@ use env
 use optimizing::{
     UnsafeBinopExprModel,
     UnsafeIndexingExprModel,
+    PushToSliceExprModel,
 }
 
 use conv for std::conv
@@ -820,16 +821,16 @@ impl ExprCoder {
         ret obj
     }
 
-    fn __append_call_assign(mut self, &dest_expr: str, mut &dest_kind: &TypeKind,
-        mut &s: &SliceExprModel, mut &m: &BuiltinAppendCallExprModel): str {
-        let mut obj = dest_expr
+    fn push_to_slice(mut self, mut m: &PushToSliceExprModel): str {
+        let dest = self.model(m.dest)
+        let mut obj = dest
         obj += " = jule::alloc_for_append("
-        obj += self.model(m.dest)
+        obj += dest
         obj += ","
-        obj += conv::itoa(s.elems.len)
+        obj += conv::itoa(m.elems.elems.len)
         obj += ");"
-        for (_, mut e) in s.elems {
-            obj += dest_expr
+        for (_, mut e) in m.elems.elems {
+            obj += dest
             // Use the "__push" function to skip allocation boundary checking.
             obj += ".__push("
             obj += self.model(e)
@@ -838,25 +839,6 @@ impl ExprCoder {
         ret obj
     }
 
-    fn append_call_assign(mut self, mut dest: ExprModel, mut m: &BuiltinAppendCallExprModel): (str, optimized: bool) {
-        match type m.elements {
-        | &SliceExprModel:
-            match type dest {
-            | &Var:
-                let mut s = (&SliceExprModel)(m.elements)
-                let dest_expr = self.model(dest)
-                let mut dest_var = (&Var)(dest)
-                ret self.__append_call_assign(dest_expr, dest_var.kind.kind, s, m), true
-            | &StructSubIdentExprModel:
-                let mut s = (&SliceExprModel)(m.elements)
-                let dest_expr = self.model(dest)
-                let mut dest_field = (&StructSubIdentExprModel)(dest).field
-                ret self.__append_call_assign(dest_expr, dest_field.kind, s, m), true
-            }
-        }
-        ret self.append_call(m), false
-    }
-
     fn append_call(mut self, mut m: &BuiltinAppendCallExprModel): str {
         let mut obj = "jule::append("
         obj += self.model(m.dest)

src/julec/obj/cxx/scope.jule

@@ -3,6 +3,9 @@
 // license that can be found in the LICENSE file.
 
 use env
+use optimizing::{
+    PushToSliceExprModel,
+}
 
 use std::jule::lex::{TokenKind, is_ignore_ident}
 use std::jule::sema::{
@@ -315,21 +318,7 @@ impl ScopeCoder {
     fn assign(mut self, mut a: &Assign): str {
         let mut obj = self.oc.ec.expr(a.l.model)
         obj += a.op.kind
-        if env::OPT_APPEND {
-            match type a.r.model {
-            | &BuiltinAppendCallExprModel:
-                let mut model = (&BuiltinAppendCallExprModel)(a.r.model)
-                let (expr, optimized) = self.oc.ec.append_call_assign(a.l.model, model)
-                if optimized {
-                    ret expr
-                }
-                obj += expr
-            |:
-                obj += self.oc.ec.expr(a.r.model)
-            }
-        } else {
-            obj += self.oc.ec.expr(a.r.model)
-        }
+        obj += self.oc.ec.expr(a.r.model)
         obj += ";"
         ret obj
     }
@@ -709,6 +698,8 @@ impl ScopeCoder {
             ret self.break_st((&BreakSt)(st))
         | &RetSt:
             ret self.ret_st((&RetSt)(st))
+        | &PushToSliceExprModel:
+            ret self.oc.ec.push_to_slice((&PushToSliceExprModel)(st))
         |:
             ret "<unimplemented_stmt>"
         }

src/julec/optimizing/model.jule

@@ -3,8 +3,11 @@
 // license that can be found in the LICENSE file.
 
 use std::jule::sema::{
+    ExprModel,
     BinopExprModel,
     IndexingExprModel,
+    BuiltinAppendCallExprModel,
+    SliceExprModel,
 }
 
 pub struct UnsafeBinopExprModel {
@@ -14,3 +17,8 @@ pub struct UnsafeBinopExprModel {
 pub struct UnsafeIndexingExprModel {
     pub node: &IndexingExprModel
 }
+
+pub struct PushToSliceExprModel{
+    pub dest:  ExprModel
+    pub elems: &SliceExprModel
+}

src/julec/optimizing/optimizer.jule

@@ -91,7 +91,8 @@ impl Optimizer {
     pub fn optimize(mut self) {
         // Do optimizatitons if any enabled.
         match {
-        | env::OPT_COND:
+        | env::OPT_COND
+        | env::OPT_APPEND:
             break
         |:
             ret

src/julec/optimizing/scope.jule

@@ -26,6 +26,9 @@ use std::jule::sema::{
     RetSt,
     BinopExprModel,
     OperandExprModel,
+    BuiltinAppendCallExprModel,
+    SliceExprModel,
+    StructSubIdentExprModel,
 }
 use strings for std::strings
 
@@ -213,6 +216,7 @@ impl ScopeOptimizer {
     fn optimize_assign(mut self, mut assign: &Assign) {
         ExprOptimizer.optimize(assign.l.model)
         ExprOptimizer.optimize(assign.r.model)
+
         match assign.op.kind {
         | TokenKind.SolidusEq | TokenKind.PercentEq:
             // Do not check division of structures safety.
@@ -232,6 +236,25 @@ impl ScopeOptimizer {
                     ret
                 }
                 assign.op.kind += "="
+                ret
+            }
+        }
+
+        if env::OPT_APPEND {
+            match type assign.r.model {
+            | &BuiltinAppendCallExprModel:
+                let mut m = (&BuiltinAppendCallExprModel)(assign.r.model)
+                match type m.elements {
+                | &SliceExprModel:
+                    match type m.dest {
+                    | &Var
+                    | &StructSubIdentExprModel:
+                        self.set_current_stmt(&PushToSliceExprModel{
+                            dest:  m.dest,
+                            elems: (&SliceExprModel)(m.elements),
+                        })
+                    }
+                }
             }
         }
     }