mirah 0.0.4-java

data/lib/mirah/ast/scope.rb

@@ -0,0 +1,208 @@
+module Duby
+  module AST
+    module Scoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          until scope.nil? || scope.class.include?(Scope)
+            scope = scope.parent
+          end
+          scope
+        end
+      end
+
+      def containing_scope
+        scope = self.scope.static_scope
+        while !scope.shadowed?(name) && scope.parent && scope.parent.include?(name)
+          scope = scope.parent
+        end
+        scope
+      end
+    end
+
+    module Scope
+      include Scoped
+      attr_writer :static_scope, :type_scope
+      def static_scope
+        @static_scope ||= StaticScope.new(self)
+      end
+    end
+
+    module ClassScoped
+      def class_scope
+        @class_scope ||= begin
+          scope = parent
+          scope = scope.parent until scope.nil? || ClassDefinition === scope
+          scope
+        end
+      end
+    end
+
+    class StaticScope
+      java_import 'java.util.LinkedHashMap'
+      attr_reader :parent
+      attr_writer :self_type, :self_node, :package
+
+      def initialize(node, parent=nil)
+        @scope_node = node
+        @vars = {}
+        @var_types = {}
+        @parent = parent
+        @children = {}
+        @imports = {}
+        @search_packages = []
+        @shadowed = {}
+      end
+
+      def <<(name)
+        @vars[name] = true
+      end
+
+      def shadow(name)
+        @shadowed[name] = @vars[name] = true
+      end
+
+      def shadowed?(name)
+        @shadowed[name]
+      end
+
+      def locals
+        @vars.keys
+      end
+
+      def local_type(name)
+        @var_types[name]
+      end
+
+      def learn_local_type(name, type)
+        return unless type
+        existing_type = local_type(name)
+        if existing_type
+          unless existing_type.assignable_from?(type)
+            raise Duby::Typer::InferenceError.new(
+                "Can't assign #{type.full_name} to " \
+                "variable of type #{existing_type.full_name}")
+          end
+          existing_type
+        elsif type
+          @var_types[name] = type
+        end
+      end
+
+      def include?(name, include_parent=true)
+        @vars.include?(name) ||
+            (include_parent && parent && parent.include?(name))
+      end
+
+      def captured?(name)
+        if !include?(name, false)
+          return false
+        elsif parent && parent.include?(name)
+          return true
+        else
+          return children.any? {|child| child.include?(name, false)}
+        end
+      end
+
+      def children
+        @children.keys
+      end
+
+      def add_child(scope)
+        @children[scope] = true
+      end
+
+      def remove_child(scope)
+        @children.delete(scope)
+      end
+
+      def parent=(parent)
+        @parent.remove_child(self) if @parent
+        parent.add_child(self)
+        @parent = parent
+      end
+
+      def outer_scope
+        node = @scope_node.scope
+        node && node.static_scope
+      end
+
+      def self_type
+        if @self_type.nil? && parent
+          @self_type = parent.self_type
+        end
+        @self_type
+      end
+
+      def self_node
+        if @self_node.nil? && parent
+          @self_node = parent.self_node
+        end
+        @self_node
+      end
+
+      def binding_type(defining_class=nil, duby=nil)
+        @binding_type ||= begin
+          if parent
+            parent.binding_type(defining_class, duby)
+          else
+            name = "#{defining_class.name}$#{duby.tmp}"
+            factory = Duby::AST.type_factory
+            if factory
+              factory.declare_type(@scope_node, name)
+            else
+              Duby::AST::TypeReference.new(name, false, false)
+            end
+          end
+        end
+      end
+
+      def binding_type=(type)
+        if parent
+          parent.binding_type = type
+        else
+          @binding_type = type
+        end
+      end
+
+      def has_binding?
+        @binding_type != nil || (parent && parent.has_binding?)
+      end
+
+      def package
+        @package || outer_scope.package
+      end
+
+      def fetch_imports(map)
+        parent_scope = outer_scope
+        parent_scope.fetch_imports(map) if parent_scope
+
+        map.update(@imports)
+      end
+
+      def fetch_packages(list)
+        parent_scope = outer_scope
+        parent_scope.fetch_packages(list) if parent_scope
+
+        list.concat(@search_packages)
+      end
+
+      def imports
+        @cached_imports ||= fetch_imports({})
+      end
+
+      def search_packages
+        @cached_packages ||= fetch_packages([])
+      end
+
+      def import(full_name, short_name)
+        return if full_name == short_name
+        if short_name == '*'
+          @search_packages << full_name.sub(/\.\*$/, '')
+        else
+          @imports[short_name] = full_name
+        end
+      end
+    end
+  end
+end

data/lib/mirah/ast/structure.rb

@@ -0,0 +1,226 @@
+module Duby::AST
+  class Body < Node
+    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)
+      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)}
+        end
+
+        if @inferred_type
+          resolved!
+        else
+          typer.defer(self)
+        end
+      end
+
+      @inferred_type
+    end
+
+    def <<(node)
+      super
+      if @typer
+        orig_self = @typer.self_type
+        @typer.known_types['self'] = @self_type
+        @typer.infer(node)
+        @typer.known_types['self'] = orig_self
+      end
+      self
+    end
+  end
+
+  # class << self
+  class ClassAppendSelf < Body
+    include Scope
+    include Scoped
+
+    def initialize(parent, line_number, &block)
+      super(parent, line_number, &block)
+    end
+
+    def infer(typer)
+      static_scope.self_type = scope.static_scope.self_type.meta
+      super
+    end
+  end
+
+  class ScopedBody < Body
+    include Scope
+    include Scoped
+
+    def infer(typer)
+      static_scope.self_type ||= typer.self_type
+      super
+    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)
+      end
+      str << "\n#{indent_str}body:" << super(indent + 1)
+    end
+  end
+
+  class Block < Node
+    include Scoped
+    include Scope
+    include Java::DubyLangCompiler::Block
+    child :args
+    child :body
+
+    def initialize(parent, position, &block)
+      super(parent, position) do
+        static_scope.parent = scope.static_scope
+        yield(self) if block_given?
+      end
+    end
+
+    def prepare(typer, method)
+      duby = typer.transformer
+      interface = method.argument_types[-1]
+      outer_class = scope.defining_class
+      binding = scope.binding_type(duby)
+      name = "#{outer_class.name}$#{duby.tmp}"
+      klass = duby.define_closure(position, name, outer_class)
+      klass.interfaces = [interface]
+      klass.define_constructor(position,
+                               ['binding', binding]) do |c|
+          duby.eval("@binding = binding", '-', c, 'binding')
+      end
+
+      # TODO We need a special scope here that allows access to the
+      # outer class.
+      static_scope.self_type = typer.infer(klass)
+
+      add_methods(klass, binding, typer)
+
+      call = parent
+      instance = Call.new(call, position, 'new')
+      instance.target = Constant.new(call, position, name)
+      instance.parameters = [
+        BindingReference.new(instance, position, binding)
+      ]
+      call.parameters << instance
+      call.block = nil
+      typer.infer(instance)
+    end
+
+    def add_methods(klass, binding, typer)
+      found_def = false
+      body.each do |node|
+        if node.kind_of?(MethodDefinition)
+          found_def = true
+          node.static_scope = static_scope
+          node.binding_type = binding
+          klass.append_node(node)
+        end
+      end
+      build_method(klass, binding, typer) unless found_def
+    end
+
+    def build_method(klass, binding, typer)
+      # find all methods which would not otherwise be on java.lang.Object
+      impl_methods = find_methods(klass.interfaces).select do |m|
+        begin
+          obj_m = java.lang.Object.java_class.java_method m.name, *m.parameter_types
+        rescue NameError
+          # not found on Object
+          next true
+        end
+        # found on Object
+        next false
+      end
+
+      raise "Multiple abstract methods found; cannot use block" if impl_methods.size > 1
+      impl_methods.each do |method|
+        mdef = klass.define_method(position,
+                                   method.name,
+                                   method.return_type,
+                                   args.dup)
+        mdef.static_scope = static_scope
+        mdef.body = body.dup
+        mdef.binding_type = binding
+        typer.infer(mdef.body)
+      end
+    end
+
+    def find_methods(interfaces)
+      methods = []
+      interfaces = interfaces.dup
+      until interfaces.empty?
+        interface = interfaces.pop
+        methods += interface.declared_instance_methods.select {|m| m.abstract?}
+        interfaces.concat(interface.interfaces)
+      end
+      methods
+    end
+  end
+
+  class BindingReference < Node
+    def initialize(parent, position, type)
+      super(parent, position)
+      @inferred_type = type
+    end
+
+    def infer(typer)
+      resolved! unless resolved?
+      @inferred_type
+    end
+  end
+
+  class Noop < Node
+    def infer(typer)
+      resolved!
+      @inferred_type ||= typer.no_type
+    end
+  end
+
+  class Script < Node
+    include Scope
+    include Binding
+    child :body
+
+    attr_accessor :defining_class
+    attr_reader :filename
+
+    def initialize(parent, line_number, &block)
+      super(parent, line_number, &block)
+      @package = ""
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        typer.set_filename(self, filename)
+        @defining_class ||= begin
+          static_scope.self_type = typer.self_type
+        end
+        typer.infer(body)
+      end
+    end
+
+    def filename=(filename)
+      @filename = filename
+      if Script.explicit_packages
+        static_scope.package = ''
+      else
+        package = File.dirname(@filename).tr('/', '.')
+        package.sub! /^\.+/, ''
+        static_scope.package = package
+      end
+    end
+
+    class << self
+      attr_accessor :explicit_packages
+    end
+  end
+end

data/lib/mirah/ast/type.rb

@@ -0,0 +1,130 @@
+module Duby::AST
+  class Import < Node
+    include Scoped
+    attr_accessor :short
+    attr_accessor :long
+    def initialize(parent, line_number, short, long)
+      @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] = Duby::AST.error_type
+        raise ex
+      end
+      typer.no_type
+    end
+  end
+
+  defmacro('import') do |transformer, fcall, parent|
+    case fcall.parameters.size
+    when 1
+      node = fcall.parameters[0]
+      case node
+      when String
+        long = node.literal
+        short = long[(long.rindex('.') + 1)..-1]
+      when Call
+        case node.parameters.size
+        when 0
+          pieces = [node.name]
+          while Call === node
+            node = node.target
+            pieces << node.name
+          end
+          long = pieces.reverse.join '.'
+          short = pieces[0]
+        when 1
+          arg = node.parameters[0]
+          unless (FunctionalCall === arg &&
+                  arg.name == 'as' && arg.parameters.size == 1)
+            raise Duby::TransformError.new("unknown import syntax", fcall)
+          end
+          short = arg.parameters[0].name
+          pieces = [node.name]
+          while Call === node
+            node = node.target
+            pieces << node.name
+          end
+          long = pieces.reverse.join '.'
+        else
+          raise Duby::TransformError.new("unknown import syntax", fcall)
+        end
+      else
+        raise Duby::TransformError.new("unknown import syntax", fcall)
+      end
+    when 2
+      short = fcall.parameters[0].literal
+      long = fcall.parameters[1].literal
+    else
+      raise Duby::TransformError.new("unknown import syntax", fcall)
+    end
+    Import.new(parent, fcall.position, short, long)
+  end
+
+  defmacro('package') do |transformer, fcall, parent|
+    node = fcall.parameters[0]
+    block = fcall.block
+    case node
+    when String
+      name = node.literal
+    when Call
+      pieces = [node.name]
+      block ||= node.block
+      while Call === node
+        node = node.target
+        pieces << node.name
+        block ||= node.block
+      end
+      name = pieces.reverse.join '.'
+    when FunctionalCall
+      name = node.name
+      block ||= node.block
+    else
+      raise Duby::TransformError.new("unknown package syntax", fcall)
+    end
+    if block
+      raise Duby::TransformError.new("unknown package syntax", block)
+      new_scope = ScopedBody.new(parent, fcall.position)
+      new_scope.static_scope.package = name
+      new_scope << block.body
+    else
+      fcall.scope.static_scope.package = name
+      Noop.new(parent, fcall.position)
+    end
+  end
+
+  class EmptyArray < Node
+    attr_accessor :size
+    attr_accessor :component_type
+    child :type_node
+    child :size
+
+    def initialize(*args)
+      super(*args)
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        @component_type = type_node.type_reference(typer)
+        typer.infer(size)
+        typer.type_reference(nil, @component_type, true)
+      end
+    end
+  end
+
+  class Builtin < Node
+    def infer(typer)
+      resolve_if(typer) {Duby::AST.type(nil, 'mirah.impl.Builtin')}
+    end
+  end
+end