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

Package org.aspectj.org.eclipse.jdt.core.compiler

Examples of org.aspectj.org.eclipse.jdt.core.compiler.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

      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++;
            this.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) {
            this.startLoggingProblems(errors, warnings);
            for (int i = 0; i < count; i++) {
              CategorizedProblem problem = problems[i];
              if (problem!= null) {
                if (problem.getID() != IProblem.Task) {
                  this.logXmlProblem(problem, unitSource);
                }
              }
            }
            this.endLoggingProblems();
          }
          if (tasks != 0) {
            this.startLoggingTasks(tasks);
            for (int i = 0; i < count; i++) {
              CategorizedProblem problem = problems[i];
              if (problem!= null) {
                if (problem.getID() == IProblem.Task) {
                  this.logXmlTask(problem, unitSource);
                }
              }
            }
            this.endLoggingTasks();

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

View Full Code Here

      int start,
      int end,
      int lineNumber,
      int columnNumber) {
      
      CategorizedProblem pb = super.createProblem(
        originatingFileName,
        problemId,
        problemArguments,
        messageArguments,
        severity,
        start,
        end,
        lineNumber,
        columnNumber);
      int id = pb.getID();
      if (CompletionEngine.this.actualCompletionPosition > start
        && this.lastErrorStart < start
        && pb.isError()
        && (id & IProblem.Syntax) == 0
        && (CompletionEngine.this.fileName == null || CharOperation.equals(CompletionEngine.this.fileName, originatingFileName))) {
          
        CompletionEngine.this.problem = pb;
        this.lastErrorStart = start;

View Full Code Here

    return;


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

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) newErrorCount++; else 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) fixedErrorCount++; else fixedWarningCount++;
    }

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

      problemRequestor.beginReporting();
      for (Iterator iteraror = this.problems.values().iterator(); iteraror.hasNext();) {
        CategorizedProblem[] categorizedProblems = (CategorizedProblem[]) iteraror.next();
        if (categorizedProblems == null) continue;
        for (int i = 0, length = categorizedProblems.length; i < length; i++) {
          CategorizedProblem problem = categorizedProblems[i];
          if (JavaModelManager.VERBOSE){
            System.out.println("PROBLEM FOUND while reconciling : " + problem.getMessage());//$NON-NLS-1$
          }
          if (this.progressMonitor != null && this.progressMonitor.isCanceled()) break;
          problemRequestor.acceptProblem(problem);
        }
      }

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

  }


  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

0 1

TOP

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

org.aspectj.ajdt.internal.compiler.WeaverMessageHandler

org.aspectj.org.eclipse.jdt.core.dom.ASTConverter

org.aspectj.org.eclipse.jdt.core.dom.ASTRecoveryPropagator

org.aspectj.org.eclipse.jdt.core.dom.ASTSyntaxErrorPropagator

org.aspectj.org.eclipse.jdt.internal.codeassist.CompletionEngine$CompletionProblemFactory

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

org.aspectj.org.eclipse.jdt.internal.compiler.ClassFile

org.aspectj.org.eclipse.jdt.internal.compiler.CompilationResult

org.aspectj.org.eclipse.jdt.internal.compiler.problem.ProblemHandler

org.aspectj.org.eclipse.jdt.internal.compiler.problem.ProblemReporter

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.