Remove StateNames and getStateByName

`getStateByName` existed uniquely as a workaround for retrieving the jvm/heap tree state from a composite abstract state containing both.

Since composite abstract states have been removed together with the heap tree model, `getStateByName` has no reason to exist anymore.

The code is functionally unchanged since for a JvmAbstractState `getStateByName("Jvm") is just the state itself.

There are still problems with unchecked casts for all the states that were returned by getStateByName, but these will be resolved in a separate commit.

base/src/main/java/proguard/analysis/cpa/interfaces/AbstractState.java

@@ -33,14 +33,6 @@ default Precision getPrecision() {
   /** Creates a copy of itself. */
   AbstractState copy();
 
-  /**
-   * Returns an abstract state for a given {@param name} if the state is composite, returns {@code
-   * self} otherwise.
-   */
-  default AbstractState getStateByName(String name) {
-    return this;
-  }
-
   // overrides for Object
 
   @Override

base/src/main/java/proguard/analysis/cpa/jvm/domain/memory/JvmMemoryLocationTransferRelation.java

@@ -59,7 +59,6 @@
 import proguard.analysis.cpa.jvm.witness.JvmMemoryLocation;
 import proguard.analysis.cpa.jvm.witness.JvmStackLocation;
 import proguard.analysis.cpa.jvm.witness.JvmStaticFieldLocation;
-import proguard.analysis.cpa.util.StateNames;
 import proguard.analysis.datastructure.callgraph.Call;
 import proguard.classfile.AccessConstants;
 import proguard.classfile.Clazz;
@@ -254,8 +253,7 @@ public Collection<? extends AbstractState> generateAbstractSuccessors(
               }
 
               JvmAbstractState<AbstractStateT> returnJvmAbstractState =
-                  (JvmAbstractState<AbstractStateT>)
-                      returnState.get().getStateByName(StateNames.Jvm);
+                  (JvmAbstractState<AbstractStateT>) returnState.get();
               AbstractStateT value =
                   state
                       .getLocationDependentMemoryLocation()
@@ -334,8 +332,7 @@ public Collection<? extends AbstractState> generateAbstractSuccessors(
         successors.addAll(
             getSuccessorsFromMemoryLocations(
                 intraproceduralSuccessorMemoryLocations,
-                (JvmAbstractState<AbstractStateT>)
-                    intraproceduralParentState.get().getStateByName(StateNames.Jvm),
+                (JvmAbstractState<AbstractStateT>) intraproceduralParentState.get(),
                 state.getSourceReachedSet(),
                 state.copyStack()));
       }
@@ -366,8 +363,7 @@ public Collection<? extends AbstractState> generateAbstractSuccessors(
                   ci ->
                       getSuccessorsFromMemoryLocations(
                               Collections.singletonList(callerMemoryLocation.get()),
-                              (JvmAbstractState<AbstractStateT>)
-                                  ci.state.getStateByName(StateNames.Jvm),
+                              (JvmAbstractState<AbstractStateT>) ci.state,
                               ci.reachedSet,
                               new LinkedList<>())
                           .stream()
@@ -380,8 +376,7 @@ public Collection<? extends AbstractState> generateAbstractSuccessors(
           successors.addAll(
               getSuccessorsFromMemoryLocations(
                   Collections.singletonList(callerMemoryLocation.get()),
-                  (JvmAbstractState<AbstractStateT>)
-                      currentEntry.callerState.getStateByName(StateNames.Jvm),
+                  (JvmAbstractState<AbstractStateT>) currentEntry.callerState,
                   currentEntry.reachedSet,
                   successorStack));
         }
@@ -834,8 +829,7 @@ public void visitConstantInstruction(
                   memoryLocation,
                   constantInstruction,
                   clazz,
-                  ((JvmAbstractState<AbstractStateT>) parentState.getStateByName(StateNames.Jvm))
-                      .getProgramLocation()));
+                  ((JvmAbstractState<AbstractStateT>) parentState).getProgramLocation()));
           break;
         case Instruction.OP_NEW:
         case Instruction.OP_NEWARRAY:

base/src/main/java/proguard/analysis/cpa/util/TaintAnalyzerResult.java

@@ -217,8 +217,7 @@ public BamCache<MethodSignature> getTaintResultCache() {
                       .asCollection()
                       .forEach(
                           state ->
-                              ((JvmAbstractState<SetAbstractState<JvmTaintSource>>)
-                                      state.getStateByName(StateNames.Jvm))
+                              ((JvmAbstractState<SetAbstractState<JvmTaintSource>>) state)
                                   .getProgramLocation()
                                   .getLeavingEdges()
                                   .forEach(
@@ -267,8 +266,7 @@ private void createEndpointsForEdgeIfTainted(
                       .filter(
                           memoryLocation ->
                               isStateTaintedForMemoryLocation(
-                                  (JvmAbstractState<SetAbstractState<JvmTaintSource>>)
-                                      state.getStateByName(StateNames.Jvm),
+                                  (JvmAbstractState<SetAbstractState<JvmTaintSource>>) state,
                                   memoryLocation,
                                   sinkToMemoryLocations.getKey()))
                       .forEach(

docs/md/releasenotes.md

@@ -31,6 +31,7 @@ make its usage easier. This includes:
 - Remove `JvmTaintMemoryLocationBamCpaRun` in order to simplify the utility code to run the analysis. `TaintAnalyzer` is the direct replacement, this class has the same behavior as `JvmTaintMemoryLocationBamCpaRun`, as long as `analyze` is called only once.
 - Remove the `CpaRun` infrastructure.
 - Remove `MapAbstractStateFactory`, `WrapperTransferRelation`, and other classes that were only used with the tree heap model.
+- Remove `StateNames` and `getStateByName`.
 
 ## Version 9.1.6