mirah 0.0.5-java → 0.0.6-java

data/lib/mirah/ast/call.rb

@@ -13,43 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'delegate'
-
 module Mirah::AST
-  class NodeProxy < DelegateClass(Node)
-    include Java::DubyLangCompiler::Node
-    def __inline__(node)
-      node.parent = parent
-      __setobj__(node)
-    end
-
-    def dup
-      value = __getobj__.dup
-      if value.respond_to?(:proxy=)
-        new = super
-        new.__setobj__(value)
-        new.proxy = new
-        new
-      else
-        value
-      end
-    end
-
-    def _dump(depth)
-      Marshal.dump(__getobj__)
-    end
-
-    def self._load(str)
-      value = Marshal.load(str)
-      if value.respond_to?(:proxy=)
-        proxy = NodeProxy.new(value)
-        proxy.proxy = proxy
-      else
-        value
-      end
-    end
-  end
-
   class FunctionalCall < Node
     include Java::DubyLangCompiler.Call
     include Named
@@ -67,18 +31,16 @@ module Mirah::AST
 
     def initialize(parent, line_number, name, &kids)
       super(parent, line_number, &kids)
-      @name = name
+      self.name = name
       @cast = false
     end
 
     def arguments
-      @arguments ||= begin
-        args = java.util.ArrayList.new(parameters.size)
-        parameters.each do |param|
-          args.add(param)
-        end
-        args
+      args = java.util.ArrayList.new(parameters.size)
+      parameters.each do |param|
+        args.add(param)
       end
+      args
     end
 
     def target
@@ -88,20 +50,21 @@ module Mirah::AST
     def validate_parameters
       parameters.each_with_index do |child, i|
         if UnquotedValue === child
+          child = child.node
           child.parent = self
-          parameters[i] = child.node
+          parameters[i] = child
         end
       end
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       unless @inferred_type
         @self_type ||= scope.static_scope.self_type
         receiver_type = @self_type
         should_defer = false
 
         parameter_types = parameters.map do |param|
-          typer.infer(param) || should_defer = true
+          typer.infer(param, true) || should_defer = true
         end
 
         parameter_types << Mirah::AST.block_type if block
@@ -115,14 +78,14 @@ module Mirah::AST
           elsif parameters.size == 0 && scope.static_scope.include?(name)
             @inlined = Local.new(parent, position, name)
             proxy.__inline__(@inlined)
-            return proxy.infer(typer)
+            return proxy.infer(typer, expression)
           else
             @inferred_type = typer.method_type(receiver_type, name,
                                                parameter_types)
             if @inferred_type.kind_of? InlineCode
               @inlined = @inferred_type.inline(typer.transformer, self)
               proxy.__inline__(@inlined)
-              return proxy.infer(typer)
+              return proxy.infer(typer, expression)
             end
           end
         end
@@ -174,34 +137,33 @@ module Mirah::AST
 
     def initialize(parent, line_number, name, &kids)
       super(parent, line_number, &kids)
-      @name = name
+      self.name = name
     end
 
     def validate_parameters
       parameters.each_with_index do |child, i|
         if UnquotedValue === child
+          child = child.node
           child.parent = self
-          parameters[i] = child.node
+          parameters[i] = child
         end
       end
     end
 
     def arguments
-      @arguments ||= begin
-        args = java.util.ArrayList.new(parameters.size)
-        parameters.each do |param|
-          args.add(param)
-        end
-        args
+      args = java.util.ArrayList.new(parameters.size)
+      parameters.each do |param|
+        args.add(param)
       end
+      args
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       unless @inferred_type
-        receiver_type = typer.infer(target)
+        receiver_type = typer.infer(target, true)
         should_defer = receiver_type.nil?
         parameter_types = parameters.map do |param|
-          typer.infer(param) || should_defer = true
+          typer.infer(param, true) || should_defer = true
         end
 
         parameter_types << Mirah::AST.block_type if block
@@ -212,7 +174,7 @@ module Mirah::AST
           if @inferred_type.kind_of? InlineCode
             @inlined = @inferred_type.inline(typer.transformer, self)
             proxy.__inline__(@inlined)
-            return proxy.infer(typer)
+            return proxy.infer(typer, expression)
           end
         end
 
@@ -266,11 +228,15 @@ module Mirah::AST
 
       # join and load
       class_name = elements.join(".")
-      begin
-        typer.type_reference(scope, class_name, array)
-      rescue NameError => ex
-        typer.known_types[class_name] = Mirah::AST.error_type
-        raise ex
+      typer.type_reference(scope, class_name, array)
+    end
+  end
+
+
+  class Colon2 < Call
+    def infer(typer, expression)
+      resolve_if(typer) do
+        type_reference(typer).meta
       end
     end
   end
@@ -285,23 +251,29 @@ module Mirah::AST
 
     def initialize(parent, line_number)
       super(parent, line_number)
-      @call_parent = parent
-      @call_parent = (@call_parent = @call_parent.parent) until MethodDefinition === @call_parent
       @cast = false
     end
 
+    def call_parent
+      @call_parent ||= begin
+        node = parent
+        node = (node && node.parent) until MethodDefinition === node
+        node
+      end
+    end
+
     def name
-      @call_parent.name
+      call_parent.name
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       @self_type ||= scope.static_scope.self_type.superclass
 
       unless @inferred_type
-        receiver_type = @call_parent.defining_class.superclass
+        receiver_type = call_parent.defining_class.superclass
         should_defer = receiver_type.nil?
         parameter_types = parameters.map do |param|
-          typer.infer(param) || should_defer = true
+          typer.infer(param, true) || should_defer = true
         end
 
         unless should_defer
@@ -314,6 +286,25 @@ module Mirah::AST
 
       @inferred_type
     end
+
+    alias originial_parameters parameters
+
+    def parameters
+      if originial_parameters.nil?
+        self.parameters = default_parameters
+      end
+      originial_parameters
+    end
+
+    def default_parameters
+      node = self
+      node = node.parent until MethodDefinition === node || node.nil?
+      return [] if node.nil?
+      args = node.arguments.children.map {|x| x || []}
+      args.flatten.map do |arg|
+        Local.new(self, position, arg.name)
+      end
+    end
   end
 
   class BlockPass < Node

data/lib/mirah/ast/class.rb

@@ -18,6 +18,8 @@ module Mirah::AST
     include Annotated
     include Named
     include Scope
+    include Java::DubyLangCompiler.ClassDefinition
+
     attr_accessor :interfaces
     attr_accessor :current_access_level
     attr_accessor :abstract
@@ -32,7 +34,7 @@ module Mirah::AST
       @annotations = annotations
       @interfaces = []
       @interface_nodes = []
-      @name = name
+      self.name = name
       self.parent = parent
       if Mirah::AST.type_factory.respond_to? :define_type
         Mirah::AST.type_factory.define_type(self)
@@ -52,11 +54,6 @@ module Mirah::AST
       node
     end
 
-    def define_inner_class(position, name, &block)
-      name = "#{self.name}$#{name}"
-      append_node ClassDefinition.new(nil, position, name, &block)
-    end
-
     def define_method(position, name, type, *args)
       append_node(_define_method(MethodDefinition, position, name, type, args))
     end
@@ -103,14 +100,14 @@ module Mirah::AST
       append_node(field)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         @superclass = superclass_node.type_reference(typer) if superclass_node
-        @annotations.each {|a| a.infer(typer)} if @annotations
+        @annotations.each {|a| a.infer(typer, true)} if @annotations
         @interfaces.concat(@interface_nodes.map{|n| n.type_reference(typer)})
         typer.define_type(self, name, superclass, @interfaces) do
           static_scope.self_type = typer.self_type
-          typer.infer(body) if body
+          typer.infer(body, false) if body
         end
       end
     end
@@ -147,12 +144,12 @@ module Mirah::AST
     def initialize(parent, position, name, annotations)
       super(parent, position, name, annotations) {|p| }
       @abstract = true
-      @name = name
+      self.name = name
       @children = [[], nil]
       @children = yield(self)
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
         @interfaces = interface_nodes.map {|i| i.type_reference(typer)}
         super
@@ -175,7 +172,7 @@ module Mirah::AST
   end
 
   defmacro('interface') do |transformer, fcall, parent|
-    raise "Interface name required" unless fcall.parameters.size > 0
+    raise Mirah::SyntaxError.new("Interface name required", fcall) unless fcall.parameters.size > 0
     interfaces = fcall.parameters
     interface_name = interfaces.shift
     if (Call === interface_name &&
@@ -210,13 +207,13 @@ module Mirah::AST
     def initialize(parent, position, name, annotations=[], static = false, &block)
       @annotations = annotations
       super(parent, position, &block)
-      @name = name
+      self.name = name
       @static = static
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
-        @annotations.each {|a| a.infer(typer)} if @annotations
+        @annotations.each {|a| a.infer(typer, true)} if @annotations
         @type = type_node.type_reference(typer)
       end
     end
@@ -243,17 +240,17 @@ module Mirah::AST
     def initialize(parent, position, name, annotations=[], static = false, &block)
       @annotations = annotations
       super(parent, position, &block)
-      @name = name
+      self.name = name
       @static = static
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
-        @annotations.each {|a| a.infer(typer)} if @annotations
+        @annotations.each {|a| a.infer(typer, true)} if @annotations
         if static
-          typer.learn_static_field_type(class_scope, name, typer.infer(value))
+          typer.learn_static_field_type(class_scope, name, typer.infer(value, true))
         else
-          typer.learn_field_type(class_scope, name, typer.infer(value))
+          typer.learn_field_type(class_scope, name, typer.infer(value, true))
         end
       end
     end
@@ -269,13 +266,13 @@ module Mirah::AST
     def initialize(parent, position, name, annotations=[], static = false, &block)
       @annotations = annotations
       super(parent, position, &block)
-      @name = name
+      self.name = name
       @static = static
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       resolve_if(typer) do
-        @annotations.each {|a| a.infer(typer)} if @annotations
+        @annotations.each {|a| a.infer(typer, true)} if @annotations
         if static
           typer.static_field_type(class_scope, name)
         else
@@ -291,11 +288,11 @@ module Mirah::AST
 
     def initialize(parent, line_number, name)
       super(parent, line_number)
-      @name = name
+      self.name = name
       class_scope.current_access_level = name.to_sym
     end
 
-    def infer(typer)
+    def infer(typer, expression)
       typer.no_type
     end
   end
@@ -303,7 +300,7 @@ module Mirah::AST
   class Include < Node
     include Scoped
 
-    def infer(typer)
+    def infer(typer, expression)
       children.each do |type|
         typeref = type.type_reference(typer)
         the_scope = scope.static_scope

data/lib/mirah/ast/flow.rb

@@ -22,16 +22,16 @@ module Mirah
         super(parent, line_number, &block)
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
-          @inferred_type = typer.infer(predicate)
+          @inferred_type = typer.infer(predicate, true)
           if @inferred_type && !@inferred_type.primitive?
             call = Call.new(parent, position, '!=') do |call|
               predicate.parent = call
               [predicate, [Null.new(call, position)]]
             end
             self.predicate = call
-            @inferred_type = typer.infer(predicate)
+            @inferred_type = typer.infer(predicate, true)
           end
 
           @inferred_type ? resolved! : typer.defer(self)
@@ -50,60 +50,40 @@ module Mirah
         super(parent, line_number, &block)
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
-          condition_type = typer.infer(condition)
+          condition_type = typer.infer(condition, true)
           unless condition_type
             typer.defer(condition)
           end
 
           # condition type is unrelated to body types, so we proceed with bodies
-          then_type = typer.infer(body) if body
-
-          if !then_type
-            # attempt to determine else branch
-            if self.else
-              else_type = typer.infer(self.else)
-
-              if !else_type
-                # we have neither type, defer until later
-                typer.defer(self)
-              else
-                # we have else but not then, defer only then and use else type for now
-                @inferred_type = else_type
-                if body
-                  typer.defer(self)
-                else
-                  resolved! if condition_type
-                end
-              end
-            else
-              # no then type could be inferred and no else body, defer for now
-              typer.defer(self)
-            end
-          else
-            if self.else
-              else_type = typer.infer(self.else)
-
-              if !else_type
-                # we determined a then type, so we use that and defer the else body
-                @inferred_type = then_type
-                typer.defer(self)
-              else
+          then_type = typer.infer(body, expression) if body
+          else_type = typer.infer(self.else, expression) if self.else
+
+          if expression
+            have_body_type = body.nil? || then_type
+            have_else_type = self.else.nil? || else_type
+            if have_body_type && have_else_type
+              if then_type && else_type
                 # both then and else inferred, ensure they're compatible
                 if then_type.compatible?(else_type)
                   # types are compatible...if condition is resolved, we're done
                   @inferred_type = then_type.narrow(else_type)
                   resolved! if condition_type
                 else
-                  raise Typer::InferenceError.new("if statement with incompatible result types #{then_type} and #{else_type}")
+                  raise Mirah::Typer::InferenceError.new("if statement with incompatible result types #{then_type} and #{else_type}")
                 end
+              else
+                @inferred_type = then_type || else_type
+                resolved!
               end
             else
-              # only then and type inferred, we're 100% resolved
-              @inferred_type = then_type
-              resolved! if condition_type
+              typer.defer(self)
             end
+          else
+            @inferred_type = typer.no_type
+            resolved!
           end
         end
 
@@ -136,13 +116,13 @@ module Mirah
         end
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
           child_types = children.map do |c|
             if c.nil? || (Body === c && c.empty?)
               typer.no_type
             else
-              typer.infer(c)
+              typer.infer(c, true)
             end
           end
           if child_types.any? {|t| t.nil?}
@@ -211,10 +191,10 @@ module Mirah
         super(parent, line_number, &block)
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         resolve_if(typer) do
           if value
-            typer.infer(value)
+            typer.infer(value, true)
           else
             typer.no_type
           end
@@ -223,7 +203,7 @@ module Mirah
     end
 
     class Break < Node;
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
           resolved!
           @inferred_type = typer.null_type
@@ -245,12 +225,12 @@ module Mirah
         super(parent, line_number, &block)
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
           @inferred_type = AST.unreachable_type
           throwable = AST.type(nil, 'java.lang.Throwable')
           if children.size == 1
-            arg_type = typer.infer(self.exception)
+            arg_type = typer.infer(self.exception, true)
             unless arg_type
               typer.defer(self)
               return
@@ -261,7 +241,7 @@ module Mirah
             end
           end
 
-          arg_types = children.map {|c| typer.infer(c)}
+          arg_types = children.map {|c| typer.infer(c, true)}
           if arg_types.any? {|c| c.nil?}
             typer.defer(self)
           else
@@ -275,7 +255,7 @@ module Mirah
             end
             resolved!
             @children = [exception]
-            typer.infer(exception)
+            typer.infer(exception, true)
           end
         end
         @inferred_type
@@ -302,7 +282,7 @@ module Mirah
         end
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
           @types ||= type_nodes.map {|n| n.type_reference(typer)}
           if name
@@ -311,11 +291,7 @@ module Mirah
             @type = types.size == 1 ? types[0] : AST.type(nil, 'java.lang.Throwable')
             typer.learn_local_type(static_scope, name, @type)
           end
-          @inferred_type = typer.infer(body)
-
-          if (@inferred_type && !body.resolved?)
-            puts "#{body} not resolved"
-          end
+          @inferred_type = typer.infer(body, true)
 
           (@inferred_type && body.resolved?) ? resolved! : typer.defer(self)
         end
@@ -344,9 +320,9 @@ module Mirah
         @body, @clauses = children
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         unless resolved?
-          types = [typer.infer(body)] + clauses.map {|c| typer.infer(c)}
+          types = [typer.infer(body, true )] + clauses.map {|c| typer.infer(c, true)}
           if types.any? {|t| t.nil?}
             typer.defer(self)
           else
@@ -362,16 +338,16 @@ module Mirah
     class Ensure < Node
       child :body
       child :clause
-      attr_accessor :state  # Used by the some compilers.
+      attr_accessor :state  # Used by some compilers.
 
       def initialize(parent, position, &block)
         super(parent, position, &block)
       end
 
-      def infer(typer)
+      def infer(typer, expression)
         resolve_if(typer) do
-          typer.infer(clause)
-          typer.infer(body)
+          typer.infer(clause, false)
+          typer.infer(body, true)
         end
       end
     end