myco 0.1.3 → 0.1.4

data/lib/myco/code_tools/AST/Invoke.my.rb

@@ -0,0 +1,58 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:Invoke, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:receiver, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:arguments, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:block_params, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :invoke,
+    :receiver,
+    :name,
+    :arguments,
+    :block_params,
+    :block
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.implementation.bytecode(g)
+  )}
+  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (
+    ::Myco.branch_op(:"&&", self.block) {(
+      self.__send__(
+        :arguments=,
+        ::Myco.branch_op(:"||", self.arguments) {::Myco.find_constant(:ArgumentAssembly).new({
+          :line => self.line,
+          :body => []
+        })}
+      )
+      self.__send__(
+        :block_params=,
+        ::Myco.branch_op(:"||", self.block_params) {::Myco.find_constant(:ParameterAssembly).new({:line => self.line})}
+      )
+      self.arguments.__send__(
+        :block=,
+        ::Myco.find_constant(:BlockLiteral).new({
+          :line => self.line,
+          :parameters => self.block_params,
+          :body => self.block
+        })
+      )
+    )}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:nil?)) {self.arguments.__send__(:nil?)}) {::Myco.find_constant(:LocalVariableAccessAmbiguous).new({
+      :line => self.line,
+      :name => self.name
+    })}) {::Myco.find_constant(:InvokeMethod).new({
+      :line => self.line,
+      :receiver => ::Myco.branch_op(:"||", self.receiver) {::Myco.find_constant(:Self).new({:line => self.line})},
+      :name => self.name,
+      :arguments => ::Myco.branch_op(:"||", self.arguments) {::Myco.find_constant(:ArgumentAssembly).new({
+        :line => self.line,
+        :body => []
+      })}
+    })}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :Invoke })})}}.instance

data/lib/myco/code_tools/AST/InvokeMethod.my

@@ -0,0 +1,19 @@
+
+CodeTools::AST << {
+  
+  InvokeMethod < Node {
+    var receiver, var name, var arguments
+    
+    Form: [:call, :receiver, :name, :arguments]
+    
+    bytecode: |g| {
+      self.receiver.bytecode(g)
+      self.arguments.bytecode(g)
+      
+      pos(g)
+      
+      g.__send__(self.arguments.send_op, self.name, self.arguments.send_count)
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/InvokeMethod.my.rb

@@ -0,0 +1,25 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:InvokeMethod, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:receiver, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:arguments, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :call,
+    :receiver,
+    :name,
+    :arguments
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.receiver.bytecode(g)
+    self.arguments.bytecode(g)
+    self.pos(g)
+    g.__send__(
+      self.arguments.send_op,
+      self.name,
+      self.arguments.send_count
+    )
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :InvokeMethod })})}}.instance

data/lib/myco/code_tools/AST/KeywordAssembly.my

@@ -0,0 +1,30 @@
+
+CodeTools::AST << {
+  
+  KeywordAssembly < Node {
+    var body
+    
+    Form: [:hash, :body]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.push_cpath_top
+      g.find_const(:"Hash")
+      g.push(self.body.size / 2)
+      g.send(:new_from_literal, 1)
+      
+      self.body.each_slice(2) |pair| {
+        key = pair.first
+        value = pair.last
+        
+        g.dup
+        key.bytecode(g)
+        value.bytecode(g)
+        g.send(:"[]=", 2)
+        g.pop
+      }
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/KeywordAssembly.my.rb

@@ -0,0 +1,36 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:KeywordAssembly, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :hash,
+    :body
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.push_cpath_top
+    g.find_const(:Hash)
+    g.push(self.body.size.__send__(
+      :/,
+      2
+    ))
+    g.send(
+      :new_from_literal,
+      1
+    )
+    self.body.each_slice(2) { |pair| (
+      key = pair.first
+      value = pair.last
+      g.dup
+      key.bytecode(g)
+      value.bytecode(g)
+      g.send(
+        :[]=,
+        2
+      )
+      g.pop
+    )}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :KeywordAssembly })})}}.instance

data/lib/myco/code_tools/AST/LocalVariableAccessAmbiguous.my

@@ -0,0 +1,22 @@
+
+CodeTools::AST << {
+  
+  LocalVariableAccessAmbiguous < Node {
+    var name
+    
+    Form: [:lambig, :name]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      local = g.state.scope.search_local(self.name)
+      local &? (
+        local.get_bytecode(g)
+      ) ?? (
+        g.push_self
+        g.send(self.name, 0)
+      )
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/LocalVariableAccessAmbiguous.my.rb

@@ -0,0 +1,22 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:LocalVariableAccessAmbiguous, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :lambig,
+    :name
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    local = g.state.scope.search_local(self.name)
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", local) {local.get_bytecode(g)}) {(
+      g.push_self
+      g.send(
+        self.name,
+        0
+      )
+    )}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :LocalVariableAccessAmbiguous })})}}.instance

data/lib/myco/code_tools/AST/LocalVariableAssignment.my

@@ -0,0 +1,20 @@
+
+CodeTools::AST << {
+  
+  LocalVariableAssignment < Node {
+    var name, var value
+    var variable # TODO: remove
+    
+    Form: [:lasgn, :name, :value]
+    
+    bytecode: |g| {
+      var = g.state.scope.assign_local_reference(self)
+      
+      self.value && self.value.bytecode(g)
+      
+      pos(g)
+      var.set_bytecode(g)
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/LocalVariableAssignment.my.rb

@@ -0,0 +1,20 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:LocalVariableAssignment, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:variable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :lasgn,
+    :name,
+    :value
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    var = g.state.scope.assign_local_reference(self)
+    ::Myco.branch_op(:"&&", self.value) {self.value.bytecode(g)}
+    self.pos(g)
+    var.set_bytecode(g)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :LocalVariableAssignment })})}}.instance

data/lib/myco/{parser/ast/myco_module_scope.rb → code_tools/AST/MycoModuleScope.my}

@@ -1,40 +1,38 @@
 
-module CodeTools::AST
+CodeTools::AST << {
   
-  class MycoModuleScope < ModuleScope
-    def initialize(line, body)
-      @line = line
-      @name = :MycoModuleScope # TODO: remove/fix
-      @body = body
-    end
+  # TODO: rename to something else
+  MycoModuleScope < CodeTools::Compiler::LocalVariables, Node {
+    var name, var body
     
-    def bytecode(g)
+    bytecode: |g| {
       pos(g)
       
       # Register in the AST as a scope for local variable lookup
       # Right now, this just sets @parent to g.state.scope
       # (Necessary to pass local variables from above to memes below)
-      g.state.scope.nest_scope self
+      g.state.scope.nest_scope(self)
       
-      attach_and_call g, :__myco_module_init__, true
-    end
+      attach_and_call(g, :__myco_module_init__, true)
+    }
     
     # TODO: figure out how to keep in sync with ClosedScope#attach_and_call impl
-    def attach_and_call(g, arg_name, scoped=false, pass_block=false)
-      name = @name || arg_name
+    attach_and_call: |g, arg_name, scoped=false, pass_block=false| {
+      self.name = :"MycoModuleScope" # TODO: remove/fix
+      name = self.name || arg_name
       meth = new_generator(g, name)
       
-      meth.push_state self
+      meth.push_state(self)
       meth.for_module_body = true
       
-      if scoped
+      scoped && (
         meth.push_self
         meth.add_scope
-      end
+      )
       
-      meth.state.push_name name
+      meth.state.push_name(name.to_sym)
       
-      body_bytecode meth # (@body.bytecode meth) in original implementation
+      body_bytecode(meth) # (@body.bytecode meth) in original implementation
       
       meth.state.pop_name
       
@@ -46,39 +44,34 @@ module CodeTools::AST
       
       meth.pop_state
       
-      g.create_block meth
+      g.create_block(meth)
       g.swap
       g.push_scope
       g.push_true
-      g.send :call_under, 3
+      g.send(:call_under, 3)
       
-      return meth
-    end
+      meth
+    }
     
-    def body_bytecode g
-      @body.bytecode g
-    end
-    
-    include CodeTools::Compiler::LocalVariables
+    body_bytecode: |g| self.body.bytecode(g)
     
     # Become the AST scope parent of the given AST scope Node .
     # This is only for the benefit of LocalVariableAccessAmbiguous
     # being able to call search_local, and has nothing to do with
     # the scope referenced by g.push_scope or g.add_scope
-    def nest_scope scope
-      scope.parent = self
-    end
+    nest_scope: |scope| scope.parent = self
     
-    attr_accessor :parent
+    var parent
     
-    # This is an abbreviated form of Iter#search_local
+    # This is an abbreviated form of BlockLiteral#search_local
     # because no locals can be assigned within the MycoModuleScope
-    def search_local name
-      if reference = @parent.search_local(name)
-        reference.depth += 1
+    search_local: |name| {
+      reference = self.parent.search_local(name)
+      reference && (
+        reference.depth = reference.depth + 1
         reference
-      end
-    end
-  end
+      )
+    }
+  }
   
-end
+}

data/lib/myco/code_tools/AST/MycoModuleScope.my.rb

@@ -0,0 +1,82 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:MycoModuleScope, ::Myco::Component.new([
+  ::Myco.find_constant(:CodeTools)::Compiler::LocalVariables,
+  ::Myco.find_constant(:Node)
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.state.scope.nest_scope(self)
+    self.attach_and_call(
+      g,
+      :__myco_module_init__,
+      true
+    )
+  )}
+  declare_meme(:attach_and_call, [], nil, ::Myco.cscope.dup) { |g, arg_name, scoped=false, pass_block=false| (
+    self.__send__(
+      :name=,
+      :MycoModuleScope
+    )
+    name = ::Myco.branch_op(:"||", self.name) {arg_name}
+    meth = self.new_generator(
+      g,
+      name
+    )
+    meth.push_state(self)
+    meth.__send__(
+      :for_module_body=,
+      true
+    )
+    ::Myco.branch_op(:"&&", scoped) {(
+      meth.push_self
+      meth.add_scope
+    )}
+    meth.state.push_name(name.to_sym)
+    self.body_bytecode(meth)
+    meth.state.pop_name
+    meth.ret
+    meth.close
+    meth.__send__(
+      :local_count=,
+      self.local_count
+    )
+    meth.__send__(
+      :local_names=,
+      self.local_names
+    )
+    meth.pop_state
+    g.create_block(meth)
+    g.swap
+    g.push_scope
+    g.push_true
+    g.send(
+      :call_under,
+      3
+    )
+    meth
+  )}
+  declare_meme(:body_bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.body.bytecode(g))}
+  declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
+    :parent=,
+    self
+  ))}
+  declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:search_local, [], nil, ::Myco.cscope.dup) { |name| (
+    reference = self.parent.search_local(name)
+    ::Myco.branch_op(:"&&", reference) {(
+      reference.__send__(
+        :depth=,
+        reference.depth.__send__(
+          :+,
+          1
+        )
+      )
+      reference
+    )}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :MycoModuleScope })})}}.instance

data/lib/myco/code_tools/AST/Node.my

@@ -0,0 +1,67 @@
+
+CodeTools::AST << {
+  
+  Node < BasicObject {
+    var line
+    
+    pos: |g| g.set_line(self.line)
+    
+    new_block_generator: |g, parameters| {
+      blk = g.class.new
+      blk.name = g.state.name || :"__block__"
+      blk.file = g.file
+      blk.for_block = true
+      
+      parameters.generator_setup(blk)
+      
+      blk
+    }
+    
+    new_generator: |g, name, parameters=null| {
+      meth = g.class.new
+      meth.name = name
+      meth.file = g.file
+      
+      parameters && parameters.generator_setup(meth)
+      
+      meth
+    }
+  }
+  
+  # TODO: move this out of Node.my ?
+  State < BasicObject {
+    var scope
+    
+    # TODO: decouple rubinius-compiler from rubinius-ast and remove this hack
+    sclass new: |scope| {
+      obj = allocate
+      obj.scope = scope
+      obj
+    }
+    
+    var names: [] # stack of names
+    push_name: |x| self.names.push(x)
+    pop_name:      self.names.pop
+    name:          self.names.last
+    
+    # TODO: investigate the possibility of removing
+    var supers: [] # stack of supers
+    push_super: |x| self.supers.push(x)
+    pop_super:      self.supers.pop
+    super:          self.supers.last
+    
+    # TODO: investigate the possibility of removing
+    var evals: [] # stack of evals
+    push_eval: |x| self.evals.push(x)
+    pop_eval:      self.evals.pop
+    eval:          self.evals.last
+    
+    # TODO: investigate the possibility of removing
+    var block: 0 # count block levels
+    push_block: self.block = self.block + 1
+    pop_block: (self.block > 0) && (self.block = self.block - 1)
+    
+    # TODO: investigate the possibility of removing
+    var check_for_locals: true
+  }
+}

data/lib/myco/code_tools/AST/Node.my.rb

@@ -0,0 +1,84 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(
+  ::Myco.cscope.for_method_definition.const_set(:Node, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:line, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:pos, [], nil, ::Myco.cscope.dup) { |g| (g.set_line(self.line))}
+    declare_meme(:new_block_generator, [], nil, ::Myco.cscope.dup) { |g, parameters| (
+      blk = g.__send__(:class).new
+      blk.__send__(
+        :name=,
+        ::Myco.branch_op(:"||", g.state.name) {:__block__}
+      )
+      blk.__send__(
+        :file=,
+        g.file
+      )
+      blk.__send__(
+        :for_block=,
+        true
+      )
+      parameters.generator_setup(blk)
+      blk
+    )}
+    declare_meme(:new_generator, [], nil, ::Myco.cscope.dup) { |g, name, parameters=nil| (
+      meth = g.__send__(:class).new
+      meth.__send__(
+        :name=,
+        name
+      )
+      meth.__send__(
+        :file=,
+        g.file
+      )
+      ::Myco.branch_op(:"&&", parameters) {parameters.generator_setup(meth)}
+      meth
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :Node }
+  ::Myco.cscope.for_method_definition.const_set(:State, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:scope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:new, [[:sclass, []]], nil, ::Myco.cscope.dup) { |scope| (
+      obj = self.allocate
+      obj.__send__(
+        :scope=,
+        scope
+      )
+      obj
+    )}
+    declare_meme(:names, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+    declare_meme(:push_name, [], nil, ::Myco.cscope.dup) { |x| (self.names.push(x))}
+    declare_meme(:pop_name, [], nil, ::Myco.cscope.dup) { |*| (self.names.pop)}
+    declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| (self.names.last)}
+    declare_meme(:supers, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+    declare_meme(:push_super, [], nil, ::Myco.cscope.dup) { |x| (self.supers.push(x))}
+    declare_meme(:pop_super, [], nil, ::Myco.cscope.dup) { |*| (self.supers.pop)}
+    declare_meme(:super, [], nil, ::Myco.cscope.dup) { |*| (self.supers.last)}
+    declare_meme(:evals, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+    declare_meme(:push_eval, [], nil, ::Myco.cscope.dup) { |x| (self.evals.push(x))}
+    declare_meme(:pop_eval, [], nil, ::Myco.cscope.dup) { |*| (self.evals.pop)}
+    declare_meme(:eval, [], nil, ::Myco.cscope.dup) { |*| (self.evals.last)}
+    declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (0)}
+    declare_meme(:push_block, [], nil, ::Myco.cscope.dup) { |*| (self.__send__(
+      :block=,
+      self.block.__send__(
+        :+,
+        1
+      )
+    ))}
+    declare_meme(:pop_block, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", self.block.__send__(
+      :>,
+      0
+    )) {self.__send__(
+      :block=,
+      self.block.__send__(
+        :-,
+        1
+      )
+    )})}
+    declare_meme(:check_for_locals, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (true)}
+  )}})
+  .tap { |__c__| __c__.__name__ = :State }
+)})}}.instance