Find self from the scope

lib/duby/jvm/base.rb

@@ -11,6 +11,7 @@ def initialize(filename)
         @jump_scope = []
         @bindings = Hash.new {|h, type| h[type] = type.define(@file)}
         @captured_locals = Hash.new {|h, binding| h[binding] = {}}
+        @self_scope = nil
       end
 
       def compile(ast, expression = false)
@@ -151,13 +152,25 @@ def declare_argument(name, type)
       end
 
       def body(body, expression)
+        saved_self = @self_scope
+        if body.kind_of?(Duby::AST::ScopedBody)
+          scope = body.static_scope
+          if scope != @self_scope
+            @self_scope = scope
+            if scope.self_node
+              local_assign(
+                  scope, 'self', scope.self_type, false, scope.self_node)
+            end
+          end
+        end
         # all except the last element in a body of code is treated as a statement
         i, last = 0, body.children.size - 1
         while i < last
           body.children[i].compile(self, false)
           i += 1
         end
         yield body.children[last] if last >= 0
+        @current_self = saved_self
       end
 
       def scoped_body(scope, expression)
@@ -180,6 +193,14 @@ def fixnum(type, value)
       end
       alias float fixnum
 
+      def compile_self
+        if @self_scope && @self_scope.self_node
+          local(@self_scope, 'self', @self_scope.self_type)
+        else
+          real_self
+        end
+      end
+
       def get_binding(type)
         @bindings[type]
       end

lib/duby/jvm/compiler.rb

@@ -337,8 +337,8 @@ def call(call, expression)
 
       def self_call(fcall, expression)
         return cast(fcall, expression) if fcall.cast?
-        type = @type
-        type = type.meta if @static
+        type = @self_scope ? @self_scope.self_type : @type
+        type = type.meta if (@static && type == @type)
         fcall.target = ImplicitSelf.new(type)
 
         params = fcall.parameters.map do |param|
@@ -688,7 +688,7 @@ def binding_reference
         @method.aload(@method.local('$binding'))
       end
 
-      def compile_self
+      def real_self
         method.aload(0)
       end
 

lib/duby/jvm/source_compiler.rb

@@ -194,7 +194,11 @@ def field(name, type, annotations)
       end
 
       def this
-        @static ? @class.class_name : 'this'
+        if @self_scope && @self_scope.self_node
+          scoped_local_name('self', @self_scope)
+        else
+          @static ? @class.class_name : 'this'
+        end
       end
 
       def local_assign(scope, name, type, expression, value)
@@ -659,7 +663,7 @@ def binding_reference
         @method.print '$binding'
       end
 
-      def compile_self
+      def real_self
         @method.print 'this'
       end
 

lib/duby/jvm/source_generator/precompile.rb

@@ -86,7 +86,7 @@ class FunctionalCall
     def method(compiler)
       @method ||= begin
         arg_types = parameters.map {|p| p.inferred_type}
-        compiler.self_type.get_method(name, arg_types)
+        @self_type.get_method(name, arg_types)
       end
     end
 

lib/duby/jvm/types/intrinsics.rb

@@ -59,7 +59,20 @@ def add_macro(name, *args, &block)
     def add_compiled_macro(klass, name, arg_types)
       add_macro(name, *arg_types) do |duby, call|
         expander = klass.constructors[0].newInstance(duby, call)
-        expander.expand
+        ast = expander.expand
+        if ast
+          if call.target
+            body = Duby::AST::ScopedBody.new(call.parent, call.position)
+            body.static_scope.self_type = call.target.inferred_type!
+            body.static_scope.self_node = call.target
+            body << ast
+            body
+          else
+            ast
+          end
+        else
+          Duby::AST::Noop.new(call.parent, call.position)
+        end
       end
     end