}
}
}
// check @Override annotation
final CompilerOptions compilerOptions = this.scope.compilerOptions();
checkOverride: {
if (this.binding == null) break checkOverride;
long complianceLevel = compilerOptions.complianceLevel;
if (complianceLevel < ClassFileConstants.JDK1_5) break checkOverride;
int bindingModifiers = this.binding.modifiers;
boolean hasOverrideAnnotation = (this.binding.tagBits & TagBits.AnnotationOverride) != 0;
boolean hasUnresolvedArguments = (this.binding.tagBits & TagBits.HasUnresolvedArguments) != 0;
if (hasOverrideAnnotation && !hasUnresolvedArguments) {
// no static method is considered overriding
if ((bindingModifiers & (ClassFileConstants.AccStatic|ExtraCompilerModifiers.AccOverriding)) == ExtraCompilerModifiers.AccOverriding)
break checkOverride;
// in 1.5, strictly for overriding superclass method
// in 1.6 and above, also tolerate implementing interface method
if (complianceLevel >= ClassFileConstants.JDK1_6
&& ((bindingModifiers & (ClassFileConstants.AccStatic|ExtraCompilerModifiers.AccImplementing)) == ExtraCompilerModifiers.AccImplementing))
break checkOverride;
// claims to override, and doesn't actually do so
this.scope.problemReporter().methodMustOverride(this, complianceLevel);
} else {
//In case of a concrete class method, we have to check if it overrides(in 1.5 and above) OR implements a method(1.6 and above).
//Also check if the method has a signature that is override-equivalent to that of any public method declared in Object.
if (!this.binding.declaringClass.isInterface()){
if((bindingModifiers & (ClassFileConstants.AccStatic|ExtraCompilerModifiers.AccOverriding)) == ExtraCompilerModifiers.AccOverriding) {
this.scope.problemReporter().missingOverrideAnnotation(this);
} else {
if(complianceLevel >= ClassFileConstants.JDK1_6
&& compilerOptions.reportMissingOverrideAnnotationForInterfaceMethodImplementation
&& this.binding.isImplementing()) {
// actually overrides, but did not claim to do so
this.scope.problemReporter().missingOverrideAnnotationForInterfaceMethodImplementation(this);
}
}
}
else { //For 1.6 and above only
//In case of a interface class method, we have to check if it overrides a method (isImplementing returns true in case it overrides)
//Also check if the method has a signature that is override-equivalent to that of any public method declared in Object.
if(complianceLevel >= ClassFileConstants.JDK1_6
&& compilerOptions.reportMissingOverrideAnnotationForInterfaceMethodImplementation
&& (((bindingModifiers & (ClassFileConstants.AccStatic|ExtraCompilerModifiers.AccOverriding)) == ExtraCompilerModifiers.AccOverriding) || this.binding.isImplementing())){
// actually overrides, but did not claim to do so
this.scope.problemReporter().missingOverrideAnnotationForInterfaceMethodImplementation(this);
}
}
}
}
// by grammatical construction, interface methods are always abstract
switch (TypeDeclaration.kind(this.scope.referenceType().modifiers)) {
case TypeDeclaration.ENUM_DECL :
if (this.selector == TypeConstants.VALUES) break;
if (this.selector == TypeConstants.VALUEOF) break;
//$FALL-THROUGH$
case TypeDeclaration.CLASS_DECL :
// if a method has an semicolon body and is not declared as abstract==>error
// native methods may have a semicolon body
if ((this.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0) {
if ((this.modifiers & ClassFileConstants.AccNative) == 0)
if ((this.modifiers & ClassFileConstants.AccAbstract) == 0)
this.scope.problemReporter().methodNeedBody(this);
} else {
// the method HAS a body --> abstract native modifiers are forbiden
if (((this.modifiers & ClassFileConstants.AccNative) != 0) || ((this.modifiers & ClassFileConstants.AccAbstract) != 0))
this.scope.problemReporter().methodNeedingNoBody(this);
else if (this.binding != null && !this.binding.isStatic() && !(this.binding.declaringClass instanceof LocalTypeBinding) && !returnsUndeclTypeVar) {
// Not a method of local type - can be static
this.bits |= ASTNode.CanBeStatic;
}
}
}
super.resolveStatements();
// TagBits.OverridingMethodWithSupercall is set during the resolveStatements() call
if (compilerOptions.getSeverity(CompilerOptions.OverridingMethodWithoutSuperInvocation) != ProblemSeverities.Ignore) {
if (this.binding != null) {
int bindingModifiers = this.binding.modifiers;
if ((bindingModifiers & (ExtraCompilerModifiers.AccOverriding|ExtraCompilerModifiers.AccImplementing)) == ExtraCompilerModifiers.AccOverriding
&& (this.bits & ASTNode.OverridingMethodWithSupercall) == 0) {
this.scope.problemReporter().overridesMethodWithoutSuperInvocation(this.binding);