mirah 0.1.0.pre-java → 0.1.1-java

data/lib/mirah/jvm/types/floats.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,10 +23,6 @@ module Mirah::JVM::Types
       @type_system.type(nil, 'float')
     end
 
-    def box_type
-      @type_system.type(nil, 'java.lang.Float')
-    end
-
     def suffix
       'g'
     end
@@ -54,6 +50,8 @@ module Mirah::JVM::Types
         # Do nothing
       when 'double'
         builder.f2d
+      when wrapper_name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
       else
         raise ArgumentError, "Invalid widening conversion from float to #{type}"
       end
@@ -69,10 +67,6 @@ module Mirah::JVM::Types
       @type_system.type(nil, 'double')
     end
 
-    def box_type
-      @type_system.type(nil, 'java.lang.Double')
-    end
-
     def wide?
       true
     end
@@ -93,7 +87,11 @@ module Mirah::JVM::Types
     end
 
     def compile_widen(builder, type)
-      if type.name != 'double'
+      case type.name
+      when 'double'
+      when wrapper_name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
+      else
         raise ArgumentError, "Invalid widening conversion from double to #{type}"
       end
     end

data/lib/mirah/jvm/types/integers.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");
@@ -39,6 +39,8 @@ module Mirah::JVM::Types
         builder.i2f
       when 'double'
         builder.i2d
+      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
@@ -52,10 +54,6 @@ module Mirah::JVM::Types
       @type_system.type(nil, 'int')
     end
 
-    def box_type
-      @type_system.type(nil, 'java.lang.Integer')
-    end
-
     def jump_if(builder, op, label)
       builder.send "if_icmp#{op}", label
     end
@@ -72,6 +70,17 @@ module Mirah::JVM::Types
     end
   end
 
+  class CharacterType < IntegerType
+    def compile_widen(builder, type)
+      case type.name
+      when 'char'
+        # do nothing
+      else
+        super
+      end
+    end
+  end
+
   class LongType < Number
     def prefix
       'l'
@@ -81,10 +90,6 @@ module Mirah::JVM::Types
       @type_system.type(nil, 'long')
     end
 
-    def box_type
-      @type_system.type(nil, 'java.lang.Long')
-    end
-
     def literal(builder, value)
       builder.ldc_long(value)
     end
@@ -105,6 +110,8 @@ module Mirah::JVM::Types
         builder.l2f
       when 'double'
         builder.l2d
+      when wrapper_name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
       else
         raise ArgumentError, "Invalid widening conversion from Int to #{type}"
       end

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

@@ -48,10 +48,10 @@ module Mirah::JVM::Types
       @macros ||= Hash.new {|h, k| h[k] = {}}
     end
 
-    def add_method(name, args, method_or_type=nil, &block)
+    def add_method(name, args, method_or_type=nil, kind=nil, &block)
       if block_given?
         method_or_type = Intrinsic.new(self, name, args,
-                                       method_or_type, &block)
+                                       method_or_type, kind, &block)
       end
       intrinsics[name][args] = method_or_type
     end
@@ -76,6 +76,7 @@ module Mirah::JVM::Types
         # call.parameters.each do |arg|
         #   arg.scope = scope
         # end
+
         begin
           expander = klass.constructors[0].newInstance(typer.macro_compiler, call)
           ast = expander.expand
@@ -83,7 +84,7 @@ module Mirah::JVM::Types
         #   puts "Unable to expand macro #{name.inspect} from #{klass} with #{call}"
         end
         if ast
-          body = Mirah::AST::NodeList.new(ast.position)
+          body = Mirah::AST::NodeList.new(ast.position.to_java(Mirah::AST::Position))
           # TODO scope
           # static_scope = typer.scoper.add_scope(body)
           # static_scope.parent = typer.scoper.get_scope(call)
@@ -151,7 +152,7 @@ module Mirah::JVM::Types
     def load_extensions(klass=nil)
       mirror = nil
       if klass
-        mirror = @type_system.get_mirror(klass.name)
+        mirror = @type_system.mirror_class(klass)
       elsif jvm_type
         mirror = jvm_type
       end
@@ -162,10 +163,10 @@ module Mirah::JVM::Types
         return self if macros.nil?
         macros.each do |macro_class|
           klass = begin
-            JRuby.runtime.jruby_class_loader.loadClass(macro_class)
-          rescue java.lang.NoClassDefFoundError => ex
-            raise ex
-          end
+                    JRuby.runtime.jruby_class_loader.loadClass(macro_class)
+                  rescue java.lang.NoClassDefFoundError => ex
+                    raise ex
+                  end
           add_compiled_macro(klass)
         end
       end
@@ -193,7 +194,7 @@ module Mirah::JVM::Types
       object_type = @type_system.type(nil, 'java.lang.Object')
       class_type = @type_system.type(nil, 'java.lang.Class')
 
-      add_method('nil?', [], boolean) do |compiler, call, expression|
+      add_method('nil?', [], boolean, 'IS_NULL') do |compiler, call, expression|
         if expression
           compiler.visit(call.target, true)
           compiler.method.op_to_bool do |target|
@@ -202,7 +203,7 @@ module Mirah::JVM::Types
         end
       end
 
-      add_method('==', [object_type], boolean) do |compiler, call, expression|
+      add_method('==', [object_type], boolean, 'COMPARISON_OP') do |compiler, call, expression|
         # Should this call Object.equals for consistency with Ruby?
         if expression
           compiler.visit(call.target, true)
@@ -213,7 +214,7 @@ module Mirah::JVM::Types
         end
       end
 
-      add_method('!=', [object_type], boolean) do |compiler, call, expression|
+      add_method('!=', [object_type], boolean, 'COMPARISON_OP') do |compiler, call, expression|
         # Should this call Object.equals for consistency with Ruby?
         if expression
           compiler.visit(call.target, true)
@@ -224,7 +225,7 @@ module Mirah::JVM::Types
         end
       end
 
-      add_method('kind_of?', [object_type.meta], boolean) do |compiler, call, expression|
+      add_method('kind_of?', [object_type.meta], boolean, "INSTANCEOF") do |compiler, call, expression|
         compiler.visit(call.target, expression)
         if expression
           klass = compiler.inferred_type(call.parameters(0))
@@ -261,7 +262,7 @@ module Mirah::JVM::Types
       load_extensions(ArrayExtensions.java_class) if ArrayExtensions
       int_type = @type_system.type(nil, 'int')
       add_method(
-          '[]', [int_type], component_type) do |compiler, call, expression|
+          '[]', [int_type], component_type, "ARRAY_ACCESS") do |compiler, call, expression|
         if expression
           compiler.visit(call.target, true)
           compiler.visit(call.parameters(0), true)
@@ -271,7 +272,7 @@ module Mirah::JVM::Types
 
       add_method('[]=',
                  [int_type, component_type],
-                 component_type) do |compiler, call, expression|
+                 component_type, "ARRAY_ASSIGN") do |compiler, call, expression|
         compiler.visit(call.target, true)
         convert_args(compiler, call.parameters, [@type_system.type(nil, 'int'), component_type])
         component_type.astore(compiler.method)
@@ -280,7 +281,7 @@ module Mirah::JVM::Types
         end
       end
 
-      add_method('length', [], int_type) do |compiler, call, expression|
+      add_method('length', [], int_type, "ARRAY_LENGTH") do |compiler, call, expression|
         compiler.visit(call.target, true)
         compiler.method.arraylength
       end
@@ -289,7 +290,7 @@ module Mirah::JVM::Types
 
   class MetaType
     def add_intrinsics
-      add_method('class', [], @type_system.type(nil, 'java.lang.Class')) do |compiler, call, expression|
+      add_method('class', [], @type_system.type(nil, 'java.lang.Class'), "CLASS_LITERAL") do |compiler, call, expression|
         if expression
           compiler.method.ldc_class(unmeta)
         end
@@ -322,59 +323,6 @@ module Mirah::JVM::Types
       char_type = @type_system.type(nil, 'char')
       float_type = @type_system.type(nil, 'float')
       double_type = @type_system.type(nil, 'double')
-      add_method('+', [string_type], string_type) do |compiler, call, expression|
-        if expression
-          java_method('concat', string_type).call(compiler, call, expression)
-        end
-      end
-      add_method('+', [bool_type], string_type) do |compiler, call, expression|
-        if expression
-          compiler.visit(call.target, true)
-          compiler.visit(call.parameters(0), true)
-          compiler.method.invokestatic string_type, "valueOf", [string_type, bool_type]
-          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
-        end
-      end
-      add_method('+', [char_type], string_type) do |compiler, call, expression|
-        if expression
-          compiler.visit(call.target, true)
-          compiler.visit(call.parameters(0), true)
-          compiler.method.invokestatic string_type, "valueOf", [string_type, char_type]
-          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
-        end
-      end
-      add_method('+', [int_type], string_type) do |compiler, call, expression|
-        if expression
-          compiler.visit(call.target, true)
-          compiler.visit(call.parameters(0), true)
-          compiler.method.invokestatic string_type, "valueOf", [string_type, int_type]
-          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
-        end
-      end
-      add_method('+', [long_type], string_type) do |compiler, call, expression|
-        if expression
-          compiler.visit(call.target, true)
-          compiler.visit(call.parameters(0), true)
-          compiler.method.invokestatic string_type, "valueOf", [string_type, long_type]
-          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
-        end
-      end
-      add_method('+', [float_type], string_type) do |compiler, call, expression|
-        if expression
-          compiler.visit(call.target, true)
-          compiler.visit(call.parameters(0), true)
-          compiler.method.invokestatic string_type, "valueOf", [string_type, float_type]
-          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
-        end
-      end
-      add_method('+', [double_type], string_type) do |compiler, call, expression|
-        if expression
-          compiler.visit(call.target, true)
-          compiler.visit(call.parameters(0), true)
-          compiler.method.invokestatic string_type, "valueOf", [string_type, double_type]
-          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
-        end
-      end
       add_method('[]', [int_type], char_type) do |compiler, call, expression|
         if expression
           compiler.visit(call.target, true)

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

@@ -13,6 +13,11 @@ module Mirah
           @unmeta.basic_type
         end
 
+        def name
+          return @unmeta.name if @unmeta
+          super
+        end
+
         def meta?
           true
         end

data/lib/mirah/jvm/types/methods.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");
@@ -25,20 +25,48 @@ class Java::JavaMethod
   end
 end
 
+class BiteScript::ASM::FieldMirror
+  def returnType
+    self.type
+  end
+end
+
 module Mirah::JVM::Types
   AST ||= Mirah::AST
 
   module ArgumentConversion
     def convert_args(compiler, values, types=nil)
       # TODO boxing/unboxing
-      # TODO varargs
       types ||= argument_types
-      values.zip(types).each do |value, type|
+      needs_to_build_varargs_array = false
+      
+      if respond_to?(:varargs?) && varargs?
+        non_varargs_types = types[0..-2]
+        non_varargs_values = values.first non_varargs_types.size
+
+        varargs_values = values.to_a.last(values.size - non_varargs_values.size)
+        varargs_type = types.last
+
+        unless varargs_values.length == 1 &&
+          varargs_type.compatible?(compiler.inferred_type(varargs_values.first))
+          needs_to_build_varargs_array = true
+          values = non_varargs_values
+        end
+      end
+
+      values_and_types = values.zip(types)
+      
+      values_and_types.each do |value, type|
         compiler.visit(value, true)
-        if type.primitive? && type != compiler.inferred_type(value)
-            compiler.inferred_type(value).compile_widen(compiler.method, type)
+        in_type = compiler.inferred_type(value)
+        if in_type.primitive? && type != in_type
+          in_type.compile_widen(compiler.method, type)
         end
       end
+
+      if needs_to_build_varargs_array
+        compiler.visitVarargsArray(varargs_type, varargs_values)
+      end
     end
   end
 
@@ -48,13 +76,23 @@ module Mirah::JVM::Types
     include ArgumentConversion
     attr_reader :name, :argument_types, :return_type
 
-    def initialize(klass, name, args, type, &block)
+    def initialize(klass, name, args, type, kind=nil, &block)
       raise ArgumentError, "Block required" unless block_given?
       @class = klass
       @name = name
       @argument_types = args
       @return_type = type
       @block = block
+      @kind = kind
+    end
+
+    def kind
+      Java::OrgMirahJvmTypes::MemberKind.const_get(@kind)
+    end
+    
+    def accept(visitor, expression)
+      name = "visit_#{@kind.downcase}".sub(/_op$/,"")
+      visitor.send(name, self, expression)
     end
 
     def call(builder, ast, expression, *args)
@@ -80,10 +118,19 @@ module Mirah::JVM::Types
     def exceptions
       []
     end
+
+    def varargs?
+      false
+    end
+    
+    def isVararg
+      varargs?
+    end
   end
 
   class Macro
     java_import 'org.mirah.typer.InlineCode'
+    java_import 'org.mirah.typer.NodeBuilder'
     attr_reader :name, :argument_types, :return_type
 
     def initialize(klass, name, args, &block)
@@ -92,7 +139,7 @@ module Mirah::JVM::Types
       @name = name
       @argument_types = args
       raise ArgumentError unless args.all?
-      @return_type = InlineCode.new(&block)
+      @return_type = InlineCode.new(block.to_java(NodeBuilder))
     end
 
     def declaring_class
@@ -102,13 +149,11 @@ module Mirah::JVM::Types
 
   class JavaCallable
     include ArgumentConversion
-    java_import 'org.mirah.typer.ResolvedType'
-    java_import 'org.mirah.typer.TypeSystem'
 
     attr_accessor :member
 
     def initialize(types, member)
-      raise ArgumentError unless types.kind_of?(TypeSystem)
+      raise ArgumentError unless types.kind_of?(Mirah::Typer::TypeSystem)
       @types = types
       @member = member
     end
@@ -124,6 +169,10 @@ module Mirah::JVM::Types
     def parameter_types
       @member.parameter_types
     end
+    
+    def synthetic?
+      @member.synthetic?
+    end
   end
 
   class JavaConstructor < JavaCallable
@@ -143,7 +192,7 @@ module Mirah::JVM::Types
 
     def exceptions
       @member.exception_types.map do |exception|
-        if exception.kind_of?(ResolvedType)
+        if exception.kind_of?(Mirah::Typer::ResolvedType)
           exception
         else
           @types.type(nil, exception.class_name)
@@ -176,6 +225,22 @@ module Mirah::JVM::Types
     def constructor?
       true
     end
+
+    def varargs?
+      @member.varargs?
+    end
+
+    def isVararg
+      varargs?
+    end
+
+    def accept(visitor, expression)
+      visitor.visitConstructor(self, expression)
+    end
+    
+    def kind
+      Java::OrgMirahJvmTypes::MemberKind::CONSTRUCTOR
+    end
   end
 
   class JavaMethod < JavaConstructor
@@ -214,6 +279,22 @@ module Mirah::JVM::Types
       false
     end
 
+    def accept(visitor, expression)
+      if self.static?
+        visitor.visitStaticMethodCall(self, expression)
+      else
+        visitor.visitMethodCall(self, expression)
+      end
+    end
+    
+    def kind
+      if self.static?
+        Java::OrgMirahJvmTypes::MemberKind::STATIC_METHOD
+      else
+        Java::OrgMirahJvmTypes::MemberKind::METHOD
+      end
+    end
+
     def call(compiler, ast, expression, parameters=nil)
       target = compiler.inferred_type(ast.target)
       compiler.visit(ast.target, true)
@@ -296,50 +377,13 @@ module Mirah::JVM::Types
       compiler.method.aconst_null if expression && void?
       return_type.pop(compiler.method) unless expression || void?
     end
-  end
-
-  class JavaDynamicMethod < JavaMethod
-    def initialize(type_system, name, *argument_types)
-      super(type_system, nil)
-      @name = name
-      @argument_types = argument_types
-    end
-
-    def return_type
-      @types.type(nil, 'dynamic')
-    end
-
-    def declaring_class
-      java.lang.Object
-    end
 
-    def argument_types
-      @argument_types
+    def accept(visitor, expression)
+      visitor.visitStaticMethodCall(self, expression)
     end
-
-    def call(compiler, ast, expression, parameters=nil)
-      target = compiler.inferred_type(ast.target)
-      compiler.visit(ast.target, true)
-
-      parameters ||= ast.parameters
-      parameters.each do |param|
-        compiler.visit(param, true)
-      end
-      handle = compiler.method.mh_invokestatic(
-        org.dynalang.dynalink.DefaultBootstrapper,
-        "bootstrap",
-        java.lang.invoke.CallSite,
-        java.lang.invoke.MethodHandles::Lookup,
-        java.lang.String,
-        java.lang.invoke.MethodType)
-      compiler.method.invokedynamic(
-        "dyn:callPropWithThis:#{name}",
-        [return_type, target, *@argument_types],
-        handle)
-
-      unless expression
-        return_type.pop(compiler.method)
-      end
+    
+    def kind
+      Java::OrgMirahJvmTypes::MemberKind::STATIC_METHOD
     end
   end
 
@@ -380,6 +424,22 @@ module Mirah::JVM::Types
         end
       end
     end
+
+    def accept(visitor, expression)
+      if self.static?
+        visitor.visitStaticFieldAccess(self, expression)
+      else
+        visitor.visitFieldAccess(self, expression)
+      end
+    end
+    
+    def kind
+      if self.static?
+        Java::OrgMirahJvmTypes::MemberKind::STATIC_FIELD_ACCESS
+      else
+        Java::OrgMirahJvmTypes::MemberKind::FIELD_ACCESS
+      end
+    end
   end
 
   class JavaFieldSetter < JavaFieldAccessor
@@ -408,6 +468,22 @@ module Mirah::JVM::Types
         compiler.method.putfield(target, name, @member.type)
       end
     end
+
+    def accept(visitor, expression)
+      if self.static?
+        visitor.visitStaticFieldAssign(self, expression)
+      else
+        visitor.visitFieldAssign(self, expression)
+      end
+    end
+    
+    def kind
+      if self.static?
+        Java::OrgMirahJvmTypes::MemberKind::STATIC_FIELD_ASSIGN
+      else
+        Java::OrgMirahJvmTypes::MemberKind::FIELD_ASSIGN
+      end
+    end
   end
 
   class MirahMember
@@ -433,9 +509,19 @@ module Mirah::JVM::Types
     def abstract?
       @declaring_class.interface?
     end
+
+    def varargs?
+      false
+    end
+    
+    def isVararg
+      varargs?
+    end
   end
 
   class Type
+    java_import "org.mirah.jvm.types.JVMMethod" rescue nil
+
     def method_listeners
       if meta?
         unmeta.method_listeners
@@ -465,7 +551,7 @@ module Mirah::JVM::Types
       else
         listeners[block] = block
       end
-      if !self.meta? && jvm_type && superclass && !superclass.isError
+      if !self.meta? && jvm_type && super_class_valid?
         superclass.add_method_listener(name, self)
       end
       interfaces.each {|i| i.add_method_listener(name, self) unless i.isError}
@@ -473,27 +559,17 @@ module Mirah::JVM::Types
 
     # TODO take a scope and check visibility
     def find_callable_macros(name)
-      interfaces = []
-      macros = find_callable_macros2(name, interfaces)
-      seen = {}
-      until interfaces.empty?
-        interface = interfaces.pop
-        next if seen[interface] || interface.isError
-        seen[interface] = true
-        interfaces.concat(interface.interfaces)
-        macros.concat(interface.declared_macros(name))
-      end
+      macros = find_callable_macros2 name
+      macros.concat collect_up_interface_tree {|interface| interface.declared_macros(name) }
       macros
     end
 
-    def find_callable_macros2(name, interfaces)
-      macros = []
-      interfaces.concat(self.interfaces)
-      macros.concat(declared_macros(name))
-      if superclass && !superclass.error?
-        macros.concat(superclass.find_callable_macros2(name, interfaces))
-      end
-      macros
+    def find_callable_macros2(name)
+      collect_up_inheritance_tree {|type| type.declared_macros name }
+    end
+
+    def find_callable_static_methods(name)
+      collect_up_inheritance_tree { |type| type.declared_class_methods(name) }
     end
 
     # TODO take a scope and check visibility
@@ -503,33 +579,17 @@ module Mirah::JVM::Types
         proc.call(find_callable_methods(name))
         return
       end
-      interfaces = if self.interface? || include_interfaces # TODO || self.abstract?
-        []
-      else
-        nil
-      end
-      methods = find_callable_methods2(name, interfaces)
-      if interfaces
-        seen = {}
-        until interfaces.empty?
-          interface = interfaces.pop
-          next if seen[interface]
-          seen[interface] = true
-          interfaces.concat(interface.interfaces)
-          methods.concat(interface.declared_instance_methods(name))
-        end
+
+      methods = find_callable_methods2 name
+
+      if self.interface? || include_interfaces # TODO || self.abstract?
+        methods.concat collect_up_interface_tree { |interface| interface.declared_instance_methods(name) }
       end
       methods
     end
 
-    def find_callable_methods2(name, interfaces)
-      methods = []
-      interfaces.concat(self.interfaces) if interfaces
-      methods.concat(declared_instance_methods(name))
-      if superclass && !superclass.error?
-        methods.concat(superclass.find_callable_methods2(name, interfaces))
-      end
-      methods
+    def find_callable_methods2(name)
+      collect_up_inheritance_tree { |type| type.declared_instance_methods(name) }
     end
 
     def get_method(name, args)
@@ -547,8 +607,7 @@ module Mirah::JVM::Types
 
     def constructor(*types)
       begin
-        descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
-        constructor = jvm_type.getConstructor(*descriptors)
+        constructor = jvm_type.getConstructor(*bitescript_signatures(types))
         return JavaConstructor.new(@type_system, constructor) if constructor
       rescue => ex
         log("#{ex.message}\n#{ex.backtrace.join("\n")}")
@@ -559,13 +618,9 @@ module Mirah::JVM::Types
     def java_method(name, *types)
       intrinsic = intrinsics[name][types]
       return intrinsic if intrinsic
-      jvm_types = types.map {|type| type.jvm_type}
-
-      return JavaDynamicMethod.new(@type_system, name, *jvm_types) if dynamic?
 
       begin
-        descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
-        method = jvm_type.getDeclaredMethod(name, *descriptors) if jvm_type
+        method = jvm_type.getDeclaredMethod(name, *bitescript_signatures(types)) if jvm_type
 
         if method.nil? && superclass
           method = superclass.java_method(name, *types) rescue nil
@@ -580,8 +635,7 @@ module Mirah::JVM::Types
 
         return method if method.kind_of?(JavaCallable)
         if method && method.static? == meta?
-          return JavaStaticMethod.new(@type_system, method) if method.static?
-          return JavaMethod.new(@type_system, method)
+          return wrap_jvm_method method
         end
       rescue   => ex
         log("#{ex.message}\n#{ex.backtrace.join("\n")}")
@@ -590,23 +644,13 @@ module Mirah::JVM::Types
     end
 
     def declared_instance_methods(name=nil)
-      methods = []
-      if jvm_type && !array?
-        jvm_type.getDeclaredMethods(name).each do |method|
-          methods << JavaMethod.new(@type_system, method) unless method.static?
-        end
-      end
-      methods.concat((meta? ? unmeta : self).declared_intrinsics(name))
+      all_declared_jvm_methods(name).reject{ |method| method.static? && !method.synthetic? } +
+      (meta? ? unmeta : self).declared_intrinsics(name)
     end
 
     def declared_class_methods(name=nil)
-      methods = []
-      if jvm_type && !unmeta.array?
-        jvm_type.getDeclaredMethods(name).each do |method|
-          methods << JavaStaticMethod.new(@type_system, method) if method.static?
-        end
-      end
-      methods.concat(meta.declared_intrinsics(name))
+      all_declared_jvm_methods(name).select{ |method| method.static? && !method.synthetic? } +
+      meta.declared_intrinsics(name)
     end
 
     def declared_constructors
@@ -616,38 +660,130 @@ module Mirah::JVM::Types
     end
 
     def field_getter(name)
-      if jvm_type
-        field = jvm_type.getField(name)
-        JavaFieldGetter.new(@type_system, field) if field
-      else
-        nil
-      end
+      field = jvm_field(name)
+      return nil unless field
+
+      JavaFieldGetter.new(@type_system, field)
     end
 
     def field_setter(name)
-      if jvm_type
-        field = jvm_type.getField(name)
-        JavaFieldSetter.new(@type_system, field) if field
-      else
-        nil
-      end
+      field = jvm_field(name)
+      return nil unless field
+
+      JavaFieldSetter.new(@type_system, field)
     end
 
     def inner_class_getter(name)
       full_name = "#{self.name}$#{name}"
-      inner_class = nil  # @type_system.type(nil, full_name) rescue nil
+      inner_class = @type_system.type(nil, full_name) rescue nil
       return unless inner_class
+
       inner_class.inner_class = true
-      add_macro(name) do |transformer, call|
-        Mirah::AST::Constant.new(call.parent, call.position, full_name)
+      macro = Macro.new(self, name, []) do |call, typer|
+        Mirah::AST::Constant.new(call.position, Mirah::AST::SimpleString.new(call.position, full_name))
       end
-      intrinsics[name][[]]
+      intrinsics[name][[]] = macro
+    end
+    
+    def getDeclaredFields
+      @member.getDeclaredFields.to_java(JVMMethod)
+    end
+    
+    def getDeclaredField(name)
+      @member.getDeclaredField(name)
+    end
+    
+    def hasStaticField(name)
+      f = getDeclaredField(name)
+      f && f.static?
+    end
+
+    protected
+
+    def find_interfaces
+      collect_up_inheritance_tree {|type| type.interfaces }
+    end
+
+    def collect_up_interface_tree &block
+      interfaces = find_interfaces
+      things = []
+      seen = {}
+      until interfaces.empty?
+        interface = interfaces.pop
+        next if seen[interface]
+        next if interface.isError
+        seen[interface] = true
+        interfaces.concat(interface.interfaces)
+        new_things = block.call interface
+        things.concat new_things if new_things
+      end
+      things
+    end
+
+    def collect_up_inheritance_tree(&block)
+      things = []
+      new_things = block.call(self)
+      things.concat new_things if new_things
+      if super_class_valid?
+        things.concat superclass.collect_up_inheritance_tree(&block)
+      end
+      things
+    end
+
+    private
+
+    def super_class_valid?
+      superclass && !superclass.error?
+    end
+
+    def all_declared_jvm_methods(name=nil)
+      return [] if !jvm_type || (meta? ? unmeta : self).array?
+
+      jvm_type.getDeclaredMethods(name).map { |method| wrap_jvm_method method }
+    end
+
+    def wrap_jvm_method method
+      if (method.static? && !method.synthetic?)
+        JavaStaticMethod.new(@type_system, method)
+      else
+        JavaMethod.new(@type_system, method)
+      end
+    end
+
+    def jvm_field(name)
+      return nil unless jvm_type
+      field = jvm_type.getField(name)
+      field ||= begin
+                  ifaces = jvm_type.interfaces.map { |i| wrap_with_mirror i }
+                  ifaces.map{|i| i.getField(name) }.compact.first
+                end
+      field ||= begin
+                  mirror = wrap_with_mirror jvm_type.superclass
+                  potential, mirror = [mirror.getField(name), wrap_with_mirror(mirror.superclass)] until potential || mirror.nil?
+                  potential
+                end
+      field
+    end
+
+    def wrap_with_mirror type
+      return unless type
+      if type.respond_to?(:getField)
+        type
+      else
+        BiteScript::ASM::ClassMirror.for_name type.class_name
+      end
+    end
+
+    def bitescript_signatures types
+      types.map {|type| BiteScript::Signature.class_id(type)}
     end
   end
 
   class TypeDefinition
+    java_import "org.mirah.jvm.types.JVMMethod" rescue nil
+
     def java_method(name, *types)
-      method = instance_methods[name].find {|m| m.argument_types == types}
+      method = first_matching instance_methods[name], types
       return method if method
       intrinsic = intrinsics[name][types]
       return intrinsic if intrinsic
@@ -655,7 +791,7 @@ module Mirah::JVM::Types
     end
 
     def java_static_method(name, *types)
-      method = static_methods[name].find {|m| m.argument_types == types}
+      method = first_matching static_methods[name], types
       return method if method
       intrinsic = meta.intrinsics[name][types]
       return intrinsic if intrinsic
@@ -663,29 +799,17 @@ module Mirah::JVM::Types
     end
 
     def constructor(*types)
-      constructor = constructors.find {|c| c.argument_types == types}
+      constructor = first_matching constructors, types
       return constructor if constructor
       raise NameError, "No constructor #{name}(#{types.join ', '})"
     end
 
     def declared_instance_methods(name=nil)
-      declared_intrinsics(name) + if name.nil?
-        instance_methods.values.flatten
-      else
-        instance_methods[name]
-      end
+      declared_methods self, instance_methods, name
     end
 
     def declared_class_methods(name=nil)
-      meta.declared_intrinsics(name) + if name.nil?
-        static_methods.values.flatten
-      else
-        static_methods[name]
-      end
-    end
-
-    def declared_constructors
-      constructors
+      declared_methods meta, static_methods, name
     end
 
     def constructors
@@ -696,6 +820,7 @@ module Mirah::JVM::Types
       end
       @constructors
     end
+    alias :declared_constructors :constructors
 
     def instance_methods
       @instance_methods ||= Hash.new {|h, k| h[k] = []}
@@ -704,6 +829,31 @@ module Mirah::JVM::Types
     def static_methods
       @static_methods ||= Hash.new {|h, k| h[k] = []}
     end
+    
+    def getDeclaredFields
+      @fields.values.to_java(JVMMethod)
+    end
+    
+    def getDeclaredField(name)
+      @fields[name]
+    end
+    
+    def hasStaticField(name)
+      f = getDeclaredField(name)
+      f && f.static?
+    end
+    
+    def declared_fields
+      @fields ||= {}
+    end
+
+    def declare_field(name, type, static)
+      if type.isError
+        declared_fields.delete(name)
+        return
+      end
+      declared_fields[name] ||= MirahMember.new(self, name, [], type, static, [])
+    end
 
     def declare_method(name, arguments, type, exceptions)
       raise "Bad args" unless arguments.all?
@@ -750,6 +900,22 @@ module Mirah::JVM::Types
     def field_setter(name)
       nil
     end
+
+    private
+
+    def declared_methods target, method_hash, name
+      # should the declared intrinsics be first here? nh
+      target.declared_intrinsics(name) +
+        if name.nil?
+          method_hash.values.flatten
+        else
+          method_hash[name]
+        end
+    end
+
+    def first_matching method_list, types
+      method_list.find {|m| m.argument_types == types}
+    end
   end
 
   class TypeDefMeta