myco 0.1.3 → 0.1.4

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

@@ -91,31 +91,51 @@
   ::Myco.find_constant(:VoidLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("::Myco::Void"))})}
   ::Myco.find_constant(:TrueLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("true"))})}
   ::Myco.find_constant(:FalseLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("false"))})}
-  ::Myco.find_constant(:StringLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.string.inspect))})}
+  ::Myco.find_constant(:StringLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.value.inspect))})}
   ::Myco.find_constant(:SymbolLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.value.inspect))})}
   ::Myco.find_constant(:DynamicString).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    inspect_escape = ::Myco.find_constant(:Proc).new { |str| (str.inspect.slice(::Range.new(
-      1,
-      -2
-    )))}
     g.add("\"")
-    g.add(inspect_escape.call(self.string))
-    self.array.each_slice(2) { |interpolated, inner_string| (
-      g.add("\#{")
-      g.add(interpolated.value)
-      g.add("}")
-      g.add(inspect_escape.call(inner_string.value))
+    self.body.each_slice(2) { |string, to_string| (
+      g.add(string.value.to_s.inspect.slice(::Range.new(
+        1,
+        -2
+      )))
+      ::Myco.branch_op(:"&&", to_string) {(
+        g.add("\#{")
+        g.add(to_string)
+        g.add("}")
+      )}
     )}
     g.add("\"")
   )})}
   ::Myco.find_constant(:DynamicSymbol).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add(":")
-    ::Myco.find_constant(:DynamicString).instance_method(:to_ruby).bind(self).call(g)
+    g.add(":\"")
+    self.body.each_slice(2) { |string, to_string| (
+      g.add(string.value.to_s.inspect.slice(::Range.new(
+        1,
+        -2
+      )))
+      ::Myco.branch_op(:"&&", to_string) {(
+        g.add("\#{")
+        g.add(to_string)
+        g.add("}")
+      )}
+    )}
+    g.add("\"")
+  )})}
+  ::Myco.find_constant(:ArrayAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+    g.add("[")
+    g.list(
+      self.body,
+      ",",
+      {:auto_lines => true}
+    )
+    g.add("]")
   )})}
-  ::Myco.find_constant(:HashLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:KeywordAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add("{")
     g.list(
-      self.array.each_slice(2).to_a,
+      self.body.each_slice(2).to_a,
       ",",
       {:auto_lines => true}
     ) { |pair| (g.add(
@@ -125,60 +145,35 @@
     ))}
     g.add("}")
   )})}
-  ::Myco.find_constant(:ArrayAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("[")
-    g.list(
-      self.body,
-      ",",
-      {:auto_lines => true}
-    )
-    g.add("]")
+  ::Myco.find_constant(:ConstantAccess).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+    name_list = self.names.map(&:to_sym)
+    first_name = name_list.shift
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {g.add("::#{first_name}")}) {g.add("::Myco.find_constant(#{first_name.inspect})")}
+    name_list.each { |name| (g.add("::#{name}"))}
+  )})}
+  ::Myco.find_constant(:ConstantAssignment).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+    name_list = self.constant.names.map(&:to_sym)
+    last_name = name_list.pop
+    first_name = ::Myco.branch_op(:"&&", name_list.__send__(:any?)) {name_list.shift}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"&&", first_name) {g.add("::#{first_name}")}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {g.add("::Myco.find_constant(#{first_name.inspect})")}) {g.add("::Myco.cscope.for_method_definition")}}
+    name_list.each { |name| (g.add("::#{name}"))}
+    g.add("::#{last_name} = ")
+    g.add(self.value)
   )})}
-  ::Myco.find_constant(:ScopedConstant).component_eval {(
-    declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-      g.add(self.parent)
-      g.add("::#{self.name}")
-    )}
-    declare_meme(:to_ruby_assign, [], nil, ::Myco.cscope.dup) { |g, value| (
-      self.to_ruby(g)
-      g.add(" = ")
-      g.add(value)
-    )}
-  )}
-  ::Myco.find_constant(:ToplevelConstant).component_eval {(
-    declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("::#{self.name}"))}
-    declare_meme(:to_ruby_assign, [], nil, ::Myco.cscope.dup) { |g, value| (
-      self.to_ruby(g)
-      g.add(" = ")
-      g.add(value)
-    )}
-  )}
-  ::Myco.find_constant(:ConstantAccess).component_eval {(
-    declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("::Myco.find_constant(#{self.name.inspect})"))}
-    declare_meme(:to_ruby_assign, [], nil, ::Myco.cscope.dup) { |g, value| (
-      g.add("::Myco.cscope.for_method_definition.const_set(#{self.name.inspect}, ")
-      g.add(value)
-      g.add(")")
-    )}
-  )}
-  ::Myco.find_constant(:ConstantAssignment).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (self.constant.to_ruby_assign(
-    g,
-    self.value
-  ))})}
   ::Myco.find_constant(:ConstantDefine).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add(self.implementation)
     g.line(".tap { |__c__| __c__.__name__ = ")
-    g.add(self.name.name.inspect)
+    g.add(self.constant.names.last.inspect)
     g.add(" }")
   )})}
   ::Myco.find_constant(:ConstantReopen).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add(self.name)
+    g.add(self.constant)
     g.add(".component_eval {")
     g.add(self.body)
     g.add("}")
   )})}
   ::Myco.find_constant(:MycoModuleScope).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (g.add(self.body))})})}
-  ::Myco.find_constant(:EvalExpression).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.body))})}
+  ::Myco.find_constant(:Script).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.body))})}
   ::Myco.find_constant(:DeclareFile).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.line
     self.implementation.to_ruby(g)
@@ -195,19 +190,19 @@
   )})}
   ::Myco.find_constant(:DeclareString).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.implementation))})}
   ::Myco.find_constant(:DeclareCategory).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("__category__(#{self.name.value.inspect})")
+    g.add("__category__(#{self.name.inspect})")
     g.add(".component_eval {")
     g.add(self.body)
     g.add("}")
   )})}
   ::Myco.find_constant(:DeclareMeme).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self.body_implementation) { || (
-    g.var_scope_declare_locals(*self.arguments.names)
+    g.var_scope_declare_locals(*self.parameters.names)
     g.add("declare_meme(")
     g.add("#{self.name.inspect}, ")
     g.add(self.decorations)
     g.add(", nil, ::Myco.cscope.dup)")
     g.add(" { ")
-    g.add(self.arguments)
+    g.add(self.parameters)
     g.add(" ")
     g.add(self.body)
     g.add("}")
@@ -217,11 +212,12 @@
     g.add(self.arguments)
     g.add("]")
   )})}
-  ::Myco.find_constant(:Parameters).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:BlockParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("&#{self.name}"))})}
+  ::Myco.find_constant(:ParameterAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     list = []
     list_add = ::Myco.find_constant(:Proc).new { |&blk| (list.push(::Myco.find_constant(:Proc).new(&blk)))}
     self.required.each { |item| (list_add.call { || (g.add(item.to_s))})}
-    ::Myco.branch_op(:"&?", self.defaults) {self.defaults.arguments.each { |asgn| (
+    self.optional.each { |asgn| (
       name = asgn.name
       value = asgn.value
       list_add.call { || (
@@ -234,32 +230,31 @@
           :*
         )}) {g.add(value)}
       )}
-    )}}
+    )}
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.splat.__send__(
       :==,
-      :*
+      true
     )) {list_add.call { || (g.add("*"))}}) {::Myco.branch_op(:"&?", self.splat) {list_add.call { || (g.add("*#{self.splat}"))}}}
-    ::Myco.branch_op(:"&?", self.keywords) {(
-      self.keywords.arguments.each { |asgn| (
-        name = asgn.name
-        value = asgn.value
-        list_add.call { || (
-          g.add("#{name}:")
-          ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", value.__send__(
-            :is_a?,
-            ::Myco.find_constant(:SymbolLiteral)
-          )) {value.value.__send__(
-            :==,
-            :*
-          )}) {g.add(value)}
-        )}
+    self.post.each { |item| (list_add.call { || (g.add(item.to_s))})}
+    self.kwargs.each { |asgn| (
+      name = asgn.name
+      value = asgn.value
+      list_add.call { || (
+        g.add("#{name}:")
+        ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", value.__send__(
+          :is_a?,
+          ::Myco.find_constant(:SymbolLiteral)
+        )) {value.value.__send__(
+          :==,
+          :*
+        )}) {g.add(value)}
       )}
-      ::Myco.branch_op(:"&?", ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.keywords.kwrest.__send__(
-        :==,
-        true
-      )) {list_add.call { || (g.add("**"))}}) {self.keywords.kwrest}) {list_add.call { || (g.add("**#{self.keywords.kwrest.name}"))}}
     )}
-    ::Myco.branch_op(:"&?", self.block_arg) {list_add.call { || (g.add("&#{self.block_arg.name}"))}}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.kwrest.__send__(
+      :==,
+      true
+    )) {list_add.call { || (g.add("**"))}}) {::Myco.branch_op(:"&?", self.kwrest) {list_add.call { || (g.add("**#{self.kwrest}"))}}}
+    ::Myco.branch_op(:"&&", self.block) {list_add.call { || (g.add(self.block))}}
     g.add("|")
     g.list(
       list,
@@ -267,7 +262,7 @@
     ) { |proc| (proc.call)}
     g.add("|")
   )})}
-  ::Myco.find_constant(:Block).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:Body).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add("(")
     g.list(
       self.array,
@@ -281,7 +276,7 @@
     list = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.arguments) {self.arguments.body.dup}) {[]}
     ::Myco.branch_op(:"&&", self.arguments.block.__send__(
       :is_a?,
-      ::Myco.find_constant(:BlockPass)
+      ::Myco.find_constant(:BlockArgument)
     )) {list.push(self.arguments.block)}
     g.add(self.receiver)
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
@@ -289,10 +284,10 @@
       self.name
     )) {g.add(".#{self.name}")}) {(
       g.add(".__send__")
-      list.unshift(::Myco.find_constant(:SymbolLiteral).new(
-        self.line,
-        self.name
-      ))
+      list.unshift(::Myco.find_constant(:SymbolLiteral).new({
+        :line => self.line,
+        :value => self.name
+      }))
     )}
     ::Myco.branch_op(:"&&", list.__send__(:any?)) {(
       g.add("(")
@@ -305,7 +300,7 @@
     )}
     ::Myco.branch_op(:"&&", self.arguments.block.__send__(
       :is_a?,
-      ::Myco.find_constant(:Iter)
+      ::Myco.find_constant(:BlockLiteral)
     )) {(
       g.add(" {")
       g.add(self.arguments.block)
@@ -340,17 +335,14 @@
     g.add("*")
     self.value.to_ruby(g)
   )})})}
-  ::Myco.find_constant(:CollectSplat).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| nil})}
-  ::Myco.find_constant(:ConcatArgs).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| nil})}
-  ::Myco.find_constant(:PushArgs).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| nil})}
-  ::Myco.find_constant(:BlockPass).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:BlockArgument).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add("&")
     g.add(self.body)
   )})}
-  ::Myco.find_constant(:Iter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (
-    g.var_scope_declare_locals(*self.arguments.names)
+  ::Myco.find_constant(:BlockLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (
+    g.var_scope_declare_locals(*self.parameters.names)
     g.add(" ")
-    g.add(self.arguments)
+    g.add(self.parameters)
     g.add(" ")
     g.add(self.body)
   )})})}
@@ -376,8 +368,4 @@
     g.add(self.right)
     g.add("}")
   )})}
-  ::Myco.find_constant(:Return).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("return ")
-    g.add(self.value)
-  )})}
 )})}}.instance

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

@@ -0,0 +1,57 @@
+
+CodeTools::AST << {
+  
+  # Helper methods for bytecode generation
+  ::CodeTools::Generator << {
+    push_myco: push_cpath_top; find_const(:"Myco")
+    push_void: push_myco;      find_const(:"Void")
+    push_null: push_nil
+  }
+  
+  Self < Node {
+    Form: [:self]
+    bytecode: |g| pos(g); g.push_self
+  }
+  
+  NullLiteral < Node {
+    Form: [:null]
+    bytecode: |g| pos(g); g.push_null
+  }
+  
+  VoidLiteral < Node {
+    Form: [:void]
+    bytecode: |g| pos(g); g.push_void
+  }
+  
+  TrueLiteral < Node {
+    Form: [:true]
+    bytecode: |g| pos(g); g.push_true
+  }
+  
+  FalseLiteral < Node {
+    Form: [:false]
+    bytecode: |g| pos(g); g.push_false
+  }
+  
+  # TODO: use some other way to be eager
+  EVALUATE_NOW: ::CodeTools::AST.component_eval {
+    constants.select |const_name| {
+      const_get(const_name).constants.include?(:"Form")
+      }.each |const_name| {
+        component = const_get(const_name)
+        form = component.const_get(:"Form").dup
+        form_name = form.shift
+        
+        BuilderMethods.declare_meme(form_name) |*args| {
+          inst = component.new
+          loc = args.shift
+          inst.line = loc.line
+          form.zip(args).each |key, value| {
+            inst.send(:""key"=", value)
+          }
+          inst
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,81 @@
+
+::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 {(
+  ::CodeTools::Generator.component_eval {(
+    declare_meme(:push_myco, [], nil, ::Myco.cscope.dup) { |*| (
+      self.push_cpath_top
+      self.find_const(:Myco)
+    )}
+    declare_meme(:push_void, [], nil, ::Myco.cscope.dup) { |*| (
+      self.push_myco
+      self.find_const(:Void)
+    )}
+    declare_meme(:push_null, [], nil, ::Myco.cscope.dup) { |*| (self.push_nil)}
+  )}
+  ::Myco.cscope.for_method_definition.const_set(:Self, ::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, ([:self]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_self
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :Self }
+  ::Myco.cscope.for_method_definition.const_set(:NullLiteral, ::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, ([:null]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_null
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :NullLiteral }
+  ::Myco.cscope.for_method_definition.const_set(:VoidLiteral, ::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, ([:void]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_void
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :VoidLiteral }
+  ::Myco.cscope.for_method_definition.const_set(:TrueLiteral, ::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, ([:true]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_true
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :TrueLiteral }
+  ::Myco.cscope.for_method_definition.const_set(:FalseLiteral, ::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, ([:false]))
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.pos(g)
+      g.push_false
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :FalseLiteral }
+  ::Myco.cscope.for_method_definition.const_set(:EVALUATE_NOW, (::CodeTools::AST.component_eval { || (self.constants.select { |const_name| (self.const_get(const_name).constants.__send__(
+    :include?,
+    :Form
+  ))}.each { |const_name| (
+    component = self.const_get(const_name)
+    form = component.const_get(:Form).dup
+    form_name = form.shift
+    ::Myco.find_constant(:BuilderMethods).declare_meme(form_name) { |*args| (
+      inst = component.new
+      loc = args.shift
+      inst.__send__(
+        :line=,
+        loc.line
+      )
+      form.zip(args).each { |key, value| (inst.send(
+        :"#{key}=",
+        value
+      ))}
+      inst
+    )}
+  )})}))
+)})}}.instance

data/lib/myco/code_tools/AST.my

@@ -0,0 +1,52 @@
+
+CodeTools::AST << {
+  BuilderMethods: Module.new { } # TODO: move out of this file
+}
+
+import 'AST/Node.my'
+
+import 'AST/Script.my'
+
+import 'AST/StringLiteral.my'
+import 'AST/SymbolLiteral.my'
+import 'AST/DynamicString.my'
+import 'AST/DynamicSymbol.my'
+
+import 'AST/Body.my'
+
+import 'AST/SplatValue.my'
+import 'AST/ArrayAssembly.my'
+import 'AST/KeywordAssembly.my'
+import 'AST/ArgumentAssembly.my'
+import 'AST/BlockArgument.my'
+import 'AST/BlockLiteral.my'
+
+import 'AST/BlockParameter.my'
+import 'AST/ParameterAssembly.my'
+
+import 'AST/MycoModuleScope.my'
+
+import 'AST/ConstantAccess.my'
+import 'AST/ConstantAssignment.my'
+import 'AST/ConstantDefine.my'
+import 'AST/ConstantReopen.my'
+import 'AST/DeclareCategory.my'
+import 'AST/DeclareDecorator.my'
+import 'AST/DeclareFile.my'
+import 'AST/DeclareMeme.my'
+import 'AST/DeclareObject.my'
+import 'AST/DeclareString.my'
+
+import 'AST/Invoke.my'
+import 'AST/InvokeMethod.my'
+import 'AST/LocalVariableAccessAmbiguous.my'
+import 'AST/LocalVariableAssignment.my'
+import 'AST/BlockLiteral.my'
+
+import 'AST/Quest.my'
+import 'AST/BranchOperator.my'
+
+# TODO: refactor and break out misc
+import "AST/misc.my"
+
+import 'AST/ToRuby.my'

data/lib/myco/code_tools/AST.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(:BuilderMethods, (::Myco.find_constant(:Module).new { || nil})))}
+  declare_meme(:"AST/Node.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/Script.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/StringLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/SymbolLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/DynamicString.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/DynamicSymbol.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/Body.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/SplatValue.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ArrayAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/KeywordAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ArgumentAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/BlockArgument.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/BlockLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/BlockParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ParameterAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/MycoModuleScope.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ConstantAccess.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ConstantAssignment.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ConstantDefine.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ConstantReopen.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/DeclareFile.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/DeclareMeme.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/DeclareObject.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/DeclareString.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}
+  declare_meme(:"AST/LocalVariableAccessAmbiguous.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/LocalVariableAssignment.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/BlockLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/Quest.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/BranchOperator.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/misc.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/ToRuby.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+)}}.instance