mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/typer.rb

@@ -14,23 +14,9 @@
 # limitations under the License.
 
 require 'mirah/errors'
-require 'mirah/typer/base'
-require 'mirah/typer/simple'
 
 module Mirah
   module Typer
-    class << self
-      attr_accessor :verbose
-
-      def log(message)
-        puts "* [#{name}] #{message}" if Typer.verbose
-      end
-    end
-
-    InferenceError = Mirah::InferenceError
-  end
-
-  def self.typer_plugins
-    @typer_plugins ||= []
+    java_import 'org.mirah.typer.Typer'
   end
-end
+end

data/lib/mirah/util/argument_processor.rb

@@ -13,8 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mirah/util/logging'
+
 module Mirah
   module Util
+
     class ArgumentProcessor
       def initialize(state, args)
         @state = state
@@ -49,7 +52,7 @@ module Mirah
           when '--help', '-h'
             args.shift
             print_help
-            
+
             self.exit_status_code = 0
             break
           when '--java', '-j'
@@ -74,15 +77,26 @@ module Mirah
             plugin = args.shift
             require "mirah/plugin/#{plugin}"
           when '--verbose', '-V'
-            Mirah::Typer.verbose = true
-            Mirah::AST.verbose = true
-            Mirah::JVM::Compiler::JVMBytecode.verbose = true
+            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'
@@ -90,14 +104,14 @@ module Mirah
             state.save_extensions = false
           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
@@ -111,7 +125,7 @@ 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
+        --cd DIR\t\tSwitch to the specified DIR before compilation
         -d, --dir DIR\t\tUse DIR as the base dir for compilation, packages
         -e CODE\t\tCompile or run the inline script following -e
         \t\t\t  (the class will be named \"DashE\")
@@ -123,7 +137,8 @@ module Mirah
         \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"
+        -V, --verbose\t\tVerbose logging
+        --vmodule logger.name=LEVEL[,...]\t\tSet the Level for the specified Java loggers"
       end
 
       def print_version

data/lib/mirah/util/class_loader.rb

@@ -1,6 +1,6 @@
 module Mirah
   module Util
-    
+
     ClassLoader = Java::OrgMirah::MirahClassLoader
 
     # converts string to a java string w/ binary encoding

data/lib/mirah/util/compilation_state.rb

@@ -20,6 +20,7 @@ module Mirah
     class CompilationState
       def initialize
         @save_extensions = true
+        set_jvm_version ENV_JAVA['java.specification.version']
       end
 
       attr_accessor :verbose, :destination
@@ -31,29 +32,27 @@ module Mirah
       attr_accessor :compiler_class
       attr_accessor :args
       attr_accessor :command
+      attr_accessor :loggers
 
-      def classpath=(classpath)
-        Mirah::AST.type_factory.classpath = classpath
-      end
-
-      def bootclasspath=(classpath)
-        Mirah::AST.type_factory.bootclasspath = classpath
-      end
+      attr_accessor :classpath, :bootclasspath
+      attr_reader :target_jvm_version
 
       def set_jvm_version(ver_str)
-        case ver_str
-        when '1.4'
-          BiteScript.bytecode_version = BiteScript::JAVA1_4
-        when '1.5'
-          BiteScript.bytecode_version = BiteScript::JAVA1_5
-        when '1.6'
-          BiteScript.bytecode_version = BiteScript::JAVA1_6
-        when '1.7'
-          BiteScript.bytecode_version = BiteScript::JAVA1_7
+        @target_jvm_version = ver_str
+        @bytecode_version = case ver_str
+        when '1.4' then BiteScript::JAVA1_4
+        when '1.5' then BiteScript::JAVA1_5
+        when '1.6' then BiteScript::JAVA1_6
+        when '1.7' then BiteScript::JAVA1_7
         else
           $stderr.puts "invalid bytecode version specified: #{ver_str}"
         end
+        BiteScript.bytecode_version = @bytecode_version
+      end
+
+      def supports_invokedynamic?
+        @bytecode_version == BiteScript::JAVA1_7
       end
     end
   end
-end
+end

data/lib/mirah/util/delegate.rb

@@ -5,7 +5,7 @@ module Mirah
     class Delegator
       IgnoreBacktracePat = %r"\A#{Regexp.quote(__FILE__)}:\d+:in `"
     end
-  
+
     def self.DelegateClass(superclass)
       klass = Class.new
       methods = superclass.public_instance_methods(true).map(&:to_s)
@@ -62,4 +62,4 @@ module Mirah
       return klass
     end
   end
-end
+end

data/lib/mirah/util/logging.rb

@@ -0,0 +1,110 @@
+module Mirah
+  module Logging
+    java_import 'java.util.logging.Logger'
+    java_import 'java.util.logging.Formatter'
+    java_import 'java.util.logging.ConsoleHandler'
+    java_import 'java.util.logging.Level'
+
+    MirahLogger = Logger.getLogger('org.mirah')
+    MirahHandler = ConsoleHandler.new
+    MirahLogger.addHandler(MirahHandler)
+    MirahLogger.use_parent_handlers = false
+    MirahHandler.level = Level::ALL
+
+    class LogFormatter < Formatter
+      def initialize(use_color=true)
+        @color = use_color
+        @names = {}
+        @inverse_names = {}
+      end
+
+      def format_name(sb, level, name)
+        sb.append("\e[1m") if @color
+        sb.append("* [")
+        if @color && level > 800
+          if level > 900
+            sb.append("\e[31m")
+          else
+            sb.append("\e[34m")
+          end
+        end
+        sb.append(shorten(name))
+        sb.append("\e[39m") if @color
+        sb.append('] ')
+        sb.append("\e[0m") if @color
+      end
+
+      def shorten(name)
+        short = @names[name]
+        return short if short
+        pieces = name.split('.')
+        pieces.size.times do |i|
+          key = pieces[-i - 1, i + 1]
+          existing = @inverse_names[key]
+          if existing.nil? || existing == [name]
+            @inverse_names[key] = [name]
+            return @names[name] = key.join('.')
+          else
+            existing.each {|i| @names[i] = nil}
+            existing << name unless existing.include?(name)
+          end
+        end
+        return name
+      end
+
+      def format(record)
+        sb = java.lang.StringBuilder.new
+        format_name(sb, record.level.int_value, record.logger_name)
+        sb.append(formatMessage(record))
+        sb.append("\n")
+        if record.thrown
+          sw = java.io.StringWriter.new
+          pw = java.io.PrintWriter.new(sw)
+          record.thrown.printStackTrace(pw)
+          pw.close
+          sb.append(sw.toString)
+        end
+        sb.toString
+      end
+    end
+
+    MirahHandler.formatter = LogFormatter.new
+
+    module Logged
+      VLEVELS = [Level::CONFIG, Level::FINE, Level::FINER, Level::FINEST]
+      def logger
+        @logger ||= java.util.logging.Logger.getLogger(logger_name)
+      end
+
+      def logger_name
+        name = self.class.name.sub(/^Mirah::/, '').gsub('::', '.')
+        "org.mirah.ruby.#{name}"
+      end
+
+      def error(*args)
+        logger.log(Level::SEVERE, *args)
+      end
+
+      def warning(*args)
+        logger.log(Level::WARNING, *args)
+      end
+
+      def info(*args)
+        logger.log(Level::INFO, *args)
+      end
+
+      def log(*args)
+        vlog(1, *args)
+      end
+
+      def logging?(level=Level::FINE)
+        level = VLEVELS[level] unless level.kind_of?(Level)
+        logger.isLoggable(level)
+      end
+
+      def vlog(level, *args)
+        logger.log(VLEVELS[level], *args)
+      end
+    end
+  end
+end

data/lib/mirah/util/process_errors.rb

@@ -16,24 +16,82 @@
 module Mirah
   module Util
     module ProcessErrors
+      java_import 'org.mirah.typer.ErrorType'
+
       # errors - array of NodeErrors
       def process_errors(errors)
         errors.each do |ex|
-          puts ex
-          if ex.node
-            Mirah.print_error(ex.message, ex.position)
+          if ex.kind_of?(ErrorType)
+            ex.message.each do |pair|
+              message, position = pair.to_a
+              if position
+                Mirah.print_error(message, position)
+              else
+                puts message
+              end
+            end if ex.message
           else
-            puts ex.message
-          end
-          if ex.kind_of?(Mirah::InternalCompilerError) && ex.cause
-            puts ex.cause
-            puts ex.cause.backtrace
-          elsif @verbose
-            puts ex.backtrace
+            puts ex
+            if ex.respond_to?(:node) && ex.node
+              Mirah.print_error(ex.message, ex.position)
+            else
+              puts ex.message
+            end
+            error(ex.backtrace.join("\n")) if self.logging?
           end
         end
         throw :exit, 1 unless errors.empty?
       end
+
+      java_import 'mirah.lang.ast.NodeScanner'
+      class ErrorCollector < NodeScanner
+        def initialize(typer)
+          super()
+          @errors = {}
+          @typer = typer
+        end
+        def exitDefault(node, arg)
+          type = @typer.getInferredType(node)
+          type = type.resolve if type
+          if (type && type.isError)
+            @errors[type] ||= begin
+              if type.message.size == 1
+                m = type.message[0]
+                if m.size == 1
+                  m << node rescue nil
+                elsif m.size == 2 && m[1] == nil
+                  m[1] = node.position rescue nil
+                end
+              elsif type.message.size == 0
+                type.message << ["Error", node.position]
+              end
+              type
+            end
+          end
+          nil
+        end
+        def errors
+          @errors.values
+        end
+      end
+
+      def process_inference_errors(typer, nodes)
+        errors = []
+        nodes.each do |ast|
+          collector = ErrorCollector.new(typer)
+          ast.accept(collector, nil)
+          errors.concat(collector.errors)
+        end
+        failed = !errors.empty?
+        if failed
+          if block_given?
+            yield(errors)
+          else
+            puts "Inference Error:"
+            process_errors(errors)
+          end
+        end
+      end
     end
   end
-end
+end

data/lib/mirah/version.rb

@@ -14,5 +14,5 @@
 # limitations under the License.
 
 module Mirah
-  VERSION = "0.0.12"
+  VERSION = "0.1.0"
 end

data/test/core/commands_test.rb

@@ -16,17 +16,13 @@ require 'test_helper'
 
 
 class CommandsTest < Test::Unit::TestCase
-  def teardown
-    Mirah::AST.type_factory = nil
-  end
-  
   class RaisesMirahErrorCommand < Mirah::Commands::Base
     def execute
       execute_base { raise Mirah::MirahError, "just an error" }
     end
     def command_name; :foo; end
   end
-  
+
   class MirahProcessesErrorCommand < Mirah::Commands::Base
     include  Mirah::Util::ProcessErrors
     def execute
@@ -34,7 +30,7 @@ class CommandsTest < Test::Unit::TestCase
     end
     def command_name; :foo; end
   end
-  
+
   class SuccessfulCommand < Mirah::Commands::Base
     def execute
       execute_base { "something" }
@@ -53,43 +49,29 @@ class CommandsTest < Test::Unit::TestCase
       RaisesMirahErrorCommand.new(['-bad-argument']).execute
     end
   end
-  
+
   def test_on_v_with_no_args_exits_without_running_command
     assert_zero_exit do
       RaisesMirahErrorCommand.new(['-v']).execute
     end
   end
-    
+
   def test_on_j_option_when_command_is_not_compile_has_non_zero_exit_code
     assert_non_zero_exit do
       RaisesMirahErrorCommand.new(['-j']).execute
     end
   end
-  
+
   def test_success_is_truthy
     assert SuccessfulCommand.new([]).execute, "expected it to be truthy"
   end
-  
+
   def test_process_errors_causes_a_non_zero_exit
     assert_non_zero_exit do
       MirahProcessesErrorCommand.new([]).execute
     end
   end
 
-  def test_run_says_no_main_and_exits_with_non_zero_with_no_main
-    cmd = Mirah::Commands::Run.new([])
-
-    #stub class generation, loading, return nil main
-    def cmd.load_classes_and_find_main *args;nil;end
-    def cmd.generate_class_map;end
-
-    assert_non_zero_exit do
-      assert_output "No main found\n" do
-        cmd.execute
-      end
-    end
-  end
-
   def assert_non_zero_exit
     ex = assert_raise SystemExit do
       yield