rlang 0.4.1 → 0.6.0

data/lib/rlang/parser.rb

@@ -13,6 +13,7 @@
 require 'parser/current'
 require 'pathname'
 require_relative '../utils/log'
+require_relative '../utils/exceptions'
 require_relative './parser/wtype'
 require_relative './parser/wtree'
 require_relative './parser/wnode'
@@ -29,23 +30,19 @@ module Rlang::Parser
 
     include Log
 
-    ARITHMETIC_OPS = [:+, :-, :*, :/, :%, :&, :|, :^, :>>, :<<]
-    RELATIONAL_OPS = [:==, :!=, :>, :<, :>=, :<=, :'>s', :'<s', :'>=s', :'>=s']
-    UNARY_OPS = [:'!']
-
-    # Type cast order in decreading order of precedence
-    TYPE_CAST_PRECEDENCE = [Type::F64, Type::F32, Type::I64, Type::I32]
-
     # WARNING!! THIS IS A **VERY** NASTY HACK PRETENDING
     # THAT THIS int VALUE means NIL. It's totally unsafe 
     # of course as an expression could end up evaluating
     # to this value and not be nil at all. But I'm using
     # it for now in the xxxx_with_result_type variants of
     # some parsing methods (if, while,...)
+    # NOTE: those variants with result type are **NOT** the
+    # ones used by Rlang right now
     NIL = 999999999
 
-    # export toggle for method declaration
-    @@export = false
+    # export and import toggle for method declaration
+    @@export, @@export_name = false, nil
+    @@import, @@import_module_name, @@import_function_name = false, nil, nil
 
 
     attr_accessor :wgenerator, :source, :config
@@ -81,7 +78,7 @@ module Rlang::Parser
     # Note : this method can be called recursively
     # through require statements
     def parse_file(file)
-      raise "parse_file only acccepts absolute path (got #{file})" \
+      rlse node, "parse_file only acccepts absolute path (got #{file})" \
         unless Pathname.new(file).absolute? || file.nil?
       # Already parsed. Ignore.
       if self.config[:LOADED_FEATURES].include? file
@@ -107,7 +104,14 @@ module Rlang::Parser
     end
 
     def parse(source, wnode=nil)
-      ast = ::Parser::CurrentRuby.parse(source)
+      if config[:comments]
+        ast, comments = ::Parser::CurrentRuby.parse_with_comments(source)
+        @associated_comments = ::Parser::Source::Comment.associate(ast, comments)
+      else
+        ast = ::Parser::CurrentRuby.parse(source)
+        @associated_comments = {}
+      end
+
       parse_node(ast, wnode || @wgenerator.root) if ast
     end
 
@@ -118,8 +122,16 @@ module Rlang::Parser
     # - keep_eval: whether to keep the value of the evaluated
     #   WAT expression on stock or not
     def parse_node(node, wnode, keep_eval=true)
+      rlse node, "wnode type is incorrect (got #{wnode})" unless wnode.is_a?(WNode) || wnode.nil?
       logger.debug "\n---------------------->>\n" + 
-        "Parsing node: #{node}, wnode: #{wnode}, keep_eval: #{keep_eval}"
+        "Parsing node: #{node}, wnode: #{wnode.head}, keep_eval: #{keep_eval}"
+      # Nothing to parse
+      return if node.nil?
+
+      # check if there is a comment
+      if config[:comments] && (comments = @associated_comments[node])
+        @wgenerator.comments(wnode, comments)
+      end
 
       case node.type
       when :self
@@ -128,6 +140,9 @@ module Rlang::Parser
       when :class
         wn = parse_class(node, wnode)
 
+      when :module
+        wn = parse_module(node, wnode)
+
       when :defs
         wn = parse_defs(node, wnode, keep_eval)
 
@@ -171,11 +186,11 @@ module Rlang::Parser
         wn = parse_int(node, wnode, keep_eval)
       
       when :float
-        raise "float instructions not supported"
+        rlse node, "float instructions not supported"
         #parse_float(node, wnode, keep_eval)
 
       when :nil
-        raise "nil not supported"
+        rlse node, "nil not supported"
 
       when :const
         wn = parse_const(node, wnode, keep_eval)
@@ -216,11 +231,15 @@ module Rlang::Parser
       when :str
         wn = parse_string(node, wnode, keep_eval)
 
+      when :array
+        wn = parse_array(node, wnode, keep_eval)
+
       else
-        raise "Unknown node type: #{node.type} => #{node}"
+        rlse node, "Unknown node type: #{node.type} => #{node}"
       end
+      rlse node, "wnode type is incorrect (got #{wn}) at node #{node}" unless wn.is_a?(WNode) || wn.nil?
       logger.debug "\n----------------------<<\n" + 
-        "End parsing node: #{node}, parent wnode: #{wnode}, keep_eval: #{keep_eval}\n generated wnode #{wn}" +
+        "End parsing node: #{node}, parent wnode: #{wnode&.head}, keep_eval: #{keep_eval}\n generated wnode #{wn&.head}" +
         "\n----------------------<<\n"
       wn
     end
@@ -240,7 +259,7 @@ module Rlang::Parser
         end
         logger.debug "node idx: #{idx}/#{child_count-1}, wnode type: #{wnode.type}, keep_eval: #{keep_eval}, local_keep_eval: #{local_keep_eval}"
         wn = parse_node(n, wnode, local_keep_eval)
-        logger.debug "in begin: parsing node #{n} gives wnode #{wn}"
+        logger.debug "in begin: parsing node #{n} gives wnode #{wn&.head}"
       end
       return wn # return last wnode
     end
@@ -250,19 +269,31 @@ module Rlang::Parser
     #  ... body ...
     # end
     # -----
-    # [s(:const, nil, :Stack), nil, s(:begin ... body.... )]
+    # (class
+    #   (const nil :Stack) nil (begin ....)))
     #
+    # class Stack < Array
+    #  ... body ...
+    # end
+    # -----
+    # (class
+    #   (const nil :Stack) (const nil :Array) (begin ....)))
     def parse_class(node, wnode)
-      const_node = node.children.first
-      body_node = node.children.last
-      raise "expecting a constant for class name (got #{const_node})" \
-        unless const_node.type == :const
+      class_const_node, super_class_const_node, body_node = *node.children
+      rlse node, "expecting a constant for class name (got #{const_node})" \
+        unless class_const_node.type == :const
 
       # create the class wnode
-      wn_class = @wgenerator.klass(wnode, const_node.children.last)
+      class_path = _build_const_path(class_const_node)
+      super_class_path = _build_const_path(super_class_const_node)
+      wn_class = @wgenerator.klass(wnode, class_path, super_class_path)
+
+      # If body node is nil then this must be interpreted as
+      # a class declaration (no implementation yet)
+      return wn_class unless body_node
 
       # Parse the body of the class
-      parse_node(body_node, wn_class) if body_node
+      parse_node(body_node, wn_class)
 
       # We finished parsing the class body so
       # 1) postprocess instance variables
@@ -275,6 +306,29 @@ module Rlang::Parser
       wn_class
     end
 
+    # Example:
+    # module Kernel
+    #  ... body ...
+    # end
+    # -----
+    # (module
+    #   (const nil :Kernel) nil (begin ....)))
+    #
+    def parse_module(node, wnode)
+      const_node = node.children.first
+      body_node = node.children.last
+      rlse node, "expecting a constant for module name (got #{const_node})" \
+        unless const_node.type == :const
+      
+      module_path = _build_const_path(const_node)
+
+      # create the module wnode
+      wn_module = @wgenerator.module(wnode, module_path)
+      # Parse the body of the module
+      parse_node(body_node, wn_module) if body_node
+      wn_module
+    end
+
     # TODO: the code for op_asgn is quite murky but I thought
     # we would use quite often so I implemented it. We could do
     # without it though..
@@ -325,7 +379,7 @@ module Rlang::Parser
     #
     def parse_op_asgn(node, wnode, keep_eval)
       op_asgn_type = node.children.first.type
-      logger.debug "op_asgn on #{op_asgn_type} / wnode: #{wnode}, keep_eval: #{keep_eval}"
+      logger.debug "op_asgn on #{op_asgn_type} / wnode: #{wnode.head}, keep_eval: #{keep_eval}"
 
       case op_asgn_type
       # Global variable case
@@ -338,10 +392,11 @@ module Rlang::Parser
         # wnode as a child of wnode
         wn_var_set = parse_node(var_asgn_node, wnode, keep_eval)
         gvar = Global.find(var_name)
-        raise "Unknown global variable #{var_name}" unless gvar
+        # \nline #{node.location.line}: #{node.location.expression.range.source}
+        rlse node, "Unknown global variable #{var_name}" unless gvar
 
         # Create the operator node (infer operator type from variable)
-        wn_op = @wgenerator.send_method(wn_var_set, op, gvar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, gvar.wtype.class_path, op, :instance)
         # Create the var getter node as a child of operator node
         wn_var_get = @wgenerator.gvar(wn_op, gvar)
 
@@ -355,10 +410,10 @@ module Rlang::Parser
         # wnode as a child of wnode
         wn_var_set = parse_node(var_asgn_node, wnode, keep_eval)
         cvar = wnode.find_cvar(var_name)
-        raise "Unknown class variable #{var_name}" unless cvar
+        rlse node, "Unknown class variable #{var_name}" unless cvar
 
         # Create the operator node (infer operator type from variable)
-        wn_op = @wgenerator.send_method(wn_var_set, op, cvar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, cvar.wtype.class_path, op, :instance)
         # Create the var getter node as a child of operator node
         wn_var_get = @wgenerator.cvar(wn_op, cvar)
       
@@ -372,10 +427,10 @@ module Rlang::Parser
         # wnode as a child of wnode
         wn_var_set = parse_node(var_asgn_node, wnode, keep_eval)
         lvar = wnode.find_lvar(var_name) || wnode.find_marg(var_name)
-        raise "Unknown local variable #{var_name}" unless lvar
+        rlse node, "Unknown local variable #{var_name}" unless lvar
 
         # Create the operator node (infer operator type from variable)
-        wn_op = @wgenerator.send_method(wn_var_set, op, lvar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, lvar.wtype.class_path, op, :instance)
         # Create the var getter node as a child of operator node
         wn_var_get = @wgenerator.lvar(wn_op, lvar)
 
@@ -386,14 +441,14 @@ module Rlang::Parser
       # s(:op_asgn,
       #    s(:ivasgn, :@stack_ptr), :-, s(:lvar, :nbytes))
       when :ivasgn
-        raise "Instance variable can only be accessed in instance method scope" \
+        rlse node, "Instance variable can only be accessed in instance method scope" \
           unless wnode.in_instance_method_scope?
         var_asgn_node, operator, exp_node = *node.children
         var_name = var_asgn_node.children.last
 
         # To op_asgn to work, ivar must already be declared
         ivar = wnode.find_ivar(var_name)
-        raise "Unknown instance variable #{var_name}" unless ivar
+        rlse node, "Unknown instance variable #{var_name}" unless ivar
 
         # Create the top level variable setter node
         wn_var_set = @wgenerator.ivasgn(wnode, ivar)
@@ -401,7 +456,7 @@ module Rlang::Parser
         # Second argument of the setter is the operator wnode
         # Create it with wtype of receiver by default. We may
         # change that wtype with the operands call later on
-        wn_op = @wgenerator.send_method(wn_var_set, operator, ivar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, ivar.wtype.class_path, operator, :instance)
 
         # now create the getter node as a child of the
         # operator
@@ -431,7 +486,7 @@ module Rlang::Parser
         wn_recv = parse_node(recv_node, wnode, true)
 
         # Create the top level setter call
-        wn_var_set = @wgenerator.call(wnode, wn_recv.wtype.name, "#{method_name}=", :instance)
+        wn_var_set = @wgenerator.send_method(wnode, wn_recv.wtype.class_path, :"#{method_name}=", :instance)
 
         # First argument of the setter must be the recv_node
         wn_recv.reparent_to(wn_var_set)
@@ -439,7 +494,7 @@ module Rlang::Parser
         # Second argument of the setter is the operator wnode
         # Create it with wtype of receiver by default. We may
         # change that wtype with the operands call later on
-        wn_op = @wgenerator.send_method(wn_var_set, op, wn_recv.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, wn_recv.wtype.class_path, op, :instance)
 
         # Parsing the send node will create the getter wnode
         # this is the first argument of the operator wnode,
@@ -452,10 +507,10 @@ module Rlang::Parser
         # must be ignored then drop it
         unless (keep_eval || wn_var_set.wtype.blank?)
           @wgenerator.drop(wnode)
-          #@wgenerator.call(wnode, wn_recv.wtype.name, "#{method_name}", :instance)
+          #@wgenerator.send_method(wnode, wn_recv.wtype.class_path, "#{method_name}", :instance)
         end
       else
-        raise "op_asgn not supported for #{node.children.first}"
+        rlse node, "op_asgn not supported for #{node.children.first}"
       end
 
       # Finally, parse the expression node and make it
@@ -475,20 +530,27 @@ module Rlang::Parser
     # (casgn nil :MYCONST
     #   (int 2000))
     def parse_casgn(node, wnode, keep_eval)
-      class_name_node, constant_name, exp_node = *node.children
-#      raise "dynamic constant assignment" unless wnode.in_class_scope?
-      unless class_name_node.nil?
-        raise "constant assignment with class path not supported (got #{class_name_node})"
-      end
+      class_path_node, constant_name, exp_node = *node.children
+      const_path = _build_const_path(class_path_node) << constant_name
+
+      # rlse node, "dynamic constant assignment" unless wnode.in_class_scope?
+      # unless class_path_node.nil?
+      #  rlse node, "constant assignment with class path not supported (got #{class_name_node})"
+      # end
+      
+      # find the scope class
+      k = wnode.find_current_class_or_module()
 
       if wnode.in_method_scope?
         # if exp_node is nil then this is the form of 
         # :casgn that comes from op_asgn
+        const = wnode.find_const(const_path)
         if exp_node        
           if const.nil?
             # first constant occurence
             # type cast the constant to the wtype of the expression
-            const = wnode.create_const(constant_name, nil, 0, WType::DEFAULT)
+            const = wnode.create_const(const_path, nil, 0, WType::DEFAULT)
+            k.consts << const
             wn_casgn = @wgenerator.casgn(wnode, const)
             wn_exp = parse_node(exp_node, wn_casgn)
             const.wtype = wn_exp.wtype
@@ -498,10 +560,10 @@ module Rlang::Parser
             wn_casgn = @wgenerator.casgn(wnode, const)
             wn_exp = parse_node(exp_node, wn_casgn)
             @wgenerator.cast(wn_exp, const.wtype, false)
-            logger.warning "Already initialized constant #{const.name}"
+            logger.warn "Already initialized constant #{const.name}"
           end
         else
-          raise "Constant #{const_name} not declared before" unless const
+          rlse node, "Constant #{const_path} not declared before" unless const
           wn_casgn = @wgenerator.casgn(wnode, const)
         end
         # to mimic Ruby push the constant value on stack if needed
@@ -516,13 +578,20 @@ module Rlang::Parser
         # executing this code. Just statically initiliazing the 
         # const with the value
         wn_exp = parse_node(exp_node, wnode)
-        raise "Constant initializer initializer can only be an int or a constant/class (got #{wn_exp}" \
+        rlse node, "Constant initializer can only be an int or a constant/class (got #{wn_exp}" \
           unless wn_exp.const?
-        const = wnode.create_const(constant_name, nil, wn_exp.wargs[:value], wn_exp.wtype)
+        if (const = wnode.find_const(const_path))
+          logger.warn "already initialized constant #{const.path}"
+          const.value = wn_exp.wargs[:value]
+        else
+          const = wnode.create_const(const_path, wn_exp.wargs[:value], wn_exp.wtype)
+          k.consts << const
+        end
         wnode.remove_child(wn_exp)
-        logger.debug "Constant #{constant_name} initialized with value #{const.value} and wtype #{const.wtype}"
+        logger.debug "Constant #{const_path} initialized with value #{const.value} and wtype #{const.wtype}"
+        return nil
       else
-        raise "Constant can only be defined in method or class scope"
+        rlse node, "Constant can only be defined in method or class scope"
       end
     end
 
@@ -562,7 +631,7 @@ module Rlang::Parser
             @wgenerator.cast(wn_exp, gvar.wtype, false)
           end
         else
-          raise "Global variable #{cv_name} not declared before" unless gvar
+          rlse node, "Global variable #{gv_name} not declared before" unless gvar
           wn_gvasgn = @wgenerator.gvasgn(wnode, gvar)
         end
         # to mimic Ruby push the variable value on stack if needed
@@ -571,7 +640,7 @@ module Rlang::Parser
       elsif true #wnode.in_class_scope?
         # If we are at root or in class scope
         # then it is a global variable initialization
-        raise "Global op_asgn can only happen in method scope" unless exp_node
+        rlse node, "Global op_asgn can only happen in method scope" unless exp_node
         # In the class or root scope 
         # it can only be a Global var **declaration**
         # In this case the expression has to reduce
@@ -581,7 +650,7 @@ module Rlang::Parser
         # Then remove the generated wnode because it is not for
         # execution. It is just to get the init value
         wn_exp = parse_node(exp_node, wnode)
-        raise "Global initializer can only be a int or a constant/class (got #{wn_exp})" \
+        rlse node, "Global initializer can only be a int or a constant/class (got #{wn_exp})" \
           unless wn_exp.const?
         wnode.remove_child(wn_exp)
         if gvar
@@ -591,8 +660,9 @@ module Rlang::Parser
         end
         # Do not export global for now
         #gvar.export! if self.config[:export_all]
+        return nil
       else
-        raise "Global can only be defined in method or class scope"
+        rlse node, "Global can only be defined in method or class scope"
       end
     end
 
@@ -604,7 +674,7 @@ module Rlang::Parser
     def parse_ivasgn(node, wnode, keep_eval)
       iv_name, exp_node = *node.children
 
-      raise "Instance variable #{iv_name} can only used in instance method scope" \
+      rlse node,  "Instance variable #{iv_name} can only used in instance method scope" \
         unless wnode.in_instance_method_scope? 
 
       if (ivar = wnode.find_ivar(iv_name))
@@ -662,7 +732,7 @@ module Rlang::Parser
             @wgenerator.cast(wn_exp, cvar.wtype, false)
           end
         else
-          raise "Class variable #{cv_name} not declared before" unless cvar
+          rlse node,  "Class variable #{cv_name} not declared before" unless cvar
           wn_cvasgn = @wgenerator.cvasgn(wnode, cvar)
         end
         # to mimic Ruby push the variable value on stack if needed
@@ -672,20 +742,22 @@ module Rlang::Parser
       elsif wnode.in_class_scope?
         # If we are in class scope
         # then it is a class variable initialization
-        raise "Class variable #{cv_name} already declared" if cvar
-        raise "Class variable op_asgn can only happen in method scope" unless exp_node
+        rlse node, "Class variable #{cv_name} already declared" if cvar
+        rlse node, "Class variable op_asgn can only happen in method scope" unless exp_node
         # Parse the expression node to see if it's a ixx.const
         # in the end but get rid of it then because we are not
         # executing this code. Just statically initiliazing the 
         # cvar with the value
         wn_exp = parse_node(exp_node, wnode)
-        raise "Class variable initializer can only be an int or a constant/class (got #{wn_exp}" \
+        rlse node,  "Class variable initializer can only be an int or a constant/class (got #{wn_exp}" \
           unless wn_exp.const?
         cvar = wnode.create_cvar(cv_name, wn_exp.wargs[:value], wn_exp.wtype)
         wnode.remove_child(wn_exp)
         logger.debug "Class variable #{cv_name} initialized with value #{cvar.value} and wtype #{cvar.wtype}"
+        return
+        
       else
-        raise "Class variable can only be defined in method or class scope"
+        rlse node, "Class variable can only be defined in method or class scope"
       end
     end
 
@@ -723,7 +795,7 @@ module Rlang::Parser
           @wgenerator.cast(wn_exp, lvar.wtype, false)
         end
       else
-        raise "Local variable #{cv_name} not declared before" unless lvar
+        rlse node, "Local variable #{cv_name} not declared before" unless lvar
         wn_lvasgn = @wgenerator.lvasgn(wnode, lvar)
       end
       # to mimic Ruby push the variable value on stack if needed
@@ -738,7 +810,7 @@ module Rlang::Parser
     def parse_gvar(node, wnode, keep_eval)
       gv_name, = *node.children
       gvar = Global.find(gv_name)
-      raise "Unknown Global variable #{gv_name}" unless gvar
+      rlse node, "Unknown Global variable #{gv_name}" unless gvar
       wn_gvar = @wgenerator.gvar(wnode, gvar)
       # Drop last evaluated result if asked to
       @wgenerator.drop(wnode) unless keep_eval
@@ -750,13 +822,13 @@ module Rlang::Parser
     # ---
     # ... s(:ivar, :@stack_ptr)
     def parse_ivar(node, wnode, keep_eval)
-      raise "Instance variable can only be accessed in instance method scope" \
+      rlse node, "Instance variable can only be accessed in instance method scope" \
         unless wnode.in_instance_method_scope?
       iv_name, = *node.children
       if (ivar = wnode.find_ivar(iv_name))
         wn_ivar = @wgenerator.ivar(wnode, ivar)
       else
-        raise "unknown instance variable #{ivar_name}"
+        rlse node, "unknown instance variable #{ivar_name}"
       end
       # Drop last evaluated result if asked to
       @wgenerator.drop(wnode) unless keep_eval
@@ -768,13 +840,13 @@ module Rlang::Parser
     # ---
     # ... s(:cvar, :@@stack_ptr)
     def parse_cvar(node, wnode, keep_eval)
-      raise "Class variable can only be accessed in method scope" \
+      rlse node, "Class variable can only be accessed in method scope" \
         unless wnode.in_method_scope?
       cv_name, = *node.children
       if (cvar = wnode.find_cvar(cv_name))
         wn_cvar = @wgenerator.cvar(wnode, cvar)
       else
-        raise "unknown class variable #{cv_name}"
+        rlse node, "unknown class variable #{cv_name}"
       end
       # Drop last evaluated result if asked to
       @wgenerator.drop(wnode) unless keep_eval
@@ -786,15 +858,14 @@ module Rlang::Parser
     # ---
     # ... s(:lvar, :nbytes)
     def parse_lvar(node, wnode, keep_eval)
-      logger.debug("node: #{node}, wnode: #{wnode}, keep_eval: #{keep_eval}")
+      logger.debug("node: #{node}, wnode: #{wnode.head}, keep_eval: #{keep_eval}")
 
       lv_name, = *node.children
       if (lvar = wnode.find_lvar(lv_name) || wnode.find_marg(lv_name))
         wn_lvar = @wgenerator.lvar(wnode, lvar)
       else
-        raise "unknown local variable #{lv_name}"
+        rlse node, "unknown local variable #{lv_name}"
       end
-      logger.debug "wnode: #{wnode}"
       # Drop last evaluated result if asked to 
       @wgenerator.drop(wnode) unless keep_eval
       return wn_lvar
@@ -802,7 +873,7 @@ module Rlang::Parser
 
     def parse_int(node, wnode, keep_eval)
       value, = *node.children
-      logger.debug "int: #{value} for parent wnode #{wnode} keep_eval:#{keep_eval}"
+      logger.debug "int: #{value} for parent wnode #{wnode.head} keep_eval:#{keep_eval}"
       wn_int = @wgenerator.int(wnode, WType::DEFAULT, value)
       # Drop last evaluated result if asked to
       @wgenerator.drop(wnode) unless keep_eval
@@ -829,12 +900,11 @@ module Rlang::Parser
       return wn_false
     end
 
-    # Whenever a string literal is used in Rlang
-    # in whatever scope (root, class or method scope)
-    # the string literal must be allocated
-    # statically.
-    # Then if the literal is used in a method scope
-    # we must instantiate a dynamic string object
+    # When a string literal initializer is used
+    # in root or class scope,  the string literal is
+    # allocated statically.
+    # If the initializer is used in a method scope
+    # we instantiate a dynamic string object
     # and copy the initial static value in it
     def parse_string(node, wnode, keep_eval)
       string = node.children.last
@@ -852,32 +922,57 @@ module Rlang::Parser
       return wn_string
     end
 
+    # Example
+    # [1, -2, 5]
+    # -------
+    # (array
+    #   (int 1)
+    #   (int -2)
+    #   (int 5)
+    # )
+    #
+    # When an array literal initializer is used
+    # in root or class scope, the array literal is
+    # allocated statically.
+    # If the initializer is used in a method scope
+    # we instantiate a dynamic string object
+    # and copy the initial static value in it
+    #
+    def parse_array(node, wnode, keep_eval)
+      # check that all array elements are of type int 
+      # this is the only initializer type we support for
+      # now. Collect int values.
+      array = node.children.collect do |wn|
+        rlse node,  "Array initializer can only be of type int (got #{wn}" unless wn.type == :int
+        wn.children.last
+      end
+
+      if wnode.in_method_scope?
+        # allocate array dynamically
+        wn_array = @wgenerator.array_dynamic_new(wnode, array)
+      else
+        # allocate array statically
+        wn_array = @wgenerator.array_static_new(wnode, array)
+      end
+      # Drop last evaluated result if asked to
+      @wgenerator.drop(wnode) unless keep_eval
+
+      logger.debug "wn_array:#{wn_array} wtype:#{wn_array.wtype} keep_eval:#{keep_eval}"
+      return wn_array
+    end
+
     # Example
     # TestA::C::MYCONST
     # -------
     # (const (const (const nil :TESTA) :C) :MYCONST))
     def parse_const(node, wnode, keep_eval)
-      # Build constant path from embeddec const sexp
-      const_path = []
-      n = node
-      while n
-        logger.debug "adding #{n.children.last} to constant path"
-        const_path.unshift(n.children.last)
-        n = n.children.first
-      end
+      # Build constant path from embedded const sexp
+      const_path = _build_const_path(node)
       full_const_name = const_path.join('::')
-      if const_path.size == 1
-        class_name = wnode.class_name
-        const_name = const_path.first
-      elsif const_path.size == 2
-        class_name, const_name = *const_path
-      else
-        raise "only constant of the form X or X::Y is supported (got #{full_const_name}"
-      end
 
       # See if constant exists. It should at this point
-      unless (const = wnode.find_const(const_name, class_name))
-        raise "unknown constant #{full_const_name}"
+      unless (const = wnode.find_const(const_path))
+        rlse node, "unknown constant #{full_const_name}"
       end
       wn_const = @wgenerator.const(wnode, const)
 
@@ -890,7 +985,7 @@ module Rlang::Parser
     def parse_args(node, wnode)
       # collect method arguments
       node.children.each do |arg_node|
-        raise "only regular method argument is supported (got #{arg_node.type})" if arg_node.type != :arg
+        rlse node, "only regular method argument is supported (got #{arg_node.type})" if arg_node.type != :arg
         # keep track of method arguments. Do not generate wasm code yet
         # as 'arg' directives may later affect argument types (see parse_send)
         wnode.create_marg(arg_node.children.last)
@@ -908,23 +1003,33 @@ module Rlang::Parser
     #   ...
     # end
     def parse_defs(node, wnode, keep_eval)
-      logger.debug "node: #{node}\nwnode: #{wnode}"
-      recv_node, method_name, arg_nodes, body_node = *node.children
-      raise "only class method is supported. Wrong receiver at #{recv_node.loc.expression}" if recv_node.type != :self
+      logger.debug "node: #{node}\nwnode: #{wnode.head}"
+      if node.type == :def
+        # we are being called from parse_def to define
+        # a class method in addition to an instance method
+        method_name, arg_nodes, body_node = *node.children
+        recv_node = nil
+      else
+        recv_node, method_name, arg_nodes, body_node = *node.children
+        rlse node, "only class method is supported. Wrong receiver at #{recv_node.loc.expression}" \
+          if recv_node.type != :self
+      end
+      logger.debug "Defining class method: #{method_name}"
       logger.debug "recv_node: #{recv_node}\nmethod_name: #{method_name}"
 
       # create corresponding func node
-      method = wnode.find_or_create_method(method_name, nil, nil, :class)
-      method.export! if (@@export || self.config[:export_all])
-      logger.debug "Method object : #{method}"
-      wn_method = @wgenerator.class_method(wnode, method)
+      wn_method = @wgenerator.def_method(wnode, method_name, :class)
+      if @@import
+        wn_import = @wgenerator.import_method(wn_method, @@import_module_name, @@import_function_name)
+      end
+
       # collect method arguments
       parse_args(arg_nodes, wn_method)
       # Look for any result directive and parse it so 
       # that we know what the return type is in advance
       # If :nil for instance then it may change the way
       # we generate code in the body of the method
-      if (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
+      if body_node && (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
         logger.debug "result directive found: #{result_node}"
         parse_node(result_node, wn_method, keep_eval)
       end
@@ -941,9 +1046,12 @@ module Rlang::Parser
       @wgenerator.locals(wn_method)
       @wgenerator.result(wn_method)
       @wgenerator.params(wn_method)
+      @wgenerator.export_method(wn_method, @@export_name) if (@@export || self.config[:export_all])
       logger.debug "Full method wnode: #{wn_method}"
-      # reset export toggle
-      @@export = false
+
+      # reset method toggles
+      self.class._reset_toggles
+
       return wn_method
     end
 
@@ -957,23 +1065,24 @@ module Rlang::Parser
     #   ...
     # end
     def parse_def(node, wnode, keep_eval)
-      logger.debug "node: #{node}\nwnode: #{wnode}"
+      logger.debug "node: #{node}\nwnode: #{wnode.head}"
       method_name, arg_nodes, body_node = *node.children
-      logger.debug "method_name: #{method_name}"
+      logger.debug "Defining instance method: #{method_name}"
 
       # create corresponding func node
-      method = wnode.find_or_create_method(method_name, nil, nil, :instance)
-      method.export! if (@@export || self.config[:export_all])
-      logger.debug "Method object : #{method}"
-      wn_method = @wgenerator.instance_method(wnode, method)
+      wn_method = @wgenerator.def_method(wnode, method_name, :instance)
+      if @@import
+        wn_import = @wgenerator.import_method(wn_method, @@import_module_name, @@import_function_name)
+      end
 
       # collect method arguments
-      parse_args(arg_nodes, wn_method)
+      wn_args = parse_args(arg_nodes, wn_method)
+
       # Look for any result directive and parse it so 
       # that we know what the return type is in advance
       # If :nil for instance then it may change the way
       # we generate code in the body of the method
-      if (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
+      if body_node && (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
         logger.debug "result directive found: #{result_node}"
         parse_node(result_node, wn_method, keep_eval)
       end
@@ -990,9 +1099,18 @@ module Rlang::Parser
       @wgenerator.locals(wn_method)
       @wgenerator.result(wn_method)
       @wgenerator.params(wn_method)
+      @wgenerator.export_method(wn_method, @@export_name) if (@@export || self.config[:export_all])
       logger.debug "Full method wnode: #{wn_method}"
-      # reset export toggle
-      @@export = false
+
+      # reset method toggles
+      self.class._reset_toggles
+
+      # if we are in a module then also define
+      # the class method because we don't know
+      # whether the module will be included or extended
+      if wnode.in_module_scope?
+        self.parse_defs(node, wnode, keep_eval)
+      end
       return wn_method
     end
 
@@ -1014,10 +1132,12 @@ module Rlang::Parser
         when /^\./
           # If file starts with . then look for file in pwd
           load_path = [Dir.pwd]
+=begin
         when /^rlang/
           # If it starts with rlang then look for it in the 
           # installed rlang gem in addition to load path
           load_path = self.config[:LOAD_PATH] + $LOAD_PATH
+=end
         else
           load_path = self.config[:LOAD_PATH]
           load_path = [Dir.pwd] if self.config[:LOAD_PATH].empty?
@@ -1037,7 +1157,7 @@ module Rlang::Parser
           end
         end
       end
-      raise LoadError, "no such file to load: #{full_path_file}" unless full_path_file
+      rlse node, LoadError, "no such file to load: #{file}" unless full_path_file
 
       # Now load the file 
       if File.extname(full_path_file) == '.wat'
@@ -1138,22 +1258,22 @@ module Rlang::Parser
         case method_name
         when :address=
           value_node = node.children[2]
-          raise "DAta address must be an integer" unless value_node.type == :int
+          rlse node, "DAta address must be an integer" unless value_node.type == :int
           DAta.address = value_node.children.last
         when :align
           value_node = node.children[2]
-          raise "DAta alignment argument must be an integer" unless value_node.type == :int
+          rlse node, "DAta alignment argument must be an integer" unless value_node.type == :int
           DAta.align(value_node.children.last)
         when :[]=
           if (data_label_node = node.children[2]).type == :sym
             label = data_label_node.children.last
           else
-            raise "Data label must be a symbol (got #{data_label_node}"
+            rlse node, "Data label must be a symbol (got #{data_label_node}"
           end
           arg_node = node.children[3]
           parse_data_value(label, arg_node)
         else
-          raise "Unsupported DAta method #{method_name}"
+          rlse node, "Unsupported DAta method #{method_name}"
         end
         return
       end
@@ -1166,14 +1286,15 @@ module Rlang::Parser
       # Example
       # (expression).cast_to(class_name, argument)    
       # -----
-      # s(:begin,
+      # s(:send,
       #    s(expression),
       #    :cast_to, s(sym, :Class_name))
       # the signed argument true|false is optional and 
       # it defaults to false
+      # Class_name is a symbol like :A or :"A:B" or :"A:B:C"
       if method_name == :cast_to
         class_name_node = node.children.last
-        raise "cast_to expects a symbol argument (got #{class_name_node}" unless class_name_node.type == :sym
+        rlse node, "cast_to expects a symbol argument (got #{class_name_node}" unless class_name_node.type == :sym
         tgt_wtype = WType.new(class_name_node.children.first)
         logger.debug "in cast_to: target type #{tgt_wtype}"
 
@@ -1188,26 +1309,23 @@ module Rlang::Parser
       end
 
 
-      # Type cast directives specific for native types
-      # can pass the signed argument wheres cast_to cannot
-      # this must be processed at compile time. It's not dynamic
+      # Explicit type cast directives for native types.
+      # Used at compile time
+      #
       # Example
-      # (recv).to_Ixx(true|fasle) where xx is 64 or 32
+      # (recv).to_xxxx where xxxx can be [U]I[32|64]
       # -----
-      # s(:begin,
+      # s(:send,
       #    s(expression),
-      #    :to_I64, [true|false])
-      # the signed argument true|false is optional and 
-      # it defaults to false
-      if method_name == :to_I64 || method_name == :to_I32
-        tgt_wtype = (method_name == :to_I64) ? WType.new(:I64) : WType.new(:I32)
-        if (cnt = node.children.count) == 3
-          signed = true if node.children.last.type == :true
-        elsif cnt == 2
-          signed = false
-        else
-          raise "cast directive should have 0 or 1 argument (got #{cnt - 2})"
+      #    :to_I64)
+      #
+      if [:to_UI64, :to_I64, :to_UI32, :to_I32].include? method_name
+        if (cnt = node.children.count) > 2
+          rlse node, "cast directive should have no argument (got #{cnt - 2})"
         end
+        tgt_rlang_type = method_name.to_s.scan(/to_(.+)$/).first.first
+        tgt_wtype = WType.new(tgt_rlang_type)
+        signed = tgt_wtype.signed?
         logger.debug "in cast section: child count #{cnt}, tgt_wtype #{tgt_wtype}, signed: #{signed}"
 
         # Parse the expression and cast it
@@ -1220,6 +1338,49 @@ module Rlang::Parser
         return wn_cast
       end
 
+      # addr method applied to statically allocated variables
+      # only constant and class variables returns their address 
+      # in memory
+      #
+      # Example
+      # @@argv_bu_size.addr
+      # ---
+      # (send (cvar :@@argv_buf_size) :addr)
+      #
+      if method_name == :addr
+        if recv_node.type == :const
+          # Build constant path from embedded const sexp
+          const_path = _build_const_path(recv_node)
+          full_const_name = const_path.join('::')
+
+          # See if constant exists. It should at this point
+          unless (const = wnode.find_const(const_path))
+            rlse node, "unknown constant #{full_const_name}"
+          end
+          wn_const_addr = @wgenerator.const_addr(wnode, const)
+
+          # Drop last evaluated result if asked to
+          @wgenerator.drop(wnode) unless keep_eval
+          return wn_const_addr
+
+        elsif recv_node.type == :cvar
+          rlse node, "Class variable can only be accessed in method scope" \
+            unless wnode.in_method_scope?
+          cv_name = recv_node.children.first
+          if (cvar = wnode.find_cvar(cv_name))
+            wn_cvar_addr = @wgenerator.cvar_addr(wnode, cvar)
+          else
+            rlse node, "unknown class variable #{cv_name}"
+          end
+          # Drop last evaluated result if asked to
+          @wgenerator.drop(wnode) unless keep_eval
+          return wn_cvar_addr
+
+        else
+          # Do nothing. This will be treated as a regular method call
+        end
+      end
+
       # A that stage it's a method call of some sort
       # (call on class or instance)
       return parse_send_method_lookup(node, wnode, keep_eval)
@@ -1229,7 +1390,7 @@ module Rlang::Parser
     def parse_send_nil_receiver(node, wnode, keep_eval)
       recv_node = node.children[0]
       method_name = node.children[1]
-      raise "receiver should be nil here (got #{recv_node})" \
+      rlse node, "receiver should be nil here (got #{recv_node})" \
         unless recv_node.nil?
 
       if recv_node.nil? && method_name == :require
@@ -1240,10 +1401,26 @@ module Rlang::Parser
         return parse_send_require_relative(node, wnode, keep_eval)
       end
 
+      if recv_node.nil? && method_name == :include
+        return parse_send_include(node, wnode, keep_eval)
+      end
+
+      if recv_node.nil? && method_name == :prepend
+        return parse_send_prepend(node, wnode, keep_eval)
+      end
+
+      if recv_node.nil? && method_name == :extend
+        return parse_send_extend(node, wnode, keep_eval)
+      end
+
       if recv_node.nil? && method_name == :export
         return parse_send_export(node, wnode, keep_eval)
       end
 
+      if recv_node.nil? && method_name == :import
+        return parse_send_import(node, wnode, keep_eval)
+      end
+
       if recv_node.nil? && method_name == :local
         return parse_send_local(node, wnode, keep_eval)
       end
@@ -1277,10 +1454,10 @@ module Rlang::Parser
     # (send nil :require
     #   (str "test5"))
     def parse_send_require(node, wnode, keep_eval)
-      raise "require must be used at root level" \
+      rlse node, "require must be used at root level" \
         unless wnode.in_root_scope?
       file_node = node.children.last
-      raise "require only accepts a string argument (got #{file_node})" \
+      rlse node, "require only accepts a string argument (got #{file_node})" \
         unless file_node.type == :str
       parse_require(wnode, file_node.children.last)
       return
@@ -1292,20 +1469,119 @@ module Rlang::Parser
     # (send nil :require_relative
     #   (str "test5"))
     def parse_send_require_relative(node, wnode, keep_eval)
-      raise "require_relative must be used at root level" \
+      rlse node, "require_relative must be used at root level" \
         unless wnode.in_root_scope?
       file_node = node.children.last
-      raise "require only accepts a string argument (got #{file_node})" \
+      rlse node, "require only accepts a string argument (got #{file_node})" \
         unless file_node.type == :str
       parse_require_relative(wnode, file_node.children.last)
       return
     end
 
+    # Directive to include a module
+    # current file
+    # Example
+    # include Kernel
+    # ----
+    # (send nil :include
+    #   (const nil :Kernel))
+    def parse_send_include(node, wnode, keep_eval)
+      const_node = node.children.last
+      module_path = _build_const_path(const_node)
+      rlse node, "expecting a constant for include (got #{const_node})" \
+        unless const_node.type == :const
+      rlse node, "include must be used in class scope" \
+        unless wnode.in_class_scope?
+      @wgenerator.include(wnode, module_path)
+    end
+
+    # Directive to prepend a module
+    # current file
+    # Example
+    # prepend MyModule
+    # ----
+    # (send nil :prepend
+    #   (const nil :MyModule))
+    def parse_send_prepend(node, wnode, keep_eval)
+      const_node = node.children.last
+      module_path = _build_const_path(const_node)
+      rlse node, "expecting a constant for prepend (got #{const_node})" \
+        unless const_node.type == :const
+      rlse node, "prepend must be used in class scope" \
+        unless wnode.in_class_scope?
+      @wgenerator.prepend(wnode, module_path)
+    end
+
+    # Directive to extend a module
+    # current file
+    # Example
+    # extend Kernel
+    # ----
+    # (send nil :extend
+    #   (const nil :Kernel))
+    def parse_send_extend(node, wnode, keep_eval)
+      const_node = node.children.last
+      module_path = _build_const_path(const_node)
+      rlse node, "expecting a constant for extend (got #{const_node})" \
+        unless const_node.type == :const
+      rlse node, "extend must be used in class scope" \
+        unless wnode.in_class_scope?
+      @wgenerator.extend(wnode, module_path)
+    end
+
     # Directive to declare the current method
     # in the WASM exports
+    # Example
+    #
+    # export
+    # ---
+    # (send nil :export)
+    # OR
+    # export :function_name
+    # ---
+    # (send nil :export
+    #   (sym :function_name))
+    #
+    # With out an explicit function name, the export name
+    # will be automatically built from the class/method names
     def parse_send_export(node, wnode, keep_eval)
-      raise "export must be used in class scope" unless wnode.in_class_scope?
+      logger.debug "Export directive found for..."
+      rlse node, "export must be used in class scope" unless wnode.in_class_or_module_scope?
       @@export = true
+      if (function_node = node.children[2])
+        rlse node, "export function name must be a symbol (got #{function_node})" \
+          unless function_node.type == :sym  
+        @@export_name = function_node.children.last
+      end
+      logger.debug "... #{@@export_name}"
+      return
+    end
+
+    # Directive to declare the current method
+    # in the WASM imports
+    # Example
+    #
+    # import :module_name, :function_name
+    # ---
+    # (send nil :import
+    #   (sym :mod)
+    #   (sym :func))
+    #
+    def parse_send_import(node, wnode, keep_eval)
+      logger.debug "Import directive found for..."
+      rlse node, "export must be used in class scope" unless wnode.in_class_or_module_scope?
+      rlse node, "import expects 2 arguments (got #{node.children.count - 2})" \
+        unless node.children.count == 4
+      
+      module_node, function_node = node.children[2..-1]
+      rlse node, "import module name must be a symbol (got #{module_node})" \
+        unless module_node.type == :sym    
+      rlse node, "import function name must be a symbol (got #{function_node})" \
+        unless function_node.type == :sym
+      @@import = true
+      @@import_module_name   = module_node.children.last
+      @@import_function_name = function_node.children.last
+      logger.debug "... #{@@import_module_name}, #{@@import_function_name}"
       return
     end
 
@@ -1322,13 +1598,13 @@ module Rlang::Parser
     #       s(:sym, :I64))
     # ))
     def parse_send_local(node, wnode, keep_eval)
-      raise "local declaration can only be used in methods" \
+      rlse node, "local declaration can only be used in methods" \
         unless wnode.in_method_scope?
       hash_node = node.children.last
       local_types = parse_type_args(hash_node, :local)
       local_types.each do |name, wtype|
         lvar = wnode.find_or_create_lvar(name)
-        raise "couldn't find or create local variable #{name}" unless lvar
+        rlse node, "couldn't find or create local variable #{name}" unless lvar
         lvar.wtype = WType.new(wtype)
       end
       return
@@ -1347,13 +1623,13 @@ module Rlang::Parser
     #       s(:sym, :I64))
     # ))
     def parse_send_arg(node, wnode, keep_eval)
-      raise "arg declaration can only be used in methods" \
+      rlse node, "arg declaration can only be used in methods" \
         unless wnode.in_method_scope?
       hash_node = node.children.last
       marg_types = parse_type_args(hash_node, :argument)
       marg_types.each do |name, wtype|
         marg = wnode.find_marg(name)
-        raise "couldn't find method argument #{name}" unless marg
+        rlse node, "couldn't find method argument #{name}" unless marg
         marg.wtype = WType.new(wtype)
       end
       return
@@ -1383,42 +1659,33 @@ module Rlang::Parser
     # (:none means no value is returned)
     #
     # Example
-    # result :class_name, :method_name, :I64
+    # result :MyClass, :split, :I64
+    # result :"ClassA::MyClass", :split, :Header
     # ---------
     # s(:send, nil, :result,
-    #   s(:sym, :class_name),
+    #   s(:sym, :class_path),
     #   s(:sym, :method_name),
     #   s(:sym, :I64))
     #
     # if name starts with # it's a n instance method,
     # otherwise a class method
+    # Note: class path can be either A or A::B
     def parse_send_result(node, wnode, keep_eval)
       if wnode.in_method_scope?
         result_type, = *node.children[2]
-        raise "result directive expects a symbol argument (got #{result_type})" \
+        rlse node, "result directive expects a symbol argument (got #{result_type})" \
           unless result_type.is_a? Symbol
         wnode.method_wnode.wtype = WType.new(result_type)
         logger.debug "result_type #{result_type} updated for method #{wnode.method_wnode.method}"
       elsif wnode.in_class_scope?
-        cn_name,  = *node.children[2]
-        mn_name,  = *node.children[3]
+        class_path_name,  = *node.children[2]
+        method_name, = *node.children[3]
         result_type, = *node.children[4]
-        raise "result directive expects a symbol argument (got #{result_type}) in node #{node}" \
+        rlse node, "result directive expects a symbol argument (got #{result_type}) in node #{node}" \
           unless result_type.is_a? Symbol
-        # Create class and method objects as we known we'll
-        # be calling them later on
-        WNode.root.find_or_create_class(cn_name)
-        if mn_name[0] == '#'
-          method_type = :instance
-          mth_name = mn_name[1..-1].to_sym
-        else
-          method_type = :class
-          mth_name = mn_name.to_sym
-        end
-        (mth = wnode.find_or_create_method(mth_name, cn_name, nil, method_type)).wtype = WType.new(result_type)
-        logger.debug "Declared #{method_type} method #{mth.name} in class #{mth.class_name} with wtype #{mth.wtype.name}"
+        @wgenerator.declare_method(wnode, WType.new(class_path_name), method_name.to_sym, result_type)
       else
-        raise "result declaration not supported #{wn.scope} scope"
+        rlse node, "result declaration not supported #{wn.scope} scope"
       end
       return
     end
@@ -1437,21 +1704,21 @@ module Rlang::Parser
     #   s(:sym, :ptr),
     #   s(:sym, :size))
     def parse_send_attr(node, wnode, keep_eval)
-      raise "attr directives can only happen in class scope" \
+      rlse node, "attr directives can only happen in class scope" \
         unless wnode.in_class_scope?
       
       # check accessor directive is valid
       attr_access = node.children[1].to_s
-      raise "Unknown kind of attribute accessor: #{attr_access}" \
+      rlse node, "Unknown kind of attribute accessor: #{attr_access}" \
         unless ['attr_reader', 'attr_writer', 'attr_accessor'].include? attr_access
       # scan through all attributes
       attr_nodes = node.children[2..-1]
       attr_nodes.each do |an|
         logger.debug "processing attr node #{an}"
-        raise "attribute name must be a symbol (got #{an})" unless an.type == :sym
+        rlse node, "attribute name must be a symbol (got #{an})" unless an.type == :sym
         attr_name = an.children.last
         if (attr = wnode.find_attr(attr_name))
-          raise "attribute #{attr_name} already declared" if attr
+          rlse node, "attribute #{attr_name} already declared" if attr
         else
           attr = wnode.create_attr(attr_name)
           attr.export!
@@ -1465,29 +1732,29 @@ module Rlang::Parser
     # in case it's not the default type 
     #
     # Example
-    # attr_type ptr: :I64, size: :I32
+    # attr_type ptr: :Header, size: :I32
     # ---------
     # s(:send, nil, :attr_type,
     #   (hash
     #     (pair
     #       s(:sym, :ptr)
-    #       s(:sym, :I64))
+    #       s(:sym, :Header))
     #     (pair
     #       s(:sym, :size)
     #       s(:sym, :I32))   ))
     #
     def parse_send_attr_type(node, wnode, keep_eval)
-      raise "attr directives can only happen in class scope" \
+      rlse node, "attr directives can only happen in class scope" \
         unless wnode.in_class_scope?
       hash_node = node.children.last
       attr_types = parse_type_args(hash_node, :attribute)
       attr_types.each do |name, wtype|
+        logger.debug "Setting attr #{name} type to #{wtype}"
         if (attr = wnode.find_attr(name))
-          logger.debug "Setting attr #{name} type to #{wtype}"
           # TODO find a way to update both wtype at once
           attr.wtype = WType.new(wtype)
         else
-          raise "Unknown class attribute #{name} in #{wnode}"
+          rlse node, "Unknown class attribute #{name} in #{wnode.head}"
         end          
       end
       return
@@ -1525,17 +1792,17 @@ module Rlang::Parser
     #       (str "call_indirect(state, cf, opcodes, opcode)"))
     #  
     def parse_send_inline(node, wnode, keep_eval)
-      raise "inline can only happen in a method body or at root" \
+      rlse node, "inline can only happen in a method body or at root" \
         unless wnode.in_method_scope? || wnode.in_root_scope?
       hash_node = node.children.last
-      raise "inline expects a hash argument (got #{hash_node.type}" \
+      rlse node, "inline expects a hash argument (got #{hash_node.type}" \
         unless hash_node.type == :hash
 
       # Find the :wat entry in hash
       logger.debug "Hash node: #{hash_node} "
       wat_node = hash_node.children.\
         find {|pair| sym_node, = *pair.children; sym_node.children.last == :wat}
-      raise "inline has no wat: hash entry" unless wat_node
+      rlse node, "inline has no wat: hash entry" unless wat_node
       logger.debug "inline wat entry: #{wat_node}"
 
       # Find the :wtype entry in hash if any
@@ -1550,7 +1817,7 @@ module Rlang::Parser
       logger.debug "wtype: #{wtype} "
 
       # Now extract the WAT code itself
-      raise "inline has no wat: hash entry" unless wat_node
+      rlse node, "inline has no wat: hash entry" unless wat_node
       wcode_node = wat_node.children.last
       if wcode_node.type == :dstr
         # iterate over str children
@@ -1558,7 +1825,7 @@ module Rlang::Parser
       elsif wcode_node.type == :str
         wat_code = wcode_node.children.last
       else
-        raise "inline WAT code must be a string (got #{wcode_node})"
+        rlse node, "inline WAT code must be a string (got #{wcode_node})"
       end
       wn_inline = @wgenerator.inline(wnode, wat_code, wtype)
       # Drop last evaluated result if asked to
@@ -1567,40 +1834,31 @@ module Rlang::Parser
     end
 
     # Determine whether it's an instance or class method call
+    # TODO : see how to remove identical code between class
+    # and instance method calls below
     def parse_send_method_lookup(node, wnode, keep_eval)
       recv_node = node.children[0]
       #method_name = node.children[1]
-      if wnode.in_class_scope? || wnode.in_class_method_scope? || wnode.in_root_scope?
-        if recv_node.nil? || recv_node.type == :self 
-          return parse_send_class_method_call(node, wnode, keep_eval)
-        elsif recv_node.type == :const
-          const_name = recv_node.children.last
-          # if this is a Constant, not a class
-          # then it's actually an instance method call
-          if wnode.find_const(const_name)
+      #if wnode.in_class_scope? || wnode.in_class_method_scope? || wnode.in_root_scope?
+        if recv_node.nil? || recv_node.type == :self
+          if wnode.in_instance_method_scope?
             return parse_send_instance_method_call(node, wnode, keep_eval)
           else
             return parse_send_class_method_call(node, wnode, keep_eval)
           end
-        else
-          return parse_send_instance_method_call(node, wnode, keep_eval)
-        end
-      elsif wnode.in_instance_method_scope?
-        if recv_node&.type == :const
-          recv_name = recv_node.children.last
+        elsif recv_node.type == :const
+          const_path = _build_const_path(recv_node)
           # if this is a Constant, not a class
           # then it's actually an instance method call
-          if wnode.find_const(recv_name)
-            return parse_send_instance_method_call(node, wnode, keep_eval)
-          else
+          rlse node, "Unknown constant #{const_path}" unless (c = wnode.find_const(const_path))
+          if (c.class? || c.module?)
             return parse_send_class_method_call(node, wnode, keep_eval)
-          end
+          else
+            return parse_send_instance_method_call(node, wnode, keep_eval)
+          end            
         else
           return parse_send_instance_method_call(node, wnode, keep_eval)
         end
-      else
-        raise "Don't know how to call method in scope #{wnode.scope} from node #{recv_node}"
-      end
     end
 
     # Regular class Method call to self class
@@ -1638,26 +1896,27 @@ module Rlang::Parser
     #   (const nil :Header) :new) )
     #
     def parse_send_class_method_call(node, wnode, keep_eval)
-      logger.debug "Parsing class method call:..."
+      logger.debug "Parsing class method call..."
       recv_node = node.children[0]
       method_name = node.children[1]
       if recv_node.nil? || recv_node.type == :self
-        class_name = wnode.class_name
+        # differ class_name identification to
+        class_path = []
       elsif recv_node.type == :const
-        class_name = recv_node.children.last
+        class_path = _build_const_path(recv_node)
       else
-        raise "Can only call method class on self or class objects (got #{recv_node} in node #{node})"
+        rlse node, "Can only call method class on self or class objects (got #{recv_node} in node #{node})"
       end
-      logger.debug "...#{class_name}::#{method_name}"
+      logger.debug "...#{class_path}::#{method_name}"
       if method_name == :new && (wnode.in_class_scope? || wnode.in_root_scope?)
         # This is class object instantiation. Statically 
         # allocated though. So it can only happen in the
         # class scope for a class variable or a constant
         # Returns a wnode with a i32.const containing the address
-        wn_addr = @wgenerator.static_new(wnode, class_name)
+        wn_addr = @wgenerator.static_new(wnode, class_path)
         return wn_addr
       else
-        wn_call = @wgenerator.call(wnode, class_name, method_name, :class)
+        wn_call = @wgenerator.send_method(wnode, class_path, method_name, :class)
         arg_nodes = node.children[2..-1]
         arg_nodes.each { |node| parse_node(node, wn_call) }
         # Drop last evaluated result if asked to or if
@@ -1665,7 +1924,7 @@ module Rlang::Parser
         @wgenerator.drop(wnode) unless (keep_eval || wn_call.wtype.blank?)
         return wn_call
       end
-      raise "FATAL ERROR!! Unreachable point at end of parse_send_class_method_call (node: #{node})"
+      rlse node, "FATAL ERROR!! Unreachable point at end of parse_send_class_method_call (node: #{node})"
     end
 
     # Instance Method lookup and native operator
@@ -1709,6 +1968,7 @@ module Rlang::Parser
     #  ) :!)
     #
     def parse_send_instance_method_call(node, wnode, keep_eval)
+      logger.debug "Parsing instance method call..."
       recv_node = node.children[0]
       method_name = node.children[1]
       # Parse receiver node and temporarily attach it
@@ -1717,31 +1977,28 @@ module Rlang::Parser
       logger.debug "Parsing instance method call #{method_name}, keep_eval: #{keep_eval}..."
       logger.debug "... on receiver #{recv_node}..."
 
-      # parse the receiver node just to know its wtype
-      # if nil it means self
+      # parse the receiver node just to determine its wtype
+      # if receiver node is nil it means the receiver is self
       wn_phony = @wgenerator.phony(wnode)
-
       wn_recv = recv_node.nil? ? parse_self(recv_node, wn_phony) : parse_node(recv_node, wn_phony)
       logger.debug "Parsed receiver : #{wn_recv} / wtype: #{wn_recv.wtype}"
 
-      # If it's a Wasm natively supported operator and it
-      # is not overloaded by the receiver's class
-      # then generate native operator Wasm code instead of
-      # a method call
-      wn_op = @wgenerator.send_method(wnode, method_name, wn_recv.wtype)
+      # Generate method call code
+      wn_op = @wgenerator.send_method(wnode, wn_recv.wtype.class_path, method_name, :instance)
 
       # reparent the receiver wnode(s) to operator wnode
       wn_phony.reparent_children_to(wn_op)
       wnode.remove_child(wn_phony)
 
-      # Grab all arguments and add them as child of the call node
+      # Grab all argument nodes, parse them and add them as child 
+      # to the method call node
       arg_nodes = node.children[2..-1]
       wn_args = arg_nodes.collect do |n| 
         logger.debug "...with arg #{n}"
         parse_node(n, wn_op, true)
       end
 
-      # now cast operands (will do nothing if it's a method call)
+      # now process operands (e.g. cast them if needed)
       @wgenerator.operands(wn_op, wn_recv, wn_args)
       logger.debug "After operands, call wnode: #{wn_op} wtype: #{wn_op.wtype}, wn_op children types: #{wn_op.children.map(&:wtype)}"
 
@@ -1756,14 +2013,14 @@ module Rlang::Parser
       types = {}
       # Is this a hash Node ?
       unless hash_node.respond_to?(:type) && hash_node.type == :hash
-        raise "#{entity} expects a hash argument (got #{hash_node}" \
+        rlse hash_node, "#{entity} expects a hash argument (got #{hash_node}" \
       end
       logger.debug "#{entity} hash node: #{hash_node}"
       hash_node.children.each do |pair_node|
         name_node, type_node = pair_node.children
-        raise "The name of an #{entity} must be a symbol (got #{name_node})" \
+        rlse name_node, "The name of an #{entity} must be a symbol (got #{name_node})" \
           unless name_node.type == :sym
-        raise "The type of an #{entity} must be a symbol (got #{type_node})" \
+        rlse type_node, "The type of an #{entity} must be a symbol (got #{type_node})" \
           unless type_node.type == :sym
         name = name_node.children.last
         type = type_node.children.last
@@ -1787,7 +2044,7 @@ module Rlang::Parser
         # TODO: not sure this is the right thing to do. Double check
         logger.debug "self in class definition scope. Nothing to do."
       else
-        raise "Don't know what self means in this context: #{wnode}"
+        rlse node, "Don't know what self means in this context: #{wnode.head}"
       end 
       wn
     end
@@ -1806,27 +2063,27 @@ module Rlang::Parser
         logger.debug "in send: recv_node #{recv_node}, method_name #{method_name}"
         case method_name
         when :to_I64
-          raise "Data type casting can only apply to int (got #{recv_node}" \
+          rlse node, "Data type casting can only apply to int (got #{recv_node}" \
             unless recv_node.type == :int
           value = recv_node.children.last
           DAta.append(label, value, Type::I64)
         when :[]
-          raise "Initializer can only be a Data address (got #{node})" \
+          rlse node, "Initializer can only be a Data address (got #{node})" \
             unless recv_node.children.last == :DAta
-          raise "Initializer expects a symbol (got #{arg_node})" \
+          rlse node, "Initializer expects a symbol (got #{arg_node})" \
             unless arg_node.type == :sym
           DAta.append(label, DAta[arg_node.children.last])
         else
-          raise "Unknow data initializer #{node}"
+          rlse node, "Unknow data initializer #{node}"
         end
       else
-        raise "Unknow data initializer #{node}"
+        rlse node, "Unknow data initializer #{node}"
       end
     end
 
     def parse_return(node, wnode, keep_eval)
       ret_count = node.children.count
-      raise "only one or no value can be returned (got #{ret_count})" if ret_count > 1
+      rlse node, "only one or no value can be returned (got #{ret_count})" if ret_count > 1
       exp_node = node.children.first
       wn_ret = @wgenerator.return(wnode)
       if exp_node
@@ -1936,7 +2193,7 @@ module Rlang::Parser
         parse_node(else_node, wn_else, keep_eval)
         wn_else.wtype = wn_else.children.last.wtype
         if wn_then.wtype != wn_else.wtype
-          raise "then and else clauses must return same wtype (got #{wn_then.wtype} and #{wn_else.wtype}"
+          rlse node, "then and else clauses must return same wtype (got #{wn_then.wtype} and #{wn_else.wtype}"
         end
       else
         # if the else clause doesn't exist in Ruby we still
@@ -2034,6 +2291,24 @@ module Rlang::Parser
       return wn_op
     end
 
+    def _build_const_path(node)
+      logger.debug "Building constant path..."
+      const_path = []; n = node
+      while n
+        rlse node, "expecting a const node (got #{n})" unless n.type == :const
+        logger.debug "adding #{n.children.last} to constant path"
+        const_path.unshift(n.children.last)
+        n = n.children.first
+      end
+      logger.debug "... #{const_path}"
+      const_path
+    end
+
+    def self._reset_toggles
+      @@export, @@export_name = false, nil
+      @@import, @@import_module_name, @@import_function_name = false, nil, nil
+    end
+
     def dump
       @ast
     end