myco 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8031fe74a54c47a6c344eef7a2c5e13855bf2bc
-  data.tar.gz: c2f129e293c295731e643372d5add7704fdf9252
+  metadata.gz: 10d6d42881d428ea5359f83d8bfdce81ebf34ea7
+  data.tar.gz: fa2936dff1fbf455e7b8462c1c969cc023de020b
 SHA512:
-  metadata.gz: 4fb206f4849977fcfe676b435b76de6d0145cc96507456fde0071f63b291f5743deeac07729f3d30717a58ac94acf55465266d32599395e76fc4e17249f18a7f
-  data.tar.gz: 2735f64a252ba18ab5b43ddb62e0f3b96772902146dcc645a9dfb1754d99eb0609a8449d06469e45600b82908702b3c9219f3032f54cebaf7df8acfbba0d03ac
+  metadata.gz: 9663e17bf43f6b64241939eafeb51350bb6a7298add9322c815f4ed4dec266efa93398ad4c27243bdfd20524a314c6cc8a0eaf6f8f3016dc807660df07bd65e5
+  data.tar.gz: da1ebe5deab665ceef785c9ddb89cb62fd6e551d616c8bbacb0af15fd590cdaf32a10597d051dab58fc4476290003dde6bcda25f9fcbc3ed8b27479dfe7b515d

data/lib/myco/bootstrap/instance.rb

@@ -99,12 +99,22 @@ module Myco
       "#<#{__component__.to_s}>"
     end
     
-    def inspect
+    def inspect(pretty: true)
       vars = __ivar_names__.map { |var|
         [var.to_s[1..-1], __get_ivar__(var).inspect].join(": ")
       }
-      vars = vars.any? ? (" " + vars.join(", ")) : ""
-      "#<#{__component__.to_s}#{vars}>"
+      
+      vars = if vars.empty?
+        ""
+      elsif vars.size == 1
+        vars.first
+      elsif !pretty
+        vars.join(", ")
+      else
+        "\n  " + vars.join("\n").gsub("\n", "\n  ") + "\n"
+      end
+      
+      "#{__component__.to_s}#(#{vars})"
     end
     
     alias_method :hash,   :__hash__   # TODO: remove?

data/lib/myco/code_tools/AST.my

@@ -45,8 +45,6 @@ import 'AST/DeclareString.my'
 import 'AST/DeclareFile.my'
 import 'AST/DeclareExtension.my'
 import 'AST/DeclareCategory.my'
-
-import 'AST/DeclareDecorator.my'
 import 'AST/DeclareMeme.my'
 
 import 'AST/Invoke.my'

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

@@ -42,7 +42,6 @@
   declare_meme(:"AST/DeclareFile.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/DeclareExtension.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/DeclareCategory.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareDecorator.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/DeclareMeme.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/Invoke.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/InvokeMethod.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}

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

@@ -6,11 +6,11 @@ CodeTools::AST << {
     field parameters, field body
     
     var parent # TODO: investigate removing
+    var new_cscope
     
     CompilerClass: CodeTools::Compiler # TODO: remove this
     
-    setter parameters: |given| given || ParameterAssembly.new(line:self.line)
-    setter body:       |given| given || NullLiteral.new(line:self.line)
+    setter body: |given| given || NullLiteral.new(line:self.line)
     
     locals: self.body.?locals.?body.map(&:value) ?? null
     
@@ -59,13 +59,19 @@ CodeTools::AST << {
     
     new_nested_local: |name| new_local(name).nested_reference
     
+    effective_parameters: self.parameters || ParameterAssembly.new(
+      line: self.line
+      rest: RestParameter.new(line: self.line)
+    )
+    
     bytecode: |g| {
       pos(g)
       
       state = g.state
       state.scope.nest_scope(self)
       
-      blk = new_block_generator(g, self.parameters)
+      parameters = self.effective_parameters
+      blk = new_block_generator(g, parameters)
       
       blk.push_state(self)
       blk.definition_line(self.line)
@@ -77,7 +83,7 @@ CodeTools::AST << {
       # Push line info down.
       pos(blk)
       
-      self.parameters.bytecode(blk)
+      parameters.bytecode(blk)
       
       blk.state.push_block
       blk.push_modifiers
@@ -97,6 +103,11 @@ CodeTools::AST << {
       blk.local_count = local_count
       blk.local_names = local_names
       
+      self.new_cscope &? (
+        g.push_scope
+        g.send(:for_method_definition, 0)
+        g.add_scope
+      )
       g.create_block(blk)
     }
   }

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

@@ -9,8 +9,8 @@
   declare_meme(:parameters, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:new_cscope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   ::Myco.cscope.for_method_definition::CompilerClass = (::Myco.find_constant(:CodeTools)::Compiler)
-  declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:ParameterAssembly).new({:line => self.line})})}
   declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
   declare_meme(:locals, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?((Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals), :body).false? ? ::Myco::Void : (Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
   declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.locals, :include?).false? ? ::Myco::Void : self.locals.__send__(
@@ -72,13 +72,18 @@
     )) {::Myco.find_constant(:CompilerClass)::LocalVariable.new(self.allocate_slot)}
   ))}
   declare_meme(:new_nested_local, [], nil, ::Myco.cscope.dup) { |name| (self.new_local(name).nested_reference)}
+  declare_meme(:effective_parameters, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"||", self.parameters) {::Myco.find_constant(:ParameterAssembly).new({
+    :line => self.line,
+    :rest => ::Myco.find_constant(:RestParameter).new({:line => self.line})
+  })})}
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     state = g.state
     state.scope.nest_scope(self)
+    parameters = self.effective_parameters
     blk = self.new_block_generator(
       g,
-      self.parameters
+      parameters
     )
     blk.push_state(self)
     blk.definition_line(self.line)
@@ -86,7 +91,7 @@
     blk.state.push_eval(state.eval)
     blk.state.push_name(blk.name)
     self.pos(blk)
-    self.parameters.bytecode(blk)
+    parameters.bytecode(blk)
     blk.state.push_block
     blk.push_modifiers
     blk.__send__(
@@ -116,6 +121,14 @@
       :local_names=,
       self.local_names
     )
+    ::Myco.branch_op(:"&?", self.new_cscope) {(
+      g.push_scope
+      g.send(
+        :for_method_definition,
+        0
+      )
+      g.add_scope
+    )}
     g.create_block(blk)
   )}
 )}}

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

@@ -1,78 +1,58 @@
 
 CodeTools::AST << {
   
-  DeclareMemeBody < Block {
-    node_type "DeclareMemeBody" # To prevent it from masquerading as a Block TODO: remove
-    field name
+  DeclareMeme < Node {
+    node_type meme
+    field decorations, field body
     
     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)
+      self.effective_name.node_type == :symbol &? (
+        ##
+        # module = scope.for_method_definition
+        # module.send :declare_meme, name, decorations, Proc(body)
+        #
+        g.push_scope
+        g.send(:for_method_definition, 0)
+          self.effective_name.bytecode(g)
+          self.effective_decorations.bytecode(g)
+          self.effective_body.bytecode(g)
+        g.send(:declare_meme, 3)
+      ) ?? (
+        ConstantAssignment.new(
+          line:     self.line
+          constant: self.effective_name
+          value:    self.effective_body.block.body
+        ).bytecode(g)
+      )
     }
-  }
-  
-  DeclareMeme < Node {
-    node_type meme
-    field name, field decorations, field parameters, field body
     
-    setter name: |x|
-      x.value
-    setter decorations: |x|
-      x || ArrayAssembly.new(line:line, body:[])
-    setter parameters: |x|
-      x || ParameterAssembly.new(line:line, required:[], rest:RestParameter.new(line:line))
-    setter body: |x|
-      x || NullLiteral.new(line:line)
+    effective_name: self.decorations.last
     
-    body_implementation: DeclareMemeBody.new(
-      line:       self.line
-      name:       self.name
-      parameters: self.parameters
-      body:       self.body
-    )
+    effective_decorations: {
+      decorations = self.decorations[Ruby::Range.new(0, -1, true)]
+      
+      ArrayAssembly.new(line: self.line, body: decorations.reverse.map |d| {
+        d.node_type == :invoke &? (
+          ArrayAssembly.new(line: d.line, body: [
+            SymbolLiteral.new(line: d.line, value: d.name)
+            ArrayAssembly.new(line: d.line, body: d.arguments.body)
+          ])
+        ) ?? (
+          d
+        )
+      })
+    }
     
-    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)
+    effective_body: {
+      body = self.body || BlockLiteral.new(line: self.line,
+        block: Block.new(line: self.line,
+          body: NullLiteral.new(line: self.line)
+        )
+      )
+      body.block.new_cscope = true
+      body
     }
   }
   

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

@@ -1,85 +1,77 @@
 
 ::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::DeclareMemeBody = ::Myco::Component.new([::Myco.find_constant(:Block)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:DeclareMemeBody, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:name, [[:field, []]], 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
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::DeclareMeme = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:meme, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:decorations, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.effective_name.node_type.__send__(
+      :==,
+      :symbol
+    )) {(
       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::DeclareMeme = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:meme, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:decorations, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:parameters, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    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 => [],
-      :rest => ::Myco.find_constant(:RestParameter).new({:line => self.line})
-    })})}
-    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)
+      self.effective_name.bytecode(g)
+      self.effective_decorations.bytecode(g)
+      self.effective_body.bytecode(g)
       g.send(
         :declare_meme,
         3
       )
-    )}
-  )}}
-  .tap { |__c__| __c__.__name__ = :DeclareMeme }
-)})}}.instance
+    )}) {::Myco.find_constant(:ConstantAssignment).new({
+      :line => self.line,
+      :constant => self.effective_name,
+      :value => self.effective_body.block.body
+    }).bytecode(g)}
+  )}
+  declare_meme(:effective_name, [], nil, ::Myco.cscope.dup) { |*| (self.decorations.last)}
+  declare_meme(:effective_decorations, [], nil, ::Myco.cscope.dup) { |*| (
+    decorations = self.decorations.__send__(
+      :[],
+      ::Myco.find_constant(:Ruby)::Range.new(
+        0,
+        -1,
+        true
+      )
+    )
+    ::Myco.find_constant(:ArrayAssembly).new({
+      :line => self.line,
+      :body => decorations.reverse.map { |d| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", d.node_type.__send__(
+        :==,
+        :invoke
+      )) {::Myco.find_constant(:ArrayAssembly).new({
+        :line => d.line,
+        :body => [
+          ::Myco.find_constant(:SymbolLiteral).new({
+            :line => d.line,
+            :value => d.name
+          }),
+          ::Myco.find_constant(:ArrayAssembly).new({
+            :line => d.line,
+            :body => d.arguments.body
+          })
+        ]
+      })}) {d})}
+    })
+  )}
+  declare_meme(:effective_body, [], nil, ::Myco.cscope.dup) { |*| (
+    body = ::Myco.branch_op(:"||", self.body) {::Myco.find_constant(:BlockLiteral).new({
+      :line => self.line,
+      :block => ::Myco.find_constant(:Block).new({
+        :line => self.line,
+        :body => ::Myco.find_constant(:NullLiteral).new({:line => self.line})
+      })
+    })}
+    body.block.__send__(
+      :new_cscope=,
+      true
+    )
+    body
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :DeclareMeme })})}}.instance

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

@@ -238,25 +238,22 @@ CodeTools::AST << {
   
   DeclareMeme << {
     to_ruby: |g| {
-      g.with_nested_var_scope(body_implementation) {
-        g.var_scope_declare_locals(*self.parameters.names)
-        
+      name = self.decorations.last
+      name.node_type == :symbol &? (
         g.add("declare_meme(")
-        g.add(""self.name.inspect", ")
-        g.add(self.decorations); g.add(", nil, ::Myco.cscope.dup)")
-        g.add(" { ");
-          g.add(self.parameters); g.add(" ")
-          g.add(self.body);
-        g.add("}")
-      }
-    }
-  }
-  
-  DeclareDecorator << {
-    to_ruby: |g| {
-      g.add("["self.name.value.inspect", [")
-        g.list(self.arguments.body, ",", auto_lines:true)
-      g.add("]]")
+          g.list([
+            self.effective_name
+            self.effective_decorations
+            self.effective_body
+          ], ",", auto_lines: true)
+        g.add(")")
+      ) ?? (
+        g.add(ConstantAssignment.new(
+          line:     self.line
+          constant: self.effective_name
+          value:    self.effective_body.block.body
+        ))
+      )
     }
   }
   
@@ -351,9 +348,9 @@ CodeTools::AST << {
   Block << {
     to_ruby: |g| {
       g.with_nested_var_scope(self) {
-        g.var_scope_declare_locals(*self.parameters.names)
+        g.var_scope_declare_locals(*self.effective_parameters.names)
         
-        g.add(" "); g.add(self.parameters); g.add(" "); g.add(self.body)
+        g.add(" "); g.add(self.effective_parameters); g.add(" "); g.add(self.body)
       }
     }
   }