myco 0.1.3 → 0.1.4

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

@@ -0,0 +1,248 @@
+
+CodeTools::AST << {
+  
+  ParameterAssembly < Node {
+    var required: []
+    var optional: []
+    var splat:    null
+    var post:     []
+    var kwargs:   []
+    var kwrest:   null
+    var block:    null
+    
+    Form: [:args, :required, :optional, :splat, :post, :kwargs, :kwrest, :block]
+    
+    # Called on a new method or block generator
+    # to set up various parameter-related properties.
+    generator_setup: |g| {
+      g.required_args = self.required.size + self.post.size
+      
+      g.post_args = self.post.size
+      
+      g.total_args =
+        self.required.size + self.optional.size + self.post.size
+        + ((self.kwargs.any? || self.kwrest) &? 1 ?? 0)
+      
+      g.splat_index =
+        self.splat &? (self.required.size + self.optional.size) ?? null
+      
+      g.block_index = self.block && (
+        self.required.size
+        + self.optional.size
+        + (self.splat &? 1 ?? 0)
+        + self.post.size
+        + ((self.kwargs.any? || self.kwrest) &? 1 ?? 0)
+        + 1 # for self.block
+      )
+      
+      g.arity         = self.arity
+      
+      g.keywords      = self.keyword_entries
+    }
+    
+    # TODO: remove/refactor out
+    required_and_optional_kwargs: {
+      # TODO: perhaps make these be given separately?
+      required_kwargs = []
+      optional_kwargs = []
+      
+      self.kwargs.each |param| {
+        # TODO: use nil or some other param.value to represent required kwarg
+        (param.value.kind_of?(SymbolLiteral) && param.value.value == :"*")
+        &? required_kwargs.push(param)
+        ?? optional_kwargs.push(param)
+      }
+      
+      ret = [required_kwargs, optional_kwargs]
+    }
+    
+    # TODO: remove/refactor out
+    keyword_entries: {
+      entries = required_and_optional_kwargs
+      entries.first.map! |x| { [x.name, true] }
+      entries.last.map! |x| { [x.name, false] }
+      entries = entries.flatten(2)
+      entries.empty? &? null ?? entries
+    }
+    
+    # TODO: remove/refactor out
+    arity: {
+      arity = self.required.size + self.post.size
+      
+      # Check for required kwargs
+      kwargs_are_required = self.kwargs.select |param| {
+        # TODO: use nil or some other param.value to represent required kwarg
+        (param.value.kind_of?(SymbolLiteral) && param.value.value == :"*")
+      }
+      
+      kwargs_are_required && (
+        arity = arity + 1
+      )
+      
+      (self.splat
+      || self.optional.any?
+      || (kwargs.any? && !kwargs_are_required)) && (
+        arity = arity + 1
+        arity = arity * -1
+      )
+      
+      arity
+    }
+    
+    names: [
+      *self.required,
+      *self.optional.map(&:name),
+      *(self.splat.is_a?(Symbol) &? [self.splat] ?? []),
+      *self.post,
+      *self.kwargs.map(&:name),
+      *(self.kwrest.is_a?(Symbol) &? [self.kwrest] ?? []),
+      *(self.block &? [self.block.name] ?? []),
+    ]
+    
+    map_locals: |scope| {
+      self.required.each |name| { scope.new_local(name) }
+      self.optional.each |var|  { scope.assign_local_reference(var) }
+      self.splat && (self.splat.is_a?(Symbol) &? scope.new_local(self.splat) ?? scope.new_local(:"*"))
+      self.post.each     |name| { scope.new_local(name) }
+      
+      (self.kwargs.any? || self.kwrest) && scope.new_local(:"__myco_kwargs_value__")
+      self.kwargs.each |var| { scope.assign_local_reference(var) }
+      self.kwrest && (self.kwrest.is_a?(Symbol) && scope.new_local(self.kwrest))
+      
+      self.block && scope.assign_local_reference(self.block)
+    }
+    
+    # TODO: simplify
+    bytecode: |g| {
+      g.state.check_for_locals = false
+      self.map_locals(g.state.scope)
+      
+      self.optional.each |param| {
+        done = g.new_label
+        
+        param.variable.get_bytecode(g)
+        g.goto_if_not_undefined(done)
+        param.bytecode(g)
+        g.pop
+        
+        done.set!
+      }
+      
+      (self.kwargs.any? || self.kwrest) && (
+        kw_done = g.new_label
+        assignments_label = g.new_label
+        missing_value_label = g.new_label
+        defaults_label = g.new_label
+        
+        kwargs_value_var = g.state.scope.search_local(:"__myco_kwargs_value__")
+        kwargs_value_var.get_bytecode(g)
+        
+        g.dup; g.goto_if_not_nil(assignments_label) # TODO: trivially remove this line?
+        
+        g.pop
+        g.push_cpath_top
+        g.find_const(:"Hash")
+        g.send(:allocate, 0, true)
+        
+        assignments_label.set!
+        
+        entries = self.required_and_optional_kwargs
+        required_kwargs = entries.first
+        optional_kwargs = entries.last
+        
+        required_kwargs.each |param| {
+          g.dup
+          
+          g.push_literal(param.name)
+          g.send(:find_item, 1, true)
+          
+          g.dup
+          g.goto_if_false(missing_value_label)
+          
+          g.send(:value, 0, true)
+          
+          param.variable.set_bytecode(g)
+          g.pop
+        }
+        
+        g.goto(defaults_label)
+        
+        missing_value_label.set!
+        g.pop
+        g.push_rubinius
+        g.find_const(:"Runtime")
+        g.swap
+        g.send(:keywords_missing, 1, true)
+        g.goto(kw_done)
+        
+        defaults_label.set!
+        
+        extra_keys_label = g.new_label
+        
+        optional_kwargs.empty? &? (
+          g.dup
+          g.send(:size, 0, true)
+          g.push(required_kwargs.size)
+          g.goto_if_not_equal(extra_keys_label)
+          
+          self.kwrest.is_a?(Symbol) && (
+            g.push_cpath_top
+            g.find_const(:"Hash")
+            g.send(:allocate, 0, true)
+            kwrest_asgn = g.state.scope.search_local(self.kwrest)
+            kwrest_asgn.set_bytecode(g)
+            g.pop
+          )
+          
+          g.goto(kw_done)
+        ) ?? (
+          optional_kwargs.each |arg| {
+            next_value_label = g.new_label
+            default_value_label = g.new_label
+            
+            g.dup
+            g.push_literal(arg.name)
+            g.send(:find_item, 1, true)
+            
+            g.dup
+            g.goto_if_false(default_value_label)
+            
+            g.send(:value, 0, true)
+            arg.variable.set_bytecode(g)
+            g.goto(next_value_label)
+            
+            default_value_label.set!
+            g.pop
+            arg.bytecode(g)
+            
+            next_value_label.set!
+            g.pop
+          }
+        )
+        
+        extra_keys_label.set!
+        
+        g.dup
+        g.push_rubinius
+        g.find_const(:"Runtime")
+        g.swap
+        
+        self.kwrest &? g.push(:true) ?? g.push(:false)
+        
+        g.send(:keywords_extra, 2, true)
+        self.kwrest.is_a?(Symbol) && (
+          kwrest_asgn = g.state.scope.search_local(self.kwrest)
+          kwrest_asgn.set_bytecode(g)
+        )
+        g.pop
+        
+        kw_done.set!
+      )
+      
+      self.block && self.block.bytecode(g)
+      
+      g.state.check_for_locals = true
+    }
+  }
+  
+}

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

@@ -0,0 +1,314 @@
+
+::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(:ParameterAssembly, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:required, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:optional, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:splat, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
+  declare_meme(:post, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:kwargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:kwrest, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
+  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :args,
+    :required,
+    :optional,
+    :splat,
+    :post,
+    :kwargs,
+    :kwrest,
+    :block
+  ]))
+  declare_meme(:generator_setup, [], nil, ::Myco.cscope.dup) { |g| (
+    g.__send__(
+      :required_args=,
+      self.required.size.__send__(
+        :+,
+        self.post.size
+      )
+    )
+    g.__send__(
+      :post_args=,
+      self.post.size
+    )
+    g.__send__(
+      :total_args=,
+      self.required.size.__send__(
+        :+,
+        self.optional.size
+      ).__send__(
+        :+,
+        self.post.size
+      ).__send__(
+        :+,
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", self.kwargs.__send__(:any?)) {self.kwrest}) {1}) {0}
+      )
+    )
+    g.__send__(
+      :splat_index=,
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.splat) {self.required.size.__send__(
+        :+,
+        self.optional.size
+      )}) {nil}
+    )
+    g.__send__(
+      :block_index=,
+      ::Myco.branch_op(:"&&", self.block) {self.required.size.__send__(
+        :+,
+        self.optional.size
+      ).__send__(
+        :+,
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.splat) {1}) {0}
+      ).__send__(
+        :+,
+        self.post.size
+      ).__send__(
+        :+,
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", self.kwargs.__send__(:any?)) {self.kwrest}) {1}) {0}
+      ).__send__(
+        :+,
+        1
+      )}
+    )
+    g.__send__(
+      :arity=,
+      self.arity
+    )
+    g.__send__(
+      :keywords=,
+      self.keyword_entries
+    )
+  )}
+  declare_meme(:required_and_optional_kwargs, [], nil, ::Myco.cscope.dup) { |*| (
+    required_kwargs = []
+    optional_kwargs = []
+    self.kwargs.each { |param| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", param.value.__send__(
+      :kind_of?,
+      ::Myco.find_constant(:SymbolLiteral)
+    )) {param.value.value.__send__(
+      :==,
+      :*
+    )}) {required_kwargs.push(param)}) {optional_kwargs.push(param)})}
+    ret = [
+      required_kwargs,
+      optional_kwargs
+    ]
+  )}
+  declare_meme(:keyword_entries, [], nil, ::Myco.cscope.dup) { |*| (
+    entries = self.required_and_optional_kwargs
+    entries.first.__send__(:map!) { |x| ([
+      x.name,
+      true
+    ])}
+    entries.last.__send__(:map!) { |x| ([
+      x.name,
+      false
+    ])}
+    entries = entries.flatten(2)
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", entries.__send__(:empty?)) {nil}) {entries}
+  )}
+  declare_meme(:arity, [], nil, ::Myco.cscope.dup) { |*| (
+    arity = self.required.size.__send__(
+      :+,
+      self.post.size
+    )
+    kwargs_are_required = self.kwargs.select { |param| (::Myco.branch_op(:"&&", param.value.__send__(
+      :kind_of?,
+      ::Myco.find_constant(:SymbolLiteral)
+    )) {param.value.value.__send__(
+      :==,
+      :*
+    )})}
+    ::Myco.branch_op(:"&&", kwargs_are_required) {arity = arity.__send__(
+      :+,
+      1
+    )}
+    ::Myco.branch_op(:"&&", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", self.splat) {self.optional.__send__(:any?)}) {::Myco.branch_op(:"&&", self.kwargs.__send__(:any?)) {kwargs_are_required.__send__(:!)}}) {(
+      arity = arity.__send__(
+        :+,
+        1
+      )
+      arity = arity.__send__(
+        :*,
+        -1
+      )
+    )}
+    arity
+  )}
+  declare_meme(:names, [], nil, ::Myco.cscope.dup) { |*| ([
+    *self.required,
+    *self.optional.map(&:name),
+    *::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.splat.__send__(
+      :is_a?,
+      ::Myco.find_constant(:Symbol)
+    )) {[self.splat]}) {[]},
+    *self.post,
+    *self.kwargs.map(&:name),
+    *::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.kwrest.__send__(
+      :is_a?,
+      ::Myco.find_constant(:Symbol)
+    )) {[self.kwrest]}) {[]},
+    *::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block) {[self.block.name]}) {[]}
+  ])}
+  declare_meme(:map_locals, [], nil, ::Myco.cscope.dup) { |scope| (
+    self.required.each { |name| (scope.new_local(name))}
+    self.optional.each { |var| (scope.assign_local_reference(var))}
+    ::Myco.branch_op(:"&&", self.splat) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.splat.__send__(
+      :is_a?,
+      ::Myco.find_constant(:Symbol)
+    )) {scope.new_local(self.splat)}) {scope.new_local(:*)}}
+    self.post.each { |name| (scope.new_local(name))}
+    ::Myco.branch_op(:"&&", ::Myco.branch_op(:"||", self.kwargs.__send__(:any?)) {self.kwrest}) {scope.new_local(:__myco_kwargs_value__)}
+    self.kwargs.each { |var| (scope.assign_local_reference(var))}
+    ::Myco.branch_op(:"&&", self.kwrest) {::Myco.branch_op(:"&&", self.kwrest.__send__(
+      :is_a?,
+      ::Myco.find_constant(:Symbol)
+    )) {scope.new_local(self.kwrest)}}
+    ::Myco.branch_op(:"&&", self.block) {scope.assign_local_reference(self.block)}
+  )}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    g.state.__send__(
+      :check_for_locals=,
+      false
+    )
+    self.map_locals(g.state.scope)
+    self.optional.each { |param| (
+      done = g.new_label
+      param.variable.get_bytecode(g)
+      g.goto_if_not_undefined(done)
+      param.bytecode(g)
+      g.pop
+      done.__send__(:set!)
+    )}
+    ::Myco.branch_op(:"&&", ::Myco.branch_op(:"||", self.kwargs.__send__(:any?)) {self.kwrest}) {(
+      kw_done = g.new_label
+      assignments_label = g.new_label
+      missing_value_label = g.new_label
+      defaults_label = g.new_label
+      kwargs_value_var = g.state.scope.search_local(:__myco_kwargs_value__)
+      kwargs_value_var.get_bytecode(g)
+      g.dup
+      g.goto_if_not_nil(assignments_label)
+      g.pop
+      g.push_cpath_top
+      g.find_const(:Hash)
+      g.send(
+        :allocate,
+        0,
+        true
+      )
+      assignments_label.__send__(:set!)
+      entries = self.required_and_optional_kwargs
+      required_kwargs = entries.first
+      optional_kwargs = entries.last
+      required_kwargs.each { |param| (
+        g.dup
+        g.push_literal(param.name)
+        g.send(
+          :find_item,
+          1,
+          true
+        )
+        g.dup
+        g.goto_if_false(missing_value_label)
+        g.send(
+          :value,
+          0,
+          true
+        )
+        param.variable.set_bytecode(g)
+        g.pop
+      )}
+      g.goto(defaults_label)
+      missing_value_label.__send__(:set!)
+      g.pop
+      g.push_rubinius
+      g.find_const(:Runtime)
+      g.swap
+      g.send(
+        :keywords_missing,
+        1,
+        true
+      )
+      g.goto(kw_done)
+      defaults_label.__send__(:set!)
+      extra_keys_label = g.new_label
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", optional_kwargs.__send__(:empty?)) {(
+        g.dup
+        g.send(
+          :size,
+          0,
+          true
+        )
+        g.push(required_kwargs.size)
+        g.goto_if_not_equal(extra_keys_label)
+        ::Myco.branch_op(:"&&", self.kwrest.__send__(
+          :is_a?,
+          ::Myco.find_constant(:Symbol)
+        )) {(
+          g.push_cpath_top
+          g.find_const(:Hash)
+          g.send(
+            :allocate,
+            0,
+            true
+          )
+          kwrest_asgn = g.state.scope.search_local(self.kwrest)
+          kwrest_asgn.set_bytecode(g)
+          g.pop
+        )}
+        g.goto(kw_done)
+      )}) {optional_kwargs.each { |arg| (
+        next_value_label = g.new_label
+        default_value_label = g.new_label
+        g.dup
+        g.push_literal(arg.name)
+        g.send(
+          :find_item,
+          1,
+          true
+        )
+        g.dup
+        g.goto_if_false(default_value_label)
+        g.send(
+          :value,
+          0,
+          true
+        )
+        arg.variable.set_bytecode(g)
+        g.goto(next_value_label)
+        default_value_label.__send__(:set!)
+        g.pop
+        arg.bytecode(g)
+        next_value_label.__send__(:set!)
+        g.pop
+      )}}
+      extra_keys_label.__send__(:set!)
+      g.dup
+      g.push_rubinius
+      g.find_const(:Runtime)
+      g.swap
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.kwrest) {g.push(:true)}) {g.push(:false)}
+      g.send(
+        :keywords_extra,
+        2,
+        true
+      )
+      ::Myco.branch_op(:"&&", self.kwrest.__send__(
+        :is_a?,
+        ::Myco.find_constant(:Symbol)
+      )) {(
+        kwrest_asgn = g.state.scope.search_local(self.kwrest)
+        kwrest_asgn.set_bytecode(g)
+      )}
+      g.pop
+      kw_done.__send__(:set!)
+    )}
+    ::Myco.branch_op(:"&&", self.block) {self.block.bytecode(g)}
+    g.state.__send__(
+      :check_for_locals=,
+      true
+    )
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :ParameterAssembly })})}}.instance

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

@@ -0,0 +1,61 @@
+
+CodeTools::AST << {
+  
+  Quest < Node {
+    var receiver, var questable
+    
+    Form: [:quest, :receiver, :questable]
+    
+    setter questable: |given| {
+      given.receiver = FakeReceiver.new(line: self.line)
+      given
+    }
+    
+    bytecode: |g| {
+      pos(g)
+      
+      ##
+      # unless self.receiver.respond_to?(self.questable.name).false?
+      #   execute_statement self.questable
+      # else
+      #   return void
+      # end
+      
+      else_label = g.new_label
+      end_label  = g.new_label
+      
+      self.receiver.bytecode(g)
+      g.dup_top # dup the receiver to save it for later
+        g.push_literal(self.questable.name)
+      g.send(:"respond_to?", 1)
+      g.send(:"false?", 0)
+      g.goto_if_true(else_label)
+      
+      # The duped receiver is still at the top of the stack,
+      # and self.questable.receiver has been set to an instance of FakeReceiver
+      # to let the true receiver pass through instead.
+      self.questable.bytecode(g)
+      g.goto(end_label)
+      
+      else_label.set!
+      g.pop # pop the duped receiver - it won't be used after all
+      g.push_cpath_top
+      g.find_const(:"Myco")
+      g.find_const(:"Void")
+      
+      end_label.set!
+    }
+    
+    
+    FakeReceiver < Node {
+      Form: [:qrcvr]
+      
+      # Do nothing here - this would normally be ill-advised,
+      # because Nodes are expected to push an item onto the stack,
+      # but here we are intentionally not doing so because
+      # the real receiver should already at the top of the stack
+      bytecode: |g| pos(g)
+    }
+  }
+  
+}

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

@@ -0,0 +1,51 @@
+
+::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(:Quest, ::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(:questable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :quest,
+    :receiver,
+    :questable
+  ]))
+  declare_meme(:questable, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (
+    given.__send__(
+      :receiver=,
+      ::Myco.find_constant(:FakeReceiver).new({:line => self.line})
+    )
+    given
+  )}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    else_label = g.new_label
+    end_label = g.new_label
+    self.receiver.bytecode(g)
+    g.dup_top
+    g.push_literal(self.questable.name)
+    g.send(
+      :respond_to?,
+      1
+    )
+    g.send(
+      :false?,
+      0
+    )
+    g.goto_if_true(else_label)
+    self.questable.bytecode(g)
+    g.goto(end_label)
+    else_label.__send__(:set!)
+    g.pop
+    g.push_cpath_top
+    g.find_const(:Myco)
+    g.find_const(:Void)
+    end_label.__send__(:set!)
+  )}
+  ::Myco.cscope.for_method_definition.const_set(:FakeReceiver, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition.const_set(:Form, ([:qrcvr]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.pos(g))}
+  )}})
+  .tap { |__c__| __c__.__name__ = :FakeReceiver }
+)}})
+.tap { |__c__| __c__.__name__ = :Quest })})}}.instance

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

@@ -0,0 +1,27 @@
+
+CodeTools::AST << {
+  
+  # TODO: consider moving out of the AST namespace - or maybe collapse into FileToplevel
+  Script < Node {
+    var file, var body
+    var variable_scope # TODO: remove?
+    
+    Form: [:script, :file, :body]
+    
+    nest_scope: |scope| scope.parent = self
+    search_local: null # TODO: revisit and possibly implement for nested evals
+    
+    bytecode: |g| {
+      g.name = :"__script__"
+      g.file = self.file.to_sym
+      
+      g.push_state(self)
+      
+      self.body.bytecode(g)
+      g.ret
+      
+      g.pop_state
+    }
+  }
+  
+}