/* Answer true if the method use is considered deprecated.
* An access in the same compilation unit is allowed.
*/
public final boolean isMethodUseDeprecated(
MethodBinding method, Scope scope, boolean isExplicitUse) {
// ignore references insing Javadoc comments
if ((this.bits & ASTNode.InsideJavadoc) == 0
&& method.isOrEnclosedByPrivateType()
&& !scope.isDefinedInMethod(method)) {
// ignore cases where method is used from inside itself (e.g. direct recursions)
method.original().modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
}
// TODO (maxime) consider separating concerns between deprecation and access restriction.
// Caveat: this was not the case when access restriction funtion was added.
if (isExplicitUse && (method.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0) {
// note: explicit constructors calls warnings are kept despite the 'new C1()' case (two
// warnings, one on type, the other on constructor), because of the 'super()' case.
AccessRestriction restriction =
scope.environment().getAccessRestriction(method.declaringClass.erasure());
if (restriction != null) {
scope
.problemReporter()
.forbiddenReference(
method,
this,
restriction.classpathEntryType,
restriction.classpathEntryName,
restriction.getProblemId());
}
}
if (!method.isViewedAsDeprecated()) return false;
// inside same unit - no report
if (scope.isDefinedInSameUnit(method.declaringClass)) return false;
// non explicit use and non explicitly deprecated - no report
if (!isExplicitUse && (method.modifiers & ClassFileConstants.AccDeprecated) == 0) {
return false;
}
// if context is deprecated, may avoid reporting
if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode
&& scope.isInsideDeprecatedCode()) return false;
return true;
}
/* Answer true if the type use is considered deprecated.
* An access in the same compilation unit is allowed.
*/
public final boolean isTypeUseDeprecated(TypeBinding type, Scope scope) {
if (type.isArrayType()) {
type = ((ArrayBinding) type).leafComponentType;
}
if (type.isBaseType()) return false;
ReferenceBinding refType = (ReferenceBinding) type;
// ignore references insing Javadoc comments
if ((this.bits & ASTNode.InsideJavadoc) == 0
&& refType.isOrEnclosedByPrivateType()
&& !scope.isDefinedInType(refType)) {
// ignore cases where type is used from inside itself
((ReferenceBinding) refType.erasure()).modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
}
if (refType.hasRestrictedAccess()) {
AccessRestriction restriction = scope.environment().getAccessRestriction(type.erasure());
if (restriction != null) {
scope
.problemReporter()
.forbiddenReference(
type,
this,
restriction.classpathEntryType,
restriction.classpathEntryName,
restriction.getProblemId());
}
}
// force annotations resolution before deciding whether the type may be deprecated
refType.initializeDeprecatedAnnotationTagBits();
if (!refType.isViewedAsDeprecated()) return false;
// inside same unit - no report
if (scope.isDefinedInSameUnit(refType)) return false;
// if context is deprecated, may avoid reporting
if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode
&& scope.isInsideDeprecatedCode()) return false;
return true;
}
public final boolean isFieldUseDeprecated(
FieldBinding field, Scope scope, boolean isStrictlyAssigned) {
// ignore references insing Javadoc comments
if ((this.bits & ASTNode.InsideJavadoc) == 0
&& !isStrictlyAssigned
&& field.isOrEnclosedByPrivateType()
&& !scope.isDefinedInField(field)) {
// ignore cases where field is used from inside itself
field.original().modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
}
if ((field.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0) {
AccessRestriction restriction =
scope.environment().getAccessRestriction(field.declaringClass.erasure());
if (restriction != null) {
scope
.problemReporter()
.forbiddenReference(
field,
this,
restriction.classpathEntryType,
restriction.classpathEntryName,
restriction.getProblemId());
}
}
if (!field.isViewedAsDeprecated()) return false;
// inside same unit - no report
if (scope.isDefinedInSameUnit(field.declaringClass)) return false;
// if context is deprecated, may avoid reporting
if (!scope.compilerOptions().reportDeprecationInsideDeprecatedCode
&& scope.isInsideDeprecatedCode()) return false;
return true;
}