@@ -3,6 +3,10 @@ module Duby::AST def initialize(parent, line_number, &block) super(parent, line_number, &block) end + + def infer(typer) + @inferred_type = typer.array_type + end end class Fixnum < Node lib/duby/ast/literal.rb @@ -37,6 +37,12 @@ module Duby end end end + + class Array + def compile(compiler, expression) + compiler.array(self, expression) + end + end class Body def compile(compiler, expression) lib/duby/compiler.rb @@ -556,6 +556,34 @@ module Duby def boolean(value) value ? @method.iconst_1 : @method.iconst_0 end + + def array(node, expression) + if expression + # create basic arraylist + @method.new java::util::ArrayList + @method.dup + @method.ldc_int node.children ? node.children.size : 0 + @method.invokespecial java::util::ArrayList, "<init>", [@method.void, @method.int] + + # elements, as expressions + # TODO: ensure they're all reference types! + node.children.each do |node| + @method.dup + node.compile(self, true) + @method.invokeinterface java::util::List, "add", [@method.boolean, @method.object] + @method.pop + end + + # make it unmodifiable + @method.invokestatic java::util::Collections, "unmodifiableList", [java::util::List, java::util::List] + else + # elements, as non-expressions + # TODO: ensure they're all reference types! + node.children.each do |node| + node.compile(self, false) + end + end + end def null @method.aconst_null lib/duby/jvm/compiler.rb @@ -42,6 +42,16 @@ module Duby def no_type Void end + + def array_type + # TODO: allow other types for pre-1.2 profiles + type_reference("java.util.List") + end + + def hash_type + # TODO: allow other types for pre-1.2 profiles + type_reference("java.util.Map") + end def learn_method_type(target_type, name, parameter_types, type, exceptions) static = target_type.meta? lib/duby/jvm/typer.rb @@ -79,6 +79,16 @@ module Duby AST::TypeReference::NoType end + # to be overridden + def array_type + AST::TypeReference::NullType + end + + # to be overridden + def hash_type + AST::TypeReference::NullType + end + def define_type(name, superclass, interfaces) log "New type defined: '#{name}' < '#{superclass}'" known_types[name] = type_definition(name, superclass, interfaces) lib/duby/typer.rb @@ -1508,4 +1508,25 @@ class TestJVMCompiler < Test::Unit::TestCase b.new end end + + def test_literal_array + cls, = compile(<<-EOF) + def foo; puts "hello"; nil; end + def expr + [foo] + end + def nonexpr + [foo] + nil + end + EOF + + assert_output("hello\nhello\n") do + val = cls.expr + assert val + + val = cls.nonexpr + assert !val + end + end end \ No newline at end of file test/test_jvm_compiler.rb 60b1c148b37322f17374db72324da88ee2cd639e Charles Oliver Nutter headius@headius.com http://github.com/headius/duby/commit/b5d6149e5b79e2231fab867d2a94989486573106 b5d6149e5b79e2231fab867d2a94989486573106 2009-11-08T01:55:35-08:00 2009-11-08T01:55:35-08:00 Literal array support; only JVM compiler supports it right now... aeab9daf2157291f4d2bd45e4c43afc8ffe35a2c Charles Oliver Nutter headius@headius.com