/** report a compilation problem (callback for JDT) */
  public void reportProblem(CategorizedProblem pb) {
    if (pb == null) {
      return;
    }

    // we can not accept this problem, even in noclasspath mode
    // otherwise a nasty null pointer exception occurs later
    if (pb.getID() == IProblem.DuplicateTypes) {
      throw new ModelBuildingException(pb.getMessage());
    }

    probs.add(pb);
  }
  protected void storeProblemsFor(SourceFile sourceFile, CategorizedProblem[] problems)
      throws CoreException {
    if (sourceFile == null || problems == null || problems.length == 0) return;

    for (int i = problems.length; --i >= 0; ) {
      CategorizedProblem problem = problems[i];
      if (problem != null && problem.getID() == IProblem.UndefinedType) {
        if (this.typeLocatorsWithUndefinedTypes == null)
          this.typeLocatorsWithUndefinedTypes = new StringSet(3);
        this.typeLocatorsWithUndefinedTypes.add(sourceFile.typeLocator());
        break;
      }
    }

    super.storeProblemsFor(sourceFile, problems);
  }
 public boolean isSuppressed(CategorizedProblem problem) {
   if (this.suppressWarningsCount == 0) return false;
   int irritant = ProblemReporter.getIrritant(problem.getID());
   if (irritant == 0) return false;
   int start = problem.getSourceStart();
   int end = problem.getSourceEnd();
   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)) return true;
   }
   return false;
 }
 public void finalizeProblems() {
   if (this.suppressWarningsCount == 0) return;
   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 hasMandatoryErrors = false;
   nextProblem:
   for (int iProblem = 0, length = problemCount; iProblem < length; iProblem++) {
     CategorizedProblem problem = problems[iProblem];
     int problemID = problem.getID();
     int irritant = ProblemReporter.getIrritant(problemID);
     boolean isError = problem.isError();
     if (isError) {
       if (irritant == 0) {
         // tolerate unused warning tokens when mandatory errors
         hasMandatoryErrors = true;
         continue;
       }
       if (!options.suppressOptionalErrors) {
         continue;
       }
     }
     int start = problem.getSourceStart();
     int end = problem.getSourceEnd();
     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;
       this.compilationResult.removeProblem(problem);
       if (foundIrritants[iSuppress] == null) {
         foundIrritants[iSuppress] = new IrritantSet(irritant);
       } else {
         foundIrritants[iSuppress].set(irritant);
       }
       continue nextProblem;
     }
   }
   // compact remaining problems
   if (removed > 0) {
     for (int i = 0, index = 0; i < problemCount; i++) {
       CategorizedProblem problem;
       if ((problem = problems[i]) != null) {
         if (i > index) {
           problems[index++] = problem;
         } else {
           index++;
         }
       }
     }
   }
   // flag SuppressWarnings which had no effect (only if no (mandatory) error got detected within
   // unit
   if (!hasMandatoryErrors) {
     int severity = options.getSeverity(CompilerOptions.UnusedWarningToken);
     if (severity != ProblemSeverities.Ignore) {
       boolean unusedWarningTokenIsWarning = (severity & ProblemSeverities.Error) == 0;
       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++) {
             MemberValuePair pair = pairs[iPair];
             if (CharOperation.equals(pair.name, TypeConstants.VALUE)) {
               Expression value = pair.value;
               if (value instanceof ArrayInitializer) {
                 ArrayInitializer initializer = (ArrayInitializer) value;
                 Expression[] inits = initializer.expressions;
                 if (inits != null) {
                   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 effectively 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--) {
                             long position = this.suppressWarningScopePositions[jSuppress];
                             int startSuppress = (int) (position >>> 32);
                             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 effectively 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--) {
                         long position = this.suppressWarningScopePositions[jSuppress];
                         int startSuppress = (int) (position >>> 32);
                         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);
                   }
                 }
               }
               break pairLoop;
             }
           }
         }
       }
     }
   }
 }