Attachment #111495 for bug #245973

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 245973
Collapse All | Expand All

Lines 1321-1327 Link Here

(-)src/org/eclipse/jdt/core/tests/util/Util.java (-1 / +1 lines)
1321	}	1321	}
1322	}	1322	}
1323	if (showWarningToken) {	1323	if (showWarningToken) {
1324	long irritant = ProblemReporter.getIrritant(problem.getID());	1324	int irritant = ProblemReporter.getIrritant(problem.getID());
1325	if (irritant != 0) {	1325	if (irritant != 0) {
1326	String warningToken = CompilerOptions.warningTokenFromIrritant(irritant);	1326	String warningToken = CompilerOptions.warningTokenFromIrritant(irritant);
1327	if (warningToken != null) {	1327	if (warningToken != null) {




import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.IrritantSet;
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;


// irritant vs warning token - check To/From symmetry
public void test001_irritant_warning_token() {
	String [] tokens = new String[64];
	Map matcher = new HashMap();
	for (int group = 0; group < IrritantSet.GROUP_MAX; group++) {
		for (int i = 0; i < 29; i++) {
			int irritant = (group << IrritantSet.GROUP_SHIFT) + (1 << i);
			String token = CompilerOptions.warningTokenFromIrritant(irritant);
			if (token != null) {
				matcher.put(token, token);
				assertTrue(CompilerOptions.warningTokenToIrritants(token) != null);
			}
		}
	}
	String [] allTokens = CompilerOptions.warningTokens;

Lines 460-466 Link Here

(-)model/org/eclipse/jdt/core/CorrectionEngine.java (-1 / +1 lines)
460	* @since 3.1	460	* @since 3.1
461	*/	461	*/
462	public static String getWarningToken(int problemID){	462	public static String getWarningToken(int problemID){
463	long irritant = ProblemReporter.getIrritant(problemID);	463	int irritant = ProblemReporter.getIrritant(problemID);
464	if (irritant != 0) {	464	if (irritant != 0) {
465	return CompilerOptions.warningTokenFromIrritant(irritant);	465	return CompilerOptions.warningTokenFromIrritant(irritant);
466	}	466	}




import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.impl.IrritantSet;
import org.eclipse.jdt.internal.compiler.lookup.*;

/**

	}

	public void recordSuppressWarnings(Scope scope, int startSuppresss, int endSuppress, boolean isSuppressingWarnings) {
		IrritantSet suppressWarningIrritants = null;
		MemberValuePair[] pairs = memberValuePairs();
		pairLoop: for (int i = 0, length = pairs.length; i < length; i++) {
			MemberValuePair pair = pairs[i];

						for (int j = 0, initsLength = inits.length; j < initsLength; j++) {
							Constant cst = inits[j].constant;
							if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
								IrritantSet irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
								if (irritants != null) {
									if (suppressWarningIrritants == null) {
										suppressWarningIrritants = new IrritantSet(irritants);
									} else if (suppressWarningIrritants.set(irritants) == null) {
											scope.problemReporter().unusedWarningToken(inits[j]);
									}
								} else {
									scope.problemReporter().unhandledWarningToken(inits[j]);

				} else {
					Constant cst = value.constant;
					if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
						IrritantSet irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
						if (irritants != null) {
							suppressWarningIrritants = new IrritantSet(irritants);
							// TODO: should check for unused warning token against enclosing annotation as well ?
						} else {
							scope.problemReporter().unhandledWarningToken(value);
						}

				break pairLoop;
			}
		}
		if (isSuppressingWarnings && suppressWarningIrritants != null) {
			scope.referenceCompilationUnit().recordSuppressWarnings(suppressWarningIrritants, this, startSuppresss, endSuppress);
		}
	}

		long tagBits = detectStandardAnnotation(scope, annotationType, valueAttribute);

		// record annotation positions in the compilation result
		scope.referenceCompilationUnit().recordSuppressWarnings(IrritantSet.NLS, null, this.sourceStart, this.declarationSourceEnd);
		if (this.recipient != null) {
			if (tagBits != 0) {
				// tag bits onto recipient




import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.impl.IrritantSet;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
import org.eclipse.jdt.internal.compiler.lookup.ImportBinding;

	private int stringLiteralsPtr;
	private HashSetOfInt stringLiteralsStart;

	IrritantSet[] suppressWarningIrritants;  // irritant for suppressed warnings
	Annotation[] suppressWarningAnnotations;
	long[] suppressWarningScopePositions; // (start << 32) + end
	int suppressWarningsCount;

		int removed = 0;
		CategorizedProblem[] problems = this.compilationResult.problems;
		int problemCount = this.compilationResult.problemCount;
		IrritantSet[] foundIrritants = new IrritantSet[this.suppressWarningsCount];
		CompilerOptions options = this.scope.compilerOptions();
		boolean hasErrors = false;
		nextProblem: for (int iProblem = 0, length = problemCount; iProblem < length; iProblem++) {

			}
			int start = problem.getSourceStart();
			int end = problem.getSourceEnd();
			int irritant = ProblemReporter.getIrritant(problemID);
			nextSuppress: for (int iSuppress = 0, suppressCount = this.suppressWarningsCount; iSuppress < suppressCount; iSuppress++) {
				long position = this.suppressWarningScopePositions[iSuppress];
				int startSuppress = (int) (position >>> 32);
				int endSuppress = (int) position;
				if (start < startSuppress) continue nextSuppress;
				if (end > endSuppress) continue nextSuppress;
				if (!this.suppressWarningIrritants[iSuppress].isSet(irritant))
					continue nextSuppress;
				// discard suppressed warning
				removed++;
				problems[iProblem] = null;
				if (this.compilationResult.problemsMap != null) this.compilationResult.problemsMap.remove(problem);
				if (this.compilationResult.firstErrors != null) this.compilationResult.firstErrors.remove(problem);
				if (foundIrritants[iSuppress] == null){
					foundIrritants[iSuppress] = new IrritantSet(irritant);
				} else {
					foundIrritants[iSuppress].set(irritant);
				}
				continue nextProblem;
			}
		}

				for (int iSuppress = 0, suppressCount = this.suppressWarningsCount; iSuppress < suppressCount; iSuppress++) {
					Annotation annotation = this.suppressWarningAnnotations[iSuppress];
					if (annotation == null) continue; // implicit annotation
					IrritantSet irritants = this.suppressWarningIrritants[iSuppress];
					if (unusedWarningTokenIsWarning && irritants.areAllSet()) continue; // @SuppressWarnings("all") also suppresses unused warning token
					if (irritants != foundIrritants[iSuppress]) { // mismatch, some warning tokens were unused
						MemberValuePair[] pairs = annotation.memberValuePairs();
						pairLoop: for (int iPair = 0, pairCount = pairs.length; iPair < pairCount; iPair++) {

										for (int iToken = 0, tokenCount = inits.length; iToken < tokenCount; iToken++) {
											Constant cst = inits[iToken].constant;
											if (cst != Constant.NotAConstant && cst.typeID() == TypeIds.T_JavaLangString) {
												IrritantSet tokenIrritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
												if (tokenIrritants != null
														&& !tokenIrritants.areAllSet() // no complaint against @SuppressWarnings("all")
														&& options.isAnyEnabled(tokenIrritants) // if irritant is effectevely enabled
														&& (foundIrritants[iSuppress] == null || !foundIrritants[iSuppress].isAnySet(tokenIrritants))) { // if irritant had no matching problem
													if (unusedWarningTokenIsWarning) {
														int start = value.sourceStart, end = value.sourceEnd;
														nextSuppress: for (int jSuppress = iSuppress - 1; jSuppress >= 0; jSuppress--) {

															int endSuppress = (int) position;
															if (start < startSuppress) continue nextSuppress;
															if (end > endSuppress) continue nextSuppress;
															if (this.suppressWarningIrritants[jSuppress].areAllSet()) break pairLoop; // suppress all?
														}
													}
													this.scope.problemReporter().unusedWarningToken(inits[iToken]);

								} else {
									Constant cst = value.constant;
									if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
										IrritantSet tokenIrritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
										if (tokenIrritants != null
												&& !tokenIrritants.areAllSet() // no complaint against @SuppressWarnings("all")
												&& options.isAnyEnabled(tokenIrritants) // if irritant is effectevely enabled
												&& (foundIrritants[iSuppress] == null || !foundIrritants[iSuppress].isAnySet(tokenIrritants))) { // if irritant had no matching problem
											if (unusedWarningTokenIsWarning) {
												int start = value.sourceStart, end = value.sourceEnd;
												nextSuppress: for (int jSuppress = iSuppress - 1; jSuppress >= 0; jSuppress--) {

													int endSuppress = (int) position;
													if (start < startSuppress) continue nextSuppress;
													if (end > endSuppress) continue nextSuppress;
													if (this.suppressWarningIrritants[jSuppress].areAllSet()) break pairLoop; // suppress all?
												}
											}
											this.scope.problemReporter().unusedWarningToken(value);

		this.stringLiterals[this.stringLiteralsPtr++] = literal;
	}

	public void recordSuppressWarnings(IrritantSet irritants, Annotation annotation, int scopeStart, int scopeEnd) {
		if (this.suppressWarningIrritants == null) {
			this.suppressWarningIrritants = new IrritantSet[3];
			this.suppressWarningAnnotations = new Annotation[3];
			this.suppressWarningScopePositions = new long[3];
		} else if (this.suppressWarningIrritants.length == this.suppressWarningsCount) {
			System.arraycopy(this.suppressWarningIrritants, 0,this.suppressWarningIrritants = new IrritantSet[2*this.suppressWarningsCount], 0, this.suppressWarningsCount);
			System.arraycopy(this.suppressWarningAnnotations, 0,this.suppressWarningAnnotations = new Annotation[2*this.suppressWarningsCount], 0, this.suppressWarningsCount);
			System.arraycopy(this.suppressWarningScopePositions, 0,this.suppressWarningScopePositions = new long[2*this.suppressWarningsCount], 0, this.suppressWarningsCount);
		}
		this.suppressWarningIrritants[this.suppressWarningsCount] = irritants;
		this.suppressWarningAnnotations[this.suppressWarningsCount] = annotation;
		this.suppressWarningScopePositions[this.suppressWarningsCount++] = ((long)scopeStart<<32) + scopeEnd;
	}

Lines 381-387 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (-1 / +1 lines)
381		381
382	// find out an option name controlling a given problemID	382	// find out an option name controlling a given problemID
383	private String getProblemOptionKey(int problemID) {	383	private String getProblemOptionKey(int problemID) {
384	long irritant = ProblemReporter.getIrritant(problemID);	384	int irritant = ProblemReporter.getIrritant(problemID);
385	return CompilerOptions.optionKeyFromIrritant(irritant);	385	return CompilerOptions.optionKeyFromIrritant(irritant);
386	}	386	}
387		387




	return leadProblemId << 8 | elaborationVariant; // leadProblemId comes into the higher order bytes
}

public static int getIrritant(int problemID) {
	switch(problemID){

		case IProblem.MaskedCatch :

		// fatal problems even if optional are all falling into same category (not irritant based)
		if ((severity & ProblemSeverities.Fatal) != 0)
			break categorizeOnIrritant;
		int irritant = getIrritant(problemID);
		switch (irritant) {
			case CompilerOptions.MethodWithConstructorName :
			case CompilerOptions.AccessEmulation :
			case CompilerOptions.AssertUsedAsAnIdentifier :
			case CompilerOptions.NonStaticAccessToStatic :
			case CompilerOptions.UnqualifiedFieldAccess :
			case CompilerOptions.UndocumentedEmptyBlock :
			case CompilerOptions.IndirectStaticAccess :
			case CompilerOptions.FinalParameterBound :
			case CompilerOptions.EnumUsedAsAnIdentifier :
			case CompilerOptions.AnnotationSuperInterface :
			case CompilerOptions.AutoBoxing :
			case CompilerOptions.MissingOverrideAnnotation :
			case CompilerOptions.MissingDeprecatedAnnotation :
			case CompilerOptions.ParameterAssignment :				
				return CategorizedProblem.CAT_CODE_STYLE;

			case CompilerOptions.MaskedCatchBlock :
			case CompilerOptions.NoImplicitStringConversion :
			case CompilerOptions.NoEffectAssignment :
			case CompilerOptions.AccidentalBooleanAssign :
			case CompilerOptions.EmptyStatement :
			case CompilerOptions.FinallyBlockNotCompleting :
			case CompilerOptions.MissingSerialVersion :
			case CompilerOptions.VarargsArgumentNeedCast :
			case CompilerOptions.NullReference :
			case CompilerOptions.PotentialNullReference :
			case CompilerOptions.RedundantNullCheck :
			case CompilerOptions.IncompleteEnumSwitch :
			case CompilerOptions.FallthroughCase :
			case CompilerOptions.OverridingMethodWithoutSuperInvocation :
			case CompilerOptions.ComparingIdentical :
			case CompilerOptions.MissingSynchronizedModifierInInheritedMethod :				
				return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;
			
			case CompilerOptions.OverriddenPackageDefaultMethod :
			case CompilerOptions.IncompatibleNonInheritedInterfaceMethod :
			case CompilerOptions.LocalVariableHiding :
			case CompilerOptions.FieldHiding :
			case CompilerOptions.TypeHiding :
				return CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT;		

			case CompilerOptions.UnusedLocalVariable :
			case CompilerOptions.UnusedArgument :
			case CompilerOptions.UnusedImport :
			case CompilerOptions.UnusedPrivateMember :
			case CompilerOptions.UnusedDeclaredThrownException :
			case CompilerOptions.UnnecessaryTypeCheck :
			case CompilerOptions.UnnecessaryElse :
			case CompilerOptions.UnhandledWarningToken :
			case CompilerOptions.UnusedWarningToken :
			case CompilerOptions.UnusedLabel :
			case CompilerOptions.RedundantSuperinterface :				
				return CategorizedProblem.CAT_UNNECESSARY_CODE;					

			case CompilerOptions.UsingDeprecatedAPI :
				return CategorizedProblem.CAT_DEPRECATION;
			}
		} else {
			irritantInt = (int)(irritant >>> 32);
			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.RedundantNullCheck >>> 32):
				case (int)(CompilerOptions.IncompleteEnumSwitch >>> 32):
				case (int)(CompilerOptions.FallthroughCase >>> 32):
				case (int)(CompilerOptions.OverridingMethodWithoutSuperInvocation >>> 32):
				case (int)(CompilerOptions.ComparingIdentical >>> 32):
				case (int)(CompilerOptions.MissingSynchronizedModifierInInheritedMethod >> 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.UnusedWarningToken >>> 32):
				case (int)(CompilerOptions.UnusedLabel >>> 32):
				case (int)(CompilerOptions.RedundantSuperinterface >>> 32):
					return CategorizedProblem.CAT_UNNECESSARY_CODE;

				case (int)(CompilerOptions.ForbiddenReference >>> 32):
				case (int)(CompilerOptions.DiscouragedReference >>> 32):
					return CategorizedProblem.CAT_RESTRICTION;

			case CompilerOptions.NonExternalizedString :
				return CategorizedProblem.CAT_NLS;

			case CompilerOptions.Task :
				return CategorizedProblem.CAT_UNSPECIFIED; // TODO may want to improve
			
			case CompilerOptions.MissingJavadocComments :
			case CompilerOptions.MissingJavadocTags :
			case CompilerOptions.InvalidJavadoc :
			case CompilerOptions.InvalidJavadoc|CompilerOptions.UsingDeprecatedAPI :
				return CategorizedProblem.CAT_JAVADOC;					

			case CompilerOptions.UncheckedTypeOperation :
			case CompilerOptions.RawTypeReference :
				return CategorizedProblem.CAT_UNCHECKED_RAW;				
			
			case CompilerOptions.ForbiddenReference :
			case CompilerOptions.DiscouragedReference :
				return CategorizedProblem.CAT_RESTRICTION;
			
			default:
				break categorizeOnIrritant;
		}
	}
	// categorize fatal problems per ID

			}
			break;
	}
	int irritant = getIrritant(problemID);
	if (irritant != 0) {
		if ((problemID & IProblem.Javadoc) != 0 && !this.options.docCommentSupport)
			return ProblemSeverities.Ignore;





	/**
	 * Bit mask for configurable problems (error/warning threshold)
	 * Note: bitmask assumes 3 highest bits to denote irritant group (to allow storing 8 groups of 29 bits each
	 */
	// group 0
	public static final int MethodWithConstructorName = IrritantSet.GROUP0 | ASTNode.Bit1;
	public static final int OverriddenPackageDefaultMethod = IrritantSet.GROUP0 | ASTNode.Bit2;
	public static final int UsingDeprecatedAPI = IrritantSet.GROUP0 | ASTNode.Bit3;
	public static final int MaskedCatchBlock = IrritantSet.GROUP0 | ASTNode.Bit4;
	public static final int UnusedLocalVariable = IrritantSet.GROUP0 | ASTNode.Bit5;
	public static final int UnusedArgument = IrritantSet.GROUP0 | ASTNode.Bit6;
	public static final int NoImplicitStringConversion = IrritantSet.GROUP0 | ASTNode.Bit7;
	public static final int AccessEmulation = IrritantSet.GROUP0 | ASTNode.Bit8;
	public static final int NonExternalizedString = IrritantSet.GROUP0 | ASTNode.Bit9;
	public static final int AssertUsedAsAnIdentifier = IrritantSet.GROUP0 | ASTNode.Bit10;
	public static final int UnusedImport = IrritantSet.GROUP0 | ASTNode.Bit11;
	public static final int NonStaticAccessToStatic = IrritantSet.GROUP0 | ASTNode.Bit12;
	public static final int Task = IrritantSet.GROUP0 | ASTNode.Bit13;
	public static final int NoEffectAssignment = IrritantSet.GROUP0 | ASTNode.Bit14;
	public static final int IncompatibleNonInheritedInterfaceMethod = IrritantSet.GROUP0 | ASTNode.Bit15;
	public static final int UnusedPrivateMember = IrritantSet.GROUP0 | ASTNode.Bit16;
	public static final int LocalVariableHiding = IrritantSet.GROUP0 | ASTNode.Bit17;
	public static final int FieldHiding = IrritantSet.GROUP0 | ASTNode.Bit18;
	public static final int AccidentalBooleanAssign = IrritantSet.GROUP0 | ASTNode.Bit19;
	public static final int EmptyStatement = IrritantSet.GROUP0 | ASTNode.Bit20;
	public static final int MissingJavadocComments  = IrritantSet.GROUP0 | ASTNode.Bit21;
	public static final int MissingJavadocTags = IrritantSet.GROUP0 | ASTNode.Bit22;
	public static final int UnqualifiedFieldAccess = IrritantSet.GROUP0 | ASTNode.Bit23;
	public static final int UnusedDeclaredThrownException = IrritantSet.GROUP0 | ASTNode.Bit24;
	public static final int FinallyBlockNotCompleting = IrritantSet.GROUP0 | ASTNode.Bit25;
	public static final int InvalidJavadoc = IrritantSet.GROUP0 | ASTNode.Bit26;
	public static final int UnnecessaryTypeCheck = IrritantSet.GROUP0 | ASTNode.Bit27;
	public static final int UndocumentedEmptyBlock = IrritantSet.GROUP0 | ASTNode.Bit28;
	public static final int IndirectStaticAccess = IrritantSet.GROUP0 | ASTNode.Bit29;
	
	// group 1
	public static final int UnnecessaryElse  = IrritantSet.GROUP1 | ASTNode.Bit1;
	public static final int UncheckedTypeOperation = IrritantSet.GROUP1 | ASTNode.Bit2;
	public static final int FinalParameterBound = IrritantSet.GROUP1 | ASTNode.Bit3;
	public static final int MissingSerialVersion = IrritantSet.GROUP1 | ASTNode.Bit4;
	public static final int EnumUsedAsAnIdentifier = IrritantSet.GROUP1 | ASTNode.Bit5;
	public static final int ForbiddenReference = IrritantSet.GROUP1 | ASTNode.Bit6;
	public static final int VarargsArgumentNeedCast = IrritantSet.GROUP1 | ASTNode.Bit7;
	public static final int NullReference = IrritantSet.GROUP1 | ASTNode.Bit8;
	public static final int AutoBoxing = IrritantSet.GROUP1 | ASTNode.Bit9;
	public static final int AnnotationSuperInterface = IrritantSet.GROUP1 | ASTNode.Bit10;
	public static final int TypeHiding = IrritantSet.GROUP1 | ASTNode.Bit11;
	public static final int MissingOverrideAnnotation = IrritantSet.GROUP1 | ASTNode.Bit12;
	public static final int IncompleteEnumSwitch = IrritantSet.GROUP1 | ASTNode.Bit13;
	public static final int MissingDeprecatedAnnotation = IrritantSet.GROUP1 | ASTNode.Bit14;
	public static final int DiscouragedReference = IrritantSet.GROUP1 | ASTNode.Bit15;
	public static final int UnhandledWarningToken = IrritantSet.GROUP1 | ASTNode.Bit16;
	public static final int RawTypeReference = IrritantSet.GROUP1 | ASTNode.Bit17;
	public static final int UnusedLabel = IrritantSet.GROUP1 | ASTNode.Bit18;
	public static final int ParameterAssignment = IrritantSet.GROUP1 | ASTNode.Bit19;
	public static final int FallthroughCase = IrritantSet.GROUP1 | ASTNode.Bit20;
	public static final int OverridingMethodWithoutSuperInvocation = IrritantSet.GROUP1 | ASTNode.Bit21;
	public static final int PotentialNullReference = IrritantSet.GROUP1 | ASTNode.Bit22;
	public static final int RedundantNullCheck = IrritantSet.GROUP1 | ASTNode.Bit23;
	public static final int MissingJavadocTagDescription = IrritantSet.GROUP1 | ASTNode.Bit24;
	public static final int UnusedTypeArguments = IrritantSet.GROUP1 | ASTNode.Bit25;
	public static final int UnusedWarningToken = IrritantSet.GROUP1 | ASTNode.Bit26;
	public static final int RedundantSuperinterface = IrritantSet.GROUP1 | ASTNode.Bit27;
	public static final int ComparingIdentical = IrritantSet.GROUP1 | ASTNode.Bit28;
	public static final int MissingSynchronizedModifierInInheritedMethod= IrritantSet.GROUP1 | ASTNode.Bit29;

	// group 2
	// NEXT IRRITANT GOES HERE (group1 is complete already)
	//	public static final int FirstInGroup2 = IrritantSet.GROUP2 | ASTNode.Bit1;
	
	// Map: String optionKey --> Long irritant>
	private static Map OptionToIrritants;

	// Severity level for handlers
	/** 
	 * Defaults defined at {@lnk IrritantSet#COMPILER_DEFAULT_ERRORS} 
	 * @see #resetDefaults()
	 */
	protected IrritantSet errorThreshold;
	/** 
	 * Defaults defined at {@lnk IrritantSet#COMPILER_DEFAULT_WARNINGS}
	 * @see #resetDefaults()
	 */
	protected IrritantSet warningThreshold;
	
	/**
	 * Default settings are to be defined in {@lnk CompilerOptions#resetDefaults()}
	 */
	
	/** Classfile debug information, may contain source file name, line numbers, local variable tables, etc... */
	public int produceDebugAttributes; 
	/** Compliance level for the compiler, refers to a JDK version, e.g. {lnk {@link ClassFileConstants#JDK1_4} */
	public long complianceLevel;
	/** Java source level, refers to a JDK version, e.g. {lnk {@link ClassFileConstants#JDK1_4} */
	public long sourceLevel;
	/** VM target level, refers to a JDK version, e.g. {lnk {@link ClassFileConstants#JDK1_4} */
	public long targetJDK;
	/** Source encoding format */
	public String defaultEncoding;
	/** Compiler trace verbosity */
	public boolean verbose;
	/** Indicates whether reference info is desired */
	public boolean produceReferenceInfo;	
	/** Indicates if unused/optimizable local variables need to be preserved (debugging purpose) */
	public boolean preserveAllLocalVariables;
	/** Indicates whether literal expressions are inlined at parse-time or not */
	public boolean parseLiteralExpressionsAsConstants;
	/** Max problems per compilation unit */
	public int maxProblemsPerUnit;
	/** Tags used to recognize tasks in comments */
	public char[][] taskTags;
	/** Respective priorities of recognized task tags */
	public char[][] taskPriorites;
	/** Indicate whether tag detection is case sensitive or not */
	public boolean isTaskCaseSensitive;
	/** Specify whether deprecation inside deprecated code is to be reported */
	public boolean reportDeprecationInsideDeprecatedCode;
	/** Specify whether override of deprecated method is to be reported */
	public boolean reportDeprecationWhenOverridingDeprecatedMethod;
	/** Specify if should report unused parameter when implementing abstract method */
	public boolean reportUnusedParameterWhenImplementingAbstract;
	/** Specify if should report unused parameter when overriding concrete method */
	public boolean reportUnusedParameterWhenOverridingConcrete;
	/** Specify if should report documented unused parameter (in javadoc) */
	public boolean reportUnusedParameterIncludeDocCommentReference;
	/** Specify if should reported unused declared thrown exception when overriding method */
	public boolean reportUnusedDeclaredThrownExceptionWhenOverriding;
	/** Specify if should reported unused declared thrown exception when documented in javadoc */
	public boolean reportUnusedDeclaredThrownExceptionIncludeDocCommentReference;
	/** Specify if should reported unused declared thrown exception when Exception or Throwable */
	public boolean reportUnusedDeclaredThrownExceptionExemptExceptionAndThrowable;
	/** Specify whether should report constructor/setter method parameter hiding */
	public boolean reportSpecialParameterHidingField;
	/** Master flag controlling whether doc comment should be processed */
	public boolean docCommentSupport;
	/** Specify if invalid javadoc shall be reported */
	public boolean reportInvalidJavadocTags;
	/** Only report invalid javadoc above a given level of visibility of associated construct */
	public int reportInvalidJavadocTagsVisibility;
	/** Specify if deprecated javadoc ref is allowed */
	public boolean reportInvalidJavadocTagsDeprecatedRef;
	/** Specify if non visible javadoc ref is allowed */
	public boolean reportInvalidJavadocTagsNotVisibleRef;
	/** Specify when to report missing javadoc tag description */
	public String reportMissingJavadocTagDescription;
	/** Only report missing javadoc tags above a given level of visibility of associated construct */
	public int reportMissingJavadocTagsVisibility;
	/** Specify if need to flag missing javadoc tags for overriding method */
	public boolean reportMissingJavadocTagsOverriding;
	/** Only report missing javadoc comment above a given level of visibility of associated construct */
	public int reportMissingJavadocCommentsVisibility;
	/** Specify if need to flag missing javadoc comment for overriding method */
	public boolean reportMissingJavadocCommentsOverriding;
	/** Indicate whether the JSR bytecode should be inlined to avoid its presence in classfile */
	public boolean inlineJsrBytecode;
	/** Indicate if @SuppressWarning annotation are activated */
	public boolean suppressWarnings;
	/** Specify if should treat optional error as fatal or just like warning */
	public boolean treatOptionalErrorAsFatal;
	/** Specify if parser should perform structural recovery in methods */
	public boolean performMethodsFullRecovery;
	/** Specify if parser perform statements recovery */
	public boolean performStatementsRecovery;
	/** Control whether annotation processing is enabled */
	public boolean processAnnotations;
	/** Store annotations */
	public boolean storeAnnotations;
	/** Indicate if annotation processing generates classfiles */
	public boolean generateClassFiles;


	// keep in sync with warningTokenToIrritant and warningTokenFromIrritant
	public final static String[] warningTokens = {
		"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$
		"unchecked", //$NON-NLS-1$
		"unqualified-field-access", //$NON-NLS-1$
		"unused", //$NON-NLS-1$
	};

	/**
	 * Return the most specific option key controlling this irritant. Note that in some case, some irritant is controlled by
	 * other master options (e.g. javadoc, deprecation, etc.).
	 * This information is intended for grouping purpose (several problems governed by a rule)
	 */
	public static String optionKeyFromIrritant(int irritant) {
		// keep in sync with warningTokens and warningTokenToIrritant
		switch (irritant) {
			case MethodWithConstructorName :
				return OPTION_ReportMethodWithConstructorName;
			case OverriddenPackageDefaultMethod  :
				return OPTION_ReportOverridingPackageDefaultMethod;
			case UsingDeprecatedAPI :
			case (InvalidJavadoc | UsingDeprecatedAPI) :
				return OPTION_ReportDeprecation;
			case MaskedCatchBlock  :
				return OPTION_ReportHiddenCatchBlock;
			case UnusedLocalVariable :
				return OPTION_ReportUnusedLocal;
			case UnusedArgument :
				return OPTION_ReportUnusedParameter;
			case NoImplicitStringConversion :
				return OPTION_ReportNoImplicitStringConversion;
			case AccessEmulation :
				return OPTION_ReportSyntheticAccessEmulation;
			case NonExternalizedString :
				return OPTION_ReportNonExternalizedStringLiteral;
			case AssertUsedAsAnIdentifier :
				return OPTION_ReportAssertIdentifier;
			case UnusedImport :
				return OPTION_ReportUnusedImport;
			case NonStaticAccessToStatic :
				return OPTION_ReportNonStaticAccessToStatic;
			case Task :
				return OPTION_TaskTags;
			case NoEffectAssignment :
				return OPTION_ReportNoEffectAssignment;
			case IncompatibleNonInheritedInterfaceMethod :
				return OPTION_ReportIncompatibleNonInheritedInterfaceMethod;
			case UnusedPrivateMember :
				return OPTION_ReportUnusedPrivateMember;
			case LocalVariableHiding :
				return OPTION_ReportLocalVariableHiding;
			case FieldHiding :
				return OPTION_ReportFieldHiding;
			case AccidentalBooleanAssign :
				return OPTION_ReportPossibleAccidentalBooleanAssignment;
			case EmptyStatement :
				return OPTION_ReportEmptyStatement;
			case MissingJavadocComments  :
				return OPTION_ReportMissingJavadocComments;
			case MissingJavadocTags :
				return OPTION_ReportMissingJavadocTags;
			case UnqualifiedFieldAccess :
				return OPTION_ReportUnqualifiedFieldAccess;
			case UnusedDeclaredThrownException :
				return OPTION_ReportUnusedDeclaredThrownExceptionWhenOverriding;
			case FinallyBlockNotCompleting :
				return OPTION_ReportFinallyBlockNotCompletingNormally;
			case InvalidJavadoc :
				return OPTION_ReportInvalidJavadoc;
			case UnnecessaryTypeCheck :
				return OPTION_ReportUnnecessaryTypeCheck;
			case UndocumentedEmptyBlock :
				return OPTION_ReportUndocumentedEmptyBlock;
			case IndirectStaticAccess :
				return OPTION_ReportIndirectStaticAccess;
			case UnnecessaryElse  :
				return OPTION_ReportUnnecessaryElse;
			case UncheckedTypeOperation :
				return OPTION_ReportUncheckedTypeOperation;
			case FinalParameterBound :
				return OPTION_ReportFinalParameterBound;
			case MissingSerialVersion :
				return OPTION_ReportMissingSerialVersion ;
			case EnumUsedAsAnIdentifier :
				return OPTION_ReportEnumIdentifier;
			case ForbiddenReference :
				return OPTION_ReportForbiddenReference;
			case VarargsArgumentNeedCast :
				return OPTION_ReportVarargsArgumentNeedCast;
			case NullReference :
				return OPTION_ReportNullReference;
			case PotentialNullReference :
				return OPTION_ReportPotentialNullReference;
			case RedundantNullCheck :
				return OPTION_ReportRedundantNullCheck;
			case AutoBoxing :
				return OPTION_ReportAutoboxing;
			case AnnotationSuperInterface :
				return OPTION_ReportAnnotationSuperInterface;
			case TypeHiding :
				return OPTION_ReportTypeParameterHiding;
			case MissingOverrideAnnotation :
				return OPTION_ReportMissingOverrideAnnotation;
			case IncompleteEnumSwitch :
				return OPTION_ReportIncompleteEnumSwitch;
			case MissingDeprecatedAnnotation :
				return OPTION_ReportMissingDeprecatedAnnotation;
			case DiscouragedReference :
				return OPTION_ReportDiscouragedReference;
			case UnhandledWarningToken :
				return OPTION_ReportUnhandledWarningToken;
			case RawTypeReference :
				return OPTION_ReportRawTypeReference;
			case UnusedLabel :
				return OPTION_ReportUnusedLabel;
			case ParameterAssignment :
				return OPTION_ReportParameterAssignment;
			case FallthroughCase :
				return OPTION_ReportFallthroughCase;
			case OverridingMethodWithoutSuperInvocation :
				return OPTION_ReportOverridingMethodWithoutSuperInvocation;
			case MissingJavadocTagDescription :
				return OPTION_ReportMissingJavadocTagDescription;
			case UnusedTypeArguments :
				return OPTION_ReportUnusedTypeArgumentsForMethodInvocation;
			case UnusedWarningToken :
				return OPTION_ReportUnusedWarningToken;
			case RedundantSuperinterface :
				return OPTION_ReportRedundantSuperinterface;
			case ComparingIdentical :
				return OPTION_ReportComparingIdentical;
			case MissingSynchronizedModifierInInheritedMethod :
				return OPTION_ReportMissingSynchronizedOnInheritedMethod;
		}
		return null;
	}

	public static long optionKeyToIrritant(String optionName) {
		if (OptionToIrritants == null) {
			int group = 0;
			for (int g = 0; g < 8; g++) {
				group <<= 1;
				int index = 0;
				for (int i = 0; i < 30; i++) {
					index <<= 1;
					int irritant = (group<<IrritantSet.GROUP_SHIFT)+index;
					String optionKey = optionKeyFromIrritant(irritant);
					if (optionKey == null) continue;
					OptionToIrritants.put(optionKey, new Integer(irritant));
				}
				
			}
		}
		Long irritant = (Long)OptionToIrritants.get(optionName);
		return irritant == null ? 0 : irritant.longValue();
	}

	public static String versionFromJdkLevel(long jdkLevel) {
		switch ((int)(jdkLevel>>16)) {
			case ClassFileConstants.MAJOR_VERSION_1_1 :
				if (jdkLevel == ClassFileConstants.JDK1_1)
					return VERSION_1_1;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_2 :
				if (jdkLevel == ClassFileConstants.JDK1_2)
					return VERSION_1_2;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_3 :
				if (jdkLevel == ClassFileConstants.JDK1_3)
					return VERSION_1_3;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_4 :
				if (jdkLevel == ClassFileConstants.JDK1_4)
					return VERSION_1_4;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_5 :
				if (jdkLevel == ClassFileConstants.JDK1_5)
					return VERSION_1_5;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_6 :
				if (jdkLevel == ClassFileConstants.JDK1_6)
					return VERSION_1_6;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_7 :
				if (jdkLevel == ClassFileConstants.JDK1_7)
					return VERSION_1_7;
				break;
		}
		return Util.EMPTY_STRING; // unknown version
	}

	public static long versionToJdkLevel(Object versionID) {
		if (versionID instanceof String) {
			String version = (String) versionID;
			// verification is optimized for all versions with same length and same "1." prefix
			if (version.length() == 3 && version.charAt(0) == '1' && version.charAt(1) == '.') {
				switch (version.charAt(2)) {
					case '1':
						return ClassFileConstants.JDK1_1;
					case '2':
						return ClassFileConstants.JDK1_2;
					case '3':
						return ClassFileConstants.JDK1_3;
					case '4':
						return ClassFileConstants.JDK1_4;
					case '5':
						return ClassFileConstants.JDK1_5;
					case '6':
						return ClassFileConstants.JDK1_6;
					case '7':
						return ClassFileConstants.JDK1_7;
					default:
						return 0; // unknown
				}
			}
			if (VERSION_JSR14.equals(versionID)) {
				return ClassFileConstants.JDK1_4;
			}
			if (VERSION_CLDC1_1.equals(versionID)) {
				return ClassFileConstants.CLDC_1_1;
			}
		}
		return 0; // unknown
	}

	/**
	 * Return all warning option names for use as keys in compiler options maps.
	 * @return all warning option names
	 * TODO (maxime) revise for ensuring completeness
	 */
	public static String[] warningOptionNames() {
		String[] result = {
			OPTION_ReportAnnotationSuperInterface,
			OPTION_ReportAssertIdentifier,
			OPTION_ReportAutoboxing,
			OPTION_ReportDeprecation,
			OPTION_ReportDiscouragedReference,
			OPTION_ReportEmptyStatement,
			OPTION_ReportEnumIdentifier,
			OPTION_ReportFallthroughCase,
			OPTION_ReportFieldHiding,
			OPTION_ReportFinalParameterBound,
			OPTION_ReportFinallyBlockNotCompletingNormally,
			OPTION_ReportForbiddenReference,
			OPTION_ReportHiddenCatchBlock,
			OPTION_ReportIncompatibleNonInheritedInterfaceMethod,
			OPTION_ReportIncompleteEnumSwitch,
			OPTION_ReportIndirectStaticAccess,
			OPTION_ReportInvalidJavadoc,
			OPTION_ReportLocalVariableHiding,
			OPTION_ReportMethodWithConstructorName,
			OPTION_ReportMissingDeprecatedAnnotation,
			OPTION_ReportMissingJavadocComments,
			OPTION_ReportMissingJavadocTagDescription,
			OPTION_ReportMissingJavadocTags,
			OPTION_ReportMissingOverrideAnnotation,
			OPTION_ReportMissingSerialVersion,
			OPTION_ReportNoEffectAssignment,
			OPTION_ReportNoImplicitStringConversion,
			OPTION_ReportNonExternalizedStringLiteral,
			OPTION_ReportNonStaticAccessToStatic,
			OPTION_ReportNullReference,
			OPTION_ReportPotentialNullReference,
			OPTION_ReportRedundantNullCheck,
			OPTION_ReportRedundantSuperinterface,
			OPTION_ReportOverridingPackageDefaultMethod,
			OPTION_ReportParameterAssignment,
			OPTION_ReportPossibleAccidentalBooleanAssignment,
			OPTION_ReportSyntheticAccessEmulation,
			OPTION_ReportTypeParameterHiding,
			OPTION_ReportUncheckedTypeOperation,
			OPTION_ReportUndocumentedEmptyBlock,
			OPTION_ReportUnnecessaryElse,
			OPTION_ReportUnnecessaryTypeCheck,
			OPTION_ReportUnqualifiedFieldAccess,
			OPTION_ReportUnusedDeclaredThrownException,
			OPTION_ReportUnusedImport,
			OPTION_ReportUnusedLocal,
			OPTION_ReportUnusedParameter,
			OPTION_ReportUnusedPrivateMember,
			OPTION_ReportVarargsArgumentNeedCast,
			OPTION_ReportUnhandledWarningToken,
			OPTION_ReportUnusedWarningToken,
			OPTION_ReportOverridingMethodWithoutSuperInvocation,
			OPTION_ReportUnusedTypeArgumentsForMethodInvocation,
		};
		return result;
	}

	/**
	 * For suppressable warnings
	 */
	public static String warningTokenFromIrritant(int irritant) {
		// keep in sync with warningTokens and warningTokenToIrritant
		switch (irritant) {
			case (InvalidJavadoc | UsingDeprecatedAPI) :
			case UsingDeprecatedAPI :
				return "deprecation"; //$NON-NLS-1$
			case FinallyBlockNotCompleting :
				return "finally"; //$NON-NLS-1$
			case FieldHiding :
			case LocalVariableHiding :
			case MaskedCatchBlock :
				return "hiding"; //$NON-NLS-1$
			case NonExternalizedString :
				return "nls"; //$NON-NLS-1$
			case UnnecessaryTypeCheck :
				return "cast"; //$NON-NLS-1$
			case UnusedLocalVariable :
			case UnusedArgument :
			case UnusedImport :
			case UnusedPrivateMember :
			case UnusedDeclaredThrownException :
				return "unused"; //$NON-NLS-1$
			case IndirectStaticAccess :
			case NonStaticAccessToStatic :
				return "static-access"; //$NON-NLS-1$
			case AccessEmulation :
				return "synthetic-access"; //$NON-NLS-1$
			case UnqualifiedFieldAccess :
				return "unqualified-field-access"; //$NON-NLS-1$
			case UncheckedTypeOperation :
				return "unchecked"; //$NON-NLS-1$
			case MissingSerialVersion :
				return "serial"; //$NON-NLS-1$
			case AutoBoxing :
				return "boxing"; //$NON-NLS-1$
			case TypeHiding :
				return "hiding"; //$NON-NLS-1$
			case IncompleteEnumSwitch :
				return "incomplete-switch"; //$NON-NLS-1$
			case MissingDeprecatedAnnotation :
				return "dep-ann"; //$NON-NLS-1$
			case RawTypeReference :
				return "unchecked"; //$NON-NLS-1$
			case UnusedLabel :
			case UnusedTypeArguments :
			case RedundantSuperinterface :
				return "unused"; //$NON-NLS-1$
			case DiscouragedReference :
			case ForbiddenReference :
				return "restriction"; //$NON-NLS-1$
			case NullReference :
			case PotentialNullReference :
			case RedundantNullCheck :
				return "null"; //$NON-NLS-1$
			case FallthroughCase :
				return "fallthrough"; //$NON-NLS-1$
			case OverridingMethodWithoutSuperInvocation :
				return "super"; //$NON-NLS-1$
		}
		return null;
	}

	public static IrritantSet warningTokenToIrritants(String warningToken) {
		// keep in sync with warningTokens and warningTokenFromIrritant
		if (warningToken == null || warningToken.length() == 0) return null;
		switch (warningToken.charAt(0)) {
			case 'a' :
				if ("all".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.ALL;
				break;
			case 'b' :
				if ("boxing".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.BOXING;
				break;
			case 'c' :
				if ("cast".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.CAST;
				break;
			case 'd' :
				if ("deprecation".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.DEPRECATION;
				if ("dep-ann".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.DEP_ANN;
				break;
			case 'f' :
				if ("fallthrough".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.FALLTHROUGH;
				if ("finally".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.FINALLY;
				break;
			case 'h' :
				if ("hiding".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.HIDING;
			case 'i' :
				if ("incomplete-switch".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.INCOMPLETE_SWITCH;
				break;
			case 'n' :
				if ("nls".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.NLS;
				if ("null".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.NULL;
				break;
			case 'r' :
				if ("restriction".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.RESTRICTION;
				break;
			case 's' :
				if ("serial".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.SERIAL;
				if ("static-access".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.STATIC_ACCESS;
				if ("synthetic-access".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.SYNTHETIC_ACCESS;
				if ("super".equals(warningToken)) { //$NON-NLS-1$
					return IrritantSet.SUPER;
				}
				break;
			case 'u' :
				if ("unused".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.UNUSED;
				if ("unchecked".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.UNCHECKED;
				if ("unqualified-field-access".equals(warningToken)) //$NON-NLS-1$
					return IrritantSet.UNQUALIFIED_FIELD_ACCESS;
				break;
		}
		return null;
	}

	/**
	 * Initializing the compiler options with defaults
	 */
	public CompilerOptions(){
		this(null); // use default options
	}

	/**

	 * @param settings
	 */
	public CompilerOptions(Map settings){
		resetDefaults();
		if (settings != null) {
			set(settings);
		}
	}

	/**

		this.parseLiteralExpressionsAsConstants = parseLiteralExpressionsAsConstants;
	}

	
	public Map getMap() {
		Map optionsMap = new HashMap(30);
		optionsMap.put(OPTION_LocalVariableAttribute, (this.produceDebugAttributes & ClassFileConstants.ATTR_VARS) != 0 ? GENERATE : DO_NOT_GENERATE);

		return optionsMap;
	}

	public int getSeverity(int irritant) {
		if (this.errorThreshold.isSet(irritant)) {
			if ((irritant & (IrritantSet.GROUP_MASK | UnusedWarningToken)) == UnusedWarningToken) {
	 * This information is intended for grouping purpose (several problems governed by a rule)
	 */
	public static String optionKeyFromIrritant(long irritant) {
		// keep in sync with warningTokens and warningTokenToIrritant
		int irritantInt = (int) irritant;
		if (irritantInt == irritant) {
			switch (irritantInt) {
				case (int) MethodWithConstructorName :
					return OPTION_ReportMethodWithConstructorName;
				case (int) OverriddenPackageDefaultMethod  :
					return OPTION_ReportOverridingPackageDefaultMethod;
				case (int) UsingDeprecatedAPI :
				case (int) (InvalidJavadoc | UsingDeprecatedAPI) :
					return OPTION_ReportDeprecation;
				case (int) MaskedCatchBlock  :
					return OPTION_ReportHiddenCatchBlock;
				case (int) UnusedLocalVariable :
					return OPTION_ReportUnusedLocal;
				case (int) UnusedArgument :
					return OPTION_ReportUnusedParameter;
				case (int) NoImplicitStringConversion :
					return OPTION_ReportNoImplicitStringConversion;
				case (int) AccessEmulation :
					return OPTION_ReportSyntheticAccessEmulation;
				case (int) NonExternalizedString :
					return OPTION_ReportNonExternalizedStringLiteral;
				case (int) AssertUsedAsAnIdentifier :
					return OPTION_ReportAssertIdentifier;
				case (int) UnusedImport :
					return OPTION_ReportUnusedImport;
				case (int) NonStaticAccessToStatic :
					return OPTION_ReportNonStaticAccessToStatic;
				case (int) Task :
					return OPTION_TaskTags;
				case (int) NoEffectAssignment :
					return OPTION_ReportNoEffectAssignment;
				case (int) IncompatibleNonInheritedInterfaceMethod :
					return OPTION_ReportIncompatibleNonInheritedInterfaceMethod;
				case (int) UnusedPrivateMember :
					return OPTION_ReportUnusedPrivateMember;
				case (int) LocalVariableHiding :
					return OPTION_ReportLocalVariableHiding;
				case (int) FieldHiding :
					return OPTION_ReportFieldHiding;
				case (int) AccidentalBooleanAssign :
					return OPTION_ReportPossibleAccidentalBooleanAssignment;
				case (int) EmptyStatement :
					return OPTION_ReportEmptyStatement;
				case (int) MissingJavadocComments  :
					return OPTION_ReportMissingJavadocComments;
				case (int) MissingJavadocTags :
					return OPTION_ReportMissingJavadocTags;
				case (int) UnqualifiedFieldAccess :
					return OPTION_ReportUnqualifiedFieldAccess;
				case (int) UnusedDeclaredThrownException :
					return OPTION_ReportUnusedDeclaredThrownExceptionWhenOverriding;
				case (int) FinallyBlockNotCompleting :
					return OPTION_ReportFinallyBlockNotCompletingNormally;
				case (int) InvalidJavadoc :
					return OPTION_ReportInvalidJavadoc;
				case (int) UnnecessaryTypeCheck :
					return OPTION_ReportUnnecessaryTypeCheck;
				case (int) UndocumentedEmptyBlock :
					return OPTION_ReportUndocumentedEmptyBlock;
				case (int) IndirectStaticAccess :
					return OPTION_ReportIndirectStaticAccess;
				case (int) UnnecessaryElse  :
					return OPTION_ReportUnnecessaryElse;
				case (int) UncheckedTypeOperation :
					return OPTION_ReportUncheckedTypeOperation;
				case (int) FinalParameterBound :
					return OPTION_ReportFinalParameterBound;
			}
		} else {
			irritantInt = (int)(irritant >>> 32);
			switch (irritantInt) {
				case (int)(MissingSerialVersion >>> 32) :
					return OPTION_ReportMissingSerialVersion ;
				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_ReportPotentialNullReference;
				case (int)(RedundantNullCheck >>> 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) :
					return OPTION_ReportUnusedLabel;
				case (int)(ParameterAssignment>>> 32) :
					return OPTION_ReportParameterAssignment;
				case (int)(FallthroughCase >>> 32) :
					return OPTION_ReportFallthroughCase;
				case (int)(OverridingMethodWithoutSuperInvocation >>> 32) :
					return OPTION_ReportOverridingMethodWithoutSuperInvocation;
				case (int)(MissingJavadocTagDescription >>> 32):
					return OPTION_ReportMissingJavadocTagDescription;
				case (int)(UnusedTypeArguments >>> 32):
					return OPTION_ReportUnusedTypeArgumentsForMethodInvocation;
				case (int)(UnusedWarningToken >>> 32) :
					return OPTION_ReportUnusedWarningToken;
				case (int)(RedundantSuperinterface >>> 32) :
					return OPTION_ReportRedundantSuperinterface;
				case (int)(ComparingIdentical >>> 32) :
					return OPTION_ReportComparingIdentical;
				case (int)(MissingSynchronizedModifierInInheritedMethod >>> 32) :
					return OPTION_ReportMissingSynchronizedOnInheritedMethod;
			}
		}
		return null;
	}

	public static long optionKeyToIrritant(String optionName) {
		if (OptionToIrritants == null) {
			long irritant = 0;
			for (int i = 0; i < 64; i++) {
				irritant <<= 1;
				String optionKey = optionKeyFromIrritant(irritant);
				if (optionKey == null) continue;
				OptionToIrritants.put(optionKey, new Long(irritant));
			}
		}
		Long irritant = (Long)OptionToIrritants.get(optionName);
		return irritant == null ? 0 : irritant.longValue();
	}

	public int getSeverity(long irritant) {
		if((this.errorThreshold & irritant) != 0) {
			if ((irritant & UnusedWarningToken) != 0) {
				return ProblemSeverities.Error | ProblemSeverities.Optional; // cannot be treated as fatal - codegen already occurred
			}
			return this.treatOptionalErrorAsFatal
				? ProblemSeverities.Error | ProblemSeverities.Optional | ProblemSeverities.Fatal
				: ProblemSeverities.Error | ProblemSeverities.Optional;
		}
		if (this.warningThreshold.isSet(irritant)) {
			return ProblemSeverities.Warning | ProblemSeverities.Optional;
		}
		return ProblemSeverities.Ignore;
	}

	public String getSeverityString(int irritant) {
		if(this.errorThreshold.isSet(irritant))
			return ERROR;
		if(this.warningThreshold.isSet(irritant))
			return WARNING;
		return IGNORE;
	}

	public String getVisibilityString(int level) {
		switch (level & ExtraCompilerModifiers.AccVisibilityMASK) {
			case ClassFileConstants.AccPublic:

		}
	}

	public boolean isAnyEnabled(IrritantSet irritants) {
		return this.warningThreshold.isAnySet(irritants) || this.errorThreshold.isAnySet(irritants);
	}

	protected void resetDefaults() {
		// problem default severities defined on IrritantSet
		this.errorThreshold = new IrritantSet(IrritantSet.COMPILER_DEFAULT_ERRORS);
		this.warningThreshold = new IrritantSet(IrritantSet.COMPILER_DEFAULT_WARNINGS);
		
		// by default only lines and source attributes are generated.
		this.produceDebugAttributes = ClassFileConstants.ATTR_SOURCE | ClassFileConstants.ATTR_LINES;
		this.complianceLevel = ClassFileConstants.JDK1_4; // by default be compliant with 1.4
		this.sourceLevel = ClassFileConstants.JDK1_3; //1.3 source behavior by default
		this.targetJDK = ClassFileConstants.JDK1_2; // default generates for JVM1.2

		this.defaultEncoding = null; // will use the platform default encoding

		// print what unit is being processed
		this.verbose = Compiler.DEBUG;

		this.produceReferenceInfo = false; // no reference info by default

		// indicates if unused/optimizable local variables need to be preserved (debugging purpose)
		this.preserveAllLocalVariables = false;

		// indicates whether literal expressions are inlined at parse-time or not
		this.parseLiteralExpressionsAsConstants = true;

		// max problems per compilation unit
		this.maxProblemsPerUnit = 100; // no more than 100 problems per default

		// tags used to recognize tasks in comments
		this.taskTags = null;
		this.taskPriorites = null;
		this.isTaskCaseSensitive = true;

		// deprecation report
		this.reportDeprecationInsideDeprecatedCode = false;
		this.reportDeprecationWhenOverridingDeprecatedMethod = false;
		
		// unused parameters report
		this.reportUnusedParameterWhenImplementingAbstract = false;
		this.reportUnusedParameterWhenOverridingConcrete = false;
		this.reportUnusedParameterIncludeDocCommentReference = true;
		
		// unused declaration of thrown exception
		this.reportUnusedDeclaredThrownExceptionWhenOverriding = false;
		this.reportUnusedDeclaredThrownExceptionIncludeDocCommentReference = true;
		this.reportUnusedDeclaredThrownExceptionExemptExceptionAndThrowable = true;
		
		// constructor/setter parameter hiding
		this.reportSpecialParameterHidingField = false;

		// check javadoc comments tags
		this.reportInvalidJavadocTagsVisibility = ClassFileConstants.AccPublic;
		this.reportInvalidJavadocTags = false;
		this.reportInvalidJavadocTagsDeprecatedRef = false;
		this.reportInvalidJavadocTagsNotVisibleRef = false;
		this.reportMissingJavadocTagDescription = RETURN_TAG;
		
		// check missing javadoc tags
		this.reportMissingJavadocTagsVisibility = ClassFileConstants.AccPublic;
		this.reportMissingJavadocTagsOverriding = false;

		// check missing javadoc comments
		this.reportMissingJavadocCommentsVisibility = ClassFileConstants.AccPublic;
		this.reportMissingJavadocCommentsOverriding = false;
		
		// JSR bytecode inlining
		this.inlineJsrBytecode = false;

		// javadoc comment support
		this.docCommentSupport = false;

		// suppress warning annotation
		this.suppressWarnings = true;

		// treat optional error as fatal or just like warning?
		this.treatOptionalErrorAsFatal = true;

		// parser perform statements recovery
		this.performMethodsFullRecovery = true;

		// parser perform statements recovery
		this.performStatementsRecovery = true;

		// store annotations
		this.storeAnnotations = false;

		// annotation processing
		this.generateClassFiles = true;

		// enable annotation processing by default only in batch mode
		this.processAnnotations = false;
	}

	public void set(Map optionsMap) {
		Object optionValue;
		if ((optionValue = optionsMap.get(OPTION_LocalVariableAttribute)) != null) {

			}
		}
	}

	public String toString() {

		StringBuffer buf = new StringBuffer("CompilerOptions:"); //$NON-NLS-1$
		buf.append("\n\t- local variables debug attributes: ").append((this.produceDebugAttributes & ClassFileConstants.ATTR_VARS) != 0 ? "ON" : " OFF"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		buf.append("\n\t- line number debug attributes: ").append((this.produceDebugAttributes & ClassFileConstants.ATTR_LINES) != 0 ? "ON" : " OFF"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		buf.append("\n\t- missing synchronized on inherited method: ").append(getSeverityString(MissingSynchronizedModifierInInheritedMethod)); //$NON-NLS-1$
		return buf.toString();
	}
	
	protected void updateSeverity(int irritant, Object severityString) {
		if (ERROR.equals(severityString)) {
			this.errorThreshold.set(irritant);
			this.warningThreshold.clear(irritant);
		} else if (WARNING.equals(severityString)) {
			this.errorThreshold.clear(irritant);
			this.warningThreshold.set(irritant);
		} else if (IGNORE.equals(severityString)) {
			this.errorThreshold.clear(irritant);
			this.warningThreshold.clear(irritant);
		}
	}
	public static long versionToJdkLevel(Object versionID) {
		if (versionID instanceof String) {
			String version = (String) versionID;
			// verification is optimized for all versions with same length and same "1." prefix
			if (version.length() == 3 && version.charAt(0) == '1' && version.charAt(1) == '.') {
				switch (version.charAt(2)) {
					case '1':
						return ClassFileConstants.JDK1_1;
					case '2':
						return ClassFileConstants.JDK1_2;
					case '3':
						return ClassFileConstants.JDK1_3;
					case '4':
						return ClassFileConstants.JDK1_4;
					case '5':
						return ClassFileConstants.JDK1_5;
					case '6':
						return ClassFileConstants.JDK1_6;
					case '7':
						return ClassFileConstants.JDK1_7;
					default:
						return 0; // unknown
				}
			}
			if (VERSION_JSR14.equals(versionID)) {
				return ClassFileConstants.JDK1_4;
			}
			if (VERSION_CLDC1_1.equals(versionID)) {
				return ClassFileConstants.CLDC_1_1;
			}
		}
		return 0; // unknown
	}

	public static String versionFromJdkLevel(long jdkLevel) {
		switch ((int)(jdkLevel>>16)) {
			case ClassFileConstants.MAJOR_VERSION_1_1 :
				if (jdkLevel == ClassFileConstants.JDK1_1)
					return VERSION_1_1;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_2 :
				if (jdkLevel == ClassFileConstants.JDK1_2)
					return VERSION_1_2;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_3 :
				if (jdkLevel == ClassFileConstants.JDK1_3)
					return VERSION_1_3;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_4 :
				if (jdkLevel == ClassFileConstants.JDK1_4)
					return VERSION_1_4;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_5 :
				if (jdkLevel == ClassFileConstants.JDK1_5)
					return VERSION_1_5;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_6 :
				if (jdkLevel == ClassFileConstants.JDK1_6)
					return VERSION_1_6;
				break;
			case ClassFileConstants.MAJOR_VERSION_1_7 :
				if (jdkLevel == ClassFileConstants.JDK1_7)
					return VERSION_1_7;
				break;
		}
		return Util.EMPTY_STRING; // unknown version
	}

	/**
	 * Return all warning option names for use as keys in compiler options maps.
	 * @return all warning option names
	 * TODO (maxime) revise for ensuring completeness
	 */
	public static String[] warningOptionNames() {
		String[] result = {
			OPTION_ReportAnnotationSuperInterface,
			OPTION_ReportAssertIdentifier,
			OPTION_ReportAutoboxing,
			OPTION_ReportDeprecation,
			OPTION_ReportDiscouragedReference,
			OPTION_ReportEmptyStatement,
			OPTION_ReportEnumIdentifier,
			OPTION_ReportFallthroughCase,
			OPTION_ReportFieldHiding,
			OPTION_ReportFinalParameterBound,
			OPTION_ReportFinallyBlockNotCompletingNormally,
			OPTION_ReportForbiddenReference,
			OPTION_ReportHiddenCatchBlock,
			OPTION_ReportIncompatibleNonInheritedInterfaceMethod,
			OPTION_ReportIncompleteEnumSwitch,
			OPTION_ReportIndirectStaticAccess,
			OPTION_ReportInvalidJavadoc,
			OPTION_ReportLocalVariableHiding,
			OPTION_ReportMethodWithConstructorName,
			OPTION_ReportMissingDeprecatedAnnotation,
			OPTION_ReportMissingJavadocComments,
			OPTION_ReportMissingJavadocTagDescription,
			OPTION_ReportMissingJavadocTags,
			OPTION_ReportMissingOverrideAnnotation,
			OPTION_ReportMissingSerialVersion,
			OPTION_ReportNoEffectAssignment,
			OPTION_ReportNoImplicitStringConversion,
			OPTION_ReportNonExternalizedStringLiteral,
			OPTION_ReportNonStaticAccessToStatic,
			OPTION_ReportNullReference,
			OPTION_ReportPotentialNullReference,
			OPTION_ReportRedundantNullCheck,
			OPTION_ReportRedundantSuperinterface,
			OPTION_ReportOverridingPackageDefaultMethod,
			OPTION_ReportParameterAssignment,
			OPTION_ReportPossibleAccidentalBooleanAssignment,
			OPTION_ReportSyntheticAccessEmulation,
			OPTION_ReportTypeParameterHiding,
			OPTION_ReportUncheckedTypeOperation,
			OPTION_ReportUndocumentedEmptyBlock,
			OPTION_ReportUnnecessaryElse,
			OPTION_ReportUnnecessaryTypeCheck,
			OPTION_ReportUnqualifiedFieldAccess,
			OPTION_ReportUnusedDeclaredThrownException,
			OPTION_ReportUnusedImport,
			OPTION_ReportUnusedLocal,
			OPTION_ReportUnusedParameter,
			OPTION_ReportUnusedPrivateMember,
			OPTION_ReportVarargsArgumentNeedCast,
			OPTION_ReportUnhandledWarningToken,
			OPTION_ReportUnusedWarningToken,
			OPTION_ReportOverridingMethodWithoutSuperInvocation,
			OPTION_ReportUnusedTypeArgumentsForMethodInvocation,
		};
		return result;
	}

	/**
	 * For suppressable warnings
	 */
	public static String warningTokenFromIrritant(long irritant) {
		// keep in sync with warningTokens and warningTokenToIrritant
		int irritantInt = (int) irritant;
		if (irritantInt == irritant) {
			switch (irritantInt) {
				case (int) (InvalidJavadoc | UsingDeprecatedAPI) :
				case (int) UsingDeprecatedAPI :
					return "deprecation"; //$NON-NLS-1$
				case (int) FinallyBlockNotCompleting :
					return "finally"; //$NON-NLS-1$
				case (int) FieldHiding :
				case (int) LocalVariableHiding :
				case (int) MaskedCatchBlock :
					return "hiding"; //$NON-NLS-1$
				case (int) NonExternalizedString :
					return "nls"; //$NON-NLS-1$
				case (int) UnnecessaryTypeCheck :
					return "cast"; //$NON-NLS-1$
				case (int) UnusedLocalVariable :
				case (int) UnusedArgument :
				case (int) UnusedImport :
				case (int) UnusedPrivateMember:
				case (int) UnusedDeclaredThrownException:
					return "unused"; //$NON-NLS-1$
				case (int) IndirectStaticAccess :
				case (int) NonStaticAccessToStatic :
					return "static-access"; //$NON-NLS-1$
				case (int) AccessEmulation :
					return "synthetic-access"; //$NON-NLS-1$
				case (int) UnqualifiedFieldAccess :
					return "unqualified-field-access"; //$NON-NLS-1$
				case (int) UncheckedTypeOperation :
					return "unchecked"; //$NON-NLS-1$
			}
		} else {
			irritantInt = (int)(irritant >>> 32);
			switch (irritantInt) {
				case (int)(MissingSerialVersion >>> 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):
				case (int) (UnusedTypeArguments >>> 32) :
				case (int) (RedundantSuperinterface >>> 32) :
					return "unused"; //$NON-NLS-1$
				case (int) (DiscouragedReference >>> 32) :
				case (int) (ForbiddenReference >>> 32) :
					return "restriction"; //$NON-NLS-1$
				case (int) (NullReference >>> 32) :
				case (int) (PotentialNullReference >>> 32) :
				case (int) (RedundantNullCheck >>> 32) :
					return "null"; //$NON-NLS-1$
				case (int) (FallthroughCase >>> 32) :
					return "fallthrough"; //$NON-NLS-1$
				case (int) (OverridingMethodWithoutSuperInvocation >>> 32) :
					return "super"; //$NON-NLS-1$
			}
		}
		return null;
	}
	// keep in sync with warningTokenToIrritant and warningTokenFromIrritant
	public final static String[] warningTokens = {
		"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$
		"unchecked", //$NON-NLS-1$
		"unqualified-field-access", //$NON-NLS-1$
		"unused", //$NON-NLS-1$
	};
	
	public static long warningTokenToIrritants(String warningToken) {
		// keep in sync with warningTokens and warningTokenFromIrritant
		if (warningToken == null || warningToken.length() == 0) return 0;
		switch (warningToken.charAt(0)) {
			case 'a' :
				if ("all".equals(warningToken)) //$NON-NLS-1$
					return 0xFFFFFFFFFFFFFFFFl; // suppress all warnings
				break;
			case 'b' :
				if ("boxing".equals(warningToken)) //$NON-NLS-1$
					return AutoBoxing;
				break;
			case 'c' :
				if ("cast".equals(warningToken)) //$NON-NLS-1$
					return UnnecessaryTypeCheck;
				break;
			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$
					return FallthroughCase;
				if ("finally".equals(warningToken)) //$NON-NLS-1$
					return FinallyBlockNotCompleting;
				break;
			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 NonExternalizedString;
				if ("null".equals(warningToken)) //$NON-NLS-1$
					return NullReference | PotentialNullReference | RedundantNullCheck;
				break;
			case 'r' :
				if ("restriction".equals(warningToken)) //$NON-NLS-1$
					return DiscouragedReference | ForbiddenReference;
				break;
			case 's' :
				if ("serial".equals(warningToken)) //$NON-NLS-1$
					return MissingSerialVersion;
				if ("static-access".equals(warningToken)) //$NON-NLS-1$
					return IndirectStaticAccess | NonStaticAccessToStatic;
				if ("synthetic-access".equals(warningToken)) //$NON-NLS-1$
					return AccessEmulation;
				if ("super".equals(warningToken)) { //$NON-NLS-1$
					return OverridingMethodWithoutSuperInvocation;
				}
				break;
			case 'u' :
				if ("unused".equals(warningToken)) //$NON-NLS-1$
					return UnusedLocalVariable | UnusedArgument | UnusedPrivateMember | UnusedDeclaredThrownException | UnusedLabel | UnusedImport | UnusedTypeArguments | RedundantSuperinterface;
				if ("unchecked".equals(warningToken)) //$NON-NLS-1$
					return UncheckedTypeOperation | RawTypeReference;
				if ("unqualified-field-access".equals(warningToken)) //$NON-NLS-1$
					return UnqualifiedFieldAccess;
				break;
		}
		return 0;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.compiler.impl;

import org.eclipse.jdt.internal.compiler.ast.ASTNode;

/**
 * Represent a set of irritant flags. Irritants are organized in up to 8 group
 * of 29, allowing for a maximum of 232 distinct irritants.
 */
public class IrritantSet {

	// Reserve two high bits for selecting the right bit pattern
	public final static int GROUP_MASK = ASTNode.Bit32 | ASTNode.Bit31 | ASTNode.Bit30;
	public final static int GROUP_SHIFT = 29;
	public final static int GROUP_MAX = 3; // can be increased up to 8

	// Group prefix for irritants
	public final static int GROUP0 = 0 << GROUP_SHIFT;
	public final static int GROUP1 = 1 << GROUP_SHIFT;
	public final static int GROUP2 = 2 << GROUP_SHIFT;
	// reveal subsequent groups as needed
	// public final static int GROUP3 = 3 << GROUP_SHIFT;
	// public final static int GROUP4 = 4 << GROUP_SHIFT;
	// public final static int GROUP5 = 5 << GROUP_SHIFT;
	// public final static int GROUP6 = 6 << GROUP_SHIFT;
	// public final static int GROUP7 = 7 << GROUP_SHIFT;

	// Predefine sets of irritants matching warning tokens
	public static final IrritantSet ALL = new IrritantSet(
			0xFFFFFFFF & ~GROUP_MASK);
	public static final IrritantSet BOXING = new IrritantSet(
			CompilerOptions.AutoBoxing);
	public static final IrritantSet CAST = new IrritantSet(
			CompilerOptions.UnnecessaryTypeCheck);
	public static final IrritantSet DEPRECATION = new IrritantSet(
			CompilerOptions.UsingDeprecatedAPI);
	public static final IrritantSet DEP_ANN = new IrritantSet(
			CompilerOptions.MissingDeprecatedAnnotation);
	public static final IrritantSet FALLTHROUGH = new IrritantSet(
			CompilerOptions.FallthroughCase);
	public static final IrritantSet FINALLY = new IrritantSet(
			CompilerOptions.FinallyBlockNotCompleting);
	public static final IrritantSet HIDING = new IrritantSet(
			CompilerOptions.MaskedCatchBlock); // further scenarii in static
												// initializer
	public static final IrritantSet INCOMPLETE_SWITCH = new IrritantSet(
			CompilerOptions.IncompleteEnumSwitch);
	public static final IrritantSet NLS = new IrritantSet(
			CompilerOptions.NonExternalizedString);
	public static final IrritantSet NULL = new IrritantSet(
			CompilerOptions.NullReference); // further scenarii in static
											// initializer
	public static final IrritantSet RESTRICTION = new IrritantSet(
			CompilerOptions.ForbiddenReference); // further scenarii in static
													// initializer
	public static final IrritantSet SERIAL = new IrritantSet(
			CompilerOptions.MissingSerialVersion);
	public static final IrritantSet STATIC_ACCESS = new IrritantSet(
			CompilerOptions.IndirectStaticAccess); // further scenarii in static
													// initializer
	public static final IrritantSet SYNTHETIC_ACCESS = new IrritantSet(
			CompilerOptions.AccessEmulation);
	public static final IrritantSet SUPER = new IrritantSet(
			CompilerOptions.OverridingMethodWithoutSuperInvocation);
	public static final IrritantSet UNUSED = new IrritantSet(
			CompilerOptions.UnusedLocalVariable); // further scenarii in static
													// initializer
	public static final IrritantSet UNCHECKED = new IrritantSet(
			CompilerOptions.UncheckedTypeOperation); // further scenarii in
														// static initializer
	public static final IrritantSet UNQUALIFIED_FIELD_ACCESS = new IrritantSet(
			CompilerOptions.UnqualifiedFieldAccess);

	public static final IrritantSet COMPILER_DEFAULT_ERRORS = new IrritantSet(0); // no optional error by default	
	public static final IrritantSet COMPILER_DEFAULT_WARNINGS = new IrritantSet(0); // see static initializer below
	static {
		COMPILER_DEFAULT_WARNINGS
			// group-0 warnings enabled by default
			.set(
				CompilerOptions.MethodWithConstructorName
				| CompilerOptions.OverriddenPackageDefaultMethod
				| CompilerOptions.UsingDeprecatedAPI
				| CompilerOptions.MaskedCatchBlock
				| CompilerOptions.UnusedLocalVariable
				| CompilerOptions.NoImplicitStringConversion
				| CompilerOptions.AssertUsedAsAnIdentifier
				| CompilerOptions.UnusedImport
				| CompilerOptions.NonStaticAccessToStatic
				| CompilerOptions.NoEffectAssignment
				| CompilerOptions.IncompatibleNonInheritedInterfaceMethod
				| CompilerOptions.UnusedPrivateMember
				| CompilerOptions.FinallyBlockNotCompleting)
			// group-1 warnings enabled by default
			.set(
				CompilerOptions.UncheckedTypeOperation
				| CompilerOptions.FinalParameterBound
				| CompilerOptions.MissingSerialVersion
				| CompilerOptions.EnumUsedAsAnIdentifier
				| CompilerOptions.ForbiddenReference
				| CompilerOptions.VarargsArgumentNeedCast
				| CompilerOptions.NullReference
				| CompilerOptions.AnnotationSuperInterface
				| CompilerOptions.TypeHiding
				| CompilerOptions.DiscouragedReference
				| CompilerOptions.UnhandledWarningToken
				| CompilerOptions.RawTypeReference
				| CompilerOptions.UnusedLabel
				| CompilerOptions.UnusedTypeArguments
				| CompilerOptions.UnusedWarningToken
				| CompilerOptions.ComparingIdentical
				| CompilerOptions.MissingSynchronizedModifierInInheritedMethod);
			// group-2 warnings enabled by default
			// next irritant goes here (group-1 is complete)						
			
		ALL.setAll();
		HIDING
			.set(CompilerOptions.FieldHiding)
			.set(CompilerOptions.LocalVariableHiding)
			.set(CompilerOptions.TypeHiding);
		NULL
			.set(CompilerOptions.PotentialNullReference)
			.set(CompilerOptions.RedundantNullCheck);
		RESTRICTION.set(CompilerOptions.DiscouragedReference);
		STATIC_ACCESS.set(CompilerOptions.NonStaticAccessToStatic);
		UNUSED
			.set(CompilerOptions.UnusedArgument)
			.set(CompilerOptions.UnusedPrivateMember)
			.set(CompilerOptions.UnusedDeclaredThrownException)
			.set(CompilerOptions.UnusedLabel)
			.set(CompilerOptions.UnusedImport)
			.set(CompilerOptions.UnusedTypeArguments)
			.set(CompilerOptions.RedundantSuperinterface);
		UNCHECKED.set(CompilerOptions.RawTypeReference);
	}

	// Internal state
	private int[] bits = new int[GROUP_MAX];

	/**
	 * Constructor with initial irritant set
	 */
	public IrritantSet(int singleGroupIrritants) {
		initialize(singleGroupIrritants);
	}

	/**
	 * Constructor with initial irritant set
	 */
	public IrritantSet(IrritantSet other) {
		initialize(other);
	}

	public boolean areAllSet() {
		for (int i = 0; i < GROUP_MAX; i++) {
			if (this.bits[i] != (0xFFFFFFFF & ~GROUP_MASK))
				return false;
		}
		return true;
	}

	public IrritantSet clear(int singleGroupIrritants) {
		int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
		this.bits[group] &= ~singleGroupIrritants;
		return this;
	}

	public IrritantSet clearAll() {
		for (int i = 0; i < GROUP_MAX; i++) {
			this.bits[i] = 0;
		}
		return this;
	}

	/**
	 * Initialize a set of irritants in one group
	 * 
	 * @param singleGroupIrritants
	 */
	public void initialize(int singleGroupIrritants) {
		if (singleGroupIrritants == 0)
			return;
		int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
		this.bits[group] = singleGroupIrritants & ~GROUP_MASK; // erase group information
	}

	public void initialize(IrritantSet other) {
		if (other == null)
			return;
		System.arraycopy(other.bits, 0, this.bits = new int[GROUP_MAX], 0, GROUP_MAX);
	}

	/**
	 * Returns true if any of the irritants in given other set is positionned in receiver
	 * @param other
	 */
	public boolean isAnySet(IrritantSet other) {
		if (other == null)
			return false;
		for (int i = 0; i < GROUP_MAX; i++) {
			if ((this.bits[i] & other.bits[i]) != 0)
				return true;
		}
		return false;
	}

	public boolean isSet(int singleGroupIrritants) {
		int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
		return (this.bits[group] & singleGroupIrritants) != 0;
	}

	public IrritantSet set(int singleGroupIrritants) {
		int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
		this.bits[group] |= (singleGroupIrritants & ~GROUP_MASK); // erase the group bits
		return this;
	}

	/**
	 * Return updated irritantSet or null if it was a no-op
	 * 
	 * @param other
	 */
	public IrritantSet set(IrritantSet other) {
		if (other == null)
			return this;
		boolean wasNoOp = true;
		for (int i = 0; i < GROUP_MAX; i++) {
			int otherIrritant = other.bits[i] & ~GROUP_MASK; // erase the
																	// group
																	// bits
			if ((this.bits[i] & otherIrritant) != otherIrritant) {
				wasNoOp = false;
				this.bits[i] |= otherIrritant;
			}
		}
		return wasNoOp ? null : this;
	}
	
	public IrritantSet setAll() {
		for (int i = 0; i < GROUP_MAX; i++) {
			this.bits[i] |= 0xFFFFFFFF & ~GROUP_MASK; // erase the group
															// bits;
		}
		return this;
	}
}




import org.eclipse.jdt.internal.compiler.lookup.SignatureWrapper;
import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding;
import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

				String errorMessage = Util.appendConstant(this.scriptOutput, constant);
				if (errorMessage != null) {
//					reportError(scope, errorMessage, qualifiedNameReference);
					reportWarning(scope, "SHOULD BE ERROR - " + errorMessage, qualifiedNameReference); //$NON-NLS-1$
				}
				return false;
			}

			String errorMessage = Util.appendConstant(this.scriptOutput, singleNameReference.constant);
			if (errorMessage != null) {
//				reportError(scope, errorMessage, singleNameReference);
				reportWarning(scope, "SHOULD BE ERROR - " + errorMessage, singleNameReference); //$NON-NLS-1$
			}
			return false;
		}

							switch (synthetic.purpose) {
								case SyntheticMethodBinding.FieldReadAccess:
									printIndent();
									this.scriptOutput.append(argumentsCount == 0 ? "return " : "return arg0."); //$NON-NLS-1$  //$NON-NLS-2$
									this.scriptOutput.append(synthetic.targetReadField.name);
									this.scriptOutput.append(";\n"); //$NON-NLS-1$
									break;




import java.util.Map;

import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.impl.IrritantSet;

public class CompilerOptions extends org.eclipse.jdt.internal.compiler.impl.CompilerOptions {
	
	public static final String OPTION_ReportNonConstStaticFinalField = "org.eclipse.jdt.core.compiler.problem.as.nonConstStaticFinalField"; //$NON-NLS-1$
	public static final int NonConstStaticFinalField = IrritantSet.GROUP2 + ASTNode.Bit15; // offset behind base compiler irritants
	public static final String OPTION_DisableWarnings = "org.eclipse.jdt.core.compiler.problem.disableWarnings"; //$NON-NLS-1$

	// disable all warnings
	public boolean disableWarnings = false;

	public CompilerOptions() {
		super();
	}
	public CompilerOptions(Map settings) {
		super(settings);
	}
	
	protected void resetDefaults() {
		super.resetDefaults();
		this.warningThreshold.set(NonConstStaticFinalField);
	}
	
	public Map getMap() {


	public void set(Map optionsMap) {
		super.set(optionsMap);
		Object optionValue;
		if ((optionValue = optionsMap.get(CompilerOptions.OPTION_DisableWarnings)) != null) {
			// inlined (not visible) updateSeverity(NonConstStaticFinalField, optionValue);
			if (ERROR.equals(optionValue)) {
				this.errorThreshold |= NonConstStaticFinalField;
				this.warningThreshold &= ~NonConstStaticFinalField;
			} else if (WARNING.equals(optionValue)) {
				this.errorThreshold &= ~NonConstStaticFinalField;
				this.warningThreshold |= NonConstStaticFinalField;
			} else if (IGNORE.equals(optionValue)) {
				this.errorThreshold &= ~NonConstStaticFinalField;
				this.warningThreshold &= ~NonConstStaticFinalField;
			}
		}
		if ((optionValue = (String) optionsMap.get(CompilerOptions.OPTION_DisableWarnings)) != null) {
			if (ENABLED.equals(optionValue)) {
				this.disableWarnings = false;
			} else if (DISABLED.equals(optionValue)) {

Return to bug 245973

Lines 15-20 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java (-12 / +14 lines)
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	16	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
17	import org.eclipse.jdt.internal.compiler.impl.Constant;	17	import org.eclipse.jdt.internal.compiler.impl.Constant;
		18	import org.eclipse.jdt.internal.compiler.impl.IrritantSet;
18	import org.eclipse.jdt.internal.compiler.lookup.*;	19	import org.eclipse.jdt.internal.compiler.lookup.*;
19		20
20	/**	21	/**
Lines 177-183 Link Here
177	}	178	}
178		179
179	public void recordSuppressWarnings(Scope scope, int startSuppresss, int endSuppress, boolean isSuppressingWarnings) {	180	public void recordSuppressWarnings(Scope scope, int startSuppresss, int endSuppress, boolean isSuppressingWarnings) {
180	long suppressWarningIrritants = 0;	181	IrritantSet suppressWarningIrritants = null;
181	MemberValuePair[] pairs = memberValuePairs();	182	MemberValuePair[] pairs = memberValuePairs();
182	pairLoop: for (int i = 0, length = pairs.length; i < length; i++) {	183	pairLoop: for (int i = 0, length = pairs.length; i < length; i++) {
183	MemberValuePair pair = pairs[i];	184	MemberValuePair pair = pairs[i];
Lines 190-201 Link Here
190	for (int j = 0, initsLength = inits.length; j < initsLength; j++) {	191	for (int j = 0, initsLength = inits.length; j < initsLength; j++) {
191	Constant cst = inits[j].constant;	192	Constant cst = inits[j].constant;
192	if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {	193	if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
193	long irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());	194	IrritantSet irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
194	if (irritants != 0) {	195	if (irritants != null) {
195	if ((suppressWarningIrritants & irritants) == irritants) {	196	if (suppressWarningIrritants == null) {
196	scope.problemReporter().unusedWarningToken(inits[j]);	197	suppressWarningIrritants = new IrritantSet(irritants);
197	} else {	198	} else if (suppressWarningIrritants.set(irritants) == null) {
198	suppressWarningIrritants \|= irritants;	199	scope.problemReporter().unusedWarningToken(inits[j]);
199	}	200	}
200	} else {	201	} else {
201	scope.problemReporter().unhandledWarningToken(inits[j]);	202	scope.problemReporter().unhandledWarningToken(inits[j]);
Lines 206-214 Link Here
206	} else {	207	} else {
207	Constant cst = value.constant;	208	Constant cst = value.constant;
208	if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {	209	if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
209	long irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());	210	IrritantSet irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
210	if (irritants != 0) {	211	if (irritants != null) {
211	suppressWarningIrritants \|= irritants;	212	suppressWarningIrritants = new IrritantSet(irritants);
		213	// TODO: should check for unused warning token against enclosing annotation as well ?
212	} else {	214	} else {
213	scope.problemReporter().unhandledWarningToken(value);	215	scope.problemReporter().unhandledWarningToken(value);
214	}	216	}
Lines 217-223 Link Here
217	break pairLoop;	219	break pairLoop;
218	}	220	}
219	}	221	}
220	if (isSuppressingWarnings && suppressWarningIrritants != 0) {	222	if (isSuppressingWarnings && suppressWarningIrritants != null) {
221	scope.referenceCompilationUnit().recordSuppressWarnings(suppressWarningIrritants, this, startSuppresss, endSuppress);	223	scope.referenceCompilationUnit().recordSuppressWarnings(suppressWarningIrritants, this, startSuppresss, endSuppress);
222	}	224	}
223	}	225	}
Lines 307-313 Link Here
307	long tagBits = detectStandardAnnotation(scope, annotationType, valueAttribute);	309	long tagBits = detectStandardAnnotation(scope, annotationType, valueAttribute);
308		310
309	// record annotation positions in the compilation result	311	// record annotation positions in the compilation result
310	scope.referenceCompilationUnit().recordSuppressWarnings(CompilerOptions.NonExternalizedString, null, this.sourceStart, this.declarationSourceEnd);	312	scope.referenceCompilationUnit().recordSuppressWarnings(IrritantSet.NLS, null, this.sourceStart, this.declarationSourceEnd);
311	if (this.recipient != null) {	313	if (this.recipient != null) {
312	if (tagBits != 0) {	314	if (tagBits != 0) {
313	// tag bits onto recipient	315	// tag bits onto recipient

Lines 45-51 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (-99 / +80 lines)
45	return leadProblemId << 8 \| elaborationVariant; // leadProblemId comes into the higher order bytes	45	return leadProblemId << 8 \| elaborationVariant; // leadProblemId comes into the higher order bytes
46	}	46	}
47		47
48	public static long getIrritant(int problemID) {	48	public static int getIrritant(int problemID) {
49	switch(problemID){	49	switch(problemID){
50		50
51	case IProblem.MaskedCatch :	51	case IProblem.MaskedCatch :
Lines 336-441 Link Here
336	// fatal problems even if optional are all falling into same category (not irritant based)	336	// fatal problems even if optional are all falling into same category (not irritant based)
337	if ((severity & ProblemSeverities.Fatal) != 0)	337	if ((severity & ProblemSeverities.Fatal) != 0)
338	break categorizeOnIrritant;	338	break categorizeOnIrritant;
339	long irritant = getIrritant(problemID);	339	int irritant = getIrritant(problemID);
340	int irritantInt = (int) irritant;	340	switch (irritant) {
341	if (irritantInt == irritant) {	341	case CompilerOptions.MethodWithConstructorName :
342	switch (irritantInt) {	342	case CompilerOptions.AccessEmulation :
343	case (int)CompilerOptions.MethodWithConstructorName:	343	case CompilerOptions.AssertUsedAsAnIdentifier :
344	case (int)CompilerOptions.AccessEmulation:	344	case CompilerOptions.NonStaticAccessToStatic :
345	case (int)CompilerOptions.AssertUsedAsAnIdentifier:	345	case CompilerOptions.UnqualifiedFieldAccess :
346	case (int)CompilerOptions.NonStaticAccessToStatic:	346	case CompilerOptions.UndocumentedEmptyBlock :
347	case (int)CompilerOptions.UnqualifiedFieldAccess:	347	case CompilerOptions.IndirectStaticAccess :
348	case (int)CompilerOptions.UndocumentedEmptyBlock:	348	case CompilerOptions.FinalParameterBound :
349	case (int)CompilerOptions.IndirectStaticAccess:	349	case CompilerOptions.EnumUsedAsAnIdentifier :
350	return CategorizedProblem.CAT_CODE_STYLE;	350	case CompilerOptions.AnnotationSuperInterface :
351		351	case CompilerOptions.AutoBoxing :
352	case (int)CompilerOptions.MaskedCatchBlock:	352	case CompilerOptions.MissingOverrideAnnotation :
353	case (int)CompilerOptions.NoImplicitStringConversion:	353	case CompilerOptions.MissingDeprecatedAnnotation :
354	case (int)CompilerOptions.NoEffectAssignment:	354	case CompilerOptions.ParameterAssignment :
355	case (int)CompilerOptions.AccidentalBooleanAssign:	355	return CategorizedProblem.CAT_CODE_STYLE;
356	case (int)CompilerOptions.EmptyStatement:	356
357	case (int)CompilerOptions.FinallyBlockNotCompleting:	357	case CompilerOptions.MaskedCatchBlock :
358	return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;	358	case CompilerOptions.NoImplicitStringConversion :
359		359	case CompilerOptions.NoEffectAssignment :
360	case (int)CompilerOptions.OverriddenPackageDefaultMethod:	360	case CompilerOptions.AccidentalBooleanAssign :
361	case (int)CompilerOptions.IncompatibleNonInheritedInterfaceMethod:	361	case CompilerOptions.EmptyStatement :
362	case (int)CompilerOptions.LocalVariableHiding:	362	case CompilerOptions.FinallyBlockNotCompleting :
363	case (int)CompilerOptions.FieldHiding:	363	case CompilerOptions.MissingSerialVersion :
364	return CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT;	364	case CompilerOptions.VarargsArgumentNeedCast :
365		365	case CompilerOptions.NullReference :
366	case (int)CompilerOptions.UnusedLocalVariable:	366	case CompilerOptions.PotentialNullReference :
367	case (int)CompilerOptions.UnusedArgument:	367	case CompilerOptions.RedundantNullCheck :
368	case (int)CompilerOptions.UnusedImport:	368	case CompilerOptions.IncompleteEnumSwitch :
369	case (int)CompilerOptions.UnusedPrivateMember:	369	case CompilerOptions.FallthroughCase :
370	case (int)CompilerOptions.UnusedDeclaredThrownException:	370	case CompilerOptions.OverridingMethodWithoutSuperInvocation :
371	case (int)CompilerOptions.UnnecessaryTypeCheck:	371	case CompilerOptions.ComparingIdentical :
372	case (int)CompilerOptions.UnnecessaryElse:	372	case CompilerOptions.MissingSynchronizedModifierInInheritedMethod :
373	return CategorizedProblem.CAT_UNNECESSARY_CODE;	373	return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;
374		374
375	case (int)CompilerOptions.UsingDeprecatedAPI:	375	case CompilerOptions.OverriddenPackageDefaultMethod :
376	return CategorizedProblem.CAT_DEPRECATION;	376	case CompilerOptions.IncompatibleNonInheritedInterfaceMethod :
377		377	case CompilerOptions.LocalVariableHiding :
378	case (int)CompilerOptions.NonExternalizedString:	378	case CompilerOptions.FieldHiding :
379	return CategorizedProblem.CAT_NLS;	379	case CompilerOptions.TypeHiding :
380		380	return CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT;
381	case (int)CompilerOptions.Task:	381
382	return CategorizedProblem.CAT_UNSPECIFIED; // TODO may want to improve	382	case CompilerOptions.UnusedLocalVariable :
383		383	case CompilerOptions.UnusedArgument :
384	case (int)CompilerOptions.MissingJavadocComments:	384	case CompilerOptions.UnusedImport :
385	case (int)CompilerOptions.MissingJavadocTags:	385	case CompilerOptions.UnusedPrivateMember :
386	case (int)CompilerOptions.InvalidJavadoc:	386	case CompilerOptions.UnusedDeclaredThrownException :
387	case (int)(CompilerOptions.InvalidJavadoc \| CompilerOptions.UsingDeprecatedAPI):	387	case CompilerOptions.UnnecessaryTypeCheck :
388	return CategorizedProblem.CAT_JAVADOC;	388	case CompilerOptions.UnnecessaryElse :
389		389	case CompilerOptions.UnhandledWarningToken :
390	case (int)CompilerOptions.UncheckedTypeOperation:	390	case CompilerOptions.UnusedWarningToken :
391	return CategorizedProblem.CAT_UNCHECKED_RAW;	391	case CompilerOptions.UnusedLabel :
		392	case CompilerOptions.RedundantSuperinterface :
		393	return CategorizedProblem.CAT_UNNECESSARY_CODE;
392		394
393	default:	395	case CompilerOptions.UsingDeprecatedAPI :
394	break categorizeOnIrritant;	396	return CategorizedProblem.CAT_DEPRECATION;
395	}
396	} else {
397	irritantInt = (int)(irritant >>> 32);
398	switch (irritantInt) {
399	case (int)(CompilerOptions.FinalParameterBound >>> 32):
400	case (int)(CompilerOptions.EnumUsedAsAnIdentifier >>> 32):
401	case (int)(CompilerOptions.AnnotationSuperInterface >>> 32):
402	case (int)(CompilerOptions.AutoBoxing >>> 32):
403	case (int)(CompilerOptions.MissingOverrideAnnotation >>> 32):
404	case (int)(CompilerOptions.MissingDeprecatedAnnotation >>> 32):
405	case (int)(CompilerOptions.ParameterAssignment >>> 32):
406	return CategorizedProblem.CAT_CODE_STYLE;
407
408	case (int)(CompilerOptions.MissingSerialVersion >>> 32):
409	case (int)(CompilerOptions.VarargsArgumentNeedCast >>> 32):
410	case (int)(CompilerOptions.NullReference >>> 32):
411	case (int)(CompilerOptions.PotentialNullReference >>> 32):
412	case (int)(CompilerOptions.RedundantNullCheck >>> 32):
413	case (int)(CompilerOptions.IncompleteEnumSwitch >>> 32):
414	case (int)(CompilerOptions.FallthroughCase >>> 32):
415	case (int)(CompilerOptions.OverridingMethodWithoutSuperInvocation >>> 32):
416	case (int)(CompilerOptions.ComparingIdentical >>> 32):
417	case (int)(CompilerOptions.MissingSynchronizedModifierInInheritedMethod >> 32):
418	return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;
419
420	case (int)(CompilerOptions.TypeHiding >>> 32):
421	return CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT;
422
423	case (int)(CompilerOptions.UnhandledWarningToken >>> 32):
424	case (int)(CompilerOptions.UnusedWarningToken >>> 32):
425	case (int)(CompilerOptions.UnusedLabel >>> 32):
426	case (int)(CompilerOptions.RedundantSuperinterface >>> 32):
427	return CategorizedProblem.CAT_UNNECESSARY_CODE;
428
429	case (int)(CompilerOptions.ForbiddenReference >>> 32):
430	case (int)(CompilerOptions.DiscouragedReference >>> 32):
431	return CategorizedProblem.CAT_RESTRICTION;
432		397
433	case (int)(CompilerOptions.RawTypeReference >>> 32):	398	case CompilerOptions.NonExternalizedString :
434	return CategorizedProblem.CAT_UNCHECKED_RAW;	399	return CategorizedProblem.CAT_NLS;
435		400
436	default:	401	case CompilerOptions.Task :
437	break categorizeOnIrritant;	402	return CategorizedProblem.CAT_UNSPECIFIED; // TODO may want to improve
438	}	403
		404	case CompilerOptions.MissingJavadocComments :
		405	case CompilerOptions.MissingJavadocTags :
		406	case CompilerOptions.InvalidJavadoc :
		407	case CompilerOptions.InvalidJavadoc\|CompilerOptions.UsingDeprecatedAPI :
		408	return CategorizedProblem.CAT_JAVADOC;
		409
		410	case CompilerOptions.UncheckedTypeOperation :
		411	case CompilerOptions.RawTypeReference :
		412	return CategorizedProblem.CAT_UNCHECKED_RAW;
		413
		414	case CompilerOptions.ForbiddenReference :
		415	case CompilerOptions.DiscouragedReference :
		416	return CategorizedProblem.CAT_RESTRICTION;
		417
		418	default:
		419	break categorizeOnIrritant;
439	}	420	}
440	}	421	}
441	// categorize fatal problems per ID	422	// categorize fatal problems per ID
Lines 1163-1169 Link Here
1163	}	1144	}
1164	break;	1145	break;
1165	}	1146	}
1166	long irritant = getIrritant(problemID);	1147	int irritant = getIrritant(problemID);
1167	if (irritant != 0) {	1148	if (irritant != 0) {
1168	if ((problemID & IProblem.Javadoc) != 0 && !this.options.docCommentSupport)	1149	if ((problemID & IProblem.Javadoc) != 0 && !this.options.docCommentSupport)
1169	return ProblemSeverities.Ignore;	1150	return ProblemSeverities.Ignore;

Lines 111-117 Link Here

(-)src/org/eclipse/jdt/internal/compiler/as/ActionScriptSourceGenerator.java (-4 / +3 lines)
111	import org.eclipse.jdt.internal.compiler.lookup.SignatureWrapper;	111	import org.eclipse.jdt.internal.compiler.lookup.SignatureWrapper;
112	import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding;	112	import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding;
113	import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding;	113	import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding;
114	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
115	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	114	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
116	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;	115	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
117	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	116	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
Lines 1889-1895 Link Here
1889	String errorMessage = Util.appendConstant(this.scriptOutput, constant);	1888	String errorMessage = Util.appendConstant(this.scriptOutput, constant);
1890	if (errorMessage != null) {	1889	if (errorMessage != null) {
1891	// reportError(scope, errorMessage, qualifiedNameReference);	1890	// reportError(scope, errorMessage, qualifiedNameReference);
1892	reportWarning(scope, "SHOULD BE ERROR - " + errorMessage, qualifiedNameReference);	1891	reportWarning(scope, "SHOULD BE ERROR - " + errorMessage, qualifiedNameReference); //$NON-NLS-1$
1893	}	1892	}
1894	return false;	1893	return false;
1895	}	1894	}
Lines 1984-1990 Link Here
1984	String errorMessage = Util.appendConstant(this.scriptOutput, singleNameReference.constant);	1983	String errorMessage = Util.appendConstant(this.scriptOutput, singleNameReference.constant);
1985	if (errorMessage != null) {	1984	if (errorMessage != null) {
1986	// reportError(scope, errorMessage, singleNameReference);	1985	// reportError(scope, errorMessage, singleNameReference);
1987	reportWarning(scope, "SHOULD BE ERROR - " + errorMessage, singleNameReference);	1986	reportWarning(scope, "SHOULD BE ERROR - " + errorMessage, singleNameReference); //$NON-NLS-1$
1988	}	1987	}
1989	return false;	1988	return false;
1990	}	1989	}
Lines 2410-2416 Link Here
2410	switch (synthetic.purpose) {	2409	switch (synthetic.purpose) {
2411	case SyntheticMethodBinding.FieldReadAccess:	2410	case SyntheticMethodBinding.FieldReadAccess:
2412	printIndent();	2411	printIndent();
2413	this.scriptOutput.append(argumentsCount == 0 ? "return " : "return arg0."); //$NON-NLS-1$	2412	this.scriptOutput.append(argumentsCount == 0 ? "return " : "return arg0."); //$NON-NLS-1$ //$NON-NLS-2$
2414	this.scriptOutput.append(synthetic.targetReadField.name);	2413	this.scriptOutput.append(synthetic.targetReadField.name);
2415	this.scriptOutput.append(";\n"); //$NON-NLS-1$	2414	this.scriptOutput.append(";\n"); //$NON-NLS-1$
2416	break;	2415	break;

Lines 21-26 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (-7 / +9 lines)
21	import org.eclipse.jdt.internal.compiler.CompilationResult;	21	import org.eclipse.jdt.internal.compiler.CompilationResult;
22	import org.eclipse.jdt.internal.compiler.ICompilerRequestor;	22	import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
23	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	23	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
		24	import org.eclipse.jdt.internal.compiler.impl.IrritantSet;
24	import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;	25	import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
25	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	26	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
26	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;	27	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
Lines 60-73 Link Here
60		61
61	// irritant vs warning token - check To/From symmetry	62	// irritant vs warning token - check To/From symmetry
62	public void test001_irritant_warning_token() {	63	public void test001_irritant_warning_token() {
63	String [] tokens = new String[64];
64	Map matcher = new HashMap();	64	Map matcher = new HashMap();
65	long irritant;	65	for (int group = 0; group < IrritantSet.GROUP_MAX; group++) {
66	String token;	66	for (int i = 0; i < 29; i++) {
67	for (int i = 0; i < 64; i++) {	67	int irritant = (group << IrritantSet.GROUP_SHIFT) + (1 << i);
68	if ((token = tokens[i] = CompilerOptions.warningTokenFromIrritant(irritant = 1L << i)) != null) {	68	String token = CompilerOptions.warningTokenFromIrritant(irritant);
69	matcher.put(token, token);	69	if (token != null) {
70	assertTrue((irritant & CompilerOptions.warningTokenToIrritants(token)) != 0);	70	matcher.put(token, token);
		71	assertTrue(CompilerOptions.warningTokenToIrritants(token) != null);
		72	}
71	}	73	}
72	}	74	}
73	String [] allTokens = CompilerOptions.warningTokens;	75	String [] allTokens = CompilerOptions.warningTokens;

Added Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java (+255 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.jdt.internal.compiler.impl;
13
14	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
15
16	/**
17	* Represent a set of irritant flags. Irritants are organized in up to 8 group
18	* of 29, allowing for a maximum of 232 distinct irritants.
19	*/
20	public class IrritantSet {
21
22	// Reserve two high bits for selecting the right bit pattern
23	public final static int GROUP_MASK = ASTNode.Bit32 \| ASTNode.Bit31 \| ASTNode.Bit30;
24	public final static int GROUP_SHIFT = 29;
25	public final static int GROUP_MAX = 3; // can be increased up to 8
26
27	// Group prefix for irritants
28	public final static int GROUP0 = 0 << GROUP_SHIFT;
29	public final static int GROUP1 = 1 << GROUP_SHIFT;
30	public final static int GROUP2 = 2 << GROUP_SHIFT;
31	// reveal subsequent groups as needed
32	// public final static int GROUP3 = 3 << GROUP_SHIFT;
33	// public final static int GROUP4 = 4 << GROUP_SHIFT;
34	// public final static int GROUP5 = 5 << GROUP_SHIFT;
35	// public final static int GROUP6 = 6 << GROUP_SHIFT;
36	// public final static int GROUP7 = 7 << GROUP_SHIFT;
37
38	// Predefine sets of irritants matching warning tokens
39	public static final IrritantSet ALL = new IrritantSet(
40	0xFFFFFFFF & ~GROUP_MASK);
41	public static final IrritantSet BOXING = new IrritantSet(
42	CompilerOptions.AutoBoxing);
43	public static final IrritantSet CAST = new IrritantSet(
44	CompilerOptions.UnnecessaryTypeCheck);
45	public static final IrritantSet DEPRECATION = new IrritantSet(
46	CompilerOptions.UsingDeprecatedAPI);
47	public static final IrritantSet DEP_ANN = new IrritantSet(
48	CompilerOptions.MissingDeprecatedAnnotation);
49	public static final IrritantSet FALLTHROUGH = new IrritantSet(
50	CompilerOptions.FallthroughCase);
51	public static final IrritantSet FINALLY = new IrritantSet(
52	CompilerOptions.FinallyBlockNotCompleting);
53	public static final IrritantSet HIDING = new IrritantSet(
54	CompilerOptions.MaskedCatchBlock); // further scenarii in static
55	// initializer
56	public static final IrritantSet INCOMPLETE_SWITCH = new IrritantSet(
57	CompilerOptions.IncompleteEnumSwitch);
58	public static final IrritantSet NLS = new IrritantSet(
59	CompilerOptions.NonExternalizedString);
60	public static final IrritantSet NULL = new IrritantSet(
61	CompilerOptions.NullReference); // further scenarii in static
62	// initializer
63	public static final IrritantSet RESTRICTION = new IrritantSet(
64	CompilerOptions.ForbiddenReference); // further scenarii in static
65	// initializer
66	public static final IrritantSet SERIAL = new IrritantSet(
67	CompilerOptions.MissingSerialVersion);
68	public static final IrritantSet STATIC_ACCESS = new IrritantSet(
69	CompilerOptions.IndirectStaticAccess); // further scenarii in static
70	// initializer
71	public static final IrritantSet SYNTHETIC_ACCESS = new IrritantSet(
72	CompilerOptions.AccessEmulation);
73	public static final IrritantSet SUPER = new IrritantSet(
74	CompilerOptions.OverridingMethodWithoutSuperInvocation);
75	public static final IrritantSet UNUSED = new IrritantSet(
76	CompilerOptions.UnusedLocalVariable); // further scenarii in static
77	// initializer
78	public static final IrritantSet UNCHECKED = new IrritantSet(
79	CompilerOptions.UncheckedTypeOperation); // further scenarii in
80	// static initializer
81	public static final IrritantSet UNQUALIFIED_FIELD_ACCESS = new IrritantSet(
82	CompilerOptions.UnqualifiedFieldAccess);
83
84	public static final IrritantSet COMPILER_DEFAULT_ERRORS = new IrritantSet(0); // no optional error by default
85	public static final IrritantSet COMPILER_DEFAULT_WARNINGS = new IrritantSet(0); // see static initializer below
86	static {
87	COMPILER_DEFAULT_WARNINGS
88	// group-0 warnings enabled by default
89	.set(
90	CompilerOptions.MethodWithConstructorName
91	\| CompilerOptions.OverriddenPackageDefaultMethod
92	\| CompilerOptions.UsingDeprecatedAPI
93	\| CompilerOptions.MaskedCatchBlock
94	\| CompilerOptions.UnusedLocalVariable
95	\| CompilerOptions.NoImplicitStringConversion
96	\| CompilerOptions.AssertUsedAsAnIdentifier
97	\| CompilerOptions.UnusedImport
98	\| CompilerOptions.NonStaticAccessToStatic
99	\| CompilerOptions.NoEffectAssignment
100	\| CompilerOptions.IncompatibleNonInheritedInterfaceMethod
101	\| CompilerOptions.UnusedPrivateMember
102	\| CompilerOptions.FinallyBlockNotCompleting)
103	// group-1 warnings enabled by default
104	.set(
105	CompilerOptions.UncheckedTypeOperation
106	\| CompilerOptions.FinalParameterBound
107	\| CompilerOptions.MissingSerialVersion
108	\| CompilerOptions.EnumUsedAsAnIdentifier
109	\| CompilerOptions.ForbiddenReference
110	\| CompilerOptions.VarargsArgumentNeedCast
111	\| CompilerOptions.NullReference
112	\| CompilerOptions.AnnotationSuperInterface
113	\| CompilerOptions.TypeHiding
114	\| CompilerOptions.DiscouragedReference
115	\| CompilerOptions.UnhandledWarningToken
116	\| CompilerOptions.RawTypeReference
117	\| CompilerOptions.UnusedLabel
118	\| CompilerOptions.UnusedTypeArguments
119	\| CompilerOptions.UnusedWarningToken
120	\| CompilerOptions.ComparingIdentical
121	\| CompilerOptions.MissingSynchronizedModifierInInheritedMethod);
122	// group-2 warnings enabled by default
123	// next irritant goes here (group-1 is complete)
124
125	ALL.setAll();
126	HIDING
127	.set(CompilerOptions.FieldHiding)
128	.set(CompilerOptions.LocalVariableHiding)
129	.set(CompilerOptions.TypeHiding);
130	NULL
131	.set(CompilerOptions.PotentialNullReference)
132	.set(CompilerOptions.RedundantNullCheck);
133	RESTRICTION.set(CompilerOptions.DiscouragedReference);
134	STATIC_ACCESS.set(CompilerOptions.NonStaticAccessToStatic);
135	UNUSED
136	.set(CompilerOptions.UnusedArgument)
137	.set(CompilerOptions.UnusedPrivateMember)
138	.set(CompilerOptions.UnusedDeclaredThrownException)
139	.set(CompilerOptions.UnusedLabel)
140	.set(CompilerOptions.UnusedImport)
141	.set(CompilerOptions.UnusedTypeArguments)
142	.set(CompilerOptions.RedundantSuperinterface);
143	UNCHECKED.set(CompilerOptions.RawTypeReference);
144	}
145
146	// Internal state
147	private int[] bits = new int[GROUP_MAX];
148
149	/**
150	* Constructor with initial irritant set
151	*/
152	public IrritantSet(int singleGroupIrritants) {
153	initialize(singleGroupIrritants);
154	}
155
156	/**
157	* Constructor with initial irritant set
158	*/
159	public IrritantSet(IrritantSet other) {
160	initialize(other);
161	}
162
163	public boolean areAllSet() {
164	for (int i = 0; i < GROUP_MAX; i++) {
165	if (this.bits[i] != (0xFFFFFFFF & ~GROUP_MASK))
166	return false;
167	}
168	return true;
169	}
170
171	public IrritantSet clear(int singleGroupIrritants) {
172	int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
173	this.bits[group] &= ~singleGroupIrritants;
174	return this;
175	}
176
177	public IrritantSet clearAll() {
178	for (int i = 0; i < GROUP_MAX; i++) {
179	this.bits[i] = 0;
180	}
181	return this;
182	}
183
184	/**
185	* Initialize a set of irritants in one group
186	*
187	* @param singleGroupIrritants
188	*/
189	public void initialize(int singleGroupIrritants) {
190	if (singleGroupIrritants == 0)
191	return;
192	int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
193	this.bits[group] = singleGroupIrritants & ~GROUP_MASK; // erase group information
194	}
195
196	public void initialize(IrritantSet other) {
197	if (other == null)
198	return;
199	System.arraycopy(other.bits, 0, this.bits = new int[GROUP_MAX], 0, GROUP_MAX);
200	}
201
202	/**
203	* Returns true if any of the irritants in given other set is positionned in receiver
204	* @param other
205	*/
206	public boolean isAnySet(IrritantSet other) {
207	if (other == null)
208	return false;
209	for (int i = 0; i < GROUP_MAX; i++) {
210	if ((this.bits[i] & other.bits[i]) != 0)
211	return true;
212	}
213	return false;
214	}
215
216	public boolean isSet(int singleGroupIrritants) {
217	int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
218	return (this.bits[group] & singleGroupIrritants) != 0;
219	}
220
221	public IrritantSet set(int singleGroupIrritants) {
222	int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
223	this.bits[group] \|= (singleGroupIrritants & ~GROUP_MASK); // erase the group bits
224	return this;
225	}
226
227	/**
228	* Return updated irritantSet or null if it was a no-op
229	*
230	* @param other
231	*/
232	public IrritantSet set(IrritantSet other) {
233	if (other == null)
234	return this;
235	boolean wasNoOp = true;
236	for (int i = 0; i < GROUP_MAX; i++) {
237	int otherIrritant = other.bits[i] & ~GROUP_MASK; // erase the
238	// group
239	// bits
240	if ((this.bits[i] & otherIrritant) != otherIrritant) {
241	wasNoOp = false;
242	this.bits[i] \|= otherIrritant;
243	}
244	}
245	return wasNoOp ? null : this;
246	}
247
248	public IrritantSet setAll() {
249	for (int i = 0; i < GROUP_MAX; i++) {
250	this.bits[i] \|= 0xFFFFFFFF & ~GROUP_MASK; // erase the group
251	// bits;
252	}
253	return this;
254	}
255	}

Lines 13-35 Link Here

(-)src/org/eclipse/jdt/internal/compiler/as/CompilerOptions.java (-22 / +13 lines)
13	import java.util.Map;	13	import java.util.Map;
14		14
15	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	15	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
		16	import org.eclipse.jdt.internal.compiler.impl.IrritantSet;
16		17
17	public class CompilerOptions extends org.eclipse.jdt.internal.compiler.impl.CompilerOptions {	18	public class CompilerOptions extends org.eclipse.jdt.internal.compiler.impl.CompilerOptions {
		19
18	public static final String OPTION_ReportNonConstStaticFinalField = "org.eclipse.jdt.core.compiler.problem.as.nonConstStaticFinalField"; //$NON-NLS-1$	20	public static final String OPTION_ReportNonConstStaticFinalField = "org.eclipse.jdt.core.compiler.problem.as.nonConstStaticFinalField"; //$NON-NLS-1$
19	public static final long NonConstStaticFinalField = ASTNode.Bit57L;	21	public static final int NonConstStaticFinalField = IrritantSet.GROUP2 + ASTNode.Bit15; // offset behind base compiler irritants
20	public static final String OPTION_DisableWarnings = "org.eclipse.jdt.core.compiler.problem.disableWarnings"; //$NON-NLS-1$	22	public static final String OPTION_DisableWarnings = "org.eclipse.jdt.core.compiler.problem.disableWarnings"; //$NON-NLS-1$
21		23
22	// disable all warnings	24	// disable all warnings
23	public boolean disableWarnings = false;	25	public boolean disableWarnings = false;
24		26
25	public CompilerOptions() {	27	public CompilerOptions() {
26	this.warningThreshold \|= NonConstStaticFinalField;	28	super();
27	}	29	}
28	public CompilerOptions(Map options) {	30	public CompilerOptions(Map settings) {
29	this();	31	super(settings);
30	if (options != null) {	32	}
31	set(options);	33
32	}	34	protected void resetDefaults() {
		35	super.resetDefaults();
		36	this.warningThreshold.set(NonConstStaticFinalField);
33	}	37	}
34		38
35	public Map getMap() {	39	public Map getMap() {
Lines 41-61 Link Here
41		45
42	public void set(Map optionsMap) {	46	public void set(Map optionsMap) {
43	super.set(optionsMap);	47	super.set(optionsMap);
44	String optionValue;	48	Object optionValue;
45	if ((optionValue = (String) optionsMap.get(OPTION_ReportNonConstStaticFinalField)) != null) {	49	if ((optionValue = optionsMap.get(CompilerOptions.OPTION_DisableWarnings)) != null) {
46	// inlined (not visible) updateSeverity(NonConstStaticFinalField, optionValue);
47	if (ERROR.equals(optionValue)) {
48	this.errorThreshold \|= NonConstStaticFinalField;
49	this.warningThreshold &= ~NonConstStaticFinalField;
50	} else if (WARNING.equals(optionValue)) {
51	this.errorThreshold &= ~NonConstStaticFinalField;
52	this.warningThreshold \|= NonConstStaticFinalField;
53	} else if (IGNORE.equals(optionValue)) {
54	this.errorThreshold &= ~NonConstStaticFinalField;
55	this.warningThreshold &= ~NonConstStaticFinalField;
56	}
57	}
58	if ((optionValue = (String) optionsMap.get(CompilerOptions.OPTION_DisableWarnings)) != null) {
59	if (ENABLED.equals(optionValue)) {	50	if (ENABLED.equals(optionValue)) {
60	this.disableWarnings = false;	51	this.disableWarnings = false;
61	} else if (DISABLED.equals(optionValue)) {	52	} else if (DISABLED.equals(optionValue)) {