mirah 0.0.5-java → 0.0.6-java

data/lib/mirah/ast/structure.rb

@@ -15,19 +15,25 @@
 
 module Mirah::AST
   class Body < Node
+    include Java::DubyLangCompiler.Body
+
     def initialize(parent, line_number, &block)
       super(parent, line_number, &block)
     end
 
     # Type of a block is the type of its final element
-    def infer(typer)
+    def infer(typer, expression)
       unless @inferred_type
         @typer ||= typer
         @self_type ||= typer.self_type
         if children.size == 0
           @inferred_type = typer.no_type
         else
-          children.each {|child| @inferred_type = typer.infer(child)}
+          last = children.size - 1
+          children.each_with_index do |child, i|
+            child_is_expression = (i == last && expression)
+            @inferred_type = typer.infer(child, child_is_expression)
+          end
         end
 
         if @inferred_type
@@ -40,16 +46,29 @@ module Mirah::AST
       @inferred_type
     end
 
+    def string_value
+      if children.size == 1
+        children[0].string_value
+      else
+        super
+      end
+    end
+
     def <<(node)
       super
       if @typer
         orig_self = @typer.self_type
         @typer.known_types['self'] = @self_type
-        @typer.infer(node)
+        @typer.infer(node, true)
         @typer.known_types['self'] = orig_self
       end
       self
     end
+
+    def add_node(node)
+      self << node
+    end
+
   end
 
   # class << self
@@ -61,7 +80,7 @@ module Mirah::AST
       super(parent, line_number, &block)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       static_scope.self_type = scope.static_scope.self_type.meta
       super
     end
@@ -71,16 +90,38 @@ module Mirah::AST
     include Scope
     include Scoped
 
-    def infer(typer)
+    def infer(typer, expression)
       static_scope.self_type ||= typer.self_type
       super
     end
 
+    def binding_type(duby=nil)
+      static_scope.binding_type(defining_class, duby)
+    end
+
+    def binding_type=(type)
+      static_scope.binding_type = type
+    end
+
+    def has_binding?
+      static_scope.has_binding?
+    end
+
+    def type_reference(typer)
+      raise Mirah::SyntaxError.new("Invalid type", self) unless children.size == 1
+      children[0].type_reference(typer)
+    end
+
     def inspect_children(indent=0)
       indent_str = ' ' * indent
       str = ''
       if static_scope.self_node
-        str << "\n#{indent_str}self:\n" << static_scope.self_node.inspect(indent + 1)
+        str << "\n#{indent_str}self: "
+        if Node === static_scope.self_node
+          str << "\n" << static_scope.self_node.inspect(indent + 1)
+        else
+          str << static_scope.self_node.inspect
+        end
       end
       str << "\n#{indent_str}body:" << super(indent + 1)
     end
@@ -115,7 +156,7 @@ module Mirah::AST
 
       # TODO We need a special scope here that allows access to the
       # outer class.
-      static_scope.self_type = typer.infer(klass)
+      static_scope.self_type = typer.infer(klass, true)
 
       add_methods(klass, binding, typer)
 
@@ -127,7 +168,7 @@ module Mirah::AST
       ]
       call.parameters << instance
       call.block = nil
-      typer.infer(instance)
+      typer.infer(instance, true)
     end
 
     def add_methods(klass, binding, typer)
@@ -165,7 +206,7 @@ module Mirah::AST
         mdef.static_scope = static_scope
         mdef.body = body.dup
         mdef.binding_type = binding
-        typer.infer(mdef.body)
+        typer.infer(mdef.body, true)
       end
     end
 
@@ -187,14 +228,14 @@ module Mirah::AST
       @inferred_type = type
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolved! unless resolved?
       @inferred_type
     end
   end
 
   class Noop < Node
-    def infer(typer)
+    def infer(typer, expression)
       resolved!
       @inferred_type ||= typer.no_type
     end
@@ -213,13 +254,13 @@ module Mirah::AST
       @package = ""
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         typer.set_filename(self, filename)
         @defining_class ||= begin
           static_scope.self_type = typer.self_type
         end
-        typer.infer(body)
+        typer.infer(body, false)
       end
     end
 

data/lib/mirah/ast/type.rb

@@ -22,21 +22,18 @@ module Mirah::AST
       @short = short
       @long = long
       super(parent, line_number, [])
-      scope.static_scope.import(long, short)
     end
 
     def to_s
       "Import(#{short} = #{long})"
     end
 
-    def infer(typer)
-      begin
-        typer.type_reference(scope, @long)
-      rescue NameError => ex
-        typer.known_types[short] = Mirah::AST.error_type
-        raise ex
+    def infer(typer, expression)
+      resolve_if(typer) do
+        scope.static_scope.import(long, short)
+        typer.type_reference(scope, @long) if short != '*'
+        typer.no_type
       end
-      typer.no_type
     end
   end
 
@@ -128,17 +125,17 @@ module Mirah::AST
       super(*args)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         @component_type = type_node.type_reference(typer)
-        typer.infer(size)
+        typer.infer(size, true)
         typer.type_reference(nil, @component_type, true)
       end
     end
   end
 
   class Builtin < Node
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) {Mirah::AST.type(nil, 'mirah.impl.Builtin')}
     end
   end

data/lib/mirah/compiler.rb

@@ -23,6 +23,8 @@ module Mirah
           compiler.line(line_number)
           compiler.fixnum(inferred_type, literal)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -32,6 +34,8 @@ module Mirah
           compiler.line(line_number)
           compiler.regexp(literal)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -41,18 +45,24 @@ module Mirah
           compiler.line(line_number)
           compiler.string(literal)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class StringConcat
       def compile(compiler, expression)
         compiler.build_string(children, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class ToString
       def compile(compiler, expression)
         compiler.to_string(body, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -62,6 +72,8 @@ module Mirah
           compiler.line(line_number)
           compiler.float(inferred_type, literal)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -71,12 +83,16 @@ module Mirah
           compiler.line(line_number)
           compiler.boolean(literal)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class Array
       def compile(compiler, expression)
         compiler.array(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -84,6 +100,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.body(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -91,6 +109,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.scoped_body(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -98,6 +118,8 @@ module Mirah
       def compile(compiler, expression)
         # TODO: what does it mean for import to be an expression?
         compiler.import(short, long)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -107,6 +129,8 @@ module Mirah
           compiler.line(line_number)
           compiler.constant(self)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -115,6 +139,8 @@ module Mirah
         # TODO: what does it mean for printline to be an expression?
         compiler.line(line_number)
         compiler.print(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -128,6 +154,8 @@ module Mirah
             compiler.local(containing_scope, name, inferred_type)
           end
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -139,6 +167,8 @@ module Mirah
         else
           compiler.local_declare(containing_scope, name, type)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -150,6 +180,8 @@ module Mirah
         else
           compiler.local_assign(containing_scope, name, inferred_type, expression, value)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -157,6 +189,8 @@ module Mirah
       def compile(compiler, expression)
         # TODO: what does it mean for a script to be an expression? possible?
         compiler.define_main(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -164,12 +198,16 @@ module Mirah
       def compile(compiler, expression)
         # TODO: what does it mean for a method to be an expression?
         compiler.define_method(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class ConstructorDefinition
       def compile(compiler, expression)
         compiler.constructor(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -177,6 +215,8 @@ module Mirah
       def compile(compiler, expression)
         # TODO: what does it mean for a method to be an expression?
         args.each {|arg| compiler.declare_argument(arg.name, arg.inferred_type)} if args
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -184,6 +224,8 @@ module Mirah
       def compile(compiler, expression)
         # TODO: what does it mean for a noop to be an expression
         # nothing
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -191,6 +233,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.branch(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -199,6 +243,8 @@ module Mirah
         # TODO: can a condition ever be an expression? I don't think it can...
         compiler.line(line_number)
         predicate.compile(compiler, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -206,6 +252,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.self_call(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -213,6 +261,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.call(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -220,6 +270,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.super_call(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -227,24 +279,32 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.loop(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class ClassDefinition
       def compile(compiler, expression)
         compiler.define_class(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class ClosureDefinition
       def compile(compiler, expression)
         compiler.define_closure(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
     class FieldDeclaration
       def compile(compiler, expression)
         compiler.field_declare(name, inferred_type, annotations, static)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -252,6 +312,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.field_assign(name, inferred_type, expression, value, annotations, static)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -261,6 +323,8 @@ module Mirah
         if expression
           compiler.field(name, inferred_type, annotations, static)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -272,6 +336,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.return(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -281,6 +347,8 @@ module Mirah
           compiler.line(line_number)
           compiler.empty_array(component_type, size)
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -290,6 +358,8 @@ module Mirah
           compiler.line(line_number)
           compiler.null
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -297,6 +367,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.break(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -304,6 +376,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.next(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -311,6 +385,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.redo(self)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -318,6 +394,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler._raise(exception)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -325,6 +403,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.rescue(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -332,6 +412,8 @@ module Mirah
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.ensure(self, expression)
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -341,6 +423,8 @@ module Mirah
           compiler.line(line_number)
           compiler.compile_self
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
 
@@ -350,6 +434,8 @@ module Mirah
           compiler.line(line_number)
           compiler.binding_reference
         end
+      rescue Exception => ex
+        raise Mirah::InternalCompilerError.wrap(ex, self)
       end
     end
   end