myco 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7120707eb3cf4f2630bbda7bddbf88a64956cb9
-  data.tar.gz: 6fe624e6aab7c551c6b9d313acc7dcdf9c37eeff
+  metadata.gz: bc50c42ea202118c68b826111198d91b40615181
+  data.tar.gz: 3a7b9505f106be896c06b78e8398bfa6bff9c89a
 SHA512:
-  metadata.gz: 90a9b6c2b8c7d9523cb71d9740e314c743565d9a9128c8c7bd273335be190fc87f76e45b82fec69f0a530bb24342ba60d11a1ca8d14b3bc4784945454408aa83
-  data.tar.gz: 771063aed886cd75ea2a88cf1d5222f04a5a2fa49bbd55e2497bb9e1453a3df2f4de034ca055adc8bcc7dec88d2a4a69b6ef7ff1e376248d705f8dda22763a83
+  metadata.gz: 13d8580696387328fbe7ff490a8005d5f6112bcd0854f9a2d887be015b7d436141f3c86f57ad3d51818e560000696adffc374f0c0aa48dd0d534105b47606d63
+  data.tar.gz: 1b8a255e325b29af1be99af379ef2d7788576734a2521f1f9f1f5cea3ec972511a26506a41bcccf27cd41f95d6c04bea2ce44ff1dbae89b1c299665149bc1db8

data/lib/myco/code_loader.rb

@@ -42,7 +42,7 @@ module Myco
       use_path = resolve_file(path, load_paths)
       
       # TODO: This logic could be refactored to look cleaner
-      if use_path
+      if use_path && defined? Myco::ToolSet
         # Try to find an implementation with higher precedence than :myco
         # With a file that has been modified at least as recently as
         # the resolved file in use_path.

data/lib/myco/parser/ast/ToRuby.my

@@ -0,0 +1,400 @@
+
+CodeTools::AST << {
+  
+  # A Ruby code generation visitor
+  ToRuby < ::Myco::Object {
+    var lines: [""]
+    
+    # The currently held string of generated ruby code
+    to_s: lines.join("\n")
+    
+    # Add to the current line the given list of Strings
+    # and/or objects that respond to :to_ruby
+    add: |*strings| strings.each |string| {
+      string.is_a?(String)
+        &? lines.last.concat(string.dup)
+        ?? string.to_ruby(self)
+    }
+    
+    # Start a new line, optionally adding a list of Strings
+    # and/or objects that respond to :to_ruby
+    line: |*strings|
+      lines.push(indents.last.dup); add(*strings)
+    
+    # Add the given items to the current line,
+    # using the given separator between items.
+    # If a block is given, it is called on
+    # each iteration with the item instead.
+    # Returns true if any items were written, else false.
+    list: |items, separator="", auto_lines:false, &block| {
+      items.any? && (
+        items = items.dup
+        last_item = items.pop
+        
+        use_lines = items.any? && auto_lines
+        use_lines && self.push_indent
+        
+        items.each |item| {
+          use_lines && self.line
+          block &? block.call(item) ?? add(item)
+          add(separator)
+        }
+        use_lines && self.line
+        block &? block.call(last_item) ?? add(last_item)
+        
+        use_lines && self.pop_indent
+        use_lines && self.line
+      )
+    }
+    
+    # Stack of indent levels (as strings to be prefixed)
+    var indents: [""]
+    var indent_amount: 2
+    pop_indent: indents.pop
+    push_indent: |amount=indent_amount|
+      indents.push(indents.last + " " * amount)
+    
+    # Stack of every AST node in hierarchy that can hold local variables
+    var var_scopes: []
+    var_scope: var_scopes.last
+    
+    with_nested_var_scope: |node, &block| {
+      var_scopes.push(node)
+      block.call
+      var_scopes.pop
+    }
+    
+    var_scope_declare_local: |name|
+      var_scope.variables[name] = true
+    
+    var_scope_declare_locals: |*names| {
+      names.each |name| { var_scope_declare_local(name) }
+    }
+    
+    var_scope_has_local?: |name| {
+      !!var_scopes.reverse.detect |scope| {
+        scope.variables.has_key?(name)
+      }
+    }
+    
+    # Helper methods
+    
+    # Return false if the given indent might be problematic in generated Ruby
+    # TODO: make comprehensive
+    easy_ident?: |sym| {
+      str = sym.to_s
+      (str =~ Regexp.new("^[a-z_][A-Za-z_]*$"))
+      && (![:if,:unless,:and,:or,:def,:do,:class,
+            :module,:end,:break,:begin,:rescue,:ensure].include?(sym))
+    }
+  }
+  
+  # Allow any Node to be visited with the to_ruby meme
+  Node << {
+    to_ruby_code: {
+      g = ToRuby.new
+      to_ruby(g)
+      g.to_s
+    }
+  }
+  
+  Self         << { to_ruby: |g| g.add("self") }
+  NullLiteral  << { to_ruby: |g| g.add("nil") }
+  VoidLiteral  << { to_ruby: |g| g.add("::Myco::Void") }
+  TrueLiteral  << { to_ruby: |g| g.add("true") }
+  FalseLiteral << { to_ruby: |g| g.add("false") }
+  
+  StringLiteral << { to_ruby: |g| g.add(self.string.inspect) }
+  SymbolLiteral << { to_ruby: |g| g.add(self.value.inspect) }
+  
+  DynamicString << {
+    to_ruby: |g| {
+      inspect_escape = 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))
+        }
+      g.add('"')
+    }
+  }
+  
+  DynamicSymbol << {
+    to_ruby: |g| {
+      g.add(":")
+      # TODO: use super here
+      DynamicString.instance_method(:to_ruby).bind(self).call(g)
+    }
+  }
+  
+  HashLiteral << {
+    to_ruby: |g| {
+      g.add("{")
+      g.list(self.array.each_slice(2).to_a, ",", auto_lines:true) |pair| {
+        g.add(pair.first, " => ", pair.last)
+      }
+      g.add("}")
+    }
+  }
+  
+  ArrayAssembly << {
+    to_ruby: |g|
+      g.add("["); g.list(self.body, ",", auto_lines:true); g.add("]")
+  }
+  
+  ScopedConstant << {
+    to_ruby: |g|
+      g.add(self.parent); g.add("::"self.name"")
+    
+    to_ruby_assign: |g, value|
+      to_ruby(g); g.add(" = "); g.add(value)
+  }
+  
+  ToplevelConstant << {
+    to_ruby: |g|
+      g.add("::"self.name"")
+    
+    to_ruby_assign: |g, value|
+      to_ruby(g); g.add(" = "); g.add(value)
+  }
+  
+  ConstantAccess << {
+    to_ruby: |g|
+      g.add("::Myco.find_constant("self.name.inspect")")
+    
+    to_ruby_assign: |g, value| {
+      g.add("::Myco.cscope.for_method_definition.const_set("self.name.inspect", ")
+      g.add(value); g.add(")")
+    }
+  }
+  
+  ConstantAssignment << {
+    to_ruby: |g| self.constant.to_ruby_assign(g, self.value)
+  }
+  
+  ConstantDefine << {
+    to_ruby: |g| {
+      g.add(implementation)
+      g.line(".tap { |__c__| __c__.__name__ = ")
+        g.add(self.name.name.inspect)
+      g.add(" }")
+    }
+  }
+  
+  ConstantReopen << {
+    to_ruby: |g| {
+      g.add(self.name); g.add(".component_eval {")
+      g.add(self.body); g.add("}")
+    }
+  }
+  
+  MycoModuleScope << {
+    to_ruby: |g|
+      g.with_nested_var_scope(self) { g.add(self.body) }
+  }
+  
+  EvalExpression << { to_ruby: |g| g.add(self.body) }
+  DeclareFile << { to_ruby: |g| implementation.to_ruby(g) }
+  
+  DeclareObject << {
+    to_ruby: |g| {
+      g.add("::Myco::Component.new("); g.add(self.types); g.add(", ::Myco.cscope.for_method_definition, __FILE__, __LINE__)")
+      g.line(".tap { |__c__| __c__.__last__ = __c__.component_eval {"); g.add(scope_implementation); g.add("}}")
+      self.create && g.add(".instance")
+    }
+  }
+  
+  DeclareString << { to_ruby: |g| g.add(implementation) }
+  
+  DeclareCategory << {
+    to_ruby: |g| {
+      g.add("__category__("self.name.value.inspect")")
+      g.add(".component_eval {"); g.add(self.body); g.add("}")
+    }
+  }
+  
+  DeclareMeme << {
+    to_ruby: |g| {
+      g.with_nested_var_scope(body_implementation) {
+        g.var_scope_declare_locals(*self.arguments.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(" ")
+          g.add(self.body);
+        g.add("}")
+      }
+    }
+  }
+  
+  DeclareDecorator << {
+    to_ruby: |g|
+      g.add("["self.name.value.inspect", "); g.add(self.arguments); g.add("]")
+  }
+  
+  Parameters << {
+    to_ruby: |g| {
+      list = []
+      list_add = Proc.new |&blk| { list.push(Proc.new(&blk)) }
+      
+      self.required.each |item| { list_add.call { g.add(item.to_s) } }
+      
+      self.defaults &? (
+        self.defaults.arguments.each |asgn| {
+          name = asgn.name
+          value = asgn.value
+          list_add.call {
+            g.add(""name"=")
+            (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
+          }
+        }
+      )
+      
+      (self.splat == :"*") &? (
+        list_add.call { g.add("*") }
+      ) ?? (self.splat &? ( # TODO: make prettier elsif alternative
+        list_add.call { g.add("*"self.splat"") }
+      ))
+      
+      self.keywords &? (
+        self.keywords.arguments.each |asgn| {
+          name = asgn.name
+          value = asgn.value
+          list_add.call {
+            g.add(""name":")
+            (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
+          }
+        }
+        
+        (self.keywords.kwrest == true) &? (
+          list_add.call { g.add("**") }
+        ) ?? self.keywords.kwrest &? (
+          list_add.call { g.add("**"self.keywords.kwrest.name"") }
+        )
+      )
+      
+      self.block_arg &? (
+        list_add.call { g.add("&"self.block_arg.name"") }
+      )
+      
+      g.add("|"); g.list(list, ", ") |proc| { proc.call }; g.add("|")
+    }
+  }
+  
+  Block << {
+    to_ruby: |g|
+      g.add("("); g.list(self.array, "", auto_lines:true); g.add(")")
+  }
+  
+  Invoke << { to_ruby: |g| g.add(implementation) }
+  
+  InvokeMethod << {
+    to_ruby: |g| {
+      list = self.arguments &? self.arguments.body.dup ?? []
+      self.arguments.block.is_a?(BlockPass) &&
+        list.push(self.arguments.block)
+      
+      g.add(self.receiver)
+      
+      g.easy_ident?(self.name) &? (
+        g.add("."self.name"")
+      ) ?? (
+        g.add(".__send__")
+        list.unshift(SymbolLiteral.new(self.line, self.name))
+      )
+      
+      list.any? && (
+        g.add("(")
+          g.list(list, ",", auto_lines:true)
+        g.add(")")
+      )
+      
+      self.arguments.block.is_a?(Iter) && (
+        g.add(" {"); g.add(self.arguments.block); g.add("}")
+      )
+    }
+  }
+  
+  LocalVariableAssignment << {
+    to_ruby: |g| {
+      g.var_scope_declare_local(self.name)
+      g.var_scope.variables[self.name] = true
+      g.add(self.name.to_s); g.add(" = "); g.add(self.value)
+    }
+  }
+  
+  LocalVariableAccessAmbiguous << {
+    to_ruby: |g| {
+      g.var_scope_has_local?(self.name) &? (
+        g.add(self.name.to_s)
+      ) ?? (
+        g.add("self")
+        
+        g.easy_ident?(self.name) &? (
+          g.add("."self.name"")
+        ) ?? (
+          g.add(".__send__("self.name.inspect")")
+        )
+      )
+    }
+  }
+  
+  SplatValue << {
+    to_ruby: |g| {
+      self.value.is_a?(self.class) &? (
+        self.value.to_ruby(g)
+      ) ?? (
+        g.add("*")
+        self.value.to_ruby(g)
+      )
+    }
+  }
+  CollectSplat << { to_ruby: |g| { } } # TODO
+  ConcatArgs   << { to_ruby: |g| { } } # TODO
+  PushArgs     << { to_ruby: |g| { } } # TODO
+  
+  BlockPass << {
+    to_ruby: |g| g.add("&"); g.add(self.body)
+  }
+  
+  Iter << {
+    to_ruby: |g| {
+      g.with_nested_var_scope(self) {
+        g.var_scope_declare_locals(*self.arguments.names)
+        
+        g.add(" "); g.add(self.arguments); g.add(" "); g.add(self.body)
+      }
+    }
+  }
+  
+  Quest << {
+    to_ruby: |g| {
+      associated_questable = self.questable.dup
+      associated_questable.receiver = self.receiver
+      
+      g.add("(")
+        g.add(self.receiver)
+          g.add(".respond_to?("self.questable.name.inspect").false?")
+        g.add(" ? ::Myco::Void : ")
+        g.add(associated_questable)
+      g.add(")")
+    }
+  }
+  
+  BranchOperator << {
+    to_ruby: |g| {
+      g.add('::Myco.branch_op(')
+        g.add(self.type.inspect); g.add(', ')
+        g.add(self.left); g.add(') {')
+        g.add(self.right); g.add('}')
+    }
+  }
+  
+  Return << {
+    to_ruby: |g| g.add("return "); g.add(self.value)
+  }
+}