mirah 0.0.7-java → 0.0.8-java

data/lib/mirah/ast/intrinsics.rb

@@ -40,7 +40,12 @@ module Mirah::AST
       else
         position, index = Marshal.load(str)
         holder = UnquotedValue.new(nil, position)
-        holder << Unquote.__injected[index].dup
+        value = Unquote.__injected[index]
+        begin
+          holder << value.dup
+        rescue TypeError
+          holder << value
+        end
         holder
       end
     end
@@ -97,10 +102,14 @@ module Mirah::AST
       when Node
         value.string_value
       else
-        raise "Bad unquote value #{value}"
+        raise "Bad unquote value for name #{value} (#{value.class})"
       end
     end
 
+    def type
+      Constant.new(nil, position, name)
+    end
+
     def node
       case value
       when Node
@@ -114,12 +123,24 @@ module Mirah::AST
         else
           return Local.new(nil, position, value)
         end
+      when ::Fixnum
+        return Fixnum.new(nil, position, value)
       else
-        raise "Bad unquote value"
+        raise "Bad unquote value for node #{value} (#{value.class})"
       end
     end
 
-    def f_arg
+    def nodes
+      case value
+      when ::Array, Java::JavaUtil::List
+        # TODO convert items to nodes.
+        value.to_a
+      else
+        [node]
+      end
+    end
+
+    def f_arg_item(value)
       case value
       when Arguments, Argument
         value
@@ -127,8 +148,26 @@ module Mirah::AST
         RequiredArgument.new(nil, position, value.string_value)
       when ::String
         RequiredArgument.new(nil, position, value)
+      when ::Array, java.util.List
+        name, type = value.map do |item|
+          if item.kind_of?(Node)
+            item.string_value
+          else
+            item.to_s
+          end
+        end
+        RequiredArgument.new(nil, position, name, type)
       else
-        raise "Bad unquote value"
+        raise "Bad unquote value for arg #{value} (#{value.class})"
+      end
+    end
+
+    def f_arg
+      case value
+      when ::Array, java.util.List
+        value.map {|item| f_arg_item(item)}
+      else
+        f_arg_item(value)
       end
     end
   end
@@ -277,7 +316,7 @@ module Mirah::AST
       Mirah::AST.type_factory = new_factory
       ast = build_ast(name, parent, transformer)
       classes = compile_ast(name, ast, transformer)
-      loader = Mirah::ClassLoader.new(
+      loader = Mirah::Util::ClassLoader.new(
           JRuby.runtime.jruby_class_loader, classes)
       klass = loader.loadClass(name, true)
       if state.save_extensions
@@ -312,7 +351,8 @@ module Mirah::AST
 
     def compile_ast(name, ast, transformer)
       begin
-        typer = Mirah::Typer::JVM.new(transformer)
+        # FIXME: This is JVM specific, and should move out of platform-independent code
+        typer = Mirah::JVM::Typer.new(transformer)
         typer.infer(ast, false)
         typer.resolve(true)
         typer.errors.each do |e|
@@ -321,7 +361,8 @@ module Mirah::AST
       ensure
         puts ast.inspect if transformer.state.verbose
       end
-      compiler = Mirah::Compiler::JVM.new
+      # FIXME: This is JVM specific, and should move out of platform-independent code
+      compiler = Mirah::JVM::Compiler::JVMBytecode.new
       ast.compile(compiler, false)
       class_map = {}
       compiler.generate do |outfile, builder|
@@ -351,6 +392,7 @@ module Mirah::AST
       extension.implements(Mirah::AST.type(nil, 'duby.lang.compiler.Macro'))
 
       extension.static_scope.import('duby.lang.compiler.Node', 'Node')
+      extension.static_scope.package = scope.static_scope.package
 
       # The constructor just saves the state
       extension.define_constructor(

data/lib/mirah/ast/literal.rb

@@ -168,4 +168,11 @@ module Mirah::AST
       @inferred_type ||= typer.null_type
     end
   end
+
+  class Self < Node
+    include Scoped
+    def infer(typer, expression)
+      @inferred_type ||= scope.static_scope.self_type
+    end
+  end
 end

data/lib/mirah/ast/local.rb

@@ -67,7 +67,11 @@ module Mirah::AST
     def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name
-        typer.infer(value, true)
+        type = typer.infer(value, true)
+        if type && type.null?
+          type = typer.local_type(containing_scope, name) unless typer.last_chance
+        end
+        type
       end
     end
 
@@ -94,6 +98,10 @@ module Mirah::AST
       "Local(name = #{name}, scope = #{scope}, captured = #{captured? == true})"
     end
 
+    def type_reference(typer)
+      typer.type_reference(scope, @name)
+    end
+
     def infer(typer, expression)
       resolve_if(typer) do
         scope.static_scope << name

data/lib/mirah/ast/method.rb

@@ -46,7 +46,7 @@ module Mirah::AST
     end
 
     def validate_child(args, child_index)
-      if args.kind_of?(Array)
+      if args.kind_of?(::Array)
         args.each_with_index do |arg, arg_index|
           if UnquotedValue === arg
             actual_arg = arg.f_arg
@@ -70,7 +70,7 @@ module Mirah::AST
       case args
       when Arguments
         args.children.each_with_index {|child, i| merge_args(child, i)}
-      when Array
+      when ::Array
         args.each {|arg| merge_args(arg, child_index)}
       when RequiredArgument
         if child_index > 2
@@ -127,13 +127,23 @@ module Mirah::AST
         signature = method_def.signature
 
         if type_node
-          signature[name.intern] = type_node.type_reference(typer)
+          if ::String === type_node  # How does this happen?
+            signature[name.intern] = typer.type_reference(scope, type_node)
+          else
+            signature[name.intern] = type_node.type_reference(typer)
+          end
         end
 
         # if signature, search for this argument
         signature[name.intern] || typer.local_type(containing_scope, name)
       end
     end
+
+    def validate_type_node
+      if UnquotedValue === type_node
+        self.type_node = type_node.type
+      end
+    end
   end
 
   class OptionalArgument < Argument
@@ -191,7 +201,6 @@ module Mirah::AST
 
     def infer(typer, expression)
       scope.static_scope << name
-      super
     end
   end
 
@@ -237,11 +246,15 @@ module Mirah::AST
         end
         @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
+        if @return_type
+          if @return_type.kind_of?(UnquotedValue)
+            @return_type = @return_type.node
+            @return_type.parent = self
+          else
+            @return_type.parent = self
+          end
+          signature[:return] = @return_type.type_reference(typer)
         end
-        signature[:return] = @return_type.type_reference(typer) if @return_type
         if @exceptions
           signature[:throws] = @exceptions.map {|e| e.type_reference(typer)}
         end

data/lib/mirah/ast/scope.rb

@@ -93,7 +93,7 @@ module Mirah
         return unless type
         existing_type = local_type(name)
         if existing_type
-          unless existing_type.assignable_from?(type)
+          unless existing_type.compatible?(type)
             raise Mirah::Typer::InferenceError.new(
                 "Can't assign #{type.full_name} to " \
                 "variable of type #{existing_type.full_name}")

data/lib/mirah/ast/structure.rb

@@ -95,8 +95,8 @@ module Mirah::AST
       super
     end
 
-    def binding_type(duby=nil)
-      static_scope.binding_type(defining_class, duby)
+    def binding_type(mirah=nil)
+      static_scope.binding_type(defining_class, mirah)
     end
 
     def binding_type=(type)
@@ -142,16 +142,19 @@ module Mirah::AST
     end
 
     def prepare(typer, method)
-      duby = typer.transformer
+      mirah = 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)
+      
+      binding = scope.binding_type(mirah)
+      
+      name = "#{outer_class.name}$#{mirah.tmp}"
+
+      klass = mirah.define_closure(position, name, outer_class)
       klass.interfaces = [interface]
       klass.define_constructor(position,
                                ['binding', binding]) do |c|
-          duby.eval("@binding = binding", '-', c, 'binding')
+          mirah.eval("@binding = binding", '-', c, 'binding')
       end
 
       # TODO We need a special scope here that allows access to the
@@ -200,16 +203,17 @@ module Mirah::AST
         next false
       end
 
-      raise "Multiple abstract methods found; cannot use block" if impl_methods.size > 1
+      raise "Multiple abstract methods found within given interface [#{impl_methods.map(&:name).join(', ')}]; 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, true)
+                            method.name,
+                            method.return_type,
+                            args.dup) do |mdef|
+          mdef.static_scope = static_scope
+          mdef.binding_type = binding
+          mdef.body = body.dup
+        end
+        typer.infer(mdef.body, method.return_type != typer.no_type)
       end
     end
 
@@ -282,4 +286,66 @@ module Mirah::AST
       attr_accessor :explicit_packages
     end
   end
+
+  class Annotation < Node
+    attr_reader :values
+    attr_accessor :runtime
+    alias runtime? runtime
+
+    child :name_node
+
+    def initialize(parent, position, name=nil, &block)
+      super(parent, position, &block)
+      if name
+        @name = if name.respond_to?(:class_name)
+          name.class_name
+        else
+          name.name
+        end
+      end
+      @values = {}
+    end
+
+    def name
+      @name
+    end
+
+    def type
+      BiteScript::ASM::Type.getObjectType(@name.tr('.', '/'))
+    end
+
+    def []=(name, value)
+      @values[name] = value
+    end
+
+    def [](name)
+      @values[name]
+    end
+
+    def infer(typer, expression)
+      @inferred ||= begin
+        @name = name_node.type_reference(typer).name if name_node
+        @values.each do |name, value|
+          if Node === value
+            @values[name] = annotation_value(value, typer)
+          end
+        end
+        true
+      end
+    end
+
+    def annotation_value(node, typer)
+      case node
+      when String
+        java.lang.String.new(node.literal)
+      when Array
+        node.children.map {|node| annotation_value(node, typer)}
+      else
+        # TODO Support other types
+        ref = value.type_refence(typer)
+        desc = BiteScript::Signature.class_id(ref)
+        BiteScript::ASM::Type.getType(desc)
+      end
+    end
+  end
 end

data/lib/mirah/ast/type.rb

@@ -35,6 +35,10 @@ module Mirah::AST
         typer.no_type
       end
     end
+
+    def top_level?
+      true
+    end
   end
 
   defmacro('import') do |transformer, fcall, parent|

data/{bin/dubyc → lib/mirah/commands.rb}

@@ -1,5 +1,3 @@
-#!/usr/bin/env jruby
-
 # Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
 # All contributing project authors may be found in the NOTICE file.
 #
@@ -15,12 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-begin
-  require 'mirah'
-rescue LoadError
-  $: << File.dirname(File.dirname(__FILE__)) + '/lib'
-  require 'mirah'
-end
-
-puts 'WARNING: Duby is now Mirah. Please use the `mirahc` command.'
-Duby.compile(*ARGV)
+require 'mirah/commands/base'
+require 'mirah/commands/run'
+require 'mirah/commands/compile'
+require 'mirah/commands/parse'

data/lib/mirah/commands/base.rb

@@ -0,0 +1,54 @@
+# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# All contributing project authors may be found in the NOTICE file.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'mirah/jvm/types'
+require 'mirah/util/compilation_state'
+require 'mirah/util/argument_processor'
+require 'mirah/errors'
+
+module Mirah
+  module Commands
+    class Base
+      def initialize(args)
+        Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new
+        @state = Mirah::Util::CompilationState.new
+        @state.command = command_name
+        @args = args
+        @argument_processor = Mirah::Util::ArgumentProcessor.new(@state, @args)
+      end
+      
+      attr_accessor :state, :args, :argument_processor
+      
+      def execute_base
+        # because MirahCommand is a JRuby Java class, SystemExit bubbles through and makes noise
+        # so we use a catch/throw to early exit instead
+        # see process_errors.rb
+        catch(:exit) do
+          begin
+            argument_processor.process
+            yield
+          rescue Mirah::InternalCompilerError => ice
+            Mirah.print_error(ice.message, ice.position) if ice.node
+            raise ice.cause if (ice.cause && state.verbose)
+            raise ice
+          rescue Mirah::MirahError => ex
+            Mirah.print_error(ex.message, ex.position)
+            puts ex.backtrace if state.verbose
+          end
+        end
+      end
+    end
+  end
+end