Java TokenTypes.ENUM_CONSTANT_DEF属性代码示例

/**
 * 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;
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        TokenTypes.METHOD_CALL,
        TokenTypes.CLASS_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_TRY,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.PARAMETER_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.SLIST,
        TokenTypes.ENUM_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_NEW,
    };
}
 

@Test
public void testGetRequiredTokens() {
    final UnusedImportsCheck testCheckObject =
            new UnusedImportsCheck();
    final int[] actual = testCheckObject.getRequiredTokens();
    final int[] expected = {
        TokenTypes.IDENT,
        TokenTypes.IMPORT,
        TokenTypes.STATIC_IMPORT,
        // Definitions that may contain Javadoc...
        TokenTypes.PACKAGE_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ANNOTATION_FIELD_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.VARIABLE_DEF,
    };

    assertArrayEquals("Default required tokens are invalid", expected, actual);
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.INTERFACE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.STATIC_INIT,
        TokenTypes.OBJBLOCK,
        TokenTypes.LAMBDA,
    };
}
 

/**
 * Gets the AST that holds a series of annotations for the
 * potentially annotated AST.  Returns {@code null}
 * the passed in AST is not have an Annotation Holder.
 *
 * @param ast the current node
 * @return the Annotation Holder
 */
public static DetailAST getAnnotationHolder(DetailAST ast) {
    if (ast == null) {
        throw new IllegalArgumentException(THE_AST_IS_NULL);
    }

    final DetailAST annotationHolder;

    if (ast.getType() == TokenTypes.ENUM_CONSTANT_DEF
        || ast.getType() == TokenTypes.PACKAGE_DEF) {
        annotationHolder = ast.findFirstToken(TokenTypes.ANNOTATIONS);
    }
    else {
        annotationHolder = ast.findFirstToken(TokenTypes.MODIFIERS);
    }

    return annotationHolder;
}
 

/**
 * Returns array of acceptable tokens.
 * @return acceptableTokens.
 */
private static int[] makeAcceptableTokens() {
    return new int[] {TokenTypes.ANNOTATION,
        TokenTypes.ANNOTATION_FIELD_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.CTOR_DEF,
        TokenTypes.DOT,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.EXPR,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_NEW,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.METHOD_CALL,
        TokenTypes.METHOD_DEF,
        TokenTypes.QUESTION,
        TokenTypes.RESOURCE_SPECIFICATION,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LAMBDA,
    };
}
 

@Test
public void testGetAcceptableTokens() {
    final UnusedImportsCheck testCheckObject =
            new UnusedImportsCheck();
    final int[] actual = testCheckObject.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.IDENT,
        TokenTypes.IMPORT,
        TokenTypes.STATIC_IMPORT,
        // Definitions that may contain Javadoc...
        TokenTypes.PACKAGE_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ANNOTATION_FIELD_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.VARIABLE_DEF,
    };

    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

@Test
public void testGetAcceptableTokens() {
    final LeftCurlyCheck check = new LeftCurlyCheck();
    final int[] actual = check.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.INTERFACE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.STATIC_INIT,
        TokenTypes.OBJBLOCK,
        TokenTypes.LAMBDA, };
    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

/**
 * 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;
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.VARIABLE_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
    };
}
 

@Test
public void testGetAcceptableTokens() {
    final MethodParamPadCheck methodParamPadCheckObj = new MethodParamPadCheck();
    final int[] actual = methodParamPadCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CTOR_DEF,
        TokenTypes.LITERAL_NEW,
        TokenTypes.METHOD_CALL,
        TokenTypes.METHOD_DEF,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.ENUM_CONSTANT_DEF,
    };
    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.VARIABLE_DEF,
        TokenTypes.PARAMETER_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LAMBDA,
    };
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        TokenTypes.CLASS_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
    };
}
 

@Override
public void leaveToken(DetailAST ast) {
    if (ast.getType() == TokenTypes.CLASS_DEF
        || ast.getType() == TokenTypes.ENUM_DEF
        || ast.getType() == TokenTypes.ENUM_CONSTANT_DEF) {
        //pop
        frame = frame.getParent();
    }
}
 

@Override
protected IndentLevel getIndentImpl() {
    final DetailAST parentAST = getMainAst().getParent();
    IndentLevel indent = getParent().getIndent();
    if (parentAST.getType() == TokenTypes.LITERAL_NEW) {
        indent.addAcceptedIndent(super.getIndentImpl());
    }
    else if (parentAST.getType() == TokenTypes.ENUM_CONSTANT_DEF) {
        indent = super.getIndentImpl();
    }
    return indent;
}