duby 0.0.1

data/test/test_math_plugin.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+require 'duby'
+require 'duby/plugin/math'
+
+class TestMathPlugin < Test::Unit::TestCase
+  include Duby
+
+  def setup
+    @typer = Typer::Simple.new :bar
+  end
+
+  def assert_resolves_to(type, script)
+    ast = AST.parse("1 + 1")
+    ast.infer(@typer)
+    assert_nothing_raised {@typer.resolve(true)}
+    assert_equal(@typer.fixnum_type, ast.inferred_type)
+  end
+  
+  def test_plus
+    assert_resolves_to(@typer.fixnum_type, '1 + 1')
+    assert_resolves_to(@typer.float_type, '1.0 + 1.0')
+  end
+  
+  def test_minus
+    assert_resolves_to(@typer.fixnum_type, '1 - 1')
+    assert_resolves_to(@typer.float_type, '1.0 - 1.0')
+  end
+  
+  def test_times
+    assert_resolves_to(@typer.fixnum_type, '1 * 1')
+    assert_resolves_to(@typer.float_type, '1.0 * 1.0')
+  end
+  
+  def test_divide
+    assert_resolves_to(@typer.fixnum_type, '1 / 1')
+    assert_resolves_to(@typer.float_type, '1.0 / 1.0')
+  end
+
+  def test_remainder
+    assert_resolves_to(@typer.fixnum_type, '1 % 1')
+    assert_resolves_to(@typer.float_type, '1.0 % 1.0')
+  end
+
+  def test_shift_left
+    assert_resolves_to(@typer.fixnum_type, '1 << 1')
+  end
+
+  def test_shift_right
+    assert_resolves_to(@typer.fixnum_type, '1 >> 1')
+  end
+
+  def test_ushift_right
+    assert_resolves_to(@typer.fixnum_type, '1 >>> 1')
+  end
+
+  def test_bitwise_and
+    assert_resolves_to(@typer.fixnum_type, '1 & 1')
+  end
+
+  def test_bitwise_or
+    assert_resolves_to(@typer.fixnum_type, '1 | 1')
+  end
+
+  def test_bitwise_xor
+    assert_resolves_to(@typer.fixnum_type, '1 ^ 1')
+  end
+
+  def test_less_than
+    assert_resolves_to(@typer.boolean_type, '1 < 1')
+    assert_resolves_to(@typer.boolean_type, '1.0 < 1.0')
+  end
+
+  def test_greater_than
+    assert_resolves_to(@typer.boolean_type, '1 > 1')
+    assert_resolves_to(@typer.boolean_type, '1.0 > 1.0')
+  end
+
+  def test_less_than_or_equal
+    assert_resolves_to(@typer.boolean_type, '1 <= 1')
+    assert_resolves_to(@typer.boolean_type, '1.0 <= 1.0')
+  end
+
+  def test_greater_than_or_equal
+    assert_resolves_to(@typer.boolean_type, '1 >= 1')
+    assert_resolves_to(@typer.boolean_type, '1.0 >= 1.0')
+  end
+end

data/test/test_typer.rb

@@ -0,0 +1,246 @@
+require 'test/unit'
+require 'duby'
+
+class TestTyper < Test::Unit::TestCase
+  include Duby
+  
+  def test_fixnum
+    ast = AST.parse("1")
+    
+    assert_equal(AST::TypeReference.new("fixnum"), ast.infer(Typer::Simple.new(:bar)))
+  end
+  
+  def test_float
+    ast = AST.parse("1.0")
+    
+    assert_equal(AST::TypeReference.new("float"), ast.infer(Typer::Simple.new(:bar)))
+  end
+  
+  def test_string
+    ast = AST.parse("'foo'")
+    
+    assert_equal(AST::TypeReference.new("string"), ast.infer(Typer::Simple.new(:bar)))
+  end
+  
+  def test_boolean
+    ast1 = AST.parse("true")
+    ast2 = AST.parse("false")
+    
+    assert_equal(AST::TypeReference.new("boolean"), ast1.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::TypeReference.new("boolean"), ast2.infer(Typer::Simple.new(:bar)))
+  end
+  
+  def test_body
+    ast1 = AST.parse("'foo'; 1.0; 1")
+    ast2 = AST.parse("begin; end")
+    
+    assert_equal(AST::TypeReference.new("fixnum"), ast1.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::no_type, ast2.infer(Typer::Simple.new(:bar)))
+  end
+  
+  def test_local
+    ast1 = AST.parse("a = 1; a")
+    typer = Typer::Simple.new :bar
+    
+    ast1.infer(typer)
+    
+    assert_equal(AST::TypeReference.new("fixnum"), typer.local_type(ast1, 'a'))
+    assert_equal(AST::TypeReference.new("fixnum"), ast1.body.children[0].inferred_type)
+    assert_equal(AST::TypeReference.new("fixnum"), ast1.body.children[1].inferred_type)
+    
+    ast2 = AST.parse("b = a = 1")
+    ast2.infer(typer)
+    
+    assert_equal(AST::TypeReference.new("fixnum"), typer.local_type(ast2, 'a'))
+    assert_equal(AST::TypeReference.new("fixnum"), ast2.body.children[0].inferred_type)
+  end
+  
+  def test_signature
+    ["def foo", "def self.foo"].each do |def_foo|
+      ast1 = AST.parse("#{def_foo}(a); {a => :string}; end")
+      typer = Typer::Simple.new :bar
+
+      ast1.infer(typer)
+      
+      assert_nothing_raised {typer.resolve(true)}
+      assert_nothing_raised {typer.resolve}
+
+
+      if def_foo =~ /self/
+        type = typer.self_type.meta
+      else
+        type = typer.self_type
+      end
+
+      assert_equal(typer.no_type, typer.method_type(type, 'foo', [typer.string_type]))
+      assert_equal(typer.string_type, typer.local_type(ast1.body, 'a'))
+      assert_equal(typer.no_type, ast1.body.inferred_type)
+      assert_equal(typer.string_type, ast1.body.arguments.args[0].inferred_type)
+
+      ast1 = AST.parse("#{def_foo}(a); 1 end")
+      typer = Typer::Simple.new :bar
+
+      ast1.infer(typer)
+
+      assert_equal(typer.fixnum_type, typer.method_type(type, 'foo', [typer.default_type]))
+      assert_equal(typer.default_type, typer.local_type(ast1.body, 'a'))
+      assert_equal(typer.fixnum_type, ast1.body.inferred_type)
+      assert_equal(typer.default_type, ast1.body.arguments.args[0].inferred_type)
+
+      ast1 = AST.parse("#{def_foo}(a); {a => :string}; a; end")
+      typer = Typer::Simple.new :bar
+
+      ast1.infer(typer)
+
+      assert_equal(typer.string_type, typer.method_type(type, 'foo', [typer.string_type]))
+      assert_equal(typer.string_type, typer.local_type(ast1.body, 'a'))
+      assert_equal(typer.string_type, ast1.body.inferred_type)
+      assert_equal(typer.string_type, ast1.body.arguments.args[0].inferred_type)
+
+      ast1 = AST.parse("#{def_foo}(a); {:return => :string}; end")
+      typer = Typer::Simple.new :bar
+
+      assert_raise(Typer::InferenceError) do
+        ast1.infer(typer)
+        typer.resolve(true)
+      end
+
+      ast1 = AST.parse("#{def_foo}(a); a = 'foo'; end")
+      typer = Typer::Simple.new :bar
+
+      ast1.infer(typer)
+
+      assert_equal(typer.string_type, typer.method_type(type, 'foo', [typer.default_type]))
+      assert_equal(typer.string_type, typer.local_type(ast1.body, 'a'))
+      assert_equal(typer.string_type, ast1.body.inferred_type)
+      assert_equal(typer.default_type, ast1.body.arguments.args[0].inferred_type)
+      
+      typer.resolve
+      
+      assert_equal(typer.string_type, ast1.body.arguments.args[0].inferred_type)
+    end
+  end
+  
+  def test_call
+    ast = AST.parse("1.foo(2)").body
+    typer = Typer::Simple.new "bar"
+    
+    typer.learn_method_type(typer.fixnum_type, "foo", [typer.fixnum_type], typer.string_type, [])
+    assert_equal(typer.string_type, typer.method_type(typer.fixnum_type, "foo", [typer.fixnum_type]))
+    
+    ast.infer(typer)
+    
+    assert_equal(typer.string_type, ast.inferred_type)
+    
+    ast = AST.parse("def bar(a, b); {a => :fixnum, b => :string}; 1.0; end; def baz; bar(1, 'x'); end").body
+    
+    ast.infer(typer)
+    
+    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
+    assert_equal(typer.float_type, typer.method_type(typer.self_type, "baz", []))
+    assert_equal(typer.float_type, ast.children[0].inferred_type)
+    assert_equal(typer.float_type, ast.children[1].inferred_type)
+    
+    # Reverse the order, ensure deferred inference succeeds
+    ast = AST.parse("def baz; bar(1, 'x'); end; def bar(a, b); {a => :fixnum, b => :string}; 1.0; end").body
+    typer = Typer::Simple.new("bar")
+    
+    ast.infer(typer)
+    
+    assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
+    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
+    assert_equal(typer.default_type, ast.children[0].inferred_type)
+    assert_equal(typer.float_type, ast.children[1].inferred_type)
+    
+    # allow resolution to run
+    assert_nothing_raised {typer.resolve}
+    
+    assert_equal(typer.float_type, typer.method_type(typer.self_type, "baz", []))
+    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
+    assert_equal(typer.float_type, ast.children[0].inferred_type)
+    assert_equal(typer.float_type, ast.children[1].inferred_type)
+    
+    # modify bar call to have bogus types, ensure resolution fails
+    ast = AST.parse("def baz; bar(1, 1); end; def bar(a, b); {a => :fixnum, b => :string}; 1.0; end").body
+    typer = Typer::Simple.new("bar")
+    
+    ast.infer(typer)
+    
+    assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
+    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
+    assert_equal(typer.default_type, ast.children[0].inferred_type)
+    assert_equal(typer.float_type, ast.children[1].inferred_type)
+    
+    # allow resolution to run and produce error
+    assert_raise(Typer::InferenceError) {typer.resolve(true)}
+    error_nodes = typer.errors.map {|e| e.node}
+    inspected = "[FunctionalCall(bar)\n Fixnum(1)\n Fixnum(1)]"
+    assert_equal(inspected, error_nodes.inspect)
+  end
+  
+  def test_if
+    ast = AST.parse("if true; 1.0; else; ''; end").body
+    typer = Typer::Simple.new("bar")
+    
+    # incompatible body types
+    assert_raise(Typer::InferenceError) {ast.infer(typer)}
+    
+    ast = AST.parse("if true; 1.0; else; 2.0; end").body
+    
+    assert_nothing_raised {ast.infer(typer); typer.resolve(true)}
+    
+    assert_equal(typer.boolean_type, ast.condition.inferred_type)
+    assert_equal(typer.float_type, ast.body.inferred_type)
+    assert_equal(typer.float_type, ast.else.inferred_type)
+    
+    ast = AST.parse("if foo; bar; else; baz; end").body
+    
+    assert_nothing_raised {ast.infer(typer)}
+    
+    assert_equal(typer.default_type, ast.condition.inferred_type)
+    assert_equal(typer.default_type, ast.body.inferred_type)
+    assert_equal(typer.default_type, ast.else.inferred_type)
+    
+    # unresolved types for the foo, bar, and baz calls
+    assert_raise(Typer::InferenceError) {typer.resolve(true)}
+    
+    ast2 = AST.parse("def foo; 1; end; def bar; 1.0; end")
+    
+    ast2.infer(typer)
+    ast.infer(typer)
+    
+    # unresolved types for the baz call
+    assert_raise(Typer::InferenceError) {typer.resolve(true)}
+    
+    assert_equal(AST.error_type, ast.condition.inferred_type)
+    assert_equal(AST.error_type, ast.body.inferred_type)
+    assert_equal(AST.error_type, ast.else.inferred_type)
+    
+    typer.errors.clear
+    
+    ast2 = AST.parse("def baz; 2.0; end")
+    
+    ast2.infer(typer)
+    ast.infer(typer)
+    
+    assert_nothing_raised {typer.resolve(true)}
+    
+    assert_equal(typer.float_type, ast2.body.inferred_type)
+  end
+  
+  def test_class
+    ast = AST.parse("class Foo; def foo; 1; end; def baz; foo; end; end")
+    cls = ast.body
+    foo = cls.body[0]
+    baz = cls.body[1]
+    
+    typer = Typer::Simple.new("script")
+    ast.infer(typer)
+    
+    assert_nothing_raised {typer.resolve(true)}
+    
+    assert_not_nil(typer.known_types["Foo"])
+    assert(AST::TypeDefinition === typer.known_types["Foo"])
+    assert_equal(typer.known_types["Foo"], cls.inferred_type)
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: duby
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Charles Oliver Nutter
+  - Ryan Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-27 00:00:00 -05:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: bitescript
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.0.4
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: hoe
+    type: :development
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 2.3.3
+      version: 
+description: Duby is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax. Duby currently includes a typer/compiler backend for the JVM which can output either JVM bytecode or Java source files.
+email: 
+  - headius@headius.com
+  - ribrdb@google.com
+executables: 
+  - duby
+  - dubyc
+  - dubyp
+extensions: []
+
+extra_rdoc_files: 
+  - History.txt
+  - Manifest.txt
+  - README.txt
+files: 
+  - bin/duby
+  - bin/dubyc
+  - bin/dubyp
+  - lib/duby.rb
+  - lib/duby/ast.rb
+  - lib/duby/compiler.rb
+  - lib/duby/nbcompiler.rb
+  - lib/duby/transform.rb
+  - lib/duby/typer.rb
+  - lib/duby/ast/call.rb
+  - lib/duby/ast/class.rb
+  - lib/duby/ast/flow.rb
+  - lib/duby/ast/intrinsics.rb
+  - lib/duby/ast/literal.rb
+  - lib/duby/ast/local.rb
+  - lib/duby/ast/method.rb
+  - lib/duby/ast/structure.rb
+  - lib/duby/ast/type.rb
+  - lib/duby/c/compiler.rb
+  - lib/duby/jvm/compiler.rb
+  - lib/duby/jvm/method_lookup.rb
+  - lib/duby/jvm/source_compiler.rb
+  - lib/duby/jvm/typer.rb
+  - lib/duby/jvm/types.rb
+  - lib/duby/jvm/source_generator/builder.rb
+  - lib/duby/jvm/source_generator/loops.rb
+  - lib/duby/jvm/source_generator/precompile.rb
+  - lib/duby/jvm/source_generator/typer.rb
+  - lib/duby/jvm/types/basic_types.rb
+  - lib/duby/jvm/types/boolean.rb
+  - lib/duby/jvm/types/factory.rb
+  - lib/duby/jvm/types/floats.rb
+  - lib/duby/jvm/types/integers.rb
+  - lib/duby/jvm/types/intrinsics.rb
+  - lib/duby/jvm/types/literals.rb
+  - lib/duby/jvm/types/methods.rb
+  - lib/duby/jvm/types/number.rb
+  - lib/duby/old/compiler_old.rb
+  - lib/duby/old/declaration.rb
+  - lib/duby/old/mapper.rb
+  - lib/duby/old/signature.rb
+  - lib/duby/old/typer_old.rb
+  - lib/duby/plugin/edb.rb
+  - lib/duby/plugin/java.rb
+  - lib/duby/plugin/math.rb
+  - test/test_ast.rb
+  - test/test_compilation.rb
+  - test/test_java_typer.rb
+  - test/test_javac_compiler.rb
+  - test/test_jvm_compiler.rb
+  - test/test_math_plugin.rb
+  - test/test_typer.rb
+  - examples/bench_fractal.duby
+  - examples/construction.duby
+  - examples/edb.duby
+  - examples/fib.duby
+  - examples/fields.duby
+  - examples/java_thing.duby
+  - examples/simple_class.duby
+  - examples/swing.duby
+  - examples/tak.duby
+  - examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby
+  - examples/appengine/src/com/ribrdb/DubyApp.duby
+  - History.txt
+  - Manifest.txt
+  - README.txt
+  - Rakefile
+  - javalib/JRubyParser.jar
+has_rdoc: true
+homepage: http://kenai.com/projects/duby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.txt
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: duby
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Duby is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax
+test_files: 
+  - test/test_ast.rb
+  - test/test_compilation.rb
+  - test/test_java_typer.rb
+  - test/test_javac_compiler.rb
+  - test/test_jvm_compiler.rb
+  - test/test_math_plugin.rb
+  - test/test_typer.rb