AnonymousClassOnFunctionalInterfaceCheckSample.java

package checks;

class AnonymousClassOnFunctionalInterfaceCheckSample {

  enum Foo {
    FOO {
      @Override
      public String method() {
        return "foo";
      }
    },
    BAR {
      @Override
      public String method() {
        return "bar";
      }
    };

    public String method() {
      return "";
    }
  }

  interface Handler {
    String handle();
  }

  interface MyInterface {
    enum InnerEnum {
      A, B, C;
    }
  }

  void toto() {
    new MyInterface() {}; // Compliant

    new Handler(){ // Noncompliant {{Make this anonymous inner class a lambda}}
      @Override
      public String handle() {
        return "handled";
      }
    }.handle();

    new Handler(){
      private String myMethod(){
        return "plop";
      }

      @Override
      public String handle() {
        return myMethod();
      }
    }.handle();

    new Handler(){
      @Override
      public String handle() {
        return this.toString();
      }
    }.handle();

    new Handler(){ // Noncompliant {{Make this anonymous inner class a lambda}}
      @Override
      public String handle() {
        class C{
          String meth(){
            return "";
          }
          String fun(){
            return this.meth();
          }
        }
        return new C().fun();
      }
    };

    new Handler(){ // Compliant
      int myVar;

      @Override
      public String handle() {
        return "";
      }
    };

    new Handler(){ // Noncompliant {{Make this anonymous inner class a lambda}}
      @Override
      public String handle() {
        return "";
      }; // this empty statement should not be counted!
    };

    new
    Handler // Noncompliant {{Make this anonymous inner class a lambda}}
    (){
      @Override
      public String handle() {
        return AnonymousClassOnFunctionalInterfaceCheckSample.this.toString();
      }
    };

    new Handler(){ // Compliant, annotation prevents transform to a lambda
      @Override
      @SuppressWarnings("something")
      public String handle() {
        return "handled";
      }
    }.handle();

    new Handler(){ // Compliant, annotation prevents transform to a lambda
      @SuppressWarnings("something")
      @Override
      public String handle() {
        return "handled";
      }
    }.handle();
  }

  String toStr(){
    return "";
  }

  abstract static class AbstractClass {
    public abstract void foo();

    static void bar() {
      AbstractClass ac1 = new AbstractClass() { // Compliant: not a SAM
        @Override
        public void foo() {
        }
      };
    }
  }

  interface MyHandler extends Handler{}

  public abstract static class Main {

    public abstract void myMethod();

    public static void main(String[] args) {
      Main main = new Main() {
        @Override
        public void myMethod() {
        }
      };
      main.myMethod();
      Object o1 = new Object() {
        @Override
        public String toString(){
          return null;
        }
      };
      Object o12 = new MyHandler() { // Noncompliant
        @Override
        public String handle() {
          return null;
        }
      };
    }
  }
}

class SamWithExceptionS9357 {

  class MyCheckedException extends Exception {}
  interface I {
    void apply(String s) throws MyCheckedException;
  }
  void foo(I i) {
    foo(new I() { // Compliant: cannot refactor as lambda because of checked exception
      @Override
      public void apply(String s) throws MyCheckedException {
      }
    });
  }
}

abstract class WithinLambdaS9357 {

  @FunctionalInterface
  interface Action<T> {
    T run();
  }

  abstract <T> T doSomething(Action<T> action);

  private void bar(WithinLambdaS9357 a) {
    a.doSomething(
      (Action<Void>) () -> {
        new Thread(
          new Runnable() { // Noncompliant
            @Override
            public void run() {
            }
          });
        return null;
      });
  }
}

interface ABS9357 {
  default void foo() {
  }

  default void bar() {
  }

  static void main() {
    ABS9357 a = new ABS9357() { // Compliant
      @Override
      public void foo() {
      }
    };
  }
}

interface BAS9357 {
  default void foo() {
  }

  void bar();

  static void main() {
    BAS9357 a = new BAS9357() { // Noncompliant
      @Override
      public void bar() {
      }
    };
  }
}

class AlphaS9357 {

  interface Lvl1 {
    void foo();
  }

  interface Lvl2 extends Lvl1 {
    @Override
    void foo();
  }

  Lvl2 level = new Lvl2() { // Noncompliant
    @Override
    public void foo() {
    }
  };
  Lvl2 level2 = () -> {};
}

class ThisInstanceTestS9357 {

  interface WithDefault {
    default String defaultMethod() { return "defaultMethod"; }
    String funcMethod();
  }
  void testDefault() {
    WithDefault f = new WithDefault() {  // Compliant, invoke a default method
      @Override
      public String funcMethod() {
        return defaultMethod();
      }
    };
  }

  interface Math {
    int powerOfTwo(int n);
  }

  void testRecursion() {
    Math f = new Math() {  // Compliant, recursion
      @Override
      public int powerOfTwo(int n) {
        return n == 0 ? 1 : 2 * powerOfTwo(n -1);
      }
    };
  }

  int globalPowerOfTwo(int n) {
    return n == 0 ? 1 : 2 * globalPowerOfTwo(n -1);
  }

  void testNotThisInstanceMethod() {
    Math f = new Math() { // Noncompliant
      @Override
      public int powerOfTwo(int n) {
        return globalPowerOfTwo(n);
      }
    };
  }
}

abstract class GenericTypeS9357<X> {

  void foo(GenericTypeS9357<String> something) {
    bar(something, new MyComparable() { // Compliant - compare is a generic method
      @Override
      public <T extends Comparable<T>> int compare(T obj1, T obj2) {
        return 0;
      }
    });
  }

  abstract <T extends Comparable<T>> void bar(GenericTypeS9357<T> object, MyComparable comp);

  interface MyComparable {
    <T extends Comparable<T>> int compare(T obj1, T obj2);
  }
}