Java Code Examples for com.sun.tools.javac.code.Symbol#flags()

/**
 * Get the opcode associated with this method reference
 */
private int referenceKind(Symbol refSym) {
    if (refSym.isConstructor()) {
        return ClassFile.REF_newInvokeSpecial;
    } else {
        if (refSym.isStatic()) {
            return ClassFile.REF_invokeStatic;
        } else if ((refSym.flags() & PRIVATE) != 0) {
            return ClassFile.REF_invokeSpecial;
        } else if (refSym.enclClass().isInterface()) {
            return ClassFile.REF_invokeInterface;
        } else {
            return ClassFile.REF_invokeVirtual;
        }
    }
}
 

/**
 * Get the opcode associated with this method reference
 */
private int referenceKind(Symbol refSym) {
    if (refSym.isConstructor()) {
        return ClassFile.REF_newInvokeSpecial;
    } else {
        if (refSym.isStatic()) {
            return ClassFile.REF_invokeStatic;
        } else if ((refSym.flags() & PRIVATE) != 0) {
            return ClassFile.REF_invokeSpecial;
        } else if (refSym.enclClass().isInterface()) {
            return ClassFile.REF_invokeInterface;
        } else {
            return ClassFile.REF_invokeVirtual;
        }
    }
}
 

/**
 * Get the opcode associated with this method reference
 */
private int referenceKind(Symbol refSym) {
    if (refSym.isConstructor()) {
        return ClassFile.REF_newInvokeSpecial;
    } else {
        if (refSym.isStatic()) {
            return ClassFile.REF_invokeStatic;
        } else if ((refSym.flags() & PRIVATE) != 0) {
            return ClassFile.REF_invokeSpecial;
        } else if (refSym.enclClass().isInterface()) {
            return ClassFile.REF_invokeInterface;
        } else {
            return ClassFile.REF_invokeVirtual;
        }
    }
}
 

/** Check that all methods which implement some
 *  method in `ic' conform to the method they implement.
 */
void checkImplementations(JCTree tree, ClassSymbol origin, ClassSymbol ic) {
    for (List<Type> l = types.closure(ic.type); l.nonEmpty(); l = l.tail) {
        ClassSymbol lc = (ClassSymbol)l.head.tsym;
        if ((lc.flags() & ABSTRACT) != 0) {
            for (Symbol sym : lc.members().getSymbols(NON_RECURSIVE)) {
                if (sym.kind == MTH &&
                    (sym.flags() & (STATIC|ABSTRACT)) == ABSTRACT) {
                    MethodSymbol absmeth = (MethodSymbol)sym;
                    MethodSymbol implmeth = absmeth.implementation(origin, types, false);
                    if (implmeth != null && implmeth != absmeth &&
                        (implmeth.owner.flags() & INTERFACE) ==
                        (origin.flags() & INTERFACE)) {
                        // don't check if implmeth is in a class, yet
                        // origin is an interface. This case arises only
                        // if implmeth is declared in Object. The reason is
                        // that interfaces really don't inherit from
                        // Object it's just that the compiler represents
                        // things that way.
                        checkOverride(tree, implmeth, absmeth, origin);
                    }
                }
            }
        }
    }
}
 

/**
 * Get the opcode associated with this method reference
 */
private int referenceKind(Symbol refSym) {
    if (refSym.isConstructor()) {
        return ClassFile.REF_newInvokeSpecial;
    } else {
        if (refSym.isStatic()) {
            return ClassFile.REF_invokeStatic;
        } else if ((refSym.flags() & PRIVATE) != 0) {
            return ClassFile.REF_invokeSpecial;
        } else if (refSym.enclClass().isInterface()) {
            return ClassFile.REF_invokeInterface;
        } else {
            return ClassFile.REF_invokeVirtual;
        }
    }
}
 

/**
 * Get the opcode associated with this method reference
 */
private int referenceKind(Symbol refSym) {
    if (refSym.isConstructor()) {
        return ClassFile.REF_newInvokeSpecial;
    } else {
        if (refSym.isStatic()) {
            return ClassFile.REF_invokeStatic;
        } else if ((refSym.flags() & PRIVATE) != 0) {
            return ClassFile.REF_invokeSpecial;
        } else if (refSym.enclClass().isInterface()) {
            return ClassFile.REF_invokeInterface;
        } else {
            return ClassFile.REF_invokeVirtual;
        }
    }
}
 

public boolean importAccessible(Symbol sym, PackageSymbol packge) {
    try {
        int flags = (int)(sym.flags() & AccessFlags);
        switch (flags) {
        default:
        case PUBLIC:
            return true;
        case PRIVATE:
            return false;
        case 0:
        case PROTECTED:
            return sym.packge() == packge;
        }
    } catch (ClassFinder.BadClassFile err) {
        throw err;
    } catch (CompletionFailure ex) {
        return false;
    }
}
 

private boolean isEffectivelyNonPublic(Symbol sym) {
    if (sym.packge() == syms.rootPackage) {
        return false;
    }

    while (sym.kind != PCK) {
        if ((sym.flags() & PUBLIC) == 0) {
            return true;
        }
        sym = sym.owner;
    }
    return false;
}
 

@Override @DefinedBy(Api.LANGUAGE_MODEL)
public Origin getOrigin(Element e) {
    Symbol sym = cast(Symbol.class, e);
    if ((sym.flags() & Flags.GENERATEDCONSTR) != 0)
        return Origin.MANDATED;
    //TypeElement.getEnclosedElements does not return synthetic elements,
    //and most synthetic elements are not read from the classfile anyway:
    return Origin.EXPLICIT;
}
 

@Override
void process(Diagnostic<? extends JavaFileObject> diagnostic) {
    Symbol methodSym = (Symbol)methodSym(diagnostic);
    if ((methodSym.flags() & Flags.GENERATEDCONSTR) != 0) {
        //skip resolution of default constructor (put there by javac)
        return;
    }
    Candidate c = getCandidateAtPos(methodSym,
            asJCDiagnostic(diagnostic).getLineNumber(),
            asJCDiagnostic(diagnostic).getColumnNumber());
    if (c == null) {
        return; //nothing to check
    }

    if (c.applicable().length == 0 && c.mostSpecific()) {
        error("Inapplicable method cannot be most specific " + methodSym);
    }

    if (isApplicable(diagnostic) != Arrays.asList(c.applicable()).contains(phase)) {
        error("Invalid candidate's applicability " + methodSym);
    }

    if (success) {
        for (Phase p : c.applicable()) {
            if (phase.ordinal() < p.ordinal()) {
                error("Invalid phase " + p + " on method " + methodSym);
            }
        }
    }

    if (Arrays.asList(c.applicable()).contains(phase)) { //applicable
        if (c.mostSpecific() != mostSpecific) {
            error("Invalid most specific value for method " + methodSym + " " + new ElementKey(methodSym).key);
        }
        MethodType mtype = getSig(diagnostic);
        if (mtype != null) {
            checkSig(c, methodSym, mtype);
        }
    }
}
 

@Override
void process(Diagnostic<? extends JavaFileObject> diagnostic) {
    Symbol methodSym = (Symbol)methodSym(diagnostic);
    if ((methodSym.flags() & Flags.GENERATEDCONSTR) != 0) {
        //skip resolution of default constructor (put there by javac)
        return;
    }
    Candidate c = getCandidateAtPos(methodSym,
            asJCDiagnostic(diagnostic).getLineNumber(),
            asJCDiagnostic(diagnostic).getColumnNumber());
    if (c == null) {
        return; //nothing to check
    }

    if (c.applicable().length == 0 && c.mostSpecific()) {
        error("Inapplicable method cannot be most specific " + methodSym);
    }

    if (isApplicable(diagnostic) != Arrays.asList(c.applicable()).contains(phase)) {
        error("Invalid candidate's applicability " + methodSym);
    }

    if (success) {
        for (Phase p : c.applicable()) {
            if (phase.ordinal() < p.ordinal()) {
                error("Invalid phase " + p + " on method " + methodSym);
            }
        }
    }

    if (Arrays.asList(c.applicable()).contains(phase)) { //applicable
        if (c.mostSpecific() != mostSpecific) {
            error("Invalid most specific value for method " + methodSym + " " + new ElementKey(methodSym).key);
        }
        MethodType mtype = getSig(diagnostic);
        if (mtype != null) {
            checkSig(c, methodSym, mtype);
        }
    }
}
 

/**
 * Converts a class name into a (possibly localized) string. Anonymous inner
 * classes get converted into a localized string.
 *
 * @param t the type of the class whose name is to be rendered
 * @param longform if set, the class' fullname is displayed - if unset the
 * short name is chosen (w/o package)
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
@Override
protected String className(ClassType t, boolean longform, Locale locale) {
    Symbol sym = t.tsym;
    if (sym.name.length() == 0 && (sym.flags() & COMPOUND) != 0) {
        return OBJECT;
    } else if (sym.name.length() == 0) {
        // Anonymous
        String s;
        ClassType norm = (ClassType) t.tsym.type;
        if (norm == null) {
            s = OBJECT;
        } else if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) {
            s = visit(norm.interfaces_field.head, locale);
        } else {
            s = visit(norm.supertype_field, locale);
        }
        return s;
    } else if (longform) {
        String pkg = "";
        for (Symbol psym = sym; psym != null; psym = psym.owner) {
            if (psym.kind == PCK) {
                pkg = psym.getQualifiedName().toString();
                break;
            }
        }
        return fullClassNameAndPackageToClass.apply(
                sym.getQualifiedName().toString(),
                pkg
        );
    } else {
        return sym.name.toString();
    }
}
 

@Override
void process(Diagnostic<? extends JavaFileObject> diagnostic) {
    Symbol methodSym = (Symbol)methodSym(diagnostic);
    if ((methodSym.flags() & Flags.GENERATEDCONSTR) != 0) {
        //skip resolution of default constructor (put there by javac)
        return;
    }
    Candidate c = getCandidateAtPos(methodSym,
            asJCDiagnostic(diagnostic).getLineNumber(),
            asJCDiagnostic(diagnostic).getColumnNumber());
    if (c == null) {
        return; //nothing to check
    }

    if (c.applicable().length == 0 && c.mostSpecific()) {
        error("Inapplicable method cannot be most specific " + methodSym);
    }

    if (isApplicable(diagnostic) != Arrays.asList(c.applicable()).contains(phase)) {
        error("Invalid candidate's applicability " + methodSym);
    }

    if (success) {
        for (Phase p : c.applicable()) {
            if (phase.ordinal() < p.ordinal()) {
                error("Invalid phase " + p + " on method " + methodSym);
            }
        }
    }

    if (Arrays.asList(c.applicable()).contains(phase)) { //applicable
        if (c.mostSpecific() != mostSpecific) {
            error("Invalid most specific value for method " + methodSym + " " + new ElementKey(methodSym).key);
        }
        MethodType mtype = getSig(diagnostic);
        if (mtype != null) {
            checkSig(c, methodSym, mtype);
        }
    }
}
 

/** The qualifier to be used for accessing a symbol in an outer class.
 *  This is either C.sym or C.this.sym, depending on whether or not
 *  sym is static.
 *  @param sym   The accessed symbol.
 */
JCExpression accessBase(DiagnosticPosition pos, Symbol sym) {
    return (sym.flags() & STATIC) != 0
        ? access(make.at(pos.getStartPosition()).QualIdent(sym.owner))
        : makeOwnerThis(pos, sym, true);
}
 

/** Is the annotation applicable to the symbol? */
boolean annotationApplicable(JCAnnotation a, Symbol s) {
    Attribute.Array arr = getAttributeTargetAttribute(a.annotationType.type.tsym);
    Name[] targets;

    if (arr == null) {
        targets = defaultTargetMetaInfo(a, s);
    } else {
        // TODO: can we optimize this?
        targets = new Name[arr.values.length];
        for (int i=0; i<arr.values.length; ++i) {
            Attribute app = arr.values[i];
            if (!(app instanceof Attribute.Enum)) {
                return true; // recovery
            }
            Attribute.Enum e = (Attribute.Enum) app;
            targets[i] = e.value.name;
        }
    }
    for (Name target : targets) {
        if (target == names.TYPE) {
            if (s.kind == TYP)
                return true;
        } else if (target == names.FIELD) {
            if (s.kind == VAR && s.owner.kind != MTH)
                return true;
        } else if (target == names.METHOD) {
            if (s.kind == MTH && !s.isConstructor())
                return true;
        } else if (target == names.PARAMETER) {
            if (s.kind == VAR && s.owner.kind == MTH &&
                  (s.flags() & PARAMETER) != 0) {
                return true;
            }
        } else if (target == names.CONSTRUCTOR) {
            if (s.kind == MTH && s.isConstructor())
                return true;
        } else if (target == names.LOCAL_VARIABLE) {
            if (s.kind == VAR && s.owner.kind == MTH &&
                  (s.flags() & PARAMETER) == 0) {
                return true;
            }
        } else if (target == names.ANNOTATION_TYPE) {
            if (s.kind == TYP && (s.flags() & ANNOTATION) != 0) {
                return true;
            }
        } else if (target == names.PACKAGE) {
            if (s.kind == PCK)
                return true;
        } else if (target == names.TYPE_USE) {
            if (s.kind == VAR && s.owner.kind == MTH && s.type.hasTag(NONE)) {
                //cannot type annotate implictly typed locals
                return false;
            } else if (s.kind == TYP || s.kind == VAR ||
                    (s.kind == MTH && !s.isConstructor() &&
                            !s.type.getReturnType().hasTag(VOID)) ||
                    (s.kind == MTH && s.isConstructor())) {
                return true;
            }
        } else if (target == names.TYPE_PARAMETER) {
            if (s.kind == TYP && s.type.hasTag(TYPEVAR))
                return true;
        } else
            return true; // Unknown ElementType. This should be an error at declaration site,
                         // assume applicable.
    }
    return false;
}
 

static private boolean hasFlag(Symbol m, int flag) {
    return (m.flags() & flag) != 0;
}
 

/**
 * Tests whether this is a symbol that should never be seen by
 * clients, such as a synthetic class.  Returns true for null.
 */
private static boolean unwanted(Symbol s) {
    return s == null  ||  (s.flags() & SYNTHETIC) != 0;
}
 

/**
 * Tests whether this is a symbol that should never be seen by
 * clients, such as a synthetic class.  Returns true for null.
 */
private static boolean unwanted(Symbol s) {
    return s == null  ||  (s.flags() & SYNTHETIC) != 0;
}
 

/**
 * Tests whether this is a symbol that should never be seen by
 * clients, such as a synthetic class.  Returns true for null.
 */
private static boolean unwanted(Symbol s) {
    return s == null  ||  (s.flags() & SYNTHETIC) != 0;
}
 

/**
 * Tests whether this is a symbol that should never be seen by
 * clients, such as a synthetic class.  Returns true for null.
 */
private static boolean unwanted(Symbol s) {
    return s == null  ||  (s.flags() & SYNTHETIC) != 0;
}