com.sun.tools.javac.code.Symbol.OperatorSymbol Java Examples

/** Enter a unary operation into symbol table.
 *  @param name     The name of the operator.
 *  @param arg      The type of the operand.
 *  @param res      The operation's result type.
 *  @param opcode   The operation's bytecode instruction.
 */
private OperatorSymbol enterUnop(String name,
                                 Type arg,
                                 Type res,
                                 int opcode) {
    OperatorSymbol sym =
        new OperatorSymbol(names.fromString(name),
                           new MethodType(List.of(arg),
                                          res,
                                          List.<Type>nil(),
                                          methodClass),
                           opcode,
                           predefClass);
    predefClass.members().enter(sym);
    return sym;
}
 

/** Enter a unary operation into symbol table.
 *  @param name     The name of the operator.
 *  @param arg      The type of the operand.
 *  @param res      The operation's result type.
 *  @param opcode   The operation's bytecode instruction.
 */
private OperatorSymbol enterUnop(String name,
                                 Type arg,
                                 Type res,
                                 int opcode) {
    OperatorSymbol sym =
        new OperatorSymbol(names.fromString(name),
                           new MethodType(List.of(arg),
                                          res,
                                          List.<Type>nil(),
                                          methodClass),
                           opcode,
                           predefClass);
    predefClass.members().enter(sym);
    return sym;
}
 

OperatorSymbol lookupBinaryOp(Predicate<OperatorSymbol> applicabilityTest) {
    return binaryOperators.values().stream()
            .flatMap(List::stream)
            .map(helper -> helper.doLookup(applicabilityTest))
            .distinct()
            .filter(sym -> sym != noOpSymbol)
            .findFirst().get();
}
 

/** Enter a binary operation into symbol table.
 *  @param name     The name of the operator.
 *  @param left     The type of the left operand.
 *  @param right    The type of the left operand.
 *  @param res      The operation's result type.
 *  @param opcode   The operation's bytecode instruction.
 */
private void enterBinop(String name,
                        Type left, Type right, Type res,
                        int opcode) {
    predefClass.members().enter(
        new OperatorSymbol(
            names.fromString(name),
            new MethodType(List.of(left, right), res,
                           List.<Type>nil(), methodClass),
            opcode,
            predefClass));
}
 

@Override
public OperatorSymbol resolve(Type t1, Type t2) {
    ComparisonKind kind = getKind(t1, t2);
    Type t = (kind == ComparisonKind.NUMERIC_OR_BOOLEAN) ?
            binaryPromotion(t1, t2) :
            syms.objectType;
    return doLookup(t, t);
}
 

/**
 * This routine performs lazy instantiation of the operator symbols supported by this helper.
 * After initialization is done, the suppliers are cleared, to free up memory.
 */
private OperatorSymbol[] initOperators() {
    OperatorSymbol[] operators = operatorSuppliers.stream()
            .map(Supplier::get)
            .toArray(OperatorSymbol[]::new);
    alternatives = Optional.of(operators);
    operatorSuppliers = null; //let GC do its work
    return operators;
}
 

/**
 * This routine implements the main operator lookup process. Each operator is tested
 * using an applicability predicate; if the test suceeds that same operator is returned,
 * otherwise a dummy symbol is returned.
 */
final OperatorSymbol doLookup(Predicate<OperatorSymbol> applicabilityTest) {
    return Stream.of(alternatives.orElseGet(this::initOperators))
            .filter(applicabilityTest)
            .findFirst()
            .orElse(noOpSymbol);
}
 

/**
 * Report an operator lookup error.
 */
private OperatorSymbol reportErrorIfNeeded(DiagnosticPosition pos, Tag tag, Type... args) {
    if (Stream.of(args).noneMatch(Type::isErroneous)) {
        Name opName = operatorName(tag);
        JCDiagnostic.Error opError = (args.length) == 1 ?
                Errors.OperatorCantBeApplied(opName, args[0]) :
                Errors.OperatorCantBeApplied1(opName, args[0], args[1]);
        log.error(pos, opError);
    }
    return noOpSymbol;
}
 

/**
 * Creates an operator symbol.
 */
private OperatorSymbol makeOperator(Name name, List<OperatorType> formals, OperatorType res, int... opcodes) {
    MethodType opType = new MethodType(
            formals.stream()
                    .map(o -> o.asType(syms))
                    .collect(List.collector()),
            res.asType(syms), List.nil(), syms.methodClass);
    return new OperatorSymbol(name, opType, mergeOpcodes(opcodes), syms.noSymbol);
}
 

/**
 * Main operator lookup routine; lookup an operator (either unary or binary) in its corresponding
 * map. If there's a matching operator, its resolve routine is called and the result is returned;
 * otherwise the result of a fallback function is returned.
 */
private <O> OperatorSymbol resolve(Tag tag, Map<Name, List<O>> opMap, Predicate<O> opTestFunc,
                   Function<O, OperatorSymbol> resolveFunc, Supplier<OperatorSymbol> noResultFunc) {
    return opMap.get(operatorName(tag)).stream()
            .filter(opTestFunc)
            .map(resolveFunc)
            .findFirst()
            .orElseGet(noResultFunc);
}
 

/**
 * Entry point for resolving a binary operator given an operator tag and a pair of argument types.
 */
OperatorSymbol resolveBinary(DiagnosticPosition pos, JCTree.Tag tag, Type op1, Type op2) {
    return resolve(tag,
            binaryOperators,
            binop -> binop.test(op1, op2),
            binop -> binop.resolve(op1, op2),
            () -> reportErrorIfNeeded(pos, tag, op1, op2));
}
 

/**
 * Entry point for resolving a unary operator given an operator tag and an argument type.
 */
OperatorSymbol resolveUnary(DiagnosticPosition pos, JCTree.Tag tag, Type op) {
    return resolve(tag,
            unaryOperators,
            unop -> unop.test(op),
            unop -> unop.resolve(op),
            () -> reportErrorIfNeeded(pos, tag, op));
}
 

protected Operators(Context context) {
    context.put(operatorsKey, this);
    syms = Symtab.instance(context);
    names = Names.instance(context);
    log = Log.instance(context);
    types = Types.instance(context);
    noOpSymbol = new OperatorSymbol(names.empty, Type.noType, -1, syms.noSymbol);
    initOperatorNames();
    initUnaryOperators();
    initBinaryOperators();
}
 

/** Enter a binary operation into symbol table.
 *  @param name     The name of the operator.
 *  @param left     The type of the left operand.
 *  @param right    The type of the left operand.
 *  @param res      The operation's result type.
 *  @param opcode   The operation's bytecode instruction.
 */
private void enterBinop(String name,
                        Type left, Type right, Type res,
                        int opcode) {
    predefClass.members().enter(
        new OperatorSymbol(
            names.fromString(name),
            new MethodType(List.of(left, right), res,
                           List.<Type>nil(), methodClass),
            opcode,
            predefClass));
}
 

OperatorSymbol lookupBinaryOp(Predicate<OperatorSymbol> applicabilityTest) {
    return StreamSupport.stream(binaryOperators.values())
            .flatMap(StreamSupport::stream)
            .map(helper -> helper.doLookup(applicabilityTest))
            .distinct()
            .filter(sym -> sym != noOpSymbol)
            .findFirst().get();
}
 

@Override
public OperatorSymbol resolve(Type t1, Type t2) {
    ComparisonKind kind = getKind(t1, t2);
    Type t = (kind == ComparisonKind.NUMERIC_OR_BOOLEAN) ?
            binaryPromotion(t1, t2) :
            syms.objectType;
    return doLookup(t, t);
}
 

/**
 *  Check for division by integer constant zero
 *  @param pos           Position for error reporting.
 *  @param operator      The operator for the expression
 *  @param operand       The right hand operand for the expression
 */
void checkDivZero(final DiagnosticPosition pos, Symbol operator, Type operand) {
    if (operand.constValue() != null
        && operand.getTag().isSubRangeOf(LONG)
        && ((Number) (operand.constValue())).longValue() == 0) {
        int opc = ((OperatorSymbol)operator).opcode;
        if (opc == ByteCodes.idiv || opc == ByteCodes.imod
            || opc == ByteCodes.ldiv || opc == ByteCodes.lmod) {
            deferredLintHandler.report(() -> warnDivZero(pos));
        }
    }
}
 

/**
 * Entry point for resolving a unary operator given an operator tag and an argument type.
 */
OperatorSymbol resolveUnary(DiagnosticPosition pos, JCTree.Tag tag, Type op) {
    return resolve(tag,
            unaryOperators,
            unop -> unop.test(op),
            unop -> unop.resolve(op),
            () -> reportErrorIfNeeded(pos, tag, op));
}
 

/**
 * Entry point for resolving a binary operator given an operator tag and a pair of argument types.
 */
OperatorSymbol resolveBinary(DiagnosticPosition pos, JCTree.Tag tag, Type op1, Type op2) {
    return resolve(tag,
            binaryOperators,
            binop -> binop.test(op1, op2),
            binop -> binop.resolve(op1, op2),
            () -> reportErrorIfNeeded(pos, tag, op1, op2));
}
 

/**
 * Main operator lookup routine; lookup an operator (either unary or binary) in its corresponding
 * map. If there's a matching operator, its resolve routine is called and the result is returned;
 * otherwise the result of a fallback function is returned.
 */
private <O> OperatorSymbol resolve(Tag tag, Map<Name, List<O>> opMap, Predicate<O> opTestFunc,
                   Function<O, OperatorSymbol> resolveFunc, Supplier<OperatorSymbol> noResultFunc) {
    return StreamSupport.stream(opMap.get(operatorName(tag)))
            .filter(opTestFunc)
            .map(resolveFunc)
            .findFirst()
            .orElseGet(noResultFunc);
}
 

/**
 * Creates an operator symbol.
 */
private OperatorSymbol makeOperator(Name name, List<OperatorType> formals, OperatorType res, int... opcodes) {
    MethodType opType = new MethodType(
            StreamSupport.stream(formals)
                    .map(o -> o.asType(syms))
                    .collect(List.collector()),
            res.asType(syms), List.nil(), syms.methodClass);
    return new OperatorSymbol(name, opType, mergeOpcodes(opcodes), syms.noSymbol);
}
 

/**
 * Report an operator lookup error.
 */
private OperatorSymbol reportErrorIfNeeded(DiagnosticPosition pos, Tag tag, Type... args) {
    if (Stream.of(args).noneMatch(Type::isErroneous)) {
        Name opName = operatorName(tag);
        JCDiagnostic.Error opError = (args.length) == 1 ?
                Errors.OperatorCantBeApplied(opName, args[0]) :
                Errors.OperatorCantBeApplied1(opName, args[0], args[1]);
        log.error(pos, opError);
    }
    return noOpSymbol;
}
 

protected Operators(Context context) {
    context.put(operatorsKey, this);
    syms = Symtab.instance(context);
    names = Names.instance(context);
    log = Log.instance(context);
    types = Types.instance(context);
    noOpSymbol = new OperatorSymbol(names.empty, Type.noType, -1, syms.noSymbol);
    initOperatorNames();
    initUnaryOperators();
    initBinaryOperators();
}
 

/**
 * This routine implements the main operator lookup process. Each operator is tested
 * using an applicability predicate; if the test suceeds that same operator is returned,
 * otherwise a dummy symbol is returned.
 */
final OperatorSymbol doLookup(Predicate<OperatorSymbol> applicabilityTest) {
    return Stream.of(alternatives.orElseGet(this::initOperators))
            .filter(applicabilityTest)
            .findFirst()
            .orElse(noOpSymbol);
}
 

/**
 * This routine performs lazy instantiation of the operator symbols supported by this helper.
 * After initialization is done, the suppliers are cleared, to free up memory.
 */
private OperatorSymbol[] initOperators() {
    OperatorSymbol[] operators = StreamSupport.stream(operatorSuppliers)
            .map(Supplier::get)
            .toArray(OperatorSymbol[]::new);
    alternatives = Optional.of(operators);
    operatorSuppliers = null; //let GC do its work
    return operators;
}
 

/** Return tree tag for assignment operation corresponding
 *  to given binary operator.
 */
private static JCTree.Tag treeTag(OperatorSymbol operator) {
    switch (operator.opcode) {
    case ByteCodes.ior: case ByteCodes.lor:
        return BITOR_ASG;
    case ByteCodes.ixor: case ByteCodes.lxor:
        return BITXOR_ASG;
    case ByteCodes.iand: case ByteCodes.land:
        return BITAND_ASG;
    case ByteCodes.ishl: case ByteCodes.lshl:
    case ByteCodes.ishll: case ByteCodes.lshll:
        return SL_ASG;
    case ByteCodes.ishr: case ByteCodes.lshr:
    case ByteCodes.ishrl: case ByteCodes.lshrl:
        return SR_ASG;
    case ByteCodes.iushr: case ByteCodes.lushr:
    case ByteCodes.iushrl: case ByteCodes.lushrl:
        return USR_ASG;
    case ByteCodes.iadd: case ByteCodes.ladd:
    case ByteCodes.fadd: case ByteCodes.dadd:
    case ByteCodes.string_add:
        return PLUS_ASG;
    case ByteCodes.isub: case ByteCodes.lsub:
    case ByteCodes.fsub: case ByteCodes.dsub:
        return MINUS_ASG;
    case ByteCodes.imul: case ByteCodes.lmul:
    case ByteCodes.fmul: case ByteCodes.dmul:
        return MUL_ASG;
    case ByteCodes.idiv: case ByteCodes.ldiv:
    case ByteCodes.fdiv: case ByteCodes.ddiv:
        return DIV_ASG;
    case ByteCodes.imod: case ByteCodes.lmod:
    case ByteCodes.fmod: case ByteCodes.dmod:
        return MOD_ASG;
    default:
        throw new AssertionError();
    }
}
 

/**
 * Binary operator applicability test - are the input types the same as the expected operand types?
 */
boolean isBinaryOperatorApplicable(OperatorSymbol op, Type t1, Type t2) {
    List<Type> formals = op.type.getParameterTypes();
    return types.isSameType(formals.head, t1) &&
            types.isSameType(formals.tail.head, t2);
}
 

/**
 * Unary operator applicability test - is the input type the same as the expected operand type?
 */
boolean isUnaryOperatorApplicable(OperatorSymbol op, Type t) {
    return types.isSameType(op.type.getParameterTypes().head, t);
}
 

/** Return binary operator that corresponds to given access code.
 */
private OperatorSymbol binaryAccessOperator(int acode, Tag tag) {
    return operators.lookupBinaryOp(op -> op.getAccessCode(tag) == acode);
}
 

@Override
public OperatorSymbol resolve(Type arg) {
    return doLookup(syms.objectType);
}