myco 0.1.6 → 0.1.7

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

@@ -2,13 +2,9 @@
 ::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::ConstantDefine = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:constant, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:object, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :cdefn,
-    :constant,
-    :object
-  ])
+  declare_meme(:cdefn, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:constant, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:object, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstantAssignment).new({
     :line => self.line,
     :constant => self.constant,

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

@@ -1,24 +1,14 @@
 
 CodeTools::AST << {
   
-  DeclareCategoryScope < MycoModuleScope {
-    body_bytecode: |g| {
-      g.push_scope
-      g.send(:set_myco_category, 0)
-      g.pop
-      
-      self.body.bytecode(g)
-    }
-  }
-  
   DeclareCategory < Node {
-    var name, var body
-    
-    Form: [:category, :name, :body]
+    node_type category
+    field name, field body
     
-    scope_implementation: DeclareCategoryScope.new(
+    scope_implementation: DeclaredScope.new(
       line: self.line
       body: self.body
+      scope_method: :set_myco_category
     )
     
     bytecode: |g| {

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

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

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

@@ -2,13 +2,12 @@
 CodeTools::AST << {
   
   DeclareDecorator < Node {
-    var name, var arguments
+    node_type deco
+    field name, field 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]

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

@@ -2,17 +2,13 @@
 ::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::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(:deco, [[:node_type, []]], 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(: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::Form = ([
-    :deco,
-    :name,
-    :arguments
-  ])
   declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ArrayAssembly).new({
     :line => self.line,
     :body => [

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

@@ -0,0 +1,22 @@
+
+CodeTools::AST << {
+  
+  DeclareExtension < Node {
+    node_type copen
+    field constant, field body
+    
+    bytecode: |g| {
+      pos(g)
+      
+      scope = DeclaredScope.new(
+        line: self.line
+        body: self.body
+        scope_method: :set_myco_component
+      )
+      
+      self.constant.bytecode(g)
+      scope.bytecode(g)
+    }
+  }
+  
+}

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

@@ -0,0 +1,19 @@
+
+::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::DeclareExtension = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:copen, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:constant, [[: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)
+    scope = ::Myco.find_constant(:DeclaredScope).new({
+      :line => self.line,
+      :body => self.body,
+      :scope_method => :set_myco_component
+    })
+    self.constant.bytecode(g)
+    scope.bytecode(g)
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :DeclareExtension })})}}.instance

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

@@ -1,30 +1,19 @@
 
 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]
+    node_type declfile
+    field 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"])
+      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.scope_implementation.scope_method = :set_myco_file
       decl
     }
     

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

@@ -1,53 +1,37 @@
 
 ::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::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
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::DeclareFile = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:declfile, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  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.scope_implementation.__send__(
+      :scope_method=,
+      :set_myco_file
     )
-    g.pop
-    self.body.bytecode(g)
-  )})}}
-  .tap { |__c__| __c__.__name__ = :DeclareFileScope }
-  ::Myco.cscope.for_method_definition::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::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
+    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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   DeclareMemeBody < Block {
-    var name
-    
-    Form: [:"DeclareMemeBody", :name] # To prevent it from masquerading as a Block TODO: remove
+    node_type "DeclareMemeBody" # To prevent it from masquerading as a Block TODO: remove
+    field name
     
     bytecode: |g| {
       pos(g)
@@ -41,16 +40,15 @@ CodeTools::AST << {
   }
   
   DeclareMeme < Node {
-    var name, var decorations, var parameters, var body
-    
-    Form: [:meme, :name, :decorations, :parameters, :body]
+    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:[], splat:true)
+      x || ParameterAssembly.new(line:line, required:[], rest:RestParameter.new(line:line))
     setter body: |x|
       x || NullLiteral.new(line:line)
     

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

@@ -3,11 +3,8 @@
 .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(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    ::Myco.cscope.for_method_definition::Form = ([
-      :DeclareMemeBody,
-      :name
-    ])
+    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)
@@ -46,17 +43,11 @@
   .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(: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::Form = ([
-      :meme,
-      :name,
-      :decorations,
-      :parameters,
-      :body
-    ])
+    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,
@@ -65,7 +56,7 @@
     declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |x| (::Myco.branch_op(:"||", x) {::Myco.find_constant(:ParameterAssembly).new({
       :line => self.line,
       :required => [],
-      :splat => true
+      :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({

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

@@ -1,36 +1,24 @@
 
 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]
+    node_type declobj
+    field types, field body
     
     var create: true
-    var scope_type: DeclareObjectScope
     
-    var scope_implementation: self.scope_type.new(
+    var scope_implementation: DeclaredScope.new(
       line: self.line
       body: self.body
+      scope_method: :set_myco_component
     )
     
     bytecode: |g| {
       pos(g)
       
       # ::Myco::Component.new types, parent, filename
-      g.push_cpath_top
-      g.find_const(:"Myco")
-      g.find_const(:"Component")
+      g.push_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

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

@@ -1,67 +1,49 @@
 
 ::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::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| (
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::DeclareObject = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:declobj, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:types, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:create, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (true)}
+  declare_meme(:scope_implementation, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:DeclaredScope).new({
+    :line => self.line,
+    :body => self.body,
+    :scope_method => :set_myco_component
+  }))}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.push_myco
+    g.find_const(:Component)
+    self.types.bytecode(g)
     g.push_scope
     g.send(
-      :set_myco_component,
+      :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
-    self.body.bytecode(g)
-  )})}}
-  .tap { |__c__| __c__.__name__ = :DeclareObjectScope }
-  ::Myco.cscope.for_method_definition::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::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
-      )}
+    ::Myco.branch_op(:"&&", self.create) {g.send(
+      :instance,
+      0
     )}
-  )}}
-  .tap { |__c__| __c__.__name__ = :DeclareObject }
-)})}}.instance
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :DeclareObject })})}}.instance

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   DeclareString < Node {
-    var types, var string
-    
-    Form: [:declstr, :types, :string]
+    node_type declstr
+    field types, field string
     
     implementation: InvokeMethod.new(
       line:      self.string.line

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

@@ -2,13 +2,9 @@
 ::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(:types, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :declstr,
-    :types,
-    :string
-  ])
+  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,

data/lib/myco/code_tools/AST/{MycoModuleScope.my → DeclaredScope.my}

@@ -1,9 +1,10 @@
 
 CodeTools::AST << {
   
-  # TODO: rename to something else
-  MycoModuleScope < CodeTools::Compiler::LocalVariables, Node {
+  # TODO: remove from AST nodes, as this is just common behavior and has nothing itself to do with syntax
+  DeclaredScope < CodeTools::Compiler::LocalVariables, Node {
     var name, var body
+    var scope_method
     
     bytecode: |g| {
       pos(g)
@@ -13,26 +14,26 @@ CodeTools::AST << {
       # (Necessary to pass local variables from above to memes below)
       g.state.scope.nest_scope(self)
       
-      attach_and_call(g, :__myco_module_init__, true)
-    }
-    
-    # TODO: figure out how to keep in sync with ClosedScope#attach_and_call impl
-    attach_and_call: |g, arg_name, scoped=false, pass_block=false| {
-      self.name = :"MycoModuleScope" # TODO: remove/fix
-      name = self.name || arg_name
+      # This name is arbitrary and is just for the benefit of backtraces
+      name = :__declaration__
+      
       meth = new_generator(g, name)
       
       meth.push_state(self)
       meth.for_module_body = true
       
-      scoped && (
-        meth.push_self
-        meth.add_scope
-      )
+      meth.push_self
+      meth.add_scope
       
       meth.state.push_name(name.to_sym)
       
-      body_bytecode(meth) # (@body.bytecode meth) in original implementation
+      self.scope_method && (
+        meth.push_scope
+        meth.send(self.scope_method, 0)
+        meth.pop
+      )
+      
+      self.body.bytecode(meth)
       
       meth.state.pop_name
       
@@ -53,8 +54,6 @@ CodeTools::AST << {
       meth
     }
     
-    body_bytecode: |g| self.body.bytecode(g)
-    
     # Become the AST scope parent of the given AST scope Node .
     # This is only for the benefit of LocalVariableAccessAmbiguous
     # being able to call search_local, and has nothing to do with