DeadStoreCheckSample.java

package checks;

import com.google.common.collect.Lists;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.function.IntConsumer;
import java.util.function.IntFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.Supplier;

class DeadStoreCheckSample {

  int var;

  class ConstructorDeadStores {
    ConstructorDeadStores(int value) {
      int x = compute(); // Noncompliant {{Remove this useless assignment to local variable "x".}}
//          ^^^^^^^^^^^
      x = 3;
      value = compute(); // Noncompliant {{Remove this useless assignment to local variable "value".}}
//          ^^^^^^^^^^^
      value = x;
      var = value;
    }
  }

  class ConstructorWithLambdaCapture {
    ConstructorWithLambdaCapture(boolean condition) {
      int captured = compute();
      if (condition) {
        System.out.println("branch");
      }
      Runnable runnable = () -> {
        int unused = compute(); // Noncompliant {{Remove this useless assignment to local variable "unused".}}
//                 ^^^^^^^^^^^
        System.out.println(captured);
      };
      runnable.run();
    }
  }

  void singleAssignment(){
    int z = 10; // Noncompliant
  }

  int foo(int u) {
    int x = 0;// Compliant - default value
    x = 3; // Noncompliant
    x = 4;
    int y = x + 1; // Noncompliant {{Remove this useless assignment to local variable "y".}}
//        ^^^^^^^
    x = 2; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//    ^^^
    x = 3;
    y = 2;
    foo(y);
    foo(x);
    Object a = new Object();
    System.out.println(a);
    a = null; // Noncompliant
//    ^^^^^^
    return 0;
  }

  void dead_store_in_condition(BufferedReader reader) throws IOException {
    String line;
    if ((line = reader.readLine()) != null) { // Noncompliant {{Remove this useless assignment to local variable "line".}}
//            ^^^^^^^^^^^^^^^^^^^
      System.out.println("Line available");
    }
  }

  void fields() {
    this.var = 2; // Compliant
    var = 3; // Compliant - do not check fields
  }

  void foo2() {
    Object a = "";
    for (int i = 0; i < 10; i++) {
      a = "";
    }
    System.out.println(a);
  }

  void lambdas_using_local_vars(IntFunction lambda) {
    int a = 42;
    lambdas_using_local_vars(y -> a + y);
  }

  void dead_store_in_lambda() {
    int captured = compute();
    Runnable r = () -> {
      int live = compute();
      int x = compute(); // Noncompliant {{Remove this useless assignment to local variable "x".}}
//          ^^^^^^^^^^^
      x = 3;
      System.out.println(x + live + captured);
    };
    r.run();
  }

  IntFunction<Integer> dead_store_in_lambda_parameter() {
    return x -> {
      x = compute(); // Noncompliant {{Remove this useless assignment to local variable "x".}}
//      ^^^^^^^^^^^
      x = 3;
      return x;
    };
  }

  IntFunction<Integer> assignment_result_used_in_block_lambda() {
    return x -> {
      int y = x = x + 1; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//              ^^^^^^^
      return y;
    };
  }

  IntFunction<Integer> dead_store_in_expression_lambda() {
    return x -> x++; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//              ^^^
  }

  IntConsumer prefix_increment_lambda = x -> ++x; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//                                           ^^^

  IntConsumer compound_assignment_lambda = x -> x += 2; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//                                                ^^^^

  IntConsumer assignment_lambda = x -> x = 2; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//                                       ^^^

  IntConsumer prefix_increment_block_lambda = x -> {
    System.out.println(++x);
    ++x; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//  ^^^
  };

  IntConsumer compound_assignment_block_lambda = x -> {
    System.out.println(x += 2);
    x += 2; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//    ^^^^
  };

  IntUnaryOperator prefix_increment_result_lambda = x -> ++x; // Noncompliant {{Remove this useless assignment to local variable "x".}}
  IntUnaryOperator compound_assignment_result_lambda = x -> x += 2; // Noncompliant {{Remove this useless assignment to local variable "x".}}
  IntUnaryOperator assignment_result_lambda = x -> x = x + 1; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//                                                   ^^^^^^^
  IntUnaryOperator assignment_result_block_lambda = x -> {
    return x = x + 1; // Noncompliant {{Remove this useless assignment to local variable "x".}}
//           ^^^^^^^
  };

  Runnable prefix_increment_field_lambda = () -> ++var;
  Runnable compound_assignment_field_lambda = () -> var += 2;
  Runnable empty_lambda = () -> {};

  Runnable dead_store_in_nested_lambda(boolean condition) {
    return () -> {
      int captured = compute();
      if (condition) {
        System.out.println("branch");
      }
      Runnable nested = () -> {
        int x = compute(); // Noncompliant {{Remove this useless assignment to local variable "x".}}
//            ^^^^^^^^^^^
        x = captured;
        System.out.println(x);
      };
      nested.run();
    };
  }

  Supplier<Runnable> expression_lambda_returning_lambda() {
    return () -> () -> {
      int x = compute(); // Noncompliant {{Remove this useless assignment to local variable "x".}}
//          ^^^^^^^^^^^
      x = 3;
      System.out.println(x);
    };
  }

  Runnable classes_in_lambda_capturing_local_variables(boolean condition) {
    return () -> {
      int capturedByAnonymousClass = compute();
      int capturedByLocalClass = compute();
      class Local {
        void print() {
          System.out.println(capturedByLocalClass);
        }
      }
      if (condition) {
        System.out.println("branch");
      }
      new Runnable() {
        @Override
        public void run() {
          System.out.println(capturedByAnonymousClass);
          new Local().print();
        }
      }.run();
    };
  }

  Runnable method_reference_in_lambda_using_local_variable(boolean condition) {
    return () -> {
      Object captured = new Object();
      if (condition) {
        System.out.println("branch");
      }
      Supplier<String> reference = captured::toString;
      System.out.println(reference.get());
    };
  }

  IntFunction<Integer> lambda_with_conditional_assignment() {
    return condition -> {
      int x = compute();
      if (condition > 0) {
        x = compute(); // Noncompliant {{Remove this useless assignment to local variable "x".}}
//        ^^^^^^^^^^^
        x = 3;
      }
      return x;
    };
  }

  Runnable lambda_using_local_variable_in_finally() {
    return () -> {
      int x = compute();
      try {
        x = compute();
      } finally {
        System.out.println(x);
      }
    };
  }

  Runnable lambda_using_local_variable_in_catch() {
    return () -> {
      int x = compute();
      try {
        x = compute();
        System.out.println(x);
      } catch (RuntimeException e) {
        System.out.println(x);
      }
    };
  }

  Runnable lambda_with_resource_used_only_by_implicit_close() {
    return () -> {
      try (FileInputStream stream = new FileInputStream("...")) {
      } catch (java.io.IOException e) {
        throw new java.io.UncheckedIOException(e);
      }
    };
  }

  Runnable dead_store_in_lambda_inside_try_finally() {
    int x = compute();
    try {
      return () -> {
        int y = compute(); // Noncompliant {{Remove this useless assignment to local variable "y".}}
//            ^^^^^^^^^^^
        y = 3;
        System.out.println(y);
      };
    } finally {
      System.out.println(x);
    }
  }

  Runnable try_finally_in_nested_lambda_should_not_exclude_enclosing_scopes() {
    int unused = compute(); // Noncompliant {{Remove this useless assignment to local variable "unused".}}
//             ^^^^^^^^^^^
    int capturedByOuterLambda = compute();
    return () -> {
      int unusedInLambda = compute(); // Noncompliant {{Remove this useless assignment to local variable "unusedInLambda".}}
//                       ^^^^^^^^^^^
      int capturedByInnerLambda = compute();
      Runnable nested = () -> {
        try {
          System.out.println("try");
        } finally {
          System.out.println(capturedByOuterLambda + capturedByInnerLambda);
        }
      };
      nested.run();
    };
  }

  private int compute() {
    return 1;
  }

  void ignore_try_finally() {
    int a;
    a = 12; //false negative excluded by try finally
    try {

    }finally {
      a = a + 1 ;
    }
  }

  void ignore_multiple_try_finally() {
    int a;
    a = 12; //false negative excluded by try finally
    try {

    }finally {
      a = a + 1 ;
    }
    try {

    }finally {
    }
  }



  public boolean try_finally_return(boolean satisfied) {
    try {
      return satisfied = true; // compliant but by exclusion of try catch - CFG of try finally should be fixed.
    } finally {
      if (!satisfied) {
      }
    }
  }

  void try_finally_in_inner_class_should_not_exclude_method() {
    int a;
    a = 12; // Noncompliant
    class inner {
      void foo() {
        try {

        }finally {

        }
      }
    }
  }
  void for_each_statement() {
    int a = 0;
    for (String elem: Lists.newArrayList(" ", "")) {
      System.out.println(a);
      a = 2;
    }
    System.out.println(a);
  }

  int read_var_in_catch() {
    int a = -1;
    int b = 2;
    try {
      a = 2;
      b = raisingExceptionMethod();
      System.out.println(a);
    }catch (Exception e) {
      System.out.println(a);
    }
    return b;
  }

  Object inner_class() {
    int a = 12;
    class B {
      int fun() {
        return a;
      }
    }
    return new B();
  }

  int increment_operator() {
    int i = 0;
    int b = 12;
    ++b; // Noncompliant
//  ^^^
    int c = 0;
    foo(++c); // Noncompliant {{Remove this useless assignment to local variable "c".}}
    int j = -1;
    while ((j = foo(++j)) != -1) { // Noncompliant {{Remove this useless assignment to local variable "j".}}
      System.out.println("");
    }
    if(i != 0) {
      return i++; // Noncompliant
    } else {
      return ++i; // Noncompliant
    }
  }

  void parenthesis_identifier_in_assignment() {
    int i = 0;
    System.out.println(i);
    (i) = 12; // Noncompliant
//      ^^^^
  }
  int parenthesis_identifier_in_postfix_increment() {
    int j = 0;
    for (int i = 0; i < 10; ++j, ++i) ;
    int b = 0;
    return (b)++; // Noncompliant
//         ^^^^^
  }
  void foo() {
    int i = 0;
    ++i; // Noncompliant
    System.out.println("");
    return;
  }

  Object variable_initialized() {
    Object foo = null; // compliant variable should be initialized
    try {
      foo = raisingExceptionMethod();
    } catch (Exception e){
    }
    return foo;
  }

  private static int raisingExceptionMethod() throws Exception { 
    return 0;
  }

  void try_with_resource(File storageFile) throws Exception {
    String path = ""; // compliant
    try (BufferedReader br = new BufferedReader(new FileReader(path))) {
      br.readLine();
    }

    try ( FileInputStream in = new FileInputStream( storageFile );
          java.nio.channels.FileLock lock = in.getChannel().lock(0, Long.MAX_VALUE, true) ) // compliant, this will be closed in the implicit finally
    {
      in.read();
    }

  }

  void try_with_resource_java9() throws Exception {
    final FileInputStream fis = new FileInputStream("..."); // compliant
    try (fis) {

    }
  }

  public static class MyClass {
    private static class Foo {
      void bar(int p){
      }
    }

    public static void main(String... args) {
      Foo x = new Foo(); // compliant
      java.util.List<Integer> list = new java.util.ArrayList<>();
      list.forEach(x::bar);
    }
    int foo() {
      int i = 0;
      int j = 0;
      i = i + 1; // Noncompliant
      j += 1; // Noncompliant
      int k = 0;
      k += 2;
      System.out.println(k);
      int n;
      n = 2;
      n += 12; // Noncompliant
      int order = 0;
      return (short) (order &= 12); // Noncompliant
    }
  }

  private void foo3(int y) {
    final int x = 1;
    switch (y) {
      case x:
        System.out.println("1");
      default:
        System.out.println("2");
    }
  }
}

class DeadStoreCheckSampleStuff {
  void foo(boolean b1, boolean b2) {
    boolean x = false;  // Compliant
    x = b1 && b2; // Noncompliant
    ((x)) = b1 && b2; // Noncompliant
  }

  void assertStatement(boolean x) {
    boolean y = !x; // compliant, y is used in assert statement.
    assert y;
  }

}

class DeadStoreCheckSampleNoIssueOnInitializers {

  // no issue if variable initializer is 'true' or 'false'
  boolean testBoolean(boolean arg0) {
    boolean b1 = true; // Compliant
    b1 = false; // Noncompliant
    b1 = arg0;

    boolean b2 = false; // Compliant
    b2 = true; // Noncompliant
    b2 = arg0;

    boolean b3 = arg0; // Noncompliant
    b3 = arg0;

    return b1 && b2 && b3;
  }

  // no issue if initializer is 'null'
  Object testNull(boolean b, Object o) {
    Object o1 = null;  // Compliant
    o1 = new Object(); // Noncompliant
    o1 = null; // Noncompliant
    o1 = o;

    Object o2 = o; // Noncompliant
    o2 = null;

    return b ? o1 : o2;
  }

  //no issue if initializer is the empty String
  String testNull(String s) {
    String s1 = ""; // Compliant
    s1 = "yolo"; // Noncompliant
    s1 = "hello";

    String s2 = "world"; // Noncompliant
    s2 = "moto";

    return s1 + s2;
  }

  // no issue if variable initializer is '-1', '0', or '1'
  int testIntLiterals() {

    int a = +42; // Noncompliant

    int b = (0);  // Compliant
    b = -1; // Noncompliant
    b = 0; // Noncompliant
    b = 1; // Noncompliant
    int c = +1;   // Compliant
    int d = (-1); // Compliant
    int e = -1;   // Compliant

    // Only int literals are excluded
    long myLong = -1L; // Noncompliant
    double myDouble = -1.0d; // Noncompliant
    float myFloat = -1.0f; // Noncompliant

    short myShort = -1; // Compliant
    byte myByte = 1; //Compliant

    return 0;
  }
}
class DeadStoreCheckSampleB {
  void foo() {
    int attemptNumber = 0;
    while (true) {
      try {
        attemptNumber++; // compliant this is handled in the catch block
        throw new MyException();
      } catch (MyException e) {
        if (attemptNumber >= 10) {
          System.exit(1);
        }
      }
    }
  }
  static class MyException extends Exception {  }
}

abstract class DeadStoreCheckSampleC {

  public void testCodeWithForLoop2() {
    RuntimeException e = null;
    for (;;) {
      try {
        e = new RuntimeException();
        break;
      } finally {
        doSomething();
      }
    }
    throw e;
  }

  public void testCodeWithForLoop3() {
    RuntimeException e = null;
    for (int i = 0; i < 2; ) {
      try {
        e = new RuntimeException();
        break;
      } finally {
        doSomething();
      }
    }
    throw e;
  }

  public void testCodeWithWhileLoop() {
    RuntimeException e = null;
    while(true) {
      try {
        e = new RuntimeException();
        break;
      } finally {
        doSomething();
      }
    }
    throw e;
  }

  abstract void doSomething();

  public class FooException extends Exception { }
}