mirah 0.0.4-java

data/lib/mirah/ast/flow.rb

@@ -0,0 +1,364 @@
+module Duby
+  module AST
+    class Condition < Node
+      child :predicate
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+
+      def infer(typer)
+        unless resolved?
+          @inferred_type = typer.infer(predicate)
+          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)
+          end
+
+          @inferred_type ? resolved! : typer.defer(self)
+        end
+
+        @inferred_type
+      end
+    end
+
+    class If < Node
+      child :condition
+      child :body
+      child :else
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+
+      def infer(typer)
+        unless resolved?
+          condition_type = typer.infer(condition)
+          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
+                # 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}")
+                end
+              end
+            else
+              # only then and type inferred, we're 100% resolved
+              @inferred_type = then_type
+              resolved! if condition_type
+            end
+          end
+        end
+
+        @inferred_type
+      end
+    end
+
+    class Loop < Node
+      child :init
+      child :condition
+      child :pre
+      child :body
+      child :post
+      attr_accessor :check_first, :negative, :redo
+
+      def initialize(parent, position, check_first, negative, &block)
+        @check_first = check_first
+        @negative = negative
+
+        @children = [
+            Body.new(self, position),
+            nil,
+            Body.new(self, position),
+            nil,
+            Body.new(self, position),
+        ]
+        super(parent, position) do |l|
+          condition, body = yield(l)
+          [self.init, condition, self.pre, body, self.post]
+        end
+      end
+
+      def infer(typer)
+        unless resolved?
+          child_types = children.map do |c|
+            if c.nil? || (Body === c && c.empty?)
+              typer.no_type
+            else
+              typer.infer(c)
+            end
+          end
+          if child_types.any? {|t| t.nil?}
+            typer.defer(self)
+          else
+            resolved!
+            @inferred_type = typer.null_type
+          end
+        end
+
+        @inferred_type
+      end
+
+      def check_first?; @check_first; end
+      def negative?; @negative; end
+
+      def redo?
+        if @redo.nil?
+          nodes = @children.dup
+          until nodes.empty?
+            node = nodes.shift
+            while node.respond_to?(:inlined) && node.inlined
+              node = node.inlined
+            end
+            next if node.nil? || Loop === node
+            if Redo === node
+              return @redo = true
+            end
+            nodes.insert(-1, *node.children.flatten)
+          end
+          return @redo = false
+        else
+          @redo
+        end
+      end
+
+      def init?
+        init && !(init.kind_of?(Body) && init.empty?)
+      end
+
+      def pre?
+        pre && !(pre.kind_of?(Body) && pre.empty?)
+      end
+
+      def post?
+        post && !(post.kind_of?(Body) && post.empty?)
+      end
+
+      def to_s
+        "Loop(check_first = #{check_first?}, negative = #{negative?})"
+      end
+    end
+
+    class Not < Node
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+    end
+
+    class Return < Node
+      include Valued
+
+      child :value
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+
+      def infer(typer)
+        resolve_if(typer) do
+          if value
+            typer.infer(value)
+          else
+            typer.no_type
+          end
+        end
+      end
+    end
+
+    class Break < Node;
+      def infer(typer)
+        unless resolved?
+          resolved!
+          @inferred_type = typer.null_type
+        end
+        @inferred_type
+      end
+    end
+
+    class Next < Break; end
+
+    class Redo < Break; end
+
+    class Raise < Node
+      include Valued
+
+      child :exception
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+
+      def infer(typer)
+        unless resolved?
+          @inferred_type = AST.unreachable_type
+          throwable = AST.type(nil, 'java.lang.Throwable')
+          if children.size == 1
+            arg_type = typer.infer(self.exception)
+            unless arg_type
+              typer.defer(self)
+              return
+            end
+            if throwable.assignable_from?(arg_type) && !arg_type.meta?
+              resolved!
+              return @inferred_type
+            end
+          end
+
+          arg_types = children.map {|c| typer.infer(c)}
+          if arg_types.any? {|c| c.nil?}
+            typer.defer(self)
+          else
+            if arg_types[0] && throwable.assignable_from?(arg_types[0])
+              klass = children.shift
+            else
+              klass = Constant.new(self, position, 'RuntimeException')
+            end
+            exception = Call.new(self, position, 'new') do
+              [klass, children, nil]
+            end
+            resolved!
+            @children = [exception]
+            typer.infer(exception)
+          end
+        end
+        @inferred_type
+      end
+    end
+
+    defmacro('raise') do |transformer, fcall, parent|
+      Raise.new(parent, fcall.position) do |raise_node|
+        fcall.parameters
+      end
+    end
+
+    class RescueClause < Node
+      include Scope
+      include Scoped
+      attr_accessor :name, :type, :types
+      child :type_nodes
+      child :body
+
+      def initialize(parent, position)
+        super(parent, position) do
+          static_scope.parent = scope.static_scope
+          yield(self) if block_given?
+        end
+      end
+
+      def infer(typer)
+        unless resolved?
+          @types ||= type_nodes.map {|n| n.type_reference(typer)}
+          if name
+            static_scope.shadow(name)
+            # TODO find the common parent Throwable
+            @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 && body.resolved?) ? resolved! : typer.defer(self)
+        end
+
+        @inferred_type
+      end
+
+      def binding_type(duby=nil)
+        static_scope.parent.binding_type(defining_class, duby)
+      end
+
+      def binding_type=(type)
+        static_scope.parent.binding_type = type
+      end
+
+      def has_binding?
+        static_scope.parent.has_binding?
+      end
+    end
+
+    class Rescue < Node
+      child :body
+      child :clauses
+      def initialize(parent, position, &block)
+        super(parent, position, &block)
+        @body, @clauses = children
+      end
+
+      def infer(typer)
+        unless resolved?
+          types = [typer.infer(body)] + clauses.map {|c| typer.infer(c)}
+          if types.any? {|t| t.nil?}
+            typer.defer(self)
+          else
+            # TODO check types for compatibility (maybe only if an expression)
+            resolved!
+            @inferred_type = types[0]
+          end
+        end
+        @inferred_type
+      end
+    end
+
+    class Ensure < Node
+      child :body
+      child :clause
+      attr_accessor :state  # Used by the some compilers.
+
+      def initialize(parent, position, &block)
+        super(parent, position, &block)
+      end
+
+      def infer(typer)
+        resolve_if(typer) do
+          typer.infer(clause)
+          typer.infer(body)
+        end
+      end
+    end
+  end
+end

data/lib/mirah/ast/intrinsics.rb

@@ -0,0 +1,470 @@
+require 'fileutils'
+
+module Duby::AST
+
+  class Unquote < Node
+    child :value
+
+    def infer(typer)
+      raise "Unquote used outside of macro"
+    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
+      Marshal.dump([position, index])
+    end
+
+
+    def self._load(str)
+      if str =~ /^\d+$/
+        # This just returns the exact node passed in.
+        index = str.to_i
+        Unquote.__injected[index].dup
+      else
+        position, index = Marshal.load(str)
+        holder = UnquotedValue.new(nil, position)
+        holder << Unquote.__injected[index].dup
+        holder
+      end
+    end
+
+    def self.__extracted
+      Thread.current[:'Duby::AST::Unqote.extracted']
+    end
+
+    def self.__extracted=(value)
+      Thread.current[:'Duby::AST::Unqote.extracted'] = value
+    end
+
+    def self.__injected
+      Thread.current[:'Duby::AST::Unqote.injected']
+    end
+
+    def self.__injected=(value)
+      Thread.current[:'Duby::AST::Unqote.injected'] = value
+    end
+
+    def self.extract_values
+      values = self.__extracted = []
+      begin
+        yield
+        return values
+      ensure
+        self.__extracted = nil
+      end
+    end
+
+    def self.inject_values(values)
+      self.__injected = values
+      begin
+        yield
+      ensure
+        self.__injected = nil
+      end
+    end
+  end
+
+  class UnquotedValue < Node
+    java_import 'java.lang.Character'
+    child :value
+
+    def name
+      case value
+      when Duby::AST::String
+        value.literal
+      when ::String
+        value
+      when Named
+        value.name
+      else
+        raise "Bad unquote value #{value}"
+      end
+    end
+
+    def node
+      case value
+      when Node
+        value
+      when ::String
+        c = value[0]
+        if c == ?@
+          return Field.new(nil, position, value[1, value.length])
+        elsif Character.isUpperCase(c)
+          return Constant.new(nil, position, value)
+        else
+          return Local.new(nil, position, value)
+        end
+      else
+        raise "Bad unquote value"
+      end
+    end
+
+    def f_arg
+      case value
+      when Arguments, Argument
+        value
+      when Named
+        RequiredArgument.new(nil, position, value.name)
+      when ::String
+        RequiredArgument.new(nil, position, value)
+      else
+        raise "Bad unquote value"
+      end
+    end
+  end
+
+  class UnquoteAssign < Node
+    child :name
+    child :value
+
+    def infer(typer)
+      raise "UnquoteAssign used outside of macro"
+    end
+
+    def _dump(depth)
+      vals = Unquote.__extracted
+      index = vals.size
+      vals << self.name
+      Marshal.dump([position, index, self.value])
+    end
+
+
+    def self._load(str)
+      position, index, value = Marshal.load(str)
+      holder = UnquotedValueAssign.new(nil, position)
+      holder << Unquote.__injected[index].dup
+      holder << value
+      holder
+    end
+  end
+
+  class UnquotedValueAssign < UnquotedValue
+    child :name_node
+    child :value
+
+    def name
+      raise "Bad unquote value #{value}"
+    end
+
+    def node
+      klass = LocalAssignment
+      if Field === name_node
+        name = name_node.name
+        klass = FieldAssignment
+      # TODO support AttrAssign
+      elsif Named === name_node
+        name = name_node.name
+      elsif String === name_node
+        name = name_node.literal
+      elsif ::String === name_node
+        name = name
+      else
+        raise "Bad unquote value"
+      end
+      if name[0] == ?@
+        name = name[1, name.length]
+        klass = FieldAssignment
+      end
+      n = klass.new(nil, position, name)
+      n << value
+      n.validate_children
+      return n
+    end
+
+    def f_arg
+      raise "Bad unquote value"
+    end
+  end
+
+  class MacroDefinition < Node
+    include Named
+    include Scoped
+
+    child :arguments
+    child :body
+
+    attr_accessor :proxy
+
+    def self.new(*args, &block)
+      real_node = super
+      real_node.proxy = NodeProxy.new(real_node)
+    end
+
+    def initialize(parent, line_number, name, &block)
+      super(parent, line_number, &block)
+      @name = name
+    end
+
+    def infer(typer)
+      resolve_if(typer) do
+        self_type = scope.static_scope.self_type
+        extension_name = "%s$%s" % [self_type.name,
+                                    typer.transformer.tmp("Extension%s")]
+        klass = build_and_load_extension(self_type,
+                                         extension_name,
+                                         typer.transformer.state)
+
+        # restore the self type since we're sharing a type factory
+        typer.known_types['self'] = self_type
+
+        arg_types = argument_types
+        macro = self_type.add_compiled_macro(klass, name, arg_types)
+        if arguments[-1].kind_of?(BlockArgument) && arguments[-1].optional?
+          arg_types.pop
+          self_type.add_method(name, arg_types, macro)
+        end
+        proxy.__inline__(Noop.new(parent, position))
+        proxy.infer(typer)
+      end
+    end
+
+    def argument_types
+      arguments.map do |arg|
+        if arg.kind_of?(BlockArgument)
+          TypeReference::BlockType
+        else
+          # TODO support typed args. Also there should be a way
+          # to accept any AST node.
+          Duby::JVM::Types::Object
+        end
+      end
+    end
+
+    def signature
+      args = argument_types
+      if args.size > 0 && args[-1].block?
+        args[-1] = BiteScript::ASM::Type.getObjectType('duby.lang.compiler.Block')
+      end
+      [nil] + args
+    end
+
+    def build_and_load_extension(parent, name, state)
+      transformer = Duby::Transform::Transformer.new(state)
+      transformer.filename = name.gsub(".", "/")
+      orig_factory = Duby::AST.type_factory
+      new_factory = orig_factory.dup
+      Duby::AST.type_factory = new_factory
+      ast = build_ast(name, parent, transformer)
+      puts ast.inspect if state.verbose
+      classes = compile_ast(name, ast, transformer)
+      loader = DubyClassLoader.new(
+          JRuby.runtime.jruby_class_loader, classes)
+      klass = loader.loadClass(name, true)
+      annotate(parent, name)
+      Duby::AST.type_factory = orig_factory
+      klass
+    end
+
+    def annotate(type, class_name)
+      node = type.unmeta.node
+      if node
+        extension = node.annotation('duby.anno.Extensions')
+        extension ||= begin
+          node.annotations << Annotation.new(
+              nil, nil, BiteScript::ASM::Type.getObjectType('duby/anno/Extensions'))
+          node.annotations[-1].runtime = false
+          node.annotations[-1]
+        end
+        extension['macros'] ||= []
+        macro = Annotation.new(nil, nil,
+                               BiteScript::ASM::Type.getObjectType('duby/anno/Macro'))
+        macro['name'] = name
+        macro['signature'] = BiteScript::Signature.signature(*signature)
+        macro['class'] = class_name
+        extension['macros'] << macro
+        # TODO deal with optional blocks.
+      else
+        puts "Warning: No ClassDefinition for #{type.name}. Macros can't be loaded from disk."
+      end
+    end
+
+    def compile_ast(name, ast, transformer)
+      typer = Duby::Typer::JVM.new(transformer)
+      typer.infer(ast)
+      typer.resolve(true)
+      compiler = Duby::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)
+        end
+      end
+      class_map
+    end
+
+    def build_ast(name, parent, transformer)
+      # TODO should use a new type factory too.
+      
+      ast = Duby::AST.parse_ruby("begin;end")
+      ast = transformer.transform(ast, nil)
+
+      # Start building the extension class
+      extension = transformer.define_class(position, name)
+      #extension.superclass = Duby::AST.type(nil, 'duby.lang.compiler.Macro')
+      extension.implements(Duby::AST.type(nil, 'duby.lang.compiler.Macro'))
+
+      extension.static_scope.import('duby.lang.compiler.Node', 'Node')
+
+      # The constructor just saves the state
+      extension.define_constructor(
+          position,
+          ['mirah', Duby::AST.type(nil, 'duby.lang.compiler.Compiler')],
+          ['call', Duby::AST.type(nil, 'duby.lang.compiler.Call')]) do |c|
+        transformer.eval("@mirah = mirah;@call = call", '-', c, 'mirah', 'call')
+      end
+
+      node_type = Duby::AST.type(nil, 'duby.lang.compiler.Node')
+
+      # expand() parses the arguments out of call and then passes them off to
+      # _expand
+      expand = extension.define_method(
+          position, 'expand', node_type)
+      args = []
+      arguments.each_with_index do |arg, i|
+        # TODO optional args
+        args << if arg.kind_of?(BlockArgument)
+          "@call.block"
+        else
+          "Node(args.get(#{i}))"
+        end
+      end
+      expand.body = transformer.eval(<<-end)
+        args = @call.arguments
+        _expand(#{args.join(', ')})
+      end
+      actual_args = arguments.map do |arg|
+        type = if arg.kind_of?(BlockArgument)
+          Duby::AST.type(nil, 'duby.lang.compiler.Block')
+        else
+          node_type
+        end
+        [arg.name, type, arg.position]
+      end
+      m = extension.define_method(position, '_expand', node_type, *actual_args)
+      m.body = self.body
+      ast.body = extension
+      ast
+    end
+  end
+
+  defmacro('defmacro') do |duby, fcall, parent|
+    macro = fcall.parameters[0]
+    block_arg = nil
+    args = macro.parameters if macro.respond_to?(:parameters)
+    body = if macro.respond_to?(:block) && macro.block
+      macro.block
+    else
+      fcall.block
+    end
+    body = body.body if body
+
+    MacroDefinition.new(parent, fcall.position, macro.name) do |mdef|
+      # TODO optional args?
+      args = if args
+        args.map do |arg|
+          case arg
+          when LocalAssignment
+            OptionalArgument.new(mdef, arg.position, arg.name) do |optarg|
+              # TODO check that they actually passed nil as the value
+              Null.new(parent, arg.value_node.position)
+            end
+          when FunctionalCall
+            RequiredArgument.new(mdef, arg.position, arg.name)
+          when BlockPass
+            farg = BlockArgument.new(mdef, arg.position, arg.value.name)
+            farg.optional = true if LocalAssignment === arg.value
+            farg
+          else
+            raise "Unsupported argument #{arg}"
+          end
+        end
+      else
+        []
+      end
+      body.parent = mdef if body
+      [args,  body]
+    end
+  end
+
+  defmacro('macro') do |transformer, fcall, parent|
+    # Alternate macro syntax.
+    #   macro def foo(...);...;end
+    # This one supports special names like []=,
+    # but you can't use optional blocks.
+    method = fcall.parameters[0]
+    macro = MacroDefinition.new(parent, fcall.position, method.name)
+    macro.arguments = method.arguments.args || []
+    macro.body = method.body
+    macro
+  end
+
+  defmacro('abstract') do |transformer, fcall, parent|
+    class_or_method = fcall.parameters[0]
+    class_or_method.abstract = true
+    class_or_method
+  end
+
+  defmacro('puts') do |transformer, fcall, parent|
+    Call.new(parent, fcall.position, "println") do |x|
+      args = fcall.parameters
+      args.each do |arg|
+        arg.parent = x
+      end
+      [
+        Call.new(x, fcall.position, "out") do |y|
+          [
+            Constant.new(y, fcall.position, "System"),
+            []
+          ]
+        end,
+        args,
+        nil
+      ]
+    end
+  end
+
+  defmacro('print') do |transformer, fcall, parent|
+    Call.new(parent, fcall.position, "print") do |x|
+      args = fcall.parameters
+      args.each do |arg|
+        arg.parent = x
+      end
+      [
+        Call.new(x, fcall.position, "out") do |y|
+          [
+            Constant.new(y, fcall.position, "System"),
+            []
+          ]
+        end,
+        args,
+        nil
+      ]
+    end
+  end
+
+  class InlineCode
+    def initialize(&block)
+      @block = block
+    end
+
+    def inline(transformer, call)
+      @block.call(transformer, call)
+    end
+  end
+end