myco 0.1.9 → 0.1.10

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

@@ -2,25 +2,45 @@
 ::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::DeclareString = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:declstr, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:types, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:string, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  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({
+  declare_meme(
+    :declstr,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :types,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :string,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :implementation,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:InvokeMethod).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)
-  )}
+      :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,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.implementation.bytecode(g)
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclareString })})}}.instance

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

@@ -5,73 +5,101 @@
   ::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(:scope_method, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    g.state.scope.nest_scope(self)
-    name = :__declaration__
-    meth = self.new_generator(
-      g,
-      name
-    )
-    meth.push_state(self)
-    meth.__send__(
-      :for_module_body=,
-      true
-    )
-    meth.push_self
-    meth.add_scope
-    meth.state.push_name(name.to_sym)
-    ::Myco.branch_op(:"&&", self.scope_method) {(
-      meth.push_scope
-      meth.send(
-        self.scope_method,
-        0
+  declare_meme(
+    :name,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :scope_method,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      g.state.scope.nest_scope(self)
+      name = :__declaration__
+      meth = self.new_generator(
+        g,
+        name
       )
-      meth.pop
-    )}
-    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(: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
+      meth.push_state(self)
+      meth.__send__(
+        :for_module_body=,
+        true
+      )
+      meth.push_self
+      meth.add_scope
+      meth.state.push_name(name.to_sym)
+      ::Myco.branch_op(:"&&", self.scope_method) {(
+        meth.push_scope
+        meth.send(
+          self.scope_method,
+          0
         )
+        meth.pop
+      )}
+      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
       )
-      reference
+      meth.pop_state
+      g.create_block(meth)
+      g.swap
+      g.push_scope
+      g.push_true
+      g.send(
+        :call_under,
+        3
+      )
+      meth
+    )}
+  )
+  declare_meme(
+    :nest_scope,
+    [],
+    ::Object::Proc.new { |scope| (scope.__send__(
+      :parent=,
+      self
+    ))}
+  )
+  declare_meme(
+    :parent,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :search_local,
+    [],
+    ::Object::Proc.new { |name| (
+      reference = self.parent.search_local(name)
+      ::Myco.branch_op(:"&&", reference) {(
+        reference.__send__(
+          :depth=,
+          reference.depth.__send__(
+            :+,
+            1
+          )
+        )
+        reference
+      )}
     )}
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :DeclaredScope })})}}.instance

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

@@ -18,10 +18,14 @@ CodeTools::AST << {
       )
       
       !self.receiver && !use_args &? (
-        LocalVariableAccessAmbiguous.new(
-          line: self.line
-          name: self.name
-        )
+              (self.name == :self)  &? (Self        .new(line: self.line)
+        ) ?? ((self.name == :null)  &? (NullLiteral .new(line: self.line)
+        ) ?? ((self.name == :void)  &? (VoidLiteral .new(line: self.line)
+        ) ?? ((self.name == :true)  &? (TrueLiteral .new(line: self.line)
+        ) ?? ((self.name == :false) &? (FalseLiteral.new(line: self.line)
+        ) ?? (
+          LocalVariableAccessAmbiguous.new(line: self.line, name: self.name)
+        )))))
       ) ?? (
         InvokeMethod.new(
           line:      self.line

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

@@ -2,39 +2,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::Invoke = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:invoke, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:receiver, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:arguments, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:block, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    self.implementation.bytecode(g)
-  )}
-  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (
-    use_args = self.arguments
-    ::Myco.branch_op(:"&&", self.block) {(
-      use_args = ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", use_args) {use_args.dup}) {::Myco.find_constant(:ArgumentAssembly).new({
-        :line => self.line,
-        :body => []
-      })}
-      use_args.__send__(
-        :block=,
-        self.block
-      )
+  declare_meme(
+    :invoke,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :receiver,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :name,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :arguments,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :block,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.implementation.bytecode(g)
     )}
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:!)) {use_args.__send__(:!)}) {::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(:"||", use_args) {::Myco.find_constant(:ArgumentAssembly).new({
+  )
+  declare_meme(
+    :implementation,
+    [],
+    ::Object::Proc.new { |*| (
+      use_args = self.arguments
+      ::Myco.branch_op(:"&&", self.block) {(
+        use_args = ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", use_args) {use_args.dup}) {::Myco.find_constant(:ArgumentAssembly).new({
+          :line => self.line,
+          :body => []
+        })}
+        use_args.__send__(
+          :block=,
+          self.block
+        )
+      )}
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:!)) {use_args.__send__(:!)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.name.__send__(
+        :==,
+        :self
+      )) {::Myco.find_constant(:Self).new({:line => self.line})}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.name.__send__(
+        :==,
+        :null
+      )) {::Myco.find_constant(:NullLiteral).new({:line => self.line})}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.name.__send__(
+        :==,
+        :void
+      )) {::Myco.find_constant(:VoidLiteral).new({:line => self.line})}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.name.__send__(
+        :==,
+        :true
+      )) {::Myco.find_constant(:TrueLiteral).new({:line => self.line})}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.name.__send__(
+        :==,
+        :false
+      )) {::Myco.find_constant(:FalseLiteral).new({:line => self.line})}) {::Myco.find_constant(:LocalVariableAccessAmbiguous).new({
         :line => self.line,
-        :body => []
+        :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(:"||", use_args) {::Myco.find_constant(:ArgumentAssembly).new({
+          :line => self.line,
+          :body => []
+        })}
       })}
-    })}
-  )}
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :Invoke })})}}.instance

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

@@ -2,19 +2,39 @@
 ::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::InvokeMethod = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:call, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:receiver, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:arguments, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  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
-    )
-  )}
+  declare_meme(
+    :call,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :receiver,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :name,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :arguments,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |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.rb

@@ -2,32 +2,44 @@
 ::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::KeywordAssembly = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:hash, [[:node_type, []]], 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)
-    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(
-        :[]=,
+  declare_meme(
+    :hash,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |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
       )
-      g.pop
+      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