From: alxtskrnk@...
Date: 2016-10-24T17:35:05+00:00
Subject: [ruby-core:77753] [Ruby trunk Bug#12861] super in a block can be either lexically or dynamically scoped depending on how the block is invoked

Issue #12861 has been updated by bug hit.


Jeremy Evans wrote:
>
> One could argue that super is currently always relative to the current, dynamic method

Except it's not.

```ruby
class Class1
	def self.foo
		'Class1::foo'
	end
end

class Class2 < Class1
	
  def self.store_block(&block)
    @block = block
  end
  
  def self.foo
    store_block do
      super
    end
  end
  
  def self.call_stored_block
  	@block.()
  end
  
end

Class2.foo
Class2.call_stored_block # "Class1::foo"
```

When the block with super is invoked by Class2.call_stored_block, foo is not the current dynamic method, it's not even on the stack, and yet super calls foo because it is lexically bound to it.  That's the current typical behavior of super, i.e. lexical method binding. The one exception is when super is in a block/proc invoked as a method.

----------------------------------------
Bug #12861: super in a block can be either lexically or dynamically scoped depending on how the block is invoked
https://bugs.ruby-lang.org/issues/12861#change-61056

* Author: bug hit
* Status: Open
* Priority: Normal
* Assignee: 
* ruby -v: ruby 2.3.1p112 (2016-04-26 revision 54768) [x86_64-linux]
* Backport: 2.1: UNKNOWN, 2.2: UNKNOWN, 2.3: UNKNOWN
----------------------------------------
```ruby
class Class1
  def self.foo
    'foo'
  end
  def self.method1
    'method1'
  end
end

class Class2 < Class1
  def self.foo
    bar do
      super()
    end
  end
  def self.bar(&block)
    a = block.()
    define_singleton_method :method1, &block
    b = send(:method1)
    c = block.()
    [a, b, c]
  end
end

p Class2.foo # ["foo", "method1", "foo"]
```

It doesn't seem like a good idea for a given language construct to be either lexically or dynamically scoped, depending on how its surrounding block is invoked (which is not visible at the point of definition).  I think it would be better if super were always lexically scoped, and a different keyword (dynamic_super) were always dynamically scoped



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>