mirah 0.0.7-java → 0.0.8-java

data/examples/rosettacode/palindrome.mirah

@@ -0,0 +1,14 @@
+
+def reverse(s:string) 
+    StringBuilder.new(s).reverse.toString()
+end
+
+def palindrome?(s:string) 
+    s.equals(reverse(s))
+end
+
+puts palindrome?("anna")        # ==> true
+puts palindrome?("Erik")        # ==> false
+puts palindrome?("palindroom-moordnilap") # ==> true
+puts nil                        # ==> null
+

data/examples/rosettacode/repeat-a-string.mirah

@@ -0,0 +1,9 @@
+x = ""
+
+5.times do 
+    x = x + "ha"
+end
+
+puts x # ==> "hahahahaha"
+
+

data/examples/rosettacode/reverse-a-string.mirah

@@ -0,0 +1,6 @@
+
+def reverse(s:string) 
+    StringBuilder.new(s).reverse
+end
+
+puts reverse('reversed')

data/examples/rosettacode/rot-13.mirah

@@ -0,0 +1,20 @@
+
+
+def rot13 (value:string)
+    result = ""
+    d = ' '.toCharArray[0]
+    value.toCharArray.each do |c|
+        testChar = Character.toLowerCase(c)
+        if testChar <= 'm'.toCharArray[0] && testChar >= 'a'.toCharArray[0] then 
+            d = char(c + 13)
+        end
+        if testChar <= 'z'.toCharArray[0] && testChar >= 'n'.toCharArray[0] then 
+            d = char(c - 13) 
+        end 
+        result += d
+    end 
+    result
+end
+
+
+puts rot13("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

data/examples/rosettacode/user-input.mirah

@@ -0,0 +1,4 @@
+
+s = System.console.readLine()
+
+puts s

data/examples/sort_closure.mirah

@@ -18,5 +18,5 @@ import java.util.ArrayList
 
 list = ArrayList.new [9,5,2,6,8,5,0,3,6,1,8,3,6,4,7,5,0,8,5,6,7,2,3]
 puts "unsorted: #{list}"
-Collections.sort(list) {|a,b| Integer(a).compareTo(b)}
+Collections.sort(list) {|a,b| Integer(a).compareTo(Integer(b))}
 puts "sorted:   #{list}"

data/lib/mirah.rb

@@ -22,31 +22,26 @@ require 'mirah/typer'
 require 'mirah/compiler'
 require 'mirah/env'
 require 'mirah/errors'
-require 'mirah/class_loader'
-begin
-  require 'bitescript'
-rescue LoadError
-  $: << File.dirname(__FILE__) + '/../../bitescript/lib'
-  require 'bitescript'
-end
+require 'bitescript'
+
 require 'mirah/jvm/compiler'
 require 'mirah/jvm/typer'
 Dir[File.dirname(__FILE__) + "/mirah/plugin/*"].each {|file| require "#{file}" if file =~ /\.rb$/}
-require 'mirah/impl'
-require 'mirah/compilation_state'
 require 'jruby'
 
+require 'mirah/commands'
+
 module Mirah
   def self.run(*args)
-    Impl.new.run(*args)
+    Mirah::Commands::Run.new(args).execute
   end
 
   def self.compile(*args)
-    Impl.new.compile(*args)
+    Mirah::Commands::Compile.new(args).execute
   end
 
   def self.parse(*args)
-    Impl.new.parse(*args)
+    Mirah::Commands::Parse.new(args).execute
   end
 
   def self.plugins
@@ -89,7 +84,3 @@ module Mirah
     end
   end
 end
-
-if __FILE__ == $0
-  Mirah.run(ARGV[0], *ARGV[1..-1])
-end

data/lib/mirah/ast.rb

@@ -37,6 +37,10 @@ module Mirah
       attr_accessor :newline
       attr_accessor :inferred_type
 
+      # defines children of a node by name,
+      # respecting call order.
+      #
+      # @param [Symbol] name the name of the child node
       def self.child(name)
         @children ||= []
         index = @children.size
@@ -60,6 +64,13 @@ module Mirah
         java.util.ArrayList.new(@children)
       end
 
+      #
+      # @param [Mirah::AST::Node] parent the parent node
+      # @param [JMetaPosition] position the location in the source code of the node
+      # @param [Array] children the list of child nodes
+      # @yield [self] yields the node being initialized, expects the list of children as the result.
+      #               takes priority over the `children` argument.
+      # 
       def initialize(parent, position, children = [])
         JRuby.reference(self.class).setRubyClassAllocator(JRuby.reference(self.class).reified_class)
         unless parent.nil? || Mirah::AST::Node === parent
@@ -271,6 +282,10 @@ module Mirah
         end
         inferred_type
       end
+
+      def top_level?
+        false
+      end
     end
 
 
@@ -356,99 +371,9 @@ module Mirah
       end
     end
 
-    class Constant < Node
-      include Named
-      include Scoped
-      attr_accessor :array
-
-      def initialize(parent, position, name)
-        self.name = name
-        super(parent, position, [])
-      end
-
-      def infer(typer, expression)
-        @inferred_type ||= begin
-          # TODO lookup constant, inline if we're supposed to.
-          typer.type_reference(scope, name, @array, true)
-        end
-      end
-
-      def type_reference(typer)
-        typer.type_reference(scope, @name, @array)
-      end
-    end
-
-    class Self < Node
-      include Scoped
-      def infer(typer, expression)
-        @inferred_type ||= scope.static_scope.self_type
-      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
-
     class NodeProxy < DelegateClass(Node)
       include Java::DubyLangCompiler::Node
+      include Java::DubyLangCompiler.Call
       def __inline__(node)
         node.parent = parent
         __setobj__(node)
@@ -646,7 +571,12 @@ module Mirah
     end
 
     def self.unreachable_type
-      TypeReference::UnreachableType
+      factory = type_factory
+      if factory
+        factory.unreachable_type
+      else
+        TypeReference::UnreachableType
+      end
     end
 
     def self.block_type

data/lib/mirah/ast/call.rb

@@ -50,11 +50,12 @@ module Mirah::AST
     def validate_parameters
       parameters.each_with_index do |child, i|
         if UnquotedValue === child
-          child = child.node
-          child.parent = self
-          parameters[i] = child
+          children = child.nodes
+          children.each {|c| c.parent = self}
+          parameters[i] = children
         end
       end
+      parameters.flatten!
     end
 
     def infer(typer, expression)
@@ -169,6 +170,21 @@ module Mirah::AST
         parameter_types << Mirah::AST.block_type if block
 
         unless should_defer
+          class_name, array = self.type_name(true)
+          if class_name && parameters.size == 1 && typer.known_type(scope, class_name)
+            # Support casts to fully-qualified names and inner classes.
+            begin
+              type = inferred_type = typer.type_reference(scope, class_name, array)
+              @inferred_type = type unless (type && type.error?)
+              if @inferred_type
+                # cast operation
+                resolved!
+                self.cast = true
+                return @inferred_type
+              end
+            rescue
+            end
+          end
           @inferred_type = typer.method_type(receiver_type, name,
                                              parameter_types)
           if @inferred_type.kind_of? InlineCode
@@ -203,6 +219,14 @@ module Mirah::AST
     end
 
     def type_reference(typer)
+      class_name, array = type_name
+      typer.type_reference(scope, class_name, array)
+    end
+
+    def type_name(force=false)
+      if !force && parameters && !parameters.empty?
+        return nil
+      end
       if name == "[]"
         # array type, top should be a constant; find the rest
         array = true
@@ -216,19 +240,27 @@ module Mirah::AST
       while !receiver.eql?(old_receiver)
         old_receiver = receiver
         case receiver
-        when Constant, FunctionalCall, Local, Annotation
+        when Constant, Local, Annotation
           elements.unshift(receiver.name)
+        when FunctionalCall
+          if receiver.parameters.nil? || receiver.parameters.empty?
+            elements.unshift(receiver.name)
+          else
+            return nil, nil
+          end
         when Call
-          elements.unshift(receiver.name)
-          receiver = receiver.target
+          if receiver.parameters.nil? || receiver.parameters.empty?
+            elements.unshift(receiver.name)
+            receiver = receiver.target
+          else
+            return nil, nil
+          end
         when String
           elements.unshift(receiver.literal)
         end
       end
 
-      # join and load
-      class_name = elements.join(".")
-      typer.type_reference(scope, class_name, array)
+      return elements.join("."), array
     end
   end
 

data/lib/mirah/ast/class.rb

@@ -54,13 +54,13 @@ module Mirah::AST
       node
     end
 
-    def define_method(position, name, type, *args)
-      append_node(_define_method(MethodDefinition, position, name, type, args))
+    def define_method(position, name, type, *args, &block)
+      append_node(_define_method(MethodDefinition, position, name, type, args, &block))
     end
 
-    def define_static_method(position, name, type, *args)
+    def define_static_method(position, name, type, *args, &block)
       append_node(
-          _define_method(StaticMethodDefinition, position, name, type, args))
+          _define_method(StaticMethodDefinition, position, name, type, args, &block))
     end
 
     def define_constructor(position, *args, &block)
@@ -122,6 +122,10 @@ module Mirah::AST
         end
       end
     end
+
+    def top_level?
+      true
+    end
   end
 
   defmacro('implements') do |transformer, fcall, parent|
@@ -159,6 +163,10 @@ module Mirah::AST
     def superclass_node
       nil
     end
+
+    def top_level?
+      true
+    end
   end
 
   class ClosureDefinition < ClassDefinition
@@ -307,8 +315,6 @@ module Mirah::AST
         the_scope.self_type = the_scope.self_type.include(typeref)
       end
     end
-
-    def compile(compiler, expression); end
   end
 
   defmacro("include") do |transformer, fcall, parent|
@@ -320,4 +326,26 @@ module Mirah::AST
       end
     end
   end
+
+  class Constant < Node
+    include Named
+    include Scoped
+    attr_accessor :array
+
+    def initialize(parent, position, name)
+      self.name = name
+      super(parent, position, [])
+    end
+
+    def infer(typer, expression)
+      @inferred_type ||= begin
+        # TODO lookup constant, inline if we're supposed to.
+        typer.type_reference(scope, name, @array, true)
+      end
+    end
+
+    def type_reference(typer)
+      typer.type_reference(scope, @name, @array)
+    end
+  end
 end

data/lib/mirah/ast/flow.rb

@@ -235,7 +235,7 @@ module Mirah
               typer.defer(self)
               return
             end
-            if throwable.assignable_from?(arg_type) && !arg_type.meta?
+            if throwable.compatible?(arg_type) && !arg_type.meta?
               resolved!
               return @inferred_type
             end
@@ -245,7 +245,7 @@ module Mirah
           if arg_types.any? {|c| c.nil?}
             typer.defer(self)
           else
-            if arg_types[0] && throwable.assignable_from?(arg_types[0])
+            if arg_types[0] && throwable.compatible?(arg_types[0])
               klass = children.shift
             else
               klass = Constant.new(self, position, 'RuntimeException')
@@ -315,20 +315,32 @@ module Mirah
     class Rescue < Node
       child :body
       child :clauses
+      child :else_node
+
       def initialize(parent, position, &block)
         super(parent, position, &block)
-        @body, @clauses = children
       end
 
       def infer(typer, expression)
         unless resolved?
-          types = [typer.infer(body, true )] + clauses.map {|c| typer.infer(c, true)}
+          types = []
+          body_type = typer.infer(body, else_node.nil?) if body
+          else_type = typer.infer(else_node, true) if else_node
+          if else_node
+            types << else_type
+          elsif body
+            types << body_type
+          end
+          types += clauses.map {|c| typer.infer(c, true)}
           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]
+            types.each do |type|
+              @inferred_type ||= type unless type.unreachable?
+            end
+            @inferred_type ||= types[0]
           end
         end
         @inferred_type