[java] Report unannotated receiver parameter

[linusjf]

Affects PMD Version:
All.

Rule:
Suggested Name:
AnnotateReceiverParameter
Non-static methods and constructors should not use "this" as a parameter unless it's annotated. New rule needed.

Description:

Example of code with violation:

import org.checkerframework.checker.nullness.qual.NonNull;

public class Foo {
    public void bar(Foo this, int x) { // violation should be reported here
        System.out.println(x);
    }
    public void bar2(@NonNull Foo this, int x) { // violation should be reported here, too
        System.out.println(x);
    }
}

A valid code sample:
(from https://www.logicbig.com/tutorials/core-java-tutorial/java-8-enhancements/explicit_receiver_parameters.html)

For example this code may be a compile time restriction for the callers if they are not calling calc
method on an instance of Calculator which has presumably been loaded from the server.

public class Calculator {
    public Result calc(@ServerObject Calculator this){ // no violation here, valid use case
       this.getSomething();
        ...
    }
 }

Best described here:

Non-static methods and constructors to non-static inner classes have first parameter "this", as I mentioned in 2002 (https://t.co/EeB0BZOjp9). Since #Java 8, we can specify this explicitly. We call it a "receiver parameter" (§8.4 of JLS13) and allows us to annotate "this". pic.twitter.com/hejhaNlV3L

— Heinz Kabutz (@heinzkabutz) September 21, 2019

package javapuzzles;

// https://twitter.com/heinzkabutz/status/1175283793592233985
@SuppressWarnings({"PMD.ShortClassName"})
public class Foo {
  private final int i;

  public Foo(int i) {
    this.i = i;
  }

  public void method(Foo this) {
    System.out.println(this.i);
  }

  public void method(Foo this, String... args) {
    System.out.println(this.i);
    for (String arg: args)
      System.out.println(arg);
  }

  public static void main(String... args) {
    Foo foo = new Foo(42);
    foo.method();
    Bar bar = new Bar(42);
    bar.method();
    bar.method("hello", "good morning", "aloha");
  }
}

@SuppressWarnings({"checkstyle:onetoplevelclass", "PMD.ShortClassName"})
class Bar extends Foo {
  Bar(int i) {
    super(i);
  }

  @Override
  public void method() {
    // empty method
  }

  @Override
  public void method(String... args) {
    // empty method
  }
}

It can become confusing.

package javapuzzles;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class NonAnonymousReceiver {

  abstract class EmptyIterator implements Iterator<String> {
    public boolean hasNext(EmptyIterator this) {
      return false;
    }

    public String next(EmptyIterator this) {
      throw new NoSuchElementException("No next element");
    }
  }

  public Iterator<String> emptyIterator2() {
    return new EmptyIterator() {};
  }
}

[oowekyala]

Your link is dead, but I found the thread. The receiver parameter is not necessarily useless, as Brian Goetz himself argues in that thread. It's only useless if it is not annotated (or just annotated NonNull or a variant).

Feel free to submit a PR

[linusjf]

Yes, I updated the documentation. The tweet content is now embedded.

[linusjf]

Added code sample to description.

[linusjf]

https://stackoverflow.com/questions/49533897/is-a-method-with-receiver-parameter-override-equivalent-to-the-same-method-decla

[linusjf]

#719

There's also a code sample in here.

[linusjf]

https://bugs.openjdk.java.net/browse/JDK-8195646

Modified code in bug to have another code sample that compiles. That also illustrates why an anonymous class' this must refer to its parent instead since there's no way of referring the anonymous class itself.

[linusjf]

http://mail.openjdk.java.net/pipermail/core-libs-dev/2019-June/060767.html

[linusjf]

https://coderanch.com/t/708483/java/understanding-implicit-parameter

This thread has a great explanation of this keyword right upto receive parameter.

[linusjf]

https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8175198

How relevant is this?

[linusjf]

https://stackoverflow.com/questions/49533897/is-a-method-with-receiver-parameter-override-equivalent-to-the-same-method-decla

[linusjf]

https://github.com/Fernal73/LearnJava/blob/master/Reflection/reflection/SyntheticSample.java

A synthetic method in an inner class displays it's signature as consisting of a call to a receiver parameter.

[adangel]

FYI - I've updated to description to have two examples: one the new rule should detect (e.g. "invalid code") and another one, that should produce no violation (e.g. "valid code")

[linusjf]

Nice. The link that accompanies the valid code example is pretty useful as well.

[linusjf]

Is this going to be in PMD 7?