mirah 0.0.12-java → 0.1.0-java

data/examples/rosettacode/rot-13.mirah

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

data/examples/rosettacode/secure-temporary-file.mirah

@@ -16,8 +16,8 @@
 import java.io.File
 
 filename = File.createTempFile('prefix', '.suffix')
- 
+
 # Delete temp file when program exits
 filename.deleteOnExit()
- 
+
 puts filename

data/examples/rosettacode/sleep.mirah

@@ -16,7 +16,7 @@
 import java.util.Scanner
 
 puts 'Enter time to sleep in milliseconds: '
-ms = Scanner.new(System.in).nextInt() 
+ms = Scanner.new(System.in).nextInt()
 puts 'Sleeping...'
 Thread.sleep(ms)
 puts 'Awake!'

data/examples/rosettacode/string-length.mirah

@@ -15,17 +15,17 @@
 
 /**
 * Java encodes strings in UTF-16, which represents each character with one
-* or two 16-bit values. The length method of String objects returns the 
-* number of 16-bit values used to encode a string, so the number of bytes 
+* or two 16-bit values. The length method of String objects returns the
+* number of 16-bit values used to encode a string, so the number of bytes
 * can be determined by doubling that number.
-*/ 
+*/
 
 s = "Hello, world!"
 puts s.length() * 2
 
 /**
-* Another way to know the byte length of a string is to explicitly 
+* Another way to know the byte length of a string is to explicitly
 * specify the charset we desire.
-*/ 
+*/
 puts s.getBytes("UTF-16").length
 puts s.getBytes("UTF-8").length

data/examples/swing.mirah

@@ -32,4 +32,4 @@ def self.run
   end
 end
 
-run
+run

data/examples/test.edb

@@ -6,4 +6,4 @@
   <h1><%= @message %></h1>
   </body>
 </html>
-    
+

data/lib/duby.rb

@@ -14,4 +14,4 @@
 # limitations under the License.
 
 puts "WARNING: Duby is now Mirah. Please require 'mirah'."
-require File.dirname(__FILE__) + '/mirah'
+require File.dirname(__FILE__) + '/mirah'

data/lib/mirah.rb

@@ -15,18 +15,25 @@
 
 require 'fileutils'
 require 'rbconfig'
+require 'bitescript'
+
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-builtins.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-parser.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-bootstrap.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-util.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/dynalink-0.2.jar'
+
 require 'mirah/version'
 require 'mirah/transform'
 require 'mirah/ast'
-require 'mirah/typer'
 require 'mirah/compiler'
 require 'mirah/env'
 require 'mirah/errors'
-require 'bitescript'
+require 'mirah/typer'
+require 'mirah/jvm/types'
 
 require 'mirah/jvm/compiler'
-require 'mirah/jvm/typer'
-Dir[File.dirname(__FILE__) + "/mirah/plugin/*"].each {|file| require "#{file}" if file =~ /\.rb$/}
+#Dir[File.dirname(__FILE__) + "/mirah/plugin/*"].each {|file| require "#{file}" if file =~ /\.rb$/}
 require 'jruby'
 
 require 'mirah/commands'
@@ -57,30 +64,45 @@ module Mirah
       puts message
       return
     end
-    puts "#{position.file}:#{position.start_line}: #{message}"
-    file_offset = 0
-    startline = position.start_line - 1
-    endline = position.end_line - 1
-    start_col = position.start_col - 1
-    end_col = position.end_col - 1
-    # don't try to search dash_e
-    # TODO: show dash_e source the same way
-    if File.exist? position.file
-      File.open(position.file).each_with_index do |line, lineno|
-        if lineno >= startline && lineno <= endline
-          puts line.chomp
-          if lineno == startline
-            print ' ' * start_col
-          else
-            start_col = 0
-          end
-          if lineno < endline
-            puts '^' * (line.size - start_col)
-          else
-            puts '^' * [end_col - start_col, 1].max
-          end
-        end
-      end
+    puts "#{position.source.name}:#{position.start_line}: #{message}"
+    puts underline(position)
+  end
+
+  def self.underline(position)
+    start_line = position.start_line - position.source.initial_line
+    end_line = position.end_line - position.source.initial_line
+
+    start_col = position.start_column
+    end_col = position.end_column
+    adjustment = if start_line == 0
+      position.source.initial_column
+    else
+      1
+    end
+
+    start_col -= adjustment
+    end_col -= adjustment
+
+    result = ""
+    position.source.contents.each_line.with_index do |line, lineno|
+      break if lineno > end_line
+      next if lineno < start_line
+
+      chomped = line.chomp
+      result << chomped
+      result << "\n"
+
+      start = 0
+      start = start_col if lineno == start_line
+
+      result << " " * start
+
+      endcol = chomped.size
+      endcol = end_col if lineno == end_line
+
+      result << "^" * [endcol - start, 1].max
+      result << "\n"
     end
+    result
   end
 end

data/lib/mirah/ast.rb

@@ -16,7 +16,6 @@
 require 'mirah/util/delegate'
 require 'mirah/transform'
 require 'mirah/ast/scope'
-require 'jruby/core_ext'
 
 module Mirah
   module AST
@@ -24,610 +23,21 @@ module Mirah
       attr_accessor :verbose
     end
 
-    # The top of the AST class hierarchy, this represents an abstract AST node.
-    # It provides accessors for _children_, an array of all child nodes,
-    # _parent_, a reference to this node's parent (nil if none), and _newline_,
-    # whether this node represents a new line.
-    class Node
-      include Java::DubyLangCompiler.Node
-      include Enumerable
+    java_import 'mirah.lang.ast.Array'
+    java_import 'mirah.lang.ast.Annotation'
+    java_import 'mirah.lang.ast.Constant'
+    java_import 'mirah.lang.ast.EmptyArray'
+    java_import 'mirah.lang.ast.Fixnum'
+    java_import 'mirah.lang.ast.HashEntry'
+    java_import 'mirah.lang.ast.LocalAccess'
+    java_import 'mirah.lang.ast.Node'
+    java_import 'mirah.lang.ast.NodeList'
+    java_import 'mirah.lang.ast.Noop'
+    java_import 'mirah.lang.ast.OptionalArgument'
+    java_import 'mirah.lang.ast.Position'
+    java_import 'mirah.lang.ast.SimpleString'
+    java_import 'mirah.lang.ast.TypeName'
+    java_import 'mirah.lang.ast.TypeRef'
 
-      attr_accessor :children
-      attr_accessor :parent
-      attr_accessor :position
-      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
-        class_eval <<-EOF
-          def #{name}
-            @children[#{index}]
-          end
-
-          def #{name}=(node)
-            @children[#{index}] = _set_parent(node)
-          end
-        EOF
-        @children << name
-      end
-
-      def self.child_name(i)
-        @children[i] if @children
-      end
-
-      def child_nodes
-        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 1.6.x doesn't seem to like become_java! as much (see bottom of class)
-        if JRUBY_VERSION < '1.7'
-          JRuby.reference(self.class).setRubyClassAllocator(JRuby.reference(self.class).reified_class)
-        end
-        
-        unless parent.nil? || Mirah::AST::Node === parent
-          raise "Mirah::AST::Node.new parent #{parent.class} must be nil or === Mirah::AST::Node."
-        end
-
-        @parent = parent
-        @newline = false
-        @inferred_type = nil
-        @resolved = false
-        @position = position
-        if block_given?
-          @children ||= []
-          @children = yield(self) || []
-        else
-          @children = children
-        end
-      end
-
-      def _dump(depth)
-        to_skip = %w(@parent @newline @inferred_type @resolved @proxy @scope @class_scope @static_scope @typer)
-        vars = {}
-        instance_variables.each do |name|
-          next if to_skip.include?(name)
-          vars[name] = instance_variable_get(name)
-          begin
-            Mirah::AST::Unquote.extract_values do
-              Marshal.dump(vars[name]) if AST.verbose
-            end
-          rescue
-            puts "#{self}: Failed to marshal #{name}"
-            puts inspect
-            puts $!, $@
-            raise $!
-          end
-        end
-          Marshal.dump(vars)
-      end
-
-      def self._load(vars)
-        node = self.allocate
-        Marshal.load(vars).each do |name, value|
-          node.instance_variable_set(name, value)
-        end
-        node.children.each do |child|
-          node._set_parent(child)
-        end
-        node.validate_children
-        node
-      end
-
-      def validate_children
-        validate_name if respond_to?(:validate_name)
-        children.each_with_index do |child, i|
-          validate_child(child, i)
-        end
-      end
-
-      def validate_child(child, i)
-        name = self.class.child_name(i)
-        validator = :"validate_#{name}"
-        if name && respond_to?(validator)
-          send validator
-        else
-          if UnquotedValue === child
-            self[i] = child.node
-          end
-        end
-      end
-
-      def line_number
-        if @position
-          @position.start_line + 1
-        else
-          0
-        end
-      end
-
-      def log(message)
-        puts "* [AST] [#{simple_name}] " + message if AST.verbose
-      end
-
-      def inspect_children(indent = 0)
-        indent_str = ' ' * indent
-        str = ''
-        children.each_with_index do |child, i|
-          extra_indent = 0
-          if child
-            name = self.class.child_name(i)
-            
-            wrong_parent = lambda do |child|
-              if Node === child && child.parent != self 
-                "\n#{indent_str} (wrong parent)"
-              else
-                ""
-              end
-            end
-            
-            if Mirah::AST.verbose && name
-              str << "\n#{indent_str} #{name}:"
-              extra_indent = 1
-            end
-            
-            case child
-            when ::Array
-              child.each do |ary_child|
-                
-                str << wrong_parent[ary_child] if Mirah::AST.verbose
-                
-                str << "\n#{ary_child.inspect(indent + extra_indent + 1)}"
-              end
-            when ::Hash, ::String
-              str << "\n#{indent_str} #{child.inspect}"
-            else
-              str << wrong_parent[child] if Mirah::AST.verbose
-              
-              begin
-                str << "\n#{child.inspect(indent + extra_indent + 1)}"
-              rescue ArgumentError => ex
-                str << "\n#{indent_str} #{child.inspect}"
-              end
-            end
-          end
-        end
-        str
-      end
-
-      def inspect(indent = 0)
-        indent_str = ' ' * indent
-        indent_str << to_s << inspect_children(indent)
-      end
-
-      def simple_name
-        self.class.name.split("::")[-1]
-      end
-
-      def to_s; simple_name; end
-
-      def string_value
-        raise Mirah::SyntaxError.new("Can't use #{self.class} as string literal")
-      end
-
-      def [](index) children[index] end
-
-      def []=(index, node)
-        node.parent = self
-        @children[index] = node
-      end
-
-      def each(&b) children.each(&b) end
-
-      def <<(node)
-        @children << _set_parent(node)
-        self
-      end
-
-      def insert(index, node)
-        node.parent = self
-        @children.insert(index, node)
-      end
-
-      def empty?
-        @children.empty?
-      end
-
-      def resolved!(typer=nil)
-        log "#{to_s} resolved!"
-        @resolved = true
-      end
-
-      def resolved?; @resolved end
-
-      def resolve_if(typer)
-        unless resolved?
-          @inferred_type = yield
-          @inferred_type ? resolved!(typer) : typer.defer(self)
-        end
-        @inferred_type
-      end
-
-      def self.===(other)
-        super || (other.kind_of?(NodeProxy) && (self === other.__getobj__))
-      end
-
-      def _set_parent(node)
-        case node
-        when Node
-          node.parent = self
-        when ::Array
-          node.each {|x| x.parent = self if x}
-        end
-        node
-      end
-
-      def initialize_copy(other)
-        # bug: node is deferred, but it's parent isn't
-        #      parent gets duped
-        #      duped parent is inferred so it's children aren't
-        #      original node gets inferred, but not the duplicate child
-        @inferred_type = @resolved = nil
-        @parent = nil
-        @children = []
-        other.children.each do |child|
-          case child
-          when ::Array
-            self << child.map {|x| x.dup}
-          when nil
-            self << nil
-          else
-            self << child.dup
-          end
-        end
-      end
-
-      def inferred_type!
-        unless @inferred_type
-          raise Mirah::InternalCompilerError.new(
-              "Internal Error: #{self.class} never inferred", self)
-        end
-        inferred_type
-      end
-
-      def top_level?
-        false
-      end
-      
-      if JRUBY_VERSION >= '1.7'
-        become_java!
-      end
-    end
-
-    class ErrorNode < Node
-      def initialize(parent, error)
-        super(parent, error.position)
-        @error = error
-        @inferred_type = TypeReference::ErrorType
-        @resolved = true
-      end
-
-      def infer(typer, expression)
-      end
-    end
-
-    module Named
-      attr_reader :name
-
-      def name=(name)
-        if Node === name
-          name.parent = self
-        end
-        @name = name
-      end
-
-      def to_s
-        "#{super}(#{name})"
-      end
-
-      def string_value
-        name
-      end
-
-      def validate_name
-        if UnquotedValue === @name
-          @name = @name.name
-        end
-      end
-    end
-
-    module Typed
-      attr_accessor :type
-    end
-
-    module Valued
-      include Typed
-      attr_accessor :value
-    end
-
-    module Literal
-      include Typed
-      attr_accessor :literal
-
-      def to_s
-        "#{super}(#{literal.inspect})"
-      end
-
-      def string_value
-        literal.to_s
-      end
-    end
-
-    module Annotated
-      attr_accessor :annotations
-
-      def annotation(name)
-        name = name.to_s
-        annotations.find {|a| a.name == name}
-      end
-    end
-
-    module Binding
-      def binding_type(mirah=nil)
-        static_scope.binding_type(defining_class, mirah)
-      end
-
-      def binding_type=(type)
-        static_scope.binding_type = type
-      end
-
-      def has_binding?
-        static_scope.has_binding?
-      end
-    end
-
-    class NodeProxy < Mirah::Util::DelegateClass(Node)
-      include Java::DubyLangCompiler::Node
-      include Java::DubyLangCompiler.Call
-      
-      def __inline__(node)
-        node.parent = parent
-        __setobj__(node)
-      end
-
-      def dup
-        value = __getobj__.dup
-        if value.respond_to?(:proxy=)
-          new = super
-          new.__setobj__(value)
-          new.proxy = new
-          new
-        else
-          value
-        end
-      end
-
-      def _dump(depth)
-        Marshal.dump(__getobj__)
-      end
-
-      def self._load(str)
-        value = Marshal.load(str)
-        if value.respond_to?(:proxy=)
-          proxy = NodeProxy.new(value)
-          proxy.proxy = proxy
-        else
-          value
-        end
-      end
-    end
-
-    class TypeReference < Node
-      include Named
-      attr_accessor :array
-      alias array? array
-      attr_accessor :meta
-      alias meta? meta
-
-      def initialize(name, array = false, meta = false, position=nil)
-        super(nil, position)
-        self.name = name
-        @array = array
-        @meta = meta
-      end
-
-      def type_reference(typer)
-        typer.type_reference(nil, name, array, meta)
-      end
-
-      def to_s
-        "Type(#{name}#{array? ? ' array' : ''}#{meta? ? ' meta' : ''})"
-      end
-
-      def full_name
-        "#{name}#{array ? '[]' : ''}"
-      end
-
-      def ==(other)
-        to_s == other.to_s
-      end
-
-      def eql?(other)
-        self == other
-      end
-
-      def hash
-        to_s.hash
-      end
-
-      def is_parent(other)
-        # default behavior now is to disallow any polymorphic types
-        self == other
-      end
-
-      def compatible?(other)
-        # default behavior is only exact match right now
-        self == other ||
-            error? || other.error? ||
-            unreachable? || other.unreachable?
-      end
-
-      def iterable?
-        array?
-      end
-
-      def component_type
-        AST.type(nil, name) if array?
-      end
-
-      def basic_type
-        if array? || meta?
-          TypeReference.new(name, false, false)
-        else
-          self
-        end
-      end
-
-      def narrow(other)
-        # only exact match allowed for now, so narrowing is a noop
-        if error? || unreachable?
-          other
-        else
-          self
-        end
-      end
-
-      def unmeta
-        TypeReference.new(name, array, false)
-      end
-
-      def meta
-        TypeReference.new(name, array, true)
-      end
-
-      def void?
-        name == :void
-      end
-
-      def error?
-        name == :error
-      end
-
-      def null?
-        name == :null
-      end
-
-      def unreachable?
-        name == :unreachable
-      end
-
-      def block?
-        name == :block
-      end
-
-      def primitive?
-        true
-      end
-
-      def _dump(depth)
-        Marshal.dump([name, array?, meta?])
-      end
-
-      def self._load(str)
-        AST::Type(*Marshal.load(str))
-      end
-
-      NoType = TypeReference.new(:notype)
-      NullType = TypeReference.new(:null)
-      ErrorType = TypeReference.new(:error)
-      UnreachableType = TypeReference.new(:unreachable)
-      BlockType = TypeReference.new(:block)
-    end
-
-    class TypeDefinition < TypeReference
-      attr_accessor :superclass, :interfaces
-
-      def initialize(name, superclass, interfaces)
-        super(name, false)
-
-        @superclass = superclass
-        @interfaces = interfaces
-      end
-    end
-
-    def self.type_factory
-      Thread.current[:ast_type_factory]
-    end
-
-    def self.type_factory=(factory)
-      Thread.current[:ast_type_factory] = factory
-    end
-
-    # Shortcut method to construct type references
-    def self.type(scope, typesym, array = false, meta = false)
-      factory = type_factory
-      if factory
-        factory.type(scope, typesym, array, meta)
-      else
-        TypeReference.new(typesym, array, meta)
-      end
-    end
-
-    def self.no_type
-      factory = type_factory
-      if factory
-        factory.no_type
-      else
-        TypeReference::NoType
-      end
-    end
-
-    def self.error_type
-      TypeReference::ErrorType
-    end
-
-    def self.unreachable_type
-      factory = type_factory
-      if factory
-        factory.unreachable_type
-      else
-        TypeReference::UnreachableType
-      end
-    end
-
-    def self.block_type
-      TypeReference::BlockType
-    end
-
-    def self.fixnum(parent, position, literal)
-      Fixnum.new(parent, position, literal)
-    end
-
-    def self.float(parent, position, literal)
-      Float.new(parent, position, literal)
-    end
-
-    def self.defmacro(name, &block)
-      @macros ||= {}
-      raise "Conflicting macros for #{name}" if @macros[name]
-      @macros[name] = block
-    end
-
-    def self.macro(name)
-      @macros[name]
-    end
   end
 end
-
-require 'mirah/ast/local'
-require 'mirah/ast/call'
-require 'mirah/ast/flow'
-require 'mirah/ast/literal'
-require 'mirah/ast/method'
-require 'mirah/ast/class'
-require 'mirah/ast/structure'
-require 'mirah/ast/type'
-require 'mirah/ast/intrinsics'