mirah 0.0.5-java → 0.0.6-java

data/lib/mirah/errors.rb

@@ -0,0 +1,60 @@
+module Mirah
+  class MirahError < StandardError
+    attr_accessor :position
+    attr_accessor :cause
+
+    def initialize(message, position=nil)
+      super(message)
+      @position = position
+    end
+  end
+
+  class NodeError < MirahError
+    attr_reader :node
+
+    def initialize(message, node=nil)
+      position = node.position if node
+      super(message, position)
+      @node = node
+    end
+
+    def node=(node)
+      @position = node ? node.position : nil
+      @node = node
+    end
+
+    def self.wrap(ex, node)
+      if ex.kind_of?(NodeError)
+        ex.node ||= node
+        return ex
+      elsif ex.kind_of?(MirahError)
+        ex.position ||= node.position
+        return ex
+      else
+        new_ex = new(ex.message, node)
+        new_ex.cause = ex
+        new_ex.position ||= ex.position if ex.respond_to?(:position)
+        new_ex.set_backtrace(ex.backtrace)
+        return new_ex
+      end
+    end
+
+    def position
+      if node && node.position
+        node.position
+      else
+        super
+      end
+    end
+  end
+
+  class SyntaxError < NodeError
+  end
+
+
+  class InferenceError < NodeError
+  end
+
+  class InternalCompilerError < NodeError
+  end
+end

data/lib/mirah/jvm/base.rb

@@ -18,12 +18,7 @@ module Mirah
     class JVMCompilerBase
       attr_accessor :filename, :method, :static, :class
 
-      class CompilationError < Exception
-        attr_accessor :node
-        def initialize(msg, node = nil)
-          super(msg)
-          @node = node
-        end
+      class CompilationError < Mirah::NodeError
       end
 
       def initialize
@@ -41,8 +36,7 @@ module Mirah
         begin
           ast.compile(self, expression)
         rescue => ex
-          Mirah.print_error(ex.message, ast.position)
-          raise ex
+          raise Mirah::InternalCompilerError.wrap(ex, ast)
         end
         log "Compilation successful!"
       end
@@ -196,8 +190,7 @@ module Mirah
           scope = body.static_scope
           declare_locals(scope)
           if scope != @self_scope
-            @self_scope = scope
-            if scope.self_node
+            if scope.self_node && scope.self_node != :self
               # FIXME This is a horrible hack!
               # Instead we should eliminate unused self's.
               unless scope.self_type.name == 'mirah.impl.Builtin'
@@ -205,6 +198,7 @@ module Mirah
                     scope, 'self', scope.self_type, false, scope.self_node)
               end
             end
+            @self_scope = scope
           end
         end
         # all except the last element in a body of code is treated as a statement
@@ -238,7 +232,7 @@ module Mirah
       alias float fixnum
 
       def compile_self
-        if @self_scope && @self_scope.self_node
+        if @self_scope && @self_scope.self_node && @self_scope.self_node != :self
           local(@self_scope, 'self', @self_scope.self_type)
         else
           real_self

data/lib/mirah/jvm/compiler.rb

@@ -120,6 +120,17 @@ module Mirah
           @method.new type
           @method.dup
           @method.invokespecial type, "<init>", [@method.void]
+          if scope.respond_to? :arguments
+            scope.arguments.args.each do |param|
+              name = param.name
+              param_type = param.inferred_type
+              if scope.static_scope.captured?(param.name)
+                @method.dup
+                type.load(@method, @method.local(name, param_type))
+                @method.putfield(type, name, param_type)
+              end
+            end
+          end
           type.store(@method, @method.local('$binding', type))
         end
         begin
@@ -716,7 +727,7 @@ module Mirah
             @method.dup
             n.compile(self, true)
             # TODO this feels like it should be in the node.compile itself
-            if n.inferred_type.primitive?
+            if n.inferred_type!.primitive?
               n.inferred_type.box(@method)
             end
             @method.invokeinterface java::util::List, "add", [@method.boolean, @method.object]

data/lib/mirah/jvm/source_compiler.rb

@@ -128,6 +128,14 @@ module Mirah
           type = scope.binding_type
           @binding = @bindings[type]
           @method.puts "#{type.to_source} $binding = new #{type.to_source}();"
+          if scope.respond_to? :arguments
+            scope.arguments.args.each do |param|
+              if scope.static_scope.captured?(param.name)
+                captured_local_declare(scope, param.name, param.inferred_type)
+                @method.puts "$binding.#{param.name} = #{param.name};"
+              end
+            end
+          end
         end
         begin
           yield
@@ -218,7 +226,7 @@ module Mirah
       def this(method=nil)
         if method && method.static?
           method.declaring_class.name
-        elsif @self_scope && @self_scope.self_node
+        elsif @self_scope && @self_scope.self_node && @self_scope.self_node != :self
           scoped_local_name('self', @self_scope)
         else
           @static ? @class.class_name : 'this'
@@ -472,7 +480,7 @@ module Mirah
 
       def call(call, expression)
         return cast(call, expression) if call.cast?
-        if Mirah::AST::Constant === call.target
+        if Mirah::AST::Constant === call.target || Mirah::AST::Colon2 === call.target
           target = call.target.inferred_type.to_source
         else
           target = call.precompile_target(self)

data/lib/mirah/jvm/source_generator/builder.rb

@@ -231,7 +231,9 @@ module Mirah
       end
 
       def finish_declaration
+        raise if @stopped
         return if @declaration_finished
+
         @declaration_finished = true
         modifiers = "public#{' static' if @static}#{' abstract' if @abstract}"
         print "#{modifiers} class #{class_name} extends #{superclass.name}"
@@ -247,8 +249,8 @@ module Mirah
       end
 
       def stop
-        finish_declaration
         return if @stopped
+        finish_declaration
         @methods.each do |method|
           @out << method.out
         end

data/lib/mirah/jvm/source_generator/precompile.rb

@@ -200,4 +200,10 @@ module Mirah::AST
       false
     end
   end
+
+  class Colon2
+    def expr?(compiler)
+      true
+    end
+  end
 end

data/lib/mirah/jvm/typer.rb

@@ -42,7 +42,12 @@ module Mirah
       end
 
       def type_reference(scope, name, array=false, meta=false)
-        @factory.type(scope, name, array, meta)
+        begin
+          @factory.type(scope, name, array, meta)
+        rescue NameError => ex
+          known_types[name] = Mirah::AST.error_type
+          raise Mirah::InferenceError.wrap(ex, nil)
+        end
       end
 
       def name

data/lib/mirah/jvm/types.rb

@@ -146,6 +146,14 @@ module Mirah
           method.anewarray(self)
         end
 
+        def pop(method)
+          if wide?
+            method.pop2
+          else
+            method.pop
+          end
+        end
+
         def superclass
           raise "Incomplete type #{self}" unless jvm_type
           AST.type(nil, jvm_type.superclass) if jvm_type.superclass

data/lib/mirah/jvm/types/factory.rb

@@ -106,22 +106,26 @@ module Mirah::JVM::Types
     end
 
     def find_type(scope, name)
+      saved_ex = nil
       begin
         return get_type(name)
       rescue NameError => ex
-        raise ex if scope.nil?
+        saved_ex = ex
       end
 
-      imports = scope.static_scope.imports
-      if imports.include?(name)
-        name = imports[name] while imports.include?(name)
-        return get_type(name)
-      end
+      if scope
+        imports = scope.static_scope.imports
+        if imports.include?(name)
+          name = imports[name] while imports.include?(name)
+          return get_type(name)
+        end
 
-      # TODO support inner class names
-      if name !~ /\./
-        return package_search(name, scope)
+        # TODO support inner class names
+        if name !~ /\./
+          return package_search(name, scope)
+        end
       end
+      raise saved_ex
     end
 
     def package_search(name, scope)
@@ -141,7 +145,27 @@ module Mirah::JVM::Types
     def get_type(full_name)
       type = @known_types[full_name]
       return type.basic_type if type
-      type = Type.new(get_mirror(full_name)).load_extensions
+      begin
+        mirror = get_mirror(full_name)
+      rescue NameError => ex
+        if full_name =~ /^(.+)\.([^.]+)/
+          outer_name = $1
+          inner_name = $2
+          begin
+            outer_type = get_type(outer_name)
+            full_name = "#{outer_type.name}$#{inner_name}"
+          rescue NameError
+            raise ex
+          end
+          mirror = get_mirror(full_name)
+        else
+          raise ex
+        end
+      end
+      type = Type.new(mirror).load_extensions
+      if full_name.include? '$'
+        @known_types[full_name.gsub('$', '.')] = type
+      end
       @known_types[full_name] = type
     end
 

data/lib/mirah/jvm/types/intrinsics.rb

@@ -74,18 +74,25 @@ module Mirah::JVM::Types
 
     def add_compiled_macro(klass, name, arg_types)
       add_macro(name, *arg_types) do |duby, call|
+        # Ick. We need to preserve the scope of the arguments to the macro.
+        # However the only way to do that is to wrap them in a ScopedBody.
+        # It'd be better if we didn't have to expose this wrapper node to
+        # the user code.
+        call.parameters = call.parameters.map do |arg|
+          wrapper = Mirah::AST::ScopedBody.new(call.parent, call.position)
+          wrapper.static_scope = call.scope.static_scope
+          wrapper << arg
+        end
         expander = klass.constructors[0].newInstance(duby, call)
         ast = expander.expand
         if ast
+          body = Mirah::AST::ScopedBody.new(call.parent, call.position)
+          body << ast
           if call.target
-            body = Mirah::AST::ScopedBody.new(call.parent, call.position)
             body.static_scope.self_type = call.target.inferred_type!
             body.static_scope.self_node = call.target
-            body << ast
-            body
-          else
-            ast
           end
+          body
         else
           Mirah::AST::Noop.new(call.parent, call.position)
         end

data/lib/mirah/jvm/types/methods.rb

@@ -207,11 +207,7 @@ module Mirah::JVM::Types
       end
 
       unless expression || void?
-        if return_type.wide?
-          compiler.method.pop2
-        else
-          compiler.method.pop
-        end
+        return_type.pop(compiler.method)
       end
     end
 
@@ -238,7 +234,7 @@ module Mirah::JVM::Types
       end
 
       unless expression || void?
-        compiler.method.pop
+        return_type.pop(compiler.method)
       end
     end
   end
@@ -255,7 +251,7 @@ module Mirah::JVM::Types
       # TODO: inference phase needs to track that signature is void
       # but actual type is null object
       compiler.method.aconst_null if expression && void?
-      compiler.method.pop unless expression || void?
+      return_type.pop(compiler.method) unless expression || void?
     end
   end
 
@@ -290,7 +286,7 @@ module Mirah::JVM::Types
         [return_type, target, *@types])
 
       unless expression
-        compiler.method.pop
+        return_type.pop(compiler.method)
       end
 
       compiler.bootstrap_dynamic
@@ -422,7 +418,7 @@ module Mirah::JVM::Types
 
       begin
         descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
-        method = jvm_type.getDeclaredMethod(name, *descriptors)
+        method = jvm_type.getDeclaredMethod(name, *descriptors) if jvm_type
 
         if method.nil? && superclass
           method = superclass.java_method(name, *types) rescue nil

data/lib/mirah/plugin/gwt.rb

@@ -107,9 +107,10 @@ module Mirah::AST
       compiler.define_jsni_method(self)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       @static ||= scope.static_scope.self_type.meta? unless scope.nil?
       @defining_class ||= begin
+        static_scope.self_node = :self
         static_scope.self_type = if static?
           scope.static_scope.self_type.meta
         else
@@ -117,7 +118,7 @@ module Mirah::AST
         end
       end
       resolve_if(typer) do
-        argument_types = typer.infer(arguments)
+        argument_types = typer.infer(arguments, true)
         if argument_types.all?
           typer.learn_method_type(defining_class, name, argument_types,
             signature[:return], signature[:throws])

data/lib/mirah/transform.rb

@@ -15,16 +15,16 @@
 
 require 'base64'
 require 'jruby'
+require 'mirah/errors'
 
 module Mirah
   module Transform
-    class Error < StandardError
-      attr_reader :position, :cause
+    class Error < Mirah::MirahError
+      attr_reader :position
       def initialize(msg, position, cause=nil)
-        super(msg)
-        @position = position
-        @position = position.position if position.respond_to? :position
-        @cause = cause
+        position = position.position if position.respond_to? :position
+        super(msg, position)
+        self.cause = cause
       end
     end
 
@@ -145,14 +145,35 @@ module Mirah
         duby_node
       end
 
-      def dump_ast(node)
+      def dump_ast(node, call=nil)
         encoded = nil
         values = Mirah::AST::Unquote.extract_values do
           encoded = Base64.encode64(Marshal.dump(node))
         end
+        scope = call.scope.static_scope if call
         result = Mirah::AST::Array.new(nil, node.position)
-        result << Mirah::AST::String.new(result, node.position, encoded)
-        values.each {|value| result << value}
+        if encoded.size < 65535
+          result << Mirah::AST::String.new(result, node.position, encoded)
+        else
+          strings = Mirah::AST::StringConcat.new(result, node.position)
+          result << strings
+          while encoded.size >= 65535
+            chunk = encoded[0, 65535]
+            encoded[0, 65535] = ""
+            strings << Mirah::AST::String.new(strings, node.position, chunk)
+          end
+          strings << Mirah::AST::String.new(strings, node.position, encoded)
+        end
+        values.each do |value|
+          if call
+            scoped_value = Mirah::AST::ScopedBody.new(result, value.position)
+            scoped_value << value
+            scoped_value.static_scope = scope
+          else
+            scoped_value = value
+          end
+          result << scoped_value
+        end
         return result
       end
 
@@ -179,9 +200,33 @@ module Mirah
         node
       end
 
-      def constant(name)
+      def constant(name, array=false)
         node = eval("Foo")
         node.name = name
+        node.array = array
+        node
+      end
+
+      def cast(type, value)
+        if value.kind_of?(String)
+          value = Mirah::AST::Local.new(@extra_body, @extra_body.position, value)
+        end
+        fcall = eval("Foo()")
+        fcall.name = type
+        fcall.parameters = [value]
+        fcall
+      end
+
+      def string(value)
+        node = eval('"Foo"')
+        node.literal = value
+        node
+      end
+
+      def empty_array(type_node, size_node)
+        node = eval('int[0]')
+        node.type_node = type_node
+        node.size = size_node
         node
       end
 
@@ -206,6 +251,19 @@ module Mirah
         append_node Mirah::AST::ClassDefinition.new(@extra_body, position, name, &block)
       end
 
+      def defineClass(name, superclass=nil)
+        define_class(@extra_body.position, name) do |class_def|
+          superclass = constant(superclass)
+          superclass.parent = class_def
+          [superclass, body(class_def)]
+        end
+      end
+
+      def body(parent=nil)
+        parent ||= @extra_body
+        Mirah::AST::Body.new(parent, parent.position)
+      end
+
       def define_closure(position, name, enclosing_type)
         target = self
         parent = @extra_body