Improve error handling

.github/dependabot.yml

@@ -6,7 +6,7 @@
 
 version: 2
 updates:
- - package-ecosystem: "devcontainers"
-   directory: "/"
-   schedule:
-     interval: weekly
+  - package-ecosystem: "devcontainers"
+    directory: "/"
+    schedule:
+      interval: weekly

.github/workflows/maven.yml

@@ -29,7 +29,9 @@ jobs:
         distribution: 'temurin'
         cache: maven
     - name: Test with Maven
-      run: mvn -B test
+      run: mvn -B -ntp test
+    - name: Check coverage
+      run: mvn -B -ntp verify
 
     # Optional: Uploads the full dependency graph to GitHub to improve the quality of Dependabot alerts this repository can receive
     - name: Update dependency graph

pom.xml

@@ -28,15 +28,59 @@
         </dependency>
     </dependencies>
     <build>
-         <plugins>
-			<plugin>
+        <plugins>
+            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.2.5</version>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.2.5</version>
                 <configuration>
                     <failIfNoTests>true</failIfNoTests>
                 </configuration>
-			</plugin>
-		</plugins>
-	</build>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.12</version>
+                <executions>
+                    <execution>
+                        <id>default-prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-report</id>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-check</id>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <rule>
+                                    <element>SOURCEFILE</element>
+                                    <includes>
+                                        <include>net/marcellperger/mathexpr/util/rs/Result.java</include>
+                                        <include>net/marcellperger/mathexpr/util/rs/Option.java</include>
+                                    </includes>
+                                    <limits>
+                                        <limit>
+                                            <counter>INSTRUCTION</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <!-- We have 100% coverage, let's not loose it -->
+                                            <minimum>100%</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
 </project>

src/main/java/net/marcellperger/mathexpr/parser/Parser.java

@@ -12,6 +12,7 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.function.Function;
+import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -39,38 +40,23 @@ public MathSymbol parseExpr() throws ExprParseException {
 
     // https://regex101.com/r/2EogTA/1
     protected static final Pattern DOUBLE_RE = Pattern.compile("^([+-]?)(\\d*\\.\\d+|\\d+\\.?)(?:[eE]([+-]?\\d+))?");
-    public @NotNull MathSymbol parseDoubleLiteral_exc() throws ExprParseException {
-        return switch (parseDoubleLiteral_null()) {
-            case null -> throw new ExprParseException("Couldn't parse double in expression");
-            case MathSymbol sym -> sym;
-        };
-    }
-    public @Nullable MathSymbol parseDoubleLiteral_null() {
+    public @NotNull MathSymbol parseDoubleLiteral() throws ExprParseException {
         discardWhitespace();
-        Matcher m = DOUBLE_RE.matcher(strFromHere());
-        if (!m.lookingAt()) return null;
-        String s = m.group();
-        idx += s.length();
-        double value;
+        String s = matchNextRegexString(DOUBLE_RE, "Invalid number (double)");
         try {
-            value = Double.parseDouble(s);
-        } catch (NumberFormatException _exc) {
-            // Technically this should never happen - assuming I've got that regex right
-            assert false: "There is a problem with the regex, this should've been rejected earlier";
-            return null;
+            return new BasicDoubleSymbol(Double.parseDouble(s));
+        } catch (NumberFormatException exc) {
+            throw new AssertionError("There is a problem with the regex," +
+                " this should've been rejected earlier", exc);
         }
-        return new BasicDoubleSymbol(value);
     }
 
-    public @Nullable MathSymbol parseParensOrLiteral() throws ExprParseException {
+    public @NotNull MathSymbol parseParensOrLiteral() throws ExprParseException {
         discardWhitespace();
-        if(peek() == '(') return parseParens();
-        // TODO add a better error handling system - don't want to maintain 2 versions of each function
-        //  returning null: +easier to do unions, +no need for verbose try/catch, -no info about errors
-        return parseDoubleLiteral_null();
+        return peek() == '(' ? parseParens() : parseDoubleLiteral();
     }
 
-    public @Nullable MathSymbol parseParens() throws ExprParseException {
+    public MathSymbol parseParens() throws ExprParseException {
         advanceExpectNext_ignoreWs('(');
         MathSymbol sym = parseExpr();
         advanceExpectNext_ignoreWs(')');
@@ -152,8 +138,7 @@ boolean advanceIf(@NotNull Function<Character, Boolean> predicate) {
      * @param predicate Keep advancing while this returns true
      * @return Amount of spaces advanced
      */
-    @SuppressWarnings("UnusedReturnValue")
-    int advanceWhile(@NotNull Function<Character, Boolean> predicate) {
+    protected int advanceWhile(@NotNull Function<Character, Boolean> predicate) {
         int n = 0;
         while (notEof() && advanceIf(predicate)) ++n;
         return n;
@@ -167,19 +152,45 @@ protected void discardWhitespace() {
         advanceWhile(Character::isWhitespace);
     }
 
-    protected void advanceExpectNext(char expected) {
+    protected void advanceExpectNext(char expected) throws ExprParseException {
         char actual = advance();
-        if(actual != expected) throw new ExprParseRtException("Expected '%c', got '%c'".formatted(expected, actual));
+        if(actual != expected) throw new ExprParseException("Expected '%c', got '%c'".formatted(expected, actual));
     }
-    protected void advanceExpectNext_ignoreWs(char expected) {
+    protected void advanceExpectNext_ignoreWs(char expected) throws ExprParseException {
         discardWhitespace();
         advanceExpectNext(expected);
     }
 
+    protected MatchResult matchNextRegexResult(@NotNull Pattern pat, ExprParseException exc) throws ExprParseException {
+        Matcher m = pat.matcher(strFromHere());
+        if (!m.lookingAt()) throw exc;
+        String s = m.group();
+        idx += s.length();
+        return m.toMatchResult();
+    }
+    protected MatchResult matchNextRegexResult(@NotNull Pattern pat, String exc) throws ExprParseException {
+        return matchNextRegexResult(pat, new ExprParseException(exc));
+    }
+    protected MatchResult matchNextRegexResult(@NotNull Pattern pat) throws ExprParseException {
+        return matchNextRegexResult(pat, "Regex should've been matched");
+    }
+    @SuppressWarnings("unused")
+    protected String matchNextRegexString(@NotNull Pattern pat, ExprParseException exc) throws ExprParseException {
+        return matchNextRegexResult(pat, exc).group();
+    }
+    @SuppressWarnings("SameParameterValue")
+    protected String matchNextRegexString(@NotNull Pattern pat, String msg) throws ExprParseException {
+        return matchNextRegexResult(pat, msg).group();
+    }
+    @SuppressWarnings("unused")
+    protected String matchNextRegexString(@NotNull Pattern pat) throws ExprParseException {
+        return matchNextRegexResult(pat).group();
+    }
+
     protected boolean matchesNext(@NotNull String expected) {
         return src.startsWith(expected, /*start*/idx);
     }
-    
+
     private @NotNull List<@NotNull String> sortedByLength(@NotNull List<@NotNull String> arr) {
         return arr.stream().sorted(Comparator.comparingInt(String::length).reversed()).toList();
     }

src/main/java/net/marcellperger/mathexpr/util/JacocoIgnoreNotGenerated.java

@@ -0,0 +1,4 @@
+package net.marcellperger.mathexpr.util;
+
+public @interface JacocoIgnoreNotGenerated {
+}

src/main/java/net/marcellperger/mathexpr/util/ThrowingSupplier.java

@@ -0,0 +1,6 @@
+package net.marcellperger.mathexpr.util;
+
+@FunctionalInterface
+public interface ThrowingSupplier<T, E extends Throwable> {
+    T get() throws E;
+}

src/main/java/net/marcellperger/mathexpr/util/Util.java

@@ -7,8 +7,11 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
 
 @SuppressWarnings("unused")
 public class Util {
@@ -56,13 +59,11 @@ protected Util() {}
         return obj;
     }
 
-    @SuppressWarnings("UnusedReturnValue")
     @Contract("_ -> param1")
     public static <C extends Collection<?>> @NotNull C requireNonEmpty(@NotNull C collection) {
         if(collection.isEmpty()) throw new CollectionSizeException("Argument must not be empty");
         return collection;
     }
-    @SuppressWarnings("UnusedReturnValue")
     @Contract("null -> fail; _ -> param1")
     public static <C extends Collection<?>> @NotNull C requireNonEmptyNonNull(C collection) {
         return requireNonEmpty(Objects.requireNonNull(collection));
@@ -72,7 +73,6 @@ protected Util() {}
         if(collection.isEmpty()) throw new CollectionSizeException(msg);
         return collection;
     }
-    @SuppressWarnings("UnusedReturnValue")
     @Contract("null, _ -> fail; _, _ -> param1")
     public static <C extends Collection<?>> @NotNull C requireNonEmptyNonNull(C collection, String msg) {
         return requireNonEmpty(Objects.requireNonNull(collection), msg);
@@ -194,4 +194,91 @@ public static<T> T getOnlyItem(@Flow(sourceIsContainer = true) @NotNull Sequence
     public static <K, V> @NotNull V getNotNull(@NotNull Map<K, V> map, K key) {
         return Objects.requireNonNull(map.get(key));
     }
+
+    @Contract(value = "_ -> new", pure = true)
+    public static <T> @NotNull Iterator<T> singleItemIterator(T value) {
+        return new SingleItemIterator<>(value);
+    }
+
+    protected static class SingleItemIterator<T> implements Iterator<T> {
+        T value;
+        boolean isAtEnd;
+
+        public SingleItemIterator(T value) {
+            this.value = value;
+            isAtEnd = false;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return !isAtEnd;
+        }
+
+        @Override
+        public T next() {
+            if(isAtEnd) throw new NoSuchElementException("End of SingleItemIterator reached");
+            return _moveToEndAndPop();
+        }
+
+        protected T _moveToEndAndPop() {
+            isAtEnd = true;
+            T val = value;
+            // Don't hold on to our copy - we don't need it anymore
+            //  as iterators cannot go backwards and this lets JVM free it earlier.
+            value = null;
+            return val;
+        }
+
+        @Override
+        public void forEachRemaining(Consumer<? super T> action) {
+            if(isAtEnd) return;
+            action.accept(_moveToEndAndPop());
+        }
+    }
+
+    @Contract(pure = true)
+    public static <T> @NotNull Function<? super T, VoidVal> consumerToFunction(Consumer<? super T> consumer) {
+        return v -> {
+            consumer.accept(v);
+            return VoidVal.val();
+        };
+    }
+    @Contract(pure = true)
+    public static <T> @NotNull UnaryOperator<T> consumerToIdentityFunc(Consumer<? super T> consumer) {
+        return v -> {
+            consumer.accept(v);
+            return v;
+        };
+    }
+
+    public static @NotNull Supplier<VoidVal> runnableToSupplier(Runnable runnable) {
+        return () -> {
+            runnable.run();
+            return VoidVal.val();
+        };
+    }
+
+    // These 2 trick Java into throwing checked exceptions in an unchecked way
+    @Contract("_ -> fail")
+    public static <T> T throwAsUnchecked(Throwable exc) {
+        throwAs(exc);  // <RuntimeException> is inferred from no `throws` clause
+        // Java doesn't know that this always throws so this lets us
+        // do `return/throw throwAsUnchecked()` to make Java's flow control analyser happy
+        throw new AssertionError("Unreachable");
+    }
+    @SuppressWarnings("unchecked")
+    @Contract("_ -> fail")
+    public static <E extends Throwable> void throwAs(Throwable exc) throws E {
+        // We do a little type erasure hack to trick Java:
+        //  - E will be type-erased to Throwable so this will become
+        //       throw (Throwable)exc;
+        //     but exc is already Throwable due to the param type so
+        //     this is like a runtime no-op.
+        //  - But javac will see that we're throwing an E which is allowed!
+        //  - The reason we need a separate method is so that there is a
+        //     generic for javac to type-erase (otherwise JVM would check that
+        //     it's actually that concrete type when it is thrown and this way
+        //     it only checks for the base condition)
+        throw (E)exc;
+    }
 }