• Home
• org.checkerframework
• checker
• 2.0.1
• source code
• QualTransferAdapter.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

framework.src.org.checkerframework.qualframework.base.dataflow.QualTransferAdapter Maven / Gradle / Ivy

package org.checkerframework.qualframework.base.dataflow;

import org.checkerframework.dataflow.analysis.ConditionalTransferResult;
import org.checkerframework.dataflow.analysis.RegularTransferResult;
import org.checkerframework.dataflow.analysis.TransferInput;
import org.checkerframework.dataflow.analysis.TransferResult;
import org.checkerframework.dataflow.cfg.UnderlyingAST;
import org.checkerframework.dataflow.cfg.node.ArrayAccessNode;
import org.checkerframework.dataflow.cfg.node.ArrayCreationNode;
import org.checkerframework.dataflow.cfg.node.ArrayTypeNode;
import org.checkerframework.dataflow.cfg.node.AssertionErrorNode;
import org.checkerframework.dataflow.cfg.node.AssignmentNode;
import org.checkerframework.dataflow.cfg.node.BitwiseAndNode;
import org.checkerframework.dataflow.cfg.node.BitwiseComplementNode;
import org.checkerframework.dataflow.cfg.node.BitwiseOrNode;
import org.checkerframework.dataflow.cfg.node.BitwiseXorNode;
import org.checkerframework.dataflow.cfg.node.BooleanLiteralNode;
import org.checkerframework.dataflow.cfg.node.CaseNode;
import org.checkerframework.dataflow.cfg.node.CharacterLiteralNode;
import org.checkerframework.dataflow.cfg.node.ClassNameNode;
import org.checkerframework.dataflow.cfg.node.ConditionalAndNode;
import org.checkerframework.dataflow.cfg.node.ConditionalNotNode;
import org.checkerframework.dataflow.cfg.node.ConditionalOrNode;
import org.checkerframework.dataflow.cfg.node.DoubleLiteralNode;
import org.checkerframework.dataflow.cfg.node.EqualToNode;
import org.checkerframework.dataflow.cfg.node.ExplicitThisLiteralNode;
import org.checkerframework.dataflow.cfg.node.FieldAccessNode;
import org.checkerframework.dataflow.cfg.node.FloatLiteralNode;
import org.checkerframework.dataflow.cfg.node.FloatingDivisionNode;
import org.checkerframework.dataflow.cfg.node.FloatingRemainderNode;
import org.checkerframework.dataflow.cfg.node.FunctionalInterfaceNode;
import org.checkerframework.dataflow.cfg.node.GreaterThanNode;
import org.checkerframework.dataflow.cfg.node.GreaterThanOrEqualNode;
import org.checkerframework.dataflow.cfg.node.ImplicitThisLiteralNode;
import org.checkerframework.dataflow.cfg.node.InstanceOfNode;
import org.checkerframework.dataflow.cfg.node.IntegerDivisionNode;
import org.checkerframework.dataflow.cfg.node.IntegerLiteralNode;
import org.checkerframework.dataflow.cfg.node.IntegerRemainderNode;
import org.checkerframework.dataflow.cfg.node.LeftShiftNode;
import org.checkerframework.dataflow.cfg.node.LessThanNode;
import org.checkerframework.dataflow.cfg.node.LessThanOrEqualNode;
import org.checkerframework.dataflow.cfg.node.LocalVariableNode;
import org.checkerframework.dataflow.cfg.node.LongLiteralNode;
import org.checkerframework.dataflow.cfg.node.MarkerNode;
import org.checkerframework.dataflow.cfg.node.MethodAccessNode;
import org.checkerframework.dataflow.cfg.node.MethodInvocationNode;
import org.checkerframework.dataflow.cfg.node.NarrowingConversionNode;
import org.checkerframework.dataflow.cfg.node.NotEqualNode;
import org.checkerframework.dataflow.cfg.node.NullChkNode;
import org.checkerframework.dataflow.cfg.node.NullLiteralNode;
import org.checkerframework.dataflow.cfg.node.NumericalAdditionNode;
import org.checkerframework.dataflow.cfg.node.NumericalMinusNode;
import org.checkerframework.dataflow.cfg.node.NumericalMultiplicationNode;
import org.checkerframework.dataflow.cfg.node.NumericalPlusNode;
import org.checkerframework.dataflow.cfg.node.NumericalSubtractionNode;
import org.checkerframework.dataflow.cfg.node.ObjectCreationNode;
import org.checkerframework.dataflow.cfg.node.PackageNameNode;
import org.checkerframework.dataflow.cfg.node.ParameterizedTypeNode;
import org.checkerframework.dataflow.cfg.node.PrimitiveTypeNode;
import org.checkerframework.dataflow.cfg.node.ReturnNode;
import org.checkerframework.dataflow.cfg.node.ShortLiteralNode;
import org.checkerframework.dataflow.cfg.node.SignedRightShiftNode;
import org.checkerframework.dataflow.cfg.node.StringConcatenateAssignmentNode;
import org.checkerframework.dataflow.cfg.node.StringConcatenateNode;
import org.checkerframework.dataflow.cfg.node.StringConversionNode;
import org.checkerframework.dataflow.cfg.node.StringLiteralNode;
import org.checkerframework.dataflow.cfg.node.SuperNode;
import org.checkerframework.dataflow.cfg.node.SynchronizedNode;
import org.checkerframework.dataflow.cfg.node.TernaryExpressionNode;
import org.checkerframework.dataflow.cfg.node.ThrowNode;
import org.checkerframework.dataflow.cfg.node.TypeCastNode;
import org.checkerframework.dataflow.cfg.node.UnsignedRightShiftNode;
import org.checkerframework.dataflow.cfg.node.VariableDeclarationNode;
import org.checkerframework.dataflow.cfg.node.WideningConversionNode;
import org.checkerframework.framework.flow.CFAbstractAnalysis;
import org.checkerframework.framework.flow.CFStore;
import org.checkerframework.framework.flow.CFTransfer;
import org.checkerframework.framework.flow.CFValue;

import javax.lang.model.type.TypeMirror;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * QualTransferAdapter adapts the {@link CFTransfer} to a {@link QualTransfer}.
 *
 * It does this by converting TransferInputs and TransferResults backed
 * by CFValue and CFStores to ones backed by QualValue and QualStores.
 *
 */
public class QualTransferAdapter extends CFTransfer {

    private final QualTransfer underlying;
    private final QualAnalysis qualAnalysis;

    public QualTransferAdapter(
            QualTransfer underlying,
            CFAbstractAnalysis analysis,
            QualAnalysis qualAnalysis) {

        super(analysis);
        underlying.setAdapter(this);
        this.underlying = underlying;
        this.qualAnalysis = qualAnalysis;
    }

    /**
     * Convert a TransferInput backed by CFValue and CFStores to one backed by QualValue and QualStores.
     */
    public TransferInput, QualStore> convertCfToQualInput(TransferInput transferInput) {
        if (transferInput.containsTwoStores()) {
            return new TransferInput<>(transferInput.getNode(), qualAnalysis,
                    new QualStore(qualAnalysis, transferInput.getThenStore()),
                    new QualStore(qualAnalysis, transferInput.getElseStore()));
        } else {
            return new TransferInput<>(transferInput.getNode(), qualAnalysis,
                    new QualStore(qualAnalysis, transferInput.getThenStore()));
        }
    }

    /**
     * Convert a TransferInput backed by QualValue and QualStores to one backed by CFValue and CFStores.
     */
    public TransferInput convertQualToCfInput(TransferInput, QualStore> transferInput) {
        if (transferInput.containsTwoStores()) {
            return new TransferInput<>(transferInput.getNode(), analysis,
                    transferInput.getThenStore().getUnderlyingStore(), transferInput.getElseStore().getUnderlyingStore());
        } else {
            return new TransferInput<>(transferInput.getNode(), analysis,
                    transferInput.getRegularStore().getUnderlyingStore());
        }
    }

    /**
     * Convert a TransferResult backed by QualValue and QualStores to one backed by CFValue and CFStores.
     */
    public TransferResult convertQualToCfResult(TransferResult,
            QualStore> transferResult) {

        Map> exeStores = transferResult.getExceptionalStores();
        Map convertedExeStores = new HashMap<>();
        if (exeStores != null) {
            for (Map.Entry> entry : exeStores.entrySet()) {
                convertedExeStores.put(entry.getKey(), entry.getValue().getUnderlyingStore());
            }
        }

        CFValue resultValue = null;
        if (transferResult.getResultValue() != null) {
            resultValue = analysis.createAbstractValue(
                    qualAnalysis.getConverter().getAnnotatedType(transferResult.getResultValue().getType()));
        }

        if (transferResult.containsTwoStores()) {
            return new ConditionalTransferResult<>(resultValue,
                    transferResult.getThenStore().getUnderlyingStore(),
                    transferResult.getElseStore().getUnderlyingStore(),
                    convertedExeStores, transferResult.storeChanged());
        } else {
            return new RegularTransferResult<>(resultValue,
                    transferResult.getRegularStore().getUnderlyingStore(),
                    convertedExeStores, transferResult.storeChanged());
        }
    }

    /**
     * Convert a TransferResult backed by CFValue and CFStores to one backed by QualValue and QualStores.
     */
    public  TransferResult, QualStore> convertCfToQualResult(TransferResult transferResult) {
        Map exeStores = transferResult.getExceptionalStores();
        Map> convertedExeStores = new HashMap<>();
        if (exeStores != null) {
            for (Map.Entry entry : exeStores.entrySet()) {
                convertedExeStores.put(entry.getKey(), new QualStore(qualAnalysis, entry.getValue()));
            }
        }

        QualValue resultValue = null;
        if (transferResult.getResultValue() != null) {
            resultValue = qualAnalysis.createAbstractValue(
                    qualAnalysis.getConverter().getQualifiedType(transferResult.getResultValue().getType()));
        }

        if (transferResult.containsTwoStores()) {
            return new ConditionalTransferResult<>(resultValue,
                    new QualStore(qualAnalysis, transferResult.getThenStore()),
                    new QualStore(qualAnalysis, transferResult.getElseStore()),
                    convertedExeStores, transferResult.storeChanged());
        } else {
            return new RegularTransferResult<>(resultValue,
                    new QualStore(qualAnalysis, transferResult.getRegularStore()),
                    convertedExeStores, transferResult.storeChanged());
        }
    }

    public QualStore superInitialStore(UnderlyingAST underlyingAST, List parameters) {
        CFStore initialStore = super.initialStore(underlyingAST, parameters);
        return new QualStore<>(qualAnalysis, initialStore);
    }

    @Override
    public TransferResult visitShortLiteral(ShortLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitShortLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitShortLiteral(ShortLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitShortLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitIntegerLiteral(IntegerLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitIntegerLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitIntegerLiteral(IntegerLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitIntegerLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitLongLiteral(LongLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitLongLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitLongLiteral(LongLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitLongLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitFloatLiteral(FloatLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitFloatLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitFloatLiteral(FloatLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitFloatLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitDoubleLiteral(DoubleLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitDoubleLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitDoubleLiteral(DoubleLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitDoubleLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitBooleanLiteral(BooleanLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitBooleanLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitBooleanLiteral(BooleanLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitBooleanLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitCharacterLiteral(CharacterLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitCharacterLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitCharacterLiteral(CharacterLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitCharacterLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitStringLiteral(StringLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitStringLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitStringLiteral(StringLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitStringLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNullLiteral(NullLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNullLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNullLiteral(NullLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNullLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Unary operations
    @Override
    public TransferResult visitNumericalMinus(NumericalMinusNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNumericalMinus(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNumericalMinus(NumericalMinusNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNumericalMinus(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNumericalPlus(NumericalPlusNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNumericalPlus(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNumericalPlus(NumericalPlusNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNumericalPlus(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitBitwiseComplement(BitwiseComplementNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitBitwiseComplement(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitBitwiseComplement(BitwiseComplementNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitBitwiseComplement(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNullChk(NullChkNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNullChk(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNullChk(NullChkNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNullChk(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Binary operations
    @Override
    public TransferResult visitStringConcatenate(StringConcatenateNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitStringConcatenate(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitStringConcatenate(StringConcatenateNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitStringConcatenate(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNumericalAddition(NumericalAdditionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNumericalAddition(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNumericalAddition(NumericalAdditionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNumericalAddition(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNumericalSubtraction(NumericalSubtractionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNumericalSubtraction(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNumericalSubtraction(NumericalSubtractionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNumericalSubtraction(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNumericalMultiplication(NumericalMultiplicationNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNumericalMultiplication(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNumericalMultiplication(NumericalMultiplicationNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNumericalMultiplication(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitIntegerDivision(IntegerDivisionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitIntegerDivision(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitIntegerDivision(IntegerDivisionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitIntegerDivision(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitFloatingDivision(FloatingDivisionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitFloatingDivision(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitFloatingDivision(FloatingDivisionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitFloatingDivision(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitIntegerRemainder(IntegerRemainderNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitIntegerRemainder(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitIntegerRemainder(IntegerRemainderNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitIntegerRemainder(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitFloatingRemainder(FloatingRemainderNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitFloatingRemainder(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitFloatingRemainder(FloatingRemainderNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitFloatingRemainder(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitLeftShift(LeftShiftNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitLeftShift(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitLeftShift(LeftShiftNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitLeftShift(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitSignedRightShift(SignedRightShiftNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitSignedRightShift(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitSignedRightShift(SignedRightShiftNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitSignedRightShift(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitUnsignedRightShift(UnsignedRightShiftNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitUnsignedRightShift(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitUnsignedRightShift(UnsignedRightShiftNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitUnsignedRightShift(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitBitwiseAnd(BitwiseAndNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitBitwiseAnd(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitBitwiseAnd(BitwiseAndNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitBitwiseAnd(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitBitwiseOr(BitwiseOrNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitBitwiseOr(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitBitwiseOr(BitwiseOrNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitBitwiseOr(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitBitwiseXor(BitwiseXorNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitBitwiseXor(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitBitwiseXor(BitwiseXorNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitBitwiseXor(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Compound assignments
    @Override
    public TransferResult visitStringConcatenateAssignment(
            StringConcatenateAssignmentNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitStringConcatenateAssignment(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitStringConcatenateAssignment(StringConcatenateAssignmentNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitStringConcatenateAssignment(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Comparison operations
    @Override
    public TransferResult visitLessThan(LessThanNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitLessThan(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitLessThan(LessThanNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitLessThan(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitLessThanOrEqual(LessThanOrEqualNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitLessThanOrEqual(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitLessThanOrEqual(LessThanOrEqualNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitLessThanOrEqual(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitGreaterThan(GreaterThanNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitGreaterThan(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitGreaterThan(GreaterThanNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitGreaterThan(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitGreaterThanOrEqual(GreaterThanOrEqualNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitGreaterThanOrEqual(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitGreaterThanOrEqual(GreaterThanOrEqualNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitGreaterThanOrEqual(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitEqualTo(EqualToNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitEqualTo(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitEqualTo(EqualToNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitEqualTo(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNotEqual(NotEqualNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNotEqual(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitNotEqual(NotEqualNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNotEqual(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Conditional operations
    @Override
    public TransferResult visitConditionalAnd(ConditionalAndNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitConditionalAnd(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitConditionalAnd(ConditionalAndNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitConditionalAnd(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitConditionalOr(ConditionalOrNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitConditionalOr(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitConditionalOr(ConditionalOrNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitConditionalOr(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitConditionalNot(ConditionalNotNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitConditionalNot(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitConditionalNot(ConditionalNotNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitConditionalNot(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitTernaryExpression(TernaryExpressionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitTernaryExpression(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitTernaryExpression(TernaryExpressionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitTernaryExpression(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitAssignment(AssignmentNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitAssignment(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitAssignment(AssignmentNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitAssignment(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitLocalVariable(LocalVariableNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitLocalVariable(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitLocalVariable(LocalVariableNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitLocalVariable(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitVariableDeclaration(VariableDeclarationNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitVariableDeclaration(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitVariableDeclaration(VariableDeclarationNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitVariableDeclaration(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitFieldAccess(FieldAccessNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitFieldAccess(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitFieldAccess(FieldAccessNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitFieldAccess(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitMethodAccess(MethodAccessNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitMethodAccess(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitMethodAccess(MethodAccessNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitMethodAccess(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitArrayAccess(ArrayAccessNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitArrayAccess(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitArrayAccess(ArrayAccessNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitArrayAccess(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitImplicitThisLiteral(ImplicitThisLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitImplicitThisLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitImplicitThisLiteral(ImplicitThisLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitImplicitThisLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitExplicitThisLiteral(ExplicitThisLiteralNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitExplicitThisLiteral(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitExplicitThisLiteral(ExplicitThisLiteralNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitExplicitThisLiteral(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitSuper(SuperNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitSuper(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitSuper(SuperNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitSuper(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitReturn(ReturnNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitReturn(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    };

    public TransferResult, QualStore> superVisitReturn(ReturnNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitReturn(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitStringConversion(StringConversionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitStringConversion(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    };

    public TransferResult, QualStore> superVisitStringConversion(StringConversionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitStringConversion(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitNarrowingConversion(NarrowingConversionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitNarrowingConversion(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    };

    public TransferResult, QualStore> superVisitNarrowingConversion(NarrowingConversionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitNarrowingConversion(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitWideningConversion(WideningConversionNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitWideningConversion(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    };

    public TransferResult, QualStore> superVisitWideningConversion(WideningConversionNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitWideningConversion(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitInstanceOf(InstanceOfNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitInstanceOf(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitInstanceOf(InstanceOfNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitInstanceOf(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitTypeCast(TypeCastNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitTypeCast(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitTypeCast(TypeCastNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitTypeCast(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Statements
    @Override
    public TransferResult visitAssertionError(AssertionErrorNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitAssertionError(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitAssertionError(AssertionErrorNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitAssertionError(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitSynchronized(SynchronizedNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitSynchronized(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitSynchronized(SynchronizedNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitSynchronized(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitThrow(ThrowNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitThrow(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitThrow(ThrowNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitThrow(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Cases
    @Override
    public TransferResult visitCase(CaseNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitCase(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitCase(CaseNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitCase(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Method and constructor invocations
    @Override
    public TransferResult visitMethodInvocation(MethodInvocationNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitMethodInvocation(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitMethodInvocation(MethodInvocationNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitMethodInvocation(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitObjectCreation(ObjectCreationNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitObjectCreation(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitObjectCreation(ObjectCreationNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitObjectCreation(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitMemberReference(FunctionalInterfaceNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitMemberReference(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitMemberReference(FunctionalInterfaceNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitMemberReference(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitArrayCreation(ArrayCreationNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitArrayCreation(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitArrayCreation(ArrayCreationNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitArrayCreation(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Type, package and class names
    @Override
    public TransferResult visitArrayType(ArrayTypeNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitArrayType(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitArrayType(ArrayTypeNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitArrayType(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitPrimitiveType(PrimitiveTypeNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitPrimitiveType(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitPrimitiveType(PrimitiveTypeNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitPrimitiveType(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitClassName(ClassNameNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitClassName(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitClassName(ClassNameNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitClassName(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    @Override
    public TransferResult visitPackageName(PackageNameNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitPackageName(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitPackageName(PackageNameNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitPackageName(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Parameterized types
    @Override
    public TransferResult visitParameterizedType(ParameterizedTypeNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitParameterizedType(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitParameterizedType(ParameterizedTypeNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitParameterizedType(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }

    // Marker nodes
    @Override
    public TransferResult visitMarker(MarkerNode n, TransferInput p) {
        TransferResult, QualStore> result = underlying.visitMarker(n, convertCfToQualInput(p));
        return convertQualToCfResult(result);
    }

    public TransferResult, QualStore> superVisitMarker(MarkerNode n, TransferInput, QualStore> p) {
        TransferResult result = super.visitMarker(n, convertQualToCfInput(p));
        return convertCfToQualResult(result);
    }
}