import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private Collection<String> getDatatypesUsed(Collection<Slot> slots) {
    Set<String> types = new TreeSet<>();
    for (Slot slot : slots) {
        if (slot instanceof ConstantSlot) {
            ConstantSlot constantSlot = (ConstantSlot) slot;
            AnnotationMirror anno = constantSlot.getValue();
            if (AnnotationUtils.areSameIgnoringValues(anno, DATAFLOW)) {
                String[] dataflowValues = DataflowUtils.getTypeNames(anno);
                for (String dataflowValue : dataflowValues) {
                    types.add(dataflowValue);
                }
            }
        }
    }
    return types;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private boolean isSubtypeWithRoots(AnnotationMirror rhs, AnnotationMirror lhs) {

            Set<String> rTypeNamesSet = new HashSet<String>(Arrays.asList(DataflowUtils.getTypeNames(rhs)));
            Set<String> lTypeNamesSet = new HashSet<String>(Arrays.asList(DataflowUtils.getTypeNames(lhs)));
            Set<String> rRootsSet = new HashSet<String>(Arrays.asList(DataflowUtils.getTypeNameRoots(rhs)));
            Set<String> lRootsSet = new HashSet<String>(Arrays.asList(DataflowUtils.getTypeNameRoots(lhs)));
            Set<String> combinedTypeNames = new HashSet<String>();
            combinedTypeNames.addAll(rTypeNamesSet);
            combinedTypeNames.addAll(lTypeNamesSet);
            Set<String> combinedRoots = new HashSet<String>();
            combinedRoots.addAll(rRootsSet);
            combinedRoots.addAll(lRootsSet);

            AnnotationMirror combinedAnno = DataflowUtils.createDataflowAnnotationWithRoots(
                    combinedTypeNames, combinedRoots, processingEnv);
            AnnotationMirror refinedCombinedAnno = refineDataflow(combinedAnno);
            AnnotationMirror refinedLhs = refineDataflow(lhs);

            if (AnnotationUtils.areSame(refinedCombinedAnno, refinedLhs)) {
                return true;
            } else {
                return false;
            }
        }
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
@Override
public boolean isSubtype(AnnotationMirror rhs, AnnotationMirror lhs) {
    if (AnnotationUtils.areSameIgnoringValues(rhs, DATAFLOW)
            && AnnotationUtils.areSameIgnoringValues(lhs, DATAFLOW)) {
        return isSubtypeWithRoots(rhs, lhs);
        // return isSubtypeWithoutRoots(rhs, lhs);
    } else {
        //if (rhs != null && lhs != null)
        if (AnnotationUtils.areSameIgnoringValues(rhs, DATAFLOW)) {
            rhs = DATAFLOW;
        } else if (AnnotationUtils.areSameIgnoringValues(lhs, DATAFLOW)) {
            lhs = DATAFLOW;
        }
        return super.isSubtype(rhs, lhs);
    }
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
@Override
protected InferenceSolution solve() {
    Elements elements = processingEnvironment.getElementUtils();
    DATAFLOW = AnnotationUtils.fromClass(elements, DataFlow.class);

    Collection<String> datatypesUsed = getDatatypesUsed(slots);
    List<DataflowImpliesLogic> dataflowLogics = new ArrayList<>();

    for (String datatype : datatypesUsed) {
        Set<String> datatypeSet = new HashSet<String>();
        datatypeSet.add(datatype);
        AnnotationMirror dataflowAnnotation= DataflowUtils.createDataflowAnnotation(datatypeSet, processingEnvironment);
        LatticeGenerator lattice = new LatticeGenerator(dataflowAnnotation,processingEnvironment);
        DataflowGeneralSerializer serializer = new DataflowGeneralSerializer(
                slotManager, lattice);
        DataflowImpliesLogic logic = new DataflowImpliesLogic(lattice, constraints, serializer);
        dataflowLogics.add(logic);
    }
    List<DatatypeSolution> datatypeSolutions = solveImpliesLogic(dataflowLogics);
    return getMergedSolution(processingEnvironment, datatypeSolutions);
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private Collection<String> getDatatypesUsed(Collection<Slot> solts) {
    Set<String> types = new TreeSet<>();
    for (Slot slot : solts) {
        if (slot instanceof ConstantSlot) {
            ConstantSlot constantSlot = (ConstantSlot) slot;
            AnnotationMirror anno = constantSlot.getValue();
            if (AnnotationUtils.areSameIgnoringValues(anno, DATAFLOW)) {
                String[] dataflowValues = DataflowUtils.getTypeNames(anno);
                for (String dataflowValue : dataflowValues) {
                    types.add(dataflowValue);
                }
            }
        }
    }
    return types;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private void getSubSupertypeFor2() {
    int num = 1;
    for (AnnotationMirror i : allTypes) {
        Set<AnnotationMirror> subtypeSet = new HashSet<AnnotationMirror>();
        Set<AnnotationMirror> supertypeSet = new HashSet<AnnotationMirror>();
        if (AnnotationUtils.areSame(i, this.top)) {
            subtypeSet.add(this.top);
            subtypeSet.add(this.bottom);
            supertypeSet.add(this.top);
        } else if (AnnotationUtils.areSame(i, this.bottom)) {
            subtypeSet.add(this.bottom);
            supertypeSet.add(this.bottom);
            supertypeSet.add(this.top);
        }
        this.subType.put(i, subtypeSet);
        this.superType.put(i, supertypeSet);
        this.modifierInt.put(i, num);
        this.IntModifier.put(num, i);
        num++;

    }
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private Map<AnnotationPair, AnnotationMirror>  calculateGlbs() {
    Map<AnnotationPair, AnnotationMirror> newglbs = new HashMap<AnnotationPair, AnnotationMirror>();
    for (AnnotationMirror a1 : supertypesGraph.keySet()) {
        for (AnnotationMirror a2 : supertypesGraph.keySet()) {
            if (AnnotationUtils.areSameIgnoringValues(a1, a2))
                continue;
            if (!AnnotationUtils.areSame(getTopAnnotation(a1), getTopAnnotation(a2)))
                continue;
            AnnotationPair pair = new AnnotationPair(a1, a2);
            if (newglbs.containsKey(pair))
                continue;
            AnnotationMirror glb = findGlb(a1, a2);
            newglbs.put(pair, glb);
        }
    }
    return newglbs;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
/**
 * Returns the type qualifiers that are the greatest lower bound of
 * the qualifiers in annos1 and annos2.
 *
 * The two qualifiers have to be from the same qualifier hierarchy. Otherwise,
 * null will be returned.
 *
 * <p>
 * This method works even if the underlying Java type is a type variable.
 * In that case, a 'null' AnnnotationMirror and the empty set represent a meaningful
 * value (namely, no annotation).
 *
 * @param annos1 First collection of qualifiers
 * @param annos2 Second collection of qualifiers
 * @return Greatest lower bound of the two collections of qualifiers
 */
public Set<? extends AnnotationMirror>
greatestLowerBoundsTypeVariable(Collection<? extends AnnotationMirror> annos1, Collection<? extends AnnotationMirror> annos2) {
    Set<AnnotationMirror> result = AnnotationUtils.createAnnotationSet();
    for (AnnotationMirror top : getTopAnnotations()) {
        AnnotationMirror anno1ForTop = null;
        for (AnnotationMirror anno1 : annos1) {
            if (isSubtypeTypeVariable(anno1, top)) {
                anno1ForTop = anno1;
            }
        }
        AnnotationMirror anno2ForTop = null;
        for (AnnotationMirror anno2 : annos2) {
            if (isSubtypeTypeVariable(anno2, top)) {
                anno2ForTop = anno2;
            }
        }
        AnnotationMirror t = greatestLowerBoundTypeVariable(anno1ForTop, anno2ForTop);
        if (t != null) {
            result.add(t);
        }
    }
    return result;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private static boolean bottomsOnly(Elements elements, AnnotatedTypeFactory atypeFactory,
        Set<AnnotationMirror> annotations) {
    Set<AnnotationMirror> bots = AnnotationUtils.createAnnotationSet();
    bots.addAll(atypeFactory.getQualifierHierarchy().getBottomAnnotations());

    // Return true if all the qualifiers that are present are
    // bottom qualifiers. Allow fewer qualifiers to be present,
    // which can happen for type variables and wildcards.
    boolean allbot = true;

    for (AnnotationMirror am : annotations) {
        if (!bots.remove(am)) {
            allbot = false;
        }
    }
    return allbot;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
/**
 * Returns a set of pairs {@code (expr, annotation)} of preconditions
 * according to the given {@link RequiresQualifier}.
 */
private Set<Pair<String, String>> getPrecondition(
        AnnotationMirror requiresAnnotation) {
    if (requiresAnnotation == null) {
        return Collections.emptySet();
    }
    Set<Pair<String, String>> result = new HashSet<>();
    List<String> expressions = AnnotationUtils.getElementValueArray(
            requiresAnnotation, "expression", String.class, false);
    String annotation = AnnotationUtils.getElementValueClassName(
            requiresAnnotation, "qualifier", false).toString();
    for (String expr : expressions) {
        result.add(Pair.of(expr, annotation));
    }
    return result;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
@Override
public Void visitMethod(MethodTree node, Void p) {
    if (TreeUtils.isConstructor(node)) {
        Collection<? extends AnnotationMirror> returnTypeAnnotations = getExplicitReturnTypeAnnotations(node);
        // check for invalid constructor return type
        for (Class<? extends Annotation> c : atypeFactory.getInvalidConstructorReturnTypeAnnotations()) {
            for (AnnotationMirror a : returnTypeAnnotations) {
                if (AnnotationUtils.areSameByClass(a, c)) {
                    checker.report(Result.failure(
                            COMMITMENT_INVALID_CONSTRUCTOR_RETURN_TYPE,
                            node), node);
                    break;
                }
            }
        }

        // Check that all fields have been initialized at the end of the
        // constructor.
        boolean isStatic = false;
        Store store = atypeFactory.getRegularExitStore(node);
        List<? extends AnnotationMirror> receiverAnnotations = getAllReceiverAnnotations(node);
        checkFieldsInitialized(node, isStatic, store, receiverAnnotations);
    }
    return super.visitMethod(node, p);
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
/**
 * Returns whether the field {@code f} is unused, given the annotations on
 * the receiver.
 */
private boolean isUnused(VariableTree field,
        Collection<? extends AnnotationMirror> receiverAnnos) {
    if (receiverAnnos.isEmpty()) {
        return false;
    }

    AnnotationMirror unused = getDeclAnnotation(
            TreeUtils.elementFromDeclaration(field), Unused.class);
    if (unused == null)
        return false;

    Name when = AnnotationUtils.getElementValueClassName(unused, "when",
            false);
    for (AnnotationMirror anno : receiverAnnos) {
        Name annoName = ((TypeElement) anno.getAnnotationType().asElement())
                .getQualifiedName();
        if (annoName.contentEquals(when)) {
            return true;
        }
    }

    return false;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
/**
 * Finds all the super qualifiers for a qualifier.
 *
 * @param anno
 * @param supertypesMap
 * @return
 */
private static Set<AnnotationMirror>
findAllSupers(AnnotationMirror anno,
        Map<AnnotationMirror, Set<AnnotationMirror>> supertypes,
        Map<AnnotationMirror, Set<AnnotationMirror>> allSupersSoFar) {
    Set<AnnotationMirror> supers = AnnotationUtils.createAnnotationSet();
    if (allSupersSoFar.containsKey(anno))
        return Collections.unmodifiableSet(allSupersSoFar.get(anno));

    // Updating the visited list before and after helps avoid
    // infinite loops. TODO: cleaner way?
    allSupersSoFar.put(anno, supers);

    for (AnnotationMirror superAnno : supertypes.get(anno)) {
        supers.add(superAnno);
        supers.addAll(findAllSupers(superAnno, supertypes, allSupersSoFar));
    }
    allSupersSoFar.put(anno, Collections.unmodifiableSet(supers));
    return supers;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private boolean keyForInMap(ExpressionTree key,
        Element mapElement, TreePath path) {
    AnnotatedTypeMirror keyForType = keyForFactory.getAnnotatedType(key);

    AnnotationMirror anno = keyForType.getAnnotation(KeyFor.class);
    if (anno == null)
        return false;

    List<String> maps = AnnotationUtils.getElementValueArray(anno, "value", String.class, false);
    for (String map: maps) {
        Element elt = resolver.findVariable(map, path);
        if (elt.equals(mapElement) &&
                !isSiteRequired(TreeUtils.getReceiverTree((ExpressionTree)path.getLeaf()), elt)) {
            return true;
        }
    }

    return false;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
public RegexAnnotatedTypeFactory(BaseTypeChecker checker) {
    super(checker);

    patternCompile = TreeUtils.getMethod("java.util.regex.Pattern", "compile", 1, processingEnv);
    partialRegexValue = TreeUtils.getMethod("org.checkerframework.checker.regex.qual.PartialRegex", "value", 0, processingEnv);

    REGEX = AnnotationUtils.fromClass(elements, Regex.class);
    REGEXBOTTOM = AnnotationUtils.fromClass(elements, RegexBottom.class);
    PARTIALREGEX = AnnotationUtils.fromClass(elements, PartialRegex.class);
    regexValueElement = TreeUtils.getMethod("org.checkerframework.checker.regex.qual.Regex", "value", 0, processingEnv);

    /*
    legalReferenceTypes = new TypeMirror[] {
        getTypeMirror("java.lang.CharSequence"),
        getTypeMirror("java.lang.Character"),
        getTypeMirror("java.util.regex.Pattern"),
        getTypeMirror("java.util.regex.MatchResult") };
     */

    this.postInit();
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
/**
 * Returns a set of pairs {@code (expr, annotation)} of postconditions
 * according to the given {@link EnsuresQualifier}.
 */
private Set<Pair<String, String>> getPostcondition(
        AnnotationMirror ensuresAnnotation) {
    if (ensuresAnnotation == null) {
        return Collections.emptySet();
    }
    Set<Pair<String, String>> result = new HashSet<>();
    List<String> expressions = AnnotationUtils.getElementValueArray(
            ensuresAnnotation, "expression", String.class, false);
    String annotation = AnnotationUtils.getElementValueClassName(
            ensuresAnnotation, "qualifier", false).toString();
    for (String expr : expressions) {
        result.add(Pair.of(expr, annotation));
    }
    return result;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
/**
 * Most qualifiers have no value fields.  However, two annotations with
 * values are subtype of each other only if they have the same values.
 * i.e. I(m) is a subtype of I(n) iff m = n
 *
 * When client specifies an annotation, a1, to be a subtype of annotation
 * with values, a2, then a1 is a subtype of all instances of a2 regardless
 * of a2 values.  i.e. IGJBottom is a subtype of all instances of
 * {@code @I}.
 *
 * @param rhs The right-hand side, i.e. the sub qualifier
 * @param lhs The left-hand side, i.e. the super qualifier
 */
@Override
public boolean isSubtype(AnnotationMirror rhs, AnnotationMirror lhs) {
    checkAnnoInGraph(rhs);
    checkAnnoInGraph(lhs);

    /* TODO: this optimization leads to recursion
    for (AnnotationMirror top : tops) {
        System.out.println("Looking at top: " + tops + " and " + anno1);
        // We cannot use getRootAnnotation, as that would use subtyping and recurse
        if (isSubtype(anno1, top) && AnnotationUtils.areSame(top, anno2))
        return true;
    }*/
    if (AnnotationUtils.areSameIgnoringValues(rhs, lhs))
        return AnnotationUtils.areSame(rhs, lhs);
    Set<AnnotationMirror> supermap1 = this.supertypesMap.get(rhs);
    return AnnotationUtils.containsSame(supermap1, lhs);
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
private void replaceItself(AnnotatedTypeMirror type, Tree tree) {
    if (tree.getKind() != Tree.Kind.IDENTIFIER
        && tree.getKind() != Tree.Kind.MEMBER_SELECT
        && tree.getKind() != Tree.Kind.METHOD_INVOCATION)
        return;
    ExpressionTree expr = (ExpressionTree)tree;

    if (!type.hasAnnotationRelaxed(GUARDED_BY))
        return;

    AnnotationMirror guardedBy = type.getAnnotation(GuardedBy.class);
    if (!"itself".equals(AnnotationUtils.getElementValue(guardedBy, "value", String.class, false)))
        return;

    AnnotationMirror newAnno = createGuarded(expr.toString());
    type.replaceAnnotation(newAnno);
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
protected List<String> methodHolding(ExecutableElement element) {
    AnnotationMirror holding = atypeFactory.getDeclAnnotation(element, Holding.class);
    AnnotationMirror guardedBy
        = atypeFactory.getDeclAnnotation(element, net.jcip.annotations.GuardedBy.class);
    if (holding == null && guardedBy == null)
        return Collections.emptyList();

    List<String> locks = new ArrayList<String>();

    if (holding != null) {
        List<String> holdingValue = AnnotationUtils.getElementValueArray(holding, "value", String.class, false);
        locks.addAll(holdingValue);
    }
    if (guardedBy != null) {
        String guardedByValue = AnnotationUtils.getElementValue(guardedBy, "value", String.class, false);
        locks.add(guardedByValue);
    }

    return locks;
}
 

import org.checkerframework.javacutil.AnnotationUtils; //导入依赖的package包/类
@Override
public Void visitMethod(MethodTree node, AnnotatedTypeMirror type) {
    AnnotatedTypeMirror.AnnotatedExecutableType methType = (AnnotatedTypeMirror.AnnotatedExecutableType)type;
    Effect e = getDeclaredEffect(methType.getElement());
    TypeElement cls = (TypeElement)methType.getElement().getEnclosingElement();

    // STEP 1: Get the method effect annotation
    if (!hasExplicitEffect(methType.getElement())) {
        // TODO: This line does nothing!
        // AnnotatedTypeMirror.addAnnotation silently ignores non-qualifier annotations!
        // We should be digging up the /declaration/ of the method, and annotating that.
        methType.addAnnotation(e.getAnnot());
    }

    // STEP 2: Fix up the method receiver annotation
    AnnotatedTypeMirror.AnnotatedDeclaredType receiverType = methType.getReceiverType();
    if (receiverType != null &&
            !receiverType.isAnnotatedInHierarchy(AnnotationUtils.fromClass(elements, UI.class))) {
        receiverType.addAnnotation(isPolymorphicType(cls) ? PolyUI.class :
            fromElement(cls).hasAnnotation(UI.class) ? UI.class : AlwaysSafe.class );
    }
    return super.visitMethod(node, type);
}