mirah 0.1.2-java → 0.1.3-java

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

@@ -1,311 +0,0 @@
-module Mirah
-  module JVM
-    module Types
-      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
-          def full_name
-            name
-          end
-        end
-
-        include Mirah::JVM::MethodLookup
-        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
-
-        def initialize(type_system, mirror_or_name)
-          @type_system = type_system
-          raise ArgumentError if type_system.nil?
-          if mirror_or_name.kind_of?(BiteScript::ASM::ClassMirror)
-            @type = mirror_or_name
-            @name = mirror_or_name.type.class_name
-          else
-            @name = mirror_or_name.to_s
-          end
-          raise ArgumentError, "Bad type #{mirror_or_name}" if name =~ /Java::/
-        end
-
-        def full_name
-          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
-        end
-
-        def void?
-          false
-        end
-
-        def meta?
-          false
-        end
-        def isMeta
-          self.meta?
-        end
-
-
-        def generic?
-          false
-        end
-        def isGeneric
-          self.generic?
-        end
-
-        def isBlock
-          false
-        end
-
-        def array?
-          false
-        end
-        def isArray
-          self.array?
-        end
-
-        def primitive?
-          false
-        end
-        def isPrimitive
-          self.primitive?
-        end
-
-        def interface?
-          # FIXME: Don't do rescue nil. Figure out a cleaner way to handle
-          # mirrors for all incoming types without blowing up on e.g. 'boolean' or 'int'
-          (@type || BiteScript::ASM::ClassMirror.for_name(@name)).interface? rescue nil
-        end
-
-        def abstract?
-          (@type || BiteScript::ASM::ClassMirror.for_name(@name)).abstract? rescue nil
-        end
-
-        def dynamic?
-          false
-        end
-
-        def inner_class?
-          @inner_class
-        end
-
-        def is_parent(other)
-          assignable_from?(other)
-        end
-
-        def compatible?(other)
-          assignable_from?(other)
-        end
-
-        def error?
-          false
-        end
-        def isError
-          false
-        end
-
-        def assignable_from?(other)
-          return false unless other
-          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
-
-          return true if jvm_type && (jvm_type == other.jvm_type)
-
-          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
-
-        def widen(other)
-          return self if assignable_from?(other)
-          common_parent = (ancestors_and_interfaces & ([other] + other.ancestors_and_interfaces))[0]
-          common_parent || ErrorType.new([["Incompatible types #{self} and #{other}."]])
-        end
-
-        def matchesAnything; false; end
-
-        def iterable?
-          ['java.lang.Iterable',
-           'java.util.Iterator',
-           'java.util.Enumeration'].any? {|n| @type_system.type(nil, n).assignable_from(self)}
-        end
-
-        def component_type
-          @type_system.type(nil, 'java.lang.Object') if iterable?
-        end
-
-        def meta
-          @meta ||= MetaType.new(self)
-        end
-
-        def unmeta
-          self
-        end
-
-        def generic
-          @generic ||= GenericType.new(self)
-        end
-
-        def ungeneric
-          self
-        end
-
-        def type_parameters
-          return nil unless jvm_type
-          jvm_type.type_parameters
-        end
-
-        def basic_type
-          self
-        end
-
-        def array_type
-          @array_type ||= Mirah::JVM::Types::ArrayType.new(self)
-        end
-
-        def prefix
-          'a'
-        end
-
-        # is this a 64 bit type?
-        def wide?
-          false
-        end
-
-        def inspect(indent=0)
-          "#{' ' * indent}#<#{self.class.name.split(/::/)[-1]} #{name}>"
-        end
-
-        def to_s
-          inspect
-        end
-
-        def newarray(method)
-          method.anewarray(self)
-        end
-
-        def pop(method)
-          if wide?
-            method.pop2
-          else
-            method.pop
-          end
-        end
-
-        def superclass
-          raise "Incomplete type #{self}" unless jvm_type
-          @type_system.type(nil, jvm_type.superclass) if jvm_type.superclass
-        end
-
-        def interfaces(include_parent=true)
-          raise "Incomplete type #{self} (#{self.class})" unless jvm_type
-          @interfaces ||= begin
-            interfaces = jvm_type.interfaces.map {|i| @type_system.type(nil, i)}.to_set
-            if superclass && include_parent
-              interfaces |= superclass.interfaces
-            end
-            interfaces.to_a
-          end
-          @interfaces
-        end
-
-        def ancestors_and_interfaces
-          if self.primitive?
-            []
-          else
-            ancestors = []
-            get_ancestors = lambda {|c| [c.superclass] + c.interfaces(false)}
-            new_ancestors = get_ancestors.call(self)
-            until new_ancestors.empty?
-              klass = new_ancestors.shift
-              next if klass.nil? || klass.name == 'java.lang.Object' || klass.isError
-              ancestors << klass
-              new_ancestors.concat(get_ancestors.call(klass))
-            end
-            ancestors << @type_system.type(nil, 'java.lang.Object')
-            ancestors
-          end
-        end
-
-        def astore(builder)
-          if primitive?
-            builder.send "#{name[0,1]}astore"
-          else
-            builder.aastore
-          end
-        end
-
-        def aload(builder)
-          if primitive?
-            builder.send "#{name[0,1]}aload"
-          else
-            builder.aaload
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module Mirah
-  module JVM
-    module Types
-      class TypeDefinition < Type
-        java_import 'mirah.lang.ast.InterfaceDeclaration'
-        attr_accessor :node, :scope
-
-        def initialize(types, scope, name, node)
-          raise ArgumentError, "Bad name #{name}" if name[0,1] == '.'
-          raise ArgumentError, "Bad name #{name}" if name.include? ?/
-          @type_system = types
-          @scope = scope
-          @name = name
-          @node = node
-          @fields = {}
-          raise ArgumentError, "Bad type #{name}" if self.name =~ /Java::/
-        end
-
-        def name
-          if @type
-            @type.name.tr('/', '.')
-          else
-            if !@name.include?(?.) && scope.package
-              "#{scope.package}.#{@name}"
-            else
-              @name
-            end
-          end
-        end
-
-        def superclass
-          if node && node.superclass
-            @type_system.get(scope, node.superclass.typeref).resolve
-          else
-            @type_system.type(nil, 'java.lang.Object')
-          end
-        end
-
-        def interfaces(include_parent=true)
-          if node
-            node.interfaces.map {|n| @type_system.get(scope, n.typeref).resolve}
-          else
-            []
-          end
-        end
-
-        def abstract?
-          node && (node.kind_of?(InterfaceDeclaration) || node.annotated_abstract?)
-        end
-
-        def define(builder)
-          class_name = name.tr('.', '/')
-          is_interface = node && node.kind_of?(InterfaceDeclaration)
-          @type ||= builder.define_class(
-              class_name,
-              :visibility => :public,
-              :abstract => abstract?,
-              :interface => is_interface,
-              :superclass => superclass,
-              :interfaces => interfaces)
-        end
-
-        def meta
-          @meta ||= TypeDefMeta.new(self)
-        end
-      end
-
-      class TypeDefMeta < MetaType
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Mirah
-  module JVM
-    module Types
-      class VoidType < PrimitiveType
-        def initialize(types)
-          super(types, 'void', Java::JavaLang::Void)
-        end
-
-        def void?
-          true
-        end
-
-        def return(builder)
-          builder.returnvoid
-        end
-      end
-    end
-  end
-end

data/lib/mirah/util/compilation_state.rb

@@ -1,60 +0,0 @@
-# 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 'bitescript'
-
-module Mirah
-  module Util
-    class CompilationState
-      def initialize
-        @save_extensions = true
-        set_jvm_version ENV_JAVA['java.specification.version']
-      end
-
-      attr_accessor :verbose, :destination
-      attr_accessor :version_printed
-      attr_accessor :help_printed
-      attr_accessor :save_extensions
-      attr_accessor :running
-      alias running? running
-      attr_accessor :compiler_class
-      attr_accessor :args
-      attr_accessor :command
-      attr_accessor :loggers
-      attr_accessor :type_system
-
-      attr_accessor :classpath, :bootclasspath
-      attr_reader :target_jvm_version, :bytecode_version
-
-      def set_jvm_version(ver_str)
-        @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
-        when '1.8' then BiteScript::JAVA1_8
-        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