private static boolean isSynchronized(Symbol methodSymbol) { return Flags.isFlagged( ((JavaSymbol) methodSymbol).flags(), Flags.SYNCHRONIZED); }
private static boolean isSynchronized(Symbol methodSymbol) { return Flags.isFlagged( ((JavaSymbol) methodSymbol).flags(), Flags.SYNCHRONIZED); }
/** * Is symbol inherited in given class? */ @VisibleForTesting static boolean isInheritedIn(JavaSymbol symbol, JavaSymbol.TypeJavaSymbol clazz) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PUBLIC: return true; case Flags.PRIVATE: return symbol.owner() == clazz; case Flags.PROTECTED: // TODO see Javac return true; case 0: // TODO see Javac JavaSymbol.PackageJavaSymbol thisPackage = symbol.packge(); for (JavaSymbol.TypeJavaSymbol sup = clazz; sup != null && sup != symbol.owner(); sup = superclassSymbol(sup)) { if (sup.packge() != thisPackage) { return false; } } return true; default: throw new IllegalStateException(); } }
/** * Is symbol inherited in given class? */ @VisibleForTesting boolean isInheritedIn(JavaSymbol symbol, JavaSymbol.TypeJavaSymbol clazz) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PUBLIC: return true; case Flags.PRIVATE: return symbol.owner() == clazz; case Flags.PROTECTED: // TODO see Javac return true; case 0: // TODO see Javac JavaSymbol.PackageJavaSymbol thisPackage = symbol.packge(); for (JavaSymbol.TypeJavaSymbol sup = clazz; sup != null && sup != symbol.owner(); sup = superclassSymbol(sup)) { if (sup.packge() != thisPackage) { return false; } } return true; default: throw new IllegalStateException(); } }
/** * Is symbol inherited in given class? */ @VisibleForTesting static boolean isInheritedIn(JavaSymbol symbol, JavaSymbol.TypeJavaSymbol clazz) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PUBLIC: return true; case Flags.PRIVATE: return symbol.owner() == clazz; case Flags.PROTECTED: // TODO see Javac return true; case 0: // TODO see Javac JavaSymbol.PackageJavaSymbol thisPackage = symbol.packge(); for (JavaSymbol.TypeJavaSymbol sup = clazz; sup != null && sup != symbol.owner(); sup = superclassSymbol(sup)) { if (sup.packge() != thisPackage) { return false; } } return true; default: throw new IllegalStateException(); } }
/** * Is symbol inherited in given class? */ @VisibleForTesting static boolean isInheritedIn(JavaSymbol symbol, JavaSymbol.TypeJavaSymbol clazz) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PUBLIC: return true; case Flags.PRIVATE: return symbol.owner() == clazz; case Flags.PROTECTED: // TODO see Javac return true; case 0: // TODO see Javac JavaSymbol.PackageJavaSymbol thisPackage = symbol.packge(); for (JavaSymbol.TypeJavaSymbol sup = clazz; sup != null && sup != symbol.owner(); sup = superclassSymbol(sup)) { if (sup.packge() != thisPackage) { return false; } } return true; default: throw new IllegalStateException(); } }
/** * Is given class a subclass of given base class? */ @VisibleForTesting static boolean isSubClass(@Nullable JavaSymbol.TypeJavaSymbol c, JavaSymbol base) { // TODO get rid of null check if (c == null) { return false; } // TODO see Javac if (c == base) { // same class return true; } else if (Flags.isFlagged(base.flags(), Flags.INTERFACE)) { // check if class implements base for (JavaType interfaceType : c.getInterfaces()) { if (isSubClass(interfaceType.symbol, base)) { return true; } } // check if superclass implements base return isSubClass(superclassSymbol(c), base); } else { // check if class extends base or its superclass extends base return isSubClass(superclassSymbol(c), base); } }
/** * Is given class a subclass of given base class? */ @VisibleForTesting static boolean isSubClass(@Nullable JavaSymbol.TypeJavaSymbol c, JavaSymbol base) { // TODO get rid of null check if (c == null) { return false; } // TODO see Javac if (c == base) { // same class return true; } else if (Flags.isFlagged(base.flags(), Flags.INTERFACE)) { // check if class implements base for (JavaType interfaceType : c.getInterfaces()) { if (isSubClass(interfaceType.symbol, base)) { return true; } } // check if superclass implements base return isSubClass(superclassSymbol(c), base); } else { // check if class extends base or its superclass extends base return isSubClass(superclassSymbol(c), base); } }
/** * Is given class a subclass of given base class? */ @VisibleForTesting boolean isSubClass(JavaSymbol.TypeJavaSymbol c, JavaSymbol base) { // TODO get rid of null check if (c == null) { return false; } // TODO see Javac if (c == base) { // same class return true; } else if ((base.flags() & Flags.INTERFACE) != 0) { // check if class implements base for (JavaType interfaceType : c.getInterfaces()) { if (isSubClass(interfaceType.symbol, base)) { return true; } } // check if superclass implements base return isSubClass(superclassSymbol(c), base); } else { // check if class extends base or its superclass extends base return isSubClass(superclassSymbol(c), base); } }
/** * Is given class a subclass of given base class? */ @VisibleForTesting static boolean isSubClass(JavaSymbol.TypeJavaSymbol c, JavaSymbol base) { // TODO get rid of null check if (c == null) { return false; } // TODO see Javac if (c == base) { // same class return true; } else if ((base.flags() & Flags.INTERFACE) != 0) { // check if class implements base for (JavaType interfaceType : c.getInterfaces()) { if (isSubClass(interfaceType.symbol, base)) { return true; } } // check if superclass implements base return isSubClass(superclassSymbol(c), base); } else { // check if class extends base or its superclass extends base return isSubClass(superclassSymbol(c), base); } }
/** * Is symbol accessible as a member of given class in given environment? * <p/> * Symbol is accessible only if not overridden by another symbol. If overridden, then strictly speaking it is not a member. */ private static boolean isAccessible(Env env, JavaSymbol.TypeJavaSymbol site, JavaSymbol symbol) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PRIVATE: //if enclosing class is null, we are checking accessibility for imports so we return false. // no check of overriding, because private members cannot be overridden return env.enclosingClass != null && sameOutermostClass(env.enclosingClass, symbol.owner()) && isInheritedIn(symbol, site); case 0: return (env.packge == symbol.packge()) && isAccessible(env, site) && isInheritedIn(symbol, site) && notOverriddenIn(site, symbol); case Flags.PUBLIC: return isAccessible(env, site) && notOverriddenIn(site, symbol); case Flags.PROTECTED: return ((env.packge == symbol.packge()) || isProtectedAccessible(symbol, env.enclosingClass, site)) && isAccessible(env, site) && notOverriddenIn(site, symbol); default: throw new IllegalStateException(); } }
/** * Is symbol accessible as a member of given class in given environment? * <p/> * Symbol is accessible only if not overridden by another symbol. If overridden, then strictly speaking it is not a member. */ private static boolean isAccessible(Env env, JavaSymbol.TypeJavaSymbol site, JavaSymbol symbol) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PRIVATE: //if enclosing class is null, we are checking accessibility for imports so we return false. // no check of overriding, because private members cannot be overridden return env.enclosingClass != null && sameOutermostClass(env.enclosingClass, symbol.owner()) && isInheritedIn(symbol, site); case 0: return (env.packge == symbol.packge()) && isAccessible(env, site) && isInheritedIn(symbol, site) && notOverriddenIn(site, symbol); case Flags.PUBLIC: return isAccessible(env, site) && notOverriddenIn(site, symbol); case Flags.PROTECTED: return ((env.packge == symbol.packge()) || isProtectedAccessible(symbol, env.enclosingClass, site)) && isAccessible(env, site) && notOverriddenIn(site, symbol); default: throw new IllegalStateException(); } }
/** * Is symbol accessible as a member of given class in given environment? * <p/> * Symbol is accessible only if not overridden by another symbol. If overridden, then strictly speaking it is not a member. */ private static boolean isAccessible(Env env, JavaSymbol.TypeJavaSymbol site, JavaSymbol symbol) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PRIVATE: //if enclosing class is null, we are checking accessibility for imports so we return false. // no check of overriding, because private members cannot be overridden return env.enclosingClass != null && sameOutermostClass(env.enclosingClass, symbol.owner()) && isInheritedIn(symbol, site); case 0: return (env.packge == symbol.packge()) && isAccessible(env, site) && isInheritedIn(symbol, site) && notOverriddenIn(site, symbol); case Flags.PUBLIC: return isAccessible(env, site) && notOverriddenIn(site, symbol); case Flags.PROTECTED: return ((env.packge == symbol.packge()) || isProtectedAccessible(symbol, env.enclosingClass, site)) && isAccessible(env, site) && notOverriddenIn(site, symbol); default: throw new IllegalStateException(); } }
/** * Is symbol accessible as a member of given class in given environment? * <p/> * Symbol is accessible only if not overridden by another symbol. If overridden, then strictly speaking it is not a member. */ private boolean isAccessible(Env env, JavaSymbol.TypeJavaSymbol site, JavaSymbol symbol) { switch (symbol.flags() & Flags.ACCESS_FLAGS) { case Flags.PRIVATE: //if enclosing class is null, we are checking accessibility for imports so we return false. // no check of overriding, because private members cannot be overridden return env.enclosingClass != null && (env.enclosingClass().outermostClass() == symbol.owner().outermostClass()) && isInheritedIn(symbol, site); case 0: return (env.packge() == symbol.packge()) && isAccessible(env, site) && isInheritedIn(symbol, site) && notOverriddenIn(site, symbol); case Flags.PUBLIC: return isAccessible(env, site) && notOverriddenIn(site, symbol); case Flags.PROTECTED: return ((env.packge() == symbol.packge()) || isProtectedAccessible(symbol, env.enclosingClass, site)) && isAccessible(env, site) && notOverriddenIn(site, symbol); default: throw new IllegalStateException(); } }