mirah 0.0.5-java → 0.0.6-java

data/lib/mirah/ast/intrinsics.rb

@@ -20,22 +20,14 @@ module Mirah::AST
   class Unquote < Node
     child :value
 
-    def infer(typer)
-      raise "Unquote used outside of macro"
+    def infer(typer, expression)
+      raise Mirah::SyntaxError.new("Unquote used outside of macro", self)
     end
 
     def _dump(depth)
       vals = Unquote.__extracted
       index = vals.size
-      # Make sure the scope is saved
-      if Scoped === value
-        value.scope
-        scoped_value = value
-      else
-        scoped_value = ScopedBody.new(value.parent, value.position) {[value]}
-        scoped_value.static_scope = scoped_value.scope.static_scope
-      end
-      vals << self.value
+      vals << value
       Marshal.dump([position, index])
     end
 
@@ -70,21 +62,22 @@ module Mirah::AST
     end
 
     def self.extract_values
-      values = self.__extracted = []
+      values = []
+      saved, self.__extracted = self.__extracted, values
       begin
         yield
         return values
       ensure
-        self.__extracted = nil
+        self.__extracted = saved
       end
     end
 
     def self.inject_values(values)
-      self.__injected = values
+      saved, self.__injected = self.__injected, values
       begin
         yield
       ensure
-        self.__injected = nil
+        self.__injected = saved
       end
     end
   end
@@ -101,6 +94,8 @@ module Mirah::AST
         value
       when Named
         value.name
+      when Node
+        value.string_value
       else
         raise "Bad unquote value #{value}"
       end
@@ -128,8 +123,8 @@ module Mirah::AST
       case value
       when Arguments, Argument
         value
-      when Named
-        RequiredArgument.new(nil, position, value.name)
+      when Node
+        RequiredArgument.new(nil, position, value.string_value)
       when ::String
         RequiredArgument.new(nil, position, value)
       else
@@ -142,8 +137,8 @@ module Mirah::AST
     child :name
     child :value
 
-    def infer(typer)
-      raise "UnquoteAssign used outside of macro"
+    def infer(typer, expression)
+      raise Mirah::SyntaxError.new("UnquoteAssign used outside of macro")
     end
 
     def _dump(depth)
@@ -172,6 +167,12 @@ module Mirah::AST
     end
 
     def node
+      if ScopedBody === self.name_node
+        scope = name_node
+        name_node = scope.children[0]
+      else
+        name_node = self.name_node
+      end
       klass = LocalAssignment
       if Field === name_node
         name = name_node.name
@@ -182,7 +183,7 @@ module Mirah::AST
       elsif String === name_node
         name = name_node.literal
       elsif ::String === name_node
-        name = name
+        name = name_node
       else
         raise "Bad unquote value"
       end
@@ -193,7 +194,12 @@ module Mirah::AST
       n = klass.new(nil, position, name)
       n << value
       n.validate_children
-      return n
+      if scope
+        scope.children.clear
+        scope << n
+      else
+        return n
+      end
     end
 
     def f_arg
@@ -217,10 +223,10 @@ module Mirah::AST
 
     def initialize(parent, line_number, name, &block)
       super(parent, line_number, &block)
-      @name = name
+      self.name = name
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         self_type = scope.static_scope.self_type
         extension_name = "%s$%s" % [self_type.name,
@@ -239,7 +245,7 @@ module Mirah::AST
           self_type.add_method(name, arg_types, macro)
         end
         proxy.__inline__(Noop.new(parent, position))
-        proxy.infer(typer)
+        proxy.infer(typer, expression)
       end
     end
 
@@ -270,12 +276,13 @@ module Mirah::AST
       new_factory = orig_factory.dup
       Mirah::AST.type_factory = new_factory
       ast = build_ast(name, parent, transformer)
-      puts ast.inspect if state.verbose
       classes = compile_ast(name, ast, transformer)
       loader = MirahClassLoader.new(
           JRuby.runtime.jruby_class_loader, classes)
       klass = loader.loadClass(name, true)
-      annotate(parent, name)
+      if state.save_extensions
+        annotate(parent, name)
+      end
       Mirah::AST.type_factory = orig_factory
       klass
     end
@@ -304,20 +311,29 @@ module Mirah::AST
     end
 
     def compile_ast(name, ast, transformer)
-      typer = Mirah::Typer::JVM.new(transformer)
-      typer.infer(ast)
-      typer.resolve(true)
+      begin
+        typer = Mirah::Typer::JVM.new(transformer)
+        typer.infer(ast, false)
+        typer.resolve(true)
+        typer.errors.each do |e|
+          raise e
+        end
+      ensure
+        puts ast.inspect if transformer.state.verbose
+      end
       compiler = Mirah::Compiler::JVM.new
       ast.compile(compiler, false)
       class_map = {}
       compiler.generate do |outfile, builder|
-        outfile = "#{transformer.destination}#{outfile}"
-        FileUtils.mkdir_p(File.dirname(outfile))
-        File.open(outfile, 'wb') do |f|
-          bytes = builder.generate
-          name = builder.class_name.gsub(/\//, '.')
-          class_map[name] = bytes
-          f.write(bytes)
+        bytes = builder.generate
+        name = builder.class_name.gsub(/\//, '.')
+        class_map[name] = bytes
+        if transformer.state.save_extensions
+          outfile = "#{transformer.destination}#{outfile}"
+          FileUtils.mkdir_p(File.dirname(outfile))
+          File.open(outfile, 'wb') do |f|
+            f.write(bytes)
+          end
         end
       end
       class_map
@@ -325,7 +341,7 @@ module Mirah::AST
 
     def build_ast(name, parent, transformer)
       # TODO should use a new type factory too.
-      
+
       ast = Mirah::AST.parse_ruby("begin;end")
       ast = transformer.transform(ast, nil)
 
@@ -372,6 +388,12 @@ module Mirah::AST
         [arg.name, type, arg.position]
       end
       m = extension.define_method(position, '_expand', node_type, *actual_args)
+      scope.static_scope.imports.each do |short, long|
+        m.static_scope.import(long, short)
+      end
+      scope.static_scope.search_packages.each do |package|
+        m.static_scope.import(package, '*')
+      end
       m.body = self.body
       ast.body = extension
       ast

data/lib/mirah/ast/literal.rb

@@ -19,11 +19,13 @@ module Mirah::AST
       super(parent, line_number, &block)
     end
 
-    def infer(typer)
-      children.each do |kid|
-        kid.infer(typer)
+    def infer(typer, expression)
+      resolve_if(typer) do
+        children.each do |kid|
+          kid.infer(typer, true)
+        end
+        @inferred_type = typer.array_type
       end
-      @inferred_type = typer.array_type
     end
   end
 
@@ -35,7 +37,7 @@ module Mirah::AST
       @literal = literal
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) {@inferred_type = typer.fixnum_type(@literal)}
     end
 
@@ -56,7 +58,7 @@ module Mirah::AST
       @literal = literal
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) {@inferred_type = typer.float_type(@literal)}
     end
   end
@@ -71,7 +73,7 @@ module Mirah::AST
       @literal = literal
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       return @inferred_type if resolved?
       resolved!
       @inferred_type ||= typer.regexp_type
@@ -88,7 +90,7 @@ module Mirah::AST
       @literal = literal
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       return @inferred_type if resolved?
       resolved!
       @inferred_type ||= typer.string_type
@@ -108,10 +110,10 @@ module Mirah::AST
       super(parent, position, &block)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       unless resolved?
         resolved = true
-        children.each {|node| node.infer(typer); resolved &&= node.resolved?}
+        children.each {|node| node.infer(typer, true); resolved &&= node.resolved?}
         resolved! if resolved
         @inferred_type ||= typer.string_type
       end
@@ -126,9 +128,9 @@ module Mirah::AST
       super(parent, position)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       unless resolved?
-        body.infer(typer)
+        body.infer(typer, true)
         resolved! if body.resolved?
         @inferred_type ||= typer.string_type
       end
@@ -146,7 +148,7 @@ module Mirah::AST
       @literal = literal
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       return @inferred_type if resolved?
       resolved!
       @inferred_type ||= typer.boolean_type
@@ -160,7 +162,7 @@ module Mirah::AST
       super(parent, line_number)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       return @inferred_type if resolved?
       resolved!
       @inferred_type ||= typer.null_type

data/lib/mirah/ast/local.rb

@@ -24,14 +24,14 @@ module Mirah::AST
 
     def initialize(parent, line_number, name, &block)
       super(parent, line_number, &block)
-      @name = name
+      self.name = name
     end
 
     def captured?
       scope.static_scope.captured?(name)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name
         @type = type_node.type_reference(typer)
@@ -53,7 +53,7 @@ module Mirah::AST
 
     def initialize(parent, line_number, name, &block)
       super(parent, line_number, &block)
-      @name = name
+      self.name = name
     end
 
     def captured?
@@ -64,10 +64,10 @@ module Mirah::AST
       "LocalAssignment(name = #{name}, scope = #{scope}, captured = #{captured? == true})"
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name
-        typer.infer(value)
+        typer.infer(value, true)
       end
     end
 
@@ -83,18 +83,18 @@ module Mirah::AST
 
     def initialize(parent, line_number, name)
       super(parent, line_number, [])
-      @name = name
+      self.name = name
     end
 
     def captured?
-      scope.static_scope.captured?(name)
+      scope && scope.static_scope.captured?(name)
     end
 
     def to_s
       "Local(name = #{name}, scope = #{scope}, captured = #{captured? == true})"
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name
         typer.local_type(containing_scope, name)

data/lib/mirah/ast/method.rb

@@ -25,9 +25,9 @@ module Mirah::AST
       super(parent, line_number, &block)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       unless resolved?
-        @inferred_type = args ? args.map {|arg| typer.infer(arg)} : []
+        @inferred_type = args ? args.map {|arg| typer.infer(arg, true)} : []
         if @inferred_type.all?
           resolved!
         else
@@ -115,10 +115,10 @@ module Mirah::AST
     def initialize(parent, line_number, name, type=nil)
       super(parent, line_number, [type])
 
-      @name = name
+      self.name = name
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name
         # if not already typed, check parent of parent (MethodDefinition)
@@ -144,17 +144,17 @@ module Mirah::AST
 
     def initialize(parent, line_number, name, &block)
       super(parent, line_number, &block)
-      @name = name
+      self.name = name
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name
         # if not already typed, check parent of parent (MethodDefinition)
         # for signature info
         method_def = parent.parent
         signature = method_def.signature
-        value_type = value.infer(typer)
+        value_type = value.infer(typer, true)
         declared_type = type_node.type_reference(typer) if type_node
         signature[name.intern] = declared_type || value_type
       end
@@ -168,10 +168,10 @@ module Mirah::AST
     def initialize(parent, line_number, name)
       super(parent, line_number)
 
-      @name = name
+      self.name = name
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       scope.static_scope << name
       super
     end
@@ -186,10 +186,10 @@ module Mirah::AST
     def initialize(parent, line_number, name)
       super(parent, line_number)
 
-      @name = name
+      self.name = name
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       scope.static_scope << name
       super
     end
@@ -202,6 +202,7 @@ module Mirah::AST
     include Scoped
     include ClassScoped
     include Binding
+    include Java::DubyLangCompiler.MethodDefinition
 
     child :signature
     child :arguments
@@ -216,7 +217,7 @@ module Mirah::AST
     def initialize(parent, line_number, name, annotations=[], &block)
       @annotations = annotations
       super(parent, line_number, &block)
-      @name = name
+      self.name = name
       @visibility = (class_scope && class_scope.current_access_level) || :public
     end
 
@@ -224,24 +225,30 @@ module Mirah::AST
       super
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         @defining_class ||= begin
+          static_scope.self_node = :self
           static_scope.self_type = if static?
             scope.static_scope.self_type.meta
           else
             scope.static_scope.self_type
           end
         end
-        @annotations.each {|a| a.infer(typer)} if @annotations
-        typer.infer(arguments)
+        @annotations.each {|a| a.infer(typer, true)} if @annotations
+        typer.infer(arguments, true)
+        if @return_type.kind_of?(UnquotedValue)
+          @return_type = @return_type.node
+          @return_type.parent = self
+        end
         signature[:return] = @return_type.type_reference(typer) if @return_type
         if @exceptions
           signature[:throws] = @exceptions.map {|e| e.type_reference(typer)}
         end
         typer.infer_signature(self)
         forced_type = signature[:return]
-        inferred_type = body ? typer.infer(body) : typer.no_type
+        body_is_expression = (forced_type != typer.no_type)
+        inferred_type = body ? typer.infer(body, body_is_expression) : typer.no_type
 
         if inferred_type && arguments.inferred_type.all?
           actual_type = if forced_type.nil?
@@ -283,7 +290,7 @@ module Mirah::AST
             arguments.args.each do |arg|
               if OptionalArgument === arg
                 arg_types_for_opt = args_for_opt.map do |arg_for_opt|
-                  arg_for_opt.infer(typer)
+                  arg_for_opt.infer(typer, true)
                 end
                 typer.learn_method_type(defining_class, name, arg_types_for_opt, type, signature[:throws])
               end
@@ -318,6 +325,13 @@ module Mirah::AST
       extract_delegate_constructor
     end
 
+    def validate_children
+      super
+      if @delegate_args
+        @delegate_args.each {|arg| arg.parent = self}
+      end
+    end
+
     def first_node
       if body.kind_of? Body
         body.children[0]
@@ -354,9 +368,9 @@ module Mirah::AST
       self.first_node = Noop.new(self, position) if @delegate_args
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       unless @inferred_type
-        delegate_args.each {|a| typer.infer(a)} if delegate_args
+        delegate_args.each {|a| typer.infer(a, true)} if delegate_args
       end
       super
     end