myco 0.1.3 → 0.1.4

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

@@ -0,0 +1,40 @@
+
+::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(:DeclareCategoryScope, ::Myco::Component.new([::Myco.find_constant(:MycoModuleScope)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:body_bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    g.push_scope
+    g.send(
+      :set_myco_category,
+      0
+    )
+    g.pop
+    self.body.bytecode(g)
+  )})}})
+  .tap { |__c__| __c__.__name__ = :DeclareCategoryScope }
+  ::Myco.cscope.for_method_definition.const_set(:DeclareCategory, ::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(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    ::Myco.cscope.for_method_definition.const_set(:Form, ([
+      :category,
+      :name,
+      :body
+    ]))
+    declare_meme(:scope_implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:DeclareCategoryScope).new({
+      :line => self.line,
+      :body => self.body
+    }))}
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_self
+      g.push_literal(self.name)
+      g.send(
+        :__category__,
+        1
+      )
+      self.scope_implementation.bytecode(g)
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :DeclareCategory }
+)})}}.instance

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

@@ -0,0 +1,20 @@
+
+CodeTools::AST << {
+  
+  DeclareDecorator < Node {
+    var name, var arguments
+    
+    setter arguments: |x|
+      x || ArrayAssembly.new(line:self.line, body:[])
+    
+    Form: [:deco, :name, :arguments]
+    
+    implementation: ArrayAssembly.new(
+      line:self.line
+      body:[self.name, self.arguments]
+    )
+    
+    bytecode: |g| pos(g); implementation.bytecode(g)
+  }
+  
+}

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

@@ -0,0 +1,28 @@
+
+::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(:DeclareDecorator, ::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(:arguments, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:arguments, [[:setter, []]], nil, ::Myco.cscope.dup) { |x| (::Myco.branch_op(:"||", x) {::Myco.find_constant(:ArrayAssembly).new({
+    :line => self.line,
+    :body => []
+  })})}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :deco,
+    :name,
+    :arguments
+  ]))
+  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ArrayAssembly).new({
+    :line => self.line,
+    :body => [
+      self.name,
+      self.arguments
+    ]
+  }))}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.implementation.bytecode(g)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :DeclareDecorator })})}}.instance

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

@@ -0,0 +1,38 @@
+
+CodeTools::AST << {
+  
+  DeclareFileScope < MycoModuleScope {
+    body_bytecode: |g| {
+      g.push_scope
+      g.send(:set_myco_file, 0)
+      g.pop
+      
+      self.body.bytecode(g)
+    }
+  }
+  
+  DeclareFile < Node {
+    var body
+    
+    Form: [:declfile, :body]
+    
+    # Use minimal inspect to avoid huge inspect output for inner AST nodes
+    # that store a reference to a DeclareFile in an instance variable. 
+    inspect: to_s
+    
+    implementation: {
+      type = ConstantAccess.new(line:self.line, toplevel:true, names:[:"Myco", :"FileToplevel"])
+      types = ArrayAssembly.new(line:self.line, body:[type])
+      decl = DeclareObject.new(line:self.line, types:types, body:self.body)
+      decl.scope_type = DeclareFileScope
+      decl
+    }
+    
+    bytecode: |g| {
+      pos(g)
+      
+      implementation.bytecode(g)
+    }
+  }
+  
+}

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

@@ -0,0 +1,53 @@
+
+::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(:DeclareFileScope, ::Myco::Component.new([::Myco.find_constant(:MycoModuleScope)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:body_bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    g.push_scope
+    g.send(
+      :set_myco_file,
+      0
+    )
+    g.pop
+    self.body.bytecode(g)
+  )})}})
+  .tap { |__c__| __c__.__name__ = :DeclareFileScope }
+  ::Myco.cscope.for_method_definition.const_set(:DeclareFile, ::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, ([
+      :declfile,
+      :body
+    ]))
+    declare_meme(:inspect, [], nil, ::Myco.cscope.dup) { |*| (self.to_s)}
+    declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (
+      type = ::Myco.find_constant(:ConstantAccess).new({
+        :line => self.line,
+        :toplevel => true,
+        :names => [
+          :Myco,
+          :FileToplevel
+        ]
+      })
+      types = ::Myco.find_constant(:ArrayAssembly).new({
+        :line => self.line,
+        :body => [type]
+      })
+      decl = ::Myco.find_constant(:DeclareObject).new({
+        :line => self.line,
+        :types => types,
+        :body => self.body
+      })
+      decl.__send__(
+        :scope_type=,
+        ::Myco.find_constant(:DeclareFileScope)
+      )
+      decl
+    )}
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      self.implementation.bytecode(g)
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :DeclareFile }
+)})}}.instance

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

@@ -0,0 +1,79 @@
+
+CodeTools::AST << {
+  
+  DeclareMemeBody < BlockLiteral {
+    var name
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.state.scope.nest_scope(self)
+      
+      meth = new_generator(g, self.name, self.parameters)
+      
+      meth.push_state(self)
+      meth.state.push_super(self)
+      meth.definition_line(self.line)
+      
+      meth.state.push_name(self.name.to_sym)
+      
+      self.parameters.bytecode(meth)
+      self.body.bytecode(meth)
+      
+      meth.state.pop_name
+      
+      meth.local_count = local_count
+      meth.local_names = local_names
+      
+      meth.ret
+      meth.close
+      meth.pop_state
+      
+      g.push_scope
+      g.send(:for_method_definition, 0)
+      g.add_scope
+      
+      # Create the BlockEnvironment from the meth Generator
+      g.create_block(meth)
+    }
+  }
+  
+  DeclareMeme < Node {
+    var name, var decorations, var parameters, var body
+    
+    Form: [:meme, :name, :decorations, :parameters, :body]
+    
+    setter name: |x|
+      x.value
+    setter decorations: |x|
+      x || ArrayAssembly.new(line:line, body:[])
+    setter parameters: |x|
+      x || ParameterAssembly.new(line:line, required:[], splat:true)
+    setter body: |x|
+      x || NullLiteral.new(line:line)
+    
+    body_implementation: DeclareMemeBody.new(
+      line:       self.line
+      name:       self.name
+      parameters: self.parameters
+      body:       self.body
+    )
+    
+    bytecode: |g| {
+      pos(g)
+      
+      ##
+      # module = scope.for_method_definition
+      # module.send :declare_meme, self.name, self.decorations,
+      #   BlockEnvironment(body_implementation)
+      #
+      g.push_scope
+      g.send(:for_method_definition, 0)
+        g.push_literal(self.name)
+        self.decorations.bytecode(g)
+        body_implementation.bytecode(g)
+      g.send(:declare_meme, 3)
+    }
+  }
+  
+}

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

@@ -0,0 +1,90 @@
+
+::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(:DeclareMemeBody, ::Myco::Component.new([::Myco.find_constant(:BlockLiteral)], ::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(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.state.scope.nest_scope(self)
+      meth = self.new_generator(
+        g,
+        self.name,
+        self.parameters
+      )
+      meth.push_state(self)
+      meth.state.push_super(self)
+      meth.definition_line(self.line)
+      meth.state.push_name(self.name.to_sym)
+      self.parameters.bytecode(meth)
+      self.body.bytecode(meth)
+      meth.state.pop_name
+      meth.__send__(
+        :local_count=,
+        self.local_count
+      )
+      meth.__send__(
+        :local_names=,
+        self.local_names
+      )
+      meth.ret
+      meth.close
+      meth.pop_state
+      g.push_scope
+      g.send(
+        :for_method_definition,
+        0
+      )
+      g.add_scope
+      g.create_block(meth)
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :DeclareMemeBody }
+  ::Myco.cscope.for_method_definition.const_set(:DeclareMeme, ::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(:decorations, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:parameters, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    ::Myco.cscope.for_method_definition.const_set(:Form, ([
+      :meme,
+      :name,
+      :decorations,
+      :parameters,
+      :body
+    ]))
+    declare_meme(:name, [[:setter, []]], nil, ::Myco.cscope.dup) { |x| (x.value)}
+    declare_meme(:decorations, [[:setter, []]], nil, ::Myco.cscope.dup) { |x| (::Myco.branch_op(:"||", x) {::Myco.find_constant(:ArrayAssembly).new({
+      :line => self.line,
+      :body => []
+    })})}
+    declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |x| (::Myco.branch_op(:"||", x) {::Myco.find_constant(:ParameterAssembly).new({
+      :line => self.line,
+      :required => [],
+      :splat => true
+    })})}
+    declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |x| (::Myco.branch_op(:"||", x) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
+    declare_meme(:body_implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:DeclareMemeBody).new({
+      :line => self.line,
+      :name => self.name,
+      :parameters => self.parameters,
+      :body => self.body
+    }))}
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_scope
+      g.send(
+        :for_method_definition,
+        0
+      )
+      g.push_literal(self.name)
+      self.decorations.bytecode(g)
+      self.body_implementation.bytecode(g)
+      g.send(
+        :declare_meme,
+        3
+      )
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :DeclareMeme }
+)})}}.instance

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

@@ -0,0 +1,58 @@
+
+CodeTools::AST << {
+  
+  DeclareObjectScope < MycoModuleScope {
+    body_bytecode: |g| {
+      g.push_scope
+      g.send(:set_myco_component, 0)
+      g.pop
+      
+      self.body.bytecode(g)
+    }
+  }
+  
+  DeclareObject < Node {
+    var types, var body
+    
+    Form: [:declobj, :types, :body]
+    
+    var create: true
+    var scope_type: DeclareObjectScope
+    
+    var scope_implementation: self.scope_type.new(
+      line: self.line
+      body: self.body
+    )
+    
+    bytecode: |g| {
+      pos(g)
+      
+      # ::Myco::Component.new types, parent, filename
+      g.push_cpath_top
+      g.find_const(:"Myco")
+      g.find_const(:"Component")
+        self.types.bytecode(g)
+        g.push_scope; g.send(:for_method_definition, 0)
+        g.push_scope; g.send(:active_path, 0); g.meta_to_s
+        g.push_int(self.line)
+      g.send(:new, 4)
+      
+      # The return value of Component.new at the top of the stack
+      # will be consumed by self.scope.bytecode, so save two copies of it.
+      g.dup_top # One for sending :__last__= to
+      g.dup_top # One for sending :instance to (or returning, if !self.create)
+      
+      # Compile the inner scope,
+      # leaving the last object in the scope at the top of the stack.
+      scope_implementation.bytecode(g)
+      
+      # component.__last__ = (value left on stack from self.scope.bytecode)
+      g.send(:"__last__=", 1)
+      g.pop
+      
+      # return (self.create ? component.instance : component)
+      self.create && g.send(:instance, 0)
+    }
+  }
+  
+}

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

@@ -0,0 +1,67 @@
+
+::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(:DeclareObjectScope, ::Myco::Component.new([::Myco.find_constant(:MycoModuleScope)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:body_bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    g.push_scope
+    g.send(
+      :set_myco_component,
+      0
+    )
+    g.pop
+    self.body.bytecode(g)
+  )})}})
+  .tap { |__c__| __c__.__name__ = :DeclareObjectScope }
+  ::Myco.cscope.for_method_definition.const_set(:DeclareObject, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:types, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    ::Myco.cscope.for_method_definition.const_set(:Form, ([
+      :declobj,
+      :types,
+      :body
+    ]))
+    declare_meme(:create, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (true)}
+    declare_meme(:scope_type, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:DeclareObjectScope))}
+    declare_meme(:scope_implementation, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.scope_type.new({
+      :line => self.line,
+      :body => self.body
+    }))}
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_cpath_top
+      g.find_const(:Myco)
+      g.find_const(:Component)
+      self.types.bytecode(g)
+      g.push_scope
+      g.send(
+        :for_method_definition,
+        0
+      )
+      g.push_scope
+      g.send(
+        :active_path,
+        0
+      )
+      g.meta_to_s
+      g.push_int(self.line)
+      g.send(
+        :new,
+        4
+      )
+      g.dup_top
+      g.dup_top
+      self.scope_implementation.bytecode(g)
+      g.send(
+        :__last__=,
+        1
+      )
+      g.pop
+      ::Myco.branch_op(:"&&", self.create) {g.send(
+        :instance,
+        0
+      )}
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :DeclareObject }
+)})}}.instance

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

@@ -0,0 +1,26 @@
+
+CodeTools::AST << {
+  
+  DeclareString < Node {
+    var types, var string
+    
+    Form: [:declstr, :types, :string]
+    
+    implementation: InvokeMethod.new(
+      line:      self.string.line
+      name:      :from_string
+      arguments: ArgumentAssembly.new(
+        line:      self.string.line,
+        body:      [self.string]
+      )
+      receiver:  DeclareObject.new(
+        line:      self.line
+        types:     self.types
+        body:      NullLiteral.new(line:self.line)
+      )
+    )
+    
+    bytecode: |g| pos(g); implementation.bytecode(g)
+  }
+  
+}

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

@@ -0,0 +1,30 @@
+
+::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(:DeclareString, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:types, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :declstr,
+    :types,
+    :string
+  ]))
+  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:InvokeMethod).new({
+    :line => self.string.line,
+    :name => :from_string,
+    :arguments => ::Myco.find_constant(:ArgumentAssembly).new({
+      :line => self.string.line,
+      :body => [self.string]
+    }),
+    :receiver => ::Myco.find_constant(:DeclareObject).new({
+      :line => self.line,
+      :types => self.types,
+      :body => ::Myco.find_constant(:NullLiteral).new({:line => self.line})
+    })
+  }))}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.implementation.bytecode(g)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :DeclareString })})}}.instance

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

@@ -0,0 +1,21 @@
+
+CodeTools::AST << {
+  
+  DynamicString < Node {
+    var body
+    
+    Form: [:dstr, :body]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      self.body.each_slice(2) |string, other| {
+        g.push_literal(string.value.to_s)
+        other && (other.bytecode(g); g.meta_to_s)
+      }
+      
+      g.string_build(self.body.size)
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/DynamicString.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(:DynamicString, ::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, ([
+    :dstr,
+    :body
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.body.each_slice(2) { |string, other| (
+      g.push_literal(string.value.to_s)
+      ::Myco.branch_op(:"&&", other) {(
+        other.bytecode(g)
+        g.meta_to_s
+      )}
+    )}
+    g.string_build(self.body.size)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :DynamicString })})}}.instance

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

@@ -0,0 +1,22 @@
+
+CodeTools::AST << {
+  
+  DynamicSymbol < Node {
+    var body
+    
+    Form: [:dsym, :body]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      self.body.each_slice(2) |string, other| {
+        g.push_literal(string.value.to_s)
+        other && (other.bytecode(g); g.meta_to_s)
+      }
+      
+      g.string_build(self.body.size)
+      g.send(:to_sym, 0)
+    }
+  }
+  
+}

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

@@ -0,0 +1,26 @@
+
+::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(:DynamicSymbol, ::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, ([
+    :dsym,
+    :body
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.body.each_slice(2) { |string, other| (
+      g.push_literal(string.value.to_s)
+      ::Myco.branch_op(:"&&", other) {(
+        other.bytecode(g)
+        g.meta_to_s
+      )}
+    )}
+    g.string_build(self.body.size)
+    g.send(
+      :to_sym,
+      0
+    )
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :DynamicSymbol })})}}.instance

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

@@ -0,0 +1,37 @@
+
+CodeTools::AST << {
+  
+  Invoke < Node {
+    var receiver, var name, var arguments, var block_params, var block
+    
+    Form: [:invoke, :receiver, :name, :arguments, :block_params, :block]
+    
+    bytecode: |g| pos(g); implementation.bytecode(g)
+    
+    implementation: {
+      # TODO: error if passing both block argument and block literal
+      # Currently, this fails silently and ignores the block argument
+      # TODO: don't change AST state from here
+      self.block && (
+        self.arguments = self.arguments || ArgumentAssembly.new(line:self.line, body:[])
+        self.block_params = self.block_params || ParameterAssembly.new(line:self.line)
+        self.arguments.block = BlockLiteral.new(line:self.line, parameters:self.block_params, body:self.block)
+      )
+      
+      self.receiver.nil? && self.arguments.nil? &? (
+        LocalVariableAccessAmbiguous.new(
+          line: self.line
+          name: self.name
+        )
+      ) ?? (
+        InvokeMethod.new(
+          line:      self.line
+          receiver:  self.receiver || Self.new(line:self.line)
+          name:      self.name
+          arguments: self.arguments || ArgumentAssembly.new(line:self.line, body:[])
+        )
+      )
+    }
+  }
+  
+}