Method canMean

src/main/java/org/codehaus/groovy/syntax/Types.java:1018–1064

Determines if a type can be interpreted as another type. This is orthogonal to #ofType(int, int) and is used for semantic flexibility (e.g., an identifier can be viewed as a class name). @param actual the actual type being checked @param preferred the desired interpretation @return {@code t

(int actual, int preferred)

     * @return {@code true} if the actual type can be reinterpreted as the preferred type
     */
    public static boolean canMean(int actual, int preferred) {

        if (actual == preferred) {
            return true;
        }

        switch (preferred) {

            case SYNTH_PARAMETER_DECLARATION:
            case IDENTIFIER:
                switch (actual) {
                    case IDENTIFIER:
                    case KEYWORD_DEF:
                    case KEYWORD_DEFMACRO:
                    case KEYWORD_CLASS:
                    case KEYWORD_INTERFACE:
                    case KEYWORD_MIXIN:
                        return true;
                }
                break;

            case SYNTH_CLASS:
            case SYNTH_INTERFACE:
            case SYNTH_MIXIN:
            case SYNTH_METHOD:
            case SYNTH_PROPERTY:

            case SYNTH_VARIABLE_DECLARATION:
                return actual == IDENTIFIER;

            case SYNTH_LIST:
            case SYNTH_MAP:
                return actual == LEFT_SQUARE_BRACKET;

            case SYNTH_CAST:
                return actual == LEFT_PARENTHESIS;

            case SYNTH_BLOCK:
            case SYNTH_CLOSURE:
                return actual == LEFT_CURLY_BRACE;

            case SYNTH_LABEL:
                return actual == COLON;
        }

        return false;
    }

    /**
     * Converts an operator node's meaning to a prefix operator variant.