AssignmentGuardFinder.java

package org.mutabilitydetector.checkers.settermethod;

/*
 * #%L
 * MutabilityDetector
 * %%
 * Copyright (C) 2008 - 2014 Graham Allan
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */



import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.objectweb.asm.Opcodes.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.concurrent.Immutable;

import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.VarInsnNode;

/**
 * 
 * 
 * @author Juergen Fickel
 * @version 02.03.2013
 */
@Immutable
final class AssignmentGuardFinder implements Finder<JumpInsn> {

    private final String candidateName;
    private final ControlFlowBlock controlFlowBlock;

    private AssignmentGuardFinder(final String theCandidateName, final ControlFlowBlock theControlFlowBlock) {
        candidateName = theCandidateName;
        controlFlowBlock = theControlFlowBlock;
    }

    /**
     * Creates a new instance of this class. None of the arguments must be
     * {@code null}.
     * 
     * @param candidateName
     *            name of the lazy variable. Must not be empty!
     * @param controlFlowBlock
     *            the control flow block which is supposed to contain an
     *            {@link AssignmentGuard}.
     * @return a new instance of this class.
     */
    public static AssignmentGuardFinder newInstance(final String candidateName,
            final ControlFlowBlock controlFlowBlock) {
        checkArgument(!candidateName.isEmpty());
        return new AssignmentGuardFinder(candidateName, checkNotNull(controlFlowBlock));
    }

    @Override
    public JumpInsn find() {
        final Collection<JumpInsn> supposedAssignmentGuards = collectSupposedAssignmentGuards();
        if (1 < supposedAssignmentGuards.size()) {
            throw new IllegalStateException("There exists more than one assignment guard in this block.");
        }
        for (final JumpInsn jumpInsn : supposedAssignmentGuards) {
            return jumpInsn;
        }
        return NullJumpInsn.getInstance();
    }

    private Collection<JumpInsn> collectSupposedAssignmentGuards() {
        final Set<JumpInsn> result = new HashSet<JumpInsn>();
        for (final JumpInsn jumpInsn : collectAllConditionCheckInstructionsOfBlock()) {
            final AssignmentGuard.Builder builder = new AssignmentGuard.Builder(jumpInsn);
            final JumpInsn possibleAssignmentGuard = getAssignmentGuard(jumpInsn.getIndexWithinBlock(), builder);
            if (possibleAssignmentGuard.isAssignmentGuard()) {
                result.add(possibleAssignmentGuard);
            }
        }
        return result;
    }

    private Collection<JumpInsn> collectAllConditionCheckInstructionsOfBlock() {
        final ArrayList<JumpInsn> result = new ArrayList<JumpInsn>();
        int indexWithinBlock = 0;
        for (final AbstractInsnNode insn : controlFlowBlock.getBlockInstructions()) {
            if (isConditionCheckInstruction(insn)) {
                final JumpInsnNode jumpInsnNode = (JumpInsnNode) insn;
                final int indexWithinMethod = controlFlowBlock.getIndexWithinMethod(indexWithinBlock);
                result.add(DefaultJumpInsn.newInstance(jumpInsnNode, indexWithinBlock, indexWithinMethod));
            }
            indexWithinBlock++;
        }
        result.trimToSize();
        return result;
    }

    private static boolean isConditionCheckInstruction(final AbstractInsnNode insn) {
        final int opcode = insn.getOpcode();
        return AbstractInsnNode.JUMP_INSN == insn.getType() && opcode != Opcodes.GOTO && opcode != Opcodes.JSR
                && opcode != Opcodes.RET;
    }

    private JumpInsn getAssignmentGuard(final int indexOfInstructionToAnalyse, final AssignmentGuard.Builder builder) {
        final JumpInsn result;
        final List<AbstractInsnNode> blockInstructions = controlFlowBlock.getBlockInstructions();
        final int indexOfPredecessorInstruction = indexOfInstructionToAnalyse - 1;
        final AbstractInsnNode predecessorInstruction = blockInstructions.get(indexOfPredecessorInstruction);
        builder.addPredecessorInstruction(predecessorInstruction);
        if (isGetfieldOrGetstaticForCandidate(predecessorInstruction)) {
            result = builder.build();
        } else if (isLoadInstructionForAlias(predecessorInstruction)) {
            result = builder.build();
        } else if (isEqualsInstruction(predecessorInstruction)) {
            result = NullJumpInsn.getInstance();
        } else if (isPushNullOntoStackInstruction(predecessorInstruction)) {
            result = getAssignmentGuard(indexOfPredecessorInstruction, builder);
        } else if (isComparisonInstruction(predecessorInstruction)) {
            result = getAssignmentGuard(indexOfPredecessorInstruction, builder);
        } else {
            result = NullJumpInsn.getInstance();
        }
        return result;
    }

    private boolean isGetfieldOrGetstaticForCandidate(final AbstractInsnNode insn) {
        boolean result = false;
        if (GETFIELD == insn.getOpcode() || GETSTATIC == insn.getOpcode()) {
            final FieldInsnNode getInstruction = (FieldInsnNode) insn;
            result = candidateName.equals(getInstruction.name);
        }
        return result;
    }

    private boolean isLoadInstructionForAlias(final AbstractInsnNode insn) {
        final Finder<Alias> f = AliasFinder.newInstance(candidateName, controlFlowBlock);
        final Alias alias = f.find();
        return alias.doesExist && isLoadInstructionForAlias(insn, alias);
    }

    private static boolean isLoadInstructionForAlias(final AbstractInsnNode insn, final Alias alias) {
        boolean result = false;
        if (AbstractInsnNode.VAR_INSN == insn.getType()) {
            final VarInsnNode loadInstruction = (VarInsnNode) insn;
            result = loadInstruction.var == alias.localVariable;
        }
        return result;
    }

    private static boolean isEqualsInstruction(final AbstractInsnNode insn) {
        final boolean result;
        if (AbstractInsnNode.METHOD_INSN == insn.getType()) {
            final MethodInsnNode methodInsnNode = (MethodInsnNode) insn;
            result = methodInsnNode.name.equals("equals");
        } else {
            result = false;
        }
        return result;
    }

    private static boolean isPushNullOntoStackInstruction(final AbstractInsnNode insn) {
        return ACONST_NULL == insn.getOpcode();
    }

    private static boolean isComparisonInstruction(final AbstractInsnNode insn) {
        switch (insn.getOpcode()) {
        case LCMP:
        case FCMPL:
        case FCMPG:
        case DCMPL:
        case DCMPG:
        case IF_ICMPEQ:
        case IF_ICMPNE:
        case IF_ICMPLT:
        case IF_ICMPGE:
        case IF_ICMPGT:
        case IF_ICMPLE:
        case IF_ACMPEQ:
        case IF_ACMPNE:
            return true;
        default:
            return false;
        }
    }

    @Override
    public String toString() {
        final StringBuilder b = new StringBuilder();
        b.append(getClass().getSimpleName()).append(" [candidateName=").append(candidateName);
        b.append(", controlFlowBlock=").append(controlFlowBlock).append(']');
        return b.toString();
    }

}