Examples of CategorizedProblem

org.aspectj.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 CompilationParticipant, the simpler problem interface IProblem did not carry enough information to better separate and categorize Java problems. In order to minimize impact on existing API, Java problems are still passed around as IProblem, though actual implementations should explicitly extend 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 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.aspectj.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 IProblem for backward compatibility reason. It is intended that CategorizedProblem will be subclassed for custom problem implementation when participating 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#GENERATED_BY attribute to JavaBuilder#GENERATED_BY; compiler participants may specify the IMarker#GENERATED_BY 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#GENERATED_BY extra attribute set do not have the IMarker#GENERATED_BY attribute set either. @since 3.2
org.eclipse.dltk.compiler.problem.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

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

        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

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

 * 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

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

  }


  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

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

        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

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

      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

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

      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

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

  }


  // 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

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

  }


  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

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

  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

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

  // 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

TOP

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.