mirah 0.0.12-java → 0.1.0-java

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

@@ -14,36 +14,29 @@
 # limitations under the License.
 
 module Mirah::JVM::Types
-  Boolean = BooleanType.new('boolean', java.lang.Boolean)
-  Byte = IntegerType.new('byte', java.lang.Byte)
-  Char = IntegerType.new('char', java.lang.Character)
-  Short = IntegerType.new('short', java.lang.Short)
-  Int = IntegerType.new('int', java.lang.Integer)
-  Long = LongType.new('long', java.lang.Long)
-  Float = FloatType.new('float', java.lang.Float)
-  Double = DoubleType.new('double', java.lang.Double)
-
-  # TODO these shouldn't be constants. They should be loaded from
-  # the compilation class path.
-  Object = Type.new(BiteScript::ASM::ClassMirror.load('java.lang.Object'))
-  ClassType = Type.new(BiteScript::ASM::ClassMirror.load('java.lang.Class'))
-  String = StringType.new(
-      BiteScript::ASM::ClassMirror.load('java.lang.String'))
-  Iterable = IterableType.new(
-          BiteScript::ASM::ClassMirror.load('java.lang.Iterable'))
-
-  Void = VoidType.new
-  Unreachable = UnreachableType.new
-  Null = NullType.new
-
-  WIDENING_CONVERSIONS = {
-    Byte => [Byte, Short, Int, Long, Float, Double],
-    Short => [Short, Int, Long, Float, Double],
-    Char => [Char, Int, Long, Float, Double],
-    Int => [Int, Long, Float, Double],
-    Long => [Long, Float, Double],
-    Float => [Float, Double],
-    Double => [Double]
-  }
-  TYPE_ORDERING = [Byte, Short, Int, Long, Float, Double]
-end
+  class TypeFactory
+    def create_basic_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),
+        'short' => IntegerType.new(self, 'short', java.lang.Short),
+        'int' => IntegerType.new(self, 'int', java.lang.Integer),
+        'long' => LongType.new(self, 'long', java.lang.Long),
+        'float' => FloatType.new(self, 'float', java.lang.Float),
+        'double' => DoubleType.new(self, 'double', java.lang.Double)
+      )
+      @known_types['fixnum'] = @known_types['int']
+      @known_types['Object'] = type(nil, 'java.lang.Object')
+      @known_types['string'] = @known_types['String'] = @known_types['java.lang.String'] =
+          StringType.new(self, get_mirror('java.lang.String'))
+      type(nil, 'java.lang.Class')
+      @known_types['Iterable'] = @known_types['java.lang.Iterable'] =
+          IterableType.new(self, get_mirror('java.lang.Iterable'))
+      @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/bitescript_ext.rb

@@ -18,7 +18,7 @@ class BiteScript::MethodBuilder
     iconst_m1
     ixor
   end
-  
+
   def lnot
     # TODO would any of these be faster?
     #   iconst_m1; i2l

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

@@ -0,0 +1,15 @@
+module Mirah
+  module JVM
+    module Types
+      class BlockType < Type
+        def initialize
+          super(':block', nil)
+        end
+
+        def isBlock
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -28,16 +28,20 @@ module Mirah::JVM::Types
       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))
       add_method('!=', args, ComparisonIntrinsic.new(self, '!=', :ne, args))
     end
-    
+
     def math_type
-      Boolean
+      @type_system.type(nil, 'boolean')
     end
-    
+
     # same as NumberType's
     def compile_boolean_operator(compiler, op, negated, call, label)
       # Promote the target or the argument if necessary
@@ -62,4 +66,4 @@ module Mirah::JVM::Types
       builder.send "if_icmp#{op}", label
     end
   end
-end
+end

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

@@ -2,11 +2,10 @@ module Mirah
   module JVM
     module Types
       class DynamicType < Type
-        ObjectType = Type.new(BiteScript::ASM::ClassMirror.for_name('java.lang.Object'))
-
-        def initialize
+        def initialize(types)
           # For naming, bytecode purposes, we are an Object
-          @name = "java.lang.Object"
+          super(types, "java.lang.Object")
+          @object_type ||= types.type(nil, 'java.lang.Object')
         end
 
         def basic_type
@@ -14,17 +13,17 @@ module Mirah
         end
 
         def is_parent(other)
-          ObjectType.assignable_from?(other)
+          @object_type.assignable_from?(other)
         end
 
         def assignable_from?(other)
-          ObjectType.assignable_from?(other)
+          @object_type.assignable_from?(other)
         end
 
         def jvm_type
           java.lang.Object
         end
-        
+
         def full_name
           "dynamic"
         end
@@ -32,15 +31,15 @@ module Mirah
         def dynamic?
           true
         end
-        
+
         def superclass
-          ObjectType.superclass
+          @object_type
         end
-        
-        def interfaces
-          ObjectType.interfaces
+
+        def interfaces(include_parent=true)
+          @object_type.interfaces
         end
       end
     end
   end
-end
+end

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

@@ -20,7 +20,7 @@ module Mirah::JVM::Types
       code = intrinsics['each'][arg_types].return_type
       code.inline(transformer, call)
     end
-    
+
     def add_enumerable_macros
       all_proc = proc do |transformer, call|
         if !call.block
@@ -31,15 +31,15 @@ module Mirah::JVM::Types
           # block and attach it to the real call.
           call.block = transformer.eval("foo {|#{var}| #{var}}").block
         end
-        
+
         # Now that we've got a block we can transform it into a Loop.
         forloop = expand_each(transformer, call)
-        
+
         # Start adding stuff to the loop.
         # At the beginning of the loop we create a temp initialized to true
         all = transformer.tmp
         forloop.init << transformer.eval("#{all} = true")
-        
+
         # Now we want to wrap the body of the loop. Start off by using
         # foo as a placeholder.
         body = transformer.eval(
@@ -48,7 +48,7 @@ module Mirah::JVM::Types
         body.condition.predicate = call.block.body
         # And finally patch the new body back into the forloop.
         forloop.body = call.block.body.parent = body
-        
+
         # Loops don't have a return value, so we need somewhere to
         # put the result.
         result = Mirah::AST::Body.new(call.parent, call.position)
@@ -69,7 +69,7 @@ module Mirah::JVM::Types
             "if foo;#{any} = true;break;end", '', forloop)
         body.condition.predicate = call.block.body
         forloop.body = call.block.body.parent = body
-        
+
         result = Mirah::AST::Body.new(call.parent, call.position)
         result << forloop << transformer.eval("#{any}", '', nil, any)
       end
@@ -77,4 +77,4 @@ module Mirah::JVM::Types
       add_macro('any?', Mirah::AST.block_type, &any_proc)
     end
   end
-end
+end

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

@@ -62,22 +62,27 @@ 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 __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
@@ -98,4 +103,4 @@ module Mirah::JVM::Types
       ExtendedType.new(self).include(type)
     end
   end
-end
+end

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

@@ -16,32 +16,35 @@
 require 'jruby'
 require 'mirah/jvm/types/source_mirror'
 module Mirah::JVM::Types
-  class TypeFactory
-    BASIC_TYPES = {
-      "boolean" => Boolean,
-      "byte" => Byte,
-      "char" => Char,
-      "short" => Short,
-      "int" => Int,
-      "long" => Long,
-      "float" => Float,
-      "double" => Double,
-      "fixnum" => Int,
-      "string" => String,
-      "java.lang.String" => String,
-      "String" => String,
-      "java.lang.Object" => Object,
-      "Object" => Object,
-      "java.lang.Class" => ClassType,
-      "java.lang.Iterable" => Iterable,
-      "Iterable" => Iterable,
-      "void" => Void,
-      "notype" => Void,
-      "null" => Null,
-      "dynamic" => DynamicType.new
-    }.freeze
-    java_import 'java.net.URLClassLoader'
+  java_import 'org.mirah.typer.simple.SimpleTypes'
+  class TypeFactory < SimpleTypes
+    java_import 'org.mirah.typer.AssignableTypeFuture'
+    java_import 'org.mirah.typer.PickFirst'
+    java_import 'org.mirah.typer.BaseTypeFuture'
+    #java_import 'org.mirah.typer.BlockType'
+    java_import 'org.mirah.typer.ErrorType'
+    java_import 'org.mirah.typer.GenericTypeFuture'
+    java_import 'org.mirah.typer.MethodFuture'
+    java_import 'org.mirah.typer.MethodType'
+    java_import 'org.mirah.typer.SimpleFuture'
+    java_import 'org.mirah.typer.TypeFuture'
+    java_import 'org.mirah.typer.TypeSystem'
+    java_import 'org.mirah.typer.NarrowingTypeFuture'
+    java_import 'mirah.lang.ast.ClassDefinition'
+    java_import 'mirah.lang.ast.InterfaceDeclaration'
+    java_import 'mirah.lang.ast.Script'
+    java_import 'mirah.lang.ast.SimpleString'
+    include TypeSystem
+    include Mirah::Logging::Logged
+
+    begin
+      java_import 'org.mirah.builtins.Builtins'
+    rescue NameError
+      # We might be trying to compile mirah-builtins.jar, so just continue.
+      Builtins = nil
+    end
 
+    java_import 'java.net.URLClassLoader'
     attr_accessor :package
     attr_reader :known_types
 
@@ -53,10 +56,13 @@ module Mirah::JVM::Types
     end
 
     def initialize
+      super(":unused")
       @known_types = ParanoidHash.new
-      @known_types.update(BASIC_TYPES)
+      @anonymous_classes = Hash.new {|h, k| h[k] = 0}
       @declarations = []
       @mirrors = {}
+      @futures = {}
+      create_basic_types
     end
 
     def initialize_copy(other)
@@ -65,6 +71,465 @@ module Mirah::JVM::Types
         value.basic_type.kind_of?(Mirah::JVM::Types::TypeDefinition)
       end
       @declarations = []
+      @futures = {}
+    end
+
+    def maybe_initialize_builtins(compiler)
+      if Builtins
+        begin
+          Builtins.initialize_builtins(compiler)
+        rescue NativeException => ex
+          error("Error initializing builtins", ex.cause)
+        rescue => ex
+          error("Error initializing builtins: #{ex.message}\n\t#{ex.backtrace.join("\n\t")}")
+        end
+      else
+        warning "Unable to initialize builtins"
+      end
+    end
+
+    def wrap(resolved_type)
+      future = BaseTypeFuture.new(nil)
+      future.resolved(resolved_type) if resolved_type
+      future
+    end
+
+    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)
+        wrapper = wrap(type)
+        wrapper.resolved(ErrorType.new([["Cannot find class #{name}"]])) if type.nil?
+        wrapper
+      end
+    end
+
+    # TypeSystem methods
+    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
+    def getBaseExceptionType; cache_and_wrap_type('java.lang.Throwable') end
+    def getDefaultExceptionType; cache_and_wrap_type('java.lang.Exception') end
+    def getHashType; cache_and_wrap_type('java.util.HashMap') end
+    def getRegexType; cache_and_wrap_type('java.util.regex.Pattern') end
+    def getStringType; cache_and_wrap_type('java.lang.String') end
+    def getBooleanType; cache_and_wrap_type('boolean') end
+
+    def getFixnumType(value)
+      long = java.lang.Long.new(value)
+      if long.int_value != value
+        cache_and_wrap_type('long')
+      elsif long.short_value != value
+        cache_and_wrap_type('int')
+      elsif long.byte_value != value
+        wide = type(nil, 'int')
+        narrow = type(nil, 'short')
+        NarrowingTypeFuture.new(nil, wide, narrow)
+      else
+        wide = type(nil, 'int')
+        narrow = type(nil, 'byte')
+        NarrowingTypeFuture.new(nil, wide, narrow)
+      end
+    end
+
+    def getCharType(value) cache_and_wrap_type('char') end
+
+    def getFloatType(value)
+      d = java.lang.Double.new(value)
+      if d.float_value != value
+        cache_and_wrap_type('double')
+      else
+        wide = type(nil, 'double')
+        narrow = type(nil, 'float')
+        NarrowingTypeFuture.new(nil, wide, narrow)
+      end
+    end
+
+    def getMetaType(type)
+      if type.kind_of?(Type)
+        type.meta
+      else
+        future = BaseTypeFuture.new(nil)
+        type.on_update {|_, resolved| future.resolved(resolved.meta)}
+        future.position_set(type.position)
+        future.error_message_set(type.error_message)
+        future
+      end
+    end
+
+    def getSuperClass(future)
+      superclass = BaseTypeFuture.new(nil)
+      future.on_update do |_, type|
+        superclass.resolved(type.superclass)
+      end
+      superclass
+    end
+
+    def getArrayType(type)
+      if type.kind_of?(Type)
+        type.array_type
+      else
+        future = BaseTypeFuture.new(nil)
+        type.on_update {|_, resolved| future.resolved(resolved.array_type)}
+        future
+      end
+    end
+
+    def box(type)
+      boxed = BaseTypeFuture.new(nil)
+      type.on_update do |_, resolved|
+        if resolved.isError || !resolved.primitive?
+          boxed.resolved(resolved)
+        else
+          boxed.resolved(resolved.box_type)
+        end
+      end
+      boxed
+    end
+    
+    def getArrayLiteralType(type, position)
+      result = Mirah::JVM::Types::GenericType.new(type(nil, 'java.util.List')) # Upgrade to a generic type.
+      variable = result.type_parameters[0]
+      result.type_parameter_map[variable.name] = _build_generic_type_future(variable.bounds, position)
+      result.type_parameter_map[variable.name].assign(box(type), position)
+      wrap(result)
+    rescue => ex
+      Mirah.print_error("Error inferring generics: #{ex.message}", position)
+      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
+      for variable, type in [[generic_key, key_type], [generic_value, value_type]]
+        result.type_parameter_map[variable.name] = _build_generic_type_future(variable.bounds, position)
+        result.type_parameter_map[variable.name].assign(box(type), position)
+      end
+      wrap(result)
+    rescue => ex
+      Mirah.print_error("Error inferring generics: #{ex.message}", position)
+      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)
+      else
+        imports = scope.imports
+        name = typeref.name
+        name = imports[name] while imports.include?(name)
+        types = [ cache_and_wrap_type(name), nil ]
+        packages = []
+        packages << scope.package if scope.package && scope.package != ''
+        (packages + scope.search_packages).each do |package|
+          types << cache_and_wrap_type("#{package}.#{name}")
+          types << nil
+        end
+
+        future = PickFirst.new(types, nil)
+        future.position_set(typeref.position)
+        future.error_message_set("Cannot find class #{typeref.name}")
+        future
+      end
+      if typeref.isArray
+        getArrayType(basic_type)
+      elsif typeref.isStatic
+        getMetaType(basic_type)
+      else
+        basic_type
+      end
+    end
+
+    def getLocalType(scope, name, position)
+      scope.local_type(name, position)
+    end
+
+    def getMethodType(call)
+      target = call.resolved_target
+      argTypes = call.resolved_parameters
+      macro_types = call.parameter_nodes.map do |node|
+        get_type(node.java_class.name)
+      end if call.parameter_nodes
+      _find_method_type(call.scope, target, call.name, argTypes, macro_types, call.position)
+    rescue => ex
+      Mirah.print_error("Error getting method type #{target.name}.#{call.name}: #{ex.message}", call.position)
+      puts ex.backtrace.join("\n\t")
+      ErrorType.new([["Internal error: #{ex}", call.position]])
+    end
+
+    def _find_method_type(scope, target, name, argTypes, macroTypes, position)
+      if target.respond_to?(:isError) && target.isError
+        return target
+      end
+      type = BaseTypeFuture.new(nil)
+      target.find_method2(target, name, argTypes, macroTypes, target.meta?, scope) do |method|
+        if method.nil?
+          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
+          result = method.return_type
+
+          # Handle generics.
+          begin
+            if name == 'new' and target.type_parameters
+              result = Mirah::JVM::Types::GenericType.new(result) # Upgrade to a generic type.
+              target.type_parameters.each do |var|
+                result.type_parameter_map.put(var.name, _build_generic_type_future(var.bounds, position))
+              end
+
+              genericParameterTypes = method.member.generic_parameter_types
+              if genericParameterTypes
+                genericParameterTypes.each_index do |i|
+                  _handle_nested_generic_parameter(genericParameterTypes[i], argTypes[i], result.type_parameter_map, position)
+                end
+              end
+            elsif target.generic? && method.respond_to?(:member)
+              genericParameterTypes = method.member.generic_parameter_types
+              if genericParameterTypes
+                genericParameterTypes.each_index do |i|
+                  _handle_nested_generic_parameter(genericParameterTypes[i], argTypes[i], target.type_parameter_map, position)
+                end
+              end
+
+              result = _handle_nested_generic_return(result, method.member.generic_return_type, target.type_parameter_map, position)
+              result.resolve if result.respond_to?(:resolve)
+            end
+          rescue => ex
+            Mirah.print_error("Error inferring generics: #{ex.message}", position)
+            log("Error inferring generics: #{ex.message}\n#{ex.backtrace.join("\n")}")
+            result = method.return_type
+          end
+
+          if result.kind_of?(TypeFuture)
+            if result.isResolved
+              type.resolved(result.resolve)
+            else
+              result.onUpdate {|x, resolved| type.resolved(resolved) }
+            end
+          else
+            type.resolved(result)
+          end
+
+          # TODO(shepheb): This is modifying the argTypes of _find_method_type, and it shouldn't be.
+          # Moved to the bottom so the generics code above can access the original argTypes that were passed to _find_method_type.
+          argTypes = method.argument_types
+        end
+      end
+      argTypes = argTypes.map do |t|
+        if t.nil?
+          t
+        elsif t.isBlock
+          type.position_set(position) if (position && type.position.nil?)
+          # This should only happen if type is an error.
+          type.resolve
+        else
+          t
+        end
+      end
+      return_type = AssignableTypeFuture.new(nil)
+      return_type.assign(type, position)
+      MethodFuture.new(name, argTypes, return_type, false, position)
+    end
+
+    def _build_generic_type_future(bounds, position)
+      typeName = "java.lang.Object"
+      if bounds.size > 1
+        raise ArgumentError, "Multiple bounds on type variables are not supported."
+      elsif bounds.size == 1
+        typeName = bounds[0].raw_type.getClassName
+      end
+      GenericTypeFuture.new(position, type(nil, typeName))
+    end
+
+    def _handle_nested_generic_parameter(expectedType, providedType, type_parameter_map, position)
+      if expectedType.kind_of?(BiteScript::ASM::TypeVariable)
+        gtf = type_parameter_map.get(expectedType.name)
+        gtf.assign(SimpleFuture.new(providedType), position)
+      elsif expectedType.kind_of?(BiteScript::ASM::Wildcard) && providedType.kind_of?(TypeFuture)
+        # TODO(shepheb): Handle bounds here.
+        gtf = type_parameter_map.get(expectedType.upper_bound.name)
+        gtf.assign(providedType, position)
+      elsif expectedType.kind_of?(BiteScript::ASM::ParameterizedType)
+        # We can assume assignable_from? here, or this method would not have been called.
+        expectedParameters = expectedType.type_arguments
+        # Look up the values of the provided type's parameters.
+        providedParameters = providedType.type_parameters.map do |var|
+          if providedType.generic?
+            providedType.type_parameter_map.get(var.name)
+          else
+            type_parameter_map.get(var.name)
+          end
+        end
+
+        if expectedParameters && providedParameters && expectedParameters.size == providedParameters.size
+          expectedParameters.each_index do |i|
+            _handle_nested_generic_parameter(expectedParameters[i], providedParameters[i], type_parameter_map, position)
+          end
+        else
+          raise ArgumentError, "Type parameter mismatch: Expected #{expectedParameters}, found #{providedParameters}."
+        end
+      end
+    end
+
+    # TODO(shepheb): Handles only one level of nesting, it should handle arbitrary depth by recursion.
+    def _handle_nested_generic_return(returnType, genericReturnType, type_parameter_map, position)
+      if genericReturnType.kind_of?(BiteScript::ASM::TypeVariable)
+        type_parameter_map.get(genericReturnType.name)
+      elsif genericReturnType.kind_of?(BiteScript::ASM::ParameterizedType)
+        returnType = GenericType.new(returnType)
+        expectedTypeParameters = returnType.jvm_type.type_parameters
+        providedTypeParameters = genericReturnType.type_arguments
+        if expectedTypeParameters && providedTypeParameters && expectedTypeParameters.size == providedTypeParameters.size
+          expectedTypeParameters.each_index do |i|
+            returnType.type_parameter_map.put(expectedTypeParameters[i].name, type_parameter_map.get(providedTypeParameters[i].name))
+          end
+        else
+          raise ArgumentError, "Type parameter mismatch: Expected #{expectedTypeParameters}, found #{providedTypeParameters}"
+        end
+        returnType
+      else
+        returnType
+      end
+    end
+
+    def getMethodDefType(target, name, argTypes, returnType, position)
+      if target.nil?
+        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, position)
+      type.onUpdate do |m, resolved|
+        _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, 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
+      error("Error getting method def type #{target_name}.#{name}: #{ex.message}\n#{ex.backtrace.join("\n\t")}")
+      return_type = AssignableTypeFuture.new(nil)
+      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 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
+        future.resolved(type)
+        future
+      else
+        cache_and_wrap(type)
+      end
+    rescue => ex
+      Mirah.print_error("Error defining type #{name}: #{ex.message}", node.position)
+      puts ex.backtrace.join("\n\t")
+      ErrorType.new([["Internal error: #{ex}", node.position]])
+    end
+
+    def addMacro(klass, macro)
+      klass.unmeta.add_compiled_macro(macro)
+    end
+
+    def extendClass(classname, extensions)
+      get_type(classname).load_extensions(extensions)
+    end
+
+    def infer_override_args(target, name, arg_types)
+      # TODO What if the method we're overriding hasn't been inferred yet?
+      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}
+      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)
@@ -80,10 +545,12 @@ module Mirah::JVM::Types
         else
           name = name.getClassName
         end
+      elsif name.kind_of?(Type) && name.array?
+        array = true
       end
       type = basic_type(scope, name)
-      type = type.array_type if array
-      type = type.meta if meta
+      type = type.array_type if type && array
+      type = type.meta if type && meta
       return type
     end
 
@@ -93,8 +560,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
@@ -108,18 +576,15 @@ module Mirah::JVM::Types
     end
 
     def find_type(scope, name)
-      saved_ex = nil
-      begin
-        return get_type(name)
-      rescue NameError => ex
-        saved_ex = ex
-      end
+      type = get_type(name)
+      return type if type
 
       if scope
-        imports = scope.static_scope.imports
+        imports = scope.imports
         if imports.include?(name)
           name = imports[name] while imports.include?(name)
-          return get_type(name)
+          type = get_type(name)
+          return type if type
         end
 
         # TODO support inner class names
@@ -127,44 +592,44 @@ module Mirah::JVM::Types
           return package_search(name, scope)
         end
       end
-      raise saved_ex
+      return nil
     end
 
     def package_search(name, scope)
       packages = []
-      packages << scope.static_scope.package unless scope.static_scope.package.empty?
-      packages.concat(scope.static_scope.search_packages)
+      current_package = scope.package
+      packages << current_package unless current_package.nil? || current_package.empty?
+      packages.concat(scope.search_packages)
       packages << 'java.lang'
       packages.each do |package|
-        begin
-          return get_type("#{package}.#{name}")
-        rescue NameError
-        end
+        type =  get_type("#{package}.#{name}")
+        return type if type
       end
-      raise NameError, "Cannot find class #{name}"
+      return nil
+    end
+
+    def getBlockType
+      @block_type ||= BlockType.new
     end
 
     def get_type(full_name)
       type = @known_types[full_name]
       return type.basic_type if type
-      begin
-        mirror = get_mirror(full_name)
-      rescue NameError => ex
+      mirror = get_mirror(full_name)
+      unless mirror
         if full_name =~ /^(.+)\.([^.]+)/
           outer_name = $1
           inner_name = $2
-          begin
-            outer_type = get_type(outer_name)
-            full_name = "#{outer_type.name}$#{inner_name}"
-          rescue NameError
-            raise ex
-          end
+          outer_type = get_type(outer_name)
+          return nil if outer_type.nil?
+          full_name = "#{outer_type.name}$#{inner_name}"
           mirror = get_mirror(full_name)
+          return nil if mirror.nil?
         else
-          raise ex
+          return nil
         end
       end
-      type = Type.new(mirror).load_extensions
+      type = Type.new(self, mirror).load_extensions
       if full_name.include? '$'
         @known_types[full_name.gsub('$', '.')] = type
       end
@@ -172,83 +637,105 @@ module Mirah::JVM::Types
     end
 
     def known_type(scope, name)
-      basic_type(scope, name) rescue nil
+      basic_type(scope, name)
     end
 
     def declare_type(scope, name)
       full_name = name
-      package = scope.static_scope.package
-      if !name.include?('.') && !package.empty?
-        full_name = "#{package}.#{name}"
+      package = scope.package
+      if !name.include?('.')
+        if package && !package.empty?
+          full_name = "#{package}.#{name}"
+        else
+          scope.on_package_change do
+            full_name = "#{scope.package}.#{name}"
+            scope.import(full_name, name)
+            @known_types[full_name] = @known_types[name]
+          end
+        end
       end
       if @known_types.include? full_name
         @known_types[full_name]
       else
-        scope.static_scope.import(full_name, name)
-        @known_types[full_name] = TypeDefinition.new(full_name, nil)
+        scope.import(full_name, name)
+        @known_types[full_name] = TypeDefinition.new(self, scope, full_name, nil)
       end
     end
 
-    def define_type(node)
-      name = node.name
+    def define_type(scope, node)
+      if node.name.nil?
+        outer_node = node.find_ancestor {|n| (n != node && n.kind_of?(ClassDefinition)) || n.kind_of?(Script)}
+        if outer_node.kind_of?(ClassDefinition)
+          outer_name = outer_node.name.identifier
+        else
+          outer_name = Mirah::JVM::Compiler::JVMBytecode.classname_from_filename(node.position.source.name || 'DashE')
+        end
+        id = (@anonymous_classes[outer_name] += 1)
+        node.name_set(SimpleString.new("#{outer_name}$#{id}"))
+      end
+      name = node.name.identifier
       full_name = name
-      package = node.static_scope.package
-      if !name.include?('.') && !package.empty?
+      package = scope.package
+      if !name.include?('.') && package && !package.empty?
         full_name = "#{package}.#{name}"
       end
-      if @known_types.include? full_name
+      if @known_types.include?(full_name) && @known_types[full_name].kind_of?(TypeDefinition)
         existing = @known_types[full_name]
-        existing.node ||= node
+        unless existing.node
+          existing.node = node
+          existing.scope = scope
+        end
         existing
       else
-        if Mirah::AST::InterfaceDeclaration === node
+        if InterfaceDeclaration === node
           klass = InterfaceDefinition
         else
           klass = TypeDefinition
         end
-        node.scope.static_scope.import(full_name, name)
-        @known_types[full_name] = klass.new(full_name, node)
+        scope.import(full_name, name)
+        @known_types[full_name] = klass.new(self, scope, full_name, node)
       end
     end
 
-    def no_type
-      Void
-    end
-
-    def unreachable_type
-      Unreachable
-    end
-
     def make_urls(classpath)
       Mirah::Env.decode_paths(classpath).map do |filename|
         java.io.File.new(filename).to_uri.to_url
       end.to_java(java.net.URL)
     end
 
+    def base_classpath
+      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
+
     def classpath
-      @classpath ||= '.'
+      @classpath ||= base_classpath
     end
 
     def classpath=(classpath)
-      @classpath = classpath
+      if classpath
+        @classpath = classpath + ":" + base_classpath
+      end
       @resource_loader = nil
     end
-    
+
     def resource_loader
       @resource_loader ||= URLClassLoader.new(make_urls(classpath), bootstrap_loader)
     end
-    
+
     def bootstrap_loader
       @bootstrap_loader ||= begin
         parent = if bootclasspath
                    Mirah::Util::IsolatedResourceLoader.new(make_urls(bootclasspath))
                  end
-        bootstrap_path = if __FILE__.match /file:.*\.jar!.*/
-                           File.expand_path(__FILE__).sub(/!.*$/,'').sub('file:','')
-                         else
-                           File.expand_path("#{__FILE__}/../../../../../javalib/mirah-bootstrap.jar")
-                         end
-        bootstrap_urls = [java.io.File.new(bootstrap_path).to_uri.to_url].to_java(java.net.URL)
+        if __FILE__ =~ /^(file:.+jar)!/
+          bootstrap_urls = [java.net.URL.new($1)].to_java(java.net.URL)
+        else
+          bootstrap_jar = File.expand_path("#{__FILE__}/../../../../../javalib/mirah-bootstrap.jar")
+          bootstrap_urls = [java.io.File.new(bootstrap_jar).to_uri.to_url].to_java(java.net.URL)
+        end
         URLClassLoader.new(bootstrap_urls, parent)
       end
     end
@@ -258,15 +745,28 @@ module Mirah::JVM::Types
       @bootstrap_loader = nil
       @resource_loader = nil
     end
-    
+
     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) if 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")
@@ -277,11 +777,41 @@ module Mirah::JVM::Types
               @mirrors[mirror.type.class_name] = mirror
             end if mirrors
             @mirrors[name]
-          else
-            raise NameError, "Class '#{name}' not found."
           end
         end
       end
     end
+
+    def getAbstractMethods(type)
+      methods = []
+      unless type.isError
+        object = get_type("java.lang.Object")
+        interfaces = [type]
+        until interfaces.empty?
+          interface = interfaces.pop
+          abstract_methods = interface.declared_instance_methods.select {|m| m.abstract?}
+          methods += abstract_methods.select do |m|
+            begin
+              # Skip methods defined on Object
+              object.java_method(m.name, *m.argument_types)
+              false
+            rescue NameError
+              true
+            end
+          end
+          interfaces.concat(interface.interfaces)
+        end
+        # TODO ensure this works with hierarchies of abstract classes
+        # reject the methods implemented by the abstract class
+        if type.abstract?
+          implemented_methods = type.declared_instance_methods.reject{|m| m.abstract?}.map { |m| [m.name, m.argument_types, m.return_type] }
+          methods = methods.reject{|m| implemented_methods.include? [m.name, m.argument_types, m.return_type] }
+        end
+      end
+      methods.map do |method|
+        MethodType.new(method.name, method.argument_types, method.return_type, false)
+      end
+    end
   end
 end
+require 'mirah/jvm/types/basic_types'