Enforce PMD UnnecessaryLocalBeforeReturn rule

mrigger · mrigger · commit dcc55c56bfb5 · 2020-05-28T23:02:56.000+02:00
diff --git a/pmd-rules.xml b/pmd-rules.xml
@@ -55,7 +55,6 @@
 		<exclude name="ConfusingTernary" />
 		<exclude name="FieldDeclarationsShouldBeAtStartOfClass" />
 		<exclude name="PrematureDeclaration" />
-		<exclude name="UnnecessaryLocalBeforeReturn" />
 		<exclude name="BooleanGetMethodName" />
 	</rule>
 	<!-- <rule ref="category/java/design.xml"> <priority>4</priority> </rule> 
diff --git a/src/sqlancer/LikeImplementationHelper.java b/src/sqlancer/LikeImplementationHelper.java
@@ -48,8 +48,7 @@ public static boolean match(String str, String regex, int regexPosition, int str
 
     private static char toUpper(char cur) {
         if (cur >= 'a' && cur <= 'z') {
-            char c = (char) (cur + 'A' - 'a');
-            return c;
+            return (char) (cur + 'A' - 'a');
         } else {
             return cur;
         }
diff --git a/src/sqlancer/Main.java b/src/sqlancer/Main.java
@@ -200,8 +200,7 @@ private String getStackTrace(Throwable e1) {
             StringWriter sw = new StringWriter();
             PrintWriter pw = new PrintWriter(sw);
             e1.printStackTrace(pw);
-            String stackTrace = "--" + sw.toString().replace("\n", "\n--");
-            return stackTrace;
+            return "--" + sw.toString().replace("\n", "\n--");
         }
 
         private void printState(FileWriter writer, StateToReproduce state) {
diff --git a/src/sqlancer/Randomly.java b/src/sqlancer/Randomly.java
@@ -187,8 +187,7 @@ public static <T> List<T> extractNrRandomColumns(List<T> columns, int nr) {
 
     public static int smallNumber() {
         // no need to cache for small numbers
-        int val = (int) (Math.abs(ThreadLocalRandom.current().nextGaussian()) * 2);
-        return val;
+        return (int) (Math.abs(ThreadLocalRandom.current().nextGaussian()) * 2);
     }
 
     public static boolean getBoolean() {
diff --git a/src/sqlancer/cockroachdb/ast/CockroachDBFunction.java b/src/sqlancer/cockroachdb/ast/CockroachDBFunction.java
@@ -177,8 +177,7 @@ public CockroachDBFunctionCall getCall(CockroachDBCompositeDataType returnType,
             int depth) {
         CockroachDBDataType[] argumentTypes2 = getArgumentTypes(returnType);
         List<CockroachDBExpression> arguments = getArgumentsForReturnType(gen, depth, argumentTypes2, returnType);
-        CockroachDBFunctionCall call = new CockroachDBFunctionCall(this, arguments);
-        return call;
+        return new CockroachDBFunctionCall(this, arguments);
     }
 
     List<CockroachDBExpression> getArgumentsForReturnType(CockroachDBExpressionGenerator gen, int depth,
diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBCreateStatisticsGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBCreateStatisticsGenerator.java
@@ -24,13 +24,12 @@ public static Query create(CockroachDBGlobalState globalState) {
         sb.append(" FROM ");
         sb.append(randomTable.getName());
 
-        Query q = new QueryAdapter(sb.toString(),
+        return new QueryAdapter(sb.toString(),
                 Arrays.asList("current transaction is aborted, commands ignored until end of transaction block",
                         "ERROR: unable to encode table key: *tree.DArray" /*
                                                                            * https://github.com/cockroachdb/cockroach/
                                                                            * issues/46964
                                                                            */, "overflow during Encode"));
-        return q;
     }
 
 }
diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBExpressionGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBExpressionGenerator.java
@@ -282,8 +282,7 @@ public CockroachDBExpression generateConstant(CockroachDBCompositeDataType type)
             return CockroachDBConstant.createBooleanConstant(Randomly.getBoolean());
         case STRING:
         case BYTES: // TODO: also generate byte constants
-            CockroachDBExpression strConst = getStringConstant();
-            return strConst;
+            return getStringConstant();
         case FLOAT:
             return CockroachDBConstant.createFloatConstant(globalState.getRandomly().getDouble());
         case BIT:
diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBSetClusterSettingGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBSetClusterSettingGenerator.java
@@ -59,8 +59,7 @@ public static Query create(CockroachDBGlobalState globalState) {
         errors.add("setting updated but timed out waiting to read new value");
 
         CockroachDBErrors.addTransactionErrors(errors);
-        Query q = new QueryAdapter(sb.toString(), errors);
-        return q;
+        return new QueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBSetSessionGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBSetSessionGenerator.java
@@ -55,8 +55,7 @@ public static Query create(CockroachDBGlobalState globalState) {
         sb.append(s.f.apply(globalState));
         Set<String> errors = new HashSet<>();
         CockroachDBErrors.addTransactionErrors(errors);
-        Query q = new QueryAdapter(sb.toString(), errors);
-        return q;
+        return new QueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/cockroachdb/gen/CockroachDBTruncateGenerator.java b/src/sqlancer/cockroachdb/gen/CockroachDBTruncateGenerator.java
@@ -41,8 +41,7 @@ public static Query truncate(CockroachDBGlobalState globalState) {
             sb.append(" ");
             sb.append(Randomly.fromOptions("CASCADE", "RESTRICT"));
         }
-        Query q = new QueryAdapter(sb.toString(), errors);
-        return q;
+        return new QueryAdapter(sb.toString(), errors);
     }
 
 }
diff --git a/src/sqlancer/duckdb/DuckDBProvider.java b/src/sqlancer/duckdb/DuckDBProvider.java
@@ -168,9 +168,8 @@ public Connection createDatabase(GlobalState<?> globalState) throws SQLException
             e.printStackTrace();
         }
         String url = "jdbc:duckdb:";
-        Connection con = DriverManager.getConnection(url, globalState.getOptions().getUserName(),
+        return DriverManager.getConnection(url, globalState.getOptions().getUserName(),
                 globalState.getOptions().getPassword());
-        return con;
     }
 
     @Override
diff --git a/src/sqlancer/duckdb/DuckDBSchema.java b/src/sqlancer/duckdb/DuckDBSchema.java
@@ -23,8 +23,7 @@ public enum DuckDBDataType {
         INT, VARCHAR, BOOLEAN, FLOAT, DATE, TIMESTAMP;
 
         public static DuckDBDataType getRandom() {
-            DuckDBDataType type = Randomly.fromOptions(values());
-            return type;
+            return Randomly.fromOptions(values());
         }
 
     }
diff --git a/src/sqlancer/duckdb/ast/DuckDBJoin.java b/src/sqlancer/duckdb/ast/DuckDBJoin.java
@@ -101,14 +101,12 @@ public static List<Node<DuckDBExpression>> getJoins(
 
     public static DuckDBJoin createRightOuterJoin(TableReferenceNode<DuckDBExpression, DuckDBTable> left,
             TableReferenceNode<DuckDBExpression, DuckDBTable> right, Node<DuckDBExpression> predicate) {
-        DuckDBJoin duckDBJoin = new DuckDBJoin(left, right, JoinType.RIGHT, predicate);
-        return duckDBJoin;
+        return new DuckDBJoin(left, right, JoinType.RIGHT, predicate);
     }
 
     public static DuckDBJoin createLeftOuterJoin(TableReferenceNode<DuckDBExpression, DuckDBTable> left,
             TableReferenceNode<DuckDBExpression, DuckDBTable> right, Node<DuckDBExpression> predicate) {
-        DuckDBJoin duckDBJoin = new DuckDBJoin(left, right, JoinType.LEFT, predicate);
-        return duckDBJoin;
+        return new DuckDBJoin(left, right, JoinType.LEFT, predicate);
     }
 
     public static DuckDBJoin createInnerJoin(TableReferenceNode<DuckDBExpression, DuckDBTable> left,
diff --git a/src/sqlancer/duckdb/gen/DuckDBExpressionGenerator.java b/src/sqlancer/duckdb/gen/DuckDBExpressionGenerator.java
@@ -47,9 +47,7 @@ protected Node<DuckDBExpression> generateExpression(int depth) {
         if (allowAggregates && Randomly.getBoolean()) {
             DuckDBAggregateFunction aggregate = DuckDBAggregateFunction.getRandom();
             allowAggregates = false;
-            NewFunctionNode<DuckDBExpression, DuckDBAggregateFunction> aggr = new NewFunctionNode<>(
-                    generateExpressions(depth + 1, aggregate.getNrArgs()), aggregate);
-            return aggr;
+            return new NewFunctionNode<>(generateExpressions(depth + 1, aggregate.getNrArgs()), aggregate);
         }
         List<Expression> possibleOptions = new ArrayList<>(Arrays.asList(Expression.values()));
         if (!globalState.getDmbsSpecificOptions().testCollate) {
diff --git a/src/sqlancer/duckdb/test/DuckDBQueryPartitioningHavingTester.java b/src/sqlancer/duckdb/test/DuckDBQueryPartitioningHavingTester.java
@@ -56,8 +56,7 @@ Node<DuckDBExpression> generatePredicate() {
 
     @Override
     List<Node<DuckDBExpression>> generateFetchColumns() {
-        List<Node<DuckDBExpression>> columns = Arrays.asList(gen.generateHavingClause());
-        return columns;
+        return Arrays.asList(gen.generateHavingClause());
     }
 
 }
diff --git a/src/sqlancer/mysql/test/MySQLPivotedQuerySynthesisTester.java b/src/sqlancer/mysql/test/MySQLPivotedQuerySynthesisTester.java
@@ -144,8 +144,7 @@ public String getQueryThatContainsAtLeastOneRow() throws SQLException {
 
         MySQLToStringVisitor visitor = new MySQLToStringVisitor();
         visitor.visit(selectStatement);
-        String queryString = visitor.get();
-        return queryString;
+        return visitor.get();
     }
 
     private List<MySQLExpression> generateGroupByClause(List<MySQLColumn> columns, MySQLRowValue rw) {
diff --git a/src/sqlancer/postgres/gen/PostgresExpressionGenerator.java b/src/sqlancer/postgres/gen/PostgresExpressionGenerator.java
@@ -134,8 +134,7 @@ private PostgresExpression generateFunctionWithKnownResult(int depth, PostgresDa
                 args[i] = generateExpression(depth + 1, argTypes[i]);
             }
         } while (!randomFunction.checkArguments(args));
-        PostgresFunction f = new PostgresFunction(randomFunction, type, args);
-        return f;
+        return new PostgresFunction(randomFunction, type, args);
     }
 
     private PostgresExpression generateBooleanExpression(int depth) {
diff --git a/src/sqlancer/postgres/gen/PostgresTransactionGenerator.java b/src/sqlancer/postgres/gen/PostgresTransactionGenerator.java
@@ -24,13 +24,7 @@ public static Query executeBegin() {
             // sb.append(Randomly.fromOptions("READ WRITE", "READ ONLY"));
             // }
         }
-        QueryAdapter query = new QueryAdapter(sb.toString(), errors) {
-            @Override
-            public boolean couldAffectSchema() {
-                return true;
-            }
-        };
-        return query;
+        return new QueryAdapter(sb.toString(), errors, true);
     }
 
 }
diff --git a/src/sqlancer/postgres/test/PostgresPivotedQuerySynthesisGenerator.java b/src/sqlancer/postgres/test/PostgresPivotedQuerySynthesisGenerator.java
@@ -117,8 +117,7 @@ public String getQueryThatContainsAtLeastOneRow(PostgresStateToReproduce state)
 
         PostgresToStringVisitor visitor = new PostgresToStringVisitor();
         visitor.visit(selectStatement);
-        String queryString = visitor.get();
-        return queryString;
+        return visitor.get();
     }
 
     private List<PostgresExpression> generateGroupByClause(List<PostgresColumn> columns, PostgresRowValue rw) {
@@ -149,8 +148,7 @@ private PostgresExpression generateOffset() {
 
     private PostgresExpression generateWhereClauseThatContainsRowValue(List<PostgresColumn> columns,
             PostgresRowValue rw) {
-        PostgresExpression expression = PostgresExpressionGenerator.generateTrueCondition(columns, rw, globalState);
-        return expression;
+        return PostgresExpressionGenerator.generateTrueCondition(columns, rw, globalState);
     }
 
     private boolean isContainedIn(String queryString, MainOptions options, StateLogger logger) throws SQLException {
diff --git a/src/sqlancer/sqlite3/ast/SQLite3Constant.java b/src/sqlancer/sqlite3/ast/SQLite3Constant.java
@@ -302,8 +302,7 @@ public static String toLower(String t) {
                     text.setCharAt(i, Character.toLowerCase(c));
                 }
             }
-            String string = text.toString();
-            return string;
+            return text.toString();
         }
 
         public static String toUpper(String t) {
@@ -314,8 +313,7 @@ public static String toUpper(String t) {
                     text.setCharAt(i, Character.toUpperCase(c));
                 }
             }
-            String string = text.toString();
-            return string;
+            return text.toString();
         }
 
         public static String trim(String str) {
@@ -354,8 +352,7 @@ public SQLite3Constant applyNumericAffinity() {
             }
             Matcher matcher = leadingDigitPattern.matcher(trimmedString);
             if (matcher.matches()) {
-                SQLite3Constant castValue = SQLite3Cast.castToNumeric(this);
-                return castValue;
+                return SQLite3Cast.castToNumeric(this);
             } else {
                 return this;
             }
diff --git a/src/sqlancer/sqlite3/gen/SQLite3ExpressionGenerator.java b/src/sqlancer/sqlite3/gen/SQLite3ExpressionGenerator.java
@@ -369,8 +369,7 @@ private SQLite3Expression getMatchClause(int depth) {
 
     private SQLite3Expression getRandomColumn() {
         SQLite3Column c = Randomly.fromList(columns);
-        SQLite3ColumnName columnName = new SQLite3ColumnName(c, rw == null ? null : rw.getValues().get(c));
-        return columnName;
+        return new SQLite3ColumnName(c, rw == null ? null : rw.getValues().get(c));
     }
 
     enum Attribute {
@@ -580,8 +579,7 @@ private SQLite3Expression getComputableFunction(int depth) {
                 args[i] = new SQLite3Distinct(args[i]);
             }
         }
-        SQLite3Function sqlFunction = new SQLite3Function(func, args);
-        return sqlFunction;
+        return new SQLite3Function(func, args);
     }
 
     private SQLite3Expression getBetweenOperator(int depth) {
diff --git a/src/sqlancer/sqlite3/gen/SQLite3PragmaGenerator.java b/src/sqlancer/sqlite3/gen/SQLite3PragmaGenerator.java
@@ -94,8 +94,7 @@ public QueryAdapter insert(SQLite3GlobalState globalState) {
                 if (Randomly.getBoolean()) {
                     return 0;
                 } else {
-                    long value = Math.max(10000, Randomly.getNonCachedInteger());
-                    return value;
+                    return Math.max(10000, Randomly.getNonCachedInteger());
                 }
 
             });
diff --git a/src/sqlancer/sqlite3/queries/SQLite3PivotedQuerySynthesizer.java b/src/sqlancer/sqlite3/queries/SQLite3PivotedQuerySynthesizer.java
@@ -309,9 +309,8 @@ private List<SQLite3Expression> generateGroupByClause(List<SQLite3Column> column
 
     private SQLite3Expression generateWhereClauseThatContainsRowValue(List<SQLite3Column> columns, SQLite3RowValue rw) {
 
-        SQLite3Expression whereClause = generateNewExpression(columns, rw);
+        return generateNewExpression(columns, rw);
 
-        return whereClause;
     }
 
     private SQLite3Expression generateNewExpression(List<SQLite3Column> columns, SQLite3RowValue rw) {

Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,7 @@ public static boolean match(String str, String regex, int regexPosition, int str`
`48`	`48`
`49`	`49`	`private static char toUpper(char cur) {`
`50`	`50`	`if (cur >= 'a' && cur <= 'z') {`
`51`		`- char c = (char) (cur + 'A' - 'a');`
`52`		`- return c;`
	`51`	`+ return (char) (cur + 'A' - 'a');`
`53`	`52`	`} else {`
`54`	`53`	`return cur;`
`55`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -200,8 +200,7 @@ private String getStackTrace(Throwable e1) {`
`200`	`200`	`StringWriter sw = new StringWriter();`
`201`	`201`	`PrintWriter pw = new PrintWriter(sw);`
`202`	`202`	`e1.printStackTrace(pw);`
`203`		`- String stackTrace = "--" + sw.toString().replace("\n", "\n--");`
`204`		`- return stackTrace;`
	`203`	`+ return "--" + sw.toString().replace("\n", "\n--");`
`205`	`204`	`}`
`206`	`205`
`207`	`206`	`private void printState(FileWriter writer, StateToReproduce state) {`
Original file line number	Diff line number	Diff line change
`@@ -187,8 +187,7 @@ public static <T> List<T> extractNrRandomColumns(List<T> columns, int nr) {`
`187`	`187`
`188`	`188`	`public static int smallNumber() {`
`189`	`189`	`// no need to cache for small numbers`
`190`		`- int val = (int) (Math.abs(ThreadLocalRandom.current().nextGaussian()) * 2);`
`191`		`- return val;`
	`190`	`+ return (int) (Math.abs(ThreadLocalRandom.current().nextGaussian()) * 2);`
`192`	`191`	`}`
`193`	`192`
`194`	`193`	`public static boolean getBoolean() {`
Original file line number	Diff line number	Diff line change
`@@ -177,8 +177,7 @@ public CockroachDBFunctionCall getCall(CockroachDBCompositeDataType returnType,`
`177`	`177`	`int depth) {`
`178`	`178`	`CockroachDBDataType[] argumentTypes2 = getArgumentTypes(returnType);`
`179`	`179`	`List<CockroachDBExpression> arguments = getArgumentsForReturnType(gen, depth, argumentTypes2, returnType);`
`180`		`- CockroachDBFunctionCall call = new CockroachDBFunctionCall(this, arguments);`
`181`		`- return call;`
	`180`	`+ return new CockroachDBFunctionCall(this, arguments);`
`182`	`181`	`}`
`183`	`182`
`184`	`183`	`List<CockroachDBExpression> getArgumentsForReturnType(CockroachDBExpressionGenerator gen, int depth,`
Original file line number	Diff line number	Diff line change
`@@ -24,13 +24,12 @@ public static Query create(CockroachDBGlobalState globalState) {`
`24`	`24`	`sb.append(" FROM ");`
`25`	`25`	`sb.append(randomTable.getName());`
`26`	`26`
`27`		`- Query q = new QueryAdapter(sb.toString(),`
	`27`	`+ return new QueryAdapter(sb.toString(),`
`28`	`28`	`Arrays.asList("current transaction is aborted, commands ignored until end of transaction block",`
`29`	`29`	`"ERROR: unable to encode table key: tree.DArray" /`
`30`	`30`	`* https://github.com/cockroachdb/cockroach/`
`31`	`31`	`* issues/46964`
`32`	`32`	`*/, "overflow during Encode"));`
`33`		`- return q;`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,7 @@ public static Query create(CockroachDBGlobalState globalState) {`
`59`	`59`	`errors.add("setting updated but timed out waiting to read new value");`
`60`	`60`
`61`	`61`	`CockroachDBErrors.addTransactionErrors(errors);`
`62`		`- Query q = new QueryAdapter(sb.toString(), errors);`
`63`		`- return q;`
	`62`	`+ return new QueryAdapter(sb.toString(), errors);`
`64`	`63`	`}`
`65`	`64`
`66`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,8 +55,7 @@ public static Query create(CockroachDBGlobalState globalState) {`
`55`	`55`	`sb.append(s.f.apply(globalState));`
`56`	`56`	`Set<String> errors = new HashSet<>();`
`57`	`57`	`CockroachDBErrors.addTransactionErrors(errors);`
`58`		`- Query q = new QueryAdapter(sb.toString(), errors);`
`59`		`- return q;`
	`58`	`+ return new QueryAdapter(sb.toString(), errors);`
`60`	`59`	`}`
`61`	`60`
`62`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,7 @@ public static Query truncate(CockroachDBGlobalState globalState) {`
`41`	`41`	`sb.append(" ");`
`42`	`42`	`sb.append(Randomly.fromOptions("CASCADE", "RESTRICT"));`
`43`	`43`	`}`
`44`		`- Query q = new QueryAdapter(sb.toString(), errors);`
`45`		`- return q;`
	`44`	`+ return new QueryAdapter(sb.toString(), errors);`
`46`	`45`	`}`
`47`	`46`
`48`	`47`	`}`