duby 0.0.1

data/examples/java_thing.duby

@@ -0,0 +1,13 @@
+import "java.lang.System"
+
+def foo
+  home = System.getProperty "java.home"
+  System.setProperty "hello.world", "something"
+  hello = System.getProperty "hello.world"
+
+  puts home
+  puts hello
+end
+
+puts "Hello world!"
+foo

data/examples/simple_class.duby

@@ -0,0 +1,12 @@
+class Foo
+  def initialize
+    puts 'constructor'
+    @hello = 'Hello, '
+  end
+
+  def hello(a:string)
+    puts @hello; puts a
+  end
+end
+
+Foo.new.hello('Duby')

data/examples/swing.duby

@@ -0,0 +1,20 @@
+import javax.swing.JFrame
+import javax.swing.JButton
+import java.awt.event.ActionListener
+
+frame = JFrame.new "Welcome to Duby"
+frame.setSize 300, 300
+frame.setVisible true
+
+button = JButton.new "Press me"
+frame.add button
+frame.show
+
+class AL; implements ActionListener
+  def initialize; end
+  def actionPerformed(event)
+    JButton(event.getSource).setText "Duby Rocks!"
+  end
+end
+
+button.addActionListener AL.new

data/examples/tak.duby

@@ -0,0 +1,15 @@
+def tak(x:fixnum, y:fixnum, z:fixnum)
+  unless y < x
+    z
+  else
+    tak( tak(x-1, y, z),
+         tak(y-1, z, x),
+         tak(z-1, x, y))
+  end
+end
+
+i = 0
+while i<1000
+  tak(24, 16, 8)
+  i+=1
+end

data/lib/duby.rb

@@ -0,0 +1,170 @@
+require 'fileutils'
+require 'duby/transform'
+require 'duby/ast'
+require 'duby/typer'
+require 'duby/compiler'
+begin
+  require 'bitescript'
+rescue LoadError
+  $: << File.dirname(__FILE__) + '/../../bitescript/lib'
+  require 'bitescript'
+end
+require 'duby/jvm/compiler'
+require 'duby/jvm/typer'
+Dir[File.dirname(__FILE__) + "/duby/plugin/*"].each {|file| require "#{file}" if file =~ /\.rb$/}
+require 'jruby'
+
+module Duby
+  VERSION = '0.0.1'
+  
+  def self.run(*args)
+    DubyImpl.new.run(*args)
+  end
+  
+  def self.compile(*args)
+    DubyImpl.new.compile(*args)
+  end
+  
+  def self.parse(*args)
+    DubyImpl.new.parse(*args)
+  end
+end
+
+class DubyImpl
+  def run(*args)
+    ast = parse(*args)
+
+    main_cls = nil
+    compile_ast(ast) do |outfile, builder|
+      bytes = builder.generate
+      name = builder.class_name.gsub(/\//, '.')
+      cls = JRuby.runtime.jruby_class_loader.define_class(name, bytes.to_java_bytes)
+      proxy_cls = JavaUtilities.get_proxy_class(name)
+      # TODO: using first main; find correct one
+      if proxy_cls.respond_to? :main
+        main_cls ||= proxy_cls
+      end
+    end
+  
+    if main_cls
+      main_cls.main(args.to_java(:string))
+    else
+      puts "No main found"
+    end
+  end
+  
+  def compile(*args)
+    process_flags!(args)
+    
+    expand_files(args).each do |duby_file|
+      if duby_file == '-e'
+        @filename = '-e'
+        next
+      elsif @filename == '-e'
+        ast = parse('-e', duby_file)
+      else
+        ast = parse(duby_file)
+      end
+      exit 1 if @error
+
+      compile_ast(ast) do |filename, builder|
+        filename = "#{@dest}#{filename}"
+        FileUtils.mkdir_p(File.dirname(filename))
+        bytes = builder.generate
+        File.open(filename, 'w') {|f| f.write(bytes)}
+      end
+      @filename = nil
+    end
+  end
+
+  def parse(*args)
+    process_flags!(args)
+    @filename = args.shift
+
+    if @filename == '-e'
+      @filename = 'dash_e'
+      src = args[0]
+    else
+      src = File.read(@filename)
+    end
+    Duby::AST.type_factory = Duby::JVM::Types::TypeFactory.new(@filename)
+    ast = Duby::AST.parse_ruby(src, @filename)
+    @transformer = Duby::Transform::Transformer.new
+    ast = @transformer.transform(ast, nil)
+    @transformer.errors.each do |ex|
+      raise ex.cause || ex if @verbose
+      puts "#@filename:#{ex.position.start_line+1}: #{ex.message}"
+    end
+    @error = @transformer.errors.size > 0
+    ast
+  end
+
+  def compile_ast(ast, &block)
+    typer = Duby::Typer::JVM.new(@filename)
+    typer.infer(ast)
+    begin
+      typer.resolve(true)
+    ensure
+      typer.errors.each do |ex|
+        puts ex.message
+        puts ex.backtrace if @verbose
+      end
+    end
+
+    compiler = @compiler_class.new(@filename)
+    ast.compile(compiler, false)
+    compiler.generate(&block)
+  end
+
+  def process_flags!(args)
+    while args.length > 0
+      case args[0]
+      when '-V'
+        Duby::Typer.verbose = true
+        Duby::AST.verbose = true
+        Duby::Compiler::JVM.verbose = true
+        @verbose = true
+        args.shift
+      when '-java'
+        require 'duby/jvm/source_compiler'
+        @compiler_class = Duby::Compiler::JavaSource
+        args.shift
+      when '-d'
+        args.shift
+        @dest = File.join(args.shift, '')
+      when '-p'
+        args.shift
+        plugin = args.shift
+        require "duby/plugin/#{plugin}"
+      when '-I'
+        args.shift
+        $: << args.shift
+      else
+        break
+      end
+    end
+    @compiler_class ||= Duby::Compiler::JVM
+  end
+  
+  def expand_files(files)
+    expanded = []
+    files.each do |filename|
+      if File.directory?(filename)
+        Dir[File.join(filename, '*')].each do |child|
+          if File.directory?(child)
+            files << child
+          elsif child =~ /\.duby$/
+            expanded << child
+          end
+        end
+      else
+        expanded << filename
+      end
+    end
+    expanded
+  end
+end
+
+if __FILE__ == $0
+  Duby.run(ARGV[0], *ARGV[1..-1])
+end

data/lib/duby/ast.rb

@@ -0,0 +1,340 @@
+require 'duby/transform'
+
+module Duby
+  module AST
+    class << self
+      attr_accessor :verbose
+    end
+    
+    # The top of the AST class hierarchy, this represents an abstract AST node.
+    # It provides accessors for _children_, an array of all child nodes,
+    # _parent_, a reference to this node's parent (nil if none), and _newline_,
+    # whether this node represents a new line.
+    class Node
+      attr_accessor :children
+      attr_accessor :parent
+      attr_accessor :position
+      attr_accessor :newline
+      attr_accessor :inferred_type
+
+      def initialize(parent, position, children = [])
+        @parent = parent
+        @newline = false
+        @inferred_type = nil
+        @resolved = false
+        @position = position
+        if block_given?
+          @children = yield(self) || []
+        else
+          @children = children
+        end
+      end
+
+      def line_number
+        if @position
+          @position.start_line + 1
+        else
+          0
+        end
+      end
+
+      def log(message)
+        puts "* [AST] [#{simple_name}] " + message if AST.verbose
+      end
+
+      def inspect(indent = 0)
+        indent_str = ' ' * indent
+        str = indent_str + to_s
+        children.each do |child|
+          if child
+            if ::Array === child
+              child.each {|ary_child|
+                str << "\n#{ary_child.inspect(indent + 1)}"
+              }
+            elsif ::Hash === child
+              str << "\n#{indent_str} #{child.inspect}"
+            else
+              str << "\n#{child.inspect(indent + 1)}"
+            end
+          end
+        end
+        str
+      end
+
+      def simple_name
+        self.class.name.split("::")[-1]
+      end
+
+      def to_s; simple_name; end
+
+      def [](index) children[index] end
+
+      def each(&b) children.each(&b) end
+
+      def resolved!
+        log "#{to_s} resolved!"
+        @resolved = true
+      end
+
+      def resolved?; @resolved end
+
+      def resolve_if(typer)
+        unless resolved?
+          @inferred_type = yield
+          @inferred_type ? resolved! : typer.defer(self)
+        end
+        @inferred_type
+      end
+    end
+    
+    class ErrorNode < Node
+      def initialize(parent, error)
+        super(parent, error.position)
+        @error = error
+        @inferred_type = TypeReference::ErrorType
+        @resolved = true
+      end
+      
+      def infer(typer)
+      end
+    end
+
+    module Named
+      attr_accessor :name
+
+      def to_s
+        "#{super}(#{name})"
+      end
+    end
+
+    module Typed
+      attr_accessor :type
+    end
+
+    module Valued
+      include Typed
+      attr_accessor :value
+    end
+
+    module Literal
+      include Typed
+      attr_accessor :literal
+
+      def to_s
+        "#{super}(#{literal.inspect})"
+      end
+    end
+
+    module Scoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          raise "No parent for #{self.class.name} at #{line_number}" if scope.nil?
+          scope = scope.parent until scope.class.include?(Scope)
+          scope
+        end
+      end
+    end
+
+    module ClassScoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          scope = scope.parent until scope.nil? || ClassDefinition === scope
+          scope
+        end
+      end
+    end
+
+    module Scope; end
+
+    class Colon2 < Node; end
+
+    class Constant < Node
+      include Named
+      def initialize(parent, position, name)
+        @name = name
+        super(parent, position, [])
+      end
+
+      def infer(typer)
+        @inferred_type ||= begin
+          typer.type_reference(name, false, true)
+        end
+      end
+    end
+
+    class Self < Node; end
+
+    class VoidType < Node; end
+
+    class TypeReference < Node
+      include Named
+      attr_accessor :array
+      alias array? array
+      attr_accessor :meta
+      alias meta? meta
+      
+      def initialize(name, array = false, meta = false, position=nil)
+        super(nil, position)
+        @name = name
+        @array = array
+        @meta = meta
+      end
+
+      def to_s
+        "Type(#{name}#{array? ? ' array' : ''}#{meta? ? ' meta' : ''})"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        to_s.hash
+      end
+
+      def is_parent(other)
+        # default behavior now is to disallow any polymorphic types
+        self == other
+      end
+      
+      def compatible?(other)
+        # default behavior is only exact match right now
+        self == other ||
+            error? || other.error? ||
+            unreachable? || other.unreachable?
+      end
+
+      def iterable?
+        array?
+      end
+      
+      def component_type
+        AST.type(name) if array?
+      end
+
+      def narrow(other)
+        # only exact match allowed for now, so narrowing is a noop
+        if error? || unreachable?
+          other
+        else
+          self
+        end
+      end
+
+      def unmeta
+        TypeReference.new(name, array, false)
+      end
+
+      def meta
+        TypeReference.new(name, array, true)
+      end
+
+      def error?
+        name == :error
+      end
+
+      def unreachable?
+        name == :unreachable
+      end
+      
+      def primitive?
+        true
+      end
+
+      NoType = TypeReference.new(:notype)
+      NullType = TypeReference.new(:null)
+      ErrorType = TypeReference.new(:error)
+      UnreachableType = TypeReference.new(:unreachable)
+    end
+
+    class TypeDefinition < TypeReference
+      attr_accessor :superclass, :interfaces
+
+      def initialize(name, superclass, interfaces)
+        super(name, false)
+
+        @superclass = superclass
+        @interfaces = interfaces
+      end
+    end
+    
+    def self.type_factory
+      Thread.current[:ast_type_factory]
+    end
+    
+    def self.type_factory=(factory)
+      Thread.current[:ast_type_factory] = factory
+    end
+    
+    # Shortcut method to construct type references
+    def self.type(typesym, array = false, meta = false)
+      factory = type_factory
+      if factory
+        factory.type(typesym, array, meta)
+      else
+        TypeReference.new(typesym, array, meta)
+      end
+    end
+    
+    def self.no_type
+      factory = type_factory
+      if factory
+        factory.no_type
+      else
+        TypeReference::NoType
+      end
+    end
+    
+    def self.error_type
+      TypeReference::ErrorType
+    end
+
+    def self.unreachable_type
+      TypeReference::UnreachableType
+    end
+
+    def self.fixnum(parent, position, literal)
+      factory = type_factory
+      if factory
+        factory.fixnum(parent, position, literal)
+      else
+        Fixnum.new(parent, position, literal)
+      end      
+    end
+
+    def self.float(parent, position, literal)
+      factory = type_factory
+      if factory
+        factory.float(parent, position, literal)
+      else
+        Float.new(parent, position, literal)
+      end      
+    end
+    
+    def self.defmacro(name, &block)
+      @macros ||= {}
+      raise "Conflicting macros for #{name}" if @macros[name]
+      @macros[name] = block
+    end
+    
+    def self.macro(name)
+      @macros[name]
+    end
+  end
+end
+
+require 'duby/ast/local'
+require 'duby/ast/call'
+require 'duby/ast/flow'
+require 'duby/ast/literal'
+require 'duby/ast/method'
+require 'duby/ast/class'
+require 'duby/ast/structure'
+require 'duby/ast/type'
+require 'duby/ast/intrinsics'