Fixes bug when creating instances.

Author: modlfo

src/core/elaboration.ml

@@ -49,8 +49,12 @@ let rec unlink (t : type_) =
 
 let checkMemExists (env : env) name =
   let f = Env.getCurrentFunction env in
-  match Env.lookVarInScopes f.locals name with
-  | Some { kind = Mem _ | Inst; _ } -> true
+  (* Check context record where Inst/Mem variables are stored by addVar *)
+  match f.context with
+  | Some (_, { descr = Record members; _ }) -> (
+    match Env.Map.find name members with
+    | Some { kind = Mem _ | Inst; _ } -> true
+    | _ -> false)
   | _ -> false
 
 

src/generators/js.ml

@@ -26,23 +26,9 @@ open Core.Prog
 
 let runtime =
   {%pla|
+// Runtime functions (simple builtins like eps, pi, clip, real, int_, sin, cos, etc. are inlined)
 this.random = function()         { return Math.random(); };
 this.irandom = function()        { return Math.floor(Math.random() * 4294967296); };
-this.eps  = function()           { return 1e-18 };
-this.pi   = function()           { return 3.1415926535897932384; }
-this.clip = function(x,low,high) { return x<low?low:(x>high?high:x); };
-this.not  = function(x)          { return x==0?1:0; };
-this.real = function(x)          { return x; };
-this.int_  = function(x)         { return x|0; };
-this.sin  = function(x)          { return Math.sin(x); };
-this.cos  = function(x)          { return Math.cos(x); };
-this.abs  = function(x)          { return Math.abs(x); };
-this.exp  = function(x)          { return Math.exp(x); };
-this.floor = function(x)          { return Math.floor(x); };
-this.tan  = function(x)          { return Math.tan(x); };
-this.tanh = function(x)          { return Math.tanh(x); };
-this.pow  = function(a,b)         { return Math.pow(a,b); };
-this.sqrt = function(x)          { return x; };
 this.int_to_float = function(i)  { return i; };
 this.float_to_int = function(i)  { return Math.floor(i); };
 this.initializeArray = function(v, size){ var a = new Array(size); for(var i=0;i<size;i++) a[i]=v; return a; };
@@ -142,6 +128,53 @@ let rec print_exp e =
     let i = print_exp i in
     let v = print_exp v in
     {%pla|(<#l#>[<#i#>] = <#v#>)|}
+  (* Inline simple builtins to avoid function call overhead *)
+  | ECall { path = "eps"; args = [] } -> {%pla|1e-18|}
+  | ECall { path = "pi"; args = [] } -> {%pla|3.1415926535897932384|}
+  | ECall { path = "real"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|(<#x#>)|}
+  | ECall { path = "int_"; args = [ x ] } ->
+    (* Bitwise OR with 0 truncates to 32-bit integer *)
+    let x = print_exp x in
+    {%pla|((<#x#>)|0)|}
+  | ECall { path = "not_"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|((<#x#>) == 0 ? 1 : 0)|}
+  | ECall { path = "clip"; args = [ x; low; high ] } ->
+    let x = print_exp x in
+    let low = print_exp low in
+    let high = print_exp high in
+    {%pla|((<#x#>) < (<#low#>) ? (<#low#>) : ((<#x#>) > (<#high#>) ? (<#high#>) : (<#x#>)))|}
+  (* Inline Math functions *)
+  | ECall { path = "sin"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.sin(<#x#>)|}
+  | ECall { path = "cos"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.cos(<#x#>)|}
+  | ECall { path = "abs"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.abs(<#x#>)|}
+  | ECall { path = "exp"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.exp(<#x#>)|}
+  | ECall { path = "floor"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.floor(<#x#>)|}
+  | ECall { path = "tan"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.tan(<#x#>)|}
+  | ECall { path = "tanh"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.tanh(<#x#>)|}
+  | ECall { path = "sqrt"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|Math.sqrt(<#x#>)|}
+  | ECall { path = "pow"; args = [ a; b ] } ->
+    let a = print_exp a in
+    let b = print_exp b in
+    {%pla|Math.pow(<#a#>, <#b#>)|}
   | ECall { path; args } ->
     let args = Pla.map_sep Pla.commaspace print_exp args in
     {%pla|this.<#path#s>(<#args#>)|}

src/generators/lua.ml

@@ -104,20 +104,12 @@ else
     function rshift(a, b) return math.floor(a / (2 ^ b)) end
 end
 
--- Core runtime functions
+-- Core runtime functions (simple builtins like eps, pi, clip, real, int, bool are inlined)
 function ifExpressionValue(cond,then_,else_) if cond then return then_ else return else_ end end
 function ifExpression(cond,then_,else_) if cond then return then_() else return else_() end end
-function eps()              return 1e-18 end
-function pi()               return 3.1415926535897932384 end
 function random()           return math.random() end
 function irandom()          return math.floor(math.random() * 4294967296) end
-function clip(x,low,high)   if x > high then return high else if x < low then return low else return x end end end
-function real(x)            return x end
-function int(x)             if type(x) == "boolean" then x = x and 1 or 0 end local int_part,_ = math.modf(x) return int_part end
-function int16(x)           if type(x) == "boolean" then x = x and 1 or 0 end local int_part,_ = math.modf(x) return math.max(-32768, math.min(32767, int_part)) end
-function bool(x)            return x ~= 0 and x ~= false end
-function set(a, i, v)       a[i+1]=v end
-function get(a, i)          return a[i+1] end
+function int16(x)           local int_part,_ = math.modf(x) return math.max(-32768, math.min(32767, int_part)) end
 function intDiv(a, b)       return math.floor(a / b) end
 function list_clear(t)      for k in pairs(t) do t[k] = nil end end
 
@@ -182,9 +174,10 @@ let rec print_exp e =
     let index = i + 1 in
     {%pla|<#e#>[<#index#i>]|}
   | EIndex { e; index } ->
+    (* Inline index+1 to avoid function call overhead in standard Lua *)
     let e = print_exp e in
     let index = print_exp index in
-    {%pla|get(<#e#>, <#index#>)|}
+    {%pla|<#e#>[(<#index#>) + 1]|}
   | EArray l -> Pla.wrap (Pla.string "{") (Pla.string "}") (Pla.map_sep Pla.commaspace print_exp l)
   | ECall { path; args } -> (
     (* Use optimized functions when available *)
@@ -227,14 +220,38 @@ let rec print_exp e =
     | "list_get", [ l; i ] ->
       let l = print_exp l in
       let i = print_exp i in
-      (* Use get() helper for 1-based indexing *)
-      {%pla|get(<#l#>, <#i#>)|}
+      (* Inline index+1 to avoid function call overhead *)
+      {%pla|<#l#>[(<#i#>) + 1]|}
     | "list_set", [ l; i; v ] ->
       let l = print_exp l in
       let i = print_exp i in
       let v = print_exp v in
       (* Lua is 1-based *)
       {%pla|<#l#>[<#i#> + 1] = <#v#>|}
+    (* Inline simple builtins to avoid function call overhead *)
+    | "eps", [] -> {%pla|1e-18|}
+    | "pi", [] -> {%pla|3.1415926535897932384|}
+    | "real", [ x ] ->
+      let x = print_exp x in
+      {%pla|(<#x#>)|}
+    | "int", [ x ] ->
+      (* Inline int conversion using math.modf (truncates towards zero) *)
+      let x = print_exp x in
+      {%pla|(math.modf(<#x#>))|}
+    | "bool", [ x ] ->
+      (* Inline bool conversion *)
+      let x = print_exp x in
+      {%pla|((<#x#>) ~= 0 and (<#x#>) ~= false)|}
+    | "not_", [ x ] ->
+      (* Inline logical not *)
+      let x = print_exp x in
+      {%pla|(not (<#x#>))|}
+    | "clip", [ x; low; high ] ->
+      (* Inline clip as: (x > high) and high or ((x < low) and low or x) *)
+      let x = print_exp x in
+      let low = print_exp low in
+      let high = print_exp high in
+      {%pla|((<#x#>) > (<#high#>) and (<#high#>) or ((<#x#>) < (<#low#>) and (<#low#>) or (<#x#>)))|}
     | _ ->
       let args = Pla.map_sep Pla.commaspace print_exp args in
       {%pla|<#path#s>(<#args#>)|})

src/generators/python.ml

@@ -28,30 +28,14 @@ let runtime =
   {%pla|import math
 import random as random_module
 
-def eps():
-    return 1e-18
-
-def pi():
-    return 3.1415926535897932384
+# Runtime functions (simple builtins like eps, pi, clip, sin, cos, etc. are inlined)
 
 def random():
     return random_module.random()
 
 def irandom():
     return int(random_module.random() * 4294967296)
 
-def clip(x, low, high):
-    return low if x < low else (high if x > high else x)
-
-def not_(x):
-    return 0 if x != 0 else 1
-
-def real(x):
-    return float(x)
-
-def int_(x):
-    return int(x)
-
 def int_to_float(i):
     return float(i)
 
@@ -149,6 +133,52 @@ let rec print_exp (e : exp) =
     let i = print_exp i in
     let v = print_exp v in
     {%pla|<#l#>.__setitem__(<#i#>, <#v#>)|}
+  (* Inline simple builtins to avoid function call overhead *)
+  | ECall { path = "eps"; args = [] } -> {%pla|1e-18|}
+  | ECall { path = "pi"; args = [] } -> {%pla|3.1415926535897932384|}
+  | ECall { path = "real"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|float(<#x#>)|}
+  | ECall { path = "int_"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|int(<#x#>)|}
+  | ECall { path = "not_"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|(0 if (<#x#>) != 0 else 1)|}
+  | ECall { path = "clip"; args = [ x; low; high ] } ->
+    let x = print_exp x in
+    let low = print_exp low in
+    let high = print_exp high in
+    {%pla|((<#low#>) if (<#x#>) < (<#low#>) else ((<#high#>) if (<#x#>) > (<#high#>) else (<#x#>)))|}
+  (* Inline math functions *)
+  | ECall { path = "sin"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.sin(<#x#>)|}
+  | ECall { path = "cos"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.cos(<#x#>)|}
+  | ECall { path = "abs"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|abs(<#x#>)|}
+  | ECall { path = "exp"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.exp(<#x#>)|}
+  | ECall { path = "floor"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.floor(<#x#>)|}
+  | ECall { path = "tan"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.tan(<#x#>)|}
+  | ECall { path = "tanh"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.tanh(<#x#>)|}
+  | ECall { path = "sqrt"; args = [ x ] } ->
+    let x = print_exp x in
+    {%pla|math.sqrt(<#x#>)|}
+  | ECall { path = "pow"; args = [ a; b ] } ->
+    let a = print_exp a in
+    let b = print_exp b in
+    {%pla|math.pow(<#a#>, <#b#>)|}
   | ECall { path; args } ->
     let args = Pla.map_sep Pla.commaspace print_exp args in
     {%pla|<#path#s>(<#args#>)|}

test/code/ConstSpecialization.js.base

@@ -1,21 +1,7 @@
 
+// Runtime functions (simple builtins like eps, pi, clip, real, int_, sin, cos, etc. are inlined)
 this.random = function()         { return Math.random(); };
 this.irandom = function()        { return Math.floor(Math.random() * 4294967296); };
-this.eps  = function()           { return 1e-18 };
-this.pi   = function()           { return 3.1415926535897932384; }
-this.clip = function(x,low,high) { return x<low?low:(x>high?high:x); };
-this.not  = function(x)          { return x==0?1:0; };
-this.real = function(x)          { return x; };
-this.int_  = function(x)         { return x|0; };
-this.sin  = function(x)          { return Math.sin(x); };
-this.cos  = function(x)          { return Math.cos(x); };
-this.abs  = function(x)          { return Math.abs(x); };
-this.exp  = function(x)          { return Math.exp(x); };
-this.floor = function(x)          { return Math.floor(x); };
-this.tan  = function(x)          { return Math.tan(x); };
-this.tanh = function(x)          { return Math.tanh(x); };
-this.pow  = function(a,b)         { return Math.pow(a,b); };
-this.sqrt = function(x)          { return x; };
 this.int_to_float = function(i)  { return i; };
 this.float_to_int = function(i)  { return Math.floor(i); };
 this.initializeArray = function(v, size){ var a = new Array(size); for(var i=0;i<size;i++) a[i]=v; return a; };

test/code/ConstSpecialization.lua.base

@@ -72,20 +72,12 @@ else
     function rshift(a, b) return math.floor(a / (2 ^ b)) end
 end
 
--- Core runtime functions
+-- Core runtime functions (simple builtins like eps, pi, clip, real, int, bool are inlined)
 function ifExpressionValue(cond,then_,else_) if cond then return then_ else return else_ end end
 function ifExpression(cond,then_,else_) if cond then return then_() else return else_() end end
-function eps()              return 1e-18 end
-function pi()               return 3.1415926535897932384 end
 function random()           return math.random() end
 function irandom()          return math.floor(math.random() * 4294967296) end
-function clip(x,low,high)   if x > high then return high else if x < low then return low else return x end end end
-function real(x)            return x end
-function int(x)             if type(x) == "boolean" then x = x and 1 or 0 end local int_part,_ = math.modf(x) return int_part end
-function int16(x)           if type(x) == "boolean" then x = x and 1 or 0 end local int_part,_ = math.modf(x) return math.max(-32768, math.min(32767, int_part)) end
-function bool(x)            return x ~= 0 and x ~= false end
-function set(a, i, v)       a[i+1]=v end
-function get(a, i)          return a[i+1] end
+function int16(x)           local int_part,_ = math.modf(x) return math.max(-32768, math.min(32767, int_part)) end
 function intDiv(a, b)       return math.floor(a / b) end
 function list_clear(t)      for k in pairs(t) do t[k] = nil end end
 
@@ -264,7 +256,7 @@ function ConstSpecialization_setMatrix2(m, row, col, value)
 end
 
 function ConstSpecialization_getMatrix2(m, row, col)
-   return get(m, (row + lshift(col, 1)))
+   return m[((row + lshift(col, 1))) + 1]
 end
 
 function ConstSpecialization_test_matrix_mutation(m, x)

test/code/ConstSpecialization.py.base

@@ -1,30 +1,14 @@
 import math
 import random as random_module
 
-def eps():
-    return 1e-18
-
-def pi():
-    return 3.1415926535897932384
+# Runtime functions (simple builtins like eps, pi, clip, sin, cos, etc. are inlined)
 
 def random():
     return random_module.random()
 
 def irandom():
     return int(random_module.random() * 4294967296)
 
-def clip(x, low, high):
-    return low if x < low else (high if x > high else x)
-
-def not_(x):
-    return 0 if x != 0 else 1
-
-def real(x):
-    return float(x)
-
-def int_(x):
-    return int(x)
-
 def int_to_float(i):
     return float(i)
 

test/code/Constants.js.base

@@ -1,21 +1,7 @@
 
+// Runtime functions (simple builtins like eps, pi, clip, real, int_, sin, cos, etc. are inlined)
 this.random = function()         { return Math.random(); };
 this.irandom = function()        { return Math.floor(Math.random() * 4294967296); };
-this.eps  = function()           { return 1e-18 };
-this.pi   = function()           { return 3.1415926535897932384; }
-this.clip = function(x,low,high) { return x<low?low:(x>high?high:x); };
-this.not  = function(x)          { return x==0?1:0; };
-this.real = function(x)          { return x; };
-this.int_  = function(x)         { return x|0; };
-this.sin  = function(x)          { return Math.sin(x); };
-this.cos  = function(x)          { return Math.cos(x); };
-this.abs  = function(x)          { return Math.abs(x); };
-this.exp  = function(x)          { return Math.exp(x); };
-this.floor = function(x)          { return Math.floor(x); };
-this.tan  = function(x)          { return Math.tan(x); };
-this.tanh = function(x)          { return Math.tanh(x); };
-this.pow  = function(a,b)         { return Math.pow(a,b); };
-this.sqrt = function(x)          { return x; };
 this.int_to_float = function(i)  { return i; };
 this.float_to_int = function(i)  { return Math.floor(i); };
 this.initializeArray = function(v, size){ var a = new Array(size); for(var i=0;i<size;i++) a[i]=v; return a; };

test/code/Constants.lua.base

@@ -72,20 +72,12 @@ else
     function rshift(a, b) return math.floor(a / (2 ^ b)) end
 end
 
--- Core runtime functions
+-- Core runtime functions (simple builtins like eps, pi, clip, real, int, bool are inlined)
 function ifExpressionValue(cond,then_,else_) if cond then return then_ else return else_ end end
 function ifExpression(cond,then_,else_) if cond then return then_() else return else_() end end
-function eps()              return 1e-18 end
-function pi()               return 3.1415926535897932384 end
 function random()           return math.random() end
 function irandom()          return math.floor(math.random() * 4294967296) end
-function clip(x,low,high)   if x > high then return high else if x < low then return low else return x end end end
-function real(x)            return x end
-function int(x)             if type(x) == "boolean" then x = x and 1 or 0 end local int_part,_ = math.modf(x) return int_part end
-function int16(x)           if type(x) == "boolean" then x = x and 1 or 0 end local int_part,_ = math.modf(x) return math.max(-32768, math.min(32767, int_part)) end
-function bool(x)            return x ~= 0 and x ~= false end
-function set(a, i, v)       a[i+1]=v end
-function get(a, i)          return a[i+1] end
+function int16(x)           local int_part,_ = math.modf(x) return math.max(-32768, math.min(32767, int_part)) end
 function intDiv(a, b)       return math.floor(a / b) end
 function list_clear(t)      for k in pairs(t) do t[k] = nil end end