myco 0.1.6 → 0.1.7

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

@@ -91,12 +91,13 @@
   ::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(:NumericLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.value.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| (
+  ::Myco.find_constant(:StringCompose).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add("\"")
     self.body.each_slice(2) { |string, to_string| (
-      g.add(string.value.to_s.inspect.slice(::Range.new(
+      g.add(string.value.to_s.inspect.slice(::Myco.find_constant(:Range).new(
         1,
         -2
       )))
@@ -108,10 +109,10 @@
     )}
     g.add("\"")
   )})}
-  ::Myco.find_constant(:DynamicSymbol).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:SymbolCompose).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add(":\"")
     self.body.each_slice(2) { |string, to_string| (
-      g.add(string.value.to_s.inspect.slice(::Range.new(
+      g.add(string.value.to_s.inspect.slice(::Myco.find_constant(:Range).new(
         1,
         -2
       )))
@@ -148,14 +149,32 @@
   ::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})")}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
+      first_name,
+      :Myco,
+      ::Proc.new { || (g.add("::Myco"))},
+      :Ruby,
+      ::Proc.new { || (g.add("::Object"))},
+      :Rubinius,
+      ::Proc.new { || (g.add("::Rubinius"))},
+      ::Proc.new { || (g.add("::Myco::#{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")}}
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
+      first_name,
+      :Myco,
+      ::Proc.new { || (g.add("::Myco"))},
+      :Ruby,
+      ::Proc.new { || (g.add("::Object"))},
+      :Rubinius,
+      ::Proc.new { || (g.add("::Rubinius"))},
+      ::Proc.new { || (g.add("::Myco::#{first_name}"))}
+    )}) {g.add("::Myco")}}) {::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)
@@ -166,13 +185,13 @@
     g.add(self.constant.names.last.inspect)
     g.add(" }")
   )})}
-  ::Myco.find_constant(:ConstantReopen).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:DeclareExtension).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     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(:DeclaredScope).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (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
@@ -216,54 +235,25 @@
     )
     g.add("]]")
   )})}
+  ::Myco.find_constant(:RequiredParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("#{self.name}"))})}
+  ::Myco.find_constant(:OptionalParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+    g.add("#{self.name}=")
+    g.add(self.value)
+  )})}
+  ::Myco.find_constant(:RestParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("*#{self.name}"))})}
+  ::Myco.find_constant(:KeywordRequiredParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("#{self.name}:"))})}
+  ::Myco.find_constant(:KeywordOptionalParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+    g.add("#{self.name}:")
+    g.add(self.value)
+  )})}
+  ::Myco.find_constant(:KeywordRestParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("**#{self.name}"))})}
   ::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))})}
-    self.optional.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(:"&?", self.splat.__send__(
-      :==,
-      true
-    )) {list_add.call { || (g.add("*"))}}) {::Myco.branch_op(:"&?", self.splat) {list_add.call { || (g.add("*#{self.splat}"))}}}
-    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(:"&?", 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,
+      self.all_params,
       ", "
-    ) { |proc| (proc.call)}
+    )
     g.add("|")
   )})}
   ::Myco.find_constant(:Sequence).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
@@ -358,8 +348,9 @@
       self.receiver
     )
     g.add("(")
+    g.add("Rubinius::Type.object_respond_to?(")
     g.add(self.receiver)
-    g.add(".respond_to?(#{self.questable.name.inspect}).false?")
+    g.add(", #{self.questable.name.inspect}).false?")
     g.add(" ? ::Myco::Void : ")
     g.add(associated_questable)
     g.add(")")

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

@@ -2,55 +2,50 @@
 CodeTools::AST << {
   
   # Helper methods for bytecode generation
-  ::CodeTools::Generator << {
-    push_myco: push_cpath_top; find_const(:"Myco")
-    push_void: push_myco;      find_const(:"Void")
+  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]
+    node_type self
     bytecode: |g| pos(g); g.push_self
   }
   
   NullLiteral < Node {
-    Form: [:null]
+    node_type null
     bytecode: |g| pos(g); g.push_null
   }
   
   VoidLiteral < Node {
-    Form: [:void]
+    node_type void
     bytecode: |g| pos(g); g.push_void
   }
   
   TrueLiteral < Node {
-    Form: [:true]
+    node_type true
     bytecode: |g| pos(g); g.push_true
   }
   
   FalseLiteral < Node {
-    Form: [:false]
+    node_type false
     bytecode: |g| pos(g); g.push_false
   }
   
   # TODO: use some other way to be eager
-  EVALUATE_NOW: ::CodeTools::AST.component_eval {
+  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
-        }
+      const_get(const_name).?node_type ?? null
+    }.each |const_name| {
+      component = const_get(const_name)
+      node_type = component.node_type
+      fields    = component.fields
+      
+      BuilderMethods.declare_meme(node_type) |*args| {
+        loc = args.shift
+        kw = [:line, *fields].zip([loc.line, *args])
+        component.new(kw.to_h)
       }
     }
   }

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

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

data/lib/myco/code_tools/AST.my

@@ -8,10 +8,12 @@ import 'AST/Node.my'
 
 import 'AST/Script.my'
 
+import 'AST/NumericLiteral.my'
 import 'AST/StringLiteral.my'
 import 'AST/SymbolLiteral.my'
-import 'AST/DynamicString.my'
-import 'AST/DynamicSymbol.my'
+
+import 'AST/StringCompose.my'
+import 'AST/SymbolCompose.my'
 
 import 'AST/Sequence.my'
 
@@ -22,23 +24,30 @@ import 'AST/ArgumentAssembly.my'
 import 'AST/BlockArgument.my'
 import 'AST/Block.my'
 
+import 'AST/RequiredParameter.my'
+import 'AST/OptionalParameter.my'
+import 'AST/RestParameter.my'
+import 'AST/KeywordRequiredParameter.my'
+import 'AST/KeywordOptionalParameter.my'
+import 'AST/KeywordRestParameter.my'
 import 'AST/BlockParameter.my'
 import 'AST/ParameterAssembly.my'
 
 import 'AST/BlockLiteral.my'
 
-import 'AST/MycoModuleScope.my'
-
 import 'AST/ConstantAccess.my'
 import 'AST/ConstantAssignment.my'
 import 'AST/ConstantDefine.my'
-import 'AST/ConstantReopen.my'
+
+import 'AST/DeclaredScope.my'
+import 'AST/DeclareObject.my'
+import 'AST/DeclareString.my'
+import 'AST/DeclareFile.my'
+import 'AST/DeclareExtension.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'

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

@@ -12,10 +12,11 @@
   )}
   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/NumericLiteral.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/StringCompose.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/SymbolCompose.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/Sequence.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}
@@ -23,20 +24,26 @@
   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/Block.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/RequiredParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/OptionalParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/RestParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/KeywordRequiredParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/KeywordOptionalParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/KeywordRestParameter.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/BlockLiteral.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/DeclaredScope.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/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/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}

data/lib/myco/code_tools/Parser.my

@@ -1,6 +1,6 @@
 
 # TODO: include Pegleromyces library in a better way than clone into subdir
-import as(:"Pegleromyces") 'parser/pegleromyces/lib/pegleromyces.my'
+import as(:Pegleromyces) 'parser/pegleromyces/lib/pegleromyces.my'
 
 # TODO: remove this hack
 ::Myco::Pegleromyces: Pegleromyces

data/lib/myco/code_tools/parser/MycoBuilder.my

@@ -1,11 +1,11 @@
 
 BasicObject {
   # TODO: be more clever here
-  ASTBuilder: ::CodeTools::AST::Builder.new
+  ASTBuilder: CodeTools::AST::Builder.new
   var ast: ASTBuilder
   
   var escape_encodings: {
-    hash = Hash.new
+    hash = ::Ruby::Hash.new
     hash["\\a"] =  7.chr # \a  0x07  Bell or alert
     hash["\\b"] =  8.chr # \b  0x08  Backspace
     # TODO:              # \cx       Control-x
@@ -51,7 +51,7 @@ BasicObject {
         
         result = block
           &? block.call(n0,op,n1)
-          ?? ast.invoke(op, n0, op.sym, ast.argass(n1, [n1]))
+          ?? ast.invoke(op, n0, op.sym, ast.args(n1, [n1]))
         input.unshift(result)
       ) ?? (
         output.push(n0)

data/lib/myco/code_tools/parser/MycoBuilder.my.rb

@@ -2,10 +2,10 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.cscope.for_method_definition::ASTBuilder = (::CodeTools::AST::Builder.new)
+  ::Myco.cscope.for_method_definition::ASTBuilder = (::Myco.find_constant(:CodeTools)::AST::Builder.new)
   declare_meme(:ast, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ASTBuilder))}
   declare_meme(:escape_encodings, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (
-    hash = ::Myco.find_constant(:Hash).new
+    hash = ::Ruby::Hash.new
     hash.__send__(
       :[]=,
       "\\a",
@@ -82,7 +82,7 @@
           op,
           n0,
           op.sym,
-          self.ast.argass(
+          self.ast.args(
             n1,
             [n1]
           )