Add Optional-nullable-wrapping-unwrapping.ql

Author: Marcono1234

codeql-custom-queries-java/queries/api-misuse/Optional-nullable-wrapping-unwrapping.ql

@@ -0,0 +1,32 @@
+/**
+ * Finds code which wraps a nullable value in an `Optional` and then directly unwraps it again.
+ * Such code can be simplified using for example the methods `requireNonNull`, `requireNonNullElse` or
+ * `requireNonNullElseGet` of the class `java.util.Objects`, which avoids having to temporarily wrap
+ * the value in an `Optional`.
+ *
+ * For example:
+ * ```java
+ * Optional.ofNullable(value).orElse("default-value")
+ * // Could be written as
+ * Objects.requireNonNullElse(value, "default-value")
+ * ```
+ *
+ * @kind problem
+ * @id todo
+ */
+
+import java
+import lib.Optionals
+
+from Call wrappingCall, MethodAccess unwrappingCall
+where
+  wrappingCall.getCallee() instanceof NewNullableOptionalCallable and
+  unwrappingCall.getQualifier() = wrappingCall and
+  // Only consider this when it is directly unwrapped again; ignore for example if `filter(...)` or similar
+  // is called first, since rewriting it might make it more verbose
+  (
+    unwrappingCall.getMethod() instanceof OptionalGetValueMethod or
+    unwrappingCall.getMethod() instanceof OptionalOrMethod
+  )
+select unwrappingCall,
+  "Use `Objects.requireNonNullElse` or similar instead of wrapping as `Optional`"

codeql-custom-queries-java/queries/lib/Optionals.qll

@@ -91,6 +91,15 @@ abstract class OptionalPresenceCheckMethod extends Method {
 abstract class OptionalGetValueMethod extends Method {
 }
 
+/**
+ * Instance method which uses an alternative value in case the optional is empty.
+ * 
+ * Does not include methods which throw an exception if the optional is empty
+ * (e.g. `orElseThrow`).
+ */
+abstract class OptionalOrMethod extends Method {
+}
+
 /**
  * JDK class representing an optional value. This includes the `Object` reference
  * storing `java.util.Optional` as well as the primitive value variants, such as
@@ -143,9 +152,20 @@ class JavaObjectOptionalOfNullableMethod extends NewNullableOptionalCallable, Me
 class JavaObjectOptionalGetMethod extends OptionalGetValueMethod {
     JavaObjectOptionalGetMethod() {
         getDeclaringSourceOrASupertype(this) instanceof JavaObjectOptional
-        and hasStringSignature([
-            "get()",
-            "orElseThrow()" // Equivalent to get()
+        and (
+            hasStringSignature("get()")
+            or hasName("orElseThrow") // Equivalent to get()
+        )
+    }
+}
+
+class JavaObjectOptionalOrMethod extends OptionalOrMethod {
+    JavaObjectOptionalOrMethod() {
+        getDeclaringSourceOrASupertype(this) instanceof JavaObjectOptional
+        and hasName([
+            "or", // TODO: Maybe exclude this because it takes a `Supplier<Optional>` and returns an `Optional`
+            "orElse",
+            "orElseGet",
         ])
     }
 }
@@ -196,11 +216,23 @@ class JavaOptionalPresenceCheckMethod extends OptionalPresenceCheckMethod {
 class JavaPrimitiveOptionalGetMethod extends OptionalGetValueMethod {
     JavaPrimitiveOptionalGetMethod() {
         getDeclaringType() instanceof JavaPrimitiveOptional
-        and hasStringSignature([
-            "orElseThrow()", // Exists for all Optional types and is equivalent to their specific methods
-            "getAsDouble()", // OptionalDouble
-            "getAsInt()", // OptionalInt
-            "getAsLong()" // OptionalLong
+        and (
+            hasStringSignature([
+                "getAsDouble()", // OptionalDouble
+                "getAsInt()", // OptionalInt
+                "getAsLong()", // OptionalLong
+            ])
+            or hasName("orElseThrow") // Exists for all Optional types and is equivalent to their specific `get...` methods
+        )
+    }
+}
+
+class JavaPrimitiveOptionalOrMethod extends OptionalOrMethod {
+    JavaPrimitiveOptionalOrMethod() {
+        getDeclaringType() instanceof JavaPrimitiveOptional
+        and hasName([
+            "orElse",
+            "orElseGet",
         ])
     }
 }
@@ -244,6 +276,23 @@ class GuavaOptionalIsPresentMethod extends OptionalPresenceCheckMethod {
     boolean polarity() { result = true }
 }
 
+class GuavaOptionalGetMethod extends OptionalGetValueMethod {
+    GuavaOptionalGetMethod() {
+        getDeclaringSourceOrASupertype(this) instanceof GuavaOptional
+        and hasStringSignature("get()")
+    }
+}
+
+class GuavaOptionalOrMethod extends OptionalOrMethod {
+    GuavaOptionalOrMethod() {
+        getDeclaringSourceOrASupertype(this) instanceof GuavaOptional
+        and hasName([
+            "or", // TODO: Maybe exclude overload `or(Optional)`, which returns an `Optional`?
+            "orNull",
+        ])
+    }
+}
+
 class GuavaOptionalOrNullCall extends OptionalObjectOrNullCall {
     GuavaOptionalOrNullCall() {
         exists(Method m | m = getMethod() |