mirah 0.1.0.pre-java → 0.1.1-java

data/lib/mirah/jvm/method_lookup.rb

@@ -99,7 +99,7 @@ module Mirah
         by_name = if constructor
           mapped_type.unmeta.declared_constructors
         elsif meta
-          mapped_type.declared_class_methods(name)
+          mapped_type.find_callable_static_methods(name)
         else
           mapped_type.find_callable_methods(name)
         end
@@ -118,21 +118,27 @@ module Mirah
 
       def find_jls2(mapped_type, name, mapped_params, meta, by_name, include_fields=true, scope=nil)
         return nil if mapped_params.any? {|p| p.nil? || p.isError}
-        # filter by arity
-        by_name_and_arity = by_name.select {|m| m.argument_types.size == mapped_params.size}
+
+        # filter by arity, varargs
+        by_name_and_arity = by_name.select {|m| m.argument_types.size == mapped_params.size }
 
         phase1_methods = phase1(mapped_params, by_name_and_arity)
 
         if phase1_methods.size > 1
           method_list = phase1_methods.map do |m|
-            "#{m.name}(#{m.parameter_types.map(&:name).join(', ')})"
+            case m.member
+            when BiteScript::ASM::MethodMirror
+              m.member.inspect
+            else
+              "#{m.name}(#{m.parameter_types.map(&:name).join(', ')})"
+            end
           end.join("\n")
           raise "Ambiguous targets invoking #{mapped_type}.#{name}:\n#{method_list}"
         end
 
         phase1_methods[0] ||
           phase2(mapped_params, by_name) ||
-          phase3(mapped_params, by_name) ||
+          phase3(mapped_params, by_name)[0] ||
           (include_fields &&
             (field_lookup(mapped_params, mapped_type, meta, name, scope) ||
              inner_class(mapped_params, mapped_type, meta, name)))
@@ -152,15 +158,17 @@ module Mirah
           end
 
           # otherwise, check for potential match and compare to current
-          # TODO: missing ambiguity check; picks last method of equal specificity
+          # TODO: missing ambiguity check; picks first method of equal specificity
+          # Picking the first method means we prefer methods from the child class,
+          # which is important if the parent class is not accessible (like AbstractStringBuilder).
           if each_is_exact_or_subtype_or_convertible(mapped_params, method_params)
-            if currents.size > 0
-              if is_more_specific?(potential.argument_types, currents[0].argument_types)
-                # potential is better, dump all currents
-                currents = [potential]
-              elsif is_more_specific?(currents[0].argument_types, potential.argument_types)
+            if !currents.empty?
+              if is_more_specific?(currents[0].argument_types, potential.argument_types)
                 # currents are better, try next potential
                 #next
+              elsif is_more_specific?(potential.argument_types, currents[0].argument_types)
+                # potential is better, dump all currents
+                currents = [potential]
               else
                 # equal specificity, append to currents
                 currents << potential
@@ -186,7 +194,26 @@ module Mirah
       end
 
       def phase3(mapped_params, potentials)
-        nil
+        potential_varargs = potentials.select{|m| m.respond_to?(:varargs?) && m.varargs? }
+        methods = potential_varargs.inject([]) do |currents, potential|
+          method_params = potential.argument_types
+          # match n-1 params of potential
+          non_varargs_params, possible_varargs_params = mapped_params.partition.with_index{|param,i| i < method_params.size-1}
+          
+          vararg_types = possible_varargs_params.size.times.map{ method_params.last.component_type }
+          
+          if each_is_exact(non_varargs_params, method_params[0..-2]) &&
+              each_is_exact(possible_varargs_params, vararg_types)
+            return [potential]
+          end
+          
+          if each_is_exact_or_subtype_or_convertible(non_varargs_params, method_params[0..-2]) &&
+              each_is_exact_or_subtype_or_convertible(possible_varargs_params, vararg_types)
+            currents << potential
+          end
+
+          currents
+        end
       end
 
       def field_lookup(mapped_params, mapped_type, meta, name, scope)
@@ -234,24 +261,17 @@ module Mirah
       end
 
       def inner_class(params, type, meta, name)
-        return unless params.size == 0 && meta
+        return unless params.empty? && meta
         log("Attempting inner class lookup for '#{name}' on #{type}")
         type.inner_class_getter(name)
       end
 
       def each_is_exact(incoming, target)
-        incoming.each_with_index do |in_type, i|
-          target_type = target[i]
-
-          # exact match
-          return false unless target_type == in_type
-        end
-        return true
+        incoming.zip(target).all? { |in_type, target_type| target_type == in_type }
       end
 
       def each_is_exact_or_subtype_or_convertible(incoming, target)
-        incoming.each_with_index do |in_type, i|
-          target_type = target[i]
+        incoming.zip(target).each do |in_type, target_type|
 
           # exact match
           next if target_type == in_type
@@ -259,6 +279,7 @@ module Mirah
           unless target_type.respond_to?(:primitive?) && in_type.respond_to?(:primitive?)
             puts "Huh?"
           end
+
           # primitive is safely convertible
           if target_type.primitive?
             if in_type.primitive?

data/lib/mirah/jvm/types.rb

@@ -29,11 +29,9 @@ require 'mirah/jvm/types/meta_type'
 require 'mirah/jvm/types/generic_type'
 require 'mirah/jvm/types/null_type'
 require 'mirah/jvm/types/implicit_nil_type'
-require 'mirah/jvm/types/unreachable_type'
 require 'mirah/jvm/types/void_type'
 require 'mirah/jvm/types/block_type'
 require 'mirah/jvm/types/array_type'
-require 'mirah/jvm/types/dynamic_type'
 require 'mirah/jvm/types/type_definition'
 require 'mirah/jvm/types/interface_definition'
 require 'mirah/jvm/types/intrinsics'
@@ -44,3 +42,4 @@ require 'mirah/jvm/types/boolean'
 require 'mirah/jvm/types/floats'
 require 'mirah/jvm/types/literals'
 require 'mirah/jvm/types/factory'
+require 'mirah/jvm/types/extensions'

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

@@ -6,12 +6,7 @@ module Mirah
 
         def initialize(component_type)
           @component_type = component_type
-          if @component_type.jvm_type
-            #@type = java.lang.reflect.Array.newInstance(@component_type.jvm_type, 0).class
-          else
-            # FIXME: THIS IS WRONG, but I don't know how to fix it
-            #@type = @component_type
-          end
+
           @name = component_type.name
           @type_system = component_type.type_system
           self.intrinsics

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

@@ -0,0 +1,31 @@
+# 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.
+
+class Java::MirahLangAst::NodeImpl
+  def annotated_abstract?
+    annotations.each do |anno|
+      if anno.type.typeref.name == 'org.mirah.jvm.types.Modifiers'
+        anno.values.each do |entry|
+          if entry.key.identifier == 'flags'
+            entry.value.values.each do |value|
+              return true if value.identifier == 'ABSTRACT'
+            end
+          end
+        end
+      end
+    end
+    false
+  end
+end

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

@@ -19,7 +19,7 @@ module Mirah::JVM::Types
       @known_types.update(
         'boolean' => BooleanType.new(self, 'boolean', java.lang.Boolean),
         'byte' => IntegerType.new(self, 'byte', java.lang.Byte),
-        'char' => IntegerType.new(self, 'char', java.lang.Character),
+        'char' => CharacterType.new(self, 'char', java.lang.Character),
         'short' => IntegerType.new(self, 'short', java.lang.Short),
         'int' => IntegerType.new(self, 'int', java.lang.Integer),
         'long' => LongType.new(self, 'long', java.lang.Long),
@@ -36,7 +36,6 @@ module Mirah::JVM::Types
       @known_types['void'] = VoidType.new(self)
       @known_types['null'] = NullType.new(self)
       @known_types['implicit_nil'] = ImplicitNilType.new(self)
-      @known_types['dynamic'] = DynamicType.new(self)
     end
   end
 end

data/lib/mirah/jvm/types/boolean.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");
@@ -23,15 +23,6 @@ module Mirah::JVM::Types
       'i'
     end
 
-    def box(builder)
-      box_type = Mirah::AST::type(nil, 'java.lang.Boolean')
-      builder.invokestatic box_type, "valueOf", [box_type, self]
-    end
-
-    def box_type
-      @type_system.type(nil, 'java.lang.Boolean')
-    end
-
     def add_intrinsics
       args = [math_type]
       add_method('==', args, ComparisonIntrinsic.new(self, '==', :eq, args))
@@ -42,6 +33,16 @@ module Mirah::JVM::Types
       @type_system.type(nil, 'boolean')
     end
 
+    def compile_widen(builder, type)
+      case type.name
+      when 'boolean'
+      when wrapper_name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
+      else
+        raise ArgumentError, "Invalid widening conversion from #{name} to #{type}"
+      end
+    end
+
     # same as NumberType's
     def compile_boolean_operator(compiler, op, negated, call, label)
       # Promote the target or the argument if necessary

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

@@ -62,22 +62,31 @@ module Mirah::JVM::Types
     end
 
     def declared_instance_methods(name=nil)
-      __combine_methods(__getobj__.declared_instance_methods)
+      __combine_methods(__getobj__.declared_instance_methods, name)
     end
 
     def declared_class_methods(name=nil)
-      __combine_methods(__getobj__.declared_class_methods)
+      __combine_methods(__getobj__.declared_class_methods, name)
     end
 
-    def __combine_methods(basic_methods)
+    def find_callable_methods(name, include_interfaces=false)
+      __combine_methods(__getobj__.find_callable_methods(name, include_interfaces), name)
+    end
+
+    def find_callable_static_methods(name)
+      __combine_methods(__getobj__.find_callable_static_methods(name), name)
+    end
+
+    def __combine_methods(basic_methods, name)
       methods = {}
       basic_methods.each do |method|
-        key = [method.name, method.parameter_types, method.return_type]
+        key = [method.name, method.argument_types, method.return_type]
         methods[key] = method
       end
       @static_includes.each do |type|
         type.declared_class_methods.each do |method|
-          key = [method.name, method.parameter_types, method.return_type]
+          next if name && method.name != name
+          key = [method.name, method.argument_types, method.return_type]
           methods[key] ||= method
         end
       end

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

@@ -40,13 +40,8 @@ module Mirah::JVM::Types
     begin
       java_import 'org.mirah.builtins.Builtins'
     rescue NameError
-      $CLASSPATH << File.dirname(__FILE__) + '/../../../../javalib/mirah-builtins.jar'
-      begin
-        java_import 'org.mirah.builtins.Builtins'
-      rescue NameError
-        # We might be trying to compile mirah-builtins.jar, so just continue.
-        Builtins = nil
-      end
+      # We might be trying to compile mirah-builtins.jar, so just continue.
+      Builtins = nil
     end
 
     java_import 'java.net.URLClassLoader'
@@ -67,6 +62,7 @@ module Mirah::JVM::Types
       @declarations = []
       @mirrors = {}
       @futures = {}
+      @fields = {}
       create_basic_types
     end
 
@@ -77,12 +73,13 @@ module Mirah::JVM::Types
       end
       @declarations = []
       @futures = {}
+      @fields = {}
     end
 
     def maybe_initialize_builtins(compiler)
       if Builtins
         begin
-          Builtins.initialize_builtins(compiler)
+          Builtins.initialize_builtins(compiler.type_system)
         rescue NativeException => ex
           error("Error initializing builtins", ex.cause)
         rescue => ex
@@ -102,6 +99,7 @@ module Mirah::JVM::Types
     def cache_and_wrap(resolved_type)
       @futures[resolved_type.name] ||= wrap(resolved_type)
     end
+
     def cache_and_wrap_type(name)
       @futures[name] ||= begin
         type = type(nil, name)
@@ -115,6 +113,7 @@ module Mirah::JVM::Types
     def addDefaultImports(scope)
       scope.import('java.lang.*', '*')
     end
+
     def getNullType; cache_and_wrap_type('null') end
     def getImplicitNilType; cache_and_wrap_type('implicit_nil') end
     def getVoidType; cache_and_wrap_type('void') end
@@ -166,6 +165,7 @@ module Mirah::JVM::Types
         future
       end
     end
+
     def getSuperClass(future)
       superclass = BaseTypeFuture.new(nil)
       future.on_update do |_, type|
@@ -173,6 +173,7 @@ module Mirah::JVM::Types
       end
       superclass
     end
+
     def getArrayType(type)
       if type.kind_of?(Type)
         type.array_type
@@ -182,6 +183,7 @@ module Mirah::JVM::Types
         future
       end
     end
+
     def box(type)
       boxed = BaseTypeFuture.new(nil)
       type.on_update do |_, resolved|
@@ -205,6 +207,7 @@ module Mirah::JVM::Types
       log("Error inferring generics: #{ex.message}\n#{ex.backtrace.join("\n")}")
       cache_and_wrap_type('java.util.List')
     end
+
     def getHashLiteralType(key_type, value_type, position)
       result = Mirah::JVM::Types::GenericType.new(type(nil, 'java.util.HashMap')) # Upgrade to a generic type.
       generic_key, generic_value = result.type_parameters
@@ -218,6 +221,7 @@ module Mirah::JVM::Types
       log("Error inferring generics: #{ex.message}\n#{ex.backtrace.join("\n")}")
       cache_and_wrap_type('java.util.HashMap')
     end
+
     def get(scope, typeref)
       basic_type = if scope.nil?
         cache_and_wrap_type(typeref.name)
@@ -246,6 +250,7 @@ module Mirah::JVM::Types
         basic_type
       end
     end
+
     def getLocalType(scope, name, position)
       scope.local_type(name, position)
     end
@@ -270,12 +275,14 @@ module Mirah::JVM::Types
       type = BaseTypeFuture.new(nil)
       target.find_method2(target, name, argTypes, macroTypes, target.meta?, scope) do |method|
         if method.nil?
-          type.resolved(ErrorType.new([
-              ["Cannot find %s method %s(%s) on %s" %
-                  [ target.meta? ? "static" : "instance",
-                    name,
-                    argTypes.map{|t| t ? t.full_name : "?"}.join(', '),
-                    target.full_name], position]]))
+          unless argTypes.any?{|t| t && t.isError && (type.resolved(t); true)}
+            type.resolved(ErrorType.new([
+                ["Cannot find %s method %s(%s) on %s" %
+                    [ target.meta? ? "static" : "instance",
+                      name,
+                      argTypes.map{|t| t ? t.full_name : "?"}.join(', '),
+                      target.full_name], position]]))
+          end
         elsif method.kind_of?(Exception)
           type.resolved(ErrorType.new([[method.message, position]]))
         else
@@ -404,38 +411,43 @@ module Mirah::JVM::Types
       end
     end
 
-    def getMethodDefType(target, name, argTypes)
+    def getMethodDefType(target, name, argTypes, returnType, position)
       if target.nil?
-        return ErrorType.new([["No target"]])
+        return ErrorType.new([["No target", position]])
       end
       unless argTypes.all? {|a| a.hasDeclaration}
         infer_override_args(target, name, argTypes)
       end
+      if returnType.nil?
+        returnType = infer_override_return_type(target, name, argTypes)
+      end
+
       args = argTypes.map {|a| a.resolve}
       target = target.resolve
-      type = _find_method_type(nil, target, name, args, nil, nil)
+      type = _find_method_type(nil, target, name, args, nil, position)
       type.onUpdate do |m, resolved|
-        resolved = resolved.returnType if resolved.respond_to?(:returnType)
-        log "Learned {0} method {1}.{2}({3}) = {4}", [
-                target.meta? ? "static" : "instance",
-                target.full_name,
-                name,
-                args.map{|a| a.full_name}.join(', '),
-                resolved.full_name].to_java
-        rewritten_name = name.sub(/=$/, '_set')
-        if target.meta?
-          target.unmeta.declare_static_method(rewritten_name, args, resolved, [])
-        else
-          target.declare_method(rewritten_name, args, resolved, []) unless target.isError
+        _declare_method(target, name, args, type)
+      end
+
+      args.each_with_index do |arg, i|
+        if arg.isError
+          argTypes[i].onUpdate do |x, resolved|
+            args[i] = resolved
+            _declare_method(target, name, args, type)
+          end
         end
       end
+
       if type.kind_of?(ErrorType)
         puts "Got error type for method #{name} on #{target.resolve} (#{target.resolve.class})"
         position = type.position rescue nil
         return_type = AssignableTypeFuture.new(position)
         return_type.declare(type, position)
-        type = MethodFuture.new(name, args, return_type, false, nil)
+        type = MethodFuture.new(name, args, return_type, false, position)
+      elsif returnType
+        type.returnType.declare(returnType, position)
       end
+
       type.to_java(MethodFuture)
     rescue => ex
       target_name = target.respond_to?(:name) ? target.name : target.resolve.name
@@ -444,13 +456,48 @@ module Mirah::JVM::Types
       return_type.declare(ErrorType.new([["Internal error: #{ex}"]]), nil)
       MethodFuture.new(name, [], return_type, false, nil)
     end
+
+    def _declare_method(target, name, args, type)
+      return if args.any? {|a| a.isError }
+      return unless type.kind_of?(MethodFuture) && type.returnType.isResolved
+      resolved = type.returnType.resolve
+      resolved = resolved.returnType if resolved.respond_to?(:returnType)
+      log "Learned {0} method {1}.{2}({3}) = {4}", [
+              target.meta? ? "static" : "instance",
+              target.full_name,
+              name,
+              args.map{|a| a.full_name}.join(', '),
+              resolved.full_name].to_java
+      rewritten_name = name.sub(/=$/, '_set')
+      if target.meta?
+        target.unmeta.declare_static_method(rewritten_name, args, resolved, [])
+      else
+        target.declare_method(rewritten_name, args, resolved, [])
+      end      
+    end
+
+    def getFieldType(target, name, position)
+      # This is currently only used for fields in the current class
+      klass = target.resolve
+      key = [klass, name]
+      t = @fields[key]
+      unless t
+        t = AssignableTypeFuture.new(position)
+        @fields[key] = t
+        t.on_update {|x, resolved| klass.unmeta.declare_field(name, resolved, klass.meta?)}
+      end
+      t
+    end
+
     def getMainType(scope, script)
       filename = File.basename(script.position.source.name || 'DashE')
       classname = Mirah::JVM::Compiler::JVMBytecode.classname_from_filename(filename)
       getMetaType(cache_and_wrap(declare_type(scope, classname)))
     end
+
     def defineType(scope, node, name, superclass, interfaces)
       # TODO what if superclass or interfaces change later?
+      log("Defining type #{name} < #{superclass.resolve.name if superclass} #{interfaces.map{|i|i.resolve.name}.inspect}")
       type = define_type(scope, node)
       future = @futures[type.name]
       if future
@@ -468,6 +515,7 @@ module Mirah::JVM::Types
     def addMacro(klass, macro)
       klass.unmeta.add_compiled_macro(macro)
     end
+
     def extendClass(classname, extensions)
       get_type(classname).load_extensions(extensions)
     end
@@ -477,13 +525,27 @@ module Mirah::JVM::Types
       log("Infering argument types for #{name}")
       by_name = target.resolve.find_callable_methods(name, true)
       by_name_and_arity = by_name.select {|m| m.argument_types.size == arg_types.size}
-      if by_name_and_arity.size == 1
-        arg_types.zip(by_name_and_arity[0].argument_types).each do |arg, super_arg|
+      filtered_args = Set.new(by_name_and_arity.map {|m| m.argument_types})
+      if filtered_args.size == 1
+        arg_types.zip(filtered_args.first).each do |arg, super_arg|
           arg.declare(cache_and_wrap(super_arg), arg.position)
         end
+      else
+        log("Found method types:")
+        filtered_args.each {|args| log("  #{args.map{|a|a.full_name}.inspect}")}
+        arg_types.each {|arg| arg.declare(ErrorType.new([["Missing declaration"]]), nil)}
       # TODO else give a more useful error?
       end
     end
+    
+    def infer_override_return_type(target, name, arg_types)
+      by_name = target.resolve.find_callable_methods(name, true)
+      by_name_and_arity = {}
+      by_name.each {|m| by_name_and_arity[m.argument_types] = m if m.argument_types.size == arg_types.size }
+      resolved_args = arg_types.map {|a| a.resolve}
+      match = by_name_and_arity[resolved_args]
+      return cache_and_wrap(match.return_type) if match
+    end
 
     def define_types(builder)
       @declarations.each do |declaration|
@@ -513,8 +575,9 @@ module Mirah::JVM::Types
       end
       orig = name
       if name.kind_of? Java::JavaClass
+        #TODO is is possible to get here anymore?
         if name.array?
-          return type(name.component_type, true)
+          return type(scope, name.component_type, true)
         else
           name = name.name
         end
@@ -573,10 +636,10 @@ module Mirah::JVM::Types
           outer_name = $1
           inner_name = $2
           outer_type = get_type(outer_name)
-          return nil if outer_type.nil?
+          return nil unless outer_type
           full_name = "#{outer_type.name}$#{inner_name}"
           mirror = get_mirror(full_name)
-          return nil if mirror.nil?
+          return nil unless mirror
         else
           return nil
         end
@@ -655,16 +718,25 @@ module Mirah::JVM::Types
       end.to_java(java.net.URL)
     end
 
+    def base_classpath
+      if __FILE__.include? '.jar'
+        Mirah::Env.encode_paths([__FILE__.split('!').first.split(':').last])
+      else
+        Mirah::Env.encode_paths(['.',
+                                 File.dirname(__FILE__) + '/../../../../javalib/mirah-builtins.jar',
+                                 File.dirname(__FILE__) + '/../../../../javalib/mirah-parser.jar',
+                                 File.dirname(__FILE__) + '/../../../../javalib/mirah-bootstrap.jar'])
+      end
+    end
+
     def classpath
-      @classpath ||= Mirah::Env.encode_paths(['.',
-                                              #TODO nh make this less hacked together.
-                                              File.dirname(__FILE__) + '/../../../../javalib/mirah-builtins.jar',
-                                              File.dirname(__FILE__) + '/../../../../javalib/mirah-parser.jar',
-                                              File.dirname(__FILE__) + '/../../../../javalib/mirah-bootstrap.jar'])
+      @classpath ||= base_classpath
     end
 
     def classpath=(classpath)
-      @classpath = classpath
+      if classpath
+        @classpath = classpath + ":" + base_classpath
+      end
       @resource_loader = nil
     end
 
@@ -695,18 +767,31 @@ module Mirah::JVM::Types
 
     attr_reader :bootclasspath
 
+    def mirror_class(klass)
+      name = klass.name.tr('.', '/')
+      if klass.respond_to?(:resource_as_stream)
+        stream = klass.resource_as_stream("/#{name}.class")
+      elsif klass.respond_to?(:get_resource_as_stream)
+        stream = klass.get_resource_as_stream("/#{name}.class")
+      else
+        return get_mirror(klass.name)
+      end
+      BiteScript::ASM::ClassMirror.load(stream)
+    end
+
     def get_mirror(name)
       @mirrors[name] ||= begin
         classname = name.tr('.', '/')
         stream = resource_loader.getResourceAsStream(classname + ".class")
         if stream
-          BiteScript::ASM::ClassMirror.load(stream)
+          mirror = BiteScript::ASM::ClassMirror.load(stream)
+          mirror if mirror.type.class_name == name
         else
           # TODO(ribrdb) Should this use a separate sourcepath?
           url = resource_loader.getResource(classname + ".java")
           if url
             file = java.io.File.new(url.toURI)
-            mirrors = JavaSourceMirror.load(file, self)
+            mirrors = JavaSourceMirror.load(file, self) rescue []
             mirrors.each do |mirror|
               @mirrors[mirror.type.class_name] = mirror
             end if mirrors