Examples of org.eclipse.jdt.core.compiler.CategorizedProblem

org.eclipse.jdt.core.compiler.CategorizedProblem
Richer description of a Java problem, as detected by the compiler or some of the underlying technology reusing the compiler. With the introduction of org.eclipse.jdt.core.compiler.CompilationParticipant, the simpler problem interface {@link IProblem} did not carry enough information to betterseparate and categorize Java problems. In order to minimize impact on existing API, Java problems are still passed around as {@link IProblem}, though actual implementations should explicitly extend {@link CategorizedProblem}. Participants can produce their own problem definitions, and given these are categorized problems, they can be better handled by clients (such as user interface).
A categorized problem provides access to:
- its location (originating source file name, source position, line number),
- its message description and a predicate to check its severity (warning or error).
- its ID : a number identifying the very nature of this problem. All possible IDs for standard Java problems are listed as constants on {@link IProblem},
- its marker type : a string identifying the problem creator. It corresponds to the marker type chosen if this problem was to be persisted. Standard Java problems are associated to marker type "org.eclipse.jdt.core.problem"),
- its category ID : a number identifying the category this problem belongs to. All possible IDs for standard Java problem categories are listed in this class.
Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular their ID (attribute "id") is set to one of the IDs defined on this interface.
Note: Standard Java problems produced by Java default tooling will be subclasses of this class. Technically, most API methods dealing with problems are referring to {@link IProblem} for backward compatibility reason.It is intended that {@link CategorizedProblem} will be subclassed for custom problem implementation whenparticipating in compilation operations, so as to allow participant to contribute their own marker types, and thus defining their own domain specific problem/category IDs.
Note: standard Java problems produced by Java default tooling will set the marker IMarker#SOURCE_ID attribute to JavaBuilder#SOURCE_ID; compiler participants may specify the IMarker#SOURCE_ID attribute of their markers by adding it to the extra marker attributes of the problems they generate; markers resulting from compiler participants' problems that do not have the IMarker#SOURCE_ID extra attribute set do not have the JavaBuilder#SOURCE_ID attribute set either. @since 3.2

        MethodBinding methodBinding = methodDeclaration.binding;
         String readableName = new String(methodBinding.readableName());
         CategorizedProblem[] problems = compilationResult.problems;
         int problemsCount = compilationResult.problemCount;
        for (int j = 0; j < problemsCount; j++) {
          CategorizedProblem problem = problems[j];
          if (problem != null
              && problem.getID() == IProblem.AbstractMethodMustBeImplemented
              && problem.getMessage().indexOf(readableName) != -1
              && problem.getSourceStart() >= typeDeclarationSourceStart
              && problem.getSourceEnd() <= typeDeclarationSourceEnd) {
            // we found a match
            addMissingAbstractProblemMethod(methodDeclaration, methodBinding, problem, compilationResult);
          }
        }
      }

View Full Code Here

 * either of which may be null.
 */
protected void updateProblemCounts(IMarker[] oldProblems, CategorizedProblem[] newProblems) {
  if (newProblems != null) {
    next : for (int i = 0, l = newProblems.length; i < l; i++) {
      CategorizedProblem newProblem = newProblems[i];
      if (newProblem.getID() == IProblem.Task) continue; // skip task
      boolean isError = newProblem.isError();
      String message = newProblem.getMessage();


      if (oldProblems != null) {
        for (int j = 0, m = oldProblems.length; j < m; j++) {
          IMarker pb = oldProblems[j];
          if (pb == null) continue; // already matched up with a new problem
          boolean wasError = IMarker.SEVERITY_ERROR
            == pb.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
          if (isError == wasError && message.equals(pb.getAttribute(IMarker.MESSAGE, ""))) { //$NON-NLS-1$
            oldProblems[j] = null;
            continue next;
          }
        }
      }
      if (isError) this.newErrorCount++; else this.newWarningCount++;
    }
  }
  if (oldProblems != null) {
    next : for (int i = 0, l = oldProblems.length; i < l; i++) {
      IMarker oldProblem = oldProblems[i];
      if (oldProblem == null) continue next; // already matched up with a new problem
      boolean wasError = IMarker.SEVERITY_ERROR
        == oldProblem.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
      String message = oldProblem.getAttribute(IMarker.MESSAGE, ""); //$NON-NLS-1$


      if (newProblems != null) {
        for (int j = 0, m = newProblems.length; j < m; j++) {
          CategorizedProblem pb = newProblems[j];
          if (pb.getID() == IProblem.Task) continue; // skip task
          if (wasError == pb.isError() && message.equals(pb.getMessage()))
            continue next;
        }
      }
      if (wasError) this.fixedErrorCount++; else this.fixedWarningCount++;
    }

View Full Code Here

  }


  private boolean checkAndTagAsMalformed(ASTNode node) {
    boolean tagWithErrors = false;
    search: for (int i = 0, max = this.problems.length; i < max; i++) {
      CategorizedProblem problem = this.problems[i];
      switch(problem.getID()) {
        case IProblem.ParsingErrorOnKeywordNoSuggestion :
        case IProblem.ParsingErrorOnKeyword :
        case IProblem.ParsingError :
        case IProblem.ParsingErrorNoSuggestion :
        case IProblem.ParsingErrorInsertTokenBefore :
        case IProblem.ParsingErrorInsertTokenAfter :
        case IProblem.ParsingErrorDeleteToken :
        case IProblem.ParsingErrorDeleteTokens :
        case IProblem.ParsingErrorMergeTokens :
        case IProblem.ParsingErrorInvalidToken :
        case IProblem.ParsingErrorMisplacedConstruct :
        case IProblem.ParsingErrorReplaceTokens :
        case IProblem.ParsingErrorNoSuggestionForTokens :
        case IProblem.ParsingErrorUnexpectedEOF :
        case IProblem.ParsingErrorInsertToComplete :
        case IProblem.ParsingErrorInsertToCompleteScope :
        case IProblem.ParsingErrorInsertToCompletePhrase :
        case IProblem.EndOfSource :
        case IProblem.InvalidHexa :
        case IProblem.InvalidOctal :
        case IProblem.InvalidCharacterConstant :
        case IProblem.InvalidEscape :
        case IProblem.InvalidInput :
        case IProblem.InvalidUnicodeEscape :
        case IProblem.InvalidFloat :
        case IProblem.NullSourceString :
        case IProblem.UnterminatedString :
        case IProblem.UnterminatedComment :
        case IProblem.InvalidDigit :
          break;
        default:
          continue search;
      }
      int position = problem.getSourceStart();
      int start = node.getStartPosition();
      int end = start + node.getLength();
      if ((start <= position) && (position <= end)) {
        node.setFlags(node.getFlags() | ASTNode.MALFORMED);
        // clear the bits on parent

View Full Code Here

        end = methodDeclaration.bodyEnd;
        // try to get the best end position
        CategorizedProblem[] problems = methodDeclaration.compilationResult().problems;
        if (problems != null) {
          for (int i = 0, max = methodDeclaration.compilationResult().problemCount; i < max; i++) {
            CategorizedProblem currentProblem = problems[i];
            if (currentProblem.getSourceStart() == start && currentProblem.getID() == IProblem.ParsingErrorInsertToComplete) {
              end = currentProblem.getSourceEnd();
              break;
            }
          }
        }
        int startPosition = methodDecl.getStartPosition();

View Full Code Here

      int localProblemCount = 0;
      if (count != 0) {
        int errors = 0;
        int warnings = 0;
        for (int i = 0; i < count; i++) {
          CategorizedProblem problem = (CategorizedProblem) problems.get(i);
          if (problem != null) {
            currentMain.globalProblemsCount++;
            logExtraProblem(problem, localProblemCount, currentMain.globalProblemsCount);
            localProblemCount++;
            if (problem.isError()) {
              errors++;
              currentMain.globalErrorsCount++;
            } else if (problem.isWarning()) {
              currentMain.globalWarningsCount++;
              warnings++;
            }
          }
        }
        if ((this.tagBits & Logger.XML) != 0) {
          if ((errors + warnings) != 0) {
            startLoggingExtraProblems(count);
            for (int i = 0; i < count; i++) {
              CategorizedProblem problem = (CategorizedProblem) problems.get(i);
              if (problem!= null) {
                if (problem.getID() != IProblem.Task) {
                  logXmlExtraProblem(problem, localProblemCount, currentMain.globalProblemsCount);
                }
              }
            }
            endLoggingExtraProblems();

View Full Code Here

      if (count != 0) {
        int errors = 0;
        int warnings = 0;
        int tasks = 0;
        for (int i = 0; i < count; i++) {
          CategorizedProblem problem = problems[i];
          if (problem != null) {
            currentMain.globalProblemsCount++;
            logProblem(problem, localProblemCount, currentMain.globalProblemsCount, unitSource);
            localProblemCount++;
            if (problem.isError()) {
              localErrorCount++;
              errors++;
              currentMain.globalErrorsCount++;
            } else if (problem.getID() == IProblem.Task) {
              currentMain.globalTasksCount++;
              tasks++;
            } else {
              currentMain.globalWarningsCount++;
              warnings++;
            }
          }
        }
        if ((this.tagBits & Logger.XML) != 0) {
          if ((errors + warnings) != 0) {
            startLoggingProblems(errors, warnings);
            for (int i = 0; i < count; i++) {
              CategorizedProblem problem = problems[i];
              if (problem!= null) {
                if (problem.getID() != IProblem.Task) {
                  logXmlProblem(problem, unitSource);
                }
              }
            }
            endLoggingProblems();
          }
          if (tasks != 0) {
            startLoggingTasks(tasks);
            for (int i = 0; i < count; i++) {
              CategorizedProblem problem = problems[i];
              if (problem!= null) {
                if (problem.getID() == IProblem.Task) {
                  logXmlTask(problem, unitSource);
                }
              }
            }
            endLoggingTasks();

View Full Code Here

  }


  // if no reference context, we need to abort from the current compilation process
  if (referenceContext == null) {
    if ((severity & ProblemSeverities.Error) != 0) { // non reportable error is fatal
      CategorizedProblem problem = this.createProblem(null, problemId, problemArguments, elaborationId, messageArguments, severity, 0, 0, 0, 0);
      throw new AbortCompilation(null, problem);
    } else {
      return; // ignore non reportable warning
    }
  }


  int[] lineEnds;
  int lineNumber = problemStartPosition >= 0
      ? Util.getLineNumber(problemStartPosition, lineEnds = unitResult.getLineSeparatorPositions(), 0, lineEnds.length-1)
      : 0;
  int columnNumber = problemStartPosition >= 0
      ? Util.searchColumnNumber(unitResult.getLineSeparatorPositions(), lineNumber, problemStartPosition)
      : 0;
  CategorizedProblem problem =
    this.createProblem(
      unitResult.getFileName(),
      problemId,
      problemArguments,
      elaborationId,

View Full Code Here

  }


  private boolean markIncludedProblems(int start, int end) {
    boolean foundProblems = false;
    next: for (int i = 0, max = this.problems.length; i < max; i++) {
      CategorizedProblem problem = this.problems[i];


      if(this.usedOrIrrelevantProblems[i]) continue next;


      switch(problem.getID()) {
        case IProblem.ParsingErrorOnKeywordNoSuggestion :
        case IProblem.ParsingErrorOnKeyword :
        case IProblem.ParsingError :
        case IProblem.ParsingErrorNoSuggestion :
        case IProblem.ParsingErrorInsertTokenBefore :
        case IProblem.ParsingErrorInsertTokenAfter :
        case IProblem.ParsingErrorDeleteToken :
        case IProblem.ParsingErrorDeleteTokens :
        case IProblem.ParsingErrorMergeTokens :
        case IProblem.ParsingErrorInvalidToken :
        case IProblem.ParsingErrorMisplacedConstruct :
        case IProblem.ParsingErrorReplaceTokens :
        case IProblem.ParsingErrorNoSuggestionForTokens :
        case IProblem.ParsingErrorUnexpectedEOF :
        case IProblem.ParsingErrorInsertToComplete :
        case IProblem.ParsingErrorInsertToCompleteScope :
        case IProblem.ParsingErrorInsertToCompletePhrase :
        case IProblem.EndOfSource :
        case IProblem.InvalidHexa :
        case IProblem.InvalidOctal :
        case IProblem.InvalidCharacterConstant :
        case IProblem.InvalidEscape :
        case IProblem.InvalidInput :
        case IProblem.InvalidUnicodeEscape :
        case IProblem.InvalidFloat :
        case IProblem.NullSourceString :
        case IProblem.UnterminatedString :
        case IProblem.UnterminatedComment :
        case IProblem.InvalidDigit :
          break;
        default:
          this.usedOrIrrelevantProblems[i] = true;
          continue next;


      }


      int problemStart = problem.getSourceStart();
      int problemEnd = problem.getSourceEnd();
      if ((start <= problemStart) && (problemStart <= end) ||
          (start <= problemEnd) && (problemEnd <= end)) {
        this.usedOrIrrelevantProblems[i] = true;
        foundProblems = true;
      }

View Full Code Here

  CategorizedProblem[] allProblems = new CategorizedProblem[totalNumberOfProblem];
  int allProblemIndex = 0;
  int taskIndex = 0;
  int problemIndex = 0;
  while (taskIndex + problemIndex < totalNumberOfProblem) {
    CategorizedProblem nextTask = null;
    CategorizedProblem nextProblem = null;
    if (taskIndex < onlyTaskCount) {
      nextTask = onlyTasks[taskIndex];
    }
    if (problemIndex < onlyProblemCount) {
      nextProblem = onlyProblems[problemIndex];
    }
    // select the next problem
    CategorizedProblem currentProblem = null;
    if (nextProblem != null) {
      if (nextTask != null) {
        if (nextProblem.getSourceStart() < nextTask.getSourceStart()) {
          currentProblem = nextProblem;
          problemIndex++;

View Full Code Here

  // Re-adjust the size of the problems if necessary and filter package problems
  if (this.problems != null) {
    CategorizedProblem[] filteredProblems = new CategorizedProblem[this.problemCount];
    int keep = 0;
    for (int i=0; i< this.problemCount; i++) {
      CategorizedProblem problem = this.problems[i];
      if (problem.getID() != IProblem.MissingNonNullByDefaultAnnotationOnPackage) {
        filteredProblems[keep++] = problem;
      } else if (this.compilationUnit != null) {
        if (CharOperation.equals(this.compilationUnit.getMainTypeName(), TypeConstants.PACKAGE_INFO_NAME)) {
          filteredProblems[keep++] = problem;
        }

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.eclipse.jdt.core.compiler.CategorizedProblem

com.google.gwt.dev.javac.GWTProblem

com.google.gwt.dev.javac.JsniMethodCollectorTest

jmockit.assist.MockASTVisitor

org.apache.sling.commons.compiler.impl.EclipseJavaCompiler$CompileContext

org.eclipse.jdt.core.dom.ASTConverter

org.eclipse.jdt.core.dom.ASTRecoveryPropagator

org.eclipse.jdt.core.dom.ASTSyntaxErrorPropagator

org.eclipse.jdt.internal.compiler.apt.dispatch.BatchMessagerImpl

org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration

org.eclipse.jdt.internal.compiler.batch.Main$Logger

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.