Attachment #131032 for bug #268542




	public int maximalNumberOfFixes(JavaScriptUnit compilationUnit) {
		int result= 0;
		IProblem[] problems= compilationUnit.getProblems();
		if (isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS) && isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS_OVERRIDE)) {
			result+= getNumberOfProblems(problems, IProblem.MissingOverrideAnnotation);
		}
		if (isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS) && isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS_DEPRECATED)) {
			for (int i=0;i<problems.length;i++) {
				int id= problems[i].getID();
				if (id == IProblem.FieldMissingDeprecatedAnnotation || id == IProblem.MethodMissingDeprecatedAnnotation || id == IProblem.TypeMissingDeprecatedAnnotation)
					result++;
			}
		}
		if (isEnabled(CleanUpConstants.VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES)) {
			for (int i=0;i<problems.length;i++) {
				int id= problems[i].getID();




			proposals.add(new ModifierChangeCompletionProposal(label, cu, binding, selectedNode, Modifier.FINAL, 0, 5, image));
		}
	}
//	
//	public static void addOverrideAnnotationProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
//		IFix fix= Java50Fix.createAddOverrideAnnotationFix(context.getASTRoot(), problem);
//		if (fix != null) {
//			Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
//			Map options= new Hashtable();
//			options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS, CleanUpConstants.TRUE);
//			options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS_OVERRIDE, CleanUpConstants.TRUE);
//			FixCorrectionProposal proposal= new FixCorrectionProposal(fix, new Java50CleanUp(options), 5, image, context);
//			proposals.add(proposal);
//		}
//	}
//	
//	public static void addDeprecatedAnnotationProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
//		IFix fix= Java50Fix.createAddDeprectatedAnnotation(context.getASTRoot(), problem);
//		if (fix != null) {
//			Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
//			Map options= new Hashtable();
//			options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS, CleanUpConstants.TRUE);
//			options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS_DEPRECATED, CleanUpConstants.TRUE);
//			FixCorrectionProposal proposal= new FixCorrectionProposal(fix, new Java50CleanUp(options), 5, image, context);
//			proposals.add(proposal);
//		}
//	}
	
	public static void addOverridingDeprecatedMethodProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
		

		ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, cu, rewrite, 15, image);
		proposals.add(proposal);
	}
		
	public static void removeOverrideAnnotationProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
//		IJavaScriptUnit cu= context.getCompilationUnit();
//
//		ASTNode selectedNode= problem.getCoveringNode(context.getASTRoot());
//		if (!(selectedNode instanceof FunctionDeclaration)) {
//			return;
//		}
//		FunctionDeclaration methodDecl= (FunctionDeclaration) selectedNode;
//		Annotation annot= findAnnotation("java.lang.Override", methodDecl.modifiers()); //$NON-NLS-1$
//		if (annot != null) {
//			ASTRewrite rewrite= ASTRewrite.create(annot.getAST());
//			rewrite.remove(annot, null);
//			String label= CorrectionMessages.ModifierCorrectionSubProcessor_remove_override;
//			Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
//			ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, cu, rewrite, 6, image);
//			proposals.add(proposal);
//			
//			QuickAssistProcessor.getCreateInSuperClassProposals(context, methodDecl.getName(), proposals);
//		}
	}

	private static final String KEY_MODIFIER= "modifier"; //$NON-NLS-1$
	




			case IProblem.RedefinedArgument:
			case IProblem.CodeCannotBeReached:
			case IProblem.InvalidUsageOfTypeParameters:
			case IProblem.InvalidUsageOfStaticImports:
			case IProblem.InvalidUsageOfForeachStatements:
			case IProblem.InvalidUsageOfTypeArguments:
			case IProblem.InvalidUsageOfEnumDeclarations:
			case IProblem.InvalidUsageOfVarargs:
			case IProblem.InvalidUsageOfAnnotations:
			case IProblem.InvalidUsageOfAnnotationDeclarations:
			case IProblem.FieldMissingDeprecatedAnnotation:
			case IProblem.OverridingDeprecatedMethod:
			case IProblem.MethodMissingDeprecatedAnnotation:
			case IProblem.TypeMissingDeprecatedAnnotation:
			case IProblem.MissingOverrideAnnotation:
			case IProblem.MethodMustOverride:
			case IProblem.MethodMustOverrideOrImplement:
			case IProblem.IsClassPathCorrect:
			case IProblem.MethodReturnsVoid:
			case IProblem.ForbiddenReference:

			case IProblem.UnnecessaryNLSTag:
			case IProblem.AssignmentHasNoEffect:
			case IProblem.UnsafeTypeConversion:
			case IProblem.UndefinedAnnotationMember:
			case IProblem.MissingValueForAnnotationMember:
			case IProblem.FallthroughCase:
			case IProblem.NonGenericType:
			case IProblem.UnhandledWarningToken:
				return true;
			default:
//				if (JavaModelUtil.is50OrHigher(cu.getJavaScriptProject())) {

				LocalCorrectionsSubProcessor.getUnreachableCodeProposals(context, problem, proposals);
				break;
			case IProblem.InvalidUsageOfTypeParameters:
			case IProblem.InvalidUsageOfStaticImports:
			case IProblem.InvalidUsageOfForeachStatements:
			case IProblem.InvalidUsageOfTypeArguments:
			case IProblem.InvalidUsageOfEnumDeclarations:
			case IProblem.InvalidUsageOfVarargs:
			case IProblem.InvalidUsageOfAnnotations:
			case IProblem.InvalidUsageOfAnnotationDeclarations:
				ReorgCorrectionsSubProcessor.getNeed50ComplianceProposals(context, problem, proposals);
				break;
			case IProblem.NonGenericType:
				TypeParameterMismatchSubProcessor.removeMismatchedParameters(context, problem, proposals);
				break;
//			case IProblem.MissingOverrideAnnotation:
//				ModifierCorrectionSubProcessor.addOverrideAnnotationProposal(context, problem, proposals);
//				break;
			case IProblem.MethodMustOverride:
			case IProblem.MethodMustOverrideOrImplement:
				ModifierCorrectionSubProcessor.removeOverrideAnnotationProposal(context, problem, proposals);
				break;
			case IProblem.FieldMissingDeprecatedAnnotation:
			case IProblem.MethodMissingDeprecatedAnnotation:
			case IProblem.TypeMissingDeprecatedAnnotation:
//				ModifierCorrectionSubProcessor.addDeprecatedAnnotationProposal(context, problem, proposals);
				break;
			case IProblem.OverridingDeprecatedMethod:
				ModifierCorrectionSubProcessor.addOverridingDeprecatedMethodProposal(context, problem, proposals);
				break;




					upperScope.problemReporter().undocumentedEmptyBlock(this.blockStart, this.sourceEnd);
				}
			}
			// for enum switch, check if all constants are accounted for (if no default)
//			if (isEnumSwitch && defaultCase == null
//					&& upperScope.compilerOptions().getSeverity(CompilerOptions.IncompleteEnumSwitch) != ProblemSeverities.Ignore) {
//				int constantCount = this.constants == null ? 0 : this.constants.length; // could be null if no case statement
//				if (constantCount == caseCount // ignore diagnosis if unresolved constants
//						&& caseCount != ((ReferenceBinding)expressionType).enumConstantCount()) {
//					FieldBinding[] enumFields = ((ReferenceBinding)expressionType.erasure()).fields();
//					for (int i = 0, max = enumFields.length; i <max; i++) {
//						FieldBinding enumConstant = enumFields[i];
//						if ((enumConstant.modifiers & ClassFileConstants.AccEnum) == 0) continue;
//						findConstant : {
//							for (int j = 0; j < caseCount; j++) {
//								if ((enumConstant.id + 1) == this.constants[j]) // zero should not be returned see bug 141810
//									break findConstant;
//							}
//							// enum constant did not get referenced from switch
//							upperScope.problemReporter().missingEnumConstantCase(this, enumConstant);
//						}
//					}
//				}
//			}
	    } finally {
	        if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
	    }




			if (needValue || complyTo14) {
				manageSyntheticAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0, flowInfo);
			}
			if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
				ReferenceBinding declaringClass = lastFieldBinding.declaringClass;
				// check if accessing enum static field in initializer
				if (declaringClass.isEnum()) {
					MethodScope methodScope = currentScope.methodScope();
					SourceTypeBinding sourceType = methodScope.enclosingSourceType();
					if (lastFieldBinding.isStatic()
							&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& lastFieldBinding.constant() == Constant.NotAConstant
							&& !methodScope.isStatic
							&& methodScope.isInsideInitializerOrConstructor()) {
						currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(lastFieldBinding, this);
					}
				}
			}
			// check if final blank field
			if (lastFieldBinding.isBlankFinal()
				    && this.otherBindings != null // the last field binding is only assigned

			}
			if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
				FieldBinding fieldBinding = (FieldBinding) this.binding;

				// check if accessing enum static field in initializer
				if (declaringClass.isEnum()) {
					MethodScope methodScope = currentScope.methodScope();
					SourceTypeBinding sourceType = methodScope.enclosingSourceType();
					if (fieldBinding.isStatic()
							&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& fieldBinding.constant() == Constant.NotAConstant
							&& !methodScope.isStatic
							&& methodScope.isInsideInitializerOrConstructor()) {
						currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
					}
				}
				// check if reading a final blank field
				if (fieldBinding.isBlankFinal()
						&& currentScope.allowBlankFinalFieldAssignment(fieldBinding)

Lines 70-78 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/InstanceOfExpression.java (-3 / +1 lines)
70	if (expressionType == null \|\| checkedType == null)	70	if (expressionType == null \|\| checkedType == null)
71	return null;	71	return null;
72		72
73	if (!checkedType.isReifiable()) {	73	if ((expressionType != TypeBinding.NULL && expressionType.isBaseType()) // disallow autoboxing
74	scope.problemReporter().illegalInstanceOfGenericType(checkedType, this);
75	} else if ((expressionType != TypeBinding.NULL && expressionType.isBaseType()) // disallow autoboxing
76	\|\| !checkCastTypesCompatibility(scope, checkedType, expressionType, null)) {	74	\|\| !checkCastTypesCompatibility(scope, checkedType, expressionType, null)) {
77	scope.problemReporter().notCompatibleTypesError(this, expressionType, checkedType);	75	scope.problemReporter().notCompatibleTypesError(this, expressionType, checkedType);
78	}	76	}




import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemReferenceBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.RawTypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TagBits;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeIds;

/**
 * Variation on allocation, where can optionally be specified any of:

				TypeReference typeReference = this.typeArguments[i];
				TypeBinding argType = typeReference.resolveType(scope, true /* check bounds*/);
				if (argType == null) {
					if (typeReference instanceof Wildcard) {
						scope.problemReporter().illegalUsageOfWildcard(typeReference);
					}
					return null; // error already reported
				}
				this.genericTypeArguments[i] = argType;

		// insert anonymous type in scope
		scope.addAnonymousType(this.anonymousType, (ReferenceBinding) receiverType);
		this.anonymousType.resolve(scope);
		if (this.superTypeBinding.erasure().id == TypeIds.T_JavaLangEnum) {
			scope.problemReporter().cannotExtendEnum(this.anonymousType.binding, this.type, this.superTypeBinding);
		}

		if ((receiverType.tagBits & TagBits.HasDirectWildcard) != 0) {
			scope.problemReporter().superTypeCannotUseWildcard(this.anonymousType.binding, this.type, receiverType);
		}
		// find anonymous super constructor
		MethodBinding inheritedBinding = scope.getConstructor(this.superTypeBinding, argumentTypes, this);
		if (!inheritedBinding.isValidBinding()) {




import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodScope;
import org.eclipse.wst.jsdt.internal.compiler.lookup.Scope;
import org.eclipse.wst.jsdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TagBits;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;

public class FieldDeclaration extends AbstractVariableDeclaration implements IFieldDeclaration {

		initializationScope.lastVisibleFieldID = this.binding.id;

//		resolveAnnotations(initializationScope, this.annotations, this.binding);
		// check @Deprecated annotation presence
		if ((this.binding.getAnnotationTagBits() & TagBits.AnnotationDeprecated) == 0
				&& (this.binding.modifiers & ClassFileConstants.AccDeprecated) != 0
				&& initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
			initializationScope.problemReporter().missingDeprecatedAnnotationForField(this);
		}
		// the resolution of the initialization hasn't been done
		if (this.initialization == null) {
			this.binding.setConstant(Constant.NotAConstant);




	public void resolveStatements() {

		super.resolveStatements();
		if (this.arguments != null) {
			scope.problemReporter().annotationMembersCannotHaveParameters(this);
		}
		if (this.typeParameters != null) {
			scope.problemReporter().annotationMembersCannotHaveTypeParameters(this);
		}
		if (this.extendedDimensions != 0) {
			scope.problemReporter().illegalExtendedDimensions(this);
		}
		if (this.binding == null) return;
		TypeBinding returnTypeBinding = this.binding.returnType;
		if (returnTypeBinding != null) {

					if (leafReturnType.isEnum() || leafReturnType.isAnnotationType())
						break checkAnnotationMethodType;
				}
				scope.problemReporter().invalidAnnotationMemberType(this);
			}
			if (this.defaultValue != null) {
				MemberValuePair pair = new MemberValuePair(this.selector, this.sourceStart, this.sourceEnd, this.defaultValue);




			if (receiverType == null) {
				return;
			}
			// prevent (explicit) super constructor invocation from within enum
			if (this.accessMode == Super && receiverType.erasure().id == T_JavaLangEnum) {
				scope.problemReporter().cannotInvokeSuperConstructorInEnum(this, methodScope.referenceMethod().binding);
			}
			// qualification should be from the type of the enclosingType
			if (qualification != null) {
				if (accessMode != Super) {

					if ((this.genericTypeArguments[i] = typeReference.resolveType(scope, true /* check bounds*/)) == null) {
						argHasError = true;
					}
					if (argHasError && typeReference instanceof Wildcard) {
						scope.problemReporter().illegalUsageOfWildcard(typeReference);
					}
				}
				if (argHasError) {
					return;




		FlowInfo flowInfo) {

		if (constantExpression != null) {
			if (!this.isEnumConstant && constantExpression.constant == Constant.NotAConstant) {
				currentScope.problemReporter().caseExpressionMustBeConstant(constantExpression);
			}
			this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);
		}
		return flowInfo;

						&& (constantExpression.bits & RestrictiveFlagMASK) == Binding.FIELD) {
					NameReference reference = (NameReference) constantExpression;
					FieldBinding field = reference.fieldBinding();
					if ((field.modifiers & ClassFileConstants.AccEnum) == 0) {
						 scope.problemReporter().enumSwitchCannotTargetField(reference, field);
					} else 	if (reference instanceof QualifiedNameReference) {
						 scope.problemReporter().cannotUseQualifiedEnumConstantInCaseLabel(reference, field);
					}
					return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810
				}
			} else {




import org.eclipse.wst.jsdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.Scope;
import org.eclipse.wst.jsdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TagBits;
import org.eclipse.wst.jsdt.internal.compiler.parser.Parser;
import org.eclipse.wst.jsdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.wst.jsdt.internal.compiler.problem.AbortCompilationUnit;

			if (JavaScriptCore.IS_ECMASCRIPT4)
				bindThrownExceptions();
			resolveJavadoc();
//			if (JavaScriptCore.IS_ECMASCRIPT4)
//				resolveAnnotations(scope, this.annotations, this.binding);
			resolveStatements();
			// check @Deprecated annotation presence
			if (this.binding != null
					&& (this.binding.getAnnotationTagBits() & TagBits.AnnotationDeprecated) == 0
					&& (this.binding.modifiers & ClassFileConstants.AccDeprecated) != 0
					&& this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
				this.scope.problemReporter().missingDeprecatedAnnotationForMethod(this);
			}
		} catch (AbortMethod e) {	// ========= abort on fatal error =============
			this.ignoreFurtherInvestigation = true;
		}




							// report the problem and continue the parsing
							parser.problemReporter().interfaceCannotHaveConstructors((ConstructorDeclaration) am);
							break;
						case TypeDeclaration.ANNOTATION_TYPE_DECL :
							// report the problem and continue the parsing
							parser.problemReporter().annotationTypeDeclarationCannotHaveConstructor((ConstructorDeclaration) am);
							break;

					}
					hasConstructor = true;

//		} finally {
//			this.staticInitializerScope.insideTypeAnnotation = old;
//		}
		// check @Deprecated annotation
		if ((sourceType.getAnnotationTagBits() & TagBits.AnnotationDeprecated) == 0
				&& (sourceType.modifiers & ClassFileConstants.AccDeprecated) != 0
				&& this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
			this.scope.problemReporter().missingDeprecatedAnnotationForType(this);
		}
		if ((this.bits & ASTNode.UndocumentedEmptyBlock) != 0) {
			this.scope.problemReporter().undocumentedEmptyBlock(this.bodyStart-1, this.bodyEnd);
		}

		if (needSerialVersion) {
			this.scope.problemReporter().missingSerialVersion(this);
		}
		// check extends/implements for annotation type
		switch(kind(this.modifiers)) {
			case TypeDeclaration.ANNOTATION_TYPE_DECL :
				if (this.superclass != null) {
					this.scope.problemReporter().annotationTypeDeclarationCannotHaveSuperclass(this);
				}
				if (this.superInterfaces != null) {
					this.scope.problemReporter().annotationTypeDeclarationCannotHaveSuperinterfaces(this);
				}
				break;
			case TypeDeclaration.ENUM_DECL :
				// check enum abstract methods
				if (this.binding.isAbstract()) {
					if (!hasEnumConstants || hasEnumConstantsWithoutBody) {
						for (int i = 0, count = this.methods.length; i < count; i++) {
							final AbstractMethodDeclaration methodDeclaration = this.methods[i];
							if (methodDeclaration.isAbstract() && methodDeclaration.binding != null) {
								this.scope.problemReporter().enumAbstractMethodMustBeImplemented(methodDeclaration);
							}
						}
					}
				}
				break;
		}

		int missingAbstractMethodslength = this.missingAbstractMethods == null ? 0 : this.missingAbstractMethods.length;
		int methodsLength = this.methods == null ? 0 : this.methods.length;




					ArrayBinding varargsType = (ArrayBinding) params[varargsIndex];
					TypeBinding lastArgType = argumentTypes[varargsIndex];
					int dimensions;
					if (lastArgType != TypeBinding.NULL && (varargsType.dimensions <= (dimensions = lastArgType.dimensions()))) {
						if (!(varargsType.leafComponentType().isBaseType() && varargsType.dimensions() == 1))
							scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
					} else if (varargsType.dimensions <= (dimensions = lastArgType.dimensions())) {
						if (lastArgType.leafComponentType().isBaseType()) {
							dimensions--;
						}
						if (varargsType.dimensions < dimensions) {
							scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
						} else if (varargsType.dimensions == dimensions
										&& lastArgType != varargsType
										&& lastArgType.leafComponentType().erasure() != varargsType.leafComponentType.erasure()
										&& lastArgType.isCompatibleWith(varargsType.elementsType())
										&& lastArgType.isCompatibleWith(varargsType)) {
							scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
						}
					}
				}
			} else {




import org.eclipse.wst.jsdt.core.ast.IASTNode;
import org.eclipse.wst.jsdt.core.ast.IMemberValuePair;
import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
import org.eclipse.wst.jsdt.internal.compiler.impl.Constant;
import org.eclipse.wst.jsdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.Binding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.wst.jsdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;


			ArrayInitializer initializer = (ArrayInitializer) this.value;
			valueType = initializer.resolveTypeExpecting(scope, this.binding.returnType);
		} else if (this.value instanceof ArrayAllocationExpression) {
			scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
			this.value.resolveType(scope);
			valueType = null; // no need to pursue
		} else {

							|| (leafType.isBaseType() && BaseTypeBinding.isWidening(leafType.id, valueType.id)))
							|| valueType.isCompatibleWith(leafType))) {

				if (!leafType.isAnnotationType() || valueType.isAnnotationType()) {
					scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
				} else {
					scope.problemReporter().typeMismatchError(valueType, requiredType, this.value);
				}
				return; // may allow to proceed to find more errors at once

				case T_double :
				case T_boolean :
				case T_JavaLangString :
					if (this.value instanceof ArrayInitializer) {
						ArrayInitializer initializer = (ArrayInitializer) this.value;
						final Expression[] expressions = initializer.expressions;
						if (expressions != null) {
							for (int i =0, max = expressions.length; i < max; i++) {
								if (expressions[i].constant == Constant.NotAConstant) {
									scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, expressions[i], false);
								}
							}
						}
					} else if (this.value.constant == Constant.NotAConstant) {
						if (valueType.isArrayType()) {
							scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
						} else {
							scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, false);
						}
					}
					break checkAnnotationMethodType;
				case T_JavaLangClass :
					if (this.value instanceof ArrayInitializer) {
						ArrayInitializer initializer = (ArrayInitializer) this.value;
						final Expression[] expressions = initializer.expressions;
						if (expressions != null) {
							for (int i =0, max = expressions.length; i < max; i++) {
								Expression currentExpression = expressions[i];
								if (!(currentExpression instanceof ClassLiteralAccess)) {
									scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, currentExpression);
								}
							}
						}
					} else if (!(this.value instanceof ClassLiteralAccess)) {
						scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, this.value);
					}
					break checkAnnotationMethodType;
			}
			if (leafType.isEnum()) {
				if (this.value instanceof NullLiteral) {
					scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
				} else if (this.value instanceof ArrayInitializer) {
					ArrayInitializer initializer = (ArrayInitializer) this.value;
					final Expression[] expressions = initializer.expressions;
					if (expressions != null) {
						for (int i =0, max = expressions.length; i < max; i++) {
							Expression currentExpression = expressions[i];
							if (currentExpression instanceof NullLiteral) {
								scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
							} else if (currentExpression instanceof NameReference) {
								NameReference nameReference = (NameReference) currentExpression;
								final Binding nameReferenceBinding = nameReference.binding;
								if (nameReferenceBinding.kind() == Binding.FIELD) {
									FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
									if (!fieldBinding.declaringClass.isEnum()) {
										scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
									}
								}
							}
						}
					}
				} else if (this.value instanceof NameReference) {
					NameReference nameReference = (NameReference) this.value;
					final Binding nameReferenceBinding = nameReference.binding;
					if (nameReferenceBinding.kind() == Binding.FIELD) {
						FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
						if (!fieldBinding.declaringClass.isEnum()) {
							if (!fieldBinding.type.isArrayType()) {
								scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
							} else {
								scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
							}
						}
					}
				}
				break checkAnnotationMethodType;
			}
			if (leafType.isAnnotationType()) {
				if (!valueType.leafComponentType().isAnnotationType()) { // check annotation type and also reject null literal
					scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
				} else if (this.value instanceof ArrayInitializer) {
					ArrayInitializer initializer = (ArrayInitializer) this.value;
					final Expression[] expressions = initializer.expressions;
					if (expressions != null) {
						for (int i =0, max = expressions.length; i < max; i++) {
							Expression currentExpression = expressions[i];
							if (currentExpression instanceof NullLiteral || !(currentExpression instanceof Annotation)) {
								scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, currentExpression, leafType);
							}
						}
					}
				} else if (!(this.value instanceof Annotation)) {
					scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
				}
				break checkAnnotationMethodType;
			}
		}




import org.eclipse.wst.jsdt.core.ast.IFunctionDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
import org.eclipse.wst.jsdt.internal.compiler.CompilationResult;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.compiler.flow.ExceptionHandlingFlowContext;
import org.eclipse.wst.jsdt.internal.compiler.flow.FlowContext;
import org.eclipse.wst.jsdt.internal.compiler.flow.FlowInfo;

			}
		}

		// check @Override annotation
		final CompilerOptions compilerOptions = this.scope.compilerOptions();
		checkOverride: {
			if (this.binding == null) break checkOverride;
			long sourceLevel = compilerOptions.sourceLevel;
			if (sourceLevel < ClassFileConstants.JDK1_5) break checkOverride;
			int bindingModifiers = this.binding.modifiers;
			boolean hasOverrideAnnotation = (this.binding.tagBits & TagBits.AnnotationOverride) != 0;
			boolean isInterfaceMethod = this.binding.declaringClass.isInterface();
			if (hasOverrideAnnotation) {
				// no static method is considered overriding
				if (!isInterfaceMethod && (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 (sourceLevel >= 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);
			} else if (!isInterfaceMethod
						&& (bindingModifiers & (ClassFileConstants.AccStatic|ExtraCompilerModifiers.AccOverriding)) == ExtraCompilerModifiers.AccOverriding) {
				// actually overrides, but did not claim to do so
				this.scope.problemReporter().missingOverrideAnnotation(this);
			}
		}

		// by grammatical construction, interface methods are always abstract
//		switch (TypeDeclaration.kind(this.scope.referenceType().modifiers)) {




import org.eclipse.wst.jsdt.core.ast.IAnnotation;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.wst.jsdt.internal.compiler.impl.Constant;
import org.eclipse.wst.jsdt.internal.compiler.lookup.AnnotationBinding;

									FieldBinding field = ((Reference) initExpr).fieldBinding();
									if (field != null && field.declaringClass.id == T_JavaLangAnnotationElementType) {
										long element = getTargetElementType(field.name);
										if ((tagBits & element) == 0) {
											scope.problemReporter().duplicateTargetInTargetAnnotation(annotationType, (NameReference)initExpr);
										} else {
											tagBits |= element;
										}
									}

								if (irritant != 0) {
									suppressWarningIrritants |= irritant;
									if (~suppressWarningIrritants == 0) break pairLoop;
								} else {
									scope.problemReporter().unhandledWarningToken(inits[j]);
								}
							}
						}

						if (irritant != 0) {
							suppressWarningIrritants |= irritant;
							if (~suppressWarningIrritants == 0) break pairLoop;
						} else {
							scope.problemReporter().unhandledWarningToken(value);
						}
					}
				}

						if (otherPair == null) continue;
						if (CharOperation.equals(otherPair.name, selector)) {
							foundDuplicate = true;
							scope.problemReporter().duplicateAnnotationValue(annotationType, otherPair);
							otherPair.binding = method;
							otherPair.resolveTypeExpecting(scope, method.returnType);
							pairs[k] = null;
						}
					}
					if (foundDuplicate) {
						scope.problemReporter().duplicateAnnotationValue(annotationType, pair);
						continue nextMember;
					}
				}
			}
			if (!foundValue && (method.modifiers & ClassFileConstants.AccAnnotationDefault) == 0) {
				scope.problemReporter().missingValueForAnnotationMember(this, selector);
			}
		}
		// check unused pairs
		for (int i = 0; i < pairsLength; i++) {
			if (pairs[i] != null) {
				scope.problemReporter().undefinedAnnotationValue(annotationType, pairs[i]);
				pairs[i].resolveTypeExpecting(scope, null); // resilient
			}
		}

							break checkTargetCompatibility;
						break;
				}
				scope.problemReporter().disallowedTargetForAnnotation(this);
			}
		}
		return this.resolvedType;




import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemFieldBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemReferenceBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.Scope;
import org.eclipse.wst.jsdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TagBits;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.VariableBinding;

				manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /*write-access*/);

				FieldBinding fieldBinding = (FieldBinding) binding;
				ReferenceBinding declaringClass = fieldBinding.declaringClass;
				// check if accessing enum static field in initializer
				if (declaringClass.isEnum()) {
					MethodScope methodScope = currentScope.methodScope();
					SourceTypeBinding sourceType = currentScope.enclosingSourceType();
					if (fieldBinding.isStatic()
							&& this.constant == Constant.NotAConstant
							&& !methodScope.isStatic
							&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& methodScope.isInsideInitializerOrConstructor()) {
						currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
					}
				}
				// check if assigning a final field
				if (fieldBinding.isFinal()) {
					// inside a context where allowed

					manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /*read-access*/);
				}
				FieldBinding fieldBinding = (FieldBinding) binding;

				// check if accessing enum static field in initializer
				if (declaringClass.isEnum()) {
					MethodScope methodScope = currentScope.methodScope();
					SourceTypeBinding sourceType = currentScope.enclosingSourceType();
					if (fieldBinding.isStatic()
							&& this.constant == Constant.NotAConstant
							&& !methodScope.isStatic
							&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& methodScope.isInsideInitializerOrConstructor()) {
						currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
					}
				}
				// check if reading a final blank field
				if (fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
					if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {

Lines 393-401 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/CompilationUnitDeclaration.java (-3 lines)
393	this.javadoc.resolve(this.scope);	393	this.javadoc.resolve(this.scope);
394	}	394	}
395	}	395	}
396	if (this.currentPackage != null && this.currentPackage.annotations != null && !isPackageInfo) {
397	scope.problemReporter().invalidFileNameForPackageAnnotations(this.currentPackage.annotations[0]);
398	}
399	try {	396	try {
400	if (types != null) {	397	if (types != null) {
401	for (int i = startingTypeIndex, count = types.length; i < count; i++) {	398	for (int i = startingTypeIndex, count = types.length; i < count; i++) {

Lines 405-411 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/MessageSend.java (-1 lines)
405	case ProblemReasons.NonStaticReferenceInConstructorInvocation :	405	case ProblemReasons.NonStaticReferenceInConstructorInvocation :
406	case ProblemReasons.NonStaticReferenceInStaticContext :	406	case ProblemReasons.NonStaticReferenceInStaticContext :
407	case ProblemReasons.ReceiverTypeNotVisible :	407	case ProblemReasons.ReceiverTypeNotVisible :
408	case ProblemReasons.ParameterBoundMismatch :
409	// only steal returnType in cases listed above	408	// only steal returnType in cases listed above
410	if (closestMatch != null) this.resolvedType = closestMatch.returnType;	409	if (closestMatch != null) this.resolvedType = closestMatch.returnType;
411	default :	410	default :




import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractVariableDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.wst.jsdt.internal.compiler.ast.Annotation;
import org.eclipse.wst.jsdt.internal.compiler.ast.AnnotationMethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;
import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayAllocationExpression;
import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayQualifiedTypeReference;

import org.eclipse.wst.jsdt.internal.compiler.ast.Literal;
import org.eclipse.wst.jsdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.LongLiteral;
import org.eclipse.wst.jsdt.internal.compiler.ast.MemberValuePair;
import org.eclipse.wst.jsdt.internal.compiler.ast.MessageSend;
import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.NameReference;

import org.eclipse.wst.jsdt.internal.compiler.ast.ReturnStatement;
import org.eclipse.wst.jsdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.Statement;
import org.eclipse.wst.jsdt.internal.compiler.ast.SwitchStatement;
import org.eclipse.wst.jsdt.internal.compiler.ast.ThisReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.TypeParameter;

import org.eclipse.wst.jsdt.internal.compiler.lookup.InvocationSite;
import org.eclipse.wst.jsdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemMethodBinding;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemReferenceBinding;

			return CompilerOptions.FieldHiding;

		case IProblem.TypeParameterHidingType:
		case IProblem.TypeHidingTypeParameterFromType:
		case IProblem.TypeHidingTypeParameterFromMethod:
		case IProblem.TypeHidingType:
			return CompilerOptions.TypeHiding;


		case IProblem.UnsafeReturnTypeOverride:
			return CompilerOptions.UncheckedTypeOperation;

		case IProblem.MissingOverrideAnnotation:
			return CompilerOptions.MissingOverrideAnnotation;

		case IProblem.FieldMissingDeprecatedAnnotation:
		case IProblem.MethodMissingDeprecatedAnnotation:
		case IProblem.TypeMissingDeprecatedAnnotation:
			return CompilerOptions.MissingDeprecatedAnnotation;

		case IProblem.FinalBoundForTypeVariable:
		    return CompilerOptions.FinalParameterBound;


		case IProblem.DiscouragedReference:
			return CompilerOptions.DiscouragedReference;

		case IProblem.MethodVarargsArgumentNeedCast :
		case IProblem.ConstructorVarargsArgumentNeedCast :
			return CompilerOptions.VarargsArgumentNeedCast;

		case IProblem.NullLocalVariableReference:
			return CompilerOptions.NullReference;


		case IProblem.UnboxingConversion :
			return CompilerOptions.AutoBoxing;

		case IProblem.MissingEnumConstantCase :
			return CompilerOptions.IncompleteEnumSwitch;

		case IProblem.AnnotationTypeUsedAsSuperInterface :
			return CompilerOptions.AnnotationSuperInterface;

		case IProblem.UnhandledWarningToken :
			return CompilerOptions.UnhandledWarningToken;

		case IProblem.UnusedLabel :
			return CompilerOptions.UnusedLabel;


		case IProblem.JavadocInheritedFieldHidesEnclosingName:
		case IProblem.JavadocInheritedNameHidesEnclosingTypeName:
		case IProblem.JavadocNonStaticTypeFromStaticInvocation:
		case IProblem.JavadocGenericMethodTypeArgumentMismatch:
		case IProblem.JavadocNonGenericMethod:
		case IProblem.JavadocIncorrectArityForParameterizedMethod:
		case IProblem.JavadocParameterizedMethodArgumentTypeMismatch:
		case IProblem.JavadocTypeArgumentsForRawGenericMethod:
		case IProblem.JavadocGenericConstructorTypeArgumentMismatch:
		case IProblem.JavadocNonGenericConstructor:
		case IProblem.JavadocIncorrectArityForParameterizedConstructor:
		case IProblem.JavadocParameterizedConstructorArgumentTypeMismatch:
		case IProblem.JavadocTypeArgumentsForRawGenericConstructor:
		case IProblem.JavadocNotVisibleField:
		case IProblem.JavadocNotVisibleConstructor:
		case IProblem.JavadocNotVisibleMethod:

		case IProblem.WrongNumberOfArguments:
			return CompilerOptions.WrongNumberOfArguments;
			
		case IProblem.NonConstantExpression:
			return CompilerOptions.SwitchCaseShouldBeConstant;
		case IProblem.MissingSemiColon:
			return CompilerOptions.OptionalSemicolon;


			switch (irritantInt) {
				case (int)(CompilerOptions.FinalParameterBound >>> 32):
				case (int)(CompilerOptions.EnumUsedAsAnIdentifier >>> 32):
				case (int)(CompilerOptions.AnnotationSuperInterface >>> 32):
				case (int)(CompilerOptions.AutoBoxing >>> 32):
				case (int)(CompilerOptions.MissingOverrideAnnotation >>> 32):
				case (int)(CompilerOptions.MissingDeprecatedAnnotation >>> 32):
				case (int)(CompilerOptions.ParameterAssignment >>> 32):
					return CategorizedProblem.CAT_CODE_STYLE;

				case (int)(CompilerOptions.MissingSerialVersion >>> 32):
				case (int)(CompilerOptions.VarargsArgumentNeedCast >>> 32):
				case (int)(CompilerOptions.NullReference >>> 32):
				case (int)(CompilerOptions.PotentialNullReference >>> 32):
				case (int)(CompilerOptions.DuplicateLocalVariables >>> 32):
				case (int)(CompilerOptions.RedundantNullCheck >>> 32):
				case (int)(CompilerOptions.IncompleteEnumSwitch >>> 32):
				case (int)(CompilerOptions.FallthroughCase >>> 32):
				case (int)(CompilerOptions.OverridingMethodWithoutSuperInvocation >>> 32):
					return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;

				case (int)(CompilerOptions.TypeHiding >>> 32):
					return CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT;

				case (int)(CompilerOptions.UnhandledWarningToken >>> 32):
				case (int)(CompilerOptions.UnusedLabel >>> 32):
					return CategorizedProblem.CAT_UNNECESSARY_CODE;


		location.sourceStart,
		location.sourceEnd);
}
public void annotationCannotOverrideMethod(MethodBinding overrideMethod, MethodBinding inheritedMethod) {
	ASTNode location = overrideMethod.sourceMethod();
	this.handle(
		IProblem.AnnotationCannotOverrideMethod,
		new String[] {
				new String(overrideMethod.declaringClass.readableName()),
				new String(inheritedMethod.declaringClass.readableName()),
				new String(inheritedMethod.selector),
				typesAsString(inheritedMethod.isVarargs(), inheritedMethod.parameters, false)},
		new String[] {
				new String(overrideMethod.declaringClass.shortReadableName()),
				new String(inheritedMethod.declaringClass.shortReadableName()),
				new String(inheritedMethod.selector),
				typesAsString(inheritedMethod.isVarargs(), inheritedMethod.parameters, true)},
		location.sourceStart,
		location.sourceEnd);
}
public void annotationCircularity(TypeBinding sourceType, TypeBinding otherType, TypeReference reference) {
	if (sourceType == otherType)
		this.handle(
			IProblem.AnnotationCircularitySelfReference,
			new String[] {new String(sourceType.readableName())},
			new String[] {new String(sourceType.shortReadableName())},
			reference.sourceStart,
			reference.sourceEnd);
	else
		this.handle(
			IProblem.AnnotationCircularity,
			new String[] {new String(sourceType.readableName()), new String(otherType.readableName())},
			new String[] {new String(sourceType.shortReadableName()), new String(otherType.shortReadableName())},
			reference.sourceStart,
			reference.sourceEnd);
}
public void annotationMembersCannotHaveParameters(AnnotationMethodDeclaration annotationMethodDeclaration) {
	this.handle(
		IProblem.AnnotationMembersCannotHaveParameters,
		NoArgument,
		NoArgument,
		annotationMethodDeclaration.sourceStart,
		annotationMethodDeclaration.sourceEnd);
}
public void annotationMembersCannotHaveTypeParameters(AnnotationMethodDeclaration annotationMethodDeclaration) {
	this.handle(
		IProblem.AnnotationMembersCannotHaveTypeParameters,
		NoArgument,
		NoArgument,
		annotationMethodDeclaration.sourceStart,
		annotationMethodDeclaration.sourceEnd);
}
public void annotationTypeDeclarationCannotHaveConstructor(ConstructorDeclaration constructorDeclaration) {
	this.handle(
		IProblem.AnnotationTypeDeclarationCannotHaveConstructor,
		NoArgument,
		NoArgument,
		constructorDeclaration.sourceStart,
		constructorDeclaration.sourceEnd);
}
public void annotationTypeDeclarationCannotHaveSuperclass(TypeDeclaration typeDeclaration) {
	this.handle(
		IProblem.AnnotationTypeDeclarationCannotHaveSuperclass,
		NoArgument,
		NoArgument,
		typeDeclaration.sourceStart,
		typeDeclaration.sourceEnd);
}
public void annotationTypeDeclarationCannotHaveSuperinterfaces(TypeDeclaration typeDeclaration) {
	this.handle(
		IProblem.AnnotationTypeDeclarationCannotHaveSuperinterfaces,
		NoArgument,
		NoArgument,
		typeDeclaration.sourceStart,
		typeDeclaration.sourceEnd);
}
public void annotationTypeUsedAsSuperinterface(SourceTypeBinding type, TypeReference superInterfaceRef, ReferenceBinding superType) {
	this.handle(
		IProblem.AnnotationTypeUsedAsSuperInterface,
		new String[] {new String(superType.readableName()), new String(type.sourceName())},
		new String[] {new String(superType.shortReadableName()), new String(type.sourceName())},
		superInterfaceRef.sourceStart,
		superInterfaceRef.sourceEnd);
}
public void annotationValueMustBeAnnotation(TypeBinding annotationType, char[] name, Expression value, TypeBinding expectedType) {
	String str = new String(name);
	this.handle(
		IProblem.AnnotationValueMustBeAnnotation,
		new String[] { new String(annotationType.readableName()), str, new String(expectedType.readableName()),  },
		new String[] { new String(annotationType.shortReadableName()), str, new String(expectedType.readableName()), },
		value.sourceStart,
		value.sourceEnd);
}
public void annotationValueMustBeArrayInitializer(TypeBinding annotationType, char[] name, Expression value) {
	String str = new String(name);
	this.handle(
    	IProblem.AnnotationValueMustBeArrayInitializer,
		new String[] { new String(annotationType.readableName()), str },
		new String[] { new String(annotationType.shortReadableName()), str},
    	value.sourceStart,
    	value.sourceEnd);
}
public void annotationValueMustBeClassLiteral(TypeBinding annotationType, char[] name, Expression value) {
	String str = new String(name);
	this.handle(
		IProblem.AnnotationValueMustBeClassLiteral,
		new String[] { new String(annotationType.readableName()), str },
		new String[] { new String(annotationType.shortReadableName()), str},
		value.sourceStart,
		value.sourceEnd);
}
public void annotationValueMustBeConstant(TypeBinding annotationType, char[] name, Expression value, boolean isEnum) {
	String str = new String(name);
	if (isEnum) {
    	this.handle(
    		IProblem.AnnotationValueMustBeAnEnumConstant,
    		new String[] { new String(annotationType.readableName()), str },
    		new String[] { new String(annotationType.shortReadableName()), str},
    		value.sourceStart,
    		value.sourceEnd);
	} else {
    	this.handle(
    		IProblem.AnnotationValueMustBeConstant,
    		new String[] { new String(annotationType.readableName()), str },
    		new String[] { new String(annotationType.shortReadableName()), str},
    		value.sourceStart,
    		value.sourceEnd);
    }
}
public void anonymousClassCannotExtendFinalClass(Expression expression, TypeBinding type) {
	this.handle(
		IProblem.AnonymousClassCannotExtendFinalClass,

		messageSend.sourceStart,
		messageSend.sourceEnd);
}
public void cannotExtendEnum(SourceTypeBinding type, TypeReference superclass, TypeBinding superTypeBinding) {
	String name = new String(type.sourceName());
	String superTypeFullName = new String(superTypeBinding.readableName());
	String superTypeShortName = new String(superTypeBinding.shortReadableName());
	if (superTypeShortName.equals(name)) superTypeShortName = superTypeFullName;
	this.handle(
		IProblem.CannotExtendEnum,
		new String[] {superTypeFullName, name},
		new String[] {superTypeShortName, name},
		superclass.sourceStart,
		superclass.sourceEnd);
}
public void cannotImportPackage(ImportReference importRef) {
	String[] arguments = new String[] {CharOperation.toString(importRef.tokens)};
	this.handle(

		typeRef.sourceStart,
		typeRef.sourceEnd);
}
public void cannotInvokeSuperConstructorInEnum(ExplicitConstructorCall constructorCall, MethodBinding enumConstructor) {
	this.handle(
		IProblem.CannotInvokeSuperConstructorInEnum,
		new String[] {
		        new String(enumConstructor.declaringClass.sourceName()),
		        typesAsString(enumConstructor.isVarargs(), enumConstructor.parameters, false),
		 },
		new String[] {
		        new String(enumConstructor.declaringClass.sourceName()),
		        typesAsString(enumConstructor.isVarargs(), enumConstructor.parameters, true),
		 },
		constructorCall.sourceStart,
		constructorCall.sourceEnd);
}
public void cannotReadSource(CompilationUnitDeclaration unit, AbortCompilationUnit abortException, boolean verbose) {
	String fileName = new String(unit.compilationResult.fileName);
	if (abortException.exception instanceof CharConversionException) {

		exception.sourceStart,
		exception.sourceEnd);
}
public void cannotUseQualifiedEnumConstantInCaseLabel(Reference location, FieldBinding field) {
	this.handle(
			IProblem.IllegalQualifiedEnumConstantLabel,
			new String[]{ String.valueOf(field.declaringClass.readableName()), String.valueOf(field.name) },
			new String[]{ String.valueOf(field.declaringClass.shortReadableName()), String.valueOf(field.name) },
			nodeSourceStart(field, location),
			nodeSourceEnd(field, location));
}
public void cannotUseSuperInCodeSnippet(int start, int end) {
	this.handle(
		IProblem.CannotUseSuperInCodeSnippet,

		reference.sourceStart,
		reference.sourceEnd);
}
public void caseExpressionMustBeConstant(Expression expression) {
	this.handle(
		IProblem.NonConstantExpression,
		NoArgument,
		NoArgument,
		expression.sourceStart,
		expression.sourceEnd);
}
public void classExtendFinalClass(SourceTypeBinding type, TypeReference superclass, TypeBinding superTypeBinding) {
	String name = new String(type.sourceName());
	String superTypeFullName = new String(superTypeBinding.readableName());

	switch (problemID) {
		case IProblem.Task :
			return ProblemSeverities.Warning;
 		case IProblem.VarargsConflict :
			return ProblemSeverities.Warning;
 		case IProblem.TypeCollidesWithPackage :
			return ProblemSeverities.Warning;


		case IProblem.JavadocInheritedFieldHidesEnclosingName:
		case IProblem.JavadocInheritedNameHidesEnclosingTypeName:
		case IProblem.JavadocNonStaticTypeFromStaticInvocation:
		case IProblem.JavadocGenericMethodTypeArgumentMismatch:
		case IProblem.JavadocNonGenericMethod:
		case IProblem.JavadocIncorrectArityForParameterizedMethod:
		case IProblem.JavadocParameterizedMethodArgumentTypeMismatch:
		case IProblem.JavadocTypeArgumentsForRawGenericMethod:
		case IProblem.JavadocGenericConstructorTypeArgumentMismatch:
		case IProblem.JavadocNonGenericConstructor:
		case IProblem.JavadocIncorrectArityForParameterizedConstructor:
		case IProblem.JavadocParameterizedConstructorArgumentTypeMismatch:
		case IProblem.JavadocTypeArgumentsForRawGenericConstructor:
		case IProblem.JavadocEmptyReturnTag:
			if (!this.options.reportInvalidJavadocTags) {
				return ProblemSeverities.Ignore;

		location.sourceStart,
		nodeSourceEnd(null, location));
}
public void disallowedTargetForAnnotation(Annotation annotation) {
	this.handle(
		IProblem.DisallowedTargetForAnnotation,
		new String[] {new String(annotation.resolvedType.readableName())},
		new String[] {new String(annotation.resolvedType.shortReadableName())},
		annotation.sourceStart,
		annotation.sourceEnd);
}
public void duplicateAnnotation(Annotation annotation) {
	this.handle(
		IProblem.DuplicateAnnotation,
		new String[] {new String(annotation.resolvedType.readableName())},
		new String[] {new String(annotation.resolvedType.shortReadableName())},
		annotation.sourceStart,
		annotation.sourceEnd);
}
public void duplicateAnnotationValue(TypeBinding annotationType, MemberValuePair memberValuePair) {
	String name = 	new String(memberValuePair.name);
	this.handle(
		IProblem.DuplicateAnnotationMember,
		new String[] { name, new String(annotationType.readableName())},
		new String[] {	name, new String(annotationType.shortReadableName())},
		memberValuePair.sourceStart,
		memberValuePair.sourceEnd);
}
public void duplicateBounds(ASTNode location, TypeBinding type) {
	this.handle(
		IProblem.DuplicateBounds,

		statement.sourceStart,
		statement.sourceEnd);
}

public void duplicateEnumSpecialMethod(SourceTypeBinding type, AbstractMethodDeclaration methodDecl) {
    MethodBinding method = methodDecl.binding;
	this.handle(
		IProblem.CannotDeclareEnumSpecialMethod,
		new String[] {
	        new String(methodDecl.getSafeName()),
			new String(method.declaringClass.readableName()),
			typesAsString(method.isVarargs(), method.parameters, false)},
		new String[] {
			new String(methodDecl.getSafeName()),
			new String(method.declaringClass.shortReadableName()),
			typesAsString(method.isVarargs(), method.parameters, true)},
		methodDecl.sourceStart,
		methodDecl.sourceEnd);
}
public void duplicateFieldInType(SourceTypeBinding type, FieldDeclaration fieldDecl) {
	this.handle(
		IProblem.DuplicateField,

		reference.sourceStart,
		reference.sourceEnd);
}
public void duplicateTargetInTargetAnnotation(TypeBinding annotationType, NameReference reference) {
	FieldBinding field = reference.fieldBinding();
	String name = 	new String(field.name);
	this.handle(
		IProblem.DuplicateTargetInTargetAnnotation,
		new String[] { name, new String(annotationType.readableName())},
		new String[] {	name, new String(annotationType.shortReadableName())},
		nodeSourceStart(field, reference),
		nodeSourceEnd(field, reference));
}
public void duplicateTypeParameterInType(TypeParameter typeParameter) {
	this.handle(
		IProblem.DuplicateTypeVariable,

		sourceStart,
		sourceEnd);
}
public void enumAbstractMethodMustBeImplemented(AbstractMethodDeclaration method) {
	MethodBinding abstractMethod = method.binding;
	char[] methodSelector = abstractMethod.selector;
	if(methodSelector == null)
		methodSelector = method.getSafeName();
	this.handle(
		// Must implement the inherited abstract method %1
		// 8.4.3 - Every non-abstract subclass of an abstract type, A, must provide a concrete implementation of all of A's methods.
		IProblem.EnumAbstractMethodMustBeImplemented,
		new String[] {
		        new String(methodSelector),
		        typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),
		        new String(abstractMethod.declaringClass.readableName()),
		},
		new String[] {
		        new String(methodSelector),
		        typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),
		        new String(abstractMethod.declaringClass.shortReadableName()),
		},
		method.sourceStart(),
		method.sourceEnd());
}
public void enumConstantsCannotBeSurroundedByParenthesis(Expression expression) {
	this.handle(
		IProblem.EnumConstantsCannotBeSurroundedByParenthesis,

		expression.sourceStart,
		expression.sourceEnd);
}
public void enumStaticFieldUsedDuringInitialization(FieldBinding field, ASTNode location) {
	this.handle(
		IProblem.EnumStaticFieldInInInitializerContext,
		new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
		new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}
public void enumSwitchCannotTargetField(Reference reference, FieldBinding field) {
	this.handle(
			IProblem.EnumSwitchCannotTargetField,
			new String[]{ String.valueOf(field.declaringClass.readableName()), String.valueOf(field.name) },
			new String[]{ String.valueOf(field.declaringClass.shortReadableName()), String.valueOf(field.name) },
			nodeSourceStart(field, reference),
			nodeSourceEnd(field, reference));
}
public void errorNoMethodFor(MessageSend messageSend, TypeBinding recType, TypeBinding[] params) {
	StringBuffer buffer = new StringBuffer();
	StringBuffer shortBuffer = new StringBuffer();

		location.sourceStart,
		location.sourceEnd);
}
public void illegalExtendedDimensions(AnnotationMethodDeclaration annotationTypeMemberDeclaration) {
	this.handle(
		IProblem.IllegalExtendedDimensions,
		NoArgument,
		NoArgument,
		annotationTypeMemberDeclaration.sourceStart,
		annotationTypeMemberDeclaration.sourceEnd);
}
public void illegalExtendedDimensions(Argument argument) {
	this.handle(
		IProblem.IllegalExtendedDimensionsForVarArgs,
		NoArgument,
		NoArgument,
		argument.sourceStart,
		argument.sourceEnd);
}
public void illegalGenericArray(TypeBinding leafComponentType, ASTNode location) {
	this.handle(
		IProblem.IllegalGenericArray,

		location.sourceStart,
		location.sourceEnd);
}
public void illegalInstanceOfGenericType(TypeBinding checkedType, ASTNode location) {
	if (checkedType.isTypeVariable()) {
		this.handle(
		IProblem.IllegalInstanceofTypeParameter,
			new String[] { new String(checkedType.readableName()), new String(checkedType.erasure().readableName())},
			new String[] { new String(checkedType.shortReadableName()), new String(checkedType.erasure().shortReadableName())},
			location.sourceStart,
			location.sourceEnd);
		return;
	}
	this.handle(
		IProblem.IllegalInstanceofParameterizedType,
		new String[] { new String(checkedType.readableName()), new String(checkedType.erasure().sourceName())},
		new String[] { new String(checkedType.shortReadableName()), new String(checkedType.erasure().sourceName())},
		location.sourceStart,
		location.sourceEnd);
}
public void illegalLocalTypeDeclaration(TypeDeclaration typeDeclaration) {
	if (isRecoveredName(typeDeclaration.name)) return;


		fieldDecl.sourceStart,
		fieldDecl.sourceEnd);
}
public void illegalModifierForAnnotationField(FieldDeclaration fieldDecl) {
	String name = new String(fieldDecl.name);
	this.handle(
		IProblem.IllegalModifierForAnnotationField,
		new String[] {
			new String(fieldDecl.binding.declaringClass.readableName()),
			name,
		},
		new String[] {
			new String(fieldDecl.binding.declaringClass.shortReadableName()),
			name,
		},
		fieldDecl.sourceStart,
		fieldDecl.sourceEnd);
}
public void illegalModifierForAnnotationMember(AbstractMethodDeclaration methodDecl) {
	this.handle(
		IProblem.IllegalModifierForAnnotationMethod,
		new String[] {
			new String(methodDecl.binding.declaringClass.readableName()),
			new String(methodDecl.getSafeName()),
		},
		new String[] {
			new String(methodDecl.binding.declaringClass.shortReadableName()),
			new String(methodDecl.getSafeName()),
		},
		methodDecl.sourceStart,
		methodDecl.sourceEnd);
}
public void illegalModifierForAnnotationMemberType(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(
		IProblem.IllegalModifierForAnnotationMemberType,
		arguments,
		arguments,
		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForAnnotationType(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(
		IProblem.IllegalModifierForAnnotationType,
		arguments,
		arguments,
		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForClass(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(

		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForEnum(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(
		IProblem.IllegalModifierForEnum,
		arguments,
		arguments,
		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForEnumConstant(ReferenceBinding type, FieldDeclaration fieldDecl) {
	String[] arguments = new String[] {new String(fieldDecl.name)};
	this.handle(
		IProblem.IllegalModifierForEnumConstant,
		arguments,
		arguments,
		fieldDecl.sourceStart,
		fieldDecl.sourceEnd);
}

public void illegalModifierForEnumConstructor(AbstractMethodDeclaration constructor) {
	this.handle(
		IProblem.IllegalModifierForEnumConstructor,
		NoArgument,
		NoArgument,
		constructor.sourceStart,
		constructor.sourceEnd);
}
public void illegalModifierForField(ReferenceBinding type, FieldDeclaration fieldDecl) {
	String[] arguments = new String[] {new String(fieldDecl.name)};
	this.handle(

		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForLocalEnum(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(
		IProblem.IllegalModifierForLocalEnum,
		arguments,
		arguments,
		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForMemberClass(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(

		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForMemberEnum(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(
		IProblem.IllegalModifierForMemberEnum,
		arguments,
		arguments,
		type.sourceStart(),
		type.sourceEnd());
}
public void illegalModifierForMemberInterface(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(

		fieldDecl.sourceStart,
		fieldDecl.sourceEnd);
}
public void invalidAnnotationMemberType(MethodDeclaration methodDecl) {
	this.handle(
		IProblem.InvalidAnnotationMemberType,
		new String[] {
			new String(methodDecl.binding.returnType.readableName()),
			new String(methodDecl.getSafeName()),
			new String(methodDecl.binding.declaringClass.readableName()),
		},
		new String[] {
			new String(methodDecl.binding.returnType.shortReadableName()),
			new String(methodDecl.getSafeName()),
			new String(methodDecl.binding.declaringClass.shortReadableName()),
		},
		methodDecl.returnType.sourceStart,
		methodDecl.returnType.sourceEnd);

}
public void invalidBreak(ASTNode location) {
	this.handle(
		IProblem.InvalidBreak,

				id = IProblem.AmbiguousConstructor;
			}
			break;
		case ProblemReasons.ParameterBoundMismatch :
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			ParameterizedGenericMethodBinding substitutedConstructor = (ParameterizedGenericMethodBinding) problemConstructor.closestMatch;
			shownConstructor = substitutedConstructor.original();
			int augmentedLength = problemConstructor.parameters.length;
			TypeBinding inferredTypeArgument = problemConstructor.parameters[augmentedLength-2];
			TypeVariableBinding typeParameter = (TypeVariableBinding) problemConstructor.parameters[augmentedLength-1];
			TypeBinding[] invocationArguments = new TypeBinding[augmentedLength-2]; // remove extra info from the end
			System.arraycopy(problemConstructor.parameters, 0, invocationArguments, 0, augmentedLength-2);
			this.handle(
				IProblem.GenericConstructorTypeArgumentMismatch,
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
				        new String(shownConstructor.declaringClass.readableName()),
				        typesAsString(false, invocationArguments, false),
				        new String(inferredTypeArgument.readableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, false) },
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
				        new String(shownConstructor.declaringClass.shortReadableName()),
				        typesAsString(false, invocationArguments, true),
				        new String(inferredTypeArgument.shortReadableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, true) },
				sourceStart,
				sourceEnd);
			return;

		case ProblemReasons.TypeParameterArityMismatch :
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			shownConstructor = problemConstructor.closestMatch;
			if (shownConstructor.typeVariables == Binding.NO_TYPE_VARIABLES) {
				this.handle(
					IProblem.NonGenericConstructor,
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
					        new String(shownConstructor.declaringClass.readableName()),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
					        new String(shownConstructor.declaringClass.shortReadableName()),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
					sourceStart,
					sourceEnd);
			} else {
				this.handle(
					IProblem.IncorrectArityForParameterizedConstructor  ,
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
					        new String(shownConstructor.declaringClass.readableName()),
							typesAsString(false, shownConstructor.typeVariables, false),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
					        new String(shownConstructor.declaringClass.shortReadableName()),
							typesAsString(false, shownConstructor.typeVariables, true),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
					sourceStart,
					sourceEnd);
			}
			return;
		case ProblemReasons.ParameterizedMethodTypeMismatch :
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			shownConstructor = problemConstructor.closestMatch;
			this.handle(
				IProblem.ParameterizedConstructorArgumentTypeMismatch,
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
				        new String(shownConstructor.declaringClass.readableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownConstructor).typeArguments, false),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
				        new String(shownConstructor.declaringClass.shortReadableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownConstructor).typeArguments, true),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
				sourceStart,
				sourceEnd);
			return;
		case ProblemReasons.TypeArgumentsForRawGenericMethod :
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			shownConstructor = problemConstructor.closestMatch;
			this.handle(
				IProblem.TypeArgumentsForRawGenericConstructor,
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
				        new String(shownConstructor.declaringClass.readableName()),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
				        new String(shownConstructor.declaringClass.shortReadableName()),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
				sourceStart,
				sourceEnd);
			return;
		case ProblemReasons.NoError : // 0
		default :
			needImplementation(); // want to fail to see why we were here...

		nameRef.sourceStart,
		(int) nameRef.sourcePositions[index]);
}
public void invalidFileNameForPackageAnnotations(Annotation annotation) {
	this.handle(
			IProblem.InvalidFileNameForPackageAnnotations,
			NoArgument,
			NoArgument,
			annotation.sourceStart,
			annotation.sourceEnd);
}
public void invalidMethod(MessageSend messageSend, MethodBinding method) {
	if (isRecoveredName(messageSend.selector)) return;


				messageSend.receiver.sourceStart,
				messageSend.receiver.sourceEnd);
			return;
		case ProblemReasons.ParameterBoundMismatch :
			problemMethod = (ProblemMethodBinding) method;
			ParameterizedGenericMethodBinding substitutedMethod = (ParameterizedGenericMethodBinding) problemMethod.closestMatch;
			shownMethod = substitutedMethod.original();
			int augmentedLength = problemMethod.parameters.length;
			TypeBinding inferredTypeArgument = problemMethod.parameters[augmentedLength-2];
			TypeVariableBinding typeParameter = (TypeVariableBinding) problemMethod.parameters[augmentedLength-1];
			TypeBinding[] invocationArguments = new TypeBinding[augmentedLength-2]; // remove extra info from the end
			System.arraycopy(problemMethod.parameters, 0, invocationArguments, 0, augmentedLength-2);
			this.handle(
				IProblem.GenericMethodTypeArgumentMismatch,
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
				        new String(shownMethod.declaringClass.readableName()),
				        typesAsString(false, invocationArguments, false),
				        new String(inferredTypeArgument.readableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, false) },
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
				        new String(shownMethod.declaringClass.shortReadableName()),
				        typesAsString(false, invocationArguments, true),
				        new String(inferredTypeArgument.shortReadableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, true) },
				(int) (messageSend.nameSourcePosition >>> 32),
				(int) messageSend.nameSourcePosition);
			return;
		case ProblemReasons.TypeParameterArityMismatch :
			problemMethod = (ProblemMethodBinding) method;
			shownMethod = problemMethod.closestMatch;
			if (shownMethod.typeVariables == Binding.NO_TYPE_VARIABLES) {
				this.handle(
					IProblem.NonGenericMethod ,
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
					        new String(shownMethod.declaringClass.readableName()),
					        typesAsString(method.isVarargs(), method.parameters, false) },
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
					        new String(shownMethod.declaringClass.shortReadableName()),
					        typesAsString(method.isVarargs(), method.parameters, true) },
					(int) (messageSend.nameSourcePosition >>> 32),
					(int) messageSend.nameSourcePosition);
			} else {
				this.handle(
					IProblem.IncorrectArityForParameterizedMethod  ,
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
					        new String(shownMethod.declaringClass.readableName()),
							typesAsString(false, shownMethod.typeVariables, false),
					        typesAsString(method.isVarargs(), method.parameters, false) },
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
					        new String(shownMethod.declaringClass.shortReadableName()),
							typesAsString(false, shownMethod.typeVariables, true),
					        typesAsString(method.isVarargs(), method.parameters, true) },
					(int) (messageSend.nameSourcePosition >>> 32),
					(int) messageSend.nameSourcePosition);
			}
			return;
		case ProblemReasons.ParameterizedMethodTypeMismatch :
			problemMethod = (ProblemMethodBinding) method;
			shownMethod = problemMethod.closestMatch;
			this.handle(
				IProblem.ParameterizedMethodArgumentTypeMismatch,
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
				        new String(shownMethod.declaringClass.readableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownMethod).typeArguments, false),
				        typesAsString(method.isVarargs(), method.parameters, false) },
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
				        new String(shownMethod.declaringClass.shortReadableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownMethod).typeArguments, true),
				        typesAsString(method.isVarargs(), method.parameters, true) },
				(int) (messageSend.nameSourcePosition >>> 32),
				(int) messageSend.nameSourcePosition);
			return;
		case ProblemReasons.TypeArgumentsForRawGenericMethod :
			problemMethod = (ProblemMethodBinding) method;
			shownMethod = problemMethod.closestMatch;
			this.handle(
				IProblem.TypeArgumentsForRawGenericMethod ,
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
				        new String(shownMethod.declaringClass.readableName()),
				        typesAsString(method.isVarargs(), method.parameters, false) },
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
				        new String(shownMethod.declaringClass.shortReadableName()),
				        typesAsString(method.isVarargs(), method.parameters, true) },
				(int) (messageSend.nameSourcePosition >>> 32),
				(int) messageSend.nameSourcePosition);
			return;
		case ProblemReasons.NoError : // 0
		default :
			needImplementation(); // want to fail to see why we were here...

		expression.sourceStart,
		expression.sourceEnd);
}
public void invalidUsageOfAnnotation(Annotation annotation) {
	this.handle(
		IProblem.InvalidUsageOfAnnotations,
		NoArgument,
		NoArgument,
		annotation.sourceStart,
		annotation.sourceEnd);
}
public void invalidUsageOfAnnotationDeclarations(TypeDeclaration annotationTypeDeclaration) {
	this.handle(
		IProblem.InvalidUsageOfAnnotationDeclarations,
		NoArgument,
		NoArgument,
		annotationTypeDeclaration.sourceStart,
		annotationTypeDeclaration.sourceEnd);
}
public void invalidUsageOfEnumDeclarations(TypeDeclaration enumDeclaration) {
	this.handle(
		IProblem.InvalidUsageOfEnumDeclarations,
		NoArgument,
		NoArgument,
		enumDeclaration.sourceStart,
		enumDeclaration.sourceEnd);
}
public void invalidUsageOfForeachStatements(LocalDeclaration elementVariable, Expression collection) {
	this.handle(
		IProblem.InvalidUsageOfForeachStatements,

		elementVariable.declarationSourceStart,
		collection.sourceEnd);
}
public void invalidUsageOfStaticImports(ImportReference staticImport) {
	this.handle(
		IProblem.InvalidUsageOfStaticImports,
		NoArgument,
		NoArgument,
		staticImport.declarationSourceStart,
		staticImport.declarationSourceEnd);
}
public void invalidUsageOfTypeArguments(TypeReference firstTypeReference, TypeReference lastTypeReference) {
	this.handle(
		IProblem.InvalidUsageOfTypeArguments,
		NoArgument,
		NoArgument,
		firstTypeReference.sourceStart,
		lastTypeReference.sourceEnd);
}
public void invalidUsageOfTypeParameters(TypeParameter firstTypeParameter, TypeParameter lastTypeParameter) {
	this.handle(
		IProblem.InvalidUsageOfTypeParameters,

		firstTypeParameter.declarationSourceStart,
		lastTypeParameter.declarationSourceEnd);
}
public void invalidUsageOfVarargs(Argument argument) {
	this.handle(
		IProblem.InvalidUsageOfVarargs,
		NoArgument,
		NoArgument,
		argument.type.sourceStart,
		argument.sourceEnd);
}
public void illegalUsageOfWildcard(TypeReference wildcard) {
	this.handle(
		IProblem.InvalidUsageOfWildcard,
		NoArgument,
		NoArgument,
		wildcard.sourceStart,
		wildcard.sourceEnd);
}
public void isClassPathCorrect(char[][] wellKnownTypeName, CompilationUnitDeclaration compUnitDecl, Object location) {
	this.referenceContext = compUnitDecl;
	String[] arguments = new String[] {CharOperation.toString(wellKnownTypeName)};

public void javadocInvalidConstructor(Statement statement, MethodBinding targetConstructor, int modifiers) {

	if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) return;
	int sourceStart = statement.sourceStart;
	int sourceEnd = statement.sourceEnd;
	if (statement instanceof AllocationExpression) {
		AllocationExpression allocation = (AllocationExpression)statement;
		if (allocation.enumConstant != null) {
			sourceStart = allocation.enumConstant.sourceStart;
			sourceEnd = allocation.enumConstant.sourceEnd;
		}
	}
	int id = IProblem.JavadocUndefinedConstructor; //default...
	ProblemMethodBinding problemConstructor = null;
	MethodBinding shownConstructor = null;
	switch (targetConstructor.problemId()) {
		case ProblemReasons.NotFound :
			id = IProblem.JavadocUndefinedConstructor;

		case ProblemReasons.Ambiguous :
			id = IProblem.JavadocAmbiguousConstructor;
			break;
		case ProblemReasons.ParameterBoundMismatch :
			int severity = computeSeverity(IProblem.JavadocGenericConstructorTypeArgumentMismatch);
			if (severity == ProblemSeverities.Ignore) return;
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			ParameterizedGenericMethodBinding substitutedConstructor = (ParameterizedGenericMethodBinding) problemConstructor.closestMatch;
			shownConstructor = substitutedConstructor.original();

			int augmentedLength = problemConstructor.parameters.length;
			TypeBinding inferredTypeArgument = problemConstructor.parameters[augmentedLength-2];
			TypeVariableBinding typeParameter = (TypeVariableBinding) problemConstructor.parameters[augmentedLength-1];
			TypeBinding[] invocationArguments = new TypeBinding[augmentedLength-2]; // remove extra info from the end
			System.arraycopy(problemConstructor.parameters, 0, invocationArguments, 0, augmentedLength-2);

			this.handle(
				IProblem.JavadocGenericConstructorTypeArgumentMismatch,
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
				        new String(shownConstructor.declaringClass.readableName()),
				        typesAsString(false, invocationArguments, false),
				        new String(inferredTypeArgument.readableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, false) },
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
				        new String(shownConstructor.declaringClass.shortReadableName()),
				        typesAsString(false, invocationArguments, true),
				        new String(inferredTypeArgument.shortReadableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, true) },
				severity,
				sourceStart,
				sourceEnd);
			return;

		case ProblemReasons.TypeParameterArityMismatch :
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			shownConstructor = problemConstructor.closestMatch;
			boolean noTypeVariables = shownConstructor.typeVariables == Binding.NO_TYPE_VARIABLES;
			severity = computeSeverity(noTypeVariables ? IProblem.JavadocNonGenericConstructor : IProblem.JavadocIncorrectArityForParameterizedConstructor);
			if (severity == ProblemSeverities.Ignore) return;
			if (noTypeVariables) {
				this.handle(
					IProblem.JavadocNonGenericConstructor,
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
					        new String(shownConstructor.declaringClass.readableName()),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
					        new String(shownConstructor.declaringClass.shortReadableName()),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
					severity,
					sourceStart,
					sourceEnd);
			} else {
				this.handle(
					IProblem.JavadocIncorrectArityForParameterizedConstructor,
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
					        new String(shownConstructor.declaringClass.readableName()),
							typesAsString(false, shownConstructor.typeVariables, false),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
					new String[] {
					        new String(shownConstructor.declaringClass.sourceName()),
					        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
					        new String(shownConstructor.declaringClass.shortReadableName()),
							typesAsString(false, shownConstructor.typeVariables, true),
					        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
					severity,
					sourceStart,
					sourceEnd);
			}
			return;
		case ProblemReasons.ParameterizedMethodTypeMismatch :
			severity = computeSeverity(IProblem.JavadocParameterizedConstructorArgumentTypeMismatch);
			if (severity == ProblemSeverities.Ignore) return;
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			shownConstructor = problemConstructor.closestMatch;
			this.handle(
				IProblem.JavadocParameterizedConstructorArgumentTypeMismatch,
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
				        new String(shownConstructor.declaringClass.readableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownConstructor).typeArguments, false),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
				        new String(shownConstructor.declaringClass.shortReadableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownConstructor).typeArguments, true),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
				severity,
				sourceStart,
				sourceEnd);
			return;
		case ProblemReasons.TypeArgumentsForRawGenericMethod :
			severity = computeSeverity(IProblem.JavadocTypeArgumentsForRawGenericConstructor);
			if (severity == ProblemSeverities.Ignore) return;
			problemConstructor = (ProblemMethodBinding) targetConstructor;
			shownConstructor = problemConstructor.closestMatch;
			this.handle(
				IProblem.JavadocTypeArgumentsForRawGenericConstructor,
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
				        new String(shownConstructor.declaringClass.readableName()),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false) },
				new String[] {
				        new String(shownConstructor.declaringClass.sourceName()),
				        typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
				        new String(shownConstructor.declaringClass.shortReadableName()),
				        typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true) },
				severity,
				sourceStart,
				sourceEnd);
			return;
		case ProblemReasons.NoError : // 0
		default :
			needImplementation(); // want to fail to see why we were here...

		case ProblemReasons.Ambiguous :
			id = IProblem.JavadocAmbiguousMethod;
			break;
		case ProblemReasons.ParameterBoundMismatch :
			int severity = computeSeverity(IProblem.JavadocGenericMethodTypeArgumentMismatch);
			if (severity == ProblemSeverities.Ignore) return;
			problemMethod = (ProblemMethodBinding) method;
			ParameterizedGenericMethodBinding substitutedMethod = (ParameterizedGenericMethodBinding) problemMethod.closestMatch;
			shownMethod = substitutedMethod.original();
			int augmentedLength = problemMethod.parameters.length;
			TypeBinding inferredTypeArgument = problemMethod.parameters[augmentedLength-2];
			TypeVariableBinding typeParameter = (TypeVariableBinding) problemMethod.parameters[augmentedLength-1];
			TypeBinding[] invocationArguments = new TypeBinding[augmentedLength-2]; // remove extra info from the end
			System.arraycopy(problemMethod.parameters, 0, invocationArguments, 0, augmentedLength-2);
			this.handle(
				IProblem.JavadocGenericMethodTypeArgumentMismatch,
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
				        new String(shownMethod.declaringClass.readableName()),
				        typesAsString(false, invocationArguments, false),
				        new String(inferredTypeArgument.readableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, false) },
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
				        new String(shownMethod.declaringClass.shortReadableName()),
				        typesAsString(false, invocationArguments, true),
				        new String(inferredTypeArgument.shortReadableName()),
				        new String(typeParameter.sourceName),
				        parameterBoundAsString(typeParameter, true) },
				severity,
				(int) (messageSend.nameSourcePosition >>> 32),
				(int) messageSend.nameSourcePosition);
			return;
		case ProblemReasons.TypeParameterArityMismatch :
			problemMethod = (ProblemMethodBinding) method;
			shownMethod = problemMethod.closestMatch;
			boolean noTypeVariables = shownMethod.typeVariables == Binding.NO_TYPE_VARIABLES;
			severity = computeSeverity(noTypeVariables ? IProblem.JavadocNonGenericMethod : IProblem.JavadocIncorrectArityForParameterizedMethod);
			if (severity == ProblemSeverities.Ignore) return;
			if (noTypeVariables) {
				this.handle(
					IProblem.JavadocNonGenericMethod,
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
					        new String(shownMethod.declaringClass.readableName()),
					        typesAsString(method.isVarargs(), method.parameters, false) },
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
					        new String(shownMethod.declaringClass.shortReadableName()),
					        typesAsString(method.isVarargs(), method.parameters, true) },
					severity,
					(int) (messageSend.nameSourcePosition >>> 32),
					(int) messageSend.nameSourcePosition);
			} else {
				this.handle(
					IProblem.JavadocIncorrectArityForParameterizedMethod,
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
					        new String(shownMethod.declaringClass.readableName()),
							typesAsString(false, shownMethod.typeVariables, false),
					        typesAsString(method.isVarargs(), method.parameters, false) },
					new String[] {
					        new String(shownMethod.selector),
					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
					        new String(shownMethod.declaringClass.shortReadableName()),
							typesAsString(false, shownMethod.typeVariables, true),
					        typesAsString(method.isVarargs(), method.parameters, true) },
					severity,
					(int) (messageSend.nameSourcePosition >>> 32),
					(int) messageSend.nameSourcePosition);
			}
			return;
		case ProblemReasons.ParameterizedMethodTypeMismatch :
			severity = computeSeverity(IProblem.JavadocParameterizedMethodArgumentTypeMismatch);
			if (severity == ProblemSeverities.Ignore) return;
			problemMethod = (ProblemMethodBinding) method;
			shownMethod = problemMethod.closestMatch;
			this.handle(
				IProblem.JavadocParameterizedMethodArgumentTypeMismatch,
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
				        new String(shownMethod.declaringClass.readableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownMethod).typeArguments, false),
				        typesAsString(method.isVarargs(), method.parameters, false) },
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
				        new String(shownMethod.declaringClass.shortReadableName()),
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownMethod).typeArguments, true),
				        typesAsString(method.isVarargs(), method.parameters, true) },
				severity,
				(int) (messageSend.nameSourcePosition >>> 32),
				(int) messageSend.nameSourcePosition);
			return;
		case ProblemReasons.TypeArgumentsForRawGenericMethod :
			severity = computeSeverity(IProblem.JavadocTypeArgumentsForRawGenericMethod);
			if (severity == ProblemSeverities.Ignore) return;
			problemMethod = (ProblemMethodBinding) method;
			shownMethod = problemMethod.closestMatch;
			this.handle(
				IProblem.JavadocTypeArgumentsForRawGenericMethod,
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
				        new String(shownMethod.declaringClass.readableName()),
				        typesAsString(method.isVarargs(), method.parameters, false) },
				new String[] {
				        new String(shownMethod.selector),
				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
				        new String(shownMethod.declaringClass.shortReadableName()),
				        typesAsString(method.isVarargs(), method.parameters, true) },
				severity,
				(int) (messageSend.nameSourcePosition >>> 32),
				(int) messageSend.nameSourcePosition);
			return;
		case ProblemReasons.NoError : // 0
		default :
			needImplementation(); // want to fail to see why we were here...

		nodeSourceStart(local, location),
		nodeSourceEnd(local, location));
}
public void methodMustOverride(AbstractMethodDeclaration method) {
	MethodBinding binding = method.binding;
	char[] methodSelector = binding.selector;
	if(methodSelector == null)
		methodSelector = method.getSafeName();
	
	this.handle(
		this.options.sourceLevel == ClassFileConstants.JDK1_5 ? IProblem.MethodMustOverride : IProblem.MethodMustOverrideOrImplement,
		new String[] {new String(methodSelector), typesAsString(binding.isVarargs(), binding.parameters, false), new String(binding.declaringClass.readableName()), },
		new String[] {new String(methodSelector), typesAsString(binding.isVarargs(), binding.parameters, true), new String(binding.declaringClass.shortReadableName()),},
		method.sourceStart,
		method.sourceEnd);
}
public void methodNameClash(MethodBinding currentMethod, MethodBinding inheritedMethod) {
	this.handle(
		IProblem.MethodNameClash,

		methodDecl.sourceStart,
		methodDecl.sourceEnd);
}
public void missingDeprecatedAnnotationForField(FieldDeclaration field) {
	int severity = computeSeverity(IProblem.FieldMissingDeprecatedAnnotation);
	if (severity == ProblemSeverities.Ignore) return;
	FieldBinding binding = field.binding;
	this.handle(
		IProblem.FieldMissingDeprecatedAnnotation,
		new String[] {new String(binding.declaringClass.readableName()), new String(binding.name), },
		new String[] {new String(binding.declaringClass.shortReadableName()), new String(binding.name), },
		severity,
		nodeSourceStart(binding, field),
		nodeSourceEnd(binding, field));
}
public void missingDeprecatedAnnotationForMethod(AbstractMethodDeclaration method) {
	int severity = computeSeverity(IProblem.MethodMissingDeprecatedAnnotation);
	if (severity == ProblemSeverities.Ignore) return;
	MethodBinding binding = method.binding;
	char[] methodSelector = binding.selector;
	if(methodSelector == null)
		methodSelector = method.getSafeName();
	
	this.handle(
		IProblem.MethodMissingDeprecatedAnnotation,
		new String[] {new String(methodSelector), typesAsString(binding.isVarargs(), binding.parameters, false), new String(binding.declaringClass.readableName()), },
		new String[] {new String(methodSelector), typesAsString(binding.isVarargs(), binding.parameters, true), new String(binding.declaringClass.shortReadableName()),},
		severity,
		method.sourceStart,
		method.sourceEnd);
}
public void missingDeprecatedAnnotationForType(TypeDeclaration type) {
	int severity = computeSeverity(IProblem.TypeMissingDeprecatedAnnotation);
	if (severity == ProblemSeverities.Ignore) return;
	TypeBinding binding = type.binding;
	this.handle(
		IProblem.TypeMissingDeprecatedAnnotation,
		new String[] {new String(binding.readableName()), },
		new String[] {new String(binding.shortReadableName()),},
		severity,
		type.sourceStart,
		type.sourceEnd);
}
public void missingEnumConstantCase(SwitchStatement switchStatement, FieldBinding enumConstant) {
	this.handle(
		IProblem.MissingEnumConstantCase,
		new String[] {new String(enumConstant.declaringClass.readableName()), new String(enumConstant.name) },
		new String[] {new String(enumConstant.declaringClass.shortReadableName()), new String(enumConstant.name) },
		switchStatement.expression.sourceStart,
		switchStatement.expression.sourceEnd);
}
public void missingOverrideAnnotation(AbstractMethodDeclaration method) {
	int severity = computeSeverity(IProblem.MissingOverrideAnnotation);
	if (severity == ProblemSeverities.Ignore) return;
	MethodBinding binding = method.binding;
	char[] methodSelector = binding.selector;
	if(methodSelector == null)
		methodSelector = method.getSafeName();
	
	this.handle(
		IProblem.MissingOverrideAnnotation,
		new String[] {new String(methodSelector), typesAsString(binding.isVarargs(), binding.parameters, false), new String(binding.declaringClass.readableName()), },
		new String[] {new String(methodSelector), typesAsString(binding.isVarargs(), binding.parameters, true), new String(binding.declaringClass.shortReadableName()),},
		severity,
		method.sourceStart,
		method.sourceEnd);
}
public void missingReturnType(AbstractMethodDeclaration methodDecl) {
	this.handle(
		IProblem.MissingReturnType,

		typeDecl.sourceStart,
		typeDecl.sourceEnd);
}
public void missingValueForAnnotationMember(Annotation annotation, char[] memberName) {
	String memberString = new String(memberName);
	this.handle(
		IProblem.MissingValueForAnnotationMember,
		new String[] {new String(annotation.resolvedType.readableName()), memberString },
		new String[] {new String(annotation.resolvedType.shortReadableName()), memberString},
		annotation.sourceStart,
		annotation.sourceEnd);
}
public void mustDefineDimensionsOrInitializer(ArrayAllocationExpression expression) {
	this.handle(
		IProblem.MustDefineEitherDimensionExpressionsOrInitializer,

		expression.sourceStart,
		expression.sourceEnd);
}
public void objectCannotBeGeneric(TypeDeclaration typeDecl) {
	this.handle(
		IProblem.ObjectCannotBeGeneric,
		NoArgument,
		NoArgument,
		typeDecl.typeParameters[0].sourceStart,
		typeDecl.typeParameters[typeDecl.typeParameters.length-1].sourceEnd);
}
public void objectCannotHaveSuperTypes(SourceTypeBinding type) {
	this.handle(
		IProblem.ObjectCannotHaveSuperTypes,

		decl.sourceStart,
		decl.sourceEnd);
}
public void superTypeCannotUseWildcard(SourceTypeBinding type, TypeReference superclass, TypeBinding superTypeBinding) {
	String name = new String(type.sourceName());
	String superTypeFullName = new String(superTypeBinding.readableName());
	String superTypeShortName = new String(superTypeBinding.shortReadableName());
	if (superTypeShortName.equals(name)) superTypeShortName = superTypeFullName;
	this.handle(
		IProblem.SuperTypeUsingWildcard,
		new String[] {superTypeFullName, name},
		new String[] {superTypeShortName, name},
		superclass.sourceStart,
		superclass.sourceEnd);
}
private void syntaxError(
	int id,
	int startPosition,

		typeDecl.sourceEnd,
		compUnitDecl.compilationResult);
}
public void typeHiding(TypeDeclaration typeDecl, TypeVariableBinding hiddenTypeParameter) {
	int severity = computeSeverity(IProblem.TypeHidingTypeParameterFromType);
	if (severity == ProblemSeverities.Ignore) return;
	if (hiddenTypeParameter.declaringElement instanceof TypeBinding) {
		TypeBinding declaringType = (TypeBinding) hiddenTypeParameter.declaringElement;
		this.handle(
			IProblem.TypeHidingTypeParameterFromType,
			new String[] { new String(typeDecl.name) , new String(hiddenTypeParameter.readableName()), new String(declaringType.readableName())  },
			new String[] { new String(typeDecl.name) , new String(hiddenTypeParameter.shortReadableName()), new String(declaringType.shortReadableName()) },
			severity,
			typeDecl.sourceStart,
			typeDecl.sourceEnd);
	} else {
		// type parameter of generic method
		MethodBinding declaringMethod = (MethodBinding) hiddenTypeParameter.declaringElement;
		this.handle(
				IProblem.TypeHidingTypeParameterFromMethod,
				new String[] {
						new String(typeDecl.name),
						new String(hiddenTypeParameter.readableName()),
						new String(declaringMethod.selector),
						typesAsString(declaringMethod.isVarargs(), declaringMethod.parameters, false),
						new String(declaringMethod.declaringClass.readableName()),
				},
				new String[] {
						new String(typeDecl.name),
						new String(hiddenTypeParameter.shortReadableName()),
						new String(declaringMethod.selector),
						typesAsString(declaringMethod.isVarargs(), declaringMethod.parameters, true),
						new String(declaringMethod.declaringClass.shortReadableName()),
				},
				severity,
				typeDecl.sourceStart,
				typeDecl.sourceEnd);
	}
}
public void typeHiding(TypeDeclaration typeDecl, TypeBinding hiddenType) {
	int severity = computeSeverity(IProblem.TypeHidingType);
	if (severity == ProblemSeverities.Ignore) return;

		location.sourceStart,
		location.sourceEnd);
}
public void typeMismatchError(TypeBinding typeArgument, TypeVariableBinding typeParameter, ReferenceBinding genericType, ASTNode location) {
    if (location == null) { // binary case
		this.handle(
			IProblem.TypeArgumentMismatch,
			new String[] { new String(typeArgument.readableName()), new String(genericType.readableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, false) },
			new String[] { new String(typeArgument.shortReadableName()), new String(genericType.shortReadableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, true) },
			ProblemSeverities.AbortCompilation | ProblemSeverities.Error | ProblemSeverities.Fatal,
			0,
			0);
        return;
    }
	this.handle(
		IProblem.TypeArgumentMismatch,
		new String[] { new String(typeArgument.readableName()), new String(genericType.readableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, false) },
		new String[] { new String(typeArgument.shortReadableName()), new String(genericType.shortReadableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, true) },
		location.sourceStart,
		location.sourceEnd);
}
private String typesAsString(boolean isVarargs, TypeBinding[] types, boolean makeShort) {
	StringBuffer buffer = new StringBuffer(10);
	for (int i = 0, length = types.length; i < length; i++) {

	}
	return buffer.toString();
}
public void undefinedAnnotationValue(TypeBinding annotationType, MemberValuePair memberValuePair) {
	if (isRecoveredName(memberValuePair.name)) return;
	String name = 	new String(memberValuePair.name);
	this.handle(
		IProblem.UndefinedAnnotationMember,
		new String[] { name, new String(annotationType.readableName())},
		new String[] {	name, new String(annotationType.shortReadableName())},
		memberValuePair.sourceStart,
		memberValuePair.sourceEnd);
}
public void undefinedLabel(BranchStatement statement) {
	if (isRecoveredName(statement.label)) return;
	String[] arguments = new String[] {new String(statement.label)};

		location.sourceStart,
		location.sourceEnd);
}
public void unhandledWarningToken(Expression token) {
	String[] arguments = new String[] { token.constant.stringValue() };
	this.handle(
		IProblem.UnhandledWarningToken,
		arguments,
		arguments,
		token.sourceStart,
		token.sourceEnd);
}
public void uninitializedBlankFinalField(FieldBinding field, ASTNode location) {
	String[] arguments = new String[] {new String(field.readableName())};
	this.handle(

		sourceStart,
		sourceEnd);
}
public void varargsArgumentNeedCast(MethodBinding method, TypeBinding argumentType, InvocationSite location) {
	int severity = this.options.getSeverity(CompilerOptions.VarargsArgumentNeedCast);
	if (severity == ProblemSeverities.Ignore) return;
	ArrayBinding varargsType = (ArrayBinding)method.parameters[method.parameters.length-1];
	if (method.isConstructor()) {
		this.handle(
			IProblem.ConstructorVarargsArgumentNeedCast,
			new String[] {
					new String(argumentType.readableName()),
					new String(varargsType.readableName()),
					new String(method.declaringClass.readableName()),
					typesAsString(method.isVarargs(), method.parameters, false),
					new String(varargsType.elementsType().readableName()),
			},
			new String[] {
					new String(argumentType.shortReadableName()),
					new String(varargsType.shortReadableName()),
					new String(method.declaringClass.shortReadableName()),
					typesAsString(method.isVarargs(), method.parameters, true),
					new String(varargsType.elementsType().shortReadableName()),
			},
			severity,
			location.sourceStart(),
			location.sourceEnd());
	} else {
		this.handle(
			IProblem.MethodVarargsArgumentNeedCast,
			new String[] {
					new String(argumentType.readableName()),
					new String(varargsType.readableName()),
					new String(method.selector),
					typesAsString(method.isVarargs(), method.parameters, false),
					new String(method.declaringClass.readableName()),
					new String(varargsType.elementsType().readableName()),
			},
			new String[] {
					new String(argumentType.shortReadableName()),
					new String(varargsType.shortReadableName()),
					new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true),
					new String(method.declaringClass.shortReadableName()),
					new String(varargsType.elementsType().shortReadableName()),
			},
			severity,
			location.sourceStart(),
			location.sourceEnd());
	}
}
public void varargsConflict(MethodBinding method1, MethodBinding method2, SourceTypeBinding type) {
	this.handle(
		IProblem.VarargsConflict,
		new String[] {
		        new String(method1.selector),
		        typesAsString(method1.isVarargs(), method1.parameters, false),
		        new String(method1.declaringClass.readableName()),
		        typesAsString(method2.isVarargs(), method2.parameters, false),
		        new String(method2.declaringClass.readableName())
		},
		new String[] {
		        new String(method1.selector),
		        typesAsString(method1.isVarargs(), method1.parameters, true),
		        new String(method1.declaringClass.shortReadableName()),
		        typesAsString(method2.isVarargs(), method2.parameters, true),
		        new String(method2.declaringClass.shortReadableName())
		},
		method1.declaringClass == type ? method1.sourceStart() : type.sourceStart(),
		method1.declaringClass == type ? method1.sourceEnd() : type.sourceEnd());
}
public void variableTypeCannotBeVoid(AbstractVariableDeclaration varDecl) {
	String[] arguments = new String[] {new String(varDecl.name)};
	this.handle(




150 = The type of the expression must be an array type but it resolved to {0}
151 = Must explicitly convert the char[] to a String
152 = String constant is exceeding the limit of 65535 bytes of UTF8 encoding
153 = case expressions should be constant expressions
154 = The literal {1} of type {0} is out of range 
156 = Cannot cast from {0} to {1}
157 = Cannot instantiate the type {0}

329 = The type java.lang.Object cannot have a superclass or superinterfaces
330 = The type java.lang.Object must be a class

###[obsolete] 330 = {0} cannot be resolved or is not a valid superclass
###[obsolete] 331 = Superclass {0} is not visible
###[obsolete] 332 = Superclass {0} is ambiguous
###[obsolete] 333 = Superclass {0} cannot be referenced using its binary name
###[obsolete] 334 = Superclass {0} is defined in an inherited type and an enclosing scope
###[obsolete] 335 = {0} cannot be resolved or is not a valid superinterface
###[obsolete] 336 = Superinterface {0} is not visible
###[obsolete] 337 = Superinterface {0} is ambiguous
###[obsolete] 338 = Superinterface {0} cannot be referenced using its binary name
###[obsolete] 339 = Superinterface {0} is defined in an inherited type and an enclosing scope

340 = Duplicate field {0}.{1}
341 = Duplicate modifier for the field {0}
342 = Illegal modifier for the field {0}; only public, protected, private, static, final, transient & volatile are permitted

345 = The field {0} can be either final or volatile, not both
346 = The field {0} cannot be declared static; static fields can only be declared in static or top level types

###[obsolete] 350 = {2} cannot be resolved (or is not a valid type) for the field {1}.{0}
###[obsolete] 351 = The type {2} is not visible for the field {1}.{0}
###[obsolete] 352 = The type {2} is ambiguous for the field {1}.{0}
###[obsolete] 353 = The field type {2} cannot be referenced using its binary name
###[obsolete] 354 = The field type {2} is defined in an inherited type and an enclosing scope

355 = Duplicate function {0}({2}) in type {1}
356 = Illegal modifier for parameter {0}; only final is permitted
357 = Duplicate modifier for the function {1} in type {0}

362 = The abstract function {1} in type {0} can only set a visibility modifier, one of public or protected
363 = The abstract function {1} in type {0} can only be defined by an abstract class
364 = void is an invalid type for the parameter {1} of the function {0}
###[obsolete] 365 = An array of void is an invalid type for the parameter {1} of the function {0}
###[obsolete] 366 = An array of void is an invalid return type for the function {0}
367 = The native function {1} cannot also be declared strictfp
368 = Duplicate modifier for parameter {0}

###[obsolete] 370 = {2} cannot be resolved (or is not a valid type) for the parameter {1} of the function {0}
###[obsolete] 371 = The type {2} is not visible for the parameter {1} of the function {0}
###[obsolete] 372 = The type {2} is ambiguous for the parameter {1} of the function {0}
###[obsolete] 373 = The parameter type {2} cannot be referenced using its binary name
###[obsolete] 374 = The parameter type {2} is defined in an inherited type and an enclosing scope
###[obsolete] 375 = {1} cannot be resolved (or is not an exception type) for the function {0}
###[obsolete] 376 = The exception type {1} is not visible for the function {0}
###[obsolete] 377 = The exception type {1} is ambiguous for the function {0}
###[obsolete] 378 = The exception type {1} cannot be referenced using its binary name
###[obsolete] 379 = The exception type {1} is defined in an inherited type and an enclosing scope
###[obsolete] 380 = {1} cannot be resolved (or is not a valid return type) for the function {0}
###[obsolete] 381 = The return type {1} is not visible for the function {0}
###[obsolete] 382 = The return type {1} is ambiguous for the function {0}
###[obsolete] 383 = The return type {1} cannot be referenced using its binary name
###[obsolete] 384 = The return type {1} is defined in an inherited type and an enclosing scope

385 = The import {0} conflicts with a type defined in the same file
386 = The import {0} collides with another import statement
387 = Only a type can be imported. {0} resolves to a package
388 = The import {0} is never used
390 = The import {0} cannot be resolved

###[obsolete] 391 = The imported type {0} is not visible
###[obsolete] 392 = The imported type {0} is ambiguous
###[obsolete] 393 = The imported type {0} cannot be referenced using its binary name
###[obsolete] 394 = The imported type {0} is defined in an inherited type and an enclosing scope

391 = The static import {0} must be a field or member type

395 = Duplicate modifier for the variable {0}
396 = Illegal modifier for the variable {0}; only final is permitted
###[obsolete] 397 = Redundant null check: The variable {0} cannot be null at this location
###[obsolete] 398 = Null pointer access: The variable {0} can only be null at this location
###[obsolete] 399 = Potential null pointer access: The variable {0} may be null at this location
	
400 = The type {3} must implement the inherited abstract function {2}.{0}({1})
401 = Cannot override the final function from {0}

520 = Duplicate type parameter {0}
521 = Cannot refer to the type parameter {0} as a supertype
522 = Cannot make a static reference to the non-static type {0}
523 = The type java.lang.Object cannot be declared as a generic
524 = The type {0} is not generic; it cannot be parameterized with arguments <{1}>
525 = Incorrect number of arguments for type {0}; it cannot be parameterized with arguments <{1}>
526 = Bound mismatch: The type {0} is not a valid substitute for the bounded parameter <{2} extends {3}> of the type {1}
527 = function {0}({2}) has the same erasure {0}({3}) as another function in type {1}
528 = Illegal forward reference to type parameter {0}
529 = The type {0} is not an interface; it cannot be specified as a bounded parameter
530 = Type safety: The constructor {0}({1}) belongs to the raw type {0}. References to generic type {2} should be parameterized
531 = Type safety: The function {0}({1}) belongs to the raw type {2}. References to generic type {3} should be parameterized
532 = Type safety: The expression of type {0} needs unchecked conversion to conform to {1}
533 = Cannot use the type parameter {0} in a catch block
534 = Cannot use the parameterized type {0} either in catch block or throws clause
535 = Cannot create a generic array of {0}
536 = Type safety: The field {1} from the raw type {2} is assigned a value of type {0}. References to generic type {3} should be parameterized
537 = The type parameter {0} should not be bounded by the final type {1}. Final types cannot be further extended
538 = Inconsistent classfile encountered: The undefined type parameter {0} is referenced from within {1}
539 = The interface {2} cannot be implemented more than once with different arguments: {0} and {1}
540 = Bound mismatch: The constructor {0}({1}) of type {2} is not applicable for the arguments ({3}). The wildcard parameter {5} has no lower bound, and may actually be more restrictive than argument {4}
541 = Bound mismatch: The function {0}({1}) of type {2} is not applicable for the arguments ({3}). The wildcard parameter {5} has no lower bound, and may actually be more restrictive than argument {4}
542 = Bound mismatch: Cannot assign expression of type {0} to wildcard type {1}. The wildcard type has no lower bound, and may actually be more restrictive than expression type
543 = Bound mismatch: The generic function {0}({1}) of type {2} is not applicable for the arguments ({3}). The inferred type {4} is not a valid substitute for the bounded parameter <{5} extends {6}>
544 = Bound mismatch: The generic constructor {0}({1}) of type {2} is not applicable for the arguments ({3}). The inferred type {4} is not a valid substitute for the bounded parameter <{5} extends {6}>
545 = Type safety: Unchecked cast from {0} to {1}
546 = Cannot perform instanceof check against parameterized type {0}. Use instead its raw form {1} since generic type information will be erased at runtime
547 = Cannot perform instanceof check against type parameter {0}. Use instead its erasure {1} since generic type information will be erased at runtime
548 = The function {0}({1}) of type {2} is not generic; it cannot be parameterized with arguments <{3}>
549 = Incorrect number of type arguments for generic function <{3}>{0}({1}) of type {2}; it cannot be parameterized with arguments <{4}>
550 = The parameterized function <{3}>{0}({1}) of type {2} is not applicable for the arguments ({4})
551 = The constructor {0}({1}) of type {2} is not generic; it cannot be parameterized with arguments <{3}>
552 = Incorrect number of type arguments for generic constructor <{3}>{0}({1}) of type {2}; it cannot be parameterized with arguments <{4}>
553 = The parameterized constructor <{3}>{0}({1}) of type {2} is not applicable for the arguments ({4})
554 = The function {0}({1}) of raw type {2} is no longer generic; it cannot be parameterized with arguments <{3}>
555 = The constructor {0}({1}) of raw type {2} is no longer generic; it cannot be parameterized with arguments <{3}>
556 = The type {1} cannot extend or implement {0}. A supertype may not specify any wildcard
557 = The generic class {0} may not subclass java.lang.Throwable
558 = Illegal class literal for the type parameter {0}
559 = Type safety: The return type {0} for {1}({2}) from the type {3} needs unchecked conversion to conform to {4} from the type {5}

561 = The member type {0}<{1}> must be qualified with a parameterized type, since it is not static
562 = The member type {0} must be parameterized, since it is qualified with a parameterized type
563 = The member type {0} cannot be qualified with a parameterized type, since it is static. Remove arguments from qualifying type {1}
###[obsolete] 564 = Bound conflict: {0} is inherited with conflicting arguments
565 = Duplicate functions named {0} with the parameters ({2}) and ({3}) are defined by the type {1}
566 = Cannot allocate the member type {0} using a parameterized compound name; use its simple name and an enclosing instance of type {1}
567 = Duplicate bound {0}
568 = The array type {0} cannot be used as a type parameter bound
569 = Type safety: Unchecked invocation {0}({3}) of the generic constructor {0}({1}) of type {2}
570 = Type safety: Unchecked invocation {0}({3}) of the generic function {0}({1}) of type {2}
571 = The type parameter {0} is hiding the type {1}
572 = {0} is a raw type. References to generic type {1} should be parameterized
573 = Cannot specify any additional bound {0} when first bound is a type parameter
574 = Type safety : A generic array of {0} is created for a varargs parameter
575 = Illegal qualified access from the type parameter {0}
576 = The nested type {0} is hiding the type parameter {1} of type {2}
577 = The nested type {0} is hiding the type parameter {1} of the generic function {2}({3}) of type {4}
578 = Wildcard is not allowed at this location

### FOREACH
580 = Type mismatch: cannot convert from element type {0} to {1}


### SOURCE LEVEL
590 = Syntax error, type parameters are only available if source level is 5.0
591 = Syntax error, static imports are only available if source level is 5.0
592 = Syntax error, 'for each' statements are only available if source level is 5.0
593 = Syntax error, parameterized types are only available if source level is 5.0
594 = Syntax error, enum declarations are only available if source level is 5.0
595 = Syntax error, varargs are only available if source level is 5.0
596 = Syntax error, annotations are only available if source level is 5.0
597 = Syntax error, annotation declarations are only available if source level is 5.0

### ANNOTATIONS
600 = Illegal modifier for the annotation attribute {0}.{1}; only public & abstract are permitted
601 = Extended dimensions are illegal in an annotation attribute declaration
602 = Package annotations must be in file package-info.js
603 = Illegal modifier for the annotation type {0}; only public & abstract are permitted
604 = Illegal modifier for the member annotation type {0}; only public, protected, private, static & abstract are permitted
605 = Invalid type {0} for the annotation attribute {2}.{1}; only primitive type, String, Class, annotation, enumeration are permitted or 1-dimensional arrays thereof
606 = Cycle detected: the annotation type {0} cannot contain attributes of the annotation type itself
607 = Cycle detected: a cycle exists between annotation attributes of {0} and {1}
608 = Duplicate annotation @{0}
609 = The annotation @{0} must define the attribute {1}
610 = Duplicate attribute {0} in annotation @{1}
611 = The attribute {0} is undefined for the annotation type {1}
612 = The value for annotation attribute {0}.{1} must be a class literal
613 = The value for annotation attribute {0}.{1} must be a constant expression
###[obsolete] 614 = The annotation field {0}.{1} must be initialized with a constant expression
615 = Illegal modifier for the annotation field {0}.{1}; only public, static & final are permitted
616 = The annotation type {0} cannot override the function {1}.{2}({3})
617 = Annotation attributes cannot have parameters
618 = Annotation attributes cannot be generic
619 = Annotation type declaration cannot have an explicit superclass
620 = Annotation type declaration cannot have explicit superinterfaces
621 = Duplicate element {0} specified in annotation @{1}
622 = The annotation @{0} is disallowed for this location
623 = The function {0}({1}) of type {2} must override a superclass function
624 = Annotation type declaration cannot have a constructor
625 = The value for annotation attribute {0}.{1} must be some @{2} annotation 
626 = The annotation type {0} should not be used as a superinterface for {1}
627 = The function {0}({1}) of type {2} should be tagged with @Override since it actually overrides a superclass function
628 = The deprecated field {0}.{1} should be annotated with @Deprecated
629 = The deprecated function {0}({1}) of type {2} should be annotated with @Deprecated
630 = The deprecated type {0} should be annotated with @Deprecated
631 = Unhandled warning token {0}
632 = The value for annotation attribute {0}.{1} must be an array initializer
633 = The value for annotation attribute {0}.{1} must be an enum constant expression
634 = The function {0}({1}) of type {2} must override or implement a supertype function

### CORRUPTED BINARIES
700 = The class file {0} contains a signature ''{1}'' ill-formed at position {2}

### AUTOBOXING
720 = The expression of type {0} is boxed into {1}
721 = The expression of type {0} is unboxed into {1}

### ENUMS
750 = Illegal modifier for the enum {0}; only public is permitted
751 = Illegal modifier for the enum constant {0}; no modifier is allowed
752 = Illegal modifier for the local enum {0}; only abstract is permitted
753 = Illegal modifier for the member enum {0}; only public, protected, private, static & abstract are permitted
754 = The enum {1} already defines the function {0}({2}) implicitly
755 = The enum constant {0}.{1} reference cannot be qualified in a case label
756 = The type {1} may not subclass {0} explicitly
757 = Cannot invoke super constructor from enum constructor {0}({1})
758 = The enum {2} can only define the abstract function {0}({1}) if it also defines enum constants with corresponding implementations
759 = The field {0}.{1} cannot be referenced from an enum case label; only enum constants can be used in enum switch
760 = Illegal modifier for the enum constructor; only private is permitted.
761 = The enum constant {0}.{1} has no corresponding case label
762 = Cannot refer to the static enum field {0}.{1} within an initializer

### VARARGS
800 = Extended dimensions are illegal for a variable argument
801 = The argument of type {0} should explicitly be cast to {1} for the invocation of the varargs function {2}({3}) from type {4}. It could alternatively be cast to {5} for a varargs invocation
802 = The argument of type {0} should explicitly be cast to {1} for the invocation of the varargs constructor {2}({3}). It could alternatively be cast to {4} for a varargs invocation
803 = Varargs functions should only override or be overridden by other varargs functions unlike {2}.{0}({1}) and {4}.{0}({3})

### GENERIC JAVADOC
850 = Bound mismatch: The generic function {0}({1}) of type {2} is not applicable for the arguments ({3}). The inferred type {4} is not a valid substitute for the bounded parameter <{5} extends {6}>
851 = The function {0}({1}) of type {2} is not generic; it cannot be parameterized with arguments <{3}>
852 = Incorrect number of type arguments for generic function <{3}>{0}({1}) of type {2}; it cannot be parameterized with arguments <{4}>
853 = The parameterized function <{3}>{0}({1}) of type {2} is not applicable for the arguments ({4})
854 = The function {0}({1}) of raw type {2} is no longer generic; it cannot be parameterized with arguments <{3}>
855 = Bound mismatch: The generic constructor {0}({1}) of type {2} is not applicable for the arguments ({3}). The inferred type {4} is not a valid substitute for the bounded parameter <{5} extends {6}>
856 = The constructor {0}({1}) of type {2} is not generic; it cannot be parameterized with arguments <{3}>
857 = Incorrect number of type arguments for generic constructor <{3}>{0}({1}) of type {2}; it cannot be parameterized with arguments <{4}>
858 = The parameterized constructor <{3}>{0}({1}) of type {2} is not applicable for the arguments ({4})
859 = The constructor {0}({1}) of raw type {2} is no longer generic; it cannot be parameterized with arguments <{3}>

Lines 277-283 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/batch/messages.properties (-1 lines)
277	\ unusedPrivate + unused private member declaration\n\	277	\ unusedPrivate + unused private member declaration\n\
278	\ unusedThrown unused declared thrown exception\n\	278	\ unusedThrown unused declared thrown exception\n\
279	\ uselessTypeCheck unnecessary cast/instanceof operation\n\	279	\ uselessTypeCheck unnecessary cast/instanceof operation\n\
280	\ varargsCast + varargs argument need explicit cast\n\
281	\ warningToken + unhandled warning token in @SuppressWarnings\n\	280	\ warningToken + unhandled warning token in @SuppressWarnings\n\
282	\ \n\	281	\ \n\
283	\ Advanced options:\n\	282	\ Advanced options:\n\




		this.options.put(
			CompilerOptions.OPTION_SuppressWarnings,
			isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);
	} else if (token.equals("warningToken")) {//$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportUnhandledWarningToken,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("unnecessaryElse")) {//$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportUnnecessaryElse,

		this.options.put(
			CompilerOptions.OPTION_ReportTypeParameterHiding,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("varargsCast")) { //$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportVarargsArgumentNeedCast,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("null")) { //$NON-NLS-1$
		if (isEnabling) {
			this.options.put(CompilerOptions.OPTION_ReportNullReference,

		this.options.put(
			CompilerOptions.OPTION_ReportAutoboxing,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("over-ann")) { //$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportMissingOverrideAnnotation,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("dep-ann")) { //$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportMissingDeprecatedAnnotation,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("intfAnnotation")) { //$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportAnnotationSuperInterface,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("enumSwitch") //$NON-NLS-1$
			|| token.equals("incomplete-switch")) { //$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportIncompleteEnumSwitch,
			isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
	} else if (token.equals("hiding")) { //$NON-NLS-1$
		this.options.put(
			CompilerOptions.OPTION_ReportHiddenCatchBlock,




		}
	}
}
protected void consumeOnlyTypeArguments() {
	super.consumeOnlyTypeArguments();
	popElement(K_BINARY_OPERATOR);
	if(topKnownElementKind(COMPLETION_OR_ASSIST_PARSER) == K_PARAMETERIZED_METHOD_INVOCATION) {
		popElement(K_PARAMETERIZED_METHOD_INVOCATION);
		pushOnElementStack(K_PARAMETERIZED_METHOD_INVOCATION, INSIDE_NAME);
	} else {
		popElement(K_PARAMETERIZED_ALLOCATION);
	}
}
protected void consumeOnlyTypeArgumentsForCastExpression() {
	super.consumeOnlyTypeArgumentsForCastExpression();
	pushOnElementStack(K_PARAMETERIZED_CAST);

Lines 139-145 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/MethodVerifier.java (-1 lines)
139	}	139	}
140	void checkAgainstInheritedMethods(MethodBinding currentMethod, MethodBinding[] methods, int length, MethodBinding[] allInheritedMethods) {	140	void checkAgainstInheritedMethods(MethodBinding currentMethod, MethodBinding[] methods, int length, MethodBinding[] allInheritedMethods) {
141	if (this.type.isAnnotationType()) { // annotation cannot override any method	141	if (this.type.isAnnotationType()) { // annotation cannot override any method
142	problemReporter().annotationCannotOverrideMethod(currentMethod, methods[length - 1]);
143	return; // do not repoort against subsequent inherited methods	142	return; // do not repoort against subsequent inherited methods
144	}	143	}
145	CompilerOptions options = type.scope.compilerOptions();	144	CompilerOptions options = type.scope.compilerOptions();

Lines 106-116 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/MethodScope.java (-5 / +1 lines)
106	// check for abnormal modifiers	106	// check for abnormal modifiers
107	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccStatic \| ClassFileConstants.AccPublic \| ClassFileConstants.AccPrivate \| ClassFileConstants.AccProtected \| ClassFileConstants.AccStrictfp);	107	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccStatic \| ClassFileConstants.AccPublic \| ClassFileConstants.AccPrivate \| ClassFileConstants.AccProtected \| ClassFileConstants.AccStrictfp);
108	if (declaringClass.isEnum() && !((ConstructorDeclaration) referenceContext).isDefaultConstructor) {	108	if (declaringClass.isEnum() && !((ConstructorDeclaration) referenceContext).isDefaultConstructor) {
109	final int UNEXPECTED_ENUM_CONSTR_MODIFIERS = ~(ClassFileConstants.AccPrivate \| ClassFileConstants.AccStrictfp);	109	if ((((AbstractMethodDeclaration) referenceContext).modifiers & ClassFileConstants.AccStrictfp) != 0) {
110	if ((realModifiers & UNEXPECTED_ENUM_CONSTR_MODIFIERS) != 0) {
111	problemReporter().illegalModifierForEnumConstructor((AbstractMethodDeclaration) referenceContext);
112	modifiers &= ~ExtraCompilerModifiers.AccJustFlag \| ~UNEXPECTED_ENUM_CONSTR_MODIFIERS;
113	} else if ((((AbstractMethodDeclaration) referenceContext).modifiers & ClassFileConstants.AccStrictfp) != 0) {
114	// must check the parse node explicitly	110	// must check the parse node explicitly
115	problemReporter().illegalModifierForMethod((AbstractMethodDeclaration) referenceContext);	111	problemReporter().illegalModifierForMethod((AbstractMethodDeclaration) referenceContext);
116	}	112	}




					if (methodDecl == null) {
						methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost & may still be null if method is special
						if (methodDecl != null && methodDecl.binding != null) { // ensure its a valid user defined method
							this.scope
									.problemReporter()
									.duplicateMethodInType(this, methodDecl);
							
							} else {
								this.scope
										.problemReporter()
										.duplicateMethodInType(this, methodDecl);
							}
							methodDecl.binding = null;
							// do not alter original method array until resolution is over, due to reentrance (143259)
							if (resolvedMethods == this.methods) {

					AbstractMethodDeclaration method2Decl = method2
							.sourceMethod();
					if (method2Decl != null && method2Decl.binding != null) { // ensure its a valid user defined method
						this.scope.problemReporter().duplicateMethodInType(
								this, method2Decl);
						
											method2Decl);
						} else {
							this.scope.problemReporter().duplicateMethodInType(
									this, method2Decl);
						}
						method2Decl.binding = null;
						// do not alter original method array until resolution is over, due to reentrance (143259)
						if (resolvedMethods == this.methods) {




			if (method == null) return null; // incompatible
			if (!method.isValidBinding()) return method; // bound check issue is taking precedence
			parameters = method.parameters; // reacquire them after type inference has performed
		} else if (genericTypeArguments != null) {
			if (method instanceof ParameterizedGenericMethodBinding) {
				if (!((ParameterizedGenericMethodBinding) method).wasInferred) {
					// attempt to invoke generic method of raw type with type hints <String>foo()
					return new ProblemMethodBinding(method, method.selector, genericTypeArguments, ProblemReasons.TypeArgumentsForRawGenericMethod);
				}
			} else {
				return new ProblemMethodBinding(method, method.selector, genericTypeArguments, ProblemReasons.TypeParameterArityMismatch);
			}
		}

		if (parameterCompatibilityLevel(method, arguments) > NOT_COMPATIBLE)
			return method;
		if (genericTypeArguments != null)
			return new ProblemMethodBinding(method, method.selector, arguments, ProblemReasons.ParameterizedMethodTypeMismatch);
		return null; // incompatible
	}





import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.core.infer.InferredType;
import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.compiler.env.IDependent;
import org.eclipse.wst.jsdt.internal.compiler.util.SimpleLookupTable;

	boolean inCycle = false; // check each method before failing
	for (int i = 0, l = currentMethods.length; i < l; i++) {
		TypeBinding returnType = currentMethods[i].returnType.leafComponentType();
		if (returnType.isAnnotationType() && ((ReferenceBinding) returnType).detectAnnotationCycle()) {
			if (this instanceof SourceTypeBinding) {
				MethodDeclaration decl = (MethodDeclaration) currentMethods[i].sourceMethod();
				((SourceTypeBinding) this).scope.problemReporter().annotationCircularity(this, this, decl != null ? decl.returnType : null);
			}
		} else if (returnType.isAnnotationType() && ((ReferenceBinding) returnType).detectAnnotationCycle()) {
			if (this instanceof SourceTypeBinding) {
				MethodDeclaration decl = (MethodDeclaration) currentMethods[i].sourceMethod();
				((SourceTypeBinding) this).scope.problemReporter().annotationCircularity(this, returnType, decl != null ? decl.returnType : null);
			}
			inCycle = true;
		}
	}




		sourceType.typeVariables = Binding.NO_TYPE_VARIABLES; // safety

		if (sourceType.id == T_JavaLangObject) { // handle the case of redefining java.lang.Object up front
			problemReporter().objectCannotBeGeneric(referenceContext);
			return;
		}
		sourceType.typeVariables = createTypeVariables(typeParameters, sourceType);

				final int UNEXPECTED_MODIFIERS =
					~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccStatic | ClassFileConstants.AccAbstract | ClassFileConstants.AccInterface | ClassFileConstants.AccStrictfp | ClassFileConstants.AccAnnotation);
				if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
					if ((realModifiers & ClassFileConstants.AccAnnotation) == 0)
						problemReporter().illegalModifierForAnnotationMemberType(sourceType);
					else
						problemReporter().illegalModifierForMemberInterface(sourceType);
				}
				/*

			} else {
				final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccAbstract | ClassFileConstants.AccInterface | ClassFileConstants.AccStrictfp | ClassFileConstants.AccAnnotation);
				if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
					if ((realModifiers & ClassFileConstants.AccAnnotation) == 0)
						problemReporter().illegalModifierForAnnotationType(sourceType);
					else
						problemReporter().illegalModifierForInterface(sourceType);
				}
			}
			modifiers |= ClassFileConstants.AccAbstract;
		} else if ((realModifiers & ClassFileConstants.AccEnum) != 0) {
			// detect abnormal cases for enums
			if (isMemberType) { // includes member types defined inside local types
				final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccStatic | ClassFileConstants.AccStrictfp | ClassFileConstants.AccEnum);
				if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
					problemReporter().illegalModifierForMemberEnum(sourceType);
			} else if (sourceType.isLocalType()) { // each enum constant is an anonymous local type
				final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccStrictfp | ClassFileConstants.AccFinal | ClassFileConstants.AccEnum); // add final since implicitly set for anonymous type
				if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
					problemReporter().illegalModifierForLocalEnum(sourceType);
			} else {
				final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccStrictfp | ClassFileConstants.AccEnum);
				if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
					problemReporter().illegalModifierForEnum(sourceType);
			}
			if (!sourceType.isAnonymousType()) {
				checkAbstractEnum: {
					// does define abstract methods ?


			// and then check that they are the only ones
			if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != IMPLICIT_MODIFIERS) {
				if ((declaringClass.modifiers  & ClassFileConstants.AccAnnotation) == 0)
					problemReporter().illegalModifierForAnnotationField(fieldDecl);
				else
					problemReporter().illegalModifierForInterfaceField(fieldDecl);
			}
			fieldBinding.modifiers = modifiers;
			return;
		} else if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
			// check that they are not modifiers in source
			if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != 0)
				problemReporter().illegalModifierForEnumConstant(declaringClass, fieldDecl);

			// set the modifiers
			final int IMPLICIT_MODIFIERS = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal | ClassFileConstants.AccEnum;
			fieldBinding.modifiers|= IMPLICIT_MODIFIERS;

					problemReporter().superclassMustBeAClass(sourceType, superclassRef, superclass);
				} else if (superclass.isFinal()) {
					problemReporter().classExtendFinalClass(sourceType, superclassRef, superclass);
				} else if ((superclass.tagBits & TagBits.HasDirectWildcard) != 0) {
					problemReporter().superTypeCannotUseWildcard(sourceType, superclassRef, superclass);
				} else if (superclass.erasure().id == T_JavaLangEnum) {
					problemReporter().cannotExtendEnum(sourceType, superclassRef, superclass);
				} else {
					// only want to reach here when no errors are reported
					sourceType.superclass = superclass;

		// check argument type compatibility
		ParameterizedTypeBinding  superType = environment().createParameterizedType(rootEnumType, new TypeBinding[]{ environment().convertToRawType(sourceType) } , null);
		sourceType.superclass = superType;
		// bound check (in case of bogus definition of Enum type)
		if (refTypeVariables[0].boundCheck(superType, sourceType) != TypeConstants.OK) {
			problemReporter().typeMismatchError(rootEnumType, refTypeVariables[0], sourceType, null);
		}
		return !foundCycle;
	}






	for (int i = 0, l = abstractMethods.length; i < l; i++) {
		MethodBinding abstractMethod = abstractMethods[i];
		if (concreteMethod.isVarargs() != abstractMethod.isVarargs())
			problemReporter().varargsConflict(concreteMethod, abstractMethod, this.type);

		// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod
		MethodBinding originalInherited = abstractMethod.original();

	}
}
void checkForBridgeMethod(MethodBinding currentMethod, MethodBinding inheritedMethod, MethodBinding[] allInheritedMethods) {
	if (currentMethod.isVarargs() != inheritedMethod.isVarargs())
		problemReporter(currentMethod).varargsConflict(currentMethod, inheritedMethod, this.type);

	// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod
	MethodBinding originalInherited = inheritedMethod.original();
	if (originalInherited.returnType != currentMethod.returnType) {




		computeSubstitutes: {
			if (substitutes != null) {
				// explicit type arguments got supplied
				if (substitutes.length != typeVariables.length) {
			        // incompatible due to wrong arity
			        return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, ProblemReasons.TypeParameterArityMismatch);
				}
				methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);
				break computeSubstitutes;
			}

			    TypeVariableBinding typeVariable = typeVariables[i];
			    TypeBinding substitute = methodSubstitute.typeArguments[i];
				switch (typeVariable.boundCheck(methodSubstitute, substitute)) {
					case TypeConstants.MISMATCH :
				        // incompatible due to bound check
						int argLength = arguments.length;
						TypeBinding[] augmentedArguments = new TypeBinding[argLength + 2]; // append offending substitute and typeVariable
						System.arraycopy(arguments, 0, augmentedArguments, 0, argLength);
						augmentedArguments[argLength] = substitute;
						augmentedArguments[argLength+1] = typeVariable;
				        return new ProblemMethodBinding(methodSubstitute, originalMethod.selector, augmentedArguments, ProblemReasons.ParameterBoundMismatch);
					case TypeConstants.UNCHECKED :
						// tolerate unchecked bounds
						methodSubstitute.isUnchecked = true;

Lines 21-30 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/ProblemReasons.java (-4 lines)
21	final int NonStaticReferenceInStaticContext = 7;	21	final int NonStaticReferenceInStaticContext = 7;
22	final int ReceiverTypeNotVisible = 8;	22	final int ReceiverTypeNotVisible = 8;
23	final int IllegalSuperTypeVariable = 9;	23	final int IllegalSuperTypeVariable = 9;
24	final int ParameterBoundMismatch = 10; // for generic method
25	final int TypeParameterArityMismatch = 11; // for generic method
26	final int ParameterizedMethodTypeMismatch = 12; // for generic method
27	final int TypeArgumentsForRawGenericMethod = 13; // for generic method
28	final int InvalidTypeForStaticImport = 14;	24	final int InvalidTypeForStaticImport = 14;
29	final int NotAFunction = 15;	25	final int NotAFunction = 15;
30	}	26	}

Lines 69-75 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/ParameterizedTypeBinding.java (-1 lines)
69	for (int i = 0, length = typeVariables.length; i < length; i++) {	69	for (int i = 0, length = typeVariables.length; i < length; i++) {
70	if (typeVariables[i].boundCheck(this, this.arguments[i]) != TypeConstants.OK) {	70	if (typeVariables[i].boundCheck(this, this.arguments[i]) != TypeConstants.OK) {
71	hasErrors = true;	71	hasErrors = true;
72	scope.problemReporter().typeMismatchError(this.arguments[i], typeVariables[i], this.type, argumentReferences[i]);
73	}	72	}
74	}	73	}
75	}	74	}




 *                                 AnnotationValueMustBeArrayInitializer
 *                                 InvalidEncoding
 *                                 CannotReadSource
 *                                 EnumStaticFieldInInInitializerContext
 *                                 ExternalProblemNotFixable
 *                                 ExternalProblemFixable
 *     IBM Corporation - added the following constants

	int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
	// constant expressions
	int StringConstantIsExceedingUtf8Limit = Internal + 152;
	int NonConstantExpression = Internal + 153;
	int NumericValueOutOfRange = Internal + 154;
	// cast expressions
	int IllegalCast = TypeRelated + 156;

	int ObjectCannotHaveSuperTypes = Internal + 329;
	int ObjectMustBeClass = Internal + 330;

	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
	int SuperclassNotFound =  TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
	int SuperclassNotVisible =  TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
	int SuperclassAmbiguous =  TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
	int SuperclassInternalNameProvided =  TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
	int SuperclassInheritedNameHidesEnclosingName =  TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334

	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
	int InterfaceNotFound =  TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
	int InterfaceNotVisible =  TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
	int InterfaceAmbiguous =  TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
	int InterfaceInternalNameProvided =  TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
	int InterfaceInheritedNameHidesEnclosingName =  TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339

	// field related problems
	int DuplicateField = FieldRelated + 340;
	int DuplicateModifierForField = FieldRelated + 341;

	int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
	int AbstractMethodInAbstractClass = MethodRelated + 363;
	int ArgumentTypeCannotBeVoid = MethodRelated + 364;
	/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
	int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
	/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
	int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
	int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
	int DuplicateModifierForArgument = MethodRelated + 368;

	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
	int ArgumentTypeNotFound =  MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
	int ArgumentTypeNotVisible =  MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
	int ArgumentTypeAmbiguous =  MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
	int ArgumentTypeInternalNameProvided =  MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
	int ArgumentTypeInheritedNameHidesEnclosingName =  MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374

	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
	int ExceptionTypeNotFound =  MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
	int ExceptionTypeNotVisible =  MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
	int ExceptionTypeAmbiguous =  MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
	int ExceptionTypeInternalNameProvided =  MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
	int ExceptionTypeInheritedNameHidesEnclosingName =  MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379

	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
	int ReturnTypeNotFound =  MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
	int ReturnTypeNotVisible =  MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
	int ReturnTypeAmbiguous =  MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
	int ReturnTypeInternalNameProvided =  MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
	int ReturnTypeInheritedNameHidesEnclosingName =  MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384

	// import related problems
	int ConflictingImport = ImportRelated + 385;
	int DuplicateImport = ImportRelated + 386;
	int CannotImportPackage = ImportRelated + 387;

	int ImportNotFound =  ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
	int ImportNotVisible =  ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
	int ImportAmbiguous =  ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
	int ImportInternalNameProvided =  ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
	int ImportInheritedNameHidesEnclosingName =  ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394

	int InvalidTypeForStaticImport =  ImportRelated + 391;

	// local variable related problems
	int DuplicateModifierForVariable = MethodRelated + 395;
	int IllegalModifierForVariable = MethodRelated + 396;
	/** @deprecated - problem is no longer generated, use {@link #RedundantNullCheckOnNonNullLocalVariable} instead */
	int LocalVariableCannotBeNull = Internal + 397; // since 3.3: semantics are LocalVariableRedundantCheckOnNonNull
	/** @deprecated - problem is no longer generated, use {@link #NullLocalVariableReference}, {@link #RedundantNullCheckOnNullLocalVariable} or {@link #RedundantLocalVariableNullAssignment} instead */
	int LocalVariableCanOnlyBeNull = Internal + 398; // since 3.3: split with LocalVariableRedundantCheckOnNull depending on context
	/** @deprecated - problem is no longer generated, use {@link #PotentialNullLocalVariableReference} instead */
	int LocalVariableMayBeNull = Internal + 399;

	// method verifier problems
	int AbstractMethodMustBeImplemented = MethodRelated + 400;

	int DuplicateTypeVariable = Internal + 520;
	int IllegalTypeVariableSuperReference = Internal + 521;
	int NonStaticTypeFromStaticInvocation = Internal + 522;
	int ObjectCannotBeGeneric = Internal + 523;
	int NonGenericType = TypeRelated + 524;
	int IncorrectArityForParameterizedType = TypeRelated + 525;
	int TypeArgumentMismatch = TypeRelated + 526;
	int DuplicateMethodErasure = TypeRelated + 527;
	int ReferenceToForwardTypeVariable = TypeRelated + 528;
	int BoundMustBeAnInterface = TypeRelated + 529;

	int FinalBoundForTypeVariable = TypeRelated + 537;
	int UndefinedTypeVariable = Internal + 538;
	int SuperInterfacesCollide = TypeRelated + 539;
	int GenericMethodTypeArgumentMismatch = TypeRelated + 543;
	int GenericConstructorTypeArgumentMismatch = TypeRelated + 544;
	int UnsafeGenericCast = TypeRelated + 545;
	int IllegalInstanceofParameterizedType = Internal + 546;
	int IllegalInstanceofTypeParameter = Internal + 547;
	int NonGenericMethod = TypeRelated + 548;
	int IncorrectArityForParameterizedMethod = TypeRelated + 549;
	int ParameterizedMethodArgumentTypeMismatch = TypeRelated + 550;
	int NonGenericConstructor = TypeRelated + 551;
	int IncorrectArityForParameterizedConstructor = TypeRelated + 552;
	int ParameterizedConstructorArgumentTypeMismatch = TypeRelated + 553;
	int TypeArgumentsForRawGenericMethod = TypeRelated + 554;
	int TypeArgumentsForRawGenericConstructor = TypeRelated + 555;
	int SuperTypeUsingWildcard = TypeRelated + 556;
	int GenericTypeCannotExtendThrowable = TypeRelated + 557;
	int IllegalClassLiteralForTypeVariable = TypeRelated + 558;
	int UnsafeReturnTypeOverride = MethodRelated + 559;
	int MethodNameClash = MethodRelated + 560;
	int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;
	int StaticMemberOfParameterizedType = TypeRelated + 563;
	int BoundHasConflictingArguments = TypeRelated + 564;
	int DuplicateParameterizedMethods = MethodRelated + 565;
	int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;
	int DuplicateBounds = TypeRelated + 567;

	int TypeParameterHidingType = TypeRelated + 571;
	int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;
	int IllegalAccessFromTypeVariable = TypeRelated + 575;
	int TypeHidingTypeParameterFromType = TypeRelated + 576;
	int TypeHidingTypeParameterFromMethod = TypeRelated + 577;
    int InvalidUsageOfWildcard = Syntax + Internal + 578;

	/**
	 * Foreach

	 * 1.5 Syntax errors (when source level < 1.5)
	 */
    int InvalidUsageOfTypeParameters = Syntax + Internal + 590;
    int InvalidUsageOfStaticImports = Syntax + Internal + 591;
    int InvalidUsageOfForeachStatements = Syntax + Internal + 592;
    int InvalidUsageOfTypeArguments = Syntax + Internal + 593;
    int InvalidUsageOfEnumDeclarations = Syntax + Internal + 594;
    int InvalidUsageOfVarargs = Syntax + Internal + 595;
    int InvalidUsageOfAnnotations = Syntax + Internal + 596;
    int InvalidUsageOfAnnotationDeclarations = Syntax + Internal + 597;

    /**
     * Annotation
     */
	int IllegalModifierForAnnotationMethod = MethodRelated + 600;
    int IllegalExtendedDimensions = MethodRelated + 601;
	int InvalidFileNameForPackageAnnotations = Syntax + Internal + 602;
	int IllegalModifierForAnnotationType = TypeRelated + 603;
	int IllegalModifierForAnnotationMemberType = TypeRelated + 604;
	int InvalidAnnotationMemberType = TypeRelated + 605;
	int AnnotationCircularitySelfReference = TypeRelated + 606;
	int AnnotationCircularity = TypeRelated + 607;
	int DuplicateAnnotation = TypeRelated + 608;
	int MissingValueForAnnotationMember = TypeRelated + 609;
	int DuplicateAnnotationMember = Internal + 610;
	int UndefinedAnnotationMember = MethodRelated + 611;
	int AnnotationValueMustBeClassLiteral = Internal + 612;
	int AnnotationValueMustBeConstant = Internal + 613;
	int AnnotationFieldNeedConstantInitialization = Internal + 614;
	int IllegalModifierForAnnotationField = Internal + 615;
	int AnnotationCannotOverrideMethod = MethodRelated + 616;
	int AnnotationMembersCannotHaveParameters = Syntax + Internal + 617;
	int AnnotationMembersCannotHaveTypeParameters = Syntax + Internal + 618;
	int AnnotationTypeDeclarationCannotHaveSuperclass = Syntax + Internal + 619;
	int AnnotationTypeDeclarationCannotHaveSuperinterfaces = Syntax + Internal + 620;
	int DuplicateTargetInTargetAnnotation = Internal + 621;
	int DisallowedTargetForAnnotation = TypeRelated + 622;
	int MethodMustOverride = MethodRelated + 623;
	int AnnotationTypeDeclarationCannotHaveConstructor = Syntax + Internal + 624;
	int AnnotationValueMustBeAnnotation = Internal + 625;
	int AnnotationTypeUsedAsSuperInterface = TypeRelated + 626;
	int MissingOverrideAnnotation = MethodRelated + 627;
	int FieldMissingDeprecatedAnnotation = Internal + 628;
	int MethodMissingDeprecatedAnnotation = Internal + 629;
	int TypeMissingDeprecatedAnnotation = Internal + 630;
	int UnhandledWarningToken = Internal + 631;
	int AnnotationValueMustBeArrayInitializer = Internal + 632;
	int AnnotationValueMustBeAnEnumConstant = Internal + 633;
	int MethodMustOverrideOrImplement = MethodRelated + 634;

	/**
	 * Corrupted binaries

	int UnboxingConversion = Internal + 721;

	/**
	 * Enum
	 */
	int IllegalModifierForEnum = TypeRelated + 750;
	int IllegalModifierForEnumConstant = FieldRelated + 751;
	int IllegalModifierForLocalEnum = TypeRelated + 752;
	int IllegalModifierForMemberEnum = TypeRelated + 753;
	int CannotDeclareEnumSpecialMethod = MethodRelated + 754;
	int IllegalQualifiedEnumConstantLabel = FieldRelated + 755;
	int CannotExtendEnum = TypeRelated + 756;
	int CannotInvokeSuperConstructorInEnum = MethodRelated + 757;
	int EnumAbstractMethodMustBeImplemented = MethodRelated + 758;
	int EnumSwitchCannotTargetField = FieldRelated + 759;
	int IllegalModifierForEnumConstructor = MethodRelated + 760;
	int MissingEnumConstantCase = FieldRelated + 761;
	int EnumStaticFieldInInInitializerContext = FieldRelated + 762;

	/**
	 * Var args
	 */
	int IllegalExtendedDimensionsForVarArgs = Syntax + Internal + 800;
	int MethodVarargsArgumentNeedCast = MethodRelated + 801;
	int ConstructorVarargsArgumentNeedCast = ConstructorRelated + 802;
	int VarargsConflict = MethodRelated + 803;

	/**
	 * Javadoc Generic
	 */
	int JavadocGenericMethodTypeArgumentMismatch = Javadoc + Internal + 850;
	int JavadocNonGenericMethod = Javadoc + Internal + 851;
	int JavadocIncorrectArityForParameterizedMethod = Javadoc + Internal + 852;
	int JavadocParameterizedMethodArgumentTypeMismatch = Javadoc + Internal + 853;
	int JavadocTypeArgumentsForRawGenericMethod = Javadoc + Internal + 854;
	int JavadocGenericConstructorTypeArgumentMismatch = Javadoc + Internal + 855;
	int JavadocNonGenericConstructor = Javadoc + Internal + 856;
	int JavadocIncorrectArityForParameterizedConstructor = Javadoc + Internal + 857;
	int JavadocParameterizedConstructorArgumentTypeMismatch = Javadoc + Internal + 858;
	int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;

	/**
	 * External problems -- These are problems defined by other plugins
	 */





	annotationTypeDeclaration.javadoc = this.javadoc;
	this.javadoc = null;
	pushOnAstStack(annotationTypeDeclaration);
	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		this.problemReporter().invalidUsageOfAnnotationDeclarations(annotationTypeDeclaration);
	}

	// recovery
	if (this.currentElement != null){


	this.listLength = 0; // will be updated when reading super-interfaces

	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		//TODO this code will be never run while 'enum' is an identifier in 1.3 scanner
		this.problemReporter().invalidUsageOfEnumDeclarations(enumDeclaration);
	}

	// recovery
	if (this.currentElement != null){
		this.lastCheckPoint = enumDeclaration.bodyStart;

	/* if incomplete method header, this.listLength counter will not have been reset,
		indicating that some arguments are available on the stack */
	this.listLength++;

//	if(isVarArgs) {
//		if (!this.statementRecoveryActivated &&
//				options.sourceLevel < ClassFileConstants.JDK1_5 &&
//				this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
//				this.problemReporter().invalidUsageOfVarargs(arg);
//		} else if (!this.statementRecoveryActivated &&
//				extendedDimensions > 0) {
//			this.problemReporter().illegalExtendedDimensions(arg);
//		}
//	}
}

protected void handleArgumentComment(Argument arg)

	markerAnnotation = new MarkerAnnotation(typeReference, this.intStack[this.intPtr--]);
	markerAnnotation.declarationSourceEnd = markerAnnotation.sourceEnd;
	pushOnExpressionStack(markerAnnotation);
	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		this.problemReporter().invalidUsageOfAnnotation(markerAnnotation);
	}
	this.recordStringLiterals = true;
}
protected void consumeMemberValueArrayInitializer() {

		annotationRecoveryCheckPoint(normalAnnotation.sourceStart, normalAnnotation.declarationSourceEnd);
	}

	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		this.problemReporter().invalidUsageOfAnnotation(normalAnnotation);
	}
	this.recordStringLiterals = true;
}
protected void consumeOneDimLoop() {
	// OneDimLoop ::= '[' ']'
	this.dimensions++;
}
 
protected void consumeOnlyTypeArguments() {
	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		int length = this.genericsLengthStack[this.genericsLengthPtr];
		this.problemReporter().invalidUsageOfTypeArguments(
			(TypeReference)this.genericsStack[this.genericsPtr - length + 1],
			(TypeReference)this.genericsStack[this.genericsPtr]);
	}
}
protected void consumeOnlyTypeArgumentsForCastExpression() {
	// OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments
}

		annotationRecoveryCheckPoint(singleMemberAnnotation.sourceStart, singleMemberAnnotation.declarationSourceEnd);
	}

	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		this.problemReporter().invalidUsageOfAnnotation(singleMemberAnnotation);
	}
	this.recordStringLiterals = true;
}
protected void consumeSingleStaticImportDeclarationName() {

			this.options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference
		this.problemReporter().invalidUsageOfStaticImports(impt);
	}

	// recovery

			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference
		this.problemReporter().invalidUsageOfStaticImports(impt);
	}

	// recovery

protected void consumeTypeArguments() {
	concatGenericsLists();
	intPtr--;

	if(!this.statementRecoveryActivated &&
			options.sourceLevel < ClassFileConstants.JDK1_5 &&
			this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
		int length = this.genericsLengthStack[this.genericsLengthPtr];
		this.problemReporter().invalidUsageOfTypeArguments(
			(TypeReference)this.genericsStack[this.genericsPtr - length + 1],
			(TypeReference)this.genericsStack[this.genericsPtr]);
	}
}
protected void consumeTypeDeclarations() {
	// TypeDeclarations ::= TypeDeclarations TypeDeclaration

Lines 706-712 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/SourceElementParser.java (-2 lines)
706	this.options.sourceLevel < ClassFileConstants.JDK1_5 &&	706	this.options.sourceLevel < ClassFileConstants.JDK1_5 &&
707	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {	707	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
708	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference	708	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference
709	this.problemReporter().invalidUsageOfStaticImports(impt);
710	}	709	}
711		710
712	// recovery	711	// recovery
Lines 801-807 Link Here
801	options.sourceLevel < ClassFileConstants.JDK1_5 &&	800	options.sourceLevel < ClassFileConstants.JDK1_5 &&
802	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {	801	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
803	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference	802	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference
804	this.problemReporter().invalidUsageOfStaticImports(impt);
805	}	803	}
806		804
807	// recovery	805	// recovery




	public static final String OPTION_ReportUncheckedTypeOperation = "org.eclipse.wst.jsdt.core.compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
	public static final String OPTION_ReportRawTypeReference =  "org.eclipse.wst.jsdt.core.compiler.problem.rawTypeReference"; //$NON-NLS-1$
	public static final String OPTION_ReportFinalParameterBound = "org.eclipse.wst.jsdt.core.compiler.problem.finalParameterBound"; //$NON-NLS-1$
	public static final String OPTION_ReportSwitchCaseShouldBeConstant = "org.eclipse.wst.jsdt.core.compiler.problem.SwitchCaseShouldBeConstant"; //$NON-NLS-1$
	public static final String OPTION_ReportVarargsArgumentNeedCast = "org.eclipse.wst.jsdt.core.compiler.problem.varargsArgumentNeedCast"; //$NON-NLS-1$
	public static final String OPTION_Source = "org.eclipse.wst.jsdt.core.compiler.source"; //$NON-NLS-1$
	public static final String OPTION_TargetPlatform = "org.eclipse.wst.jsdt.core.compiler.codegen.targetPlatform"; //$NON-NLS-1$
	public static final String OPTION_Compliance = "org.eclipse.wst.jsdt.core.compiler.compliance"; //$NON-NLS-1$

	public static final String OPTION_ReportDuplicateLocalVariables = "org.eclipse.wst.jsdt.core.compiler.problem.duplicateLocalVariables"; //$NON-NLS-1$
	public static final String OPTION_ReportRedundantNullCheck = "org.eclipse.wst.jsdt.core.compiler.problem.redundantNullCheck"; //$NON-NLS-1$
	public static final String OPTION_ReportAutoboxing = "org.eclipse.wst.jsdt.core.compiler.problem.autoboxing"; //$NON-NLS-1$
	public static final String OPTION_ReportAnnotationSuperInterface = "org.eclipse.wst.jsdt.core.compiler.problem.annotationSuperInterface"; //$NON-NLS-1$
	public static final String OPTION_ReportMissingOverrideAnnotation = "org.eclipse.wst.jsdt.core.compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$
	public static final String OPTION_ReportMissingDeprecatedAnnotation = "org.eclipse.wst.jsdt.core.compiler.problem.missingDeprecatedAnnotation"; //$NON-NLS-1$
	public static final String OPTION_ReportIncompleteEnumSwitch = "org.eclipse.wst.jsdt.core.compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$
	public static final String OPTION_ReportForbiddenReference =  "org.eclipse.wst.jsdt.core.compiler.problem.forbiddenReference"; //$NON-NLS-1$
	public static final String OPTION_ReportDiscouragedReference =  "org.eclipse.wst.jsdt.core.compiler.problem.discouragedReference"; //$NON-NLS-1$
	public static final String OPTION_SuppressWarnings =  "org.eclipse.wst.jsdt.core.compiler.problem.suppressWarnings"; //$NON-NLS-1$
	public static final String OPTION_ReportUnhandledWarningToken =  "org.eclipse.wst.jsdt.core.compiler.problem.unhandledWarningToken"; //$NON-NLS-1$
	public static final String OPTION_ReportUnusedLabel =  "org.eclipse.wst.jsdt.core.compiler.problem.unusedLabel"; //$NON-NLS-1$
	public static final String OPTION_FatalOptionalError =  "org.eclipse.wst.jsdt.core.compiler.problem.fatalOptionalError"; //$NON-NLS-1$
	public static final String OPTION_ReportParameterAssignment =  "org.eclipse.wst.jsdt.core.compiler.problem.parameterAssignment"; //$NON-NLS-1$

	public static final long FinalParameterBound = ASTNode.Bit32L;
//TODO: remove	MissingSerialVersion
	public static final long MissingSerialVersion = ASTNode.Bit33L;
	public static final long SwitchCaseShouldBeConstant = ASTNode.Bit33L;
	public static final long EnumUsedAsAnIdentifier = ASTNode.Bit34L;
	public static final long ForbiddenReference = ASTNode.Bit35L;
	public static final long VarargsArgumentNeedCast = ASTNode.Bit36L;
	public static final long NullReference = ASTNode.Bit37L;
	public static final long AutoBoxing = ASTNode.Bit38L;
	public static final long AnnotationSuperInterface = ASTNode.Bit39L;
	public static final long TypeHiding = ASTNode.Bit40L;
	public static final long MissingOverrideAnnotation = ASTNode.Bit41L;
	public static final long IncompleteEnumSwitch = ASTNode.Bit42L;
	public static final long MissingDeprecatedAnnotation = ASTNode.Bit43L;
	public static final long DiscouragedReference = ASTNode.Bit44L;
	public static final long UnhandledWarningToken = ASTNode.Bit45L;
	public static final long RawTypeReference = ASTNode.Bit46L;
	public static final long UnusedLabel = ASTNode.Bit47L;
	public static final long ParameterAssignment = ASTNode.Bit48L;

		| EnumUsedAsAnIdentifier
		| UncheckedTypeOperation
		| RawTypeReference
		| SwitchCaseShouldBeConstant
		| VarargsArgumentNeedCast
		| ForbiddenReference
		| DiscouragedReference
		| AnnotationSuperInterface
		| TypeHiding
		| FinalParameterBound
		| UnhandledWarningToken
		| UnusedLocalVariable
		| UnusedPrivateMember
		| UnusedLabel

		optionsMap.put(OPTION_ReportUnnecessaryTypeCheck, getSeverityString(UnnecessaryTypeCheck));
		optionsMap.put(OPTION_ReportUnnecessaryElse, getSeverityString(UnnecessaryElse));
		optionsMap.put(OPTION_ReportAutoboxing, getSeverityString(AutoBoxing));
		optionsMap.put(OPTION_ReportAnnotationSuperInterface, getSeverityString(AnnotationSuperInterface));
		optionsMap.put(OPTION_ReportIncompleteEnumSwitch, getSeverityString(IncompleteEnumSwitch));
		optionsMap.put(OPTION_ReportInvalidJavadoc, getSeverityString(InvalidJavadoc));
		optionsMap.put(OPTION_ReportInvalidJavadocTagsVisibility, getVisibilityString(this.reportInvalidJavadocTagsVisibility));
		optionsMap.put(OPTION_ReportInvalidJavadocTags, this.reportInvalidJavadocTags ? ENABLED : DISABLED);

		optionsMap.put(OPTION_ReportUncheckedTypeOperation, getSeverityString(UncheckedTypeOperation));
		optionsMap.put(OPTION_ReportRawTypeReference, getSeverityString(RawTypeReference));
		optionsMap.put(OPTION_ReportFinalParameterBound, getSeverityString(FinalParameterBound));
		optionsMap.put(OPTION_ReportSwitchCaseShouldBeConstant, getSeverityString(SwitchCaseShouldBeConstant));
		optionsMap.put(OPTION_ReportForbiddenReference, getSeverityString(ForbiddenReference));
		optionsMap.put(OPTION_ReportDiscouragedReference, getSeverityString(DiscouragedReference));
		optionsMap.put(OPTION_ReportVarargsArgumentNeedCast, getSeverityString(VarargsArgumentNeedCast));
		optionsMap.put(OPTION_ReportMissingOverrideAnnotation, getSeverityString(MissingOverrideAnnotation));
		optionsMap.put(OPTION_ReportMissingDeprecatedAnnotation, getSeverityString(MissingDeprecatedAnnotation));
		optionsMap.put(OPTION_ReportIncompleteEnumSwitch, getSeverityString(IncompleteEnumSwitch));
		optionsMap.put(OPTION_ReportUnusedLabel, getSeverityString(UnusedLabel));
		optionsMap.put(OPTION_Compliance, versionFromJdkLevel(this.complianceLevel));
		optionsMap.put(OPTION_Source, versionFromJdkLevel(this.sourceLevel));

		optionsMap.put(OPTION_ReportDuplicateLocalVariables, getSeverityString(DuplicateLocalVariables));
		optionsMap.put(OPTION_ReportRedundantNullCheck, getSeverityString(RedundantNullCheck));
		optionsMap.put(OPTION_SuppressWarnings, this.suppressWarnings ? ENABLED : DISABLED);
		optionsMap.put(OPTION_ReportUnhandledWarningToken, getSeverityString(UnhandledWarningToken));
		optionsMap.put(OPTION_ReportParameterAssignment, getSeverityString(ParameterAssignment));
		optionsMap.put(OPTION_ReportFallthroughCase, getSeverityString(FallthroughCase));
		optionsMap.put(OPTION_ReportOverridingMethodWithoutSuperInvocation, getSeverityString(OverridingMethodWithoutSuperInvocation));

		} else {
			irritantInt = (int)(irritant >>> 32);
			switch (irritantInt) {
				case (int)(SwitchCaseShouldBeConstant >>> 32) :
					return OPTION_ReportSwitchCaseShouldBeConstant ;
				case (int)(EnumUsedAsAnIdentifier >>> 32) :
					return OPTION_ReportEnumIdentifier;
				case (int)(ForbiddenReference >>> 32) :
					return OPTION_ReportForbiddenReference;
				case (int)(VarargsArgumentNeedCast >>> 32) :
					return OPTION_ReportVarargsArgumentNeedCast;
				case (int)(NullReference >>> 32) :
					return OPTION_ReportNullReference;
				case (int)(PotentialNullReference >>> 32) :

					return OPTION_ReportRedundantNullCheck;
				case (int)(AutoBoxing >>> 32) :
					return OPTION_ReportAutoboxing;
				case (int)(AnnotationSuperInterface >>> 32) :
					return OPTION_ReportAnnotationSuperInterface;
				case (int)(TypeHiding >>> 32) :
					return OPTION_ReportTypeParameterHiding;
				case (int)(MissingOverrideAnnotation >>> 32) :
					return OPTION_ReportMissingOverrideAnnotation;
				case (int)(IncompleteEnumSwitch >>> 32) :
					return OPTION_ReportIncompleteEnumSwitch;
				case (int)(MissingDeprecatedAnnotation >>> 32) :
					return OPTION_ReportMissingDeprecatedAnnotation;
				case (int)(DiscouragedReference >>> 32) :
					return OPTION_ReportDiscouragedReference;
				case (int)(UnhandledWarningToken >>> 32) :
					return OPTION_ReportUnhandledWarningToken;
				case (int)(RawTypeReference >>> 32) :
					return OPTION_ReportRawTypeReference;
				case (int)(UnusedLabel >>> 32) :

		if ((optionValue = optionsMap.get(OPTION_ReportUncheckedTypeOperation)) != null) updateSeverity(UncheckedTypeOperation, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportRawTypeReference)) != null) updateSeverity(RawTypeReference, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportFinalParameterBound)) != null) updateSeverity(FinalParameterBound, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportSwitchCaseShouldBeConstant)) != null) updateSeverity(SwitchCaseShouldBeConstant, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportForbiddenReference)) != null) updateSeverity(ForbiddenReference, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportDiscouragedReference)) != null) updateSeverity(DiscouragedReference, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportVarargsArgumentNeedCast)) != null) updateSeverity(VarargsArgumentNeedCast, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportNullReference)) != null) updateSeverity(NullReference, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportPotentialNullReference)) != null) updateSeverity(PotentialNullReference, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportDuplicateLocalVariables)) != null) updateSeverity(DuplicateLocalVariables, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportRedundantNullCheck)) != null) updateSeverity(RedundantNullCheck, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportAutoboxing)) != null) updateSeverity(AutoBoxing, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportAnnotationSuperInterface)) != null) updateSeverity(AnnotationSuperInterface, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportMissingOverrideAnnotation)) != null) updateSeverity(MissingOverrideAnnotation, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportMissingDeprecatedAnnotation)) != null) updateSeverity(MissingDeprecatedAnnotation, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportIncompleteEnumSwitch)) != null) updateSeverity(IncompleteEnumSwitch, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportUnhandledWarningToken)) != null) updateSeverity(UnhandledWarningToken, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportUnusedLabel)) != null) updateSeverity(UnusedLabel, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportParameterAssignment)) != null) updateSeverity(ParameterAssignment, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportFallthroughCase)) != null) updateSeverity(FallthroughCase, optionValue);

		buf.append("\n\t- unsafe type operation: ").append(getSeverityString(UncheckedTypeOperation)); //$NON-NLS-1$
		buf.append("\n\t- unsafe raw type: ").append(getSeverityString(RawTypeReference)); //$NON-NLS-1$
		buf.append("\n\t- final bound for type parameter: ").append(getSeverityString(FinalParameterBound)); //$NON-NLS-1$
		buf.append("\n\t- missing serialVersionUID: ").append(getSeverityString(SwitchCaseShouldBeConstant)); //$NON-NLS-1$
		buf.append("\n\t- varargs argument need cast: ").append(getSeverityString(VarargsArgumentNeedCast)); //$NON-NLS-1$
		buf.append("\n\t- forbidden reference to type with access restriction: ").append(getSeverityString(ForbiddenReference)); //$NON-NLS-1$
		buf.append("\n\t- discouraged reference to type with access restriction: ").append(getSeverityString(DiscouragedReference)); //$NON-NLS-1$
		buf.append("\n\t- null reference: ").append(getSeverityString(NullReference)); //$NON-NLS-1$

		buf.append("\n\t- duplicate local variables: ").append(getSeverityString(DuplicateLocalVariables)); //$NON-NLS-1%
		buf.append("\n\t- redundant null check: ").append(getSeverityString(RedundantNullCheck)); //$NON-NLS-1$
		buf.append("\n\t- autoboxing: ").append(getSeverityString(AutoBoxing)); //$NON-NLS-1$
		buf.append("\n\t- annotation super interface: ").append(getSeverityString(AnnotationSuperInterface)); //$NON-NLS-1$
		buf.append("\n\t- missing @Override annotation: ").append(getSeverityString(MissingOverrideAnnotation)); //$NON-NLS-1$
		buf.append("\n\t- missing @Deprecated annotation: ").append(getSeverityString(MissingDeprecatedAnnotation)); //$NON-NLS-1$
		buf.append("\n\t- incomplete enum switch: ").append(getSeverityString(IncompleteEnumSwitch)); //$NON-NLS-1$
		buf.append("\n\t- suppress warnings: ").append(this.suppressWarnings ? ENABLED : DISABLED); //$NON-NLS-1$
		buf.append("\n\t- unhandled warning token: ").append(getSeverityString(UnhandledWarningToken)); //$NON-NLS-1$
		buf.append("\n\t- unused label: ").append(getSeverityString(UnusedLabel)); //$NON-NLS-1$
		buf.append("\n\t- treat optional error as fatal: ").append(this.treatOptionalErrorAsFatal ? ENABLED : DISABLED); //$NON-NLS-1$
		buf.append("\n\t- parameter assignment: ").append(getSeverityString(ParameterAssignment)); //$NON-NLS-1$

	 */
	public static String[] warningOptionNames() {
		String[] result = {
			OPTION_ReportAnnotationSuperInterface,
			OPTION_ReportAssertIdentifier,
			OPTION_ReportAutoboxing,
			OPTION_ReportDeprecation,

			OPTION_ReportForbiddenReference,
			OPTION_ReportHiddenCatchBlock,
			OPTION_ReportIncompatibleNonInheritedInterfaceMethod,
			OPTION_ReportIncompleteEnumSwitch,
			OPTION_ReportIndirectStaticAccess,
			OPTION_ReportInvalidJavadoc,
			OPTION_ReportLocalVariableHiding,
			OPTION_ReportMethodWithConstructorName,
			OPTION_ReportMissingDeprecatedAnnotation,
			OPTION_ReportMissingJavadocComments,
			OPTION_ReportMissingJavadocTags,
			OPTION_ReportMissingOverrideAnnotation,
			OPTION_ReportSwitchCaseShouldBeConstant,
			OPTION_ReportNoEffectAssignment,
			OPTION_ReportNoImplicitStringConversion,
			OPTION_ReportNonExternalizedStringLiteral,

			OPTION_ReportUnusedLocal,
			OPTION_ReportUnusedParameter,
			OPTION_ReportUnusedPrivateMember,
			OPTION_ReportVarargsArgumentNeedCast,
			OPTION_ReportUnhandledWarningToken,
			OPTION_ReportOverridingMethodWithoutSuperInvocation
		};
		return result;

		} else {
			irritantInt = (int)(irritant >>> 32);
			switch (irritantInt) {
				case (int)(SwitchCaseShouldBeConstant >>> 32) :
					return "serial"; //$NON-NLS-1$
				case (int)(AutoBoxing >>> 32) :
					return "boxing"; //$NON-NLS-1$
				case (int)(TypeHiding >>> 32) :
					return "hiding"; //$NON-NLS-1$
				case (int)(IncompleteEnumSwitch >>> 32) :
					return "incomplete-switch"; //$NON-NLS-1$
				case (int)(MissingDeprecatedAnnotation >>> 32) :
					return "dep-ann"; //$NON-NLS-1$
				case (int)(RawTypeReference >>> 32):
					return "unchecked"; //$NON-NLS-1$
				case (int) (UnusedLabel >>> 32):

		"all", //$NON-NLS-1$
		"boxing", //$NON-NLS-1$
		"cast", //$NON-NLS-1$
		"dep-ann", //$NON-NLS-1$
		"deprecation", //$NON-NLS-1$
		"fallthrough", //$NON-NLS-1$
		"finally", //$NON-NLS-1$
		"hiding", //$NON-NLS-1$
		"incomplete-switch", //$NON-NLS-1$
		"nls", //$NON-NLS-1$
		"null", //$NON-NLS-1$
		"restriction", //$NON-NLS-1$
		"serial", //$NON-NLS-1$
		"static-access", //$NON-NLS-1$
		"super", //$NON-NLS-1$
		"synthetic-access", //$NON-NLS-1$

			case 'd' :
				if ("deprecation".equals(warningToken)) //$NON-NLS-1$
					return UsingDeprecatedAPI;
				if ("dep-ann".equals(warningToken)) //$NON-NLS-1$
					return MissingDeprecatedAnnotation;
				break;
			case 'f' :
				if ("fallthrough".equals(warningToken)) //$NON-NLS-1$

			case 'h' :
				if ("hiding".equals(warningToken)) //$NON-NLS-1$
					return FieldHiding | LocalVariableHiding | MaskedCatchBlock | TypeHiding;
			case 'i' :
				if ("incomplete-switch".equals(warningToken)) //$NON-NLS-1$
					return IncompleteEnumSwitch;
				break;
			case 'n' :
				if ("nls".equals(warningToken)) //$NON-NLS-1$

					return DiscouragedReference | ForbiddenReference;
				break;
			case 's' :
				if ("serial".equals(warningToken)) //$NON-NLS-1$
					return SwitchCaseShouldBeConstant;
				if ("static-access".equals(warningToken)) //$NON-NLS-1$
					return IndirectStaticAccess | NonStaticAccessToStatic;
				if ("synthetic-access".equals(warningToken)) //$NON-NLS-1$

Return to bug 268542

Lines 639-668 Link Here

(-)src/org/eclipse/wst/jsdt/internal/ui/text/correction/ModifierCorrectionSubProcessor.java (-45 lines)
639	proposals.add(new ModifierChangeCompletionProposal(label, cu, binding, selectedNode, Modifier.FINAL, 0, 5, image));	639	proposals.add(new ModifierChangeCompletionProposal(label, cu, binding, selectedNode, Modifier.FINAL, 0, 5, image));
640	}	640	}
641	}	641	}
642	//
643	// public static void addOverrideAnnotationProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
644	// IFix fix= Java50Fix.createAddOverrideAnnotationFix(context.getASTRoot(), problem);
645	// if (fix != null) {
646	// Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
647	// Map options= new Hashtable();
648	// options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS, CleanUpConstants.TRUE);
649	// options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS_OVERRIDE, CleanUpConstants.TRUE);
650	// FixCorrectionProposal proposal= new FixCorrectionProposal(fix, new Java50CleanUp(options), 5, image, context);
651	// proposals.add(proposal);
652	// }
653	// }
654	//
655	// public static void addDeprecatedAnnotationProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
656	// IFix fix= Java50Fix.createAddDeprectatedAnnotation(context.getASTRoot(), problem);
657	// if (fix != null) {
658	// Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
659	// Map options= new Hashtable();
660	// options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS, CleanUpConstants.TRUE);
661	// options.put(CleanUpConstants.ADD_MISSING_ANNOTATIONS_DEPRECATED, CleanUpConstants.TRUE);
662	// FixCorrectionProposal proposal= new FixCorrectionProposal(fix, new Java50CleanUp(options), 5, image, context);
663	// proposals.add(proposal);
664	// }
665	// }
666		642
667	public static void addOverridingDeprecatedMethodProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {	643	public static void addOverridingDeprecatedMethodProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
668		644
Lines 692-718 Link Here
692	ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, cu, rewrite, 15, image);	668	ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, cu, rewrite, 15, image);
693	proposals.add(proposal);	669	proposals.add(proposal);
694	}	670	}
695
696	public static void removeOverrideAnnotationProposal(IInvocationContext context, IProblemLocation problem, Collection proposals) throws CoreException {
697	// IJavaScriptUnit cu= context.getCompilationUnit();
698	//
699	// ASTNode selectedNode= problem.getCoveringNode(context.getASTRoot());
700	// if (!(selectedNode instanceof FunctionDeclaration)) {
701	// return;
702	// }
703	// FunctionDeclaration methodDecl= (FunctionDeclaration) selectedNode;
704	// Annotation annot= findAnnotation("java.lang.Override", methodDecl.modifiers()); //$NON-NLS-1$
705	// if (annot != null) {
706	// ASTRewrite rewrite= ASTRewrite.create(annot.getAST());
707	// rewrite.remove(annot, null);
708	// String label= CorrectionMessages.ModifierCorrectionSubProcessor_remove_override;
709	// Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
710	// ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, cu, rewrite, 6, image);
711	// proposals.add(proposal);
712	//
713	// QuickAssistProcessor.getCreateInSuperClassProposals(context, methodDecl.getName(), proposals);
714	// }
715	}
716		671
717	private static final String KEY_MODIFIER= "modifier"; //$NON-NLS-1$	672	private static final String KEY_MODIFIER= "modifier"; //$NON-NLS-1$
718		673

Lines 220-246 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/SwitchStatement.java (-21 lines)
220	upperScope.problemReporter().undocumentedEmptyBlock(this.blockStart, this.sourceEnd);	220	upperScope.problemReporter().undocumentedEmptyBlock(this.blockStart, this.sourceEnd);
221	}	221	}
222	}	222	}
223	// for enum switch, check if all constants are accounted for (if no default)
224	// if (isEnumSwitch && defaultCase == null
225	// && upperScope.compilerOptions().getSeverity(CompilerOptions.IncompleteEnumSwitch) != ProblemSeverities.Ignore) {
226	// int constantCount = this.constants == null ? 0 : this.constants.length; // could be null if no case statement
227	// if (constantCount == caseCount // ignore diagnosis if unresolved constants
228	// && caseCount != ((ReferenceBinding)expressionType).enumConstantCount()) {
229	// FieldBinding[] enumFields = ((ReferenceBinding)expressionType.erasure()).fields();
230	// for (int i = 0, max = enumFields.length; i <max; i++) {
231	// FieldBinding enumConstant = enumFields[i];
232	// if ((enumConstant.modifiers & ClassFileConstants.AccEnum) == 0) continue;
233	// findConstant : {
234	// for (int j = 0; j < caseCount; j++) {
235	// if ((enumConstant.id + 1) == this.constants[j]) // zero should not be returned see bug 141810
236	// break findConstant;
237	// }
238	// // enum constant did not get referenced from switch
239	// upperScope.problemReporter().missingEnumConstantCase(this, enumConstant);
240	// }
241	// }
242	// }
243	// }
244	} finally {	223	} finally {
245	if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block	224	if (this.scope != null) this.scope.enclosingCase = null; // no longer inside switch case block
246	}	225	}

Lines 235-244 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/ExplicitConstructorCall.java (-7 lines)
235	if (receiverType == null) {	235	if (receiverType == null) {
236	return;	236	return;
237	}	237	}
238	// prevent (explicit) super constructor invocation from within enum
239	if (this.accessMode == Super && receiverType.erasure().id == T_JavaLangEnum) {
240	scope.problemReporter().cannotInvokeSuperConstructorInEnum(this, methodScope.referenceMethod().binding);
241	}
242	// qualification should be from the type of the enclosingType	238	// qualification should be from the type of the enclosingType
243	if (qualification != null) {	239	if (qualification != null) {
244	if (accessMode != Super) {	240	if (accessMode != Super) {
Lines 267-275 Link Here
267	if ((this.genericTypeArguments[i] = typeReference.resolveType(scope, true /* check bounds*/)) == null) {	263	if ((this.genericTypeArguments[i] = typeReference.resolveType(scope, true /* check bounds*/)) == null) {
268	argHasError = true;	264	argHasError = true;
269	}	265	}
270	if (argHasError && typeReference instanceof Wildcard) {
271	scope.problemReporter().illegalUsageOfWildcard(typeReference);
272	}
273	}	266	}
274	if (argHasError) {	267	if (argHasError) {
275	return;	268	return;

Lines 310-319 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/TypeDeclaration.java (-34 lines)
310	// report the problem and continue the parsing	310	// report the problem and continue the parsing
311	parser.problemReporter().interfaceCannotHaveConstructors((ConstructorDeclaration) am);	311	parser.problemReporter().interfaceCannotHaveConstructors((ConstructorDeclaration) am);
312	break;	312	break;
313	case TypeDeclaration.ANNOTATION_TYPE_DECL :
314	// report the problem and continue the parsing
315	parser.problemReporter().annotationTypeDeclarationCannotHaveConstructor((ConstructorDeclaration) am);
316	break;
317		313
318	}	314	}
319	hasConstructor = true;	315	hasConstructor = true;
Lines 862-873 Link Here
862	// } finally {	858	// } finally {
863	// this.staticInitializerScope.insideTypeAnnotation = old;	859	// this.staticInitializerScope.insideTypeAnnotation = old;
864	// }	860	// }
865	// check @Deprecated annotation
866	if ((sourceType.getAnnotationTagBits() & TagBits.AnnotationDeprecated) == 0
867	&& (sourceType.modifiers & ClassFileConstants.AccDeprecated) != 0
868	&& this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
869	this.scope.problemReporter().missingDeprecatedAnnotationForType(this);
870	}
871	if ((this.bits & ASTNode.UndocumentedEmptyBlock) != 0) {	861	if ((this.bits & ASTNode.UndocumentedEmptyBlock) != 0) {
872	this.scope.problemReporter().undocumentedEmptyBlock(this.bodyStart-1, this.bodyEnd);	862	this.scope.problemReporter().undocumentedEmptyBlock(this.bodyStart-1, this.bodyEnd);
873	}	863	}
Lines 985-1014 Link Here
985	if (needSerialVersion) {	975	if (needSerialVersion) {
986	this.scope.problemReporter().missingSerialVersion(this);	976	this.scope.problemReporter().missingSerialVersion(this);
987	}	977	}
988	// check extends/implements for annotation type
989	switch(kind(this.modifiers)) {
990	case TypeDeclaration.ANNOTATION_TYPE_DECL :
991	if (this.superclass != null) {
992	this.scope.problemReporter().annotationTypeDeclarationCannotHaveSuperclass(this);
993	}
994	if (this.superInterfaces != null) {
995	this.scope.problemReporter().annotationTypeDeclarationCannotHaveSuperinterfaces(this);
996	}
997	break;
998	case TypeDeclaration.ENUM_DECL :
999	// check enum abstract methods
1000	if (this.binding.isAbstract()) {
1001	if (!hasEnumConstants \|\| hasEnumConstantsWithoutBody) {
1002	for (int i = 0, count = this.methods.length; i < count; i++) {
1003	final AbstractMethodDeclaration methodDeclaration = this.methods[i];
1004	if (methodDeclaration.isAbstract() && methodDeclaration.binding != null) {
1005	this.scope.problemReporter().enumAbstractMethodMustBeImplemented(methodDeclaration);
1006	}
1007	}
1008	}
1009	}
1010	break;
1011	}
1012		978
1013	int missingAbstractMethodslength = this.missingAbstractMethods == null ? 0 : this.missingAbstractMethods.length;	979	int missingAbstractMethodslength = this.missingAbstractMethods == null ? 0 : this.missingAbstractMethods.length;
1014	int methodsLength = this.methods == null ? 0 : this.methods.length;	980	int methodsLength = this.methods == null ? 0 : this.methods.length;

Lines 308-329 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/ASTNode.java (-13 / +1 lines)
308	ArrayBinding varargsType = (ArrayBinding) params[varargsIndex];	308	ArrayBinding varargsType = (ArrayBinding) params[varargsIndex];
309	TypeBinding lastArgType = argumentTypes[varargsIndex];	309	TypeBinding lastArgType = argumentTypes[varargsIndex];
310	int dimensions;	310	int dimensions;
311	if (lastArgType == TypeBinding.NULL) {	311	if (lastArgType != TypeBinding.NULL && (varargsType.dimensions <= (dimensions = lastArgType.dimensions()))) {
312	if (!(varargsType.leafComponentType().isBaseType() && varargsType.dimensions() == 1))
313	scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
314	} else if (varargsType.dimensions <= (dimensions = lastArgType.dimensions())) {
315	if (lastArgType.leafComponentType().isBaseType()) {	312	if (lastArgType.leafComponentType().isBaseType()) {
316	dimensions--;	313	dimensions--;
317	}	314	}
318	if (varargsType.dimensions < dimensions) {
319	scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
320	} else if (varargsType.dimensions == dimensions
321	&& lastArgType != varargsType
322	&& lastArgType.leafComponentType().erasure() != varargsType.leafComponentType.erasure()
323	&& lastArgType.isCompatibleWith(varargsType.elementsType())
324	&& lastArgType.isCompatibleWith(varargsType)) {
325	scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
326	}
327	}	315	}
328	}	316	}
329	} else {	317	} else {

Lines 156-171 Link Here

(-)src/org/eclipse/wst/jsdt/internal/ui/fix/Java50CleanUp.java (-10 lines)
156	public int maximalNumberOfFixes(JavaScriptUnit compilationUnit) {	156	public int maximalNumberOfFixes(JavaScriptUnit compilationUnit) {
157	int result= 0;	157	int result= 0;
158	IProblem[] problems= compilationUnit.getProblems();	158	IProblem[] problems= compilationUnit.getProblems();
159	if (isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS) && isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS_OVERRIDE)) {
160	result+= getNumberOfProblems(problems, IProblem.MissingOverrideAnnotation);
161	}
162	if (isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS) && isEnabled(CleanUpConstants.ADD_MISSING_ANNOTATIONS_DEPRECATED)) {
163	for (int i=0;i<problems.length;i++) {
164	int id= problems[i].getID();
165	if (id == IProblem.FieldMissingDeprecatedAnnotation \|\| id == IProblem.MethodMissingDeprecatedAnnotation \|\| id == IProblem.TypeMissingDeprecatedAnnotation)
166	result++;
167	}
168	}
169	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES)) {	159	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES)) {
170	for (int i=0;i<problems.length;i++) {	160	for (int i=0;i<problems.length;i++) {
171	int id= problems[i].getID();	161	int id= problems[i].getID();

Lines 157-176 Link Here

(-)src/org/eclipse/wst/jsdt/internal/ui/text/correction/QuickFixProcessor.java (-33 lines)
157	case IProblem.RedefinedArgument:	157	case IProblem.RedefinedArgument:
158	case IProblem.CodeCannotBeReached:	158	case IProblem.CodeCannotBeReached:
159	case IProblem.InvalidUsageOfTypeParameters:	159	case IProblem.InvalidUsageOfTypeParameters:
160	case IProblem.InvalidUsageOfStaticImports:
161	case IProblem.InvalidUsageOfForeachStatements:	160	case IProblem.InvalidUsageOfForeachStatements:
162	case IProblem.InvalidUsageOfTypeArguments:
163	case IProblem.InvalidUsageOfEnumDeclarations:
164	case IProblem.InvalidUsageOfVarargs:
165	case IProblem.InvalidUsageOfAnnotations:
166	case IProblem.InvalidUsageOfAnnotationDeclarations:
167	case IProblem.FieldMissingDeprecatedAnnotation:
168	case IProblem.OverridingDeprecatedMethod:	161	case IProblem.OverridingDeprecatedMethod:
169	case IProblem.MethodMissingDeprecatedAnnotation:
170	case IProblem.TypeMissingDeprecatedAnnotation:
171	case IProblem.MissingOverrideAnnotation:
172	case IProblem.MethodMustOverride:
173	case IProblem.MethodMustOverrideOrImplement:
174	case IProblem.IsClassPathCorrect:	162	case IProblem.IsClassPathCorrect:
175	case IProblem.MethodReturnsVoid:	163	case IProblem.MethodReturnsVoid:
176	case IProblem.ForbiddenReference:	164	case IProblem.ForbiddenReference:
Lines 178-188 Link Here
178	case IProblem.UnnecessaryNLSTag:	166	case IProblem.UnnecessaryNLSTag:
179	case IProblem.AssignmentHasNoEffect:	167	case IProblem.AssignmentHasNoEffect:
180	case IProblem.UnsafeTypeConversion:	168	case IProblem.UnsafeTypeConversion:
181	case IProblem.UndefinedAnnotationMember:
182	case IProblem.MissingValueForAnnotationMember:
183	case IProblem.FallthroughCase:	169	case IProblem.FallthroughCase:
184	case IProblem.NonGenericType:	170	case IProblem.NonGenericType:
185	case IProblem.UnhandledWarningToken:
186	return true;	171	return true;
187	default:	172	default:
188	// if (JavaModelUtil.is50OrHigher(cu.getJavaScriptProject())) {	173	// if (JavaModelUtil.is50OrHigher(cu.getJavaScriptProject())) {
Lines 483-512 Link Here
483	LocalCorrectionsSubProcessor.getUnreachableCodeProposals(context, problem, proposals);	468	LocalCorrectionsSubProcessor.getUnreachableCodeProposals(context, problem, proposals);
484	break;	469	break;
485	case IProblem.InvalidUsageOfTypeParameters:	470	case IProblem.InvalidUsageOfTypeParameters:
486	case IProblem.InvalidUsageOfStaticImports:
487	case IProblem.InvalidUsageOfForeachStatements:	471	case IProblem.InvalidUsageOfForeachStatements:
488	case IProblem.InvalidUsageOfTypeArguments:
489	case IProblem.InvalidUsageOfEnumDeclarations:
490	case IProblem.InvalidUsageOfVarargs:
491	case IProblem.InvalidUsageOfAnnotations:
492	case IProblem.InvalidUsageOfAnnotationDeclarations:
493	ReorgCorrectionsSubProcessor.getNeed50ComplianceProposals(context, problem, proposals);	472	ReorgCorrectionsSubProcessor.getNeed50ComplianceProposals(context, problem, proposals);
494	break;	473	break;
495	case IProblem.NonGenericType:	474	case IProblem.NonGenericType:
496	TypeParameterMismatchSubProcessor.removeMismatchedParameters(context, problem, proposals);	475	TypeParameterMismatchSubProcessor.removeMismatchedParameters(context, problem, proposals);
497	break;	476	break;
498	// case IProblem.MissingOverrideAnnotation:
499	// ModifierCorrectionSubProcessor.addOverrideAnnotationProposal(context, problem, proposals);
500	// break;
501	case IProblem.MethodMustOverride:
502	case IProblem.MethodMustOverrideOrImplement:
503	ModifierCorrectionSubProcessor.removeOverrideAnnotationProposal(context, problem, proposals);
504	break;
505	case IProblem.FieldMissingDeprecatedAnnotation:
506	case IProblem.MethodMissingDeprecatedAnnotation:
507	case IProblem.TypeMissingDeprecatedAnnotation:
508	// ModifierCorrectionSubProcessor.addDeprecatedAnnotationProposal(context, problem, proposals);
509	break;
510	case IProblem.OverridingDeprecatedMethod:	477	case IProblem.OverridingDeprecatedMethod:
511	ModifierCorrectionSubProcessor.addOverridingDeprecatedMethodProposal(context, problem, proposals);	478	ModifierCorrectionSubProcessor.addOverridingDeprecatedMethodProposal(context, problem, proposals);
512	break;	479	break;

Lines 67-87 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/QualifiedNameReference.java (-28 / +1 lines)
67	if (needValue \|\| complyTo14) {	67	if (needValue \|\| complyTo14) {
68	manageSyntheticAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0, flowInfo);	68	manageSyntheticAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0, flowInfo);
69	}	69	}
70	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
71	ReferenceBinding declaringClass = lastFieldBinding.declaringClass;
72	// check if accessing enum static field in initializer
73	if (declaringClass.isEnum()) {
74	MethodScope methodScope = currentScope.methodScope();
75	SourceTypeBinding sourceType = methodScope.enclosingSourceType();
76	if (lastFieldBinding.isStatic()
77	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
78	&& lastFieldBinding.constant() == Constant.NotAConstant
79	&& !methodScope.isStatic
80	&& methodScope.isInsideInitializerOrConstructor()) {
81	currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(lastFieldBinding, this);
82	}
83	}
84	}
85	// check if final blank field	70	// check if final blank field
86	if (lastFieldBinding.isBlankFinal()	71	if (lastFieldBinding.isBlankFinal()
87	&& this.otherBindings != null // the last field binding is only assigned	72	&& this.otherBindings != null // the last field binding is only assigned
Lines 222-240 Link Here
222	}	207	}
223	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding	208	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
224	FieldBinding fieldBinding = (FieldBinding) this.binding;	209	FieldBinding fieldBinding = (FieldBinding) this.binding;
225	ReferenceBinding declaringClass = fieldBinding.declaringClass;	210
226	// check if accessing enum static field in initializer
227	if (declaringClass.isEnum()) {
228	MethodScope methodScope = currentScope.methodScope();
229	SourceTypeBinding sourceType = methodScope.enclosingSourceType();
230	if (fieldBinding.isStatic()
231	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
232	&& fieldBinding.constant() == Constant.NotAConstant
233	&& !methodScope.isStatic
234	&& methodScope.isInsideInitializerOrConstructor()) {
235	currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
236	}
237	}
238	// check if reading a final blank field	211	// check if reading a final blank field
239	if (fieldBinding.isBlankFinal()	212	if (fieldBinding.isBlankFinal()
240	&& currentScope.allowBlankFinalFieldAssignment(fieldBinding)	213	&& currentScope.allowBlankFinalFieldAssignment(fieldBinding)

Lines 27-36 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/QualifiedAllocationExpression.java (-11 lines)
27	import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemReferenceBinding;	27	import org.eclipse.wst.jsdt.internal.compiler.lookup.ProblemReferenceBinding;
28	import org.eclipse.wst.jsdt.internal.compiler.lookup.RawTypeBinding;	28	import org.eclipse.wst.jsdt.internal.compiler.lookup.RawTypeBinding;
29	import org.eclipse.wst.jsdt.internal.compiler.lookup.ReferenceBinding;	29	import org.eclipse.wst.jsdt.internal.compiler.lookup.ReferenceBinding;
30	import org.eclipse.wst.jsdt.internal.compiler.lookup.TagBits;
31	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;	30	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;
32	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeConstants;	31	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeConstants;
33	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeIds;
34		32
35	/**	33	/**
36	* Variation on allocation, where can optionally be specified any of:	34	* Variation on allocation, where can optionally be specified any of:
Lines 232-240 Link Here
232	TypeReference typeReference = this.typeArguments[i];	230	TypeReference typeReference = this.typeArguments[i];
233	TypeBinding argType = typeReference.resolveType(scope, true /* check bounds*/);	231	TypeBinding argType = typeReference.resolveType(scope, true /* check bounds*/);
234	if (argType == null) {	232	if (argType == null) {
235	if (typeReference instanceof Wildcard) {
236	scope.problemReporter().illegalUsageOfWildcard(typeReference);
237	}
238	return null; // error already reported	233	return null; // error already reported
239	}	234	}
240	this.genericTypeArguments[i] = argType;	235	this.genericTypeArguments[i] = argType;
Lines 333-345 Link Here
333	// insert anonymous type in scope	328	// insert anonymous type in scope
334	scope.addAnonymousType(this.anonymousType, (ReferenceBinding) receiverType);	329	scope.addAnonymousType(this.anonymousType, (ReferenceBinding) receiverType);
335	this.anonymousType.resolve(scope);	330	this.anonymousType.resolve(scope);
336	if (this.superTypeBinding.erasure().id == TypeIds.T_JavaLangEnum) {
337	scope.problemReporter().cannotExtendEnum(this.anonymousType.binding, this.type, this.superTypeBinding);
338	}
339		331
340	if ((receiverType.tagBits & TagBits.HasDirectWildcard) != 0) {
341	scope.problemReporter().superTypeCannotUseWildcard(this.anonymousType.binding, this.type, receiverType);
342	}
343	// find anonymous super constructor	332	// find anonymous super constructor
344	MethodBinding inheritedBinding = scope.getConstructor(this.superTypeBinding, argumentTypes, this);	333	MethodBinding inheritedBinding = scope.getConstructor(this.superTypeBinding, argumentTypes, this);
345	if (!inheritedBinding.isValidBinding()) {	334	if (!inheritedBinding.isValidBinding()) {

Lines 93-107 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/AnnotationMethodDeclaration.java (-10 lines)
93	public void resolveStatements() {	93	public void resolveStatements() {
94		94
95	super.resolveStatements();	95	super.resolveStatements();
96	if (this.arguments != null) {
97	scope.problemReporter().annotationMembersCannotHaveParameters(this);
98	}
99	if (this.typeParameters != null) {
100	scope.problemReporter().annotationMembersCannotHaveTypeParameters(this);
101	}
102	if (this.extendedDimensions != 0) {
103	scope.problemReporter().illegalExtendedDimensions(this);
104	}
105	if (this.binding == null) return;	96	if (this.binding == null) return;
106	TypeBinding returnTypeBinding = this.binding.returnType;	97	TypeBinding returnTypeBinding = this.binding.returnType;
107	if (returnTypeBinding != null) {	98	if (returnTypeBinding != null) {
Lines 126-132 Link Here
126	if (leafReturnType.isEnum() \|\| leafReturnType.isAnnotationType())	117	if (leafReturnType.isEnum() \|\| leafReturnType.isAnnotationType())
127	break checkAnnotationMethodType;	118	break checkAnnotationMethodType;
128	}	119	}
129	scope.problemReporter().invalidAnnotationMemberType(this);
130	}	120	}
131	if (this.defaultValue != null) {	121	if (this.defaultValue != null) {
132	MemberValuePair pair = new MemberValuePair(this.selector, this.sourceStart, this.sourceEnd, this.defaultValue);	122	MemberValuePair pair = new MemberValuePair(this.selector, this.sourceStart, this.sourceEnd, this.defaultValue);

Lines 41-49 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/CaseStatement.java (-8 lines)
41	FlowInfo flowInfo) {	41	FlowInfo flowInfo) {
42		42
43	if (constantExpression != null) {	43	if (constantExpression != null) {
44	if (!this.isEnumConstant && constantExpression.constant == Constant.NotAConstant) {
45	currentScope.problemReporter().caseExpressionMustBeConstant(constantExpression);
46	}
47	this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);	44	this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);
48	}	45	}
49	return flowInfo;	46	return flowInfo;
Lines 106-116 Link Here
106	&& (constantExpression.bits & RestrictiveFlagMASK) == Binding.FIELD) {	103	&& (constantExpression.bits & RestrictiveFlagMASK) == Binding.FIELD) {
107	NameReference reference = (NameReference) constantExpression;	104	NameReference reference = (NameReference) constantExpression;
108	FieldBinding field = reference.fieldBinding();	105	FieldBinding field = reference.fieldBinding();
109	if ((field.modifiers & ClassFileConstants.AccEnum) == 0) {
110	scope.problemReporter().enumSwitchCannotTargetField(reference, field);
111	} else if (reference instanceof QualifiedNameReference) {
112	scope.problemReporter().cannotUseQualifiedEnumConstantInCaseLabel(reference, field);
113	}
114	return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810	106	return IntConstant.fromValue(field.original().id + 1); // (ordinal value + 1) zero should not be returned see bug 141810
115	}	107	}
116	} else {	108	} else {

Lines 13-24 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/MemberValuePair.java (-90 / +1 lines)
13	import org.eclipse.wst.jsdt.core.ast.IASTNode;	13	import org.eclipse.wst.jsdt.core.ast.IASTNode;
14	import org.eclipse.wst.jsdt.core.ast.IMemberValuePair;	14	import org.eclipse.wst.jsdt.core.ast.IMemberValuePair;
15	import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;	15	import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
16	import org.eclipse.wst.jsdt.internal.compiler.impl.Constant;
17	import org.eclipse.wst.jsdt.internal.compiler.lookup.BaseTypeBinding;	16	import org.eclipse.wst.jsdt.internal.compiler.lookup.BaseTypeBinding;
18	import org.eclipse.wst.jsdt.internal.compiler.lookup.Binding;
19	import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;	17	import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;
20	import org.eclipse.wst.jsdt.internal.compiler.lookup.ElementValuePair;	18	import org.eclipse.wst.jsdt.internal.compiler.lookup.ElementValuePair;
21	import org.eclipse.wst.jsdt.internal.compiler.lookup.FieldBinding;
22	import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodBinding;	19	import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodBinding;
23	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;	20	import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeBinding;
24		21
Lines 79-85 Link Here
79	ArrayInitializer initializer = (ArrayInitializer) this.value;	76	ArrayInitializer initializer = (ArrayInitializer) this.value;
80	valueType = initializer.resolveTypeExpecting(scope, this.binding.returnType);	77	valueType = initializer.resolveTypeExpecting(scope, this.binding.returnType);
81	} else if (this.value instanceof ArrayAllocationExpression) {	78	} else if (this.value instanceof ArrayAllocationExpression) {
82	scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
83	this.value.resolveType(scope);	79	this.value.resolveType(scope);
84	valueType = null; // no need to pursue	80	valueType = null; // no need to pursue
85	} else {	81	} else {
Lines 100-108 Link Here
100	\|\| (leafType.isBaseType() && BaseTypeBinding.isWidening(leafType.id, valueType.id)))	96	\|\| (leafType.isBaseType() && BaseTypeBinding.isWidening(leafType.id, valueType.id)))
101	\|\| valueType.isCompatibleWith(leafType))) {	97	\|\| valueType.isCompatibleWith(leafType))) {
102		98
103	if (leafType.isAnnotationType() && !valueType.isAnnotationType()) {	99	if (!leafType.isAnnotationType() \|\| valueType.isAnnotationType()) {
104	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
105	} else {
106	scope.problemReporter().typeMismatchError(valueType, requiredType, this.value);	100	scope.problemReporter().typeMismatchError(valueType, requiredType, this.value);
107	}	101	}
108	return; // may allow to proceed to find more errors at once	102	return; // may allow to proceed to find more errors at once
Lines 124-220 Link Here
124	case T_double :	118	case T_double :
125	case T_boolean :	119	case T_boolean :
126	case T_JavaLangString :	120	case T_JavaLangString :
127	if (this.value instanceof ArrayInitializer) {
128	ArrayInitializer initializer = (ArrayInitializer) this.value;
129	final Expression[] expressions = initializer.expressions;
130	if (expressions != null) {
131	for (int i =0, max = expressions.length; i < max; i++) {
132	if (expressions[i].constant == Constant.NotAConstant) {
133	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, expressions[i], false);
134	}
135	}
136	}
137	} else if (this.value.constant == Constant.NotAConstant) {
138	if (valueType.isArrayType()) {
139	scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
140	} else {
141	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, false);
142	}
143	}
144	break checkAnnotationMethodType;	121	break checkAnnotationMethodType;
145	case T_JavaLangClass :	122	case T_JavaLangClass :
146	if (this.value instanceof ArrayInitializer) {
147	ArrayInitializer initializer = (ArrayInitializer) this.value;
148	final Expression[] expressions = initializer.expressions;
149	if (expressions != null) {
150	for (int i =0, max = expressions.length; i < max; i++) {
151	Expression currentExpression = expressions[i];
152	if (!(currentExpression instanceof ClassLiteralAccess)) {
153	scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, currentExpression);
154	}
155	}
156	}
157	} else if (!(this.value instanceof ClassLiteralAccess)) {
158	scope.problemReporter().annotationValueMustBeClassLiteral(this.binding.declaringClass, this.name, this.value);
159	}
160	break checkAnnotationMethodType;	123	break checkAnnotationMethodType;
161	}	124	}
162	if (leafType.isEnum()) {	125	if (leafType.isEnum()) {
163	if (this.value instanceof NullLiteral) {
164	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
165	} else if (this.value instanceof ArrayInitializer) {
166	ArrayInitializer initializer = (ArrayInitializer) this.value;
167	final Expression[] expressions = initializer.expressions;
168	if (expressions != null) {
169	for (int i =0, max = expressions.length; i < max; i++) {
170	Expression currentExpression = expressions[i];
171	if (currentExpression instanceof NullLiteral) {
172	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
173	} else if (currentExpression instanceof NameReference) {
174	NameReference nameReference = (NameReference) currentExpression;
175	final Binding nameReferenceBinding = nameReference.binding;
176	if (nameReferenceBinding.kind() == Binding.FIELD) {
177	FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
178	if (!fieldBinding.declaringClass.isEnum()) {
179	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, currentExpression, true);
180	}
181	}
182	}
183	}
184	}
185	} else if (this.value instanceof NameReference) {
186	NameReference nameReference = (NameReference) this.value;
187	final Binding nameReferenceBinding = nameReference.binding;
188	if (nameReferenceBinding.kind() == Binding.FIELD) {
189	FieldBinding fieldBinding = (FieldBinding) nameReferenceBinding;
190	if (!fieldBinding.declaringClass.isEnum()) {
191	if (!fieldBinding.type.isArrayType()) {
192	scope.problemReporter().annotationValueMustBeConstant(this.binding.declaringClass, this.name, this.value, true);
193	} else {
194	scope.problemReporter().annotationValueMustBeArrayInitializer(this.binding.declaringClass, this.name, this.value);
195	}
196	}
197	}
198	}
199	break checkAnnotationMethodType;	126	break checkAnnotationMethodType;
200	}	127	}
201	if (leafType.isAnnotationType()) {	128	if (leafType.isAnnotationType()) {
202	if (!valueType.leafComponentType().isAnnotationType()) { // check annotation type and also reject null literal
203	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
204	} else if (this.value instanceof ArrayInitializer) {
205	ArrayInitializer initializer = (ArrayInitializer) this.value;
206	final Expression[] expressions = initializer.expressions;
207	if (expressions != null) {
208	for (int i =0, max = expressions.length; i < max; i++) {
209	Expression currentExpression = expressions[i];
210	if (currentExpression instanceof NullLiteral \|\| !(currentExpression instanceof Annotation)) {
211	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, currentExpression, leafType);
212	}
213	}
214	}
215	} else if (!(this.value instanceof Annotation)) {
216	scope.problemReporter().annotationValueMustBeAnnotation(this.binding.declaringClass, this.name, this.value, leafType);
217	}
218	break checkAnnotationMethodType;	129	break checkAnnotationMethodType;
219	}	130	}
220	}	131	}

Lines 15-21 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/MethodDeclaration.java (-26 lines)
15	import org.eclipse.wst.jsdt.core.ast.IFunctionDeclaration;	15	import org.eclipse.wst.jsdt.core.ast.IFunctionDeclaration;
16	import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;	16	import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
17	import org.eclipse.wst.jsdt.internal.compiler.CompilationResult;	17	import org.eclipse.wst.jsdt.internal.compiler.CompilationResult;
18	import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
19	import org.eclipse.wst.jsdt.internal.compiler.flow.ExceptionHandlingFlowContext;	18	import org.eclipse.wst.jsdt.internal.compiler.flow.ExceptionHandlingFlowContext;
20	import org.eclipse.wst.jsdt.internal.compiler.flow.FlowContext;	19	import org.eclipse.wst.jsdt.internal.compiler.flow.FlowContext;
21	import org.eclipse.wst.jsdt.internal.compiler.flow.FlowInfo;	20	import org.eclipse.wst.jsdt.internal.compiler.flow.FlowInfo;
Lines 155-186 Link Here
155	}	154	}
156	}	155	}
157		156
158	// check @Override annotation
159	final CompilerOptions compilerOptions = this.scope.compilerOptions();	157	final CompilerOptions compilerOptions = this.scope.compilerOptions();
160	checkOverride: {
161	if (this.binding == null) break checkOverride;
162	long sourceLevel = compilerOptions.sourceLevel;
163	if (sourceLevel < ClassFileConstants.JDK1_5) break checkOverride;
164	int bindingModifiers = this.binding.modifiers;
165	boolean hasOverrideAnnotation = (this.binding.tagBits & TagBits.AnnotationOverride) != 0;
166	boolean isInterfaceMethod = this.binding.declaringClass.isInterface();
167	if (hasOverrideAnnotation) {
168	// no static method is considered overriding
169	if (!isInterfaceMethod && (bindingModifiers & (ClassFileConstants.AccStatic\|ExtraCompilerModifiers.AccOverriding)) == ExtraCompilerModifiers.AccOverriding)
170	break checkOverride;
171	// in 1.5, strictly for overriding superclass method
172	// in 1.6 and above, also tolerate implementing interface method
173	if (sourceLevel >= ClassFileConstants.JDK1_6
174	&& ((bindingModifiers & (ClassFileConstants.AccStatic\|ExtraCompilerModifiers.AccImplementing)) == ExtraCompilerModifiers.AccImplementing))
175	break checkOverride;
176	// claims to override, and doesn't actually do so
177	this.scope.problemReporter().methodMustOverride(this);
178	} else if (!isInterfaceMethod
179	&& (bindingModifiers & (ClassFileConstants.AccStatic\|ExtraCompilerModifiers.AccOverriding)) == ExtraCompilerModifiers.AccOverriding) {
180	// actually overrides, but did not claim to do so
181	this.scope.problemReporter().missingOverrideAnnotation(this);
182	}
183	}
184		158
185	// by grammatical construction, interface methods are always abstract	159	// by grammatical construction, interface methods are always abstract
186	// switch (TypeDeclaration.kind(this.scope.referenceType().modifiers)) {	160	// switch (TypeDeclaration.kind(this.scope.referenceType().modifiers)) {

Lines 14-20 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ast/Annotation.java (-15 / +1 lines)
14	import org.eclipse.wst.jsdt.core.ast.IAnnotation;	14	import org.eclipse.wst.jsdt.core.ast.IAnnotation;
15	import org.eclipse.wst.jsdt.core.compiler.CharOperation;	15	import org.eclipse.wst.jsdt.core.compiler.CharOperation;
16	import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;	16	import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
17	import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
18	import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;	17	import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;
19	import org.eclipse.wst.jsdt.internal.compiler.impl.Constant;	18	import org.eclipse.wst.jsdt.internal.compiler.impl.Constant;
20	import org.eclipse.wst.jsdt.internal.compiler.lookup.AnnotationBinding;	19	import org.eclipse.wst.jsdt.internal.compiler.lookup.AnnotationBinding;
Lines 143-151 Link Here
143	FieldBinding field = ((Reference) initExpr).fieldBinding();	142	FieldBinding field = ((Reference) initExpr).fieldBinding();
144	if (field != null && field.declaringClass.id == T_JavaLangAnnotationElementType) {	143	if (field != null && field.declaringClass.id == T_JavaLangAnnotationElementType) {
145	long element = getTargetElementType(field.name);	144	long element = getTargetElementType(field.name);
146	if ((tagBits & element) != 0) {	145	if ((tagBits & element) == 0) {
147	scope.problemReporter().duplicateTargetInTargetAnnotation(annotationType, (NameReference)initExpr);
148	} else {
149	tagBits \|= element;	146	tagBits \|= element;
150	}	147	}
151	}	148	}
Lines 210-217 Link Here
210	if (irritant != 0) {	207	if (irritant != 0) {
211	suppressWarningIrritants \|= irritant;	208	suppressWarningIrritants \|= irritant;
212	if (~suppressWarningIrritants == 0) break pairLoop;	209	if (~suppressWarningIrritants == 0) break pairLoop;
213	} else {
214	scope.problemReporter().unhandledWarningToken(inits[j]);
215	}	210	}
216	}	211	}
217	}	212	}
Lines 223-230 Link Here
223	if (irritant != 0) {	218	if (irritant != 0) {
224	suppressWarningIrritants \|= irritant;	219	suppressWarningIrritants \|= irritant;
225	if (~suppressWarningIrritants == 0) break pairLoop;	220	if (~suppressWarningIrritants == 0) break pairLoop;
226	} else {
227	scope.problemReporter().unhandledWarningToken(value);
228	}	221	}
229	}	222	}
230	}	223	}
Lines 290-315 Link Here
290	if (otherPair == null) continue;	283	if (otherPair == null) continue;
291	if (CharOperation.equals(otherPair.name, selector)) {	284	if (CharOperation.equals(otherPair.name, selector)) {
292	foundDuplicate = true;	285	foundDuplicate = true;
293	scope.problemReporter().duplicateAnnotationValue(annotationType, otherPair);
294	otherPair.binding = method;	286	otherPair.binding = method;
295	otherPair.resolveTypeExpecting(scope, method.returnType);	287	otherPair.resolveTypeExpecting(scope, method.returnType);
296	pairs[k] = null;	288	pairs[k] = null;
297	}	289	}
298	}	290	}
299	if (foundDuplicate) {	291	if (foundDuplicate) {
300	scope.problemReporter().duplicateAnnotationValue(annotationType, pair);
301	continue nextMember;	292	continue nextMember;
302	}	293	}
303	}	294	}
304	}	295	}
305	if (!foundValue && (method.modifiers & ClassFileConstants.AccAnnotationDefault) == 0) {
306	scope.problemReporter().missingValueForAnnotationMember(this, selector);
307	}
308	}	296	}
309	// check unused pairs	297	// check unused pairs
310	for (int i = 0; i < pairsLength; i++) {	298	for (int i = 0; i < pairsLength; i++) {
311	if (pairs[i] != null) {	299	if (pairs[i] != null) {
312	scope.problemReporter().undefinedAnnotationValue(annotationType, pairs[i]);
313	pairs[i].resolveTypeExpecting(scope, null); // resilient	300	pairs[i].resolveTypeExpecting(scope, null); // resilient
314	}	301	}
315	}	302	}
Lines 408-414 Link Here
408	break checkTargetCompatibility;	395	break checkTargetCompatibility;
409	break;	396	break;
410	}	397	}
411	scope.problemReporter().disallowedTargetForAnnotation(this);
412	}	398	}
413	}	399	}
414	return this.resolvedType;	400	return this.resolvedType;

Lines 1776-1785 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/batch/Main.java (-25 lines)
1776	this.options.put(	1776	this.options.put(
1777	CompilerOptions.OPTION_SuppressWarnings,	1777	CompilerOptions.OPTION_SuppressWarnings,
1778	isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);	1778	isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);
1779	} else if (token.equals("warningToken")) {//$NON-NLS-1$
1780	this.options.put(
1781	CompilerOptions.OPTION_ReportUnhandledWarningToken,
1782	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1783	} else if (token.equals("unnecessaryElse")) {//$NON-NLS-1$	1779	} else if (token.equals("unnecessaryElse")) {//$NON-NLS-1$
1784	this.options.put(	1780	this.options.put(
1785	CompilerOptions.OPTION_ReportUnnecessaryElse,	1781	CompilerOptions.OPTION_ReportUnnecessaryElse,
Lines 1880-1889 Link Here
1880	this.options.put(	1876	this.options.put(
1881	CompilerOptions.OPTION_ReportTypeParameterHiding,	1877	CompilerOptions.OPTION_ReportTypeParameterHiding,
1882	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);	1878	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1883	} else if (token.equals("varargsCast")) { //$NON-NLS-1$
1884	this.options.put(
1885	CompilerOptions.OPTION_ReportVarargsArgumentNeedCast,
1886	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1887	} else if (token.equals("null")) { //$NON-NLS-1$	1879	} else if (token.equals("null")) { //$NON-NLS-1$
1888	if (isEnabling) {	1880	if (isEnabling) {
1889	this.options.put(CompilerOptions.OPTION_ReportNullReference,	1881	this.options.put(CompilerOptions.OPTION_ReportNullReference,
Lines 1916-1938 Link Here
1916	this.options.put(	1908	this.options.put(
1917	CompilerOptions.OPTION_ReportAutoboxing,	1909	CompilerOptions.OPTION_ReportAutoboxing,
1918	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);	1910	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1919	} else if (token.equals("over-ann")) { //$NON-NLS-1$
1920	this.options.put(
1921	CompilerOptions.OPTION_ReportMissingOverrideAnnotation,
1922	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1923	} else if (token.equals("dep-ann")) { //$NON-NLS-1$
1924	this.options.put(
1925	CompilerOptions.OPTION_ReportMissingDeprecatedAnnotation,
1926	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1927	} else if (token.equals("intfAnnotation")) { //$NON-NLS-1$
1928	this.options.put(
1929	CompilerOptions.OPTION_ReportAnnotationSuperInterface,
1930	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1931	} else if (token.equals("enumSwitch") //$NON-NLS-1$
1932	\|\| token.equals("incomplete-switch")) { //$NON-NLS-1$
1933	this.options.put(
1934	CompilerOptions.OPTION_ReportIncompleteEnumSwitch,
1935	isEnabling ? CompilerOptions.WARNING : CompilerOptions.IGNORE);
1936	} else if (token.equals("hiding")) { //$NON-NLS-1$	1911	} else if (token.equals("hiding")) { //$NON-NLS-1$
1937	this.options.put(	1912	this.options.put(
1938	CompilerOptions.OPTION_ReportHiddenCatchBlock,	1913	CompilerOptions.OPTION_ReportHiddenCatchBlock,

Lines 3366-3381 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/complete/CompletionParser.java (-10 lines)
3366	}	3366	}
3367	}	3367	}
3368	}	3368	}
3369	protected void consumeOnlyTypeArguments() {
3370	super.consumeOnlyTypeArguments();
3371	popElement(K_BINARY_OPERATOR);
3372	if(topKnownElementKind(COMPLETION_OR_ASSIST_PARSER) == K_PARAMETERIZED_METHOD_INVOCATION) {
3373	popElement(K_PARAMETERIZED_METHOD_INVOCATION);
3374	pushOnElementStack(K_PARAMETERIZED_METHOD_INVOCATION, INSIDE_NAME);
3375	} else {
3376	popElement(K_PARAMETERIZED_ALLOCATION);
3377	}
3378	}
3379	protected void consumeOnlyTypeArgumentsForCastExpression() {	3369	protected void consumeOnlyTypeArgumentsForCastExpression() {
3380	super.consumeOnlyTypeArgumentsForCastExpression();	3370	super.consumeOnlyTypeArgumentsForCastExpression();
3381	pushOnElementStack(K_PARAMETERIZED_CAST);	3371	pushOnElementStack(K_PARAMETERIZED_CAST);

Lines 1438-1452 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/SourceTypeBinding.java (-17 / +7 lines)
1438	if (methodDecl == null) {	1438	if (methodDecl == null) {
1439	methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost & may still be null if method is special	1439	methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost & may still be null if method is special
1440	if (methodDecl != null && methodDecl.binding != null) { // ensure its a valid user defined method	1440	if (methodDecl != null && methodDecl.binding != null) { // ensure its a valid user defined method
1441	if (isEnumSpecialMethod) {	1441	this.scope
1442	this.scope.problemReporter()	1442	.problemReporter()
1443	.duplicateEnumSpecialMethod(this,	1443	.duplicateMethodInType(this, methodDecl);
1444	methodDecl);	1444
1445	} else {
1446	this.scope
1447	.problemReporter()
1448	.duplicateMethodInType(this, methodDecl);
1449	}
1450	methodDecl.binding = null;	1445	methodDecl.binding = null;
1451	// do not alter original method array until resolution is over, due to reentrance (143259)	1446	// do not alter original method array until resolution is over, due to reentrance (143259)
1452	if (resolvedMethods == this.methods) {	1447	if (resolvedMethods == this.methods) {
Lines 1464-1477 Link Here
1464	AbstractMethodDeclaration method2Decl = method2	1459	AbstractMethodDeclaration method2Decl = method2
1465	.sourceMethod();	1460	.sourceMethod();
1466	if (method2Decl != null && method2Decl.binding != null) { // ensure its a valid user defined method	1461	if (method2Decl != null && method2Decl.binding != null) { // ensure its a valid user defined method
1467	if (isEnumSpecialMethod) {	1462	this.scope.problemReporter().duplicateMethodInType(
1468	this.scope.problemReporter()	1463	this, method2Decl);
1469	.duplicateEnumSpecialMethod(this,	1464
1470	method2Decl);
1471	} else {
1472	this.scope.problemReporter().duplicateMethodInType(
1473	this, method2Decl);
1474	}
1475	method2Decl.binding = null;	1465	method2Decl.binding = null;
1476	// do not alter original method array until resolution is over, due to reentrance (143259)	1466	// do not alter original method array until resolution is over, due to reentrance (143259)
1477	if (resolvedMethods == this.methods) {	1467	if (resolvedMethods == this.methods) {

Lines 443-463 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/Scope.java (-11 lines)
443	if (method == null) return null; // incompatible	443	if (method == null) return null; // incompatible
444	if (!method.isValidBinding()) return method; // bound check issue is taking precedence	444	if (!method.isValidBinding()) return method; // bound check issue is taking precedence
445	parameters = method.parameters; // reacquire them after type inference has performed	445	parameters = method.parameters; // reacquire them after type inference has performed
446	} else if (genericTypeArguments != null) {
447	if (method instanceof ParameterizedGenericMethodBinding) {
448	if (!((ParameterizedGenericMethodBinding) method).wasInferred) {
449	// attempt to invoke generic method of raw type with type hints <String>foo()
450	return new ProblemMethodBinding(method, method.selector, genericTypeArguments, ProblemReasons.TypeArgumentsForRawGenericMethod);
451	}
452	} else {
453	return new ProblemMethodBinding(method, method.selector, genericTypeArguments, ProblemReasons.TypeParameterArityMismatch);
454	}
455	}	446	}
456		447
457	if (parameterCompatibilityLevel(method, arguments) > NOT_COMPATIBLE)	448	if (parameterCompatibilityLevel(method, arguments) > NOT_COMPATIBLE)
458	return method;	449	return method;
459	if (genericTypeArguments != null)
460	return new ProblemMethodBinding(method, method.selector, arguments, ProblemReasons.ParameterizedMethodTypeMismatch);
461	return null; // incompatible	450	return null; // incompatible
462	}	451	}
463		452

Lines 16-22 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/ReferenceBinding.java (-11 / +1 lines)
16	import org.eclipse.wst.jsdt.core.JavaScriptCore;	16	import org.eclipse.wst.jsdt.core.JavaScriptCore;
17	import org.eclipse.wst.jsdt.core.compiler.CharOperation;	17	import org.eclipse.wst.jsdt.core.compiler.CharOperation;
18	import org.eclipse.wst.jsdt.core.infer.InferredType;	18	import org.eclipse.wst.jsdt.core.infer.InferredType;
19	import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
20	import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;	19	import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
21	import org.eclipse.wst.jsdt.internal.compiler.env.IDependent;	20	import org.eclipse.wst.jsdt.internal.compiler.env.IDependent;
22	import org.eclipse.wst.jsdt.internal.compiler.util.SimpleLookupTable;	21	import org.eclipse.wst.jsdt.internal.compiler.util.SimpleLookupTable;
Lines 569-584 Link Here
569	boolean inCycle = false; // check each method before failing	568	boolean inCycle = false; // check each method before failing
570	for (int i = 0, l = currentMethods.length; i < l; i++) {	569	for (int i = 0, l = currentMethods.length; i < l; i++) {
571	TypeBinding returnType = currentMethods[i].returnType.leafComponentType();	570	TypeBinding returnType = currentMethods[i].returnType.leafComponentType();
572	if (this == returnType) {	571	if (returnType.isAnnotationType() && ((ReferenceBinding) returnType).detectAnnotationCycle()) {
573	if (this instanceof SourceTypeBinding) {
574	MethodDeclaration decl = (MethodDeclaration) currentMethods[i].sourceMethod();
575	((SourceTypeBinding) this).scope.problemReporter().annotationCircularity(this, this, decl != null ? decl.returnType : null);
576	}
577	} else if (returnType.isAnnotationType() && ((ReferenceBinding) returnType).detectAnnotationCycle()) {
578	if (this instanceof SourceTypeBinding) {
579	MethodDeclaration decl = (MethodDeclaration) currentMethods[i].sourceMethod();
580	((SourceTypeBinding) this).scope.problemReporter().annotationCircularity(this, returnType, decl != null ? decl.returnType : null);
581	}
582	inCycle = true;	572	inCycle = true;
583	}	573	}
584	}	574	}

Lines 353-359 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/ClassScope.java (-35 / +3 lines)
353	sourceType.typeVariables = Binding.NO_TYPE_VARIABLES; // safety	353	sourceType.typeVariables = Binding.NO_TYPE_VARIABLES; // safety
354		354
355	if (sourceType.id == T_JavaLangObject) { // handle the case of redefining java.lang.Object up front	355	if (sourceType.id == T_JavaLangObject) { // handle the case of redefining java.lang.Object up front
356	problemReporter().objectCannotBeGeneric(referenceContext);
357	return;	356	return;
358	}	357	}
359	sourceType.typeVariables = createTypeVariables(typeParameters, sourceType);	358	sourceType.typeVariables = createTypeVariables(typeParameters, sourceType);
Lines 442-450 Link Here
442	final int UNEXPECTED_MODIFIERS =	441	final int UNEXPECTED_MODIFIERS =
443	~(ClassFileConstants.AccPublic \| ClassFileConstants.AccPrivate \| ClassFileConstants.AccProtected \| ClassFileConstants.AccStatic \| ClassFileConstants.AccAbstract \| ClassFileConstants.AccInterface \| ClassFileConstants.AccStrictfp \| ClassFileConstants.AccAnnotation);	442	~(ClassFileConstants.AccPublic \| ClassFileConstants.AccPrivate \| ClassFileConstants.AccProtected \| ClassFileConstants.AccStatic \| ClassFileConstants.AccAbstract \| ClassFileConstants.AccInterface \| ClassFileConstants.AccStrictfp \| ClassFileConstants.AccAnnotation);
444	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {	443	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
445	if ((realModifiers & ClassFileConstants.AccAnnotation) != 0)	444	if ((realModifiers & ClassFileConstants.AccAnnotation) == 0)
446	problemReporter().illegalModifierForAnnotationMemberType(sourceType);
447	else
448	problemReporter().illegalModifierForMemberInterface(sourceType);	445	problemReporter().illegalModifierForMemberInterface(sourceType);
449	}	446	}
450	/*	447	/*
Lines 456-483 Link Here
456	} else {	453	} else {
457	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic \| ClassFileConstants.AccAbstract \| ClassFileConstants.AccInterface \| ClassFileConstants.AccStrictfp \| ClassFileConstants.AccAnnotation);	454	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic \| ClassFileConstants.AccAbstract \| ClassFileConstants.AccInterface \| ClassFileConstants.AccStrictfp \| ClassFileConstants.AccAnnotation);
458	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {	455	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
459	if ((realModifiers & ClassFileConstants.AccAnnotation) != 0)	456	if ((realModifiers & ClassFileConstants.AccAnnotation) == 0)
460	problemReporter().illegalModifierForAnnotationType(sourceType);
461	else
462	problemReporter().illegalModifierForInterface(sourceType);	457	problemReporter().illegalModifierForInterface(sourceType);
463	}	458	}
464	}	459	}
465	modifiers \|= ClassFileConstants.AccAbstract;	460	modifiers \|= ClassFileConstants.AccAbstract;
466	} else if ((realModifiers & ClassFileConstants.AccEnum) != 0) {	461	} else if ((realModifiers & ClassFileConstants.AccEnum) != 0) {
467	// detect abnormal cases for enums	462	// detect abnormal cases for enums
468	if (isMemberType) { // includes member types defined inside local types
469	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic \| ClassFileConstants.AccPrivate \| ClassFileConstants.AccProtected \| ClassFileConstants.AccStatic \| ClassFileConstants.AccStrictfp \| ClassFileConstants.AccEnum);
470	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
471	problemReporter().illegalModifierForMemberEnum(sourceType);
472	} else if (sourceType.isLocalType()) { // each enum constant is an anonymous local type
473	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccStrictfp \| ClassFileConstants.AccFinal \| ClassFileConstants.AccEnum); // add final since implicitly set for anonymous type
474	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
475	problemReporter().illegalModifierForLocalEnum(sourceType);
476	} else {
477	final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic \| ClassFileConstants.AccStrictfp \| ClassFileConstants.AccEnum);
478	if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
479	problemReporter().illegalModifierForEnum(sourceType);
480	}
481	if (!sourceType.isAnonymousType()) {	463	if (!sourceType.isAnonymousType()) {
482	checkAbstractEnum: {	464	checkAbstractEnum: {
483	// does define abstract methods ?	465	// does define abstract methods ?
Lines 615-632 Link Here
615		597
616	// and then check that they are the only ones	598	// and then check that they are the only ones
617	if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != IMPLICIT_MODIFIERS) {	599	if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != IMPLICIT_MODIFIERS) {
618	if ((declaringClass.modifiers & ClassFileConstants.AccAnnotation) != 0)	600	if ((declaringClass.modifiers & ClassFileConstants.AccAnnotation) == 0)
619	problemReporter().illegalModifierForAnnotationField(fieldDecl);
620	else
621	problemReporter().illegalModifierForInterfaceField(fieldDecl);	601	problemReporter().illegalModifierForInterfaceField(fieldDecl);
622	}	602	}
623	fieldBinding.modifiers = modifiers;	603	fieldBinding.modifiers = modifiers;
624	return;	604	return;
625	} else if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {	605	} else if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
626	// check that they are not modifiers in source
627	if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != 0)
628	problemReporter().illegalModifierForEnumConstant(declaringClass, fieldDecl);
629
630	// set the modifiers	606	// set the modifiers
631	final int IMPLICIT_MODIFIERS = ClassFileConstants.AccPublic \| ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal \| ClassFileConstants.AccEnum;	607	final int IMPLICIT_MODIFIERS = ClassFileConstants.AccPublic \| ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal \| ClassFileConstants.AccEnum;
632	fieldBinding.modifiers\|= IMPLICIT_MODIFIERS;	608	fieldBinding.modifiers\|= IMPLICIT_MODIFIERS;
Lines 852-861 Link Here
852	problemReporter().superclassMustBeAClass(sourceType, superclassRef, superclass);	828	problemReporter().superclassMustBeAClass(sourceType, superclassRef, superclass);
853	} else if (superclass.isFinal()) {	829	} else if (superclass.isFinal()) {
854	problemReporter().classExtendFinalClass(sourceType, superclassRef, superclass);	830	problemReporter().classExtendFinalClass(sourceType, superclassRef, superclass);
855	} else if ((superclass.tagBits & TagBits.HasDirectWildcard) != 0) {
856	problemReporter().superTypeCannotUseWildcard(sourceType, superclassRef, superclass);
857	} else if (superclass.erasure().id == T_JavaLangEnum) {
858	problemReporter().cannotExtendEnum(sourceType, superclassRef, superclass);
859	} else {	831	} else {
860	// only want to reach here when no errors are reported	832	// only want to reach here when no errors are reported
861	sourceType.superclass = superclass;	833	sourceType.superclass = superclass;
Lines 910-919 Link Here
910	// check argument type compatibility	882	// check argument type compatibility
911	ParameterizedTypeBinding superType = environment().createParameterizedType(rootEnumType, new TypeBinding[]{ environment().convertToRawType(sourceType) } , null);	883	ParameterizedTypeBinding superType = environment().createParameterizedType(rootEnumType, new TypeBinding[]{ environment().convertToRawType(sourceType) } , null);
912	sourceType.superclass = superType;	884	sourceType.superclass = superType;
913	// bound check (in case of bogus definition of Enum type)
914	if (refTypeVariables[0].boundCheck(superType, sourceType) != TypeConstants.OK) {
915	problemReporter().typeMismatchError(rootEnumType, refTypeVariables[0], sourceType, null);
916	}
917	return !foundCycle;	885	return !foundCycle;
918	}	886	}
919		887

Lines 102-109 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/MethodVerifier15.java (-5 lines)
102		102
103	for (int i = 0, l = abstractMethods.length; i < l; i++) {	103	for (int i = 0, l = abstractMethods.length; i < l; i++) {
104	MethodBinding abstractMethod = abstractMethods[i];	104	MethodBinding abstractMethod = abstractMethods[i];
105	if (concreteMethod.isVarargs() != abstractMethod.isVarargs())
106	problemReporter().varargsConflict(concreteMethod, abstractMethod, this.type);
107		105
108	// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod	106	// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod
109	MethodBinding originalInherited = abstractMethod.original();	107	MethodBinding originalInherited = abstractMethod.original();
Lines 127-135 Link Here
127	}	125	}
128	}	126	}
129	void checkForBridgeMethod(MethodBinding currentMethod, MethodBinding inheritedMethod, MethodBinding[] allInheritedMethods) {	127	void checkForBridgeMethod(MethodBinding currentMethod, MethodBinding inheritedMethod, MethodBinding[] allInheritedMethods) {
130	if (currentMethod.isVarargs() != inheritedMethod.isVarargs())
131	problemReporter(currentMethod).varargsConflict(currentMethod, inheritedMethod, this.type);
132
133	// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod	128	// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod
134	MethodBinding originalInherited = inheritedMethod.original();	129	MethodBinding originalInherited = inheritedMethod.original();
135	if (originalInherited.returnType != currentMethod.returnType) {	130	if (originalInherited.returnType != currentMethod.returnType) {

Lines 40-49 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java (-12 lines)
40	computeSubstitutes: {	40	computeSubstitutes: {
41	if (substitutes != null) {	41	if (substitutes != null) {
42	// explicit type arguments got supplied	42	// explicit type arguments got supplied
43	if (substitutes.length != typeVariables.length) {
44	// incompatible due to wrong arity
45	return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, ProblemReasons.TypeParameterArityMismatch);
46	}
47	methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);	43	methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);
48	break computeSubstitutes;	44	break computeSubstitutes;
49	}	45	}
Lines 87-100 Link Here
87	TypeVariableBinding typeVariable = typeVariables[i];	83	TypeVariableBinding typeVariable = typeVariables[i];
88	TypeBinding substitute = methodSubstitute.typeArguments[i];	84	TypeBinding substitute = methodSubstitute.typeArguments[i];
89	switch (typeVariable.boundCheck(methodSubstitute, substitute)) {	85	switch (typeVariable.boundCheck(methodSubstitute, substitute)) {
90	case TypeConstants.MISMATCH :
91	// incompatible due to bound check
92	int argLength = arguments.length;
93	TypeBinding[] augmentedArguments = new TypeBinding[argLength + 2]; // append offending substitute and typeVariable
94	System.arraycopy(arguments, 0, augmentedArguments, 0, argLength);
95	augmentedArguments[argLength] = substitute;
96	augmentedArguments[argLength+1] = typeVariable;
97	return new ProblemMethodBinding(methodSubstitute, originalMethod.selector, augmentedArguments, ProblemReasons.ParameterBoundMismatch);
98	case TypeConstants.UNCHECKED :	86	case TypeConstants.UNCHECKED :
99	// tolerate unchecked bounds	87	// tolerate unchecked bounds
100	methodSubstitute.isUnchecked = true;	88	methodSubstitute.isUnchecked = true;

Lines 89-95 Link Here

(-)src/org/eclipse/wst/jsdt/core/compiler/IProblem.java (-178 lines)
89	* AnnotationValueMustBeArrayInitializer	89	* AnnotationValueMustBeArrayInitializer
90	* InvalidEncoding	90	* InvalidEncoding
91	* CannotReadSource	91	* CannotReadSource
92	* EnumStaticFieldInInInitializerContext
93	* ExternalProblemNotFixable	92	* ExternalProblemNotFixable
94	* ExternalProblemFixable	93	* ExternalProblemFixable
95	* IBM Corporation - added the following constants	94	* IBM Corporation - added the following constants
Lines 399-405 Link Here
399	int NoImplicitStringConversionForCharArrayExpression = Internal + 151;	398	int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
400	// constant expressions	399	// constant expressions
401	int StringConstantIsExceedingUtf8Limit = Internal + 152;	400	int StringConstantIsExceedingUtf8Limit = Internal + 152;
402	int NonConstantExpression = Internal + 153;
403	int NumericValueOutOfRange = Internal + 154;	401	int NumericValueOutOfRange = Internal + 154;
404	// cast expressions	402	// cast expressions
405	int IllegalCast = TypeRelated + 156;	403	int IllegalCast = TypeRelated + 156;
Lines 555-582 Link Here
555	int ObjectCannotHaveSuperTypes = Internal + 329;	553	int ObjectCannotHaveSuperTypes = Internal + 329;
556	int ObjectMustBeClass = Internal + 330;	554	int ObjectMustBeClass = Internal + 330;
557		555
558	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
559	int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
560	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
561	int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
562	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
563	int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
564	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
565	int SuperclassInternalNameProvided = TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
566	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
567	int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
568
569	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
570	int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
571	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
572	int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
573	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
574	int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
575	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
576	int InterfaceInternalNameProvided = TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
577	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
578	int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
579
580	// field related problems	556	// field related problems
581	int DuplicateField = FieldRelated + 340;	557	int DuplicateField = FieldRelated + 340;
582	int DuplicateModifierForField = FieldRelated + 341;	558	int DuplicateModifierForField = FieldRelated + 341;
Lines 597-668 Link Here
597	int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;	573	int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
598	int AbstractMethodInAbstractClass = MethodRelated + 363;	574	int AbstractMethodInAbstractClass = MethodRelated + 363;
599	int ArgumentTypeCannotBeVoid = MethodRelated + 364;	575	int ArgumentTypeCannotBeVoid = MethodRelated + 364;
600	/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
601	int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
602	/** @deprecated - problem is no longer generated, use {@link #CannotAllocateVoidArray} instead */
603	int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
604	int NativeMethodsCannotBeStrictfp = MethodRelated + 367;	576	int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
605	int DuplicateModifierForArgument = MethodRelated + 368;	577	int DuplicateModifierForArgument = MethodRelated + 368;
606		578
607	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
608	int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
609	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
610	int ArgumentTypeNotVisible = MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
611	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
612	int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
613	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
614	int ArgumentTypeInternalNameProvided = MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
615	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
616	int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
617
618	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
619	int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
620	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
621	int ExceptionTypeNotVisible = MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
622	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
623	int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
624	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
625	int ExceptionTypeInternalNameProvided = MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
626	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
627	int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
628
629	/** @deprecated - problem is no longer generated, use {@link #UndefinedType} instead */
630	int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
631	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
632	int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
633	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
634	int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
635	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
636	int ReturnTypeInternalNameProvided = MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
637	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
638	int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
639
640	// import related problems	579	// import related problems
641	int ConflictingImport = ImportRelated + 385;	580	int ConflictingImport = ImportRelated + 385;
642	int DuplicateImport = ImportRelated + 386;	581	int DuplicateImport = ImportRelated + 386;
643	int CannotImportPackage = ImportRelated + 387;	582	int CannotImportPackage = ImportRelated + 387;
644		583
645	int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390	584	int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
646	/** @deprecated - problem is no longer generated, use {@link #NotVisibleType} instead */
647	int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
648	/** @deprecated - problem is no longer generated, use {@link #AmbiguousType} instead */
649	int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
650	/** @deprecated - problem is no longer generated, use {@link #InternalTypeNameProvided} instead */
651	int ImportInternalNameProvided = ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
652	/** @deprecated - problem is no longer generated, use {@link #InheritedTypeHidesEnclosingName} instead */
653	int ImportInheritedNameHidesEnclosingName = ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
654		585
655	int InvalidTypeForStaticImport = ImportRelated + 391;	586	int InvalidTypeForStaticImport = ImportRelated + 391;
656		587
657	// local variable related problems	588	// local variable related problems
658	int DuplicateModifierForVariable = MethodRelated + 395;	589	int DuplicateModifierForVariable = MethodRelated + 395;
659	int IllegalModifierForVariable = MethodRelated + 396;	590	int IllegalModifierForVariable = MethodRelated + 396;
660	/** @deprecated - problem is no longer generated, use {@link #RedundantNullCheckOnNonNullLocalVariable} instead */
661	int LocalVariableCannotBeNull = Internal + 397; // since 3.3: semantics are LocalVariableRedundantCheckOnNonNull
662	/** @deprecated - problem is no longer generated, use {@link #NullLocalVariableReference}, {@link #RedundantNullCheckOnNullLocalVariable} or {@link #RedundantLocalVariableNullAssignment} instead */
663	int LocalVariableCanOnlyBeNull = Internal + 398; // since 3.3: split with LocalVariableRedundantCheckOnNull depending on context
664	/** @deprecated - problem is no longer generated, use {@link #PotentialNullLocalVariableReference} instead */
665	int LocalVariableMayBeNull = Internal + 399;
666		591
667	// method verifier problems	592	// method verifier problems
668	int AbstractMethodMustBeImplemented = MethodRelated + 400;	593	int AbstractMethodMustBeImplemented = MethodRelated + 400;
Lines 809-818 Link Here
809	int DuplicateTypeVariable = Internal + 520;	734	int DuplicateTypeVariable = Internal + 520;
810	int IllegalTypeVariableSuperReference = Internal + 521;	735	int IllegalTypeVariableSuperReference = Internal + 521;
811	int NonStaticTypeFromStaticInvocation = Internal + 522;	736	int NonStaticTypeFromStaticInvocation = Internal + 522;
812	int ObjectCannotBeGeneric = Internal + 523;
813	int NonGenericType = TypeRelated + 524;	737	int NonGenericType = TypeRelated + 524;
814	int IncorrectArityForParameterizedType = TypeRelated + 525;	738	int IncorrectArityForParameterizedType = TypeRelated + 525;
815	int TypeArgumentMismatch = TypeRelated + 526;
816	int DuplicateMethodErasure = TypeRelated + 527;	739	int DuplicateMethodErasure = TypeRelated + 527;
817	int ReferenceToForwardTypeVariable = TypeRelated + 528;	740	int ReferenceToForwardTypeVariable = TypeRelated + 528;
818	int BoundMustBeAnInterface = TypeRelated + 529;	741	int BoundMustBeAnInterface = TypeRelated + 529;
Lines 823-849 Link Here
823	int FinalBoundForTypeVariable = TypeRelated + 537;	746	int FinalBoundForTypeVariable = TypeRelated + 537;
824	int UndefinedTypeVariable = Internal + 538;	747	int UndefinedTypeVariable = Internal + 538;
825	int SuperInterfacesCollide = TypeRelated + 539;	748	int SuperInterfacesCollide = TypeRelated + 539;
826	int GenericMethodTypeArgumentMismatch = TypeRelated + 543;
827	int GenericConstructorTypeArgumentMismatch = TypeRelated + 544;
828	int UnsafeGenericCast = TypeRelated + 545;	749	int UnsafeGenericCast = TypeRelated + 545;
829	int IllegalInstanceofParameterizedType = Internal + 546;
830	int IllegalInstanceofTypeParameter = Internal + 547;
831	int NonGenericMethod = TypeRelated + 548;
832	int IncorrectArityForParameterizedMethod = TypeRelated + 549;
833	int ParameterizedMethodArgumentTypeMismatch = TypeRelated + 550;
834	int NonGenericConstructor = TypeRelated + 551;
835	int IncorrectArityForParameterizedConstructor = TypeRelated + 552;
836	int ParameterizedConstructorArgumentTypeMismatch = TypeRelated + 553;
837	int TypeArgumentsForRawGenericMethod = TypeRelated + 554;
838	int TypeArgumentsForRawGenericConstructor = TypeRelated + 555;
839	int SuperTypeUsingWildcard = TypeRelated + 556;
840	int GenericTypeCannotExtendThrowable = TypeRelated + 557;	750	int GenericTypeCannotExtendThrowable = TypeRelated + 557;
841	int IllegalClassLiteralForTypeVariable = TypeRelated + 558;	751	int IllegalClassLiteralForTypeVariable = TypeRelated + 558;
842	int UnsafeReturnTypeOverride = MethodRelated + 559;	752	int UnsafeReturnTypeOverride = MethodRelated + 559;
843	int MethodNameClash = MethodRelated + 560;	753	int MethodNameClash = MethodRelated + 560;
844	int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;	754	int MissingArgumentsForParameterizedMemberType = TypeRelated + 562;
845	int StaticMemberOfParameterizedType = TypeRelated + 563;	755	int StaticMemberOfParameterizedType = TypeRelated + 563;
846	int BoundHasConflictingArguments = TypeRelated + 564;
847	int DuplicateParameterizedMethods = MethodRelated + 565;	756	int DuplicateParameterizedMethods = MethodRelated + 565;
848	int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;	757	int IllegalQualifiedParameterizedTypeAllocation = TypeRelated + 566;
849	int DuplicateBounds = TypeRelated + 567;	758	int DuplicateBounds = TypeRelated + 567;
Lines 851-859 Link Here
851	int TypeParameterHidingType = TypeRelated + 571;	760	int TypeParameterHidingType = TypeRelated + 571;
852	int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;	761	int NoAdditionalBoundAfterTypeVariable = TypeRelated + 573;
853	int IllegalAccessFromTypeVariable = TypeRelated + 575;	762	int IllegalAccessFromTypeVariable = TypeRelated + 575;
854	int TypeHidingTypeParameterFromType = TypeRelated + 576;
855	int TypeHidingTypeParameterFromMethod = TypeRelated + 577;
856	int InvalidUsageOfWildcard = Syntax + Internal + 578;
857		763
858	/**	764	/**
859	* Foreach	765	* Foreach
Lines 865-916 Link Here
865	* 1.5 Syntax errors (when source level < 1.5)	771	* 1.5 Syntax errors (when source level < 1.5)
866	*/	772	*/
867	int InvalidUsageOfTypeParameters = Syntax + Internal + 590;	773	int InvalidUsageOfTypeParameters = Syntax + Internal + 590;
868	int InvalidUsageOfStaticImports = Syntax + Internal + 591;
869	int InvalidUsageOfForeachStatements = Syntax + Internal + 592;	774	int InvalidUsageOfForeachStatements = Syntax + Internal + 592;
870	int InvalidUsageOfTypeArguments = Syntax + Internal + 593;
871	int InvalidUsageOfEnumDeclarations = Syntax + Internal + 594;
872	int InvalidUsageOfVarargs = Syntax + Internal + 595;
873	int InvalidUsageOfAnnotations = Syntax + Internal + 596;
874	int InvalidUsageOfAnnotationDeclarations = Syntax + Internal + 597;
875
876	/**
877	* Annotation
878	*/
879	int IllegalModifierForAnnotationMethod = MethodRelated + 600;
880	int IllegalExtendedDimensions = MethodRelated + 601;
881	int InvalidFileNameForPackageAnnotations = Syntax + Internal + 602;
882	int IllegalModifierForAnnotationType = TypeRelated + 603;
883	int IllegalModifierForAnnotationMemberType = TypeRelated + 604;
884	int InvalidAnnotationMemberType = TypeRelated + 605;
885	int AnnotationCircularitySelfReference = TypeRelated + 606;
886	int AnnotationCircularity = TypeRelated + 607;
887	int DuplicateAnnotation = TypeRelated + 608;
888	int MissingValueForAnnotationMember = TypeRelated + 609;
889	int DuplicateAnnotationMember = Internal + 610;
890	int UndefinedAnnotationMember = MethodRelated + 611;
891	int AnnotationValueMustBeClassLiteral = Internal + 612;
892	int AnnotationValueMustBeConstant = Internal + 613;
893	int AnnotationFieldNeedConstantInitialization = Internal + 614;
894	int IllegalModifierForAnnotationField = Internal + 615;
895	int AnnotationCannotOverrideMethod = MethodRelated + 616;
896	int AnnotationMembersCannotHaveParameters = Syntax + Internal + 617;
897	int AnnotationMembersCannotHaveTypeParameters = Syntax + Internal + 618;
898	int AnnotationTypeDeclarationCannotHaveSuperclass = Syntax + Internal + 619;
899	int AnnotationTypeDeclarationCannotHaveSuperinterfaces = Syntax + Internal + 620;
900	int DuplicateTargetInTargetAnnotation = Internal + 621;
901	int DisallowedTargetForAnnotation = TypeRelated + 622;
902	int MethodMustOverride = MethodRelated + 623;
903	int AnnotationTypeDeclarationCannotHaveConstructor = Syntax + Internal + 624;
904	int AnnotationValueMustBeAnnotation = Internal + 625;
905	int AnnotationTypeUsedAsSuperInterface = TypeRelated + 626;
906	int MissingOverrideAnnotation = MethodRelated + 627;
907	int FieldMissingDeprecatedAnnotation = Internal + 628;
908	int MethodMissingDeprecatedAnnotation = Internal + 629;
909	int TypeMissingDeprecatedAnnotation = Internal + 630;
910	int UnhandledWarningToken = Internal + 631;
911	int AnnotationValueMustBeArrayInitializer = Internal + 632;
912	int AnnotationValueMustBeAnEnumConstant = Internal + 633;
913	int MethodMustOverrideOrImplement = MethodRelated + 634;
914		775
915	/**	776	/**
916	* Corrupted binaries	777	* Corrupted binaries
Lines 929-973 Link Here
929	int UnboxingConversion = Internal + 721;	790	int UnboxingConversion = Internal + 721;
930		791
931	/**	792	/**
932	* Enum
933	*/
934	int IllegalModifierForEnum = TypeRelated + 750;
935	int IllegalModifierForEnumConstant = FieldRelated + 751;
936	int IllegalModifierForLocalEnum = TypeRelated + 752;
937	int IllegalModifierForMemberEnum = TypeRelated + 753;
938	int CannotDeclareEnumSpecialMethod = MethodRelated + 754;
939	int IllegalQualifiedEnumConstantLabel = FieldRelated + 755;
940	int CannotExtendEnum = TypeRelated + 756;
941	int CannotInvokeSuperConstructorInEnum = MethodRelated + 757;
942	int EnumAbstractMethodMustBeImplemented = MethodRelated + 758;
943	int EnumSwitchCannotTargetField = FieldRelated + 759;
944	int IllegalModifierForEnumConstructor = MethodRelated + 760;
945	int MissingEnumConstantCase = FieldRelated + 761;
946	int EnumStaticFieldInInInitializerContext = FieldRelated + 762;
947
948	/**
949	* Var args
950	*/
951	int IllegalExtendedDimensionsForVarArgs = Syntax + Internal + 800;
952	int MethodVarargsArgumentNeedCast = MethodRelated + 801;
953	int ConstructorVarargsArgumentNeedCast = ConstructorRelated + 802;
954	int VarargsConflict = MethodRelated + 803;
955
956	/**
957	* Javadoc Generic
958	*/
959	int JavadocGenericMethodTypeArgumentMismatch = Javadoc + Internal + 850;
960	int JavadocNonGenericMethod = Javadoc + Internal + 851;
961	int JavadocIncorrectArityForParameterizedMethod = Javadoc + Internal + 852;
962	int JavadocParameterizedMethodArgumentTypeMismatch = Javadoc + Internal + 853;
963	int JavadocTypeArgumentsForRawGenericMethod = Javadoc + Internal + 854;
964	int JavadocGenericConstructorTypeArgumentMismatch = Javadoc + Internal + 855;
965	int JavadocNonGenericConstructor = Javadoc + Internal + 856;
966	int JavadocIncorrectArityForParameterizedConstructor = Javadoc + Internal + 857;
967	int JavadocParameterizedConstructorArgumentTypeMismatch = Javadoc + Internal + 858;
968	int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;
969
970	/**
971	* External problems -- These are problems defined by other plugins	793	* External problems -- These are problems defined by other plugins
972	*/	794	*/
973		795

Lines 1621-1631 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/parser/Parser.java (-60 lines)
1621	annotationTypeDeclaration.javadoc = this.javadoc;	1621	annotationTypeDeclaration.javadoc = this.javadoc;
1622	this.javadoc = null;	1622	this.javadoc = null;
1623	pushOnAstStack(annotationTypeDeclaration);	1623	pushOnAstStack(annotationTypeDeclaration);
1624	if(!this.statementRecoveryActivated &&
1625	options.sourceLevel < ClassFileConstants.JDK1_5 &&
1626	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
1627	this.problemReporter().invalidUsageOfAnnotationDeclarations(annotationTypeDeclaration);
1628	}
1629		1624
1630	// recovery	1625	// recovery
1631	if (this.currentElement != null){	1626	if (this.currentElement != null){
Lines 3589-3601 Link Here
3589		3584
3590	this.listLength = 0; // will be updated when reading super-interfaces	3585	this.listLength = 0; // will be updated when reading super-interfaces
3591		3586
3592	if(!this.statementRecoveryActivated &&
3593	options.sourceLevel < ClassFileConstants.JDK1_5 &&
3594	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
3595	//TODO this code will be never run while 'enum' is an identifier in 1.3 scanner
3596	this.problemReporter().invalidUsageOfEnumDeclarations(enumDeclaration);
3597	}
3598
3599	// recovery	3587	// recovery
3600	if (this.currentElement != null){	3588	if (this.currentElement != null){
3601	this.lastCheckPoint = enumDeclaration.bodyStart;	3589	this.lastCheckPoint = enumDeclaration.bodyStart;
Lines 3902-3918 Link Here
3902	/* if incomplete method header, this.listLength counter will not have been reset,	3890	/* if incomplete method header, this.listLength counter will not have been reset,
3903	indicating that some arguments are available on the stack */	3891	indicating that some arguments are available on the stack */
3904	this.listLength++;	3892	this.listLength++;
3905
3906	// if(isVarArgs) {
3907	// if (!this.statementRecoveryActivated &&
3908	// options.sourceLevel < ClassFileConstants.JDK1_5 &&
3909	// this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
3910	// this.problemReporter().invalidUsageOfVarargs(arg);
3911	// } else if (!this.statementRecoveryActivated &&
3912	// extendedDimensions > 0) {
3913	// this.problemReporter().illegalExtendedDimensions(arg);
3914	// }
3915	// }
3916	}	3893	}
3917		3894
3918	protected void handleArgumentComment(Argument arg)	3895	protected void handleArgumentComment(Argument arg)
Lines 4343-4353 Link Here
4343	markerAnnotation = new MarkerAnnotation(typeReference, this.intStack[this.intPtr--]);	4320	markerAnnotation = new MarkerAnnotation(typeReference, this.intStack[this.intPtr--]);
4344	markerAnnotation.declarationSourceEnd = markerAnnotation.sourceEnd;	4321	markerAnnotation.declarationSourceEnd = markerAnnotation.sourceEnd;
4345	pushOnExpressionStack(markerAnnotation);	4322	pushOnExpressionStack(markerAnnotation);
4346	if(!this.statementRecoveryActivated &&
4347	options.sourceLevel < ClassFileConstants.JDK1_5 &&
4348	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
4349	this.problemReporter().invalidUsageOfAnnotation(markerAnnotation);
4350	}
4351	this.recordStringLiterals = true;	4323	this.recordStringLiterals = true;
4352	}	4324	}
4353	protected void consumeMemberValueArrayInitializer() {	4325	protected void consumeMemberValueArrayInitializer() {
Lines 4909-4936 Link Here
4909	annotationRecoveryCheckPoint(normalAnnotation.sourceStart, normalAnnotation.declarationSourceEnd);	4881	annotationRecoveryCheckPoint(normalAnnotation.sourceStart, normalAnnotation.declarationSourceEnd);
4910	}	4882	}
4911		4883
4912	if(!this.statementRecoveryActivated &&
4913	options.sourceLevel < ClassFileConstants.JDK1_5 &&
4914	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
4915	this.problemReporter().invalidUsageOfAnnotation(normalAnnotation);
4916	}
4917	this.recordStringLiterals = true;	4884	this.recordStringLiterals = true;
4918	}	4885	}
4919	protected void consumeOneDimLoop() {	4886	protected void consumeOneDimLoop() {
4920	// OneDimLoop ::= '[' ']'	4887	// OneDimLoop ::= '[' ']'
4921	this.dimensions++;	4888	this.dimensions++;
4922	}	4889	}
4923
4924	protected void consumeOnlyTypeArguments() {
4925	if(!this.statementRecoveryActivated &&
4926	options.sourceLevel < ClassFileConstants.JDK1_5 &&
4927	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
4928	int length = this.genericsLengthStack[this.genericsLengthPtr];
4929	this.problemReporter().invalidUsageOfTypeArguments(
4930	(TypeReference)this.genericsStack[this.genericsPtr - length + 1],
4931	(TypeReference)this.genericsStack[this.genericsPtr]);
4932	}
4933	}
4934	protected void consumeOnlyTypeArgumentsForCastExpression() {	4890	protected void consumeOnlyTypeArgumentsForCastExpression() {
4935	// OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments	4891	// OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments
4936	}	4892	}
Lines 6489-6499 Link Here
6489	annotationRecoveryCheckPoint(singleMemberAnnotation.sourceStart, singleMemberAnnotation.declarationSourceEnd);	6445	annotationRecoveryCheckPoint(singleMemberAnnotation.sourceStart, singleMemberAnnotation.declarationSourceEnd);
6490	}	6446	}
6491		6447
6492	if(!this.statementRecoveryActivated &&
6493	options.sourceLevel < ClassFileConstants.JDK1_5 &&
6494	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
6495	this.problemReporter().invalidUsageOfAnnotation(singleMemberAnnotation);
6496	}
6497	this.recordStringLiterals = true;	6448	this.recordStringLiterals = true;
6498	}	6449	}
6499	protected void consumeSingleStaticImportDeclarationName() {	6450	protected void consumeSingleStaticImportDeclarationName() {
Lines 6526-6532 Link Here
6526	this.options.sourceLevel < ClassFileConstants.JDK1_5 &&	6477	this.options.sourceLevel < ClassFileConstants.JDK1_5 &&
6527	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {	6478	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
6528	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference	6479	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference
6529	this.problemReporter().invalidUsageOfStaticImports(impt);
6530	}	6480	}
6531		6481
6532	// recovery	6482	// recovery
Lines 6885-6891 Link Here
6885	options.sourceLevel < ClassFileConstants.JDK1_5 &&	6835	options.sourceLevel < ClassFileConstants.JDK1_5 &&
6886	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {	6836	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
6887	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference	6837	impt.modifiers = ClassFileConstants.AccDefault; // convert the static import reference to a non-static importe reference
6888	this.problemReporter().invalidUsageOfStaticImports(impt);
6889	}	6838	}
6890		6839
6891	// recovery	6840	// recovery
Lines 7348-7362 Link Here
7348	protected void consumeTypeArguments() {	7297	protected void consumeTypeArguments() {
7349	concatGenericsLists();	7298	concatGenericsLists();
7350	intPtr--;	7299	intPtr--;
7351
7352	if(!this.statementRecoveryActivated &&
7353	options.sourceLevel < ClassFileConstants.JDK1_5 &&
7354	this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
7355	int length = this.genericsLengthStack[this.genericsLengthPtr];
7356	this.problemReporter().invalidUsageOfTypeArguments(
7357	(TypeReference)this.genericsStack[this.genericsPtr - length + 1],
7358	(TypeReference)this.genericsStack[this.genericsPtr]);
7359	}
7360	}	7300	}
7361	protected void consumeTypeDeclarations() {	7301	protected void consumeTypeDeclarations() {
7362	// TypeDeclarations ::= TypeDeclarations TypeDeclaration	7302	// TypeDeclarations ::= TypeDeclarations TypeDeclaration