import org.eclipse.jdt.core.compiler.*;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
+import org.eclipse.jdt.internal.compiler.env.IGenericType;
import org.eclipse.jdt.internal.compiler.flow.ExceptionHandlingFlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.flow.InitializationFlowContext;
public class MethodDeclaration extends AbstractMethodDeclaration {
public TypeReference returnType;
-
+ public TypeParameter[] typeParameters;
+
/**
* MethodDeclaration constructor comment.
*/
}
}
+ // skip enum implicit methods
+ if (binding.declaringClass.isEnum() && (this.selector == TypeConstants.VALUES || this.selector == TypeConstants.VALUEOF))
+ return;
+
// may be in a non necessary <clinit> for innerclass with static final constant fields
if (binding.isAbstract() || binding.isNative())
return;
-
+
ExceptionHandlingFlowContext methodContext =
new ExceptionHandlingFlowContext(
initializationContext,
scope,
FlowInfo.DEAD_END);
+ // tag parameters as being set
+ if (this.arguments != null) {
+ for (int i = 0, count = this.arguments.length; i < count; i++) {
+ flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);
+ }
+ }
// propagate to statements
if (statements != null) {
boolean didAlreadyComplain = false;
}
}
+ public boolean isMethod() {
+
+ return true;
+ }
+
public void parseStatements(Parser parser, CompilationUnitDeclaration unit) {
//fill up the method body with statement
this.returnType.resolvedType = this.binding.returnType;
// record the return type binding
}
- // look if the name of the method is correct
- if (binding != null && isTypeUseDeprecated(binding.returnType, scope))
- scope.problemReporter().deprecatedType(binding.returnType, returnType);
-
// check if method with constructor name
if (CharOperation.equals(scope.enclosingSourceType().sourceName, selector)) {
scope.problemReporter().methodWithConstructorName(this);
}
+ // check @Override annotation
+ if (this.binding != null
+ && (this.binding.tagBits & TagBits.AnnotationOverride) != 0
+ && (this.binding.modifiers & AccOverriding) == 0) {
+ scope.problemReporter().methodMustOverride(this);
+ }
+
// by grammatical construction, interface methods are always abstract
- if (!scope.enclosingSourceType().isInterface()){
-
- // if a method has an semicolon body and is not declared as abstract==>error
- // native methods may have a semicolon body
- if ((modifiers & AccSemicolonBody) != 0) {
- if ((modifiers & AccNative) == 0)
- if ((modifiers & AccAbstract) == 0)
- scope.problemReporter().methodNeedBody(this);
- } else {
- // the method HAS a body --> abstract native modifiers are forbiden
- if (((modifiers & AccNative) != 0) || ((modifiers & AccAbstract) != 0))
- scope.problemReporter().methodNeedingNoBody(this);
- }
+ switch (scope.referenceType().kind()) {
+ case IGenericType.ENUM_DECL :
+ if (this.selector == TypeConstants.VALUES) break;
+ if (this.selector == TypeConstants.VALUEOF) break;
+ case IGenericType.CLASS_DECL :
+ // if a method has an semicolon body and is not declared as abstract==>error
+ // native methods may have a semicolon body
+ if ((modifiers & AccSemicolonBody) != 0) {
+ if ((modifiers & AccNative) == 0)
+ if ((modifiers & AccAbstract) == 0)
+ scope.problemReporter().methodNeedBody(this);
+ } else {
+ // the method HAS a body --> abstract native modifiers are forbiden
+ if (((modifiers & AccNative) != 0) || ((modifiers & AccAbstract) != 0))
+ scope.problemReporter().methodNeedingNoBody(this);
+ }
}
super.resolveStatements();
}
ClassScope classScope) {
if (visitor.visit(this, classScope)) {
+ if (this.annotations != null) {
+ int annotationsLength = this.annotations.length;
+ for (int i = 0; i < annotationsLength; i++)
+ this.annotations[i].traverse(visitor, scope);
+ }
+ if (this.typeParameters != null) {
+ int typeParametersLength = this.typeParameters.length;
+ for (int i = 0; i < typeParametersLength; i++) {
+ this.typeParameters[i].traverse(visitor, scope);
+ }
+ }
if (returnType != null)
returnType.traverse(visitor, scope);
if (arguments != null) {
}
visitor.endVisit(this, classScope);
}
+ public TypeParameter[] typeParameters() {
+ return this.typeParameters;
+ }
}