rlang 0.5.1 → 0.6.0

data/lib/rlang/parser/wgenerator.rb

@@ -22,26 +22,29 @@ module Rlang::Parser
     :+  => :add,
     :-  => :sub,
     :*  => :mul,
-    :/  => :div_u,
-    :%  => :rem_u,
     :&  => :and,
     :|  => :or,
     :^  => :xor,
-    :>> => :shr_u,
     :<< => :shl
   }
 
+  ARITHMETIC_SIGNED_OPS_MAP = {
+    :/  => :div_x,
+    :%  => :rem_x,
+    :>> => :shr_x
+  }
+
   RELATIONAL_OPS_MAP = {
     :==    => :eq,
     :!=    => :ne,
-    :'<s'  => :lt_s,
-    :<     => :lt_u,
-    :'>s'  => :gt_s,
-    :>     => :gt_u,
-    :'<=s' => :le_s,
-    :<=    => :le_u,
-    :'>=s' => :ge_s,
-    :>=    => :ge_u
+
+  }
+
+  RELATIONAL_SIGNED_OPS_MAP = {
+    :<     => :lt_x,
+    :>     => :gt_x,
+    :<=    => :le_x,
+    :>=    => :ge_x
   }
 
   BOOLEAN_OPS_MAP = {
@@ -50,19 +53,40 @@ module Rlang::Parser
   }
 
   UNARY_OPS_MAP = {
-    :'!'   => :eqz
+    :'!'   => :eqz,
+    :'-@'  => :sub  # special case for unary - turned into (sub 0 x)
   }
 
-  ALL_OPS_MAP = [*ARITHMETIC_OPS_MAP, *RELATIONAL_OPS_MAP, *BOOLEAN_OPS_MAP, *UNARY_OPS_MAP].to_h
+  SIGNED_OPS = {
+    signed: {div_x: :div_s, rem_x: :rem_s, shr_x: :shr_s, lt_x: :lt_s, gt_x: :gt_s,
+      le_x: :le_s, ge_x: :ge_s},
+    unsigned: {div_x: :div_u, rem_x: :rem_u, shr_x: :shr_u, lt_x: :lt_u, gt_x: :gt_u,
+        le_x: :le_u, ge_x: :ge_u},
+  }
+
+  # Operators that can be legally used when doing
+  # arithmetic on class instance (= object) pointers
+  # Only unsigned relational operators make sense as pointers
+  # are by nature unsigned integers
+  LEGAL_CLASS_WASM_OPS = [:eq, :ne, :lt_u, :gt_u, :le_u, :ge_u, :add, :sub]
+
+  # All operators with signed / unsigned variants
+  ALL_SIGNED_OPS_MAP = [*ARITHMETIC_SIGNED_OPS_MAP, *RELATIONAL_SIGNED_OPS_MAP].to_h
+
+  # All operators in on hash
+  ALL_OPS_MAP = [*ARITHMETIC_OPS_MAP, *ARITHMETIC_SIGNED_OPS_MAP, *RELATIONAL_OPS_MAP, *RELATIONAL_SIGNED_OPS_MAP,
+                 *BOOLEAN_OPS_MAP, *UNARY_OPS_MAP].to_h
 
   # Matrix of how to cast a WASM type to another
   CAST_OPS = {
-    I32: { I32: :cast_nope, I64: :cast_extend, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_wtype, none: :cast_error},
-    I64: { I32: :cast_wrap, I64: :cast_nope, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
-    F32: { I32: :cast_notyet, I64: :cast_notyet, F32: :cast_nope, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
-    F64: { I32: :cast_notyet, I64: :cast_notyet, F32: :cast_notyet, F64: :cast_nope, Class: :cast_error, none: :cast_error},    
-    Class: { I32: :cast_wtype, I64: :cast_extend, F32: :cast_error, F64: :cast_error, Class: :cast_wtype, none: :cast_error},
-    none: { I32: :cast_error, I64: :cast_error, F32: :cast_error, F64: :cast_error, Class: :cast_error, none: :cast_error},
+    UI32:  { UI32: :cast_nope,   I32: :cast_wtype,  UI64: :cast_extend, I64: :cast_extend, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_wtype, none: :cast_error},
+    I32:   { UI32: :cast_wtype,  I32: :cast_nope,   UI64: :cast_extend, I64: :cast_extend, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_wtype, none: :cast_error},
+    UI64:  { UI32: :cast_wrap,   I32: :cast_wrap,   UI64: :cast_nope,   I64: :cast_wtype,  F32: :cast_notyet, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
+    I64:   { UI32: :cast_wrap,   I32: :cast_wrap,   UI64: :cast_wtype,   I64: :cast_nope,   F32: :cast_notyet, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
+    F32:   { UI32: :cast_notyet, I32: :cast_notyet, UI64: :cast_notyet, I64: :cast_notyet, F32: :cast_nope,   F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
+    F64:   { UI32: :cast_notyet, I32: :cast_notyet, UI64: :cast_notyet, I64: :cast_notyet, F32: :cast_notyet, F64: :cast_nope,   Class: :cast_error, none: :cast_error},    
+    Class: { UI32: :cast_wtype,  I32: :cast_wtype,  UI64: :cast_extend, I64: :cast_extend, F32: :cast_error,  F64: :cast_error,  Class: :cast_wtype, none: :cast_error},
+    none:  { UI32: :cast_error,  I32: :cast_error,  UI64: :cast_error,  I64: :cast_error,  F32: :cast_error,  F64: :cast_error,  Class: :cast_error, none: :cast_error},
   }
 
   # Rlang class size method name
@@ -103,6 +127,11 @@ module Rlang::Parser
     String.new(%{ptr}, %{length})
   }
 
+  # Dynamically allocate a string object
+  ARRAY_NEW_TMPL = %q{
+    Array%{elt_size_in_bits}.new(%{ptr}, %{length})
+  }
+
   # Generate the wasm nodes and tree structure
   # ***IMPORTANT NOTE***
   # Unless otherwise stated all methods receive
@@ -190,6 +219,13 @@ module Rlang::Parser
       k.wnode
     end
 
+    def comments(wnode, comments)
+      # The gsub below is to handle =begin...=end block comments
+      comments.each do |c|
+        WNode.new(:comment, wnode).c(:comment, text: c.text.sub(/^\s*#/,'').gsub("\n", "\n;;"))
+      end
+    end
+
     # Create module object and module wnode 
     # if it doesn't exist yet
     def module(wnode, module_path)
@@ -305,9 +341,9 @@ module Rlang::Parser
       unless size_method.wnode
         logger.debug("Generating #{size_method.klass.name}\##{size_method.name}")
         wns = WNode.new(:insn, wnc)
-        wns.wtype = WType::DEFAULT 
+        wns.wtype = WType::DEFAULT
         wns.c(:class_size, func_name: size_method.wasm_name, 
-              wtype: wns.wasm_type, size: wnc.class_size)
+              wasm_type: wns.wasm_type, size: wnc.class_size)
         size_method.wnode = wns
       end
     end
@@ -317,7 +353,7 @@ module Rlang::Parser
       wnc = wnode.class_wnode
       wn_set = WNode.new(:insn, wnc, true)
       wn_set.c(:attr_setter, func_name: attr.setter.wasm_name, 
-            attr_name: attr.wasm_name, wtype: attr.wasm_type,
+            attr_name: attr.wasm_name, wasm_type: attr.wasm_type,
             offset: attr.offset)
       wn_set
     end
@@ -327,8 +363,7 @@ module Rlang::Parser
       wnc = wnode.class_wnode
       wn_get = WNode.new(:insn, wnc, true)
       wn_get.c(:attr_getter, func_name: attr.getter.wasm_name, 
-            attr_name: attr.wasm_name, wtype: attr.wasm_type,
-            offset: attr.offset)
+            wasm_type: attr.wasm_type, offset: attr.offset)
       wn_get
     end
 
@@ -381,7 +416,7 @@ module Rlang::Parser
         logger.debug("Prepending param #{marg}")
         wn = WNode.new(:insn, wnm, true)
         wn.wtype = marg.wtype
-        wn.c(:param, name: marg.wasm_name)
+        wn.c(:param, name: marg.wasm_name, wasm_type: wn.wasm_type)
       end
     end
 
@@ -389,7 +424,7 @@ module Rlang::Parser
       unless wnode.wtype.blank?
         wn = WNode.new(:insn, wnode, true)
         wn.wtype = wnode.wtype
-        wn.c(:result)      
+        wn.c(:result, wasm_type: wn.wasm_type)      
       end
     end
 
@@ -399,7 +434,7 @@ module Rlang::Parser
         logger.debug("Prepending local #{lvar.inspect}")
         wn = WNode.new(:insn, wnm, true)
         wn.wtype = lvar.wtype
-        wn.c(:local, name: lvar.wasm_name)
+        wn.c(:local, name: lvar.wasm_name, wasm_type: wn.wasm_type)
       end
     end
 
@@ -413,7 +448,7 @@ module Rlang::Parser
     # Set constant
     def casgn(wnode, const)
       (wn = WNode.new(:insn, wnode)).wtype = const.wtype
-      wn.c(:store, wtype: const.wtype)
+      wn.c(:store, wasm_type: const.wtype)
       WNode.new(:insn, wn).c(:addr, value: const.address)
       wn
     end
@@ -421,7 +456,7 @@ module Rlang::Parser
     # Get constant
     def const(wnode, const)
       (wn = WNode.new(:insn, wnode)).wtype = const.wtype
-      wn.c(:load, wtype: const.wtype, var_name: const.wasm_name)
+      wn.c(:load, wasm_type: const.wasm_type)
       WNode.new(:insn, wn).c(:addr, value: const.address)
       wn
     end
@@ -468,7 +503,7 @@ module Rlang::Parser
     # Set instance variable
     def ivasgn(wnode, ivar)
       (wn = WNode.new(:insn, wnode)).wtype = ivar.wtype
-      wn.c(:store_offset, wtype: ivar.wasm_type, offset: lambda { ivar.offset })
+      wn.c(:store_offset, wasm_type: ivar.wasm_type, offset: lambda { ivar.offset })
       self._self_(wn)
       wn
     end
@@ -476,7 +511,7 @@ module Rlang::Parser
     # Get instance variable. 
     def ivar(wnode, ivar)
       (wn = WNode.new(:insn, wnode)).wtype = ivar.wtype
-      wn.c(:load_offset, wtype: ivar.wasm_type, offset: lambda { ivar.offset })
+      wn.c(:load_offset, wasm_type: ivar.wasm_type, offset: lambda { ivar.offset })
       self._self_(wn)
       wn
     end
@@ -486,7 +521,7 @@ module Rlang::Parser
     # an empty expression node to populate later
     def cvasgn(wnode, cvar)
       (wn = WNode.new(:insn, wnode)).wtype = cvar.wtype
-      wn.c(:store, wtype: cvar.wtype)
+      wn.c(:store, wasm_type: cvar.wasm_type)
       WNode.new(:insn, wn).c(:addr, value: cvar.address)
       wn
     end
@@ -494,7 +529,7 @@ module Rlang::Parser
     # Get class variable
     def cvar(wnode, cvar)
       (wn = WNode.new(:insn, wnode)).wtype = cvar.wtype
-      wn.c(:load, wtype: cvar.wtype, var_name: cvar.wasm_name)
+      wn.c(:load, wasm_type: cvar.wasm_type)
       WNode.new(:insn, wn).c(:addr, value: cvar.address)
       wn
     end
@@ -510,14 +545,14 @@ module Rlang::Parser
     # Create the local variable storage node 
     def lvasgn(wnode, lvar)
       (wn = WNode.new(:insn, wnode)).wtype = lvar.wtype
-      wn.c(:local_set, wtype: lvar.wtype, var_name: lvar.wasm_name)
+      wn.c(:local_set, var_name: lvar.wasm_name)
       wn
     end
 
     # Read local variable
     def lvar(wnode, lvar)
       (wn = WNode.new(:insn, wnode)).wtype = lvar.wtype
-      wn.c(:local_get, wtype: lvar.wtype, var_name: lvar.wasm_name)
+      wn.c(:local_get, var_name: lvar.wasm_name)
       wn
     end
 
@@ -534,13 +569,13 @@ module Rlang::Parser
 
     def int(wnode, wtype, value)
       (wn = WNode.new(:insn, wnode)).wtype = wtype
-      wn.c(:const, wtype: wtype, value: value)
+      wn.c(:const, wasm_type: wn.wasm_type, value: value)
       wn
     end
 
     def float(wnode, wtype, value)
       (wn = WNode.new(:insn, wnode)).wtype = wtype
-      wn.c(:const, wtype: wtype, value: value)
+      wn.c(:const, wasm_type: wn.wasm_type, value: value)
       wn
     end
 
@@ -551,24 +586,25 @@ module Rlang::Parser
       WNode.new(type, wnode)
     end
 
-    # Static string allocation
-    def string_static(string, data_label)
-      # Allocate string itself and the attributes
-      # of String object pointing to that string
-      data_stg = DAta.append(data_label.to_sym, string)
-      data_stg
+    # Static string data allocation
+    def allocate_string_static_data(string, data_label)
+      # if string is empty do not allocate any memory space
+      DAta.append(data_label.to_sym, string) unless string.empty?
     end
 
     # Static new string object
     def string_static_new(wnode, string)
       klass = wnode.find_current_class_or_module()
       data_label = "#{klass.name}_string_#{@static_count += 1}"
-      # Statically 
-      data_stg = self.string_static(string, data_label)
+      # Allocate string data statically
+      # Note : data_stg is nil if string is empty
+      data_stg = self.allocate_string_static_data(string, data_label)
       # align on :I32 boundary
+      # then allocate the String object attributes
+      # and set them up
       DAta.align(4)
       data_len = DAta.append("#{data_label}_len".to_sym, string.length, WType::DEFAULT)
-      data_ptr = DAta.append("#{data_label}_ptr".to_sym, data_stg.address, WType::DEFAULT)
+      data_ptr = DAta.append("#{data_label}_ptr".to_sym, data_stg ? data_stg.address : 0, WType::DEFAULT)
       # Generate address wnode
       (wn_object_addr = WNode.new(:insn, wnode)).c(:addr, value: data_len.address)
       wn_object_addr.wtype = WType.new(:String)
@@ -579,25 +615,73 @@ module Rlang::Parser
     def string_dynamic_new(wnode, string)
       klass = wnode.find_current_class_or_module()
       data_label = "#{klass.name}_string_#{@static_count += 1}"
-      data_stg = self.string_static(string, data_label)
+      # Note : data_stg is nil if string is empty
+      data_stg = self.allocate_string_static_data(string, data_label)
       string_new_source = STRING_NEW_TMPL % {
-        ptr: data_stg.address,
+        ptr: data_stg ? data_stg.address : 0,
         length: string.length
       }
       #puts string_new_source;exit
-      wn_string = self.parser.parse(string_new_source, wnode)
-      #puts wn_string; exit
+      self.parser.parse(string_new_source, wnode)
+    end
+
+    # Static array data allocation
+    def allocate_array_static_data(array, data_label)
+      # Append each array element to the same data section
+      label = data_label.to_sym
+      data_arr = nil
+      # Do not allocate memory space if array is empty
+      array.each { |elt| data_arr = DAta.append(label, elt) }
+      data_arr
+    end
+
+    # Static new array object
+    def array_static_new(wnode, array)
+      klass = wnode.find_current_class_or_module()
+      data_label = "#{klass.name}_array_#{@static_count += 1}"
+      # Allocate array data statically
+      # Note : data_arr is nil if string is empty
+      data_arr = self.allocate_array_static_data(array, data_label)
+      # align on :I32 boundary
+      # then allocate the Array object attributes
+      # and set them up
+      DAta.align(4)
+      data_count = DAta.append("#{data_label}_count".to_sym, array.length, WType::DEFAULT)
+      data_ptr   = DAta.append("#{data_label}_ptr".to_sym, data_arr ? data_arr.address : 0, WType::DEFAULT)
+      # Generate address wnode
+      (wn_object_addr = WNode.new(:insn, wnode)).c(:addr, value: data_count.address)
+      wn_object_addr.wtype = WType.new(:Array32)
+      wn_object_addr
+    end
+
+    # Dynamic new array object
+    def array_dynamic_new(wnode, array)
+      klass = wnode.find_current_class_or_module()
+      data_label = "#{klass.name}_array_#{@static_count += 1}"
+      # Note : data_arr is nil if string is empty
+      data_arr = self.allocate_array_static_data(array, data_label)
+      array_new_source = ARRAY_NEW_TMPL % {
+        elt_size_in_bits: WTYPE::DEFAULT.size * 8,
+        ptr: data_arr ? data_arr.address : 0,
+        count: array.length
+      }
+      #puts array_new_source;exit
+      self.parser.parse(array_new_source, wnode)
     end
 
+    # TYPE CASTING methods
     # All the cast_xxxx methods below returns
     # the new wnode doing the cast operation
     # or the same wnode if there is no additional code
     # for the cast operation
+
+    # No casting. Return node as is.
     def cast_nope(wnode, wtype, signed)
-      # Do nothing
       wnode
     end
 
+    # Cast by extending to a wtype of larger bit size
+    # (e.g. I32 to I64)
     def cast_extend(wnode, wtype, signed)
       if (wnode.template == :const)
         # it's a WASM const, simply change the wtype
@@ -606,15 +690,19 @@ module Rlang::Parser
       else
         wn_cast_op = wnode.insert(:insn)
         wn_cast_op.wtype = wtype
-        wn_cast_op.c(signed ? :extend_i32_s : :extend_i32_u , wtype: wtype)
+        wn_cast_op.c(signed ? :extend_i32_s : :extend_i32_u , wasm_type: wn_cast_op.wasm_type)
       end
       wn_cast_op
     end
 
+    # Cast by simply changing the node wtype
+    # No change in native WASM type
+    # (e.g. casting an object pointer to I32)
     def cast_wtype(wnode, wtype, signed)
-      if (wnode.wtype.default? && wtype.class?) || 
-         (wnode.wtype.class? && wtype.default?) ||
-         (wnode.wtype.class? && wtype.class?)
+      # Don't cast blindly. Check that source and target
+      # have the same bit size (e.g. Object pointers, I32, UI32
+      # are the same size, )
+      if wnode.wtype.size == wtype.size
         wnode.wtype = wtype
       else
         cast_error(wnode, wtype, signed)
@@ -622,6 +710,8 @@ module Rlang::Parser
       wnode
     end
 
+    # Cast by wraping a wtype to a smaller size
+    # (e.g. I64 to I32)
     def cast_wrap(wnode, wtype, signed)
       if (wnode.template == :const)
         # it's a WASM const, simply change the wtype
@@ -630,17 +720,19 @@ module Rlang::Parser
       else
         wn_cast_op = wnode.insert(:insn)
         wn_cast_op.wtype = wtype
-        wn_cast_op.c(:wrap_i64, wtype: wtype)
+        wn_cast_op.c(:wrap_i64, wasm_type: wn_cast_op.wasm_type)
       end
       wn_cast_op
     end
 
+    # Cast operation not yet supported
     def cast_notyet(wnode, wtype, signed)
       raise "Type cast from #{wnode.wtype} to #{wtype} not supported yet"
     end
 
+    # Cast operation is invalid
     def cast_error(wnode, wtype, signed)
-      raise "Cannot cast type #{src} to #{dest}. Time to fix your code :-)"
+      raise "Cannot cast type #{wnode.wtype} to #{wtype}. Time to fix your code :-)"
     end
 
     # cast an expression to a different type
@@ -668,17 +760,20 @@ module Rlang::Parser
     # operands below)
     def native_operator(wnode, operator, wtype=WType.new(:none))
       if (op = ALL_OPS_MAP[operator])
-        (wn_op = WNode.new(:insn, wnode)).c(:operator, operator: op)
-        wn_op.wtype = wtype
+        (wn_op = WNode.new(:insn, wnode)).wtype = wtype
+        wn_op.c(:operator, wasm_type: wn_op.wasm_type, operator: op)
         logger.debug "Creating operator #{operator} wnode: #{wn_op}"
+        # special case for - unary operator transformed into (0 - x)
+        WNode.new(:insn, wn_op).c(:const, wasm_type: wn_op.wasm_type, value: 0) if operator == :-@
         wn_op
       else
         raise "operator '#{operator}' not supported"
       end
     end
 
-    # finish the setting of the operator node and
-    # attach operands
+    # Finish the setting of the operator node, 
+    # attach operands and see if they need implicit
+    # type casting
     def operands(wnode_op, wnode_recv, wnode_args)
       logger.debug "Processing operands in operator wnode: #{wnode_op}..."
       # Do not post process operands if the operator
@@ -696,26 +791,48 @@ module Rlang::Parser
       #wnode_recv = wnode_op.children[0]
       #wnode_args = wnode_op.children[1..-1]
       # First find out the wtype that has precedence
-      wtype = self.class.leading_wtype(wnode_recv, *wnode_args)
+      leading_wtype = self.class.leading_wtype(wnode_recv, *wnode_args)
       
-      wnode_op.wtype = wtype
-      logger.debug "leading type cast: #{wtype}"
+      wnode_op.wtype = leading_wtype
+      logger.debug "leading type cast: #{leading_wtype}"
 
       # Attach receiver and argument to the operator wnode
-      # type casting them if necessary    
-      self.cast(wnode_recv, wtype).reparent_to(wnode_op)
-      self.cast(wnode_args.first, wtype).reparent_to(wnode_op) unless wnode_args.empty?
+      # type casting them if necessary
+      # Note : normally for an operator there is only one argument
+      # but process args as if they were many one day.
+      logger.debug "Perform implicit type casting of receviver and operator arg(s)"
+      self.cast(wnode_recv, leading_wtype).reparent_to(wnode_op)
+      wnode_args.each do |wna|
+        self.cast(wna, leading_wtype).reparent_to(wnode_op)
+      end
+
+      # Once operands casting is done, see if we need the signed or unsigned
+      # version of the native operator
+      # NOTE : At this stage, after the operands casting both of them
+      # should either be signed or unsigned, hence the XNOR sanity check
+      # below
+      if ALL_SIGNED_OPS_MAP.values.include? op
+        if !((signed = wnode_recv.wtype.signed?) ^ (wnode_args.empty? ? true : wnode_args.first.wtype.signed?))
+          wnode_op.wargs[:operator] = SIGNED_OPS[signed ? :signed : :unsigned][op]
+          logger.debug "Receiver has wtype #{wnode_recv.wtype} / Argument has wtype #{wnode_args.first.wtype}"
+          logger.debug "Replacing #{op} operator with #{wnode_op.wargs[:operator]}"
+          op = wnode_op.wargs[:operator]
+        else
+          raise "Type mismatch between operands. Receiver is #{wnode_recv.wtype} and argument is #{wnode_args.first.wtype}"
+        end
+      end
 
       # if the receiver is a class object and not
       # a native integer then pointer arithmetic
       # applies (like in C)
       if wnode_recv.wtype.class?
-        legal_ops = RELATIONAL_OPS_MAP.values + [:add, :sub]
-        raise "Only #{legal_ops.join(', ')} operators are supported on objects (got #{op} in #{wnode_op})" \
-          unless legal_ops.include?(op)
-        # if + or - operator then multiply arg by size of object
-        if [:add, :sub].include? wnode_op.wargs[:operator]
-          (wn_mulop = WNode.new(:insn, wnode_op)).c(:operator, operator: :mul)
+        raise "Only #{LEGAL_CLASS_WASM_OPS.join(', ')} operators are supported on objects (got #{op} in #{wnode_op})" \
+          unless LEGAL_CLASS_WASM_OPS.include?(op)
+        # if :add or :sub operator then multiply arg by size of object
+        # like in C
+        if [:add, :sub].include? op
+          (wn_mulop = WNode.new(:insn, wnode_op)).wtype = WType::DEFAULT
+          wn_mulop.c(:operator, wasm_type: wn_mulop.wasm_type, operator: :mul)
           WNode.new(:insn, wn_mulop).c(:call, func_name: "$#{wnode_recv.wtype.name}::#{SIZE_METHOD}")
           wnode_args.first.reparent_to(wn_mulop)
         else
@@ -794,14 +911,35 @@ module Rlang::Parser
     # generate code for method call
     def send_method(wnode, class_path, method_name, method_type)
       logger.debug "In call generator for #{class_path}::#{method_name}"
-      k = wnode.find_class_or_module(class_path)
-      if k && (method = wnode.find_method(k, method_name, method_type))
-        logger.debug "Found method #{method.name} in class #{method.klass.name}"
-        (wn_call = WNode.new(:insn, wnode)).c(:call, func_name: method.wasm_name)
-        wn_call.wtype = method.wtype
-        wn_call
+      if k = wnode.find_class_or_module(class_path)
+        method = wnode.find_method(k, method_name, method_type)
+        if k.wtype.native? && ALL_OPS_MAP.has_key?(method_name)
+          # An Rlang method exist for this class but methods corresponding to 
+          # Webassembly native operators applied to native Webassembly types
+          # (I32, I64, F32, F64) **cannot** be overriden by instance methods
+          # in Rlang code
+          if method
+            logger.warn "Rlang #{class_path}::#{method_name} method ignored. Native operator has precedence"
+          end
+          logger.debug "Apply native operator #{method_name} to native wtype  #{class_path}"
+          wn_call = self.native_operator(wnode, method_name, WType.new(class_path))
+        elsif !k.wtype.native? && ALL_OPS_MAP.has_key?(method_name) && method.nil?
+          # Similarly if the Class is not a native type (a regular class)
+          # and the Class doesn't provide its own method implementation of the native
+          # operator then apply the native operands
+          logger.debug "Apply native operator #{method_name} to class found : #{class_path}"
+          wn_call = self.native_operator(wnode, method_name, WType.new(class_path))
+        elsif method
+          logger.debug "Found method #{method.name} in class #{method.klass.name}"
+          (wn_call = WNode.new(:insn, wnode)).c(:call, func_name: method.wasm_name)
+          wn_call.wtype = method.wtype
+          wn_call
+        else
+          raise "Unknown method '#{method_name}' in class #{class_path}"
+        end
       elsif ALL_OPS_MAP.has_key? method_name
-        # it's a native Wasm operator
+        # It is a native Wasm operator
+        logger.debug "Native operator found : #{class_path}::#{method_name}"
         wn_call = self.native_operator(wnode, method_name, WType.new(class_path))
       else
         raise "Unknown method '#{method_name}' in class #{class_path}"
@@ -838,8 +976,8 @@ module Rlang::Parser
     end
 
     def while(wnode)
-      (wnb = WNode.new(:insn, wnode)).c(:block) 
-      (wnl = WNode.new(:insn, wnb)).c(:loop) 
+      (wnb = WNode.new(:insn, wnode)).c(:block, label: wnb.set_label) 
+      (wnl = WNode.new(:insn, wnb)).c(:loop, label: wnl.set_label) 
       (wnbi = WNode.new(:insn, wnl)).c(:br_if, label: wnb.label)
       return wnb,wnbi,wnl
     end
@@ -849,7 +987,7 @@ module Rlang::Parser
     # negate the original while condition
     def while_cond(wnode, wnode_cond_exp)
       wn_eqz = WNode.new(:insn, wnode)
-      wn_eqz.c(:eqz, wtype: wnode_cond_exp.wtype)
+      wn_eqz.c(:eqz, wasm_type: wnode_cond_exp.wasm_type)
       wnode_cond_exp.reparent_to(wn_eqz)
       wn_eqz
     end

data/lib/rlang/parser/wnode.rb

@@ -52,14 +52,14 @@ module Rlang::Parser
       br_if: 'br_if %{label}',
       br: 'br %{label}',
       inline: '%{code}',
-      attr_getter: %q{func %{func_name} (param $_self_ i32) (result %{wtype})
-  (%{wtype}.load offset=%{offset} (local.get $_self_))},
-      attr_setter: %q{func %{func_name} (param $_self_ i32) (param %{attr_name} %{wtype}) (result %{wtype})
+      attr_getter: %q{func %{func_name} (param $_self_ i32) (result %{wasm_type})
+  (%{wasm_type}.load offset=%{offset} (local.get $_self_))},
+      attr_setter: %q{func %{func_name} (param $_self_ i32) (param %{attr_name} %{wasm_type}) (result %{wasm_type})
   (local.get %{attr_name})
-  (%{wtype}.store offset=%{offset} (local.get $_self_) (local.get %{attr_name}))},
-      class_size: %q{func %{func_name} (result %{wtype})
-  (%{wtype}.const %{size})},
-      comment: ';; %{comment}',
+  (%{wasm_type}.store offset=%{offset} (local.get $_self_) (local.get %{attr_name}))},
+      class_size: %q{func %{func_name} (result %{wasm_type})
+  (%{wasm_type}.const %{size})},
+      comment: ';; %{text}',
       memory: 'memory $0 %{min} %{max}',
       module: 'module %{module}'
     }
@@ -126,17 +126,37 @@ module Rlang::Parser
     def c(template, wargs = {})
       raise "Error: unknown WASM code template (#{template})" unless T.has_key? template
       raise "Error: this WNode is already populated with instruction #{@template}" if @template
-      if [:loop, :block].include? template
-        wargs[:label] = self.set_label
-      end
+      #if [:loop, :block].include? template
+      #  wargs[:label] = self.set_label
+      #end
       @template = template
       @wargs = wargs
     end
 
     def wasm_code
-      @wargs[:wasm_type] ||= self.wasm_type
+      return '' unless T[@template]
       wargs = {}
       @wargs.each { |k, v| wargs[k] = (v.is_a?(Proc) ? v.call : v) }
+      # Because WNode#to_s generate wasm code from sometimes incomplete
+      # information, we must add the wasm_type key if needed by the template
+      if T[@template].index("%{wasm_type}")
+        puts "*** adding wasm_type to #{T[@template]}" unless wargs.has_key? :wasm_type
+        wargs[:wasm_type] ||= self.wasm_type
+      end
+
+      # debug code to activate if you get 
+      # a Ruby warning on too many or too few arguments
+      # wargs.each do |k, v|
+      #  if T[@template].index("%{#{k.to_s}}").nil? 
+      #    puts "**** Error wargs missing keys in wargs : template: #{@template} / wargs: #{wargs.inspect}"
+      #  end
+      # end
+      #T[@template].scan(/%{([^}]+)}/).flatten.each do |k|
+      #  unless wargs.has_key? k.to_sym
+      #    puts "**** Error wargs missing keys in template: template: #{@template} / wargs: #{wargs.inspect}"
+      #  end
+      # end
+      #logger.debug "code template : #{@template} / T : #{T[@template]} / wargs : #{wargs.inspect}" if @template
       T[@template] ? T[@template] % wargs : ''
     end
 
@@ -154,8 +174,13 @@ module Rlang::Parser
       logger.debug "Setting wtype #{wtype} for wnode #{self}"
       @wtype = wtype
       @method.wtype = @wtype if self.method?
-      # update wasm_type template arg accordingly
-      @wargs[:wasm_type] = @wtype.wasm_type if @wtype
+      # update wasm_type template arg accordingly if ti is already set
+      # (this is needed in some cases - e.g. operands - where node wtype
+      # is known once the wtypes of the children nodes are known )
+      if @wtype && @wargs.has_key?(:wasm_type)
+        logger.debug "Updating @wargs[:wasm_type] from '#{@wargs[:wasm_type]}' to '#{@wtype.wasm_type}'"
+        @wargs[:wasm_type] = @wtype.wasm_type
+      end
       logger.debug "type #{self.type} wargs #{self.wargs} wtype #{@wtype}"
       @wtype
     end
@@ -715,7 +740,9 @@ module Rlang::Parser
       logger.debug "children: #{self} / #{children.map(&:head)}" if self.link
 
       case @type
-      # Section nodes  
+      # Section nodes
+      when :comment
+        "\n%s%s" % [indent, self.wasm_code]
       when :imports
         "\n%s;;============= %s SECTION ===============\n" % [indent, @type.to_s.upcase] +
         children.map { |wn| wn.transpile(depth) }.join('')