+ * Licensed under the Moderne Source Available License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + *
+ * https://docs.moderne.io/licensing/moderne-source-available-license + *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.staticanalysis;
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.Cursor;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.analysis.dataflow.DataFlowNode;
+import org.openrewrite.analysis.dataflow.TaintFlowSpec;
+import org.openrewrite.analysis.dataflow.analysis.FlowGraph;
+import org.openrewrite.analysis.dataflow.analysis.ForwardFlow;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaSourceFile;
+import org.openrewrite.java.tree.JavaType;
+import org.openrewrite.marker.SearchResult;
+import org.openrewrite.staticanalysis.groovy.GroovyFileChecker;
+import org.openrewrite.staticanalysis.java.JavaFileChecker;
+import org.openrewrite.staticanalysis.kotlin.KotlinFileChecker;
+import org.openrewrite.staticanalysis.table.ExceptionsWithoutCause;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class FindNewExceptionWithoutCause extends Recipe {
+
+ private static final String TAINTED_KEY = "caughtExceptionTaintedExpressions";
+ private static final String CAUGHT_KEY = "caughtExceptionVariable";
+
+ transient ExceptionsWithoutCause report = new ExceptionsWithoutCause(this);
+
+ @Override
+ public String getDisplayName() {
+ return "Find new exceptions thrown without the caught exception";
+ }
+
+ @Override
+ public String getDescription() {
+ return "Finds `catch` blocks that throw a newly created exception without referencing the caught exception, " +
+ "which discards the original exception's stack trace and message. Data flow (taint) tracking is used " +
+ "to establish whether the caught exception—or any value derived from it—reaches the thrown exception, " +
+ "so indirect references through local variables and string concatenation are not falsely reported. " +
+ "This mirrors PMD's `PreserveStackTrace` rule.";
+ }
+
+ @Override
+ public TreeVisitor getVisitor() {
+ return Preconditions.check(Preconditions.or(
+ new JavaFileChecker<>(),
+ new GroovyFileChecker<>(),
+ new KotlinFileChecker<>()
+ ), new JavaIsoVisitor
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.staticanalysis.table;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreType;
+import lombok.Value;
+import org.openrewrite.Column;
+import org.openrewrite.DataTable;
+import org.openrewrite.Recipe;
+
+@JsonIgnoreType
+public class ExceptionsWithoutCause extends DataTable
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.staticanalysis;
+
+import org.junit.jupiter.api.Test;
+import org.openrewrite.DocumentExample;
+import org.openrewrite.staticanalysis.table.ExceptionsWithoutCause;
+import org.openrewrite.test.RecipeSpec;
+import org.openrewrite.test.RewriteTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.openrewrite.java.Assertions.java;
+
+@SuppressWarnings({"ThrowablePrintStackTrace", "unused", "RedundantThrows", "CallToPrintStackTrace", "UnnecessaryLocalVariable", "CaughtExceptionImmediatelyRethrown"})
+class FindNewExceptionWithoutCauseTest implements RewriteTest {
+
+ @Override
+ public void defaults(RecipeSpec spec) {
+ spec.recipe(new FindNewExceptionWithoutCause());
+ }
+
+ @DocumentExample
+ @Test
+ void throwsNewExceptionWithoutReferencingCaught() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw new RuntimeException("Failed");
+ }
+ }
+ }
+ """,
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw /*~~>*/new RuntimeException("Failed");
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void caughtExceptionUsedForLoggingButNotChained() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw new RuntimeException("Failed");
+ }
+ }
+ }
+ """,
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw /*~~>*/new RuntimeException("Failed");
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void doNotChangeWhenCaughtExceptionPassedAsCause() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw new RuntimeException("Failed", e);
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void doNotChangeWhenCaughtMessageReferencedDirectly() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw new IllegalStateException(e.getMessage());
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void doNotChangeWhenCaughtFlowsThroughLocalVariable() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ String message = "Failed: " + e.getMessage();
+ throw new IllegalStateException(message);
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void doNotChangeWhenCaughtExceptionAliasedThenThrown() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ Throwable cause = e;
+ throw new RuntimeException("Failed", cause);
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void doNotChangeOnPlainRethrow() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() throws IOException {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw e;
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void doNotFlagThrowInsideNestedTryBody() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ try {
+ throw new RuntimeException("inner", e);
+ } catch (RuntimeException re) {
+ throw new RuntimeException(re);
+ }
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void nestedCatchIsEvaluatedAgainstItsOwnException() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ try {
+ risky();
+ } catch (IOException inner) {
+ throw new RuntimeException("dropped");
+ }
+ }
+ }
+ }
+ """,
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ try {
+ risky();
+ } catch (IOException inner) {
+ throw /*~~>*/new RuntimeException("dropped");
+ }
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void multiCatchWithoutReferenceIsFlagged() {
+ rewriteRun(
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException | RuntimeException e) {
+ throw new IllegalStateException("boom");
+ }
+ }
+ }
+ """,
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException | RuntimeException e) {
+ throw /*~~>*/new IllegalStateException("boom");
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+
+ @Test
+ void recordsDataTableRow() {
+ rewriteRun(
+ spec -> spec.dataTable(ExceptionsWithoutCause.Row.class, rows -> {
+ assertThat(rows).hasSize(1);
+ ExceptionsWithoutCause.Row row = rows.getFirst();
+ assertThat(row.getSourcePath()).isEqualTo("A.java");
+ assertThat(row.getCaughtType()).isEqualTo("java.io.IOException");
+ assertThat(row.getThrownType()).isEqualTo("java.lang.RuntimeException");
+ }),
+ //language=java
+ java(
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw new RuntimeException("Failed");
+ }
+ }
+ }
+ """,
+ """
+ import java.io.IOException;
+ class A {
+ void risky() throws IOException {}
+ void foo() {
+ try {
+ risky();
+ } catch (IOException e) {
+ throw /*~~>*/new RuntimeException("Failed");
+ }
+ }
+ }
+ """
+ )
+ );
+ }
+}