From: fennecdjay <fennecdjay@gmail.com>
Date: Mon, 8 Aug 2022 13:51:00 +0000 (+0200)
Subject: :art: Update
X-Git-Tag: nightly~264^2~50
X-Git-Url: http://10.10.0.4:5575/?a=commitdiff_plain;h=de0b35ac1211ebd505121ab4a45adbb81824dc2c;p=gwion.git

:art: Update
---

diff --git a/include/instr.h b/include/instr.h
index 8a7466bd..d85e5962 100644
--- a/include/instr.h
+++ b/include/instr.h
@@ -35,6 +35,8 @@ struct Instr_ {
 };
 #define BYTECODE_SZ (SZ_INT * 4)
 
+__attribute__((returns_nonnull)) ANN2(1) Instr
+new_instr(const MemPool mp, const f_instr f);
 ANN void free_instr(const Gwion, const Instr);
 INSTR(EOC);
 INSTR(DTOR_EOC);
diff --git a/src/emit/emit.c b/src/emit/emit.c
index 0958be8a..077a39c4 100644
--- a/src/emit/emit.c
+++ b/src/emit/emit.c
@@ -2351,12 +2351,9 @@ ANN static m_bool emit_stmt_loop(const Emitter emit, const Stmt_Loop stmt) {
 
 ANN static m_bool emit_type_def(const Emitter emit, const Type_Def tdef) {
   if (tdef->when_def) CHECK_BB(emit_func_def(emit, tdef->when_def));
-
-  if (tflag(tdef->type, tflag_cdef)) {
-    if(!tflag(tdef->type->info->parent, tflag_emit))
-                    return emit_class_def(emit, tdef->type->info->parent->info->cdef);
-  }
-  return tdef->type->info->cdef ? emit_class_def(emit, tdef->type->info->cdef) : GW_OK;
+  if (tflag(tdef->type, tflag_cdef))
+    return emit_class_def(emit, tdef->type->info->cdef);
+  return GW_OK;
 }
 
 ANN static m_bool emit_enum_def(const Emitter emit NUSED, const Enum_Def edef) {
diff --git a/src/emit/emitter.c b/src/emit/emitter.c
index d15592e8..b3473321 100644
--- a/src/emit/emitter.c
+++ b/src/emit/emitter.c
@@ -36,14 +36,19 @@ ANN void free_emitter(MemPool p, Emitter a) {
 }
 
 __attribute__((returns_nonnull)) ANN2(1) Instr
-emit_add_instr(const Emitter emit, const f_instr f) {
-  const Instr instr = mp_calloc(emit->gwion->mp, Instr);
+new_instr(const MemPool mp, const f_instr f) {
+  const Instr instr = mp_calloc(mp, Instr);
   if ((m_uint)f < 255)
     instr->opcode = (m_uint)f;
   else {
     instr->opcode  = eOP_MAX;
     instr->execute = f;
   }
+  return instr;
+}
+__attribute__((returns_nonnull)) ANN2(1) Instr
+emit_add_instr(const Emitter emit, const f_instr f) {
+  const Instr instr = new_instr(emit->gwion->mp, f);
   vector_add(&emit->code->instr, (vtype)instr);
   return instr;
 }
diff --git a/src/lib/object_op.c b/src/lib/object_op.c
index 30c44658..3266bbce 100644
--- a/src/lib/object_op.c
+++ b/src/lib/object_op.c
@@ -477,6 +477,5 @@ GWION_IMPORT(object_op) {
   GWI_BB(gwi_oper_ini(gwi, "@Compound", NULL, NULL))
   GWI_BB(gwi_oper_add(gwi, opck_struct_scan))
   GWI_BB(gwi_oper_end(gwi, "@scan", NULL))
-
   return GW_OK;
 }
diff --git a/src/parse/check.c b/src/parse/check.c
index ff80ee37..ef7db50f 100644
--- a/src/parse/check.c
+++ b/src/parse/check.c
@@ -669,8 +669,32 @@ ANN static Type_List check_template_args(const Env env, Exp_Call *exp,
   const bool spread = is_spread_tmpl(fdef->base->tmpl);
   const uint32_t len = sl->len - spread;
   Type_List    tl = new_mp_vector(env->gwion->mp, Type_Decl*, len);
-
   m_uint       args_number = 0;
+
+  if(exp->other) {
+    for(uint32_t i = 0; i < len; i++) {
+      Specialized *spec = mp_vector_at(sl, Specialized, i);
+      if (spec->xid == fdef->base->td->xid) { // check no next?
+        CHECK_OO(check_exp(env, exp->other));
+         if(!is_func(env->gwion, exp->other->type)) {
+           Type_Decl *td = type2td(env->gwion, exp->other->type, fdef->base->pos);
+           mp_vector_set(tl, Type_Decl*, 0, td);
+         } else {
+           Func func = exp->other->type->info->func;
+           do {
+             if(mp_vector_len(func->def->base->args) == 1) {
+               Arg *arg = mp_vector_at(func->def->base->args, Arg, 0);
+               Type_Decl *td = cpy_type_decl(env->gwion->mp, arg->td);
+               mp_vector_set(tl, Type_Decl*, 0, td);
+               break;
+             }
+           } while((func = func->next));
+        }
+        ++args_number;
+        break;
+      }
+    }
+  }
   for(uint32_t i = 0; i < len; i++) {
     Specialized *spec = mp_vector_at(sl, Specialized, i);
     Arg_List args          = fdef->base->args;
@@ -913,8 +937,13 @@ ANN Type check_exp_call1(const Env env, Exp_Call *const exp) {
 }
 
 ANN static Type check_exp_binary(const Env env, const Exp_Binary *bin) {
+  if(bin->lhs->exp_type == ae_exp_call && !bin->lhs->d.exp_call.tmpl) {
+    CHECK_OO(check_exp(env, bin->lhs->d.exp_call.func));
+    // check is template?
+    bin->lhs->d.exp_call.other = bin->rhs;
+  }
   CHECK_OO(check_exp(env, bin->lhs));
-  const m_bool is_auto = bin->op == insert_symbol(":=>")  &&
+  const m_bool is_auto = //bin->op == insert_symbol(":=>")  &&
                          bin->rhs->exp_type == ae_exp_decl &&
                          bin->rhs->d.exp_decl.type == env->gwion->type[et_auto];
   if (is_auto) bin->rhs->d.exp_decl.type = bin->lhs->type;
@@ -930,12 +959,19 @@ ANN static Type check_exp_binary(const Env env, const Exp_Binary *bin) {
    e->exp_type = ae_exp_unary;
    unary->unary_type = unary_td;
    unary->op = insert_symbol("new");
-   unary->ctor.td = cpy_type_decl(env->gwion->mp, bin->rhs->d.exp_unary.ctor.td);
+   unary->ctor.td = new_type_decl(env->gwion->mp, insert_symbol("auto"), bin->rhs->d.exp_unary.ctor.td->pos);
    unary->ctor.exp = lhs;
    free_exp(env->gwion->mp, rhs);
    return check_exp(env, e);
   }
+  if(bin->rhs->exp_type == ae_exp_call && !bin->rhs->d.exp_call.tmpl)
+    bin->rhs->d.exp_call.other = bin->lhs;
+  const m_uint scope = env->scope->depth;
+  if(bin->op == insert_symbol(">=>"))
+    env_push_type(env, bin->lhs->type);
   CHECK_OO(check_exp(env, bin->rhs));
+  if(bin->op == insert_symbol(">=>"))
+    env_pop(env, scope);
   if (is_auto) {
     assert(bin->rhs->type == bin->lhs->type);
     set_vflag(bin->rhs->d.exp_decl.vd.value, vflag_assigned);
@@ -1115,8 +1151,6 @@ ANN static Type check_exp_dot(const Env env, Exp_Dot *member) {
 }
 
 ANN m_bool check_type_def(const Env env, const Type_Def tdef) {
-  if(tdef->ext->array && tdef->ext->array->exp)
-    CHECK_OB(check_exp(env, tdef->type->info->cdef->base.ext->array->exp));
   if (tdef->when) {
     set_tflag(tdef->type, tflag_contract);
     struct Var_Decl_ decl = { .xid = insert_symbol("self"), .pos = tdef->when->pos };
@@ -1169,6 +1203,8 @@ ANN m_bool check_type_def(const Env env, const Type_Def tdef) {
     mp_vector_set(fdef->d.code->d.stmt_code.stmt_list, struct Stmt_, 1, ret);
     ret_id->type = tdef->type;
   }
+  if (tflag(tdef->type, tflag_cdef))
+    return check_class_def(env, tdef->type->info->cdef);
   return GW_OK;
 }
 
diff --git a/src/parse/scan1.c b/src/parse/scan1.c
index 11590445..627379f4 100644
--- a/src/parse/scan1.c
+++ b/src/parse/scan1.c
@@ -190,6 +190,8 @@ ANN static inline m_bool scan1_prim(const Env env, const Exp_Primary *prim) {
   if (prim->prim_type == ae_prim_array && prim->d.array->exp)
     return scan1_exp(env, prim->d.array->exp);
   if (prim->prim_type == ae_prim_range) return scan1_range(env, prim->d.range);
+  if (env->func && prim->prim_type == ae_prim_perform && env->scope->depth <= 2)
+    env->func->memoize = 1;
   return GW_OK;
 }
 
@@ -465,12 +467,10 @@ ANN m_bool scan1_fptr_def(const Env env, const Fptr_Def fptr) {
 }
 
 ANN m_bool scan1_type_def(const Env env, const Type_Def tdef) {
-  if (!tdef->type) tdef->type = nspc_lookup_type0(env->curr, tdef->xid);
+  //if (!tdef->type) tdef->type = nspc_lookup_type0(env->curr, tdef->xid);
   if (tdef->when) CHECK_BB(scan1_exp(env, tdef->when));
-  if (!tflag(tdef->type, tflag_cdef)) {
-    if(!tflag(tdef->type->info->parent, tflag_scan1))
-                    return scan1_class_def(env, tdef->type->info->parent->info->cdef);
-  }
+  if (tflag(tdef->type, tflag_cdef))
+    return scan1_class_def(env, tdef->type->info->cdef);
   return tdef->type->info->cdef ? scan1_cdef(env, tdef->type) : GW_OK;
 }
 
@@ -682,7 +682,7 @@ ANN static m_bool _scan1_func_def(const Env env, const Func_Def fdef) {
        fdef->base->ret_type != env->gwion->type[et_void] && fdef->d.code &&
        !fake.memoize)
      ERR_B(fdef->base->td->pos,
-           _("missing return statement in a non void function %u"), fake.memoize);
+           _("missing return statement in a non void function"));
   if (fdef->base->xid == insert_symbol("@gack") && !fake.weight) {
     gwerr_basic(_("`@gack` operator does not print anything"), NULL,
       _("use `<<<` `>>>` in the function"), env->name, fdef->base->pos, 0);
diff --git a/src/parse/scan2.c b/src/parse/scan2.c
index 876cc82d..4536842c 100644
--- a/src/parse/scan2.c
+++ b/src/parse/scan2.c
@@ -87,10 +87,8 @@ ANN m_bool scan2_fptr_def(const Env env NUSED, const Fptr_Def fptr) {
 ANN static m_bool scan2_func_def_op(const Env env, const Func_Def f);
 ANN m_bool        scan2_type_def(const Env env, const Type_Def tdef) {
   if (tdef->when) CHECK_BB(scan2_exp(env, tdef->when));
-  if (tflag(tdef->type, tflag_cdef)) {
-    if(!tflag(tdef->type->info->parent, tflag_scan2))
-                    return scan2_class_def(env, tdef->type->info->parent->info->cdef);
-  }
+  if (tflag(tdef->type, tflag_cdef))
+    return scan2_class_def(env, tdef->type->info->cdef);
   if (!tdef->type->info->cdef) return GW_OK;
   return tdef->type->info->cdef ? scan2_class_def(env, tdef->type->info->cdef) : GW_OK;
 }
diff --git a/src/vm/shreduler.c b/src/vm/shreduler.c
index 7e647175..bd793d97 100644
--- a/src/vm/shreduler.c
+++ b/src/vm/shreduler.c
@@ -76,11 +76,9 @@ ANN void shreduler_remove(const Shreduler s, const VM_Shred out,
   MUTEX_UNLOCK(s->mutex);
 }
 
-ANN void shredule(const Shreduler s, const VM_Shred shred,
+ANN void _shredule(const Shreduler s,   struct ShredTick_ *tk,
                   const m_float wake_time) {
-  struct ShredTick_ *tk   = shred->tick;
   if(tk->prev == (struct ShredTick_*)-1) return;
-  MUTEX_LOCK(s->mutex);
   const m_float      time = wake_time + (m_float)s->bbq->pos;
   tk->wake_time           = time;
   if (s->list) {
@@ -100,6 +98,13 @@ ANN void shredule(const Shreduler s, const VM_Shred shred,
   } else
     s->list = tk;
   if (tk == s->curr) s->curr = NULL;
+}
+
+ANN void shredule(const Shreduler s, const VM_Shred shred,
+                  const m_float wake_time) {
+  struct ShredTick_ *tk   = shred->tick;
+  MUTEX_LOCK(s->mutex);
+  _shredule(s, tk, wake_time);
   MUTEX_UNLOCK(s->mutex);
 }
 
@@ -112,8 +117,10 @@ ANN void shreduler_ini(const Shreduler s, const VM_Shred shred) {
 ANN void shreduler_add(const Shreduler s, const VM_Shred shred) {
   shreduler_ini(s, shred);
   shred->tick->xid = ++s->shred_ids;
+  MUTEX_LOCK(s->mutex);
   vector_add(&s->active_shreds, (vtype)shred);
-  shredule(s, shred, GWION_EPSILON);
+  _shredule(s, shred->tick, GWION_EPSILON);
+  MUTEX_UNLOCK(s->mutex);
 }
 
 ANN Shreduler new_shreduler(const MemPool mp) {
diff --git a/src/vm/vm.c b/src/vm/vm.c
index 1f31a702..d14d07a4 100644
--- a/src/vm/vm.c
+++ b/src/vm/vm.c
@@ -59,7 +59,7 @@ ANN static void clean_values(const VM_Shred shred) {
   }
 }
 
-ANN static uint16_t find_pc(const VM_Shred shred, const Symbol effect, const m_uint size) {
+ANN static uint16_t find_pc(const VM_Shred shred, const Symbol effect) {
   const VM_Code code = shred->code;
   const m_uint start = vector_at(&shred->info->frame, vector_size(&shred->info->frame) - 2);
   if (start > shred->pc) return true;
@@ -76,8 +76,8 @@ ANN static uint16_t find_pc(const VM_Shred shred, const Symbol effect, const m_u
   return 0;
 }
 
-ANN static inline bool find_handle(const VM_Shred shred, const Symbol effect, const m_uint size) {
-  const uint16_t pc = find_pc(shred, effect, size);
+ANN static inline bool find_handle(const VM_Shred shred, const Symbol effect) {
+  const uint16_t pc = find_pc(shred, effect);
   if (!pc) return false; // outside of a try statement
   shred->reg = // restore reg
       (m_bit *)VPTR(&shred->info->frame, VLEN(&shred->info->frame) - 1);
@@ -94,7 +94,7 @@ ANN bool unwind(const VM_Shred shred, const Symbol effect, const m_uint size) {
     clean_values(shred);
   if (!size) return false;
   if (code->handlers.ptr)
-    return find_handle(shred, effect, size);
+    return find_handle(shred, effect);
   // there might be no more stack to unwind
   if (shred->mem == (m_bit *)shred + sizeof(struct VM_Shred_) + SIZEOF_REG)
     return false;