duby 0.0.2-java → 0.0.3-java

data/test/test_typer.rb

@@ -3,65 +3,65 @@ 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"), typer.local_type(ast1.static_scope, '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"), typer.local_type(ast2.static_scope, '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}
 
@@ -73,19 +73,9 @@ class TestTyper < Test::Unit::TestCase
       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.string_type, typer.local_type(ast1.body[0].static_scope, '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)
+      assert_equal(typer.string_type, ast1.body[0].arguments.args[0].inferred_type)
 
       ast1 = AST.parse("#{def_foo}(a); {a => :string}; a; end")
       typer = Typer::Simple.new :bar
@@ -93,9 +83,9 @@ class TestTyper < Test::Unit::TestCase
       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)
+      assert_equal(typer.string_type, typer.local_type(ast1.body[0].static_scope, 'a'))
+      assert_equal(typer.string_type, ast1.body[0].inferred_type)
+      assert_equal(typer.string_type, ast1.body[0].arguments.args[0].inferred_type)
 
       ast1 = AST.parse("#{def_foo}(a); {:return => :string}; end")
       typer = Typer::Simple.new :bar
@@ -104,141 +94,127 @@ class TestTyper < Test::Unit::TestCase
         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
+    ast = AST.parse("if true; 1.0; else; ''; end").body[0]
     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
-    
+
+    ast = AST.parse("if true; 1.0; else; 2.0; end").body[0]
+
     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
-    
+
+    ast = AST.parse("if foo; bar; else; baz; end").body[0]
+
     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 = AST.parse("def foo; 1; end; def bar; 1.0; end")[0]
+
     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)
+
+    assert_equal(typer.float_type, ast2.body[0].inferred_type)
   end
-  
+
   def test_class
     ast = AST.parse("class Foo; def foo; 1; end; def baz; foo; end; end")
-    cls = ast.body
+    cls = ast.body[0]
     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)

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: duby
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 3
+  version: 0.0.3
 platform: java
 authors: 
   - Charles Oliver Nutter
@@ -10,19 +15,24 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-15 19:19:39.063000 -06:00
+date: 2010-06-09 15:09:02.286000 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: bitescript
-    type: :runtime
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Requirement 
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 0.0.5
-      version: 
+            segments: 
+              - 0
+              - 0
+              - 6
+            version: 0.0.6
+    type: :runtime
+    version_requirements: *id001
 description: |-
   Duby is a customizable programming language featuring static types,
   local type inference and a heavily Ruby-inspired syntax. Duby
@@ -47,6 +57,7 @@ files:
   - lib/duby.rb
   - lib/duby/ast.rb
   - lib/duby/compiler.rb
+  - lib/duby/env.rb
   - lib/duby/nbcompiler.rb
   - lib/duby/transform.rb
   - lib/duby/typer.rb
@@ -59,7 +70,7 @@ files:
   - lib/duby/ast/method.rb
   - lib/duby/ast/structure.rb
   - lib/duby/ast/type.rb
-  - lib/duby/c/compiler.rb
+  - lib/duby/jvm/base.rb
   - lib/duby/jvm/compiler.rb
   - lib/duby/jvm/method_lookup.rb
   - lib/duby/jvm/source_compiler.rb
@@ -79,40 +90,41 @@ files:
   - 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_env.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
   - test/TestUser.class
+  - examples/bintrees.duby
   - examples/construction.duby
+  - examples/dynamic.duby
   - examples/edb.duby
   - examples/fib.duby
   - examples/fields.duby
   - examples/fractal.duby
   - examples/java_thing.duby
-  - examples/README
   - examples/simple_class.duby
+  - examples/sort_closure.duby
   - examples/swing.duby
   - examples/tak.duby
   - examples/test.edb
-  - examples/appengine/config.ru
+  - examples/ant/example-build.xml
   - examples/appengine/Rakefile
   - examples/appengine/Readme
+  - examples/appengine/lib/duby_task.rb
+  - examples/appengine/lib/duby/appengine_tasks.rb
   - examples/appengine/lib/duby/plugin/datastore.rb
+  - examples/appengine/src/config.ru
   - examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby
   - examples/appengine/src/com/ribrdb/DubyApp.duby
   - examples/appengine/src/com/ribrdb/list.dhtml
+  - javalib/duby-bootstrap.jar
+  - javalib/dynalang-invoke-0.1.jar
   - javalib/JRubyParser.jar
   - History.txt
   - README.txt
@@ -128,29 +140,33 @@ rdoc_options:
 require_paths: 
   - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+          - 0
         version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+          - 0
         version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: duby
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 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_env.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