Java TokenTypes.COMMA属性代码示例

/**
 * Resolves the types found in a method call. Any references found
 * in the process are created.  Returns a <code>MethodSignature</code> for
 * the types of the parameters.
 *
 * @param elist The <code>SymTabAST</code> for the list of parameters
 * @return the signature of the parameters
 */
private MethodSignature resolveParameters(
    SymTabAST elist,
    Scope location,
    IClass context,
    boolean referencePhase) {
    Vector parameters = new Vector();

    SymTabAST expr = (SymTabAST) (elist.getFirstChild());
    while (expr != null) {
        if (expr.getType() != TokenTypes.COMMA) {
            IClass parameter =
                resolveExpression((SymTabAST) (expr
    .getFirstChild()),
    location,
    context,
    referencePhase);
            parameters.add(parameter);
        }

        expr = (SymTabAST) (expr.getNextSibling());
    }

    return new MethodSignature(parameters);
}
 

/**
 * Logs a trailing array comma violation if one exists.
 *
 * @param ast the array init
 * {@link TokenTypes#ANNOTATION_ARRAY_INIT ANNOTATION_ARRAY_INIT}.
 */
private void logCommaViolation(final DetailAST ast) {
    final DetailAST rCurly = ast.findFirstToken(TokenTypes.RCURLY);

    //comma can be null if array is empty
    final DetailAST comma = rCurly.getPreviousSibling();

    if (trailingArrayComma == TrailingArrayComma.ALWAYS
        && (comma == null || comma.getType() != TokenTypes.COMMA)) {
        log(rCurly.getLineNo(),
            rCurly.getColumnNo(), MSG_KEY_ANNOTATION_TRAILING_COMMA_MISSING);
    }
    else if (trailingArrayComma == TrailingArrayComma.NEVER
        && comma != null && comma.getType() == TokenTypes.COMMA) {
        log(comma.getLineNo(),
            comma.getColumnNo(), MSG_KEY_ANNOTATION_TRAILING_COMMA_PRESENT);
    }
}
 

/**
 * Checks if a variable definition is countable.
 *
 * @param ast the AST
 * @return true if the variable definition is countable, false otherwise
 */
private static boolean isVariableDefCountable(DetailAST ast) {
    boolean countable = false;

    //count variable definitions only if they are direct child to a slist or
    // object block
    final int parentType = ast.getParent().getType();

    if (parentType == TokenTypes.SLIST
        || parentType == TokenTypes.OBJBLOCK) {
        final DetailAST prevSibling = ast.getPreviousSibling();

        //is countable if no previous sibling is found or
        //the sibling is no COMMA.
        //This is done because multiple assignment on one line are counted
        // as 1
        countable = prevSibling == null
                || prevSibling.getType() != TokenTypes.COMMA;
    }

    return countable;
}
 

@Override
public void visitToken(DetailAST detailAST) {
    final DetailAST methodDef = detailAST.getParent();
    // Check if the method with the given name should be ignored.
    if (!isIgnorableMethod(methodDef)) {
        DetailAST token = detailAST.getFirstChild();
        while (token != null) {
            if (token.getType() != TokenTypes.COMMA) {
                final FullIdent ident = FullIdent.createFullIdent(token);
                if (illegalClassNames.contains(ident.getText())) {
                    log(token, MSG_KEY, ident.getText());
                }
            }
            token = token.getNextSibling();
        }
    }
}
 

/**
 * Collects validation details for Lambdas.
 * @param ast a {@code DetailAST} value
 * @return an object containing all details to make a validation
 */
private static Details getDetailsForLambda(DetailAST ast) {
    final DetailAST lcurly = ast.findFirstToken(TokenTypes.SLIST);
    boolean shouldCheckLastRcurly = false;
    DetailAST nextToken = getNextToken(ast);
    if (nextToken.getType() != TokenTypes.RPAREN
            && nextToken.getType() != TokenTypes.COMMA) {
        shouldCheckLastRcurly = true;
        nextToken = getNextToken(nextToken);
    }
    DetailAST rcurly = null;
    if (lcurly != null) {
        rcurly = lcurly.getLastChild();
    }
    return new Details(lcurly, rcurly, nextToken, shouldCheckLastRcurly);
}
 

/**
 * Returns a list of type parameters class names.
 * @param typeArgs type arguments token.
 * @return a list of type parameters class names.
 */
private static List<String> getTypeArgsClassNames(DetailAST typeArgs) {
    final List<String> typeClassNames = new ArrayList<String>();
    DetailAST type = typeArgs.findFirstToken(TokenTypes.TYPE_ARGUMENT);
    boolean isCanonicalName = isCanonicalName(type);
    String typeName = getTypeName(type, isCanonicalName);
    typeClassNames.add(typeName);
    DetailAST sibling = type.getNextSibling();
    while (sibling.getType() == TokenTypes.COMMA) {
        type = sibling.getNextSibling();
        isCanonicalName = isCanonicalName(type);
        typeName = getTypeName(type, isCanonicalName);
        typeClassNames.add(typeName);
        sibling = type.getNextSibling();
    }
    return typeClassNames;
}
 

/**
 * processes a <code>MethodDef</code> and resolves references in it
 *
 * @param method the <code>MethodDef</code> to process
 */
protected void handleMethod(MethodDef method) {
    SymTabAST node = method.getTreeNode();

    SymTabAST nameNode = node.findFirstToken(TokenTypes.IDENT);
    nameNode.setDefinition(method, method, true);

    // references to classes in return type
    SymTabAST returnTypeNode = node.findFirstToken(TokenTypes.TYPE);

    if (returnTypeNode != null) {
        // this is not a constructor
        resolveExpression(returnTypeNode, method, null, true);
    }

    SymTabAST throwsNode =
        node.findFirstToken(TokenTypes.LITERAL_THROWS);
    if (throwsNode != null) {
        SymTabAST exception = (SymTabAST) throwsNode.getFirstChild();
        while (exception != null) {
            // handle Checkstyle grammar
            if (exception.getType() != TokenTypes.COMMA) {
                resolveClass(exception, method, null, true);
            }
            exception = (SymTabAST) exception.getNextSibling();
        }
    }

    // references to classes in parameters

    // the body -- this would be better its own function
    SymTabAST slist = node.findFirstToken(TokenTypes.SLIST);

    if (slist != null) {
        handleSList(slist, method);
    }
}
 

/**
 * Resolves a constructor call.
 *
 * @param tree the root node of the constructor call
 * @return the <code>ClassDef</code> for the class instantiated by the
 *         constructor
 */
private void resolveArrayInitializer(
    SymTabAST initializerNode,
    Scope location,
    IClass context,
    boolean referencePhase) {
    SymTabAST child = (SymTabAST) (initializerNode.getFirstChild());
    while (child != null) {
        if (child.getType() != TokenTypes.COMMA) {
            resolveExpression(child, location, context, referencePhase);
        }
        child = (SymTabAST) (child.getNextSibling());
    }
}
 

/**
 * Visits throws clause and collects all exceptions we throw.
 * @param literalThrows throws to process.
 */
public void visitLiteralThrows(DetailAST literalThrows) {
    for (DetailAST childAST = literalThrows.getFirstChild();
         childAST != null;
         childAST = childAST.getNextSibling()) {
        if (childAST.getType() != TokenTypes.COMMA) {
            addReferencedClassName(childAST);
        }
    }
}
 

@Override
public void visitToken(DetailAST ast) {
    DetailAST nextNode = ast.getNextSibling();

    if (nextNode != null) {
        final boolean isCommaSeparated = nextNode.getType() == TokenTypes.COMMA;

        if (isCommaSeparated
            || nextNode.getType() == TokenTypes.SEMI) {
            nextNode = nextNode.getNextSibling();
        }

        if (nextNode != null
                && nextNode.getType() == TokenTypes.VARIABLE_DEF) {
            final DetailAST firstNode = CheckUtils.getFirstNode(ast);
            if (isCommaSeparated) {
                // Check if the multiple variable declarations are in a
                // for loop initializer. If they are, then no warning
                // should be displayed. Declaring multiple variables in
                // a for loop initializer is a good way to minimize
                // variable scope. Refer Feature Request Id - 2895985
                // for more details
                if (ast.getParent().getType() != TokenTypes.FOR_INIT) {
                    log(firstNode, MSG_MULTIPLE_COMMA);
                }
            }
            else {
                final DetailAST lastNode = getLastNode(ast);
                final DetailAST firstNextNode = CheckUtils.getFirstNode(nextNode);

                if (firstNextNode.getLineNo() == lastNode.getLineNo()) {
                    log(firstNode, MSG_MULTIPLE);
                }
            }
        }
    }
}
 

@Override
public void visitToken(DetailAST arrayInit) {
    final DetailAST rcurly = arrayInit.findFirstToken(TokenTypes.RCURLY);
    final DetailAST previousSibling = rcurly.getPreviousSibling();

    if (arrayInit.getLineNo() != rcurly.getLineNo()
            && arrayInit.getChildCount() != 1
            && rcurly.getLineNo() != previousSibling.getLineNo()
            && arrayInit.getLineNo() != previousSibling.getLineNo()
            && previousSibling.getType() != TokenTypes.COMMA) {
        log(rcurly.getLineNo(), MSG_KEY);
    }
}
 

@Override
public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.COMMA,
        TokenTypes.SEMI,
        TokenTypes.POST_INC,
        TokenTypes.POST_DEC,
        TokenTypes.ELLIPSIS,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.COMMA,
        TokenTypes.SEMI,
        TokenTypes.POST_INC,
        TokenTypes.POST_DEC,
        TokenTypes.DOT,
        TokenTypes.GENERIC_START,
        TokenTypes.GENERIC_END,
        TokenTypes.ELLIPSIS,
        TokenTypes.METHOD_REF,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.COMMA,
        TokenTypes.SEMI,
        TokenTypes.TYPECAST,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.DO_WHILE,
    };
}
 

@Override
public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.DOT,
        TokenTypes.COMMA,
    };
}