private static boolean isStatic(int methodFlags) { return Flags.isFlagged(methodFlags, Flags.STATIC); }
/** * Invoked when current class classified as inner class. * Owner of inner classes - is some outer class, * which is either already completed, and thus already has this inner class as member, * either will be completed by {@link org.sonar.java.resolve.BytecodeCompleter}, and thus will have this inner class as member (see {@link #defineInnerClass(String, int)}). */ private void defineOuterClass(String outerName, String innerName, int flags) { JavaSymbol.TypeJavaSymbol outerClassSymbol = getClassSymbol(outerName, flags); Preconditions.checkState(outerClassSymbol.completer == null || outerClassSymbol.completer instanceof BytecodeCompleter); classSymbol.name = innerName; classSymbol.flags = flags | Flags.filterAccessBytecodeFlags(classSymbol.flags & ~Flags.ACCESS_FLAGS); classSymbol.owner = outerClassSymbol; }
/** * Compiler marks all artifacts not presented in the source code as {@link Flags#SYNTHETIC}. */ private static boolean isNotSynthetic(int flags) { return Flags.isNotFlagged(flags, Flags.SYNTHETIC); }
private int computeFlags(ModifiersTree modifiers, Tree tree) { int result = 0; if (Flags.isFlagged(env.scope.owner.flags, Flags.INTERFACE)) { result = computeFlagsForInterfaceMember(tree); } for (ModifierKeywordTree modifier : modifiers.modifiers()) { result |= Flags.flagForModifier(modifier.modifier()); } if(hasDeprecatedAnnotation(modifiers.annotations())) { result |= Flags.DEPRECATED; } return result; }
private int computeFlags(ModifiersTree modifiers) { int result = 0; //JLS7 6.6.1: All members of interfaces are implicitly public. if ((env.scope.owner.flags & Flags.INTERFACE) != 0) { result = Flags.PUBLIC; } for (Modifier modifier : modifiers.modifiers()) { result |= Flags.flagForModifier(modifier); } if(hasDeprecatedAnnotation(modifiers.annotations())) { result |= Flags.DEPRECATED; } return result; }
classSymbol ); int methodFlags = Flags.filterAccessBytecodeFlags(flags); if (classSymbol.isInterface() && Flags.isNotFlagged(methodFlags, Flags.ABSTRACT | Flags.PRIVATE | Flags.STATIC)) {
private int computeFlags(ModifiersTree modifiers, Tree tree) { int result = 0; if (Flags.isFlagged(env.scope.owner.flags, Flags.INTERFACE)) { result = computeFlagsForInterfaceMember(tree); } for (ModifierKeywordTree modifier : modifiers.modifiers()) { result |= Flags.flagForModifier(modifier.modifier()); } if(hasDeprecatedAnnotation(modifiers.annotations())) { result |= Flags.DEPRECATED; } return result; }
private int computeFlags(ModifiersTree modifiers, Tree tree) { int result = 0; if ((env.scope.owner.flags & Flags.INTERFACE) != 0) { result = computeFlagsForInterfaceMember(tree); } for (ModifierKeywordTree modifier : modifiers.modifiers()) { result |= Flags.flagForModifier(modifier.modifier()); } if(hasDeprecatedAnnotation(modifiers.annotations())) { result |= Flags.DEPRECATED; } return result; }
classSymbol ); int methodFlags = Flags.filterAccessBytecodeFlags(flags); if (classSymbol.isInterface() && Flags.isNotFlagged(methodFlags, Flags.ABSTRACT | Flags.PRIVATE | Flags.STATIC)) {
private static boolean isStatic(int methodFlags) { return Flags.isFlagged(methodFlags, Flags.STATIC); }
/** * Invoked when current class classified as inner class. * Owner of inner classes - is some outer class, * which is either already completed, and thus already has this inner class as member, * either will be completed by {@link org.sonar.java.resolve.BytecodeCompleter}, and thus will have this inner class as member (see {@link #defineInnerClass(String, int)}). */ private void defineOuterClass(String outerName, String innerName, int flags) { JavaSymbol.TypeJavaSymbol outerClassSymbol = getClassSymbol(outerName, flags); Preconditions.checkState(outerClassSymbol.completer == null || outerClassSymbol.completer instanceof BytecodeCompleter); classSymbol.name = innerName; classSymbol.flags = flags | Flags.filterAccessBytecodeFlags(classSymbol.flags & ~Flags.ACCESS_FLAGS); classSymbol.owner = outerClassSymbol; }
/** * Compiler marks all artifacts not presented in the source code as {@link Flags#SYNTHETIC}. */ private static boolean isNotSynthetic(int flags) { return Flags.isNotFlagged(flags, Flags.SYNTHETIC); }
public Optional<Object> constantValue() { if (Flags.isFlagged(flags, Flags.STATIC) && Flags.isFlagged(flags, Flags.FINAL)) { if (value != null && type.is("boolean")) { return Optional.of(Integer.valueOf(1).equals(value) ? Boolean.TRUE : Boolean.FALSE); } return Optional.ofNullable(value); } return Optional.empty(); }
/** * Invoked when current class classified as outer class of some inner class. * Adds inner class as member. */ private void defineInnerClass(String bytecodeName, int flags) { JavaSymbol.TypeJavaSymbol innerClass = getClassSymbol(classSymbol, bytecodeName, flags); innerClass.flags |= Flags.filterAccessBytecodeFlags(flags); Preconditions.checkState(innerClass.owner == classSymbol, "Innerclass: " + innerClass.owner.getName() + " and classSymbol: " + classSymbol.getName() + " are not the same."); classSymbol.members.enter(innerClass); }
@Override public boolean isPackageVisibility() { complete(); return Flags.isNotFlagged(flags, Flags.PROTECTED | Flags.PRIVATE | Flags.PUBLIC); }
public Optional<Object> constantValue() { if (Flags.isFlagged(flags, Flags.STATIC) && Flags.isFlagged(flags, Flags.FINAL)) { if (value != null && type.is("boolean")) { return Optional.of(Integer.valueOf(1).equals(value) ? Boolean.TRUE : Boolean.FALSE); } return Optional.ofNullable(value); } return Optional.empty(); }
/** * Invoked when current class classified as outer class of some inner class. * Adds inner class as member. */ private void defineInnerClass(String bytecodeName, int flags) { JavaSymbol.TypeJavaSymbol innerClass = getClassSymbol(classSymbol, bytecodeName, flags); innerClass.flags |= Flags.filterAccessBytecodeFlags(flags); Preconditions.checkState(innerClass.owner == classSymbol, "Innerclass: " + innerClass.owner.getName() + " and classSymbol: " + classSymbol.getName() + " are not the same."); classSymbol.members.enter(innerClass); }
@Override public boolean isPackageVisibility() { complete(); return Flags.isNotFlagged(flags, Flags.PROTECTED | Flags.PRIVATE | Flags.PUBLIC); }
private static boolean isSynchronized(Symbol methodSymbol) { return Flags.isFlagged( ((JavaSymbol) methodSymbol).flags(), Flags.SYNCHRONIZED); }
@Override public void visit(int version, int flags, String name, @Nullable String signature, @Nullable String superName, @Nullable String[] interfaces) { Preconditions.checkState(name.endsWith(classSymbol.name), "Name : '%s' should ends with %s", name, classSymbol.name); Preconditions.checkState(name.endsWith("package-info") || isNotSynthetic(flags), "%s is synthetic", name); className = name; if (signature != null) { SignatureReader signatureReader = new SignatureReader(signature); signatureReader.accept(new TypeParameterDeclaration(classSymbol)); ReadGenericSignature readGenericSignature = new ReadGenericSignature(); signatureReader.accept(readGenericSignature); ((ClassJavaType) classSymbol.type).interfaces = readGenericSignature.interfaces(); } else { if (superName == null) { Preconditions.checkState("java/lang/Object".equals(className), "superName must be null only for java/lang/Object, but not for %s", className); // TODO(Godin): what about interfaces and annotations } else { ((ClassJavaType) classSymbol.type).supertype = getClassSymbol(superName).type; } ((ClassJavaType) classSymbol.type).interfaces = getCompletedClassSymbolsType(interfaces); } //if class has already access flags set (inner class) then do not reset those. //The important access flags are the one defined in the outer class. if ((classSymbol.flags & Flags.ACCESS_FLAGS) != 0) { classSymbol.flags |= Flags.filterAccessBytecodeFlags(flags & ~Flags.ACCESS_FLAGS); } else { classSymbol.flags |= Flags.filterAccessBytecodeFlags(flags); } classSymbol.members = new Scope(classSymbol); }