Class CatchResult

src/main/java/pascal/taie/analysis/exception/CatchResult.java:35–124

import java.util.Set;

public class CatchResult {

    private final Map<Stmt, MultiMap<Stmt, ClassType>> caughtImplicit = Maps.newHybridMap();

    private final MultiMap<Stmt, ClassType> uncaughtImplicit
            = Maps.newMultiMap(Maps.newHybridMap());

    private final Map<Stmt, MultiMap<Stmt, ClassType>> caughtExplicit = Maps.newHybridMap();

    private final MultiMap<Stmt, ClassType> uncaughtExplicit
            = Maps.newMultiMap(Maps.newHybridMap());

    void addCaughtImplicit(Stmt stmt, Catch catcher, ClassType exceptionType) {
        caughtImplicit.computeIfAbsent(stmt, s -> Maps.newMultiMap(Maps.newHybridMap()))
                .put(catcher, exceptionType);
    }

    void addUncaughtImplicit(Stmt stmt, ClassType exceptionType) {
        uncaughtImplicit.put(stmt, exceptionType);
    }

    /**
     * @return all exception types that may be implicitly thrown by given Stmt
     * and caught by its containing method. The result of the call is a map
     * from Catch statements to set of exception types that are caught
     * by the Catches.
     */
    public MultiMap<Stmt, ClassType> getCaughtImplicitOf(Stmt stmt) {
        return caughtImplicit.getOrDefault(stmt, Maps.newMultiMap(Map.of()));
    }

    /**
     * @return the set of exception types that may be implicitly thrown
     * by given Stmt but not caught by its containing method.
     */
    public Set<ClassType> getUncaughtImplicitOf(Stmt stmt) {
        return uncaughtImplicit.get(stmt);
    }

    void addCaughtExplicit(Stmt stmt, Catch catcher, ClassType exceptionType) {
        caughtExplicit.computeIfAbsent(stmt, s -> Maps.newMultiMap())
                .put(catcher, exceptionType);
    }

    void addUncaughtExplicit(Stmt stmt, ClassType exceptionType) {
        uncaughtExplicit.put(stmt, exceptionType);
    }

    /**
     * @return all exception types that may be explicitly thrown by given Stmt
     * and caught by its containing method. The result of the call is a map
     * from Catch statements to set of exception types that are caught
     * by the Catches.
     */
    public MultiMap<Stmt, ClassType> getCaughtExplicitOf(Stmt stmt) {
        return caughtExplicit.getOrDefault(stmt, Maps.newMultiMap());
    }