import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Tests whether the scope of a field or method is compatible
 * with the scope of this check. References for compatible
 * fields or methods should be checked.
 * @param aFieldOrMethod the field or method to check.
 * @return true if the scope of aFieldOrMethod is compatible
 * with the scope of this check.
 */
private boolean equalScope(FieldOrMethod aFieldOrMethod)
{
    if (aFieldOrMethod.isPrivate()) {
        return (mScope == Scope.PRIVATE);
    }
    else if (aFieldOrMethod.isProtected()) {
        return (mScope == Scope.PROTECTED);
    }
    else if (aFieldOrMethod.isPublic()) {
        return (mScope == Scope.PUBLIC);
    }
    else {
        return (mScope == Scope.PACKAGE);
    }
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Determines whether the declared scope of a field or method is in
 * a set of scopes.
 * @param aFieldOrMethod the field or method to test.
 * @param aScopes the set of scopes to test against.
 * @return true if the declared scope of aFieldOrMethod is in aScopes.
 */
public static boolean inScope(FieldOrMethod aFieldOrMethod, Set aScopes)
{
    if (aFieldOrMethod.isPrivate()) {
        return (aScopes.contains(Scope.PRIVATE));
    }
    else if (aFieldOrMethod.isProtected()) {
        return (aScopes.contains(Scope.PROTECTED));
    }
    else if (aFieldOrMethod.isPublic()) {
        return (aScopes.contains(Scope.PUBLIC));
    }
    else {
        return (aScopes.contains(Scope.PACKAGE));
    }
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Determines whether an AST node is in a static method or static
 * initializer.
 * @param ast the node to check.
 * @return true if ast is in a static method or a static block;
 */
private static boolean isInStatic(DetailAST ast) {
    DetailAST parent = ast.getParent();
    boolean inStatic = false;

    while (parent != null && !inStatic) {
        if (parent.getType() == TokenTypes.STATIC_INIT) {
            inStatic = true;
        }
        else if (parent.getType() == TokenTypes.METHOD_DEF
                    && !ScopeUtils.isInScope(parent, Scope.ANONINNER)
                    || parent.getType() == TokenTypes.VARIABLE_DEF) {
            final DetailAST mods =
                parent.findFirstToken(TokenTypes.MODIFIERS);
            inStatic = mods.findFirstToken(TokenTypes.LITERAL_STATIC) != null;
            break;
        }
        else {
            parent = parent.getParent();
        }
    }
    return inStatic;
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Whether we should check this node.
 * @param ast a given node.
 * @return whether we should check a given node.
 */
private boolean shouldCheck(final DetailAST ast) {
    final Scope customScope;

    if (ScopeUtils.isInInterfaceOrAnnotationBlock(ast)) {
        customScope = Scope.PUBLIC;
    }
    else {
        final DetailAST mods = ast.findFirstToken(TokenTypes.MODIFIERS);
        customScope = ScopeUtils.getScopeFromMods(mods);
    }
    final Scope surroundingScope = ScopeUtils.getSurroundingScope(ast);

    return customScope.isIn(scope)
        && (surroundingScope == null || surroundingScope.isIn(scope))
        && (excludeScope == null
            || !customScope.isIn(excludeScope)
            || surroundingScope != null
            && !surroundingScope.isIn(excludeScope));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Whether we should check this node.
 * @param ast a given node.
 * @return whether we should check a given node.
 */
private boolean shouldCheck(final DetailAST ast) {
    boolean result = false;
    if (!ScopeUtils.isInCodeBlock(ast) && !isIgnored(ast)) {
        Scope customScope = Scope.PUBLIC;
        if (ast.getType() != TokenTypes.ENUM_CONSTANT_DEF
                && !ScopeUtils.isInInterfaceOrAnnotationBlock(ast)) {
            final DetailAST mods = ast.findFirstToken(TokenTypes.MODIFIERS);
            customScope = ScopeUtils.getScopeFromMods(mods);
        }

        final Scope surroundingScope = ScopeUtils.getSurroundingScope(ast);
        result = customScope.isIn(scope) && surroundingScope.isIn(scope)
            && (excludeScope == null
                || !customScope.isIn(excludeScope)
                || !surroundingScope.isIn(excludeScope));
    }
    return result;
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
@Override
protected final void processAST(DetailAST ast) {
    final Scope theScope = calculateScope(ast);
    if (shouldCheck(ast, theScope)) {
        final FileContents contents = getFileContents();
        final TextBlock textBlock = contents.getJavadocBefore(ast.getLineNo());

        if (textBlock == null) {
            if (!isMissingJavadocAllowed(ast)) {
                log(ast, MSG_JAVADOC_MISSING);
            }
        }
        else {
            checkComment(ast, textBlock);
        }
    }
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Returns the Scope specified by the modifier set.
 *
 * @param aMods root node of a modifier set
 * @return a {@code Scope} value
 */
public static Scope getScopeFromMods(DetailAST aMods) {
    // default scope
    Scope returnValue = Scope.PACKAGE;
    for (AST token = aMods.getFirstChild(); token != null
            && returnValue == Scope.PACKAGE;
            token = token.getNextSibling()) {
        if ("public".equals(token.getText())) {
            returnValue = Scope.PUBLIC;
        }
        else if ("protected".equals(token.getText())) {
            returnValue = Scope.PROTECTED;
        }
        else if ("private".equals(token.getText())) {
            returnValue = Scope.PRIVATE;
        }
    }
    return returnValue;
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
@Test
public void testExcludeScope() throws Exception {
    final DefaultConfiguration checkConfig =
        createModuleConfig(JavadocTypeCheck.class);
    checkConfig.addAttribute("scope", Scope.PRIVATE.getName());
    checkConfig.addAttribute("excludeScope", Scope.PROTECTED.getName());
    final String[] expected = {
        "27: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "39: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "52: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "63: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "75: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "87: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "99: " + getCheckMessage(MSG_JAVADOC_MISSING),
        "111: " + getCheckMessage(MSG_JAVADOC_MISSING),
    };
    verify(checkConfig,
           getPath("InputJavadocTypeNoJavadoc.java"),
           expected);
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
@Test
public void testSurroundingScope() {
    assertEquals("Invalid surrounding scope",
            Scope.PUBLIC, ScopeUtils.getSurroundingScope(getNodeWithParentScope(
        TokenTypes.LITERAL_PUBLIC, "public", TokenTypes.ANNOTATION_DEF)));
    assertEquals("Invalid surrounding scope",
            Scope.PROTECTED, ScopeUtils.getSurroundingScope(
        getNodeWithParentScope(TokenTypes.LITERAL_PROTECTED, "protected",
        TokenTypes.INTERFACE_DEF)));
    assertEquals("Invalid surrounding scope",
            Scope.PRIVATE, ScopeUtils.getSurroundingScope(
        getNodeWithParentScope(TokenTypes.LITERAL_PRIVATE, "private", TokenTypes.ENUM_DEF)));
    assertEquals("Invalid surrounding scope",
            Scope.PACKAGE, ScopeUtils.getSurroundingScope(
        getNodeWithParentScope(TokenTypes.LITERAL_STATIC, "static", TokenTypes.CLASS_DEF)));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Whether we should check this node.
 * 
 * @param aAST
 *            a given node.
 * @return whether we should check a given node.
 */
private boolean shouldCheck(final DetailAST aAST) {
    if (ScopeUtils.inCodeBlock(aAST)) {
        return false;
    }

    final Scope scope;
    if (aAST.getType() == TokenTypes.ENUM_CONSTANT_DEF) {
        scope = Scope.PUBLIC;
    } else {
        final DetailAST mods = aAST.findFirstToken(TokenTypes.MODIFIERS);
        final Scope declaredScope = ScopeUtils.getScopeFromMods(mods);
        scope = ScopeUtils.inInterfaceOrAnnotationBlock(aAST) ? Scope.PUBLIC : declaredScope;
    }

    final Scope surroundingScope = ScopeUtils.getSurroundingScope(aAST);

    return Utilities.isExportedPackage(aAST) && scope.isIn(mScope) && surroundingScope.isIn(mScope)
            && ((mExcludeScope == null) || !scope.isIn(mExcludeScope) || !surroundingScope.isIn(mExcludeScope));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/** @see AbstractReferenceCheck */
public void setScope(String aFrom)
{
    super.setScope(aFrom);
    ((ReferenceVisitor) getVisitor()).addFieldScope(
        Scope.getInstance(aFrom));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/** @see AbstractReferenceCheck */
public void setScope(String aScopeName)
{
    super.setScope(aScopeName);
    ((ReferenceVisitor) getVisitor()).addMethodScope(
        Scope.getInstance(aScopeName));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/** @see com.puppycrawl.tools.checkstyle.checks.usage.AbstractUsageCheck */
public boolean mustCheckReferenceCount(DetailAST aAST)
{
    final DetailAST mods = aAST.findFirstToken(TokenTypes.MODIFIERS);
    return ((mods != null)
        && (ScopeUtils.getScopeFromMods(mods) == Scope.PRIVATE));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/** @see com.puppycrawl.tools.checkstyle.checks.usage.AbstractUsageCheck */
public boolean mustCheckReferenceCount(DetailAST aAST)
{
    final DetailAST mods = aAST.findFirstToken(TokenTypes.MODIFIERS);
    if ((mods == null)
        || (ScopeUtils.getScopeFromMods(mods) != Scope.PRIVATE))
    {
        return false;
    }

    return !mAllowSerializationMethods
           || !(isWriteObject(aAST) || isReadObject(aAST)
                || isWriteReplaceOrReadResolve(aAST));
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Determine the visibility modifier and raise the corresponding counter.
 * @param method
 *            The method-subtree from the AbstractSyntaxTree.
 */
private void raiseCounter(DetailAST method) {
    final MethodCounter actualCounter = counters.peek();
    final DetailAST temp = method.findFirstToken(TokenTypes.MODIFIERS);
    final Scope scope = ScopeUtils.getScopeFromMods(temp);
    actualCounter.increment(scope);
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Check the counters and report violations.
 * @param counter the method counters to check
 * @param ast to report errors against.
 */
private void checkCounters(MethodCounter counter, DetailAST ast) {
    checkMax(maxPrivate, counter.value(Scope.PRIVATE),
             MSG_PRIVATE_METHODS, ast);
    checkMax(maxPackage, counter.value(Scope.PACKAGE),
             MSG_PACKAGE_METHODS, ast);
    checkMax(maxProtected, counter.value(Scope.PROTECTED),
             MSG_PROTECTED_METHODS, ast);
    checkMax(maxPublic, counter.value(Scope.PUBLIC),
             MSG_PUBLIC_METHODS, ast);
    checkMax(maxTotal, counter.getTotal(), MSG_MANY_METHODS, ast);
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Increments to counter by one for the supplied scope.
 * @param scope the scope counter to increment.
 */
private void increment(Scope scope) {
    total++;
    if (inInterface) {
        counts.put(Scope.PUBLIC, 1 + value(Scope.PUBLIC));
    }
    else {
        counts.put(scope, 1 + value(scope));
    }
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Process if given modifiers are appropriate in given state
 * ({@code STATE_STATIC_VARIABLE_DEF}, {@code STATE_INSTANCE_VARIABLE_DEF},
 * ({@code STATE_CTOR_DEF}, {@code STATE_METHOD_DEF}), if it is
 * it updates states where appropriate or logs violation.
 * @param modifierAst modifiers to process
 * @param state current state
 * @return true if modifierAst is valid in given state, false otherwise
 */
private boolean processModifiersState(DetailAST modifierAst, ScopeState state) {
    boolean isStateValid = true;
    if (modifierAst.findFirstToken(TokenTypes.LITERAL_STATIC) == null) {
        if (state.currentScopeState > STATE_INSTANCE_VARIABLE_DEF) {
            isStateValid = false;
            log(modifierAst, MSG_INSTANCE);
        }
        else if (state.currentScopeState == STATE_STATIC_VARIABLE_DEF) {
            state.declarationAccess = Scope.PUBLIC;
            state.currentScopeState = STATE_INSTANCE_VARIABLE_DEF;
        }
    }
    else {
        if (state.currentScopeState > STATE_STATIC_VARIABLE_DEF) {
            if (!ignoreModifiers
                    || state.currentScopeState > STATE_INSTANCE_VARIABLE_DEF) {
                isStateValid = false;
                log(modifierAst, MSG_STATIC);
            }
        }
        else {
            state.currentScopeState = STATE_STATIC_VARIABLE_DEF;
        }
    }
    return isStateValid;
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Checks if given modifiers are valid in substate of given
 * state({@code Scope}), if it is it updates substate or else it
 * logs violation.
 * @param modifiersAst modifiers to process
 * @param state current state
 * @param isStateValid is main state for given modifiers is valid
 */
private void processModifiersSubState(DetailAST modifiersAst, ScopeState state,
                                      boolean isStateValid) {
    final Scope access = ScopeUtils.getScopeFromMods(modifiersAst);
    if (state.declarationAccess.compareTo(access) > 0) {
        if (isStateValid
                && !ignoreModifiers
                && !isForwardReference(modifiersAst.getParent())) {
            log(modifiersAst, MSG_ACCESS);
        }
    }
    else {
        state.declarationAccess = access;
    }
}
 

import com.puppycrawl.tools.checkstyle.api.Scope; //导入依赖的package包/类
/**
 * Whether we should check this node.
 * @param ast a given node.
 * @return whether we should check a given node.
 */
private boolean shouldCheck(final DetailAST ast) {
    boolean check = false;

    if (ast.getType() == TokenTypes.PACKAGE_DEF) {
        check = getFileContents().inPackageInfo();
    }
    else if (!ScopeUtils.isInCodeBlock(ast)) {
        final Scope customScope;

        if (ScopeUtils.isInInterfaceOrAnnotationBlock(ast)
                || ast.getType() == TokenTypes.ENUM_CONSTANT_DEF) {
            customScope = Scope.PUBLIC;
        }
        else {
            customScope = ScopeUtils.getScopeFromMods(ast.findFirstToken(TokenTypes.MODIFIERS));
        }
        final Scope surroundingScope = ScopeUtils.getSurroundingScope(ast);

        check = customScope.isIn(scope)
                && (surroundingScope == null || surroundingScope.isIn(scope))
                && (excludeScope == null
                    || !customScope.isIn(excludeScope)
                    || surroundingScope != null
                        && !surroundingScope.isIn(excludeScope));
    }
    return check;
}