Add a new delegate to allow API tracing

src/org/sosy_lab/java_smt/SolverContextFactory.java

@@ -30,6 +30,7 @@
 import org.sosy_lab.java_smt.delegate.logging.LoggingSolverContext;
 import org.sosy_lab.java_smt.delegate.statistics.StatisticsSolverContext;
 import org.sosy_lab.java_smt.delegate.synchronize.SynchronizedSolverContext;
+import org.sosy_lab.java_smt.delegate.trace.TraceSolverContext;
 import org.sosy_lab.java_smt.solvers.bitwuzla.BitwuzlaSolverContext;
 import org.sosy_lab.java_smt.solvers.boolector.BoolectorSolverContext;
 import org.sosy_lab.java_smt.solvers.cvc4.CVC4SolverContext;
@@ -95,6 +96,11 @@ public enum Solvers {
   @Option(secure = true, description = "Apply additional checks to catch common user errors.")
   private boolean useDebugMode = false;
 
+  @Option(
+      secure = true,
+      description = "Enable API tracing to record all calls to the JavaSMT library")
+  private boolean trace = false;
+
   @Option(
       secure = true,
       description = "Counts all operations and interactions towards the SMT solver.")
@@ -230,6 +236,9 @@ public SolverContext generateContext(Solvers solverToCreate)
     if (useDebugMode) {
       context = new DebuggingSolverContext(solverToCreate, config, context);
     }
+    if (trace) {
+      context = new TraceSolverContext(solverToCreate, config, context);
+    }
     if (collectStatistics) {
       // statistics need to be the most outer wrapping layer.
       context = new StatisticsSolverContext(context);

src/org/sosy_lab/java_smt/delegate/trace/TraceArrayFormulaManager.java

@@ -0,0 +1,93 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2025 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.delegate.trace;
+
+import org.sosy_lab.java_smt.api.ArrayFormula;
+import org.sosy_lab.java_smt.api.ArrayFormulaManager;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.Formula;
+import org.sosy_lab.java_smt.api.FormulaType;
+
+@SuppressWarnings("MethodTypeParameterName")
+public class TraceArrayFormulaManager implements ArrayFormulaManager {
+  private final ArrayFormulaManager delegate;
+  private final TraceLogger logger;
+
+  TraceArrayFormulaManager(ArrayFormulaManager pDelegate, TraceLogger pLogger) {
+    delegate = pDelegate;
+    logger = pLogger;
+  }
+
+  @Override
+  public <TI extends Formula, TE extends Formula> TE select(
+      ArrayFormula<TI, TE> pArray, TI pIndex) {
+    return logger.logDef(
+        "mgr.getArrayFormulaManager()",
+        String.format("select(%s, %s)", logger.toVariable(pArray), logger.toVariable(pIndex)),
+        () -> delegate.select(pArray, pIndex));
+  }
+
+  @Override
+  public <TI extends Formula, TE extends Formula> ArrayFormula<TI, TE> store(
+      ArrayFormula<TI, TE> pArray, TI pIndex, TE pValue) {
+    return logger.logDef(
+        "mgr.getArrayFormulaManager()",
+        String.format(
+            "store(%s, %s, %s)",
+            logger.toVariable(pArray), logger.toVariable(pIndex), logger.toVariable(pValue)),
+        () -> delegate.store(pArray, pIndex, pValue));
+  }
+
+  @Override
+  public <
+          TI extends Formula,
+          TE extends Formula,
+          FTI extends FormulaType<TI>,
+          FTE extends FormulaType<TE>>
+      ArrayFormula<TI, TE> makeArray(String pName, FTI pIndexType, FTE pElementType) {
+    return logger.logDef(
+        "mgr.getArrayFormulaManager()",
+        String.format(
+            "makeArray(\"%s\", %s, %s)",
+            pName, logger.printFormulaType(pIndexType), logger.printFormulaType(pElementType)),
+        () -> delegate.makeArray(pName, pIndexType, pElementType));
+  }
+
+  @Override
+  public <
+          TI extends Formula,
+          TE extends Formula,
+          FTI extends FormulaType<TI>,
+          FTE extends FormulaType<TE>>
+      ArrayFormula<TI, TE> makeArray(FTI pIndexType, FTE pElementType, TE defaultElement) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public <TI extends Formula, TE extends Formula> BooleanFormula equivalence(
+      ArrayFormula<TI, TE> pArray1, ArrayFormula<TI, TE> pArray2) {
+    return logger.logDef(
+        "mgr.getArrayFormulaManager()",
+        String.format(
+            "equivalence(%s, %s)", logger.toVariable(pArray1), logger.toVariable(pArray2)),
+        () -> delegate.equivalence(pArray1, pArray2));
+  }
+
+  @Override
+  public <TI extends Formula> FormulaType<TI> getIndexType(ArrayFormula<TI, ?> pArray) {
+    return delegate.getIndexType(pArray);
+  }
+
+  @Override
+  public <TE extends Formula> FormulaType<TE> getElementType(ArrayFormula<?, TE> pArray) {
+    return delegate.getElementType(pArray);
+  }
+}

src/org/sosy_lab/java_smt/delegate/trace/TraceBasicProverEnvironment.java

@@ -0,0 +1,93 @@
+/*
+ * This file is part of JavaSMT,
+ * an API wrapper for a collection of SMT solvers:
+ * https://github.com/sosy-lab/java-smt
+ *
+ * SPDX-FileCopyrightText: 2025 Dirk Beyer <https://www.sosy-lab.org>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.sosy_lab.java_smt.delegate.trace;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.sosy_lab.java_smt.api.BasicProverEnvironment;
+import org.sosy_lab.java_smt.api.BooleanFormula;
+import org.sosy_lab.java_smt.api.Model;
+import org.sosy_lab.java_smt.api.SolverException;
+
+public class TraceBasicProverEnvironment<T> implements BasicProverEnvironment<T> {
+  private final BasicProverEnvironment<T> delegate;
+  private final TraceLogger logger;
+
+  TraceBasicProverEnvironment(BasicProverEnvironment<T> pDelegate, TraceLogger pLogger) {
+    delegate = pDelegate;
+    logger = pLogger;
+  }
+
+  @Override
+  public void pop() {
+    logger.logStmt(logger.toVariable(this), "pop()", delegate::pop);
+  }
+
+  @Override
+  public @Nullable T addConstraint(BooleanFormula constraint) throws InterruptedException {
+    return logger.logDef(
+        logger.toVariable(this),
+        String.format("addConstraint(%s)", logger.toVariable(constraint)),
+        () -> delegate.addConstraint(constraint));
+  }
+
+  @Override
+  public void push() throws InterruptedException {
+    logger.logStmt(logger.toVariable(this), "push()", delegate::push);
+  }
+
+  @Override
+  public int size() {
+    return delegate.size();
+  }
+
+  @Override
+  public boolean isUnsat() throws SolverException, InterruptedException {
+    return logger.logDef(logger.toVariable(this), "isUnsat()", delegate::isUnsat);
+  }
+
+  @Override
+  public boolean isUnsatWithAssumptions(Collection<BooleanFormula> assumptions)
+      throws SolverException, InterruptedException {
+    throw new UnsupportedOperationException();
+  }
+
+  @SuppressWarnings("resource")
+  @Override
+  public Model getModel() throws SolverException {
+    return logger.logDef(
+        logger.toVariable(this), "getModel()", () -> new TraceModel(delegate.getModel(), logger));
+  }
+
+  @Override
+  public List<BooleanFormula> getUnsatCore() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public Optional<List<BooleanFormula>> unsatCoreOverAssumptions(
+      Collection<BooleanFormula> assumptions) throws SolverException, InterruptedException {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public void close() {
+    logger.logStmt(logger.toVariable(this), "close()", delegate::close);
+  }
+
+  @Override
+  public <R> R allSat(AllSatCallback<R> callback, List<BooleanFormula> important)
+      throws InterruptedException, SolverException {
+    throw new UnsupportedOperationException();
+  }
+}