mirah 0.1.0.pre-java → 0.1.1-java

data/lib/mirah/jvm/types/number.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# Copyright (c) 2010-2013 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");
@@ -35,6 +35,24 @@ module Mirah::JVM::Types
     def jump_if_not(compiler, call, label)
       @type.compile_boolean_operator(compiler, @op, true, call, label)
     end
+    
+    def accept(visitor, expression)
+      visitor.visitComparison(self, expression)
+    end
+    
+    def kind
+      Java::OrgMirahJvmTypes::MemberKind::COMPARISON_OP
+    end
+  end
+  
+  class MathIntrinsic < Intrinsic
+    def accept(visitor, expression)
+      visitor.visitMath(self, expression)
+    end
+    
+    def kind
+      Java::OrgMirahJvmTypes::MemberKind::MATH_OP
+    end
   end
 
   class Number < PrimitiveType
@@ -56,6 +74,13 @@ module Mirah::JVM::Types
       delegate = type.intrinsics[name][args]
       if delegate.kind_of?(ComparisonIntrinsic)
         add_method(name, args, ComparisonIntrinsic.new(type, name, delegate.op, args))
+      elsif delegate.kind_of?(MathIntrinsic)
+        method = MathIntrinsic.new(self, name, args, return_type) do |compiler, call, expression|
+          if expression
+            delegate.call(compiler, call, expression)
+          end
+        end
+        add_method(name, args, method)
       else
         add_method(name, args, return_type) do |compiler, call, expression|
           if expression
@@ -117,7 +142,8 @@ module Mirah::JVM::Types
     end
 
     def math_operator(name, op)
-      add_method(name, [math_type], math_type) do |compiler, call, expression|
+      args = [math_type]
+      method = MathIntrinsic.new(self, name, args, math_type) do |compiler, call, expression|
         if expression
           # Promote the target or the argument if necessary
           convert_args(compiler,
@@ -126,6 +152,7 @@ module Mirah::JVM::Types
           compiler.method.send "#{prefix}#{op}"
         end
       end
+      add_method(name, args, method)
       add_delegates(name)
     end
 
@@ -153,9 +180,5 @@ module Mirah::JVM::Types
       unary_operator('-@', :neg)
       unary_operator('+@', nil)
     end
-
-    def box(builder)
-      builder.invokestatic box_type, "valueOf", [box_type, math_type]
-    end
   end
 end

data/lib/mirah/jvm/types/primitive_type.rb

@@ -1,15 +1,30 @@
+# Copyright (c) 2010-2013 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.
+
 module Mirah
   module JVM
     module Types
       class PrimitiveType < Type
         WIDENING_CONVERSIONS = {
-          'byte' => ['byte', 'short', 'int', 'long', 'float', 'double'],
-          'short' => ['short', 'int', 'long', 'float', 'double'],
-          'char' => ['char', 'int', 'long', 'float', 'double'],
-          'int' => ['int', 'long', 'float', 'double'],
-          'long' => ['long', 'float', 'double'],
-          'float' => ['float', 'double'],
-          'double' => ['double']
+          'byte' => ['byte', 'short', 'int', 'long', 'float', 'double', 'java.lang.Byte', 'java.lang.Object'],
+          'short' => ['short', 'int', 'long', 'float', 'double', 'java.lang.Short', 'java.lang.Object'],
+          'char' => ['char', 'int', 'long', 'float', 'double', 'java.lang.Character', 'java.lang.Object'],
+          'int' => ['int', 'long', 'float', 'double','java.lang.Integer', 'java.lang.Object'],
+          'long' => ['long', 'float', 'double', 'java.lang.Long', 'java.lang.Object'],
+          'float' => ['float', 'double', 'java.lang.Float', 'java.lang.Object'],
+          'double' => ['double', 'java.lang.Double', 'java.lang.Object']
         }
 
         def initialize(types, type, wrapper)
@@ -35,6 +50,7 @@ module Mirah
 
         def convertible_to?(type)
           return true if type == self
+          return false if type.array?
           widening_conversions = WIDENING_CONVERSIONS[self.name]
           widening_conversions && widening_conversions.include?(type.name)
         end
@@ -42,6 +58,18 @@ module Mirah
         def superclass
           nil
         end
+
+        def wrapper_name
+          @wrapper.java_class.name
+        end
+
+        def box_type
+          @type_system.type(nil, wrapper_name)
+        end
+
+        def box(builder)
+          builder.invokestatic box_type, "valueOf", [box_type, self]
+        end
       end
     end
   end

data/lib/mirah/jvm/types/source_mirror.rb

@@ -27,10 +27,11 @@ module Mirah::JVM::Types
       java_import 'javax.lang.model.element.Element'
       java_import 'javax.lang.model.type.TypeKind'
       java_import 'javax.lang.model.type.TypeMirror'
-      java_import 'com.sun.tools.javac.model.JavacElements'
       java_import 'javax.lang.model.util.ElementScanner6'
       java_import 'javax.lang.model.element.AnnotationValueVisitor'
+      java_import 'com.sun.tools.javac.model.JavacElements'
     rescue
+      # must be after Java 7-15
     end
 
     if defined?(JavacElements)
@@ -81,10 +82,10 @@ module Mirah::JVM::Types
 
         def classpath
           options = [
-            '-classpath', Mirah::AST.type_factory.classpath
+            '-classpath', @type_factory.classpath
           ]
-          if Mirah::AST.type_factory.bootclasspath
-            options << '-bootclasspath' << Mirah::AST.type_factory.bootclasspath
+          if @type_factory.bootclasspath
+            options << '-bootclasspath' << @type_factory.bootclasspath
           end
           options
         end
@@ -262,8 +263,12 @@ module Mirah::JVM::Types
     end
 
     def self.load(file, factory)
-      parser = JavaSourceParser.new(file, factory)
-      parser.parse
+      if defined? JavacElements
+        parser = JavaSourceParser.new(file, factory)
+        parser.parse
+      end
+    rescue TypeError
+      # 1.6.8 on Java 7, don't use source mirror
     end
   end
 end

data/lib/mirah/jvm/types/type.rb

@@ -4,6 +4,7 @@ module Mirah
       class Type
         java_import 'org.mirah.typer.ErrorType'
         java_import 'org.mirah.typer.SpecialType'
+        java_import 'org.mirah.typer.InlineCode'
         java_import 'org.mirah.typer.ResolvedType'
 
         class SpecialType
@@ -16,6 +17,18 @@ module Mirah
         include Mirah::Logging::Logged
 
         include ResolvedType
+        begin
+          java_import 'org.mirah.jvm.types.JVMType'
+          include JVMType
+        rescue NameError
+          $CLASSPATH << File.dirname(__FILE__) + '/../../../../javalib/mirah-compiler.jar'
+          begin
+            java_import 'org.mirah.jvm.types.JVMType'
+            include JVMType
+          rescue
+  	        puts "Unable to load new type interface"
+          end
+        end
 
         attr_reader :name, :type_system
         attr_writer :inner_class
@@ -36,6 +49,38 @@ module Mirah
           desc = BiteScript::Signature.class_id(self)
           BiteScript::ASM::Type.get_type(desc).class_name
         end
+        
+        def internal_name
+          full_name.tr('.', '/')
+        end
+        def class_id
+          BiteScript::Signature.class_id(self)
+        end
+        def getAsmType
+          BiteScript::ASM::Type.get_type(class_id)
+        end
+        def isAnnotation
+          jvm_type ? jvm_type.annotation? : false
+        end
+        def isEnum
+          jvm_type ? jvm_type.enum? : false
+        end
+        def flags
+          flags = BiteScript::ASM::Opcodes::ACC_PUBLIC
+          flags |= BiteScript::ASM::Opcodes::ACC_ANNOTATION if isAnnotation
+          flags |= BiteScript::ASM::Opcodes::ACC_ENUM if isEnum
+          flags |= BiteScript::ASM::Opcodes::ACC_INTERFACE if self.interface?
+          flags |= BiteScript::ASM::Opcodes::ACC_ABSTRACT if self.abstract?
+          flags
+        end
+        def retention
+          if jvm_type.respond_to?(:getDeclaredAnnotation)
+            retention = jvm_type.getDeclaredAnnotation('java.lang.annotation.Retention')
+            retention.value.name
+          else
+            nil
+          end
+        end
 
         def jvm_type
           @type
@@ -74,6 +119,9 @@ module Mirah
         def primitive?
           false
         end
+        def isPrimitive
+          self.primitive?
+        end
 
         def interface?
           # FIXME: Don't do rescue nil. Figure out a cleaner way to handle
@@ -113,6 +161,7 @@ module Mirah
           return true if !primitive? && other.kind_of?(NullType)
           return true if other == self
           return true if other.matchesAnything
+          return true if other.kind_of?(InlineCode)
 
           return interface? || abstract? if other.isBlock
 
@@ -120,9 +169,12 @@ module Mirah
 
           return assignable_from?(other.ungeneric) if other.generic?
 
+          return other.convertible_to?(self) if other.primitive?
+
           assignable_from?(other.superclass) ||
               other.interfaces.any? {|i| assignable_from?(i)}
         end
+
         def assignableFrom(other)
           assignable_from?(other)
         end

data/lib/mirah/jvm/types/type_definition.rb

@@ -12,6 +12,7 @@ module Mirah
           @scope = scope
           @name = name
           @node = node
+          @fields = {}
           raise ArgumentError, "Bad type #{name}" if self.name =~ /Java::/
         end
 
@@ -43,13 +44,18 @@ module Mirah
           end
         end
 
+        def abstract?
+          node && (node.kind_of?(InterfaceDeclaration) || node.annotated_abstract?)
+        end
+
         def define(builder)
           class_name = name.tr('.', '/')
-          abstract = node && node.kind_of?(InterfaceDeclaration)  #node.abstract
+          is_interface = node && node.kind_of?(InterfaceDeclaration)
           @type ||= builder.define_class(
               class_name,
               :visibility => :public,
-              :abstract => abstract,
+              :abstract => abstract?,
+              :interface => is_interface,
               :superclass => superclass,
               :interfaces => interfaces)
         end

data/lib/mirah/transform/ast_ext.rb

@@ -1,36 +1,9 @@
 module Mirah
   module AST
-    begin
-      java_import 'mirah.impl.MirahParser'
-    rescue NameError
-      $CLASSPATH << File.dirname(__FILE__) + '/../../../javalib/mirah-parser.jar'
-      java_import 'mirah.impl.MirahParser'
-    end
+    java_import 'mirah.impl.MirahParser'
     java_import 'mirah.lang.ast.StringCodeSource'
     java_import 'org.mirah.macros.Macro'
-    java_import 'org.mirah.mmeta.ErrorHandler'
-
-    class MirahErrorHandler
-      include ErrorHandler
-      def initialize(transformer, source)
-        @transformer = transformer
-        @source = source
-      end
-
-      def warning(messages, positions)
-        print "Warning: "
-        messages.each_with_index do |message, i|
-          jpos = positions[i]
-          if jpos
-            dpos = Mirah::Transform::Transformer::JMetaPosition.new(@transformer, jpos, jpos, @source)
-            print "#{message} at "
-            Mirah.print_error("", dpos)
-          else
-            print message
-          end
-        end
-      end
-    end
+    java_import 'org.mirah.util.SimpleDiagnostics'
 
     def parse(src, filename='dash_e', raise_errors=false, transformer=nil)
       raise ArgumentError unless transformer
@@ -43,9 +16,14 @@ module Mirah
       #filename = transformer.tag_filename(src, filename)
       parser = MirahParser.new
       source = StringCodeSource.new(filename, src)
-      parser.errorHandler = MirahErrorHandler.new(transformer, source)
+      parser.diagnostics = SimpleDiagnostics.new(true)
       begin
-        parser.parse(source)
+        ast = parser.parse(source)
+        if parser.diagnostics.error_count > 0
+          puts "#{parser.diagnostics.error_count} errors, exiting"
+          throw :exit, 1
+        end
+        return ast
       rescue NativeException => ex
         ex.cause.printStackTrace
         raise ex

data/lib/mirah/transform/transformer.rb

@@ -19,7 +19,7 @@ module Mirah
       begin
         java_import 'org.mirah.macros.Compiler'
       rescue NameError
-        $CLASSPATH << File.dirname(__FILE__) + '/../../../javalib/mirah-bootstrap.jar'
+        # builtins not compiled yet
       end
 
       attr_reader :errors, :state

data/lib/mirah/typer.rb

@@ -19,6 +19,7 @@ module Mirah
   module Typer
     java_import 'org.mirah.typer.Typer'
 
-    InferenceError = Mirah::InferenceError
+    java_import 'org.mirah.typer.ResolvedType'
+    java_import 'org.mirah.typer.TypeSystem'
   end
 end

data/lib/mirah/util/argument_processor.rb

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mirah/jvm/compiler'
 require 'mirah/util/logging'
 
 module Mirah
@@ -55,17 +56,6 @@ module Mirah
 
             self.exit_status_code = 0
             break
-          when '--java', '-j'
-            if state.command == :compile
-              require 'mirah/jvm/compiler/java_source'
-              state.compiler_class = Mirah::JVM::Compiler::JavaSource
-              args.shift
-            else
-              $stderr.puts "-j/--java flag only applies to \"compile\" mode."
-
-              self.exit_status_code = 1
-              break
-            end
           when '--jvm'
             args.shift
             state.set_jvm_version(args.shift)
@@ -102,6 +92,13 @@ module Mirah
           when '--no-save-extensions'
             args.shift
             state.save_extensions = false
+          when '--new-backend', '-N'
+            args.shift
+            state.compiler_class = Mirah::JVM::Compiler::Backend
+          when '--new-types', '-T'
+            args.shift
+            java_import 'org.mirah.jvm.mirrors.MirrorTypeSystem'
+            state.type_system = MirrorTypeSystem.new
           else
             $stderr.puts "unrecognized flag: " + args[0]
 
@@ -125,14 +122,13 @@ module Mirah
         "#{$0} [flags] <files or -e SCRIPT>
         -c, --classpath PATH\tAdd PATH to the Java classpath for compilation
         --bootclasspath PATH\tSet the Java bootclasspath to PATH for compilation
-        --cd DIR\t\tSwitch to the specified DIR befor compilation
-        -d, --dir DIR\t\tUse DIR as the base dir for compilation, packages
+        --cd DIR\t\tSwitch to the specified DIR before compilation
+        -d, --dest DIR\t\tUse DIR as the dir to place the generated class files
         -e CODE\t\tCompile or run the inline script following -e
         \t\t\t  (the class will be named \"DashE\")
         --explicit-packages\tRequire explicit 'package' lines in source
         -h, --help\t\tPrint this help message
         -I DIR\t\tAdd DIR to the Ruby load path before running
-        -j, --java\t\tOutput .java source (compile mode [mirahc] only)
         --jvm VERSION\t\tEmit JVM bytecode targeting specified JVM
         \t\t\t  version (1.4, 1.5, 1.6, 1.7)
         -p, --plugin PLUGIN\trequire 'mirah/plugin/PLUGIN' before running

data/lib/mirah/util/argument_processor.rb~

@@ -0,0 +1,146 @@
+# 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/compiler'
+require 'mirah/util/logging'
+
+module Mirah
+  module Util
+
+    class ArgumentProcessor
+      def initialize(state, args)
+        @state = state
+        @args = args
+      end
+
+      attr_accessor :state, :args, :exit_status_code
+
+      alias exit? exit_status_code
+
+      def process
+        state.args = args
+        while args.length > 0 && args[0] =~ /^-/
+          case args[0]
+          when '--classpath', '-c'
+            args.shift
+            state.classpath = args.shift
+          when '--bootclasspath'
+            args.shift
+            state.bootclasspath = args.shift
+          when '--cd'
+            args.shift
+            Dir.chdir(args.shift)
+          when '--dest', '-d'
+            args.shift
+            state.destination = File.join(File.expand_path(args.shift), '')
+          when '-e'
+            break
+          when '--explicit-packages'
+            args.shift
+            Mirah::AST::Script.explicit_packages = true
+          when '--help', '-h'
+            args.shift
+            print_help
+
+            self.exit_status_code = 0
+            break
+          when '--jvm'
+            args.shift
+            state.set_jvm_version(args.shift)
+          when '-I'
+            args.shift
+            $: << args.shift
+          when '--plugin', '-p'
+            args.shift
+            plugin = args.shift
+            require "mirah/plugin/#{plugin}"
+          when '--verbose', '-V'
+            Mirah::Logging::MirahLogger.level = Mirah::Logging::Level::FINE
+            state.verbose = true
+            args.shift
+          when '--vmodule'
+            args.shift
+            spec = args.shift
+            spec.split(',').each do |item|
+              logger, level = item.split("=")
+              logger = java.util.logging.Logger.getLogger(logger)
+              (state.loggers ||= []) << logger
+              level = java.util.logging.Level.parse(level)
+              logger.setLevel(level)
+            end
+          when '--no-color'
+            args.shift
+            Mirah::Logging::MirahHandler.formatter = Mirah::Logging::LogFormatter.new(false)
+          when '--version', '-v'
+            args.shift
+            print_version
+
+            self.exit_status_code = 0 if args.empty?
+            break
+          when '--no-save-extensions'
+            args.shift
+            state.save_extensions = false
+          when '--new-backend', '-N'
+            args.shift
+            state.compiler_class = Mirah::JVM::Compiler::Backend
+          when '--new-types', '-T'
+            args.shift
+            java_import 'org.mirah.jvm.mirrors.MirrorTypeSystem'
+            state.type_system = MirrorTypeSystem.new
+          else
+            $stderr.puts "unrecognized flag: " + args[0]
+
+            self.exit_status_code = 1
+            break
+          end
+        end
+
+        return if exit?
+
+        state.destination ||= File.join(File.expand_path('.'), '')
+        state.compiler_class ||= Mirah::JVM::Compiler::JVMBytecode
+      end
+
+      def print_help
+        puts help_message
+        state.help_printed = true
+      end
+
+      def help_message
+        "#{$0} [flags] <files or -e SCRIPT>
+        -c, --classpath PATH\tAdd PATH to the Java classpath for compilation
+        --bootclasspath PATH\tSet the Java bootclasspath to PATH for compilation
+        --cd DIR\t\tSwitch to the specified DIR before compilation
+        -d, --dest DIR\t\tUse DIR as the dir to place the resulting .class files
+        -e CODE\t\tCompile or run the inline script following -e
+        \t\t\t  (the class will be named \"DashE\")
+        --explicit-packages\tRequire explicit 'package' lines in source
+        -h, --help\t\tPrint this help message
+        -I DIR\t\tAdd DIR to the Ruby load path before running
+        --jvm VERSION\t\tEmit JVM bytecode targeting specified JVM
+        \t\t\t  version (1.4, 1.5, 1.6, 1.7)
+        -p, --plugin PLUGIN\trequire 'mirah/plugin/PLUGIN' before running
+        -v, --version\t\tPrint the version of Mirah to the console
+        -V, --verbose\t\tVerbose logging
+        --vmodule logger.name=LEVEL[,...]\t\tSet the Level for the specified Java loggers"
+      end
+
+      def print_version
+        puts "Mirah v#{Mirah::VERSION}"
+        state.version_printed = true
+      end
+    end
+  end
+end