mirah 0.0.4-java

data/lib/mirah/ast/call.rb

@@ -0,0 +1,307 @@
+require 'delegate'
+
+module Duby::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
+    include Scoped
+    attr_accessor :cast, :inlined, :proxy
+    alias cast? cast
+
+    child :parameters
+    child :block
+
+    def self.new(*args, &block)
+      real_node = super
+      real_node.proxy = NodeProxy.new(real_node)
+    end
+
+    def initialize(parent, line_number, name, &kids)
+      super(parent, line_number, &kids)
+      @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
+      end
+    end
+
+    def target
+      nil
+    end
+
+    def validate_parameters
+      parameters.each_with_index do |child, i|
+        if UnquotedValue === child
+          child.parent = self
+          parameters[i] = child.node
+        end
+      end
+    end
+
+    def infer(typer)
+      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
+        end
+
+        parameter_types << Duby::AST.block_type if block
+
+        unless should_defer
+          if parameters.size == 1 && typer.known_type(scope, name)
+            # cast operation
+            resolved!
+            self.cast = true
+            @inferred_type = typer.known_type(scope, name)
+          elsif parameters.size == 0 && scope.static_scope.include?(name)
+            @inlined = Local.new(parent, position, name)
+            proxy.__inline__(@inlined)
+            return proxy.infer(typer)
+          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)
+            end
+          end
+        end
+
+        if @inferred_type
+          if block
+            method = receiver_type.get_method(name, parameter_types)
+            block.prepare(typer, method)
+          end
+          @inferred_type = receiver_type if @inferred_type.void?
+          resolved!
+        else
+          if should_defer || receiver_type.nil?
+            message = nil
+          else
+            parameter_names = parameter_types.map {|t| t.full_name}.join(', ')
+            receiver = receiver_type.full_name
+            desc = "#{name}(#{parameter_names})"
+            kind = receiver_type.meta? ? "static" : "instance"
+            message = "Cannot find #{kind} method #{desc} on #{receiver}"
+          end
+          typer.defer(proxy, message)
+        end
+      end
+
+      @inferred_type
+    end
+
+    def type_reference(typer)
+      typer.type_reference(scope, name)
+    end
+  end
+
+  class Call < Node
+    include Java::DubyLangCompiler.Call
+    include Named
+    include Scoped
+    attr_accessor :cast, :inlined, :proxy
+    alias cast? cast
+
+    child :target
+    child :parameters
+    child :block
+
+    def self.new(*args, &block)
+      real_node = super
+      real_node.proxy = NodeProxy.new(real_node)
+    end
+
+    def initialize(parent, line_number, name, &kids)
+      super(parent, line_number, &kids)
+      @name = name
+    end
+
+    def validate_parameters
+      parameters.each_with_index do |child, i|
+        if UnquotedValue === child
+          child.parent = self
+          parameters[i] = child.node
+        end
+      end
+    end
+
+    def arguments
+      @arguments ||= begin
+        args = java.util.ArrayList.new(parameters.size)
+        parameters.each do |param|
+          args.add(param)
+        end
+        args
+      end
+    end
+
+    def infer(typer)
+      unless @inferred_type
+        receiver_type = typer.infer(target)
+        should_defer = receiver_type.nil?
+        parameter_types = parameters.map do |param|
+          typer.infer(param) || should_defer = true
+        end
+
+        parameter_types << Duby::AST.block_type if block
+
+        unless should_defer
+          @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)
+          end
+        end
+
+        if @inferred_type
+          if block && !receiver_type.error?
+            method = receiver_type.get_method(name, parameter_types)
+            block.prepare(typer, method)
+          end
+          @inferred_type = receiver_type if @inferred_type.void?
+          resolved!
+        else
+          if should_defer
+            message = nil
+          else
+            parameter_names = parameter_types.map {|t| t.full_name}.join(', ')
+            receiver = receiver_type.full_name
+            desc = "#{name}(#{parameter_names})"
+            kind = receiver_type.meta? ? "static" : "instance"
+            message = "Cannot find #{kind} method #{desc} on #{receiver}"
+          end
+          typer.defer(proxy, message)
+        end
+      end
+
+      @inferred_type
+    end
+
+    def type_reference(typer)
+      if name == "[]"
+        # array type, top should be a constant; find the rest
+        array = true
+        elements = []
+      else
+        array = false
+        elements = [name]
+      end
+      old_receiver = nil
+      receiver = self.target
+      while !receiver.eql?(old_receiver)
+        old_receiver = receiver
+        case receiver
+        when Constant, FunctionalCall, Local, Annotation
+          elements.unshift(receiver.name)
+        when Call
+          elements.unshift(receiver.name)
+          receiver = receiver.target
+        when String
+          elements.unshift(receiver.literal)
+        end
+      end
+
+      # join and load
+      class_name = elements.join(".")
+      begin
+        typer.type_reference(scope, class_name, array)
+      rescue NameError => ex
+        typer.known_types[class_name] = Duby::AST.error_type
+        raise ex
+      end
+    end
+  end
+
+  class Super < Node
+    include Named
+    include Scoped
+    attr_accessor :method, :cast
+    alias :cast? :cast
+
+    child :parameters
+
+    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 name
+      @call_parent.name
+    end
+
+    def infer(typer)
+      @self_type ||= scope.static_scope.self_type.superclass
+
+      unless @inferred_type
+        receiver_type = @call_parent.defining_class.superclass
+        should_defer = receiver_type.nil?
+        parameter_types = parameters.map do |param|
+          typer.infer(param) || should_defer = true
+        end
+
+        unless should_defer
+          @inferred_type = typer.method_type(receiver_type, name,
+                                             parameter_types)
+        end
+
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+
+      @inferred_type
+    end
+  end
+
+  class BlockPass < Node
+    child :value
+  end
+end

data/lib/mirah/ast/class.rb

@@ -0,0 +1,311 @@
+module Duby::AST
+  class ClassDefinition < Node
+    include Annotated
+    include Named
+    include Scope
+    attr_accessor :interfaces
+    attr_accessor :current_access_level
+    attr_accessor :abstract
+
+    child :superclass_node
+    child :body
+
+    attr_accessor :superclass
+
+    def initialize(parent, position, name, annotations=[], &block)
+      @abstract = false
+      @annotations = annotations
+      @interfaces = []
+      @interface_nodes = []
+      @name = name
+      self.parent = parent
+      if Duby::AST.type_factory.respond_to? :define_type
+        Duby::AST.type_factory.define_type(self)
+      end
+      # We need somewhere to collect nodes that get appended during
+      # the transform phase.
+      @extra_body = Body.new(self, position)
+      super(parent, position, &block)
+      if body
+        @extra_body.insert(0, body)
+      end
+      self.body = @extra_body
+    end
+
+    def append_node(node)
+      @extra_body << node
+      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
+
+    def define_static_method(position, name, type, *args)
+      append_node(
+          _define_method(StaticMethodDefinition, position, name, type, args))
+    end
+
+    def define_constructor(position, *args, &block)
+      append_node(_define_method(
+          ConstructorDefinition, position, 'initialize', nil, args, &block))
+    end
+
+    def _define_method(klass, position, name, type, args)
+      klass.new(nil, position, name) do |method|
+        signature = {:return => type}
+        if Arguments === args[0]
+          args_node = args[0]
+          args_node.parent = method
+        else
+          args_node = Arguments.new(method, position) do |args_node|
+            arg_list = args.map do |arg_name, arg_type, arg_position|
+              signature[arg_name.intern] = arg_type
+              arg_position ||= position
+              RequiredArgument.new(args_node, arg_position, arg_name)
+            end
+            [arg_list, nil, nil, nil]
+          end
+        end
+        [
+          signature,
+          args_node,
+          if block_given?
+            yield(method)
+          end
+        ]
+      end
+    end
+
+    def declare_field(position, name, type)
+      field = FieldDeclaration.new(nil, position || self.position, name)
+      field.type = type.dup
+      append_node(field)
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        @superclass = superclass_node.type_reference(typer) if superclass_node
+        @annotations.each {|a| a.infer(typer)} 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
+        end
+      end
+    end
+
+    def implements(*types)
+      raise ArgumentError if types.any? {|x| x.nil?}
+      types.each do |type|
+        if Duby::AST::TypeReference === type
+          @interfaces << type
+        else
+          @interface_nodes << type
+        end
+      end
+    end
+  end
+
+  defmacro('implements') do |transformer, fcall, parent|
+    klass = parent
+    klass = klass.parent unless ClassDefinition === klass
+
+    interfaces = fcall.parameters.map do |interface|
+      interface.parent = klass
+      interface
+    end
+    klass.implements(*interfaces)
+    Noop.new(parent, fcall.position)
+  end
+
+  class InterfaceDeclaration < ClassDefinition
+    attr_accessor :superclass, :interfaces
+    child :interface_nodes
+    child :body
+
+    def initialize(parent, position, name, annotations)
+      super(parent, position, name, annotations) {|p| }
+      @abstract = true
+      @name = name
+      @children = [[], nil]
+      @children = yield(self)
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        @interfaces = interface_nodes.map {|i| i.type_reference(typer)}
+        super
+      end
+    end
+
+    def superclass_node
+      nil
+    end
+  end
+
+  class ClosureDefinition < ClassDefinition
+    attr_accessor :enclosing_type
+    def initialize(parent, position, name, enclosing_type)
+      super(parent, position, name, []) do
+        [nil, nil]
+      end
+      @enclosing_type = enclosing_type
+    end
+  end
+
+  defmacro('interface') do |transformer, fcall, parent|
+    raise "Interface name required" unless fcall.parameters.size > 0
+    interfaces = fcall.parameters
+    interface_name = interfaces.shift
+    if (Call === interface_name &&
+        interface_name.parameters.size == 1)
+      interfaces.unshift(interface_name.parameters[0])
+      interface_name = interface_name.target
+    end
+    raise 'Interface body required' unless fcall.block
+    InterfaceDeclaration.new(parent, fcall.position,
+                             interface_name.name,
+                             transformer.annotations) do |interface|
+      interfaces.each {|x| x.parent = interface}
+      [interfaces,
+       if fcall.block.body
+         fcall.block.body.parent = interface
+         fcall.block.body
+       end
+      ]
+    end
+  end
+
+  class FieldDeclaration < Node
+    include Annotated
+    include Named
+    include ClassScoped
+    include Typed
+
+    child :type_node
+    attr_accessor :type
+    attr_accessor :static
+
+    def initialize(parent, position, name, annotations=[], static = false, &block)
+      @annotations = annotations
+      super(parent, position, &block)
+      @name = name
+      @static = static
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        @annotations.each {|a| a.infer(typer)} if @annotations
+        @type = type_node.type_reference(typer)
+      end
+    end
+
+    def resolved!(typer)
+      if static
+        typer.learn_static_field_type(class_scope, name, @inferred_type)
+      else
+        typer.learn_field_type(class_scope, name, @inferred_type)
+      end
+      super
+    end
+  end
+
+  class FieldAssignment < Node
+    include Annotated
+    include Named
+    include Valued
+    include ClassScoped
+
+    child :value
+    attr_accessor :static
+
+    def initialize(parent, position, name, annotations=[], static = false, &block)
+      @annotations = annotations
+      super(parent, position, &block)
+      @name = name
+      @static = static
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        @annotations.each {|a| a.infer(typer)} if @annotations
+        if static
+          typer.learn_static_field_type(class_scope, name, typer.infer(value))
+        else
+          typer.learn_field_type(class_scope, name, typer.infer(value))
+        end
+      end
+    end
+  end
+
+  class Field < Node
+    include Annotated
+    include Named
+    include ClassScoped
+    
+    attr_accessor :static
+
+    def initialize(parent, position, name, annotations=[], static = false, &block)
+      @annotations = annotations
+      super(parent, position, &block)
+      @name = name
+      @static = static
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        @annotations.each {|a| a.infer(typer)} if @annotations
+        if static
+          typer.static_field_type(class_scope, name)
+        else
+          typer.field_type(class_scope, name)
+        end
+      end
+    end
+  end
+
+  class AccessLevel < Node
+    include ClassScoped
+    include Named
+
+    def initialize(parent, line_number, name)
+      super(parent, line_number)
+      @name = name
+      class_scope.current_access_level = name.to_sym
+    end
+
+    def infer(typer)
+      typer.no_type
+    end
+  end
+
+  class Include < Node
+    include Scoped
+
+    def infer(typer)
+      children.each do |type|
+        typeref = type.type_reference(typer)
+        the_scope = scope.static_scope
+        the_scope.self_type = the_scope.self_type.include(typeref)
+      end
+    end
+
+    def compile(compiler, expression); end
+  end
+
+  defmacro("include") do |transformer, fcall, parent|
+    raise "Included Class name required" unless fcall.parameters.size > 0
+    Include.new(parent, fcall.position) do |include_node|
+      fcall.parameters.map do |constant|
+        constant.parent = include_node
+        constant
+      end
+    end
+  end
+end