Lint/MissingSuper false positive

[jcoyne]

There are cases where I'm explicitly avoiding calling super in an initializer, however this cop complains on all of them. This doesn't seem very useful.

[marcandre]

There's also a request to have a list of accepted superclasse exceptions, would that resolve the issue for you?

I'm curious of examples where there are good reasons to explicitly not call super.

[fatkodima]

I'm curious of examples where there are good reasons to explicitly not call super.

👍

[jcoyne]

There's also a request to have a list of accepted superclasse exceptions, would that resolve the issue for you?

Not really. I just don't think this should be a rubocop.

I'm curious of examples where there are good reasons to explicitly not call super.

One concern would be for performance (though this is not a primary concern). Another is that this makes the code harder to read as I might have to navigate to another file to see what logic is happening there (and this could be hard to find if it's in a gem). Mostly I'm concerned that this is not idiomatic for libraries like view_component (https://github.com/github/view_component#implementation) If a new coder sees super calls they may wonder why the last developer didn't use the patterns promoted by the library authors.

[marcandre]

I might have to navigate to another file to see what logic is happening there

The idea is that if there was no initialize method, say, would you actually go to another file to see what the inherited initialize does?

That said, if others feel this Cop should be disabled by default, I won't stand in the way.

[searls]

Sorbet is one counter-example where you don't want to call super necessarily, born out of @will's post on standard standardrb/standard#195

It'd be really awesome if this was configurable for which callbacks, because I think there are fewer cases where you'd intentionally skip calling super on method_missing than on initialize. Any chance of that?

[pirj]

Speaking of those two cases (notice no parent class):

        class Foo
          def method_missing(*args)
            super

        class Foo
          def self.inherited(base)
            super

Is super really necessary? Why?
@fatkodima can you please provide an example of what will break for a missing super with no parent class?

PS Also here

module M
  def self.included(base)
    super

[fatkodima]

Yes, without parent classes those are not really strictly necessary.
For the example with M module, that was fixed on master, if I remember correctly.

[marcandre]

Not necessary, but can't hurt.
I also don't think we are dealing with:

        class Foo
          extend ModDependingOnInheritedCallback
          def self.inherited(base)
            super

or

# base.rb
      class Foo < Bar
      # ...

# extension.rb
       class Foo
         def self.inherited

[amatsuda]

Here's an example of method_missing not calling super but perfectly working. https://github.com/faker-ruby/faker/blob/9ea5a3d/lib/helpers/unique_generator.rb#L17-L27

Falling back to raise instead of super seems like a possible scenario for a method_missing (but I'm not sure if we should allow this here in this cop).

[NathanZook]

I just bumped into this with some Exception classes. To me, the exception to this rule is that the ancestors of a class do not initialize ivars. Of course, a static tool is going to be hard pressed to keep up with every possible case. However, it seems to me that the vast bulk of these exceptions can be caught without too much trouble.

1. During scanning, an ancestor map is created. (This cannot be absolutely perfect, but will work generally.)
2. A list of classes and modules from ruby and the ruby core can be maintained which do not initialize ivars.
3. Any class with a high-confidence ancestor map whose ancestors either lack an initialize instance method, or which are on "the list" are good.

Because it's REALLY annoying to write:

class MyError < RuntimeError
  # rubocop:disable Lint/MissingSuper
  def initialize(var)
    @ivar = var
  end
  # rubocop:enable Lint/MissingSuper

[apainintheneck]

I've just run into the same issue when creating a dsl and using self.inherited() only once in the base class. It would be nice if that edge case was considered by this cop. Though at the end of the day it's not too hard to just write a one line exception to the rule.

def self.inherited(subclass) # rubocop:disable Lint/MissingSuper

[philliplongman]

@marcandre, how come nothing happened with this?

There's also #8376 (comment) to have a list of accepted superclasse exceptions, would that resolve the issue for you?

This would definitely solve my problem, while allowing me to keep the cop everywhere else.

[iMacTia]

I bumped into this same issue today, my use-case is also related to Sorbet and it's ability to define abstract classes.
In my case it doesn't make sense to call super in concrete implementations of the abstract class, making this cop raising false positives.

So I've taken the freedom to open a PR to make StatelessClasses configurable 😄
With this setting, I would be able to configure the cop to ignore subclasses of abstract classes 👍

[will]

Thanks @koic!