| /******************************************************************************* |
| * Copyright (c) 2000, 2018 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Technical University Berlin - extended API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.compiler.problem; |
| |
| import org.eclipse.jdt.core.compiler.CategorizedProblem; |
| import org.eclipse.jdt.core.compiler.IProblem; |
| import org.eclipse.jdt.internal.compiler.impl.IrritantSet; |
| import org.eclipse.jdt.internal.compiler.util.Messages; |
| import org.eclipse.jdt.internal.compiler.util.Util; |
| |
| public class DefaultProblem extends CategorizedProblem { |
| private char[] fileName; |
| private int id; |
| private int startPosition; |
| private int endPosition; |
| private int line; |
| public int column; |
| public int severity; |
| private String[] arguments; |
| private String message; |
| |
| // cannot directly point to IJavaModelMarker constants from within batch compiler |
| private static final String MARKER_TYPE_PROBLEM = "org.eclipse.jdt.core.problem"; //$NON-NLS-1$ |
| private static final String MARKER_TYPE_TASK = "org.eclipse.jdt.core.task"; //$NON-NLS-1$ |
| |
| public static final Object[] EMPTY_VALUES = {}; |
| |
| //{ObjectTeams: capability for rechecking: |
| public IProblemRechecker rechecker; |
| public boolean shouldBeReported(IrritantSet[] foundIrritants) { |
| if (this.rechecker != null) |
| return this.rechecker.shouldBeReported(foundIrritants); |
| return true; |
| } |
| // SH} |
| |
| public DefaultProblem( |
| char[] originatingFileName, |
| String message, |
| int id, |
| String[] stringArguments, |
| int severity, |
| int startPosition, |
| int endPosition, |
| int line, |
| int column) { |
| |
| this.fileName = originatingFileName; |
| this.message = message; |
| this.id = id; |
| this.arguments = stringArguments; |
| this.severity = severity; |
| this.startPosition = startPosition; |
| this.endPosition = endPosition; |
| this.line = line; |
| this.column = column; |
| } |
| public void reportError() { |
| // Do nothing by default |
| } |
| |
| public String errorReportSource(char[] unitSource) { |
| //extra from the source the innacurate token |
| //and "highlight" it using some underneath ^^^^^ |
| //put some context around too. |
| |
| //this code assumes that the font used in the console is fixed size |
| |
| //sanity ..... |
| if ((this.startPosition > this.endPosition) |
| || ((this.startPosition < 0) && (this.endPosition < 0)) |
| || unitSource.length == 0) |
| return Messages.problem_noSourceInformation; |
| |
| StringBuffer errorBuffer = new StringBuffer(); |
| errorBuffer.append(' ').append(Messages.bind(Messages.problem_atLine, String.valueOf(this.line))); |
| errorBuffer.append(Util.LINE_SEPARATOR); |
| errorBuffer.append('\t'); |
| |
| char c; |
| final char SPACE = '\u0020'; |
| final char MARK = '^'; |
| final char TAB = '\t'; |
| //the next code tries to underline the token..... |
| //it assumes (for a good display) that token source does not |
| //contain any \r \n. This is false on statements ! |
| //(the code still works but the display is not optimal !) |
| |
| // expand to line limits |
| int length = unitSource.length, begin, end; |
| for (begin = this.startPosition >= length ? length - 1 : this.startPosition; begin > 0; begin--) { |
| if ((c = unitSource[begin - 1]) == '\n' || c == '\r') break; |
| } |
| for (end = this.endPosition >= length ? length - 1 : this.endPosition ; end+1 < length; end++) { |
| if ((c = unitSource[end + 1]) == '\r' || c == '\n') break; |
| } |
| |
| // trim left and right spaces/tabs |
| while ((c = unitSource[begin]) == ' ' || c == '\t') begin++; |
| //while ((c = unitSource[end]) == ' ' || c == '\t') end--; TODO (philippe) should also trim right, but all tests are to be updated |
| |
| // copy source |
| errorBuffer.append(unitSource, begin, end-begin+1); |
| errorBuffer.append(Util.LINE_SEPARATOR).append("\t"); //$NON-NLS-1$ |
| |
| // compute underline |
| for (int i = begin; i <this.startPosition; i++) { |
| errorBuffer.append((unitSource[i] == TAB) ? TAB : SPACE); |
| } |
| for (int i = this.startPosition; i <= (this.endPosition >= length ? length - 1 : this.endPosition); i++) { |
| errorBuffer.append(MARK); |
| } |
| return errorBuffer.toString(); |
| } |
| |
| @Override |
| public String[] getArguments() { |
| return this.arguments; |
| } |
| /** |
| * @see org.eclipse.jdt.core.compiler.CategorizedProblem#getCategoryID() |
| */ |
| @Override |
| public int getCategoryID() { |
| return ProblemReporter.getProblemCategory(this.severity, this.id); |
| } |
| |
| /** |
| * Answer the type of problem. |
| * @see org.eclipse.jdt.core.compiler.IProblem#getID() |
| * @return int |
| */ |
| @Override |
| public int getID() { |
| return this.id; |
| } |
| |
| /** |
| * Answers a readable name for the category which this problem belongs to, |
| * or null if none could be found. |
| * FOR TESTING PURPOSE |
| * @return java.lang.String |
| */ |
| public String getInternalCategoryMessage() { |
| switch(getCategoryID()) { |
| case CAT_UNSPECIFIED: |
| return "unspecified"; //$NON-NLS-1$ |
| case CAT_BUILDPATH: |
| return "buildpath"; //$NON-NLS-1$ |
| case CAT_SYNTAX: |
| return "syntax"; //$NON-NLS-1$ |
| case CAT_IMPORT: |
| return "import"; //$NON-NLS-1$ |
| case CAT_TYPE: |
| return "type"; //$NON-NLS-1$ |
| case CAT_MEMBER: |
| return "member"; //$NON-NLS-1$ |
| case CAT_INTERNAL: |
| return "internal"; //$NON-NLS-1$ |
| case CAT_JAVADOC: |
| return "javadoc"; //$NON-NLS-1$ |
| case CAT_CODE_STYLE: |
| return "code style"; //$NON-NLS-1$ |
| case CAT_POTENTIAL_PROGRAMMING_PROBLEM: |
| return "potential programming problem"; //$NON-NLS-1$ |
| case CAT_NAME_SHADOWING_CONFLICT: |
| return "name shadowing conflict"; //$NON-NLS-1$ |
| case CAT_DEPRECATION: |
| return "deprecation"; //$NON-NLS-1$ |
| case CAT_UNNECESSARY_CODE: |
| return "unnecessary code"; //$NON-NLS-1$ |
| case CAT_UNCHECKED_RAW: |
| return "unchecked/raw"; //$NON-NLS-1$ |
| case CAT_NLS: |
| return "nls"; //$NON-NLS-1$ |
| case CAT_RESTRICTION: |
| return "restriction"; //$NON-NLS-1$ |
| case CAT_MODULE: |
| return "module"; //$NON-NLS-1$ |
| case CAT_PREVIEW_RELATED: |
| return "preview related"; //$NON-NLS-1$ |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the marker type associated to this problem. |
| * @see org.eclipse.jdt.core.compiler.CategorizedProblem#getMarkerType() |
| */ |
| @Override |
| public String getMarkerType() { |
| return this.id == IProblem.Task |
| ? MARKER_TYPE_TASK |
| : MARKER_TYPE_PROBLEM; |
| } |
| |
| @Override |
| public String getMessage() { |
| return this.message; |
| } |
| |
| @Override |
| public char[] getOriginatingFileName() { |
| return this.fileName; |
| } |
| |
| @Override |
| public int getSourceEnd() { |
| return this.endPosition; |
| } |
| /** |
| * Answer the line number in source where the problem begins. |
| * @return int |
| */ |
| public int getSourceColumnNumber() { |
| return this.column; |
| } |
| |
| @Override |
| public int getSourceLineNumber() { |
| return this.line; |
| } |
| |
| @Override |
| public int getSourceStart() { |
| return this.startPosition; |
| } |
| |
| /* |
| * Helper method: checks the severity to see if the Error bit is set. |
| * @return boolean |
| */ |
| @Override |
| public boolean isError() { |
| return (this.severity & ProblemSeverities.Error) != 0; |
| } |
| |
| /* |
| * Helper method: checks the severity to see if the Error bit is not set. |
| * @return boolean |
| */ |
| @Override |
| public boolean isWarning() { |
| return (this.severity & ProblemSeverities.Error) == 0 |
| && (this.severity & ProblemSeverities.Info) == 0; |
| } |
| @Override |
| public boolean isInfo() { |
| return (this.severity & ProblemSeverities.Info) != 0; |
| } |
| |
| public void setOriginatingFileName(char[] fileName) { |
| this.fileName = fileName; |
| } |
| |
| @Override |
| public void setSourceEnd(int sourceEnd) { |
| this.endPosition = sourceEnd; |
| } |
| |
| @Override |
| public void setSourceLineNumber(int lineNumber) { |
| |
| this.line = lineNumber; |
| } |
| |
| @Override |
| public void setSourceStart(int sourceStart) { |
| this.startPosition = sourceStart; |
| } |
| |
| @Override |
| public String toString() { |
| String s = "Pb(" + (this.id & IProblem.IgnoreCategoriesMask) + ") "; //$NON-NLS-1$ //$NON-NLS-2$ |
| if (this.message != null) { |
| s += this.message; |
| } else { |
| if (this.arguments != null) |
| for (int i = 0; i < this.arguments.length; i++) |
| s += " " + this.arguments[i]; //$NON-NLS-1$ |
| } |
| return s; |
| } |
| //{ObjectTeams: treatment for problems in generated code: |
| /** |
| * mark this problem as referring to a generated element that should be ignored. |
| */ |
| public void markGenerated() { |
| this.severity |= ProblemSeverities.IgnoredGenerated; |
| } |
| /** |
| * Is this problem referring to a generated element, which is to be ignored? |
| */ |
| public boolean isInGenerated() { |
| return (this.severity & ProblemSeverities.IgnoredGenerated) != 0; |
| } |
| // SH} |
| } |