--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.problem;
+
+import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.core.compiler.IProblem;
+import org.eclipse.jdt.internal.compiler.*;
+import org.eclipse.jdt.internal.compiler.ast.*;
+import org.eclipse.jdt.internal.compiler.env.IConstants;
+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
+import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
+import org.eclipse.jdt.internal.compiler.lookup.*;
+import org.eclipse.jdt.internal.compiler.parser.*;
+import org.eclipse.jdt.internal.compiler.util.Util;
+
+public class ProblemReporter extends ProblemHandler implements ProblemReasons {
+
+ public ReferenceContext referenceContext;
+
+public ProblemReporter(IErrorHandlingPolicy policy, CompilerOptions options, IProblemFactory problemFactory) {
+ super(policy, options, problemFactory);
+}
+public void abortDueToInternalError(String errorMessage) {
+ String[] arguments = new String[] {errorMessage};
+ this.handle(
+ IProblem.Unclassified,
+ arguments,
+ arguments,
+ Error | Abort,
+ 0,
+ 0);
+}
+public void abortDueToInternalError(String errorMessage, ASTNode location) {
+ String[] arguments = new String[] {errorMessage};
+ this.handle(
+ IProblem.Unclassified,
+ arguments,
+ arguments,
+ Error | Abort,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void abstractMethodCannotBeOverridden(SourceTypeBinding type, MethodBinding concreteMethod) {
+
+ this.handle(
+ // %1 must be abstract since it cannot override the inherited package-private abstract method %2
+ IProblem.AbstractMethodCannotBeOverridden,
+ new String[] {
+ new String(type.sourceName()),
+ new String(
+ CharOperation.concat(
+ concreteMethod.declaringClass.readableName(),
+ concreteMethod.readableName(),
+ '.'))},
+ new String[] {
+ new String(type.sourceName()),
+ new String(
+ CharOperation.concat(
+ concreteMethod.declaringClass.shortReadableName(),
+ concreteMethod.shortReadableName(),
+ '.'))},
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void abstractMethodInAbstractClass(SourceTypeBinding type, AbstractMethodDeclaration methodDecl) {
+
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.AbstractMethodInAbstractClass,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void abstractMethodMustBeImplemented(SourceTypeBinding type, MethodBinding abstractMethod) {
+ this.handle(
+ // Must implement the inherited abstract method %1
+ // 8.4.3 - Every non-abstract subclass of an abstract type, A, must provide a concrete implementation of all of A's methods.
+ IProblem.AbstractMethodMustBeImplemented,
+ new String[] {
+ new String(
+ CharOperation.concat(
+ abstractMethod.declaringClass.readableName(),
+ abstractMethod.readableName(),
+ '.'))},
+ new String[] {
+ new String(
+ CharOperation.concat(
+ abstractMethod.declaringClass.shortReadableName(),
+ abstractMethod.shortReadableName(),
+ '.'))},
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void abstractMethodNeedingNoBody(AbstractMethodDeclaration method) {
+ this.handle(
+ IProblem.BodyForAbstractMethod,
+ NoArgument,
+ NoArgument,
+ method.sourceStart,
+ method.sourceEnd,
+ method,
+ method.compilationResult());
+}
+public void alreadyDefinedLabel(char[] labelName, ASTNode location) {
+ String[] arguments = new String[] {new String(labelName)};
+ this.handle(
+ IProblem.DuplicateLabel,
+ arguments,
+ arguments,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void anonymousClassCannotExtendFinalClass(Expression expression, TypeBinding type) {
+ this.handle(
+ IProblem.AnonymousClassCannotExtendFinalClass,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void argumentTypeCannotBeVoid(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, Argument arg) {
+ String[] arguments = new String[] {new String(methodDecl.selector), new String(arg.name)};
+ this.handle(
+ IProblem.ArgumentTypeCannotBeVoid,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void argumentTypeCannotBeVoidArray(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, Argument arg) {
+ String[] arguments = new String[] {new String(methodDecl.selector), new String(arg.name)};
+ this.handle(
+ IProblem.ArgumentTypeCannotBeVoidArray,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void argumentTypeProblem(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, Argument arg, TypeBinding expectedType) {
+ int problemId = expectedType.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.ArgumentTypeNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.ArgumentTypeNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.ArgumentTypeAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.ArgumentTypeInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.ArgumentTypeInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ this.handle(
+ id,
+ new String[] {new String(methodDecl.selector), new String(arg.name), new String(expectedType.readableName())},
+ new String[] {new String(methodDecl.selector), new String(arg.name), new String(expectedType.shortReadableName())},
+ arg.type.sourceStart,
+ arg.type.sourceEnd);
+}
+public void arrayConstantsOnlyInArrayInitializers(int sourceStart, int sourceEnd) {
+ this.handle(
+ IProblem.ArrayConstantsOnlyInArrayInitializers,
+ NoArgument,
+ NoArgument,
+ sourceStart,
+ sourceEnd);
+}
+public void assignmentHasNoEffect(Assignment assignment, char[] name){
+ String[] arguments = new String[] { new String(name) };
+ this.handle(
+ IProblem.AssignmentHasNoEffect,
+ arguments,
+ arguments,
+ assignment.sourceStart,
+ assignment.sourceEnd);
+}
+public void attemptToReturnNonVoidExpression(ReturnStatement returnStatement, TypeBinding expectedType) {
+ this.handle(
+ IProblem.VoidMethodReturnsValue,
+ new String[] {new String(expectedType.readableName())},
+ new String[] {new String(expectedType.shortReadableName())},
+ returnStatement.sourceStart,
+ returnStatement.sourceEnd);
+}
+public void attemptToReturnVoidValue(ReturnStatement returnStatement) {
+ this.handle(
+ IProblem.MethodReturnsVoid,
+ NoArgument,
+ NoArgument,
+ returnStatement.sourceStart,
+ returnStatement.sourceEnd);
+}
+public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location) {
+ String[] arguments = new String[] {new String(location.selector), parametersAsString(location.binding)};
+ if (location.isConstructor()) {
+ this.handle(
+ IProblem.BytecodeExceeds64KLimitForConstructor,
+ arguments,
+ arguments,
+ Error | Abort,
+ location.sourceStart,
+ location.sourceEnd);
+ } else {
+ this.handle(
+ IProblem.BytecodeExceeds64KLimit,
+ arguments,
+ arguments,
+ Error | Abort,
+ location.sourceStart,
+ location.sourceEnd);
+ }
+}
+public void bytecodeExceeds64KLimit(TypeDeclaration location) {
+ this.handle(
+ IProblem.BytecodeExceeds64KLimitForClinit,
+ NoArgument,
+ NoArgument,
+ Error | Abort,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void cannotAllocateVoidArray(Expression expression) {
+ this.handle(
+ IProblem.CannotAllocateVoidArray,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void cannotAssignToFinalField(FieldBinding field, ASTNode location) {
+ this.handle(
+ IProblem.FinalFieldAssignment,
+ new String[] {
+ (field.declaringClass == null ? "array" : new String(field.declaringClass.readableName())), //$NON-NLS-1$
+ new String(field.readableName())},
+ new String[] {
+ (field.declaringClass == null ? "array" : new String(field.declaringClass.shortReadableName())), //$NON-NLS-1$
+ new String(field.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void cannotAssignToFinalLocal(LocalVariableBinding local, ASTNode location) {
+ String[] arguments = new String[] { new String(local.readableName())};
+ this.handle(
+ IProblem.NonBlankFinalLocalAssignment,
+ arguments,
+ arguments,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void cannotAssignToFinalOuterLocal(LocalVariableBinding local, ASTNode location) {
+ String[] arguments = new String[] {new String(local.readableName())};
+ this.handle(
+ IProblem.FinalOuterLocalAssignment,
+ arguments,
+ arguments,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void cannotDeclareLocalInterface(char[] interfaceName, int sourceStart, int sourceEnd) {
+ String[] arguments = new String[] {new String(interfaceName)};
+ this.handle(
+ IProblem.CannotDefineInterfaceInLocalType,
+ arguments,
+ arguments,
+ sourceStart,
+ sourceEnd);
+}
+public void cannotDefineDimensionsAndInitializer(ArrayAllocationExpression expresssion) {
+ this.handle(
+ IProblem.CannotDefineDimensionExpressionsWithInit,
+ NoArgument,
+ NoArgument,
+ expresssion.sourceStart,
+ expresssion.sourceEnd);
+}
+public void cannotDireclyInvokeAbstractMethod(MessageSend messageSend, MethodBinding method) {
+ this.handle(
+ IProblem.DirectInvocationOfAbstractMethod,
+ new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)},
+ messageSend.sourceStart,
+ messageSend.sourceEnd);
+}
+public void cannotImportPackage(ImportReference importRef) {
+ String[] arguments = new String[] {CharOperation.toString(importRef.tokens)};
+ this.handle(
+ IProblem.CannotImportPackage,
+ arguments,
+ arguments,
+ importRef.sourceStart,
+ importRef.sourceEnd);
+}
+public void cannotInstantiate(TypeReference typeRef, TypeBinding type) {
+ this.handle(
+ IProblem.InvalidClassInstantiation,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ typeRef.sourceStart,
+ typeRef.sourceEnd);
+}
+public void cannotReferToNonFinalOuterLocal(LocalVariableBinding local, ASTNode location) {
+ String[] arguments =new String[]{ new String(local.readableName())};
+ this.handle(
+ IProblem.OuterLocalMustBeFinal,
+ arguments,
+ arguments,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void cannotReturnInInitializer(ASTNode location) {
+ this.handle(
+ IProblem.CannotReturnInInitializer,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void cannotThrowNull(ThrowStatement statement) {
+ this.handle(
+ IProblem.CannotThrowNull,
+ NoArgument,
+ NoArgument,
+ statement.sourceStart,
+ statement.sourceEnd);
+}
+public void cannotThrowType(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, TypeReference exceptionType, TypeBinding expectedType) {
+ this.handle(
+ IProblem.CannotThrowType,
+ new String[] {new String(expectedType.readableName())},
+ new String[] {new String(expectedType.shortReadableName())},
+ exceptionType.sourceStart,
+ exceptionType.sourceEnd);
+}
+public void cannotUseSuperInJavaLangObject(ASTNode reference) {
+ this.handle(
+ IProblem.ObjectHasNoSuperclass,
+ NoArgument,
+ NoArgument,
+ reference.sourceStart,
+ reference.sourceEnd);
+}
+public void cannotUseSuperInCodeSnippet(int start, int end) {
+ this.handle(
+ IProblem.CannotUseSuperInCodeSnippet,
+ NoArgument,
+ NoArgument,
+ Error | Abort,
+ start,
+ end);
+}
+public void caseExpressionMustBeConstant(Expression expression) {
+ this.handle(
+ IProblem.NonConstantExpression,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void classExtendFinalClass(SourceTypeBinding type, TypeReference superclass, TypeBinding expectedType) {
+ String name = new String(type.sourceName());
+ String expectedFullName = new String(expectedType.readableName());
+ String expectedShortName = new String(expectedType.shortReadableName());
+ if (expectedShortName.equals(name)) expectedShortName = expectedFullName;
+ this.handle(
+ IProblem.ClassExtendFinalClass,
+ new String[] {expectedFullName, name},
+ new String[] {expectedShortName, name},
+ superclass.sourceStart,
+ superclass.sourceEnd);
+}
+public void codeSnippetMissingClass(String missing, int start, int end) {
+ String[] arguments = new String[]{missing};
+ this.handle(
+ IProblem.CodeSnippetMissingClass,
+ arguments,
+ arguments,
+ Error | Abort,
+ start,
+ end);
+}
+public void codeSnippetMissingMethod(String className, String missingMethod, String argumentTypes, int start, int end) {
+ String[] arguments = new String[]{ className, missingMethod, argumentTypes };
+ this.handle(
+ IProblem.CodeSnippetMissingMethod,
+ arguments,
+ arguments,
+ Error | Abort,
+ start,
+ end);
+}
+/*
+ * Given the current configuration, answers which category the problem
+ * falls into:
+ * Error | Warning | Ignore
+ */
+public int computeSeverity(int problemId){
+
+ // severity can have been preset on the problem
+// if ((problem.severity & Fatal) != 0){
+// return Error;
+// }
+
+ // if not then check whether it is a configurable problem
+ switch(problemId){
+
+ case IProblem.MaskedCatch :
+ return this.options.getSeverity(CompilerOptions.MaskedCatchBlock);
+
+ case IProblem.UnusedImport :
+ return this.options.getSeverity(CompilerOptions.UnusedImport);
+
+ case IProblem.MethodButWithConstructorName :
+ return this.options.getSeverity(CompilerOptions.MethodWithConstructorName);
+
+ case IProblem.OverridingNonVisibleMethod :
+ return this.options.getSeverity(CompilerOptions.OverriddenPackageDefaultMethod);
+
+ case IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod :
+ case IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod :
+ return this.options.getSeverity(CompilerOptions.IncompatibleNonInheritedInterfaceMethod);
+
+ case IProblem.OverridingDeprecatedMethod :
+ case IProblem.UsingDeprecatedType :
+ case IProblem.UsingDeprecatedMethod :
+ case IProblem.UsingDeprecatedConstructor :
+ case IProblem.UsingDeprecatedField :
+ return this.options.getSeverity(CompilerOptions.UsingDeprecatedAPI);
+
+ case IProblem.LocalVariableIsNeverUsed :
+ return this.options.getSeverity(CompilerOptions.UnusedLocalVariable);
+
+ case IProblem.ArgumentIsNeverUsed :
+ return this.options.getSeverity(CompilerOptions.UnusedArgument);
+
+ case IProblem.NoImplicitStringConversionForCharArrayExpression :
+ return this.options.getSeverity(CompilerOptions.NoImplicitStringConversion);
+
+ case IProblem.NeedToEmulateFieldReadAccess :
+ case IProblem.NeedToEmulateFieldWriteAccess :
+ case IProblem.NeedToEmulateMethodAccess :
+ case IProblem.NeedToEmulateConstructorAccess :
+ return this.options.getSeverity(CompilerOptions.AccessEmulation);
+
+ case IProblem.NonExternalizedStringLiteral :
+ return this.options.getSeverity(CompilerOptions.NonExternalizedString);
+
+ case IProblem.UseAssertAsAnIdentifier :
+ return this.options.getSeverity(CompilerOptions.AssertUsedAsAnIdentifier);
+
+ case IProblem.NonStaticAccessToStaticMethod :
+ case IProblem.NonStaticAccessToStaticField :
+ return this.options.getSeverity(CompilerOptions.NonStaticAccessToStatic);
+
+ case IProblem.IndirectAccessToStaticMethod :
+ case IProblem.IndirectAccessToStaticField :
+ case IProblem.IndirectAccessToStaticType :
+ return this.options.getSeverity(CompilerOptions.IndirectStaticAccess);
+
+ case IProblem.AssignmentHasNoEffect:
+ return this.options.getSeverity(CompilerOptions.NoEffectAssignment);
+
+ case IProblem.UnusedPrivateConstructor:
+ case IProblem.UnusedPrivateMethod:
+ case IProblem.UnusedPrivateField:
+ case IProblem.UnusedPrivateType:
+ return this.options.getSeverity(CompilerOptions.UnusedPrivateMember);
+
+ case IProblem.Task :
+ return Warning;
+
+ case IProblem.LocalVariableHidingLocalVariable:
+ case IProblem.LocalVariableHidingField:
+ case IProblem.ArgumentHidingLocalVariable:
+ case IProblem.ArgumentHidingField:
+ return this.options.getSeverity(CompilerOptions.LocalVariableHiding);
+
+ case IProblem.FieldHidingLocalVariable:
+ case IProblem.FieldHidingField:
+ return this.options.getSeverity(CompilerOptions.FieldHiding);
+
+ case IProblem.PossibleAccidentalBooleanAssignment:
+ return this.options.getSeverity(CompilerOptions.AccidentalBooleanAssign);
+
+ case IProblem.SuperfluousSemicolon:
+ case IProblem.EmptyControlFlowStatement:
+ return this.options.getSeverity(CompilerOptions.EmptyStatement);
+
+ case IProblem.UndocumentedEmptyBlock:
+ return this.options.getSeverity(CompilerOptions.UndocumentedEmptyBlock);
+
+ case IProblem.UnnecessaryCast:
+ case IProblem.UnnecessaryArgumentCast:
+ case IProblem.UnnecessaryInstanceof:
+ return this.options.getSeverity(CompilerOptions.UnnecessaryTypeCheck);
+
+ case IProblem.FinallyMustCompleteNormally:
+ return this.options.getSeverity(CompilerOptions.FinallyBlockNotCompleting);
+
+ case IProblem.UnusedMethodDeclaredThrownException:
+ case IProblem.UnusedConstructorDeclaredThrownException:
+ return this.options.getSeverity(CompilerOptions.UnusedDeclaredThrownException);
+
+ case IProblem.UnqualifiedFieldAccess:
+ return this.options.getSeverity(CompilerOptions.UnqualifiedFieldAccess);
+
+ case IProblem.UnnecessaryElse:
+ return this.options.getSeverity(CompilerOptions.UnnecessaryElse);
+
+ /*
+ * Javadoc syntax errors
+ */
+ // Javadoc explicit IDs
+ case IProblem.JavadocUnexpectedTag:
+ case IProblem.JavadocDuplicateReturnTag:
+ case IProblem.JavadocInvalidThrowsClass:
+ case IProblem.JavadocInvalidSeeReference:
+ case IProblem.JavadocMalformedSeeReference:
+ case IProblem.JavadocInvalidSeeHref:
+ case IProblem.JavadocInvalidSeeArgs:
+ case IProblem.JavadocInvalidTag:
+ case IProblem.JavadocUnterminatedInlineTag:
+ if (this.options.docCommentSupport) {
+ return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
+
+ /*
+ * Javadoc tags resolved references errors
+ */
+ case IProblem.JavadocInvalidParamName:
+ case IProblem.JavadocDuplicateParamName:
+ case IProblem.JavadocMissingParamName:
+ case IProblem.JavadocInvalidThrowsClassName:
+ case IProblem.JavadocDuplicateThrowsClassName:
+ case IProblem.JavadocMissingThrowsClassName:
+ case IProblem.JavadocMissingSeeReference:
+ case IProblem.JavadocUsingDeprecatedField:
+ case IProblem.JavadocUsingDeprecatedConstructor:
+ case IProblem.JavadocUsingDeprecatedMethod:
+ case IProblem.JavadocUsingDeprecatedType:
+ case IProblem.JavadocUndefinedField:
+ case IProblem.JavadocNotVisibleField:
+ case IProblem.JavadocAmbiguousField:
+ case IProblem.JavadocUndefinedConstructor:
+ case IProblem.JavadocNotVisibleConstructor:
+ case IProblem.JavadocAmbiguousConstructor:
+ case IProblem.JavadocUndefinedMethod:
+ case IProblem.JavadocNotVisibleMethod:
+ case IProblem.JavadocAmbiguousMethod:
+ case IProblem.JavadocAmbiguousMethodReference:
+ case IProblem.JavadocParameterMismatch:
+ case IProblem.JavadocUndefinedType:
+ case IProblem.JavadocNotVisibleType:
+ case IProblem.JavadocAmbiguousType:
+ case IProblem.JavadocInternalTypeNameProvided:
+ case IProblem.JavadocNoMessageSendOnArrayType:
+ case IProblem.JavadocNoMessageSendOnBaseType:
+ case IProblem.JavadocInheritedMethodHidesEnclosingName:
+ case IProblem.JavadocInheritedFieldHidesEnclosingName:
+ case IProblem.JavadocInheritedNameHidesEnclosingTypeName:
+ if (this.options.docCommentSupport && this.options.reportInvalidJavadocTags) {
+ return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
+
+ /*
+ * Javadoc missing tags errors
+ */
+ case IProblem.JavadocMissingParamTag:
+ case IProblem.JavadocMissingReturnTag:
+ case IProblem.JavadocMissingThrowsTag:
+ if (this.options.docCommentSupport) {
+ return this.options.getSeverity(CompilerOptions.MissingJavadocTags);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
+
+ /*
+ * Missing Javadoc errors
+ */
+ case IProblem.JavadocMissing:
+ if (this.options.docCommentSupport) {
+ return this.options.getSeverity(CompilerOptions.MissingJavadocComments);
+ } else {
+ return ProblemSeverities.Ignore;
+ }
+
+ // by default problems are errors.
+ default:
+ return Error;
+ }
+}
+public void conditionalArgumentsIncompatibleTypes(ConditionalExpression expression, TypeBinding trueType, TypeBinding falseType) {
+ this.handle(
+ IProblem.IncompatibleTypesInConditionalOperator,
+ new String[] {new String(trueType.readableName()), new String(falseType.readableName())},
+ new String[] {new String(trueType.sourceName()), new String(falseType.sourceName())},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void conflictingImport(ImportReference importRef) {
+ String[] arguments = new String[] {CharOperation.toString(importRef.tokens)};
+ this.handle(
+ IProblem.ConflictingImport,
+ arguments,
+ arguments,
+ importRef.sourceStart,
+ importRef.sourceEnd);
+}
+public void constantOutOfFormat(NumberLiteral literal) {
+ // the literal is not in a correct format
+ // this code is called on IntLiteral and LongLiteral
+ // example 000811 ...the 8 is uncorrect.
+
+ if ((literal instanceof LongLiteral) || (literal instanceof IntLiteral)) {
+ char[] source = literal.source();
+ try {
+ final String Radix;
+ final int radix;
+ if ((source[1] == 'x') || (source[1] == 'X')) {
+ radix = 16;
+ Radix = "Hex"; //$NON-NLS-1$
+ } else {
+ radix = 8;
+ Radix = "Octal"; //$NON-NLS-1$
+ }
+ //look for the first digit that is incorrect
+ int place = -1;
+ label : for (int i = radix == 8 ? 1 : 2; i < source.length; i++) {
+ if (Character.digit(source[i], radix) == -1) {
+ place = i;
+ break label;
+ }
+ }
+ String[] arguments = new String[] {
+ new String(literal.literalType(null).readableName()), // numeric literals do not need scope to reach type
+ Radix + " " + new String(source) + " (digit " + new String(new char[] {source[place]}) + ")"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+ this.handle(
+ IProblem.NumericValueOutOfRange,
+ arguments,
+ arguments,
+ literal.sourceStart,
+ literal.sourceEnd);
+ return;
+ } catch (IndexOutOfBoundsException ex) {
+ // should never happen
+ }
+
+ // just in case .... use a predefined error..
+ // we should never come here...(except if the code changes !)
+ this.constantOutOfRange(literal, literal.literalType(null)); // numeric literals do not need scope to reach type
+ }
+}
+public void constantOutOfRange(Literal literal, TypeBinding literalType) {
+ String[] arguments = new String[] {new String(literalType.readableName()), new String(literal.source())};
+ this.handle(
+ IProblem.NumericValueOutOfRange,
+ arguments,
+ arguments,
+ literal.sourceStart,
+ literal.sourceEnd);
+}
+public void deprecatedField(FieldBinding field, ASTNode location) {
+ this.handle(
+ IProblem.UsingDeprecatedField,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void deprecatedMethod(MethodBinding method, ASTNode location) {
+ if (method.isConstructor()) {
+ this.handle(
+ IProblem.UsingDeprecatedConstructor,
+ new String[] {new String(method.declaringClass.readableName()), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), parametersAsShortString(method)},
+ location.sourceStart,
+ location.sourceEnd);
+ } else {
+ this.handle(
+ IProblem.UsingDeprecatedMethod,
+ new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)},
+ location.sourceStart,
+ location.sourceEnd);
+ }
+}
+public void deprecatedType(TypeBinding type, ASTNode location) {
+ if (location == null) return; // 1G828DN - no type ref for synthetic arguments
+ this.handle(
+ IProblem.UsingDeprecatedType,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void duplicateCase(CaseStatement caseStatement) {
+ this.handle(
+ IProblem.DuplicateCase,
+ NoArgument,
+ NoArgument,
+ caseStatement.sourceStart,
+ caseStatement.sourceEnd);
+}
+public void duplicateDefaultCase(ASTNode statement) {
+ this.handle(
+ IProblem.DuplicateDefaultCase,
+ NoArgument,
+ NoArgument,
+ statement.sourceStart,
+ statement.sourceEnd);
+}
+public void duplicateFieldInType(SourceTypeBinding type, FieldDeclaration fieldDecl) {
+ this.handle(
+ IProblem.DuplicateField,
+ new String[] {new String(type.sourceName()), new String(fieldDecl.name)},
+ new String[] {new String(type.shortReadableName()), new String(fieldDecl.name)},
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void duplicateImport(ImportReference importRef) {
+ String[] arguments = new String[] {CharOperation.toString(importRef.tokens)};
+ this.handle(
+ IProblem.DuplicateImport,
+ arguments,
+ arguments,
+ importRef.sourceStart,
+ importRef.sourceEnd);
+}
+public void duplicateInitializationOfBlankFinalField(FieldBinding field, Reference reference) {
+ String[] arguments = new String[]{ new String(field.readableName())};
+ this.handle(
+ IProblem.DuplicateBlankFinalFieldInitialization,
+ arguments,
+ arguments,
+ reference.sourceStart,
+ reference.sourceEnd);
+}
+public void duplicateInitializationOfFinalLocal(LocalVariableBinding local, ASTNode location) {
+ String[] arguments = new String[] { new String(local.readableName())};
+ this.handle(
+ IProblem.DuplicateFinalLocalInitialization,
+ arguments,
+ arguments,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void duplicateMethodInType(SourceTypeBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(methodDecl.selector), new String(type.sourceName())};
+ this.handle(
+ IProblem.DuplicateMethod,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void duplicateModifierForField(ReferenceBinding type, FieldDeclaration fieldDecl) {
+/* to highlight modifiers use:
+ this.handle(
+ new Problem(
+ DuplicateModifierForField,
+ new String[] {new String(fieldDecl.name)},
+ fieldDecl.modifiers.sourceStart,
+ fieldDecl.modifiers.sourceEnd));
+*/
+ String[] arguments = new String[] {new String(fieldDecl.name)};
+ this.handle(
+ IProblem.DuplicateModifierForField,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void duplicateModifierForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ this.handle(
+ IProblem.DuplicateModifierForMethod,
+ new String[] {new String(type.sourceName()), new String(methodDecl.selector)},
+ new String[] {new String(type.shortReadableName()), new String(methodDecl.selector)},
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void duplicateModifierForType(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.DuplicateModifierForType,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void duplicateModifierForVariable(LocalDeclaration localDecl, boolean complainForArgument) {
+ String[] arguments = new String[] {new String(localDecl.name)};
+ this.handle(
+ complainForArgument
+ ? IProblem.DuplicateModifierForArgument
+ : IProblem.DuplicateModifierForVariable,
+ arguments,
+ arguments,
+ localDecl.sourceStart,
+ localDecl.sourceEnd);
+}
+public void duplicateNestedType(TypeDeclaration typeDecl) {
+ String[] arguments = new String[] {new String(typeDecl.name)};
+ this.handle(
+ IProblem.DuplicateNestedType,
+ arguments,
+ arguments,
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd);
+}
+public void duplicateSuperinterface(SourceTypeBinding type, TypeDeclaration typeDecl, ReferenceBinding superType) {
+ this.handle(
+ IProblem.DuplicateSuperInterface,
+ new String[] {
+ new String(superType.readableName()),
+ new String(type.sourceName())},
+ new String[] {
+ new String(superType.shortReadableName()),
+ new String(type.sourceName())},
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd);
+}
+public void duplicateTypes(CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) {
+ String[] arguments = new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)};
+ this.referenceContext = typeDecl; // report the problem against the type not the entire compilation unit
+ this.handle(
+ IProblem.DuplicateTypes,
+ arguments,
+ arguments,
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd,
+ compUnitDecl.compilationResult);
+}
+public void emptyControlFlowStatement(int sourceStart, int sourceEnd) {
+ this.handle(
+ IProblem.EmptyControlFlowStatement,
+ NoArgument,
+ NoArgument,
+ sourceStart,
+ sourceEnd);
+}
+public void errorNoMethodFor(MessageSend messageSend, TypeBinding recType, TypeBinding[] params) {
+ StringBuffer buffer = new StringBuffer();
+ StringBuffer shortBuffer = new StringBuffer();
+ for (int i = 0, length = params.length; i < length; i++) {
+ if (i != 0){
+ buffer.append(", "); //$NON-NLS-1$
+ shortBuffer.append(", "); //$NON-NLS-1$
+ }
+ buffer.append(new String(params[i].readableName()));
+ shortBuffer.append(new String(params[i].shortReadableName()));
+ }
+
+ int id = recType.isArrayType() ? IProblem.NoMessageSendOnArrayType : IProblem.NoMessageSendOnBaseType;
+ /*
+ if ((messageSend.bits & ASTNode.InsideJavadoc) != 0) {
+ id |= IProblem.Javadoc;
+ if (!reportInvalidJavadocTagsVisibility()) return;
+ }
+ */
+ this.handle(
+ id,
+ new String[] {new String(recType.readableName()), new String(messageSend.selector), buffer.toString()},
+ new String[] {new String(recType.shortReadableName()), new String(messageSend.selector), shortBuffer.toString()},
+ messageSend.sourceStart,
+ messageSend.sourceEnd);
+}
+public void errorThisSuperInStatic(ASTNode reference) {
+ String[] arguments = new String[] {reference.isSuper() ? "super" : "this"}; //$NON-NLS-2$ //$NON-NLS-1$
+ this.handle(
+ IProblem.ThisInStaticContext,
+ arguments,
+ arguments,
+ reference.sourceStart,
+ reference.sourceEnd);
+}
+public void exceptionTypeProblem(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, TypeReference exceptionType, TypeBinding expectedType) {
+ int problemId = expectedType.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.ExceptionTypeNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.ExceptionTypeNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.ExceptionTypeAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.ExceptionTypeInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.ExceptionTypeInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ this.handle(
+ id,
+ new String[] {new String(methodDecl.selector), new String(expectedType.readableName())},
+ new String[] {new String(methodDecl.selector), new String(expectedType.shortReadableName())},
+ exceptionType.sourceStart,
+ exceptionType.sourceEnd);
+}
+public void expressionShouldBeAVariable(Expression expression) {
+ this.handle(
+ IProblem.ExpressionShouldBeAVariable,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void fieldHiding(FieldDeclaration fieldDecl, Binding hiddenVariable) {
+ FieldBinding field = fieldDecl.binding;
+ if (CharOperation.equals(TypeConstants.SERIALVERSIONUID, field.name)
+ && field.isStatic()
+ && field.isFinal()
+ && BaseTypes.LongBinding == field.type) {
+ return; // do not report unused serialVersionUID field
+ }
+ if (CharOperation.equals(TypeConstants.SERIALPERSISTENTFIELDS, field.name)
+ && field.isStatic()
+ && field.isFinal()
+ && field.type.dimensions() == 1
+ && CharOperation.equals(TypeConstants.CharArray_JAVA_IO_OBJECTSTREAMFIELD, field.type.leafComponentType().readableName())) {
+ return; // do not report unused serialPersistentFields field
+ }
+
+ if (hiddenVariable instanceof LocalVariableBinding) {
+ this.handle(
+ IProblem.FieldHidingLocalVariable,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name) },
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name) },
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+ } else if (hiddenVariable instanceof FieldBinding) {
+ FieldBinding hiddenField = (FieldBinding) hiddenVariable;
+ this.handle(
+ IProblem.FieldHidingField,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name) , new String(hiddenField.declaringClass.readableName()) },
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name) , new String(hiddenField.declaringClass.shortReadableName()) },
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+ }
+}
+private int fieldLocation(FieldBinding field, ASTNode node) {
+ if (node instanceof QualifiedNameReference) {
+ QualifiedNameReference ref = (QualifiedNameReference) node;
+ FieldBinding[] bindings = ref.otherBindings;
+ if (bindings != null)
+ for (int i = bindings.length; --i >= 0;)
+ if (bindings[i] == field)
+ return (int) ref.sourcePositions[i + 1]; // first position is for the primary field
+ }
+ return node.sourceEnd;
+}
+public void fieldsOrThisBeforeConstructorInvocation(ThisReference reference) {
+ this.handle(
+ IProblem.ThisSuperDuringConstructorInvocation,
+ NoArgument,
+ NoArgument,
+ reference.sourceStart,
+ reference.sourceEnd);
+}
+public void fieldTypeProblem(SourceTypeBinding type, FieldDeclaration fieldDecl, TypeBinding expectedType) {
+ int problemId = expectedType.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.FieldTypeNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.FieldTypeNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.FieldTypeAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.FieldTypeInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.FieldTypeInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ this.handle(
+ id,
+ new String[] {new String(fieldDecl.name), new String(type.sourceName()), new String(expectedType.readableName())},
+ new String[] {new String(fieldDecl.name), new String(type.sourceName()), new String(expectedType.shortReadableName())},
+ fieldDecl.type.sourceStart,
+ fieldDecl.type.sourceEnd);
+}
+public void finallyMustCompleteNormally(Block finallyBlock) {
+ this.handle(
+ IProblem.FinallyMustCompleteNormally,
+ NoArgument,
+ NoArgument,
+ finallyBlock.sourceStart,
+ finallyBlock.sourceEnd);
+}
+public void finalMethodCannotBeOverridden(MethodBinding currentMethod, MethodBinding inheritedMethod) {
+ this.handle(
+ // Cannot override the final method from %1
+ // 8.4.3.3 - Final methods cannot be overridden or hidden.
+ IProblem.FinalMethodCannotBeOverridden,
+ new String[] {new String(inheritedMethod.declaringClass.readableName())},
+ new String[] {new String(inheritedMethod.declaringClass.shortReadableName())},
+ currentMethod.sourceStart(),
+ currentMethod.sourceEnd());
+}
+public void forwardReference(Reference reference, int indexInQualification, TypeBinding type) {
+ this.handle(
+ IProblem.ReferenceToForwardField,
+ NoArgument,
+ NoArgument,
+ reference.sourceStart,
+ reference.sourceEnd);
+}
+// use this private API when the compilation unit result can be found through the
+// reference context. Otherwise, use the other API taking a problem and a compilation result
+// as arguments
+private void handle(
+ int problemId,
+ String[] problemArguments,
+ String[] messageArguments,
+ int problemStartPosition,
+ int problemEndPosition){
+
+ this.handle(
+ problemId,
+ problemArguments,
+ messageArguments,
+ problemStartPosition,
+ problemEndPosition,
+ this.referenceContext,
+ this.referenceContext == null ? null : this.referenceContext.compilationResult());
+ this.referenceContext = null;
+}
+// use this private API when the compilation unit result can be found through the
+// reference context. Otherwise, use the other API taking a problem and a compilation result
+// as arguments
+private void handle(
+ int problemId,
+ String[] problemArguments,
+ String[] messageArguments,
+ int severity,
+ int problemStartPosition,
+ int problemEndPosition){
+
+ this.handle(
+ problemId,
+ problemArguments,
+ messageArguments,
+ severity,
+ problemStartPosition,
+ problemEndPosition,
+ this.referenceContext,
+ this.referenceContext == null ? null : this.referenceContext.compilationResult());
+ this.referenceContext = null;
+}
+// use this private API when the compilation unit result cannot be found through the
+// reference context.
+
+private void handle(
+ int problemId,
+ String[] problemArguments,
+ String[] messageArguments,
+ int problemStartPosition,
+ int problemEndPosition,
+ CompilationResult unitResult){
+
+ this.handle(
+ problemId,
+ problemArguments,
+ messageArguments,
+ problemStartPosition,
+ problemEndPosition,
+ this.referenceContext,
+ unitResult);
+ this.referenceContext = null;
+}
+public void hiddenCatchBlock(ReferenceBinding exceptionType, ASTNode location) {
+ this.handle(
+ IProblem.MaskedCatch,
+ new String[] {
+ new String(exceptionType.readableName()),
+ },
+ new String[] {
+ new String(exceptionType.shortReadableName()),
+ },
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void hidingEnclosingType(TypeDeclaration typeDecl) {
+ String[] arguments = new String[] {new String(typeDecl.name)};
+ this.handle(
+ IProblem.HidingEnclosingType,
+ arguments,
+ arguments,
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd);
+}
+public void hierarchyCircularity(SourceTypeBinding sourceType, ReferenceBinding superType, TypeReference reference) {
+ int start = 0;
+ int end = 0;
+ String typeName = ""; //$NON-NLS-1$
+ String shortTypeName = ""; //$NON-NLS-1$
+
+ if (reference == null) { // can only happen when java.lang.Object is busted
+ start = sourceType.sourceStart();
+ end = sourceType.sourceEnd();
+ typeName = new String(superType.readableName());
+ shortTypeName = new String(superType.sourceName());
+ } else {
+ start = reference.sourceStart;
+ end = reference.sourceEnd;
+ char[][] qName = reference.getTypeName();
+ typeName = CharOperation.toString(qName);
+ shortTypeName = new String(qName[qName.length-1]);
+ }
+
+ if (sourceType == superType)
+ this.handle(
+ IProblem.HierarchyCircularitySelfReference,
+ new String[] {new String(sourceType.sourceName()), typeName},
+ new String[] {new String(sourceType.sourceName()), shortTypeName},
+ start,
+ end);
+ else
+ this.handle(
+ IProblem.HierarchyCircularity,
+ new String[] {new String(sourceType.sourceName()), typeName},
+ new String[] {new String(sourceType.sourceName()), shortTypeName},
+ start,
+ end);
+}
+public void hierarchyHasProblems(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.HierarchyHasProblems,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalAbstractModifierCombinationForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.IllegalAbstractModifierCombinationForMethod,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void illegalModifierCombinationFinalAbstractForClass(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalModifierCombinationFinalAbstractForClass,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalModifierCombinationFinalVolatileForField(ReferenceBinding type, FieldDeclaration fieldDecl) {
+ String[] arguments = new String[] {new String(fieldDecl.name)};
+
+ this.handle(
+ IProblem.IllegalModifierCombinationFinalVolatileForField,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+
+public void illegalModifierForClass(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalModifierForClass,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalModifierForField(ReferenceBinding type, FieldDeclaration fieldDecl) {
+ String[] arguments = new String[] {new String(fieldDecl.name)};
+ this.handle(
+ IProblem.IllegalModifierForField,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void illegalModifierForInterface(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalModifierForInterface,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalModifierForInterfaceField(ReferenceBinding type, FieldDeclaration fieldDecl) {
+ String[] arguments = new String[] {new String(fieldDecl.name)};
+ this.handle(
+ IProblem.IllegalModifierForInterfaceField,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void illegalModifierForInterfaceMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.IllegalModifierForInterfaceMethod,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void illegalModifierForLocalClass(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalModifierForLocalClass,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalModifierForMemberClass(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalModifierForMemberClass,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalModifierForMemberInterface(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalModifierForMemberInterface,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalModifierForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.IllegalModifierForMethod,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void illegalModifierForVariable(LocalDeclaration localDecl, boolean complainAsArgument) {
+ String[] arguments = new String[] {new String(localDecl.name)};
+ this.handle(
+ complainAsArgument
+ ? IProblem.IllegalModifierForArgument
+ : IProblem.IllegalModifierForVariable,
+ arguments,
+ arguments,
+ localDecl.sourceStart,
+ localDecl.sourceEnd);
+}
+public void illegalPrimitiveOrArrayTypeForEnclosingInstance(TypeBinding enclosingType, ASTNode location) {
+ this.handle(
+ IProblem.IllegalPrimitiveOrArrayTypeForEnclosingInstance,
+ new String[] {new String(enclosingType.readableName())},
+ new String[] {new String(enclosingType.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void illegalStaticModifierForMemberType(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalStaticModifierForMemberType,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalVisibilityModifierCombinationForField(ReferenceBinding type, FieldDeclaration fieldDecl) {
+ String[] arguments = new String[] {new String(fieldDecl.name)};
+ this.handle(
+ IProblem.IllegalVisibilityModifierCombinationForField,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void illegalVisibilityModifierCombinationForMemberType(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalVisibilityModifierCombinationForMemberType,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalVisibilityModifierCombinationForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.IllegalVisibilityModifierCombinationForMethod,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void illegalVisibilityModifierForInterfaceMemberType(SourceTypeBinding type) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+ this.handle(
+ IProblem.IllegalVisibilityModifierForInterfaceMemberType,
+ arguments,
+ arguments,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void illegalVoidExpression(ASTNode location) {
+ this.handle(
+ IProblem.InvalidVoidExpression,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void importProblem(ImportReference importRef, Binding expectedImport) {
+ int problemId = expectedImport.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.ImportNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.ImportNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.ImportAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.ImportInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.ImportInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ char[][] tokens = expectedImport instanceof ProblemReferenceBinding
+ ? ((ProblemReferenceBinding) expectedImport).compoundName
+ : importRef.tokens;
+ String[] arguments = new String[]{CharOperation.toString(tokens)};
+ this.handle(id, arguments, arguments, importRef.sourceStart, (int) importRef.sourcePositions[tokens.length - 1]);
+}
+public void incompatibleExceptionInThrowsClause(SourceTypeBinding type, MethodBinding currentMethod, MethodBinding inheritedMethod, ReferenceBinding exceptionType) {
+ if (type == currentMethod.declaringClass) {
+ int id;
+ if (currentMethod.declaringClass.isInterface()
+ && !inheritedMethod.isPublic()){ // interface inheriting Object protected method
+ id = IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod;
+ } else {
+ id = IProblem.IncompatibleExceptionInThrowsClause;
+ }
+ this.handle(
+ // Exception %1 is not compatible with throws clause in %2
+ // 9.4.4 - The type of exception in the throws clause is incompatible.
+ id,
+ new String[] {
+ new String(exceptionType.sourceName()),
+ new String(
+ CharOperation.concat(
+ inheritedMethod.declaringClass.readableName(),
+ inheritedMethod.readableName(),
+ '.'))},
+ new String[] {
+ new String(exceptionType.sourceName()),
+ new String(
+ CharOperation.concat(
+ inheritedMethod.declaringClass.shortReadableName(),
+ inheritedMethod.shortReadableName(),
+ '.'))},
+ currentMethod.sourceStart(),
+ currentMethod.sourceEnd());
+ } else
+ this.handle(
+ // Exception %1 in throws clause of %2 is not compatible with %3
+ // 9.4.4 - The type of exception in the throws clause is incompatible.
+ IProblem.IncompatibleExceptionInInheritedMethodThrowsClause,
+ new String[] {
+ new String(exceptionType.sourceName()),
+ new String(
+ CharOperation.concat(
+ currentMethod.declaringClass.sourceName(),
+ currentMethod.readableName(),
+ '.')),
+ new String(
+ CharOperation.concat(
+ inheritedMethod.declaringClass.readableName(),
+ inheritedMethod.readableName(),
+ '.'))},
+ new String[] {
+ new String(exceptionType.sourceName()),
+ new String(
+ CharOperation.concat(
+ currentMethod.declaringClass.sourceName(),
+ currentMethod.shortReadableName(),
+ '.')),
+ new String(
+ CharOperation.concat(
+ inheritedMethod.declaringClass.shortReadableName(),
+ inheritedMethod.shortReadableName(),
+ '.'))},
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void incompatibleReturnType(MethodBinding currentMethod, MethodBinding inheritedMethod) {
+ StringBuffer methodSignature = new StringBuffer();
+ methodSignature
+ .append(inheritedMethod.declaringClass.readableName())
+ .append('.')
+ .append(inheritedMethod.readableName());
+
+ StringBuffer shortSignature = new StringBuffer();
+ shortSignature
+ .append(inheritedMethod.declaringClass.shortReadableName())
+ .append('.')
+ .append(inheritedMethod.shortReadableName());
+
+ int id;
+ if (currentMethod.declaringClass.isInterface()
+ && !inheritedMethod.isPublic()){ // interface inheriting Object protected method
+ id = IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod;
+ } else {
+ id = IProblem.IncompatibleReturnType;
+ }
+ this.handle(
+ id,
+ new String[] {methodSignature.toString()},
+ new String[] {shortSignature.toString()},
+ currentMethod.sourceStart(),
+ currentMethod.sourceEnd());
+}
+public void incorrectLocationForEmptyDimension(ArrayAllocationExpression expression, int index) {
+ this.handle(
+ IProblem.IllegalDimension,
+ NoArgument,
+ NoArgument,
+ expression.dimensions[index + 1].sourceStart,
+ expression.dimensions[index + 1].sourceEnd);
+}
+public void indirectAccessToStaticField(ASTNode location, FieldBinding field){
+ this.handle(
+ IProblem.IndirectAccessToStaticField,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ location.sourceStart,
+ fieldLocation(field, location));
+}
+public void indirectAccessToStaticMethod(ASTNode location, MethodBinding method) {
+ this.handle(
+ IProblem.IndirectAccessToStaticMethod,
+ new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void indirectAccessToStaticType(ASTNode location, ReferenceBinding type) {
+ this.handle(
+ IProblem.IndirectAccessToStaticMethod,
+ new String[] {new String(type.enclosingType().readableName()), new String(type.sourceName) },
+ new String[] {new String(type.enclosingType().shortReadableName()), new String(type.sourceName) },
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void incorrectSwitchType(Expression expression, TypeBinding testType) {
+ this.handle(
+ IProblem.IncorrectSwitchType,
+ new String[] {new String(testType.readableName())},
+ new String[] {new String(testType.shortReadableName())},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void inheritedMethodReducesVisibility(SourceTypeBinding type, MethodBinding concreteMethod, MethodBinding[] abstractMethods) {
+ StringBuffer concreteSignature = new StringBuffer();
+ concreteSignature
+ .append(concreteMethod.declaringClass.readableName())
+ .append('.')
+ .append(concreteMethod.readableName());
+ StringBuffer shortSignature = new StringBuffer();
+ shortSignature
+ .append(concreteMethod.declaringClass.shortReadableName())
+ .append('.')
+ .append(concreteMethod.shortReadableName());
+ this.handle(
+ // The inherited method %1 cannot hide the public abstract method in %2
+ IProblem.InheritedMethodReducesVisibility,
+ new String[] {
+ concreteSignature.toString(),
+ new String(abstractMethods[0].declaringClass.readableName())},
+ new String[] {
+ new String(shortSignature.toString()),
+ new String(abstractMethods[0].declaringClass.shortReadableName())},
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void inheritedMethodsHaveIncompatibleReturnTypes(SourceTypeBinding type, MethodBinding[] inheritedMethods, int length) {
+ StringBuffer methodSignatures = new StringBuffer();
+ StringBuffer shortSignatures = new StringBuffer();
+ for (int i = length; --i >= 0;) {
+ methodSignatures
+ .append(inheritedMethods[i].declaringClass.readableName())
+ .append('.')
+ .append(inheritedMethods[i].readableName());
+ shortSignatures
+ .append(inheritedMethods[i].declaringClass.shortReadableName())
+ .append('.')
+ .append(inheritedMethods[i].shortReadableName());
+ if (i != 0){
+ methodSignatures.append(", "); //$NON-NLS-1$
+ shortSignatures.append(", "); //$NON-NLS-1$
+ }
+ }
+
+ this.handle(
+ // Return type is incompatible with %1
+ // 9.4.2 - The return type from the method is incompatible with the declaration.
+ IProblem.IncompatibleReturnType,
+ new String[] {methodSignatures.toString()},
+ new String[] {shortSignatures.toString()},
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void initializerMustCompleteNormally(FieldDeclaration fieldDecl) {
+ this.handle(
+ IProblem.InitializerMustCompleteNormally,
+ NoArgument,
+ NoArgument,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void innerTypesCannotDeclareStaticInitializers(ReferenceBinding innerType, ASTNode location) {
+ this.handle(
+ IProblem.CannotDefineStaticInitializerInLocalType,
+ new String[] {new String(innerType.readableName())},
+ new String[] {new String(innerType.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void interfaceCannotHaveConstructors(ConstructorDeclaration constructor) {
+ this.handle(
+ IProblem.InterfaceCannotHaveConstructors,
+ NoArgument,
+ NoArgument,
+ constructor.sourceStart,
+ constructor.sourceEnd,
+ constructor,
+ constructor.compilationResult());
+}
+public void interfaceCannotHaveInitializers(SourceTypeBinding type, FieldDeclaration fieldDecl) {
+ String[] arguments = new String[] {new String(type.sourceName())};
+
+ this.handle(
+ IProblem.InterfaceCannotHaveInitializers,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void invalidBreak(ASTNode location) {
+ this.handle(
+ IProblem.InvalidBreak,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void invalidConstructor(Statement statement, MethodBinding targetConstructor) {
+
+ boolean insideDefaultConstructor =
+ (this.referenceContext instanceof ConstructorDeclaration)
+ && ((ConstructorDeclaration)this.referenceContext).isDefaultConstructor();
+ boolean insideImplicitConstructorCall =
+ (statement instanceof ExplicitConstructorCall)
+ && (((ExplicitConstructorCall) statement).accessMode == ExplicitConstructorCall.ImplicitSuper);
+
+ int id = IProblem.UndefinedConstructor; //default...
+ switch (targetConstructor.problemId()) {
+ case NotFound :
+ if (insideDefaultConstructor){
+ id = IProblem.UndefinedConstructorInDefaultConstructor;
+ } else if (insideImplicitConstructorCall){
+ id = IProblem.UndefinedConstructorInImplicitConstructorCall;
+ } else {
+ id = IProblem.UndefinedConstructor;
+ }
+ break;
+ case NotVisible :
+ if (insideDefaultConstructor){
+ id = IProblem.NotVisibleConstructorInDefaultConstructor;
+ } else if (insideImplicitConstructorCall){
+ id = IProblem.NotVisibleConstructorInImplicitConstructorCall;
+ } else {
+ id = IProblem.NotVisibleConstructor;
+ }
+ break;
+ case Ambiguous :
+ if (insideDefaultConstructor){
+ id = IProblem.AmbiguousConstructorInDefaultConstructor;
+ } else if (insideImplicitConstructorCall){
+ id = IProblem.AmbiguousConstructorInImplicitConstructorCall;
+ } else {
+ id = IProblem.AmbiguousConstructor;
+ }
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ this.handle(
+ id,
+ new String[] {new String(targetConstructor.declaringClass.readableName()), parametersAsString(targetConstructor)},
+ new String[] {new String(targetConstructor.declaringClass.shortReadableName()), parametersAsShortString(targetConstructor)},
+ statement.sourceStart,
+ statement.sourceEnd);
+}
+
+public void invalidExplicitConstructorCall(ASTNode location) {
+
+ this.handle(
+ IProblem.InvalidExplicitConstructorCall,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void invalidContinue(ASTNode location) {
+ this.handle(
+ IProblem.InvalidContinue,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void invalidEnclosingType(Expression expression, TypeBinding type, ReferenceBinding enclosingType) {
+
+ if (enclosingType.isAnonymousType()) enclosingType = enclosingType.superclass();
+ int flag = IProblem.UndefinedType; // default
+ switch (type.problemId()) {
+ case NotFound : // 1
+ flag = IProblem.UndefinedType;
+ break;
+ case NotVisible : // 2
+ flag = IProblem.NotVisibleType;
+ break;
+ case Ambiguous : // 3
+ flag = IProblem.AmbiguousType;
+ break;
+ case InternalNameProvided :
+ flag = IProblem.InternalTypeNameProvided;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ this.handle(
+ flag,
+ new String[] {new String(enclosingType.readableName()) + "." + new String(type.readableName())}, //$NON-NLS-1$
+ new String[] {new String(enclosingType.shortReadableName()) + "." + new String(type.shortReadableName())}, //$NON-NLS-1$
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidExpressionAsStatement(Expression expression){
+ this.handle(
+ IProblem.InvalidExpressionAsStatement,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidField(FieldReference fieldRef, TypeBinding searchedType) {
+ int id = IProblem.UndefinedField;
+ FieldBinding field = fieldRef.binding;
+ switch (field.problemId()) {
+ case NotFound :
+ id = IProblem.UndefinedField;
+/* also need to check that the searchedType is the receiver type
+ if (searchedType.isHierarchyInconsistent())
+ severity = SecondaryError;
+*/
+ break;
+ case NotVisible :
+ id = IProblem.NotVisibleField;
+ break;
+ case Ambiguous :
+ id = IProblem.AmbiguousField;
+ break;
+ case NonStaticReferenceInStaticContext :
+ id = IProblem.NonStaticFieldFromStaticInvocation;
+ break;
+ case NonStaticReferenceInConstructorInvocation :
+ id = IProblem.InstanceFieldDuringConstructorInvocation;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.InheritedFieldHidesEnclosingName;
+ break;
+ case ReceiverTypeNotVisible :
+ this.handle(
+ IProblem.NotVisibleType, // cannot occur in javadoc comments
+ new String[] {new String(searchedType.leafComponentType().readableName())},
+ new String[] {new String(searchedType.leafComponentType().shortReadableName())},
+ fieldRef.receiver.sourceStart,
+ fieldRef.receiver.sourceEnd);
+ return;
+
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ String[] arguments = new String[] {new String(field.readableName())};
+ this.handle(
+ id,
+ arguments,
+ arguments,
+ fieldRef.sourceStart,
+ fieldRef.sourceEnd);
+}
+public void invalidField(NameReference nameRef, FieldBinding field) {
+ int id = IProblem.UndefinedField;
+ switch (field.problemId()) {
+ case NotFound :
+ id = IProblem.UndefinedField;
+ break;
+ case NotVisible :
+ id = IProblem.NotVisibleField;
+ break;
+ case Ambiguous :
+ id = IProblem.AmbiguousField;
+ break;
+ case NonStaticReferenceInStaticContext :
+ id = IProblem.NonStaticFieldFromStaticInvocation;
+ break;
+ case NonStaticReferenceInConstructorInvocation :
+ id = IProblem.InstanceFieldDuringConstructorInvocation;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.InheritedFieldHidesEnclosingName;
+ break;
+ case ReceiverTypeNotVisible :
+ this.handle(
+ IProblem.NotVisibleType,
+ new String[] {new String(field.declaringClass.leafComponentType().readableName())},
+ new String[] {new String(field.declaringClass.leafComponentType().shortReadableName())},
+ nameRef.sourceStart,
+ nameRef.sourceEnd);
+ return;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+ String[] arguments = new String[] {new String(field.readableName())};
+ this.handle(
+ id,
+ arguments,
+ arguments,
+ nameRef.sourceStart,
+ nameRef.sourceEnd);
+}
+public void invalidField(QualifiedNameReference nameRef, FieldBinding field, int index, TypeBinding searchedType) {
+ //the resolution of the index-th field of qname failed
+ //qname.otherBindings[index] is the binding that has produced the error
+
+ //The different targetted errors should be :
+ //UndefinedField
+ //NotVisibleField
+ //AmbiguousField
+
+ if (searchedType.isBaseType()) {
+ this.handle(
+ IProblem.NoFieldOnBaseType,
+ new String[] {
+ new String(searchedType.readableName()),
+ CharOperation.toString(CharOperation.subarray(nameRef.tokens, 0, index)),
+ new String(nameRef.tokens[index])},
+ new String[] {
+ new String(searchedType.sourceName()),
+ CharOperation.toString(CharOperation.subarray(nameRef.tokens, 0, index)),
+ new String(nameRef.tokens[index])},
+ nameRef.sourceStart,
+ (int) nameRef.sourcePositions[index]);
+ return;
+ }
+
+ int id = IProblem.UndefinedField;
+ switch (field.problemId()) {
+ case NotFound :
+ id = IProblem.UndefinedField;
+/* also need to check that the searchedType is the receiver type
+ if (searchedType.isHierarchyInconsistent())
+ severity = SecondaryError;
+*/
+ break;
+ case NotVisible :
+ id = IProblem.NotVisibleField;
+ break;
+ case Ambiguous :
+ id = IProblem.AmbiguousField;
+ break;
+ case NonStaticReferenceInStaticContext :
+ id = IProblem.NonStaticFieldFromStaticInvocation;
+ break;
+ case NonStaticReferenceInConstructorInvocation :
+ id = IProblem.InstanceFieldDuringConstructorInvocation;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.InheritedFieldHidesEnclosingName;
+ break;
+ case ReceiverTypeNotVisible :
+ this.handle(
+ IProblem.NotVisibleType,
+ new String[] {new String(searchedType.leafComponentType().readableName())},
+ new String[] {new String(searchedType.leafComponentType().shortReadableName())},
+ nameRef.sourceStart,
+ nameRef.sourceEnd);
+ return;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+ String[] arguments = new String[] {CharOperation.toString(CharOperation.subarray(nameRef.tokens, 0, index + 1))};
+ this.handle(
+ id,
+ arguments,
+ arguments,
+ nameRef.sourceStart,
+ (int) nameRef.sourcePositions[index]);
+}
+public void invalidMethod(MessageSend messageSend, MethodBinding method) {
+ // CODE should be UPDATED according to error coding in the different method binding errors
+ // The different targetted errors should be :
+ // UndefinedMethod
+ // NotVisibleMethod
+ // AmbiguousMethod
+ // InheritedNameHidesEnclosingName
+ // InstanceMethodDuringConstructorInvocation
+ // StaticMethodRequested
+
+ int id = IProblem.UndefinedMethod; //default...
+ switch (method.problemId()) {
+ case NotFound :
+ id = IProblem.UndefinedMethod;
+ break;
+ case NotVisible :
+ id = IProblem.NotVisibleMethod;
+ break;
+ case Ambiguous :
+ id = IProblem.AmbiguousMethod;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.InheritedMethodHidesEnclosingName;
+ break;
+ case NonStaticReferenceInConstructorInvocation :
+ id = IProblem.InstanceMethodDuringConstructorInvocation;
+ break;
+ case NonStaticReferenceInStaticContext :
+ id = IProblem.StaticMethodRequested;
+ break;
+ case ReceiverTypeNotVisible :
+ this.handle(
+ IProblem.NotVisibleType, // cannot occur in javadoc comments
+ new String[] {new String(method.declaringClass.leafComponentType().readableName())},
+ new String[] {new String(method.declaringClass.leafComponentType().shortReadableName())},
+ messageSend.receiver.sourceStart,
+ messageSend.receiver.sourceEnd);
+ return;
+
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ if (id == IProblem.UndefinedMethod) {
+ ProblemMethodBinding problemMethod = (ProblemMethodBinding) method;
+ if (problemMethod.closestMatch != null) {
+ String closestParameterTypeNames = parametersAsString(problemMethod.closestMatch);
+ String parameterTypeNames = parametersAsString(method);
+ String closestParameterTypeShortNames = parametersAsShortString(problemMethod.closestMatch);
+ String parameterTypeShortNames = parametersAsShortString(method);
+ if (closestParameterTypeShortNames.equals(parameterTypeShortNames)){
+ closestParameterTypeShortNames = closestParameterTypeNames;
+ parameterTypeShortNames = parameterTypeNames;
+ }
+ id = IProblem.ParameterMismatch;
+ this.handle(
+ id,
+ new String[] {
+ new String(problemMethod.closestMatch.declaringClass.readableName()),
+ new String(problemMethod.closestMatch.selector),
+ closestParameterTypeNames,
+ parameterTypeNames
+ },
+ new String[] {
+ new String(problemMethod.closestMatch.declaringClass.shortReadableName()),
+ new String(problemMethod.closestMatch.selector),
+ closestParameterTypeShortNames,
+ parameterTypeShortNames
+ },
+ (int) (messageSend.nameSourcePosition >>> 32),
+ (int) messageSend.nameSourcePosition);
+ return;
+ }
+ }
+
+ this.handle(
+ id,
+ new String[] {
+ new String(method.declaringClass.readableName()),
+ new String(method.selector), parametersAsString(method)},
+ new String[] {
+ new String(method.declaringClass.shortReadableName()),
+ new String(method.selector), parametersAsShortString(method)},
+ (int) (messageSend.nameSourcePosition >>> 32),
+ (int) messageSend.nameSourcePosition);
+}
+public void invalidNullToSynchronize(Expression expression) {
+ this.handle(
+ IProblem.InvalidNullToSynchronized,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidOperator(BinaryExpression expression, TypeBinding leftType, TypeBinding rightType) {
+ String leftName = new String(leftType.readableName());
+ String rightName = new String(rightType.readableName());
+ String leftShortName = new String(leftType.shortReadableName());
+ String rightShortName = new String(rightType.shortReadableName());
+ if (leftShortName.equals(rightShortName)){
+ leftShortName = leftName;
+ rightShortName = rightName;
+ }
+ this.handle(
+ IProblem.InvalidOperator,
+ new String[] {
+ expression.operatorToString(),
+ leftName + ", " + rightName}, //$NON-NLS-1$
+ new String[] {
+ expression.operatorToString(),
+ leftShortName + ", " + rightShortName}, //$NON-NLS-1$
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidOperator(CompoundAssignment assign, TypeBinding leftType, TypeBinding rightType) {
+ String leftName = new String(leftType.readableName());
+ String rightName = new String(rightType.readableName());
+ String leftShortName = new String(leftType.shortReadableName());
+ String rightShortName = new String(rightType.shortReadableName());
+ if (leftShortName.equals(rightShortName)){
+ leftShortName = leftName;
+ rightShortName = rightName;
+ }
+ this.handle(
+ IProblem.InvalidOperator,
+ new String[] {
+ assign.operatorToString(),
+ leftName + ", " + rightName}, //$NON-NLS-1$
+ new String[] {
+ assign.operatorToString(),
+ leftShortName + ", " + rightShortName}, //$NON-NLS-1$
+ assign.sourceStart,
+ assign.sourceEnd);
+}
+public void invalidOperator(UnaryExpression expression, TypeBinding type) {
+ this.handle(
+ IProblem.InvalidOperator,
+ new String[] {expression.operatorToString(), new String(type.readableName())},
+ new String[] {expression.operatorToString(), new String(type.shortReadableName())},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidParenthesizedExpression(ASTNode reference) {
+ this.handle(
+ IProblem.InvalidParenthesizedExpression,
+ NoArgument,
+ NoArgument,
+ reference.sourceStart,
+ reference.sourceEnd);
+}
+public void invalidSuperclass(SourceTypeBinding type, TypeReference superclassRef, ReferenceBinding expectedType) {
+ int problemId = expectedType.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.SuperclassNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.SuperclassNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.SuperclassAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.SuperclassInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.SuperclassInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ this.handle(
+ id,
+ new String[] {new String(expectedType.readableName()), new String(type.sourceName())},
+ new String[] {new String(expectedType.shortReadableName()), new String(type.sourceName())},
+ superclassRef.sourceStart,
+ superclassRef.sourceEnd);
+}
+public void invalidSuperinterface(SourceTypeBinding type, TypeReference superinterfaceRef, ReferenceBinding expectedType) {
+ int problemId = expectedType.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.InterfaceNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.InterfaceNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.InterfaceAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.InterfaceInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.InterfaceInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ this.handle(
+ id,
+ new String[] {new String(expectedType.readableName()), new String(type.sourceName())},
+ new String[] {new String(expectedType.shortReadableName()), new String(type.sourceName())},
+ superinterfaceRef.sourceStart,
+ superinterfaceRef.sourceEnd);
+}
+public void invalidType(ASTNode location, TypeBinding type) {
+ int id = IProblem.UndefinedType; // default
+ switch (type.problemId()) {
+ case NotFound :
+ id = IProblem.UndefinedType;
+ break;
+ case NotVisible :
+ id = IProblem.NotVisibleType;
+ break;
+ case Ambiguous :
+ id = IProblem.AmbiguousType;
+ break;
+ case InternalNameProvided :
+ id = IProblem.InternalTypeNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.InheritedTypeHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ int end = location.sourceEnd;
+ if (location instanceof QualifiedNameReference) {
+ QualifiedNameReference ref = (QualifiedNameReference) location;
+ if (ref.indexOfFirstFieldBinding >= 1)
+ end = (int) ref.sourcePositions[ref.indexOfFirstFieldBinding - 1];
+ }
+ this.handle(
+ id,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ location.sourceStart,
+ end);
+}
+public void invalidTypeReference(Expression expression) {
+ this.handle(
+ IProblem.InvalidTypeExpression,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidTypeToSynchronize(Expression expression, TypeBinding type) {
+ this.handle(
+ IProblem.InvalidTypeToSynchronized,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void invalidUnaryExpression(Expression expression) {
+ this.handle(
+ IProblem.InvalidUnaryExpression,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void isClassPathCorrect(char[][] wellKnownTypeName, CompilationUnitDeclaration compUnitDecl) {
+ this.referenceContext = compUnitDecl;
+ String[] arguments = new String[] {CharOperation.toString(wellKnownTypeName)};
+ this.handle(
+ IProblem.IsClassPathCorrect,
+ arguments,
+ arguments,
+ AbortCompilation | Error,
+ 0,
+ 0);
+}
+public void javadocDuplicatedReturnTag(int sourceStart, int sourceEnd){
+ this.handle(IProblem.JavadocDuplicateReturnTag, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocDeprecatedField(FieldBinding field, ASTNode location, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ this.handle(
+ IProblem.JavadocUsingDeprecatedField,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ location.sourceStart,
+ location.sourceEnd);
+ }
+}
+public void javadocDeprecatedMethod(MethodBinding method, ASTNode location, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ if (method.isConstructor()) {
+ this.handle(
+ IProblem.JavadocUsingDeprecatedConstructor,
+ new String[] {new String(method.declaringClass.readableName()), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), parametersAsShortString(method)},
+ location.sourceStart,
+ location.sourceEnd);
+ } else {
+ this.handle(
+ IProblem.JavadocUsingDeprecatedMethod,
+ new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)},
+ location.sourceStart,
+ location.sourceEnd);
+ }
+ }
+}
+public void javadocDeprecatedType(TypeBinding type, ASTNode location, int modifiers) {
+ if (location == null) return; // 1G828DN - no type ref for synthetic arguments
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ this.handle(
+ IProblem.JavadocUsingDeprecatedType,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+ }
+}
+public void javadocDuplicatedParamTag(JavadocSingleNameReference param, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] {String.valueOf(param.token)};
+ this.handle(IProblem.JavadocDuplicateParamName, arguments, arguments, param.sourceStart, param.sourceEnd);
+ }
+}
+public void javadocDuplicatedThrowsClassName(TypeReference typeReference, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] {String.valueOf(typeReference.resolvedType.sourceName())};
+ this.handle(IProblem.JavadocDuplicateThrowsClassName, arguments, arguments, typeReference.sourceStart, typeReference.sourceEnd);
+ }
+}
+public void javadocErrorNoMethodFor(MessageSend messageSend, TypeBinding recType, TypeBinding[] params, int modifiers) {
+ StringBuffer buffer = new StringBuffer();
+ StringBuffer shortBuffer = new StringBuffer();
+ for (int i = 0, length = params.length; i < length; i++) {
+ if (i != 0){
+ buffer.append(", "); //$NON-NLS-1$
+ shortBuffer.append(", "); //$NON-NLS-1$
+ }
+ buffer.append(new String(params[i].readableName()));
+ shortBuffer.append(new String(params[i].shortReadableName()));
+ }
+
+ int id = recType.isArrayType() ? IProblem.JavadocNoMessageSendOnArrayType : IProblem.JavadocNoMessageSendOnBaseType;
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ this.handle(
+ id,
+ new String[] {new String(recType.readableName()), new String(messageSend.selector), buffer.toString()},
+ new String[] {new String(recType.shortReadableName()), new String(messageSend.selector), shortBuffer.toString()},
+ messageSend.sourceStart,
+ messageSend.sourceEnd);
+ }
+}
+public void javadocInvalidConstructor(Statement statement, MethodBinding targetConstructor, int modifiers) {
+
+ if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ return;
+ }
+// boolean insideDefaultConstructor =
+// (this.referenceContext instanceof ConstructorDeclaration)
+// && ((ConstructorDeclaration)this.referenceContext).isDefaultConstructor();
+// boolean insideImplicitConstructorCall =
+// (statement instanceof ExplicitConstructorCall)
+// && (((ExplicitConstructorCall) statement).accessMode == ExplicitConstructorCall.ImplicitSuper);
+
+ int id = IProblem.JavadocUndefinedConstructor; //default...
+ switch (targetConstructor.problemId()) {
+ case NotFound :
+// if (insideDefaultConstructor){
+// id = IProblem.JavadocUndefinedConstructorInDefaultConstructor;
+// } else if (insideImplicitConstructorCall){
+// id = IProblem.JavadocUndefinedConstructorInImplicitConstructorCall;
+// } else {
+ id = IProblem.JavadocUndefinedConstructor;
+// }
+ break;
+ case NotVisible :
+// if (insideDefaultConstructor){
+// id = IProblem.JavadocNotVisibleConstructorInDefaultConstructor;
+// } else if (insideImplicitConstructorCall){
+// id = IProblem.JavadocNotVisibleConstructorInImplicitConstructorCall;
+// } else {
+ id = IProblem.JavadocNotVisibleConstructor;
+// }
+ break;
+ case Ambiguous :
+// if (insideDefaultConstructor){
+// id = IProblem.AmbiguousConstructorInDefaultConstructor;
+// } else if (insideImplicitConstructorCall){
+// id = IProblem.AmbiguousConstructorInImplicitConstructorCall;
+// } else {
+ id = IProblem.JavadocAmbiguousConstructor;
+// }
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ this.handle(
+ id,
+ new String[] {new String(targetConstructor.declaringClass.readableName()), parametersAsString(targetConstructor)},
+ new String[] {new String(targetConstructor.declaringClass.shortReadableName()), parametersAsShortString(targetConstructor)},
+ statement.sourceStart,
+ statement.sourceEnd);
+}
+public void javadocAmbiguousMethodReference(int sourceStart, int sourceEnd, Binding fieldBinding, int modifiers) {
+ int id = IProblem.JavadocAmbiguousMethodReference;
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] {new String(fieldBinding.readableName())};
+ handle(id, arguments, arguments, sourceStart, sourceEnd);
+ }
+}
+/*
+ * Similar implementation than invalidField(FieldReference...)
+ * Note that following problem id cannot occur for Javadoc:
+ * - NonStaticReferenceInStaticContext :
+ * - NonStaticReferenceInConstructorInvocation :
+ * - ReceiverTypeNotVisible :
+ */
+public void javadocInvalidField(int sourceStart, int sourceEnd, Binding fieldBinding, TypeBinding searchedType, int modifiers) {
+ int id = IProblem.JavadocUndefinedField;
+ switch (fieldBinding.problemId()) {
+ case NotFound :
+ id = IProblem.JavadocUndefinedField;
+ break;
+ case NotVisible :
+ id = IProblem.JavadocNotVisibleField;
+ break;
+ case Ambiguous :
+ id = IProblem.JavadocAmbiguousField;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.JavadocInheritedFieldHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] {new String(fieldBinding.readableName())};
+ handle(id, arguments, arguments, sourceStart, sourceEnd);
+ }
+}
+/*
+ * Similar implementation than invalidMethod(MessageSend...)
+ * Note that following problem id cannot occur for Javadoc:
+ * - NonStaticReferenceInStaticContext :
+ * - NonStaticReferenceInConstructorInvocation :
+ * - ReceiverTypeNotVisible :
+ */
+public void javadocInvalidMethod(MessageSend messageSend, MethodBinding method, int modifiers) {
+ if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ return;
+ }
+ int id = IProblem.JavadocUndefinedMethod; //default...
+ switch (method.problemId()) {
+ case NotFound :
+ id = IProblem.JavadocUndefinedMethod;
+ break;
+ case NotVisible :
+ id = IProblem.JavadocNotVisibleMethod;
+ break;
+ case Ambiguous :
+ id = IProblem.JavadocAmbiguousMethod;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.JavadocInheritedMethodHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+
+ if (id == IProblem.JavadocUndefinedMethod) {
+ ProblemMethodBinding problemMethod = (ProblemMethodBinding) method;
+ if (problemMethod.closestMatch != null) {
+ String closestParameterTypeNames = parametersAsString(problemMethod.closestMatch);
+ String parameterTypeNames = parametersAsString(method);
+ String closestParameterTypeShortNames = parametersAsShortString(problemMethod.closestMatch);
+ String parameterTypeShortNames = parametersAsShortString(method);
+ if (closestParameterTypeShortNames.equals(parameterTypeShortNames)){
+ closestParameterTypeShortNames = closestParameterTypeNames;
+ parameterTypeShortNames = parameterTypeNames;
+ }
+ this.handle(
+ IProblem.JavadocParameterMismatch,
+ new String[] {
+ new String(problemMethod.closestMatch.declaringClass.readableName()),
+ new String(problemMethod.closestMatch.selector),
+ closestParameterTypeNames,
+ parameterTypeNames
+ },
+ new String[] {
+ new String(problemMethod.closestMatch.declaringClass.shortReadableName()),
+ new String(problemMethod.closestMatch.selector),
+ closestParameterTypeShortNames,
+ parameterTypeShortNames
+ },
+ (int) (messageSend.nameSourcePosition >>> 32),
+ (int) messageSend.nameSourcePosition);
+ return;
+ }
+ }
+
+ this.handle(
+ id,
+ new String[] {
+ new String(method.declaringClass.readableName()),
+ new String(method.selector), parametersAsString(method)},
+ new String[] {
+ new String(method.declaringClass.shortReadableName()),
+ new String(method.selector), parametersAsShortString(method)},
+ (int) (messageSend.nameSourcePosition >>> 32),
+ (int) messageSend.nameSourcePosition);
+}
+public void javadocInvalidParamName(JavadocSingleNameReference param, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] {String.valueOf(param.token)};
+ this.handle(IProblem.JavadocInvalidParamName, arguments, arguments, param.sourceStart, param.sourceEnd);
+ }
+}
+public void javadocInvalidSeeReference(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocInvalidSeeReference, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocInvalidSeeReferenceArgs(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocInvalidSeeArgs, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocInvalidSeeUrlReference(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocInvalidSeeHref, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocInvalidTag(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocInvalidTag, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocInvalidThrowsClass(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocInvalidThrowsClass, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocInvalidThrowsClassName(TypeReference typeReference, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] {String.valueOf(typeReference.resolvedType.sourceName())};
+ this.handle(IProblem.JavadocInvalidThrowsClassName, arguments, arguments, typeReference.sourceStart, typeReference.sourceEnd);
+ }
+}
+public void javadocInvalidType(ASTNode location, TypeBinding type, int modifiers) {
+ if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) {
+ int id = IProblem.JavadocUndefinedType; // default
+ switch (type.problemId()) {
+ case NotFound :
+ id = IProblem.JavadocUndefinedType;
+ break;
+ case NotVisible :
+ id = IProblem.JavadocNotVisibleType;
+ break;
+ case Ambiguous :
+ id = IProblem.JavadocAmbiguousType;
+ break;
+ case InternalNameProvided :
+ id = IProblem.JavadocInternalTypeNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName :
+ id = IProblem.JavadocInheritedNameHidesEnclosingTypeName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ break;
+ }
+ this.handle(
+ id,
+ new String[] {new String(type.readableName())},
+ new String[] {new String(type.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+ }
+}
+public void javadocMalformedSeeReference(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocMalformedSeeReference, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocMissing(int sourceStart, int sourceEnd, int modifiers){
+ boolean overriding = (modifiers & (CompilerModifiers.AccImplementing+CompilerModifiers.AccOverriding)) != 0;
+ boolean report = (this.options.getSeverity(CompilerOptions.MissingJavadocComments) != ProblemSeverities.Ignore)
+ && (!overriding || this.options.reportMissingJavadocCommentsOverriding);
+ if (report) {
+ String arg = javadocVisibilityArgument(this.options.reportMissingJavadocCommentsVisibility, modifiers);
+ if (arg != null) {
+ String[] arguments = new String[] { arg };
+ this.handle(IProblem.JavadocMissing, arguments, arguments, sourceStart, sourceEnd);
+ }
+ }
+}
+public void javadocMissingParamName(int sourceStart, int sourceEnd){
+ this.handle(IProblem.JavadocMissingParamName, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocMissingParamTag(Argument param, int modifiers) {
+ boolean overriding = (modifiers & (CompilerModifiers.AccImplementing+CompilerModifiers.AccOverriding)) != 0;
+ boolean report = (this.options.getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore)
+ && (!overriding || this.options.reportMissingJavadocTagsOverriding);
+ if (report && javadocVisibility(this.options.reportMissingJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] { String.valueOf(param.name) };
+ this.handle(IProblem.JavadocMissingParamTag, arguments, arguments, param.sourceStart, param.sourceEnd);
+ }
+}
+public void javadocMissingReturnTag(int sourceStart, int sourceEnd, int modifiers){
+ boolean overriding = (modifiers & (CompilerModifiers.AccImplementing+CompilerModifiers.AccOverriding)) != 0;
+ boolean report = (this.options.getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore)
+ && (!overriding || this.options.reportMissingJavadocTagsOverriding);
+ if (report && javadocVisibility(this.options.reportMissingJavadocTagsVisibility, modifiers)) {
+ this.handle(IProblem.JavadocMissingReturnTag, NoArgument, NoArgument, sourceStart, sourceEnd);
+ }
+}
+public void javadocMissingSeeReference(int sourceStart, int sourceEnd){
+ this.handle(IProblem.JavadocMissingSeeReference, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocMissingThrowsClassName(int sourceStart, int sourceEnd){
+ this.handle(IProblem.JavadocMissingThrowsClassName, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocMissingThrowsTag(TypeReference typeRef, int modifiers){
+ boolean overriding = (modifiers & (CompilerModifiers.AccImplementing+CompilerModifiers.AccOverriding)) != 0;
+ boolean report = (this.options.getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore)
+ && (!overriding || this.options.reportMissingJavadocTagsOverriding);
+ if (report && javadocVisibility(this.options.reportMissingJavadocTagsVisibility, modifiers)) {
+ String[] arguments = new String[] { String.valueOf(typeRef.resolvedType.sourceName()) };
+ this.handle(IProblem.JavadocMissingThrowsTag, arguments, arguments, typeRef.sourceStart, typeRef.sourceEnd);
+ }
+}
+public void javadocUnexpectedTag(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocUnexpectedTag, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+public void javadocUnterminatedInlineTag(int sourceStart, int sourceEnd) {
+ this.handle(IProblem.JavadocUnterminatedInlineTag, NoArgument, NoArgument, sourceStart, sourceEnd);
+}
+private boolean javadocVisibility(int visibility, int modifiers) {
+ switch (modifiers & CompilerModifiers.AccVisibilityMASK) {
+ case IConstants.AccPublic :
+ return true;
+ case IConstants.AccProtected:
+ return (visibility != IConstants.AccPublic);
+ case IConstants.AccDefault:
+ return (visibility == IConstants.AccDefault || visibility == IConstants.AccPrivate);
+ case IConstants.AccPrivate:
+ return (visibility == IConstants.AccPrivate);
+ }
+ return true;
+}
+private String javadocVisibilityArgument(int visibility, int modifiers) {
+ String argument = null;
+ switch (modifiers & CompilerModifiers.AccVisibilityMASK) {
+ case IConstants.AccPublic :
+ argument = CompilerOptions.PUBLIC;
+ break;
+ case IConstants.AccProtected:
+ if (visibility != IConstants.AccPublic) {
+ argument = CompilerOptions.PROTECTED;
+ }
+ break;
+ case IConstants.AccDefault:
+ if (visibility == IConstants.AccDefault || visibility == IConstants.AccPrivate) {
+ argument = CompilerOptions.DEFAULT;
+ }
+ break;
+ case IConstants.AccPrivate:
+ if (visibility == IConstants.AccPrivate) {
+ argument = CompilerOptions.PRIVATE;
+ }
+ break;
+ }
+ return argument;
+}
+public void localVariableHiding(LocalDeclaration local, Binding hiddenVariable, boolean isSpecialArgHidingField) {
+ if (hiddenVariable instanceof LocalVariableBinding) {
+ String[] arguments = new String[] {new String(local.name) };
+ this.handle(
+ (local instanceof Argument)
+ ? IProblem.ArgumentHidingLocalVariable
+ : IProblem.LocalVariableHidingLocalVariable,
+ arguments,
+ arguments,
+ local.sourceStart,
+ local.sourceEnd);
+ } else if (hiddenVariable instanceof FieldBinding) {
+ if (isSpecialArgHidingField && !this.options.reportSpecialParameterHidingField){
+ return;
+ }
+ FieldBinding field = (FieldBinding) hiddenVariable;
+ this.handle(
+ (local instanceof Argument)
+ ? IProblem.ArgumentHidingField
+ : IProblem.LocalVariableHidingField,
+ new String[] {new String(local.name) , new String(field.declaringClass.readableName()) },
+ new String[] {new String(local.name), new String(field.declaringClass.shortReadableName()) },
+ local.sourceStart,
+ local.sourceEnd);
+ }
+}
+public void methodNeedBody(AbstractMethodDeclaration methodDecl) {
+ this.handle(
+ IProblem.MethodRequiresBody,
+ NoArgument,
+ NoArgument,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void methodNeedingNoBody(MethodDeclaration methodDecl) {
+ this.handle(
+ ((methodDecl.modifiers & IConstants.AccNative) != 0) ? IProblem.BodyForNativeMethod : IProblem.BodyForAbstractMethod,
+ NoArgument,
+ NoArgument,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void methodWithConstructorName(MethodDeclaration methodDecl) {
+ this.handle(
+ IProblem.MethodButWithConstructorName,
+ NoArgument,
+ NoArgument,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void missingReturnType(AbstractMethodDeclaration methodDecl) {
+ this.handle(
+ IProblem.MissingReturnType,
+ NoArgument,
+ NoArgument,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void missingSemiColon(Expression expression){
+ this.handle(
+ IProblem.MissingSemiColon,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void mustDefineDimensionsOrInitializer(ArrayAllocationExpression expression) {
+ this.handle(
+ IProblem.MustDefineEitherDimensionExpressionsOrInitializer,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void mustSpecifyPackage(CompilationUnitDeclaration compUnitDecl) {
+ String[] arguments = new String[] {new String(compUnitDecl.getFileName())};
+ this.handle(
+ IProblem.MustSpecifyPackage,
+ arguments,
+ arguments,
+ compUnitDecl.sourceStart,
+ compUnitDecl.sourceStart + 1);
+}
+public void mustUseAStaticMethod(MessageSend messageSend, MethodBinding method) {
+ this.handle(
+ IProblem.StaticMethodRequested,
+ new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)},
+ messageSend.sourceStart,
+ messageSend.sourceEnd);
+}
+
+public void nativeMethodsCannotBeStrictfp(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.NativeMethodsCannotBeStrictfp,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void needImplementation() {
+ this.abortDueToInternalError(Util.bind("abort.missingCode")); //$NON-NLS-1$
+}
+public void needToEmulateFieldReadAccess(FieldBinding field, ASTNode location) {
+ this.handle(
+ IProblem.NeedToEmulateFieldReadAccess,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void needToEmulateFieldWriteAccess(FieldBinding field, ASTNode location) {
+ this.handle(
+ IProblem.NeedToEmulateFieldWriteAccess,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void needToEmulateMethodAccess(
+ MethodBinding method,
+ ASTNode location) {
+
+ if (method.isConstructor())
+ this.handle(
+ IProblem.NeedToEmulateConstructorAccess,
+ new String[] {
+ new String(method.declaringClass.readableName()),
+ parametersAsString(method)
+ },
+ new String[] {
+ new String(method.declaringClass.shortReadableName()),
+ parametersAsShortString(method)
+ },
+ location.sourceStart,
+ location.sourceEnd);
+ else
+ this.handle(
+ IProblem.NeedToEmulateMethodAccess,
+ new String[] {
+ new String(method.declaringClass.readableName()),
+ new String(method.selector),
+ parametersAsString(method)
+ },
+ new String[] {
+ new String(method.declaringClass.shortReadableName()),
+ new String(method.selector),
+ parametersAsShortString(method)
+ },
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void nestedClassCannotDeclareInterface(TypeDeclaration typeDecl) {
+ String[] arguments = new String[] {new String(typeDecl.name)};
+ this.handle(
+ IProblem.CannotDefineInterfaceInLocalType,
+ arguments,
+ arguments,
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd);
+}
+public void noMoreAvailableSpaceForArgument(LocalVariableBinding local, ASTNode location) {
+ String[] arguments = new String[]{ new String(local.name) };
+ this.handle(
+ local instanceof SyntheticArgumentBinding
+ ? IProblem.TooManySyntheticArgumentSlots
+ : IProblem.TooManyArgumentSlots,
+ arguments,
+ arguments,
+ Abort | Error,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void noMoreAvailableSpaceForLocal(LocalVariableBinding local, ASTNode location) {
+ String[] arguments = new String[]{ new String(local.name) };
+ this.handle(
+ IProblem.TooManyLocalVariableSlots,
+ arguments,
+ arguments,
+ Abort | Error,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void nonStaticAccessToStaticMethod(ASTNode location, MethodBinding method) {
+ this.handle(
+ IProblem.NonStaticAccessToStaticMethod,
+ new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)},
+ new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void nonStaticAccessToStaticField(ASTNode location, FieldBinding field) {
+ this.handle(
+ IProblem.NonStaticAccessToStaticField,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ location.sourceStart,
+ fieldLocation(field, location));
+}
+public void noSuchEnclosingInstance(TypeBinding targetType, ASTNode location, boolean isConstructorCall) {
+
+ int id;
+
+ if (isConstructorCall) {
+ //28 = No enclosing instance of type {0} is available due to some intermediate constructor invocation
+ id = IProblem.EnclosingInstanceInConstructorCall;
+ } else if ((location instanceof ExplicitConstructorCall)
+ && ((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper) {
+ //20 = No enclosing instance of type {0} is accessible to invoke the super constructor. Must define a constructor and explicitly qualify its super constructor invocation with an instance of {0} (e.g. x.super() where x is an instance of {0}).
+ id = IProblem.MissingEnclosingInstanceForConstructorCall;
+ } else if (location instanceof AllocationExpression
+ && (((AllocationExpression) location).binding.declaringClass.isMemberType()
+ || (((AllocationExpression) location).binding.declaringClass.isAnonymousType()
+ && ((AllocationExpression) location).binding.declaringClass.superclass().isMemberType()))) {
+ //21 = No enclosing instance of type {0} is accessible. Must qualify the allocation with an enclosing instance of type {0} (e.g. x.new A() where x is an instance of {0}).
+ id = IProblem.MissingEnclosingInstance;
+ } else { // default
+ //22 = No enclosing instance of the type {0} is accessible in scope
+ id = IProblem.IncorrectEnclosingInstanceReference;
+ }
+
+ this.handle(
+ id,
+ new String[] { new String(targetType.readableName())},
+ new String[] { new String(targetType.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void notCompatibleTypesError(EqualExpression expression, TypeBinding leftType, TypeBinding rightType) {
+ String leftName = new String(leftType.readableName());
+ String rightName = new String(rightType.readableName());
+ String leftShortName = new String(leftType.shortReadableName());
+ String rightShortName = new String(rightType.shortReadableName());
+ if (leftShortName.equals(rightShortName)){
+ leftShortName = leftName;
+ rightShortName = rightName;
+ }
+ this.handle(
+ IProblem.IncompatibleTypesInEqualityOperator,
+ new String[] {leftName, rightName },
+ new String[] {leftShortName, rightShortName },
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void notCompatibleTypesError(InstanceOfExpression expression, TypeBinding leftType, TypeBinding rightType) {
+ String leftName = new String(leftType.readableName());
+ String rightName = new String(rightType.readableName());
+ String leftShortName = new String(leftType.shortReadableName());
+ String rightShortName = new String(rightType.shortReadableName());
+ if (leftShortName.equals(rightShortName)){
+ leftShortName = leftName;
+ rightShortName = rightName;
+ }
+ this.handle(
+ IProblem.IncompatibleTypesInConditionalOperator,
+ new String[] {leftName, rightName },
+ new String[] {leftShortName, rightShortName },
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void objectCannotHaveSuperTypes(SourceTypeBinding type) {
+ this.handle(
+ IProblem.ObjectCannotHaveSuperTypes,
+ NoArgument,
+ NoArgument,
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void operatorOnlyValidOnNumericType(CompoundAssignment assignment, TypeBinding leftType, TypeBinding rightType) {
+ String leftName = new String(leftType.readableName());
+ String rightName = new String(rightType.readableName());
+ String leftShortName = new String(leftType.shortReadableName());
+ String rightShortName = new String(rightType.shortReadableName());
+ if (leftShortName.equals(rightShortName)){
+ leftShortName = leftName;
+ rightShortName = rightName;
+ }
+ this.handle(
+ IProblem.TypeMismatch,
+ new String[] {leftName, rightName },
+ new String[] {leftShortName, rightShortName },
+ assignment.sourceStart,
+ assignment.sourceEnd);
+}
+public void overridesDeprecatedMethod(MethodBinding localMethod, MethodBinding inheritedMethod) {
+ this.handle(
+ IProblem.OverridingDeprecatedMethod,
+ new String[] {
+ new String(
+ CharOperation.concat(
+ localMethod.declaringClass.readableName(),
+ localMethod.readableName(),
+ '.')),
+ new String(inheritedMethod.declaringClass.readableName())},
+ new String[] {
+ new String(
+ CharOperation.concat(
+ localMethod.declaringClass.shortReadableName(),
+ localMethod.shortReadableName(),
+ '.')),
+ new String(inheritedMethod.declaringClass.shortReadableName())},
+ localMethod.sourceStart(),
+ localMethod.sourceEnd());
+}
+public void overridesPackageDefaultMethod(MethodBinding localMethod, MethodBinding inheritedMethod) {
+ this.handle(
+ IProblem.OverridingNonVisibleMethod,
+ new String[] {
+ new String(
+ CharOperation.concat(
+ localMethod.declaringClass.readableName(),
+ localMethod.readableName(),
+ '.')),
+ new String(inheritedMethod.declaringClass.readableName())},
+ new String[] {
+ new String(
+ CharOperation.concat(
+ localMethod.declaringClass.shortReadableName(),
+ localMethod.shortReadableName(),
+ '.')),
+ new String(inheritedMethod.declaringClass.shortReadableName())},
+ localMethod.sourceStart(),
+ localMethod.sourceEnd());
+}
+public void packageCollidesWithType(CompilationUnitDeclaration compUnitDecl) {
+ String[] arguments = new String[] {CharOperation.toString(compUnitDecl.currentPackage.tokens)};
+ this.handle(
+ IProblem.PackageCollidesWithType,
+ arguments,
+ arguments,
+ compUnitDecl.currentPackage.sourceStart,
+ compUnitDecl.currentPackage.sourceEnd);
+}
+public void packageIsNotExpectedPackage(CompilationUnitDeclaration compUnitDecl) {
+ String[] arguments = new String[] {CharOperation.toString(compUnitDecl.compilationResult.compilationUnit.getPackageName())};
+ this.handle(
+ IProblem.PackageIsNotExpectedPackage,
+ arguments,
+ arguments,
+ compUnitDecl.currentPackage == null ? 0 : compUnitDecl.currentPackage.sourceStart,
+ compUnitDecl.currentPackage == null ? 0 : compUnitDecl.currentPackage.sourceEnd);
+}
+private String parametersAsString(MethodBinding method) {
+ TypeBinding[] params = method.parameters;
+ StringBuffer buffer = new StringBuffer();
+ for (int i = 0, length = params.length; i < length; i++) {
+ if (i != 0)
+ buffer.append(", "); //$NON-NLS-1$
+ buffer.append(new String(params[i].readableName()));
+ }
+ return buffer.toString();
+}
+private String parametersAsShortString(MethodBinding method) {
+ TypeBinding[] params = method.parameters;
+ StringBuffer buffer = new StringBuffer();
+ for (int i = 0, length = params.length; i < length; i++) {
+ if (i != 0)
+ buffer.append(", "); //$NON-NLS-1$
+ buffer.append(new String(params[i].shortReadableName()));
+ }
+ return buffer.toString();
+}
+public void parseError(
+ int startPosition,
+ int endPosition,
+ int currentToken,
+ char[] currentTokenSource,
+ String errorTokenName,
+ String[] possibleTokens) {
+
+ if (possibleTokens.length == 0) { //no suggestion available
+ if (isKeyword(currentToken)) {
+ String[] arguments = new String[] {new String(currentTokenSource)};
+ this.handle(
+ IProblem.ParsingErrorOnKeywordNoSuggestion,
+ arguments,
+ arguments,
+ // this is the current -invalid- token position
+ startPosition,
+ endPosition);
+ return;
+ } else {
+ String[] arguments = new String[] {errorTokenName};
+ this.handle(
+ IProblem.ParsingErrorNoSuggestion,
+ arguments,
+ arguments,
+ // this is the current -invalid- token position
+ startPosition,
+ endPosition);
+ return;
+ }
+ }
+
+ //build a list of probable right tokens
+ StringBuffer list = new StringBuffer(20);
+ for (int i = 0, max = possibleTokens.length; i < max; i++) {
+ if (i > 0)
+ list.append(", "); //$NON-NLS-1$
+ list.append('"');
+ list.append(possibleTokens[i]);
+ list.append('"');
+ }
+
+ if (isKeyword(currentToken)) {
+ String[] arguments = new String[] {new String(currentTokenSource), list.toString()};
+ this.handle(
+ IProblem.ParsingErrorOnKeyword,
+ arguments,
+ arguments,
+ // this is the current -invalid- token position
+ startPosition,
+ endPosition);
+ return;
+ }
+ //extract the literal when it's a literal
+ if (isLiteral(currentToken) ||
+ isIdentifier(currentToken)) { //$NON-NLS-1$
+ errorTokenName = new String(currentTokenSource);
+ }
+
+ String[] arguments = new String[] {errorTokenName, list.toString()};
+ this.handle(
+ IProblem.ParsingError,
+ arguments,
+ arguments,
+ // this is the current -invalid- token position
+ startPosition,
+ endPosition);
+}
+public void possibleAccidentalBooleanAssignment(Assignment assignment) {
+ String[] arguments = new String[] {};
+ this.handle(
+ IProblem.PossibleAccidentalBooleanAssignment,
+ arguments,
+ arguments,
+ assignment.sourceStart,
+ assignment.sourceEnd);
+}
+public void publicClassMustMatchFileName(CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) {
+ this.referenceContext = typeDecl; // report the problem against the type not the entire compilation unit
+ String[] arguments = new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)};
+ this.handle(
+ IProblem.PublicClassMustMatchFileName,
+ arguments,
+ arguments,
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd,
+ compUnitDecl.compilationResult);
+}
+public void recursiveConstructorInvocation(ExplicitConstructorCall constructorCall) {
+
+ this.handle(
+ IProblem.RecursiveConstructorInvocation,
+ new String[] {
+ new String(constructorCall.binding.declaringClass.readableName()),
+ parametersAsString(constructorCall.binding)
+ },
+ new String[] {
+ new String(constructorCall.binding.declaringClass.shortReadableName()),
+ parametersAsShortString(constructorCall.binding)
+ },
+ constructorCall.sourceStart,
+ constructorCall.sourceEnd);
+}
+
+public void redefineArgument(Argument arg) {
+ String[] arguments = new String[] {new String(arg.name)};
+ this.handle(
+ IProblem.RedefinedArgument,
+ arguments,
+ arguments,
+ arg.sourceStart,
+ arg.sourceEnd);
+}
+public void redefineLocal(LocalDeclaration localDecl) {
+ String[] arguments = new String[] {new String(localDecl.name)};
+ this.handle(
+ IProblem.RedefinedLocal,
+ arguments,
+ arguments,
+ localDecl.sourceStart,
+ localDecl.sourceEnd);
+}
+public void referenceMustBeArrayTypeAt(TypeBinding arrayType, ArrayReference arrayRef) {
+ this.handle(
+ IProblem.ArrayReferenceRequired,
+ new String[] {new String(arrayType.readableName())},
+ new String[] {new String(arrayType.shortReadableName())},
+ arrayRef.sourceStart,
+ arrayRef.sourceEnd);
+}
+public void returnTypeCannotBeVoidArray(SourceTypeBinding type, MethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(methodDecl.selector)};
+ this.handle(
+ IProblem.ReturnTypeCannotBeVoidArray,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void returnTypeProblem(SourceTypeBinding type, MethodDeclaration methodDecl, TypeBinding expectedType) {
+ int problemId = expectedType.problemId();
+ int id;
+ switch (problemId) {
+ case NotFound : // 1
+ id = IProblem.ReturnTypeNotFound;
+ break;
+ case NotVisible : // 2
+ id = IProblem.ReturnTypeNotVisible;
+ break;
+ case Ambiguous : // 3
+ id = IProblem.ReturnTypeAmbiguous;
+ break;
+ case InternalNameProvided : // 4
+ id = IProblem.ReturnTypeInternalNameProvided;
+ break;
+ case InheritedNameHidesEnclosingName : // 5
+ id = IProblem.ReturnTypeInheritedNameHidesEnclosingName;
+ break;
+ case NoError : // 0
+ default :
+ needImplementation(); // want to fail to see why we were here...
+ return;
+ }
+ this.handle(
+ id,
+ new String[] {new String(methodDecl.selector), new String(expectedType.readableName())},
+ new String[] {new String(methodDecl.selector), new String(expectedType.shortReadableName())},
+ methodDecl.returnType.sourceStart,
+ methodDecl.returnType.sourceEnd);
+}
+public void scannerError(Parser parser, String errorTokenName) {
+ Scanner scanner = parser.scanner;
+
+ int flag = IProblem.ParsingErrorNoSuggestion;
+ int startPos = scanner.startPosition;
+
+ //special treatment for recognized errors....
+ if (errorTokenName.equals(Scanner.END_OF_SOURCE))
+ flag = IProblem.EndOfSource;
+ else if (errorTokenName.equals(Scanner.INVALID_HEXA))
+ flag = IProblem.InvalidHexa;
+ else if (errorTokenName.equals(Scanner.INVALID_OCTAL))
+ flag = IProblem.InvalidOctal;
+ else if (errorTokenName.equals(Scanner.INVALID_CHARACTER_CONSTANT))
+ flag = IProblem.InvalidCharacterConstant;
+ else if (errorTokenName.equals(Scanner.INVALID_ESCAPE))
+ flag = IProblem.InvalidEscape;
+ else if (errorTokenName.equals(Scanner.INVALID_UNICODE_ESCAPE)){
+ flag = IProblem.InvalidUnicodeEscape;
+ // better locate the error message
+ char[] source = scanner.source;
+ int checkPos = scanner.currentPosition - 1;
+ if (checkPos >= source.length) checkPos = source.length - 1;
+ while (checkPos >= startPos){
+ if (source[checkPos] == '\\') break;
+ checkPos --;
+ }
+ startPos = checkPos;
+ } else if (errorTokenName.equals(Scanner.INVALID_FLOAT))
+ flag = IProblem.InvalidFloat;
+ else if (errorTokenName.equals(Scanner.UNTERMINATED_STRING))
+ flag = IProblem.UnterminatedString;
+ else if (errorTokenName.equals(Scanner.UNTERMINATED_COMMENT))
+ flag = IProblem.UnterminatedComment;
+ else if (errorTokenName.equals(Scanner.INVALID_CHAR_IN_STRING))
+ flag = IProblem.UnterminatedString;
+ else if (errorTokenName.equals(Scanner.INVALID_INPUT))
+ flag = IProblem.InvalidInput;
+
+ String[] arguments = flag == IProblem.ParsingErrorNoSuggestion
+ ? new String[] {errorTokenName}
+ : NoArgument;
+ this.handle(
+ flag,
+ arguments,
+ arguments,
+ // this is the current -invalid- token position
+ startPos,
+ scanner.currentPosition - 1,
+ parser.compilationUnit.compilationResult);
+}
+public void shouldReturn(TypeBinding returnType, ASTNode location) {
+ this.handle(
+ IProblem.ShouldReturnValue,
+ new String[] { new String (returnType.readableName())},
+ new String[] { new String (returnType.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void signalNoImplicitStringConversionForCharArrayExpression(Expression expression) {
+ this.handle(
+ IProblem.NoImplicitStringConversionForCharArrayExpression,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void staticAndInstanceConflict(MethodBinding currentMethod, MethodBinding inheritedMethod) {
+ if (currentMethod.isStatic())
+ this.handle(
+ // This static method cannot hide the instance method from %1
+ // 8.4.6.4 - If a class inherits more than one method with the same signature a static (non-abstract) method cannot hide an instance method.
+ IProblem.CannotHideAnInstanceMethodWithAStaticMethod,
+ new String[] {new String(inheritedMethod.declaringClass.readableName())},
+ new String[] {new String(inheritedMethod.declaringClass.shortReadableName())},
+ currentMethod.sourceStart(),
+ currentMethod.sourceEnd());
+ else
+ this.handle(
+ // This instance method cannot override the static method from %1
+ // 8.4.6.4 - If a class inherits more than one method with the same signature an instance (non-abstract) method cannot override a static method.
+ IProblem.CannotOverrideAStaticMethodWithAnInstanceMethod,
+ new String[] {new String(inheritedMethod.declaringClass.readableName())},
+ new String[] {new String(inheritedMethod.declaringClass.shortReadableName())},
+ currentMethod.sourceStart(),
+ currentMethod.sourceEnd());
+}
+public void staticFieldAccessToNonStaticVariable(ASTNode location, FieldBinding field) {
+ String[] arguments = new String[] {new String(field.readableName())};
+ this.handle(
+ IProblem.NonStaticFieldFromStaticInvocation,
+ arguments,
+ arguments,
+ location.sourceStart,
+ fieldLocation(field, location));
+}
+public void staticInheritedMethodConflicts(SourceTypeBinding type, MethodBinding concreteMethod, MethodBinding[] abstractMethods) {
+ this.handle(
+ // The static method %1 conflicts with the abstract method in %2
+ // 8.4.6.4 - If a class inherits more than one method with the same signature it is an error for one to be static (non-abstract) and the other abstract.
+ IProblem.StaticInheritedMethodConflicts,
+ new String[] {
+ new String(concreteMethod.readableName()),
+ new String(abstractMethods[0].declaringClass.readableName())},
+ new String[] {
+ new String(concreteMethod.readableName()),
+ new String(abstractMethods[0].declaringClass.shortReadableName())},
+ type.sourceStart(),
+ type.sourceEnd());
+}
+public void stringConstantIsExceedingUtf8Limit(ASTNode location) {
+ this.handle(
+ IProblem.StringConstantIsExceedingUtf8Limit,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void superclassMustBeAClass(SourceTypeBinding type, TypeReference superclassRef, ReferenceBinding superType) {
+ this.handle(
+ IProblem.SuperclassMustBeAClass,
+ new String[] {new String(superType.readableName()), new String(type.sourceName())},
+ new String[] {new String(superType.shortReadableName()), new String(type.sourceName())},
+ superclassRef.sourceStart,
+ superclassRef.sourceEnd);
+}
+public void superfluousSemicolon(int sourceStart, int sourceEnd) {
+ this.handle(
+ IProblem.SuperfluousSemicolon,
+ NoArgument,
+ NoArgument,
+ sourceStart,
+ sourceEnd);
+}
+public void superinterfaceMustBeAnInterface(SourceTypeBinding type, TypeDeclaration typeDecl, ReferenceBinding superType) {
+ this.handle(
+ IProblem.SuperInterfaceMustBeAnInterface,
+ new String[] {new String(superType.readableName()), new String(type.sourceName())},
+ new String[] {new String(superType.shortReadableName()), new String(type.sourceName())},
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd);
+}
+public void task(String tag, String message, String priority, int start, int end){
+ this.handle(
+ IProblem.Task,
+ new String[] { tag, message, priority/*secret argument that is not surfaced in getMessage()*/},
+ new String[] { tag, message, priority/*secret argument that is not surfaced in getMessage()*/},
+ start,
+ end);
+}
+public void tooManyDimensions(ASTNode expression) {
+ this.handle(
+ IProblem.TooManyArrayDimensions,
+ NoArgument,
+ NoArgument,
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void tooManyFields(TypeDeclaration typeDeclaration) {
+ this.handle(
+ IProblem.TooManyFields,
+ new String[]{ new String(typeDeclaration.binding.readableName())},
+ new String[]{ new String(typeDeclaration.binding.shortReadableName())},
+ Abort | Error,
+ typeDeclaration.sourceStart,
+ typeDeclaration.sourceEnd);
+}
+public void tooManyMethods(TypeDeclaration typeDeclaration) {
+ this.handle(
+ IProblem.TooManyMethods,
+ new String[]{ new String(typeDeclaration.binding.readableName())},
+ new String[]{ new String(typeDeclaration.binding.shortReadableName())},
+ Abort | Error,
+ typeDeclaration.sourceStart,
+ typeDeclaration.sourceEnd);
+}
+public void typeCastError(CastExpression expression, TypeBinding leftType, TypeBinding rightType) {
+ String leftName = new String(leftType.readableName());
+ String rightName = new String(rightType.readableName());
+ String leftShortName = new String(leftType.shortReadableName());
+ String rightShortName = new String(rightType.shortReadableName());
+ if (leftShortName.equals(rightShortName)){
+ leftShortName = leftName;
+ rightShortName = rightName;
+ }
+ this.handle(
+ IProblem.IllegalCast,
+ new String[] { rightName, leftName },
+ new String[] { rightShortName, leftShortName },
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void typeCollidesWithPackage(CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) {
+ this.referenceContext = typeDecl; // report the problem against the type not the entire compilation unit
+ String[] arguments = new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)};
+ this.handle(
+ IProblem.TypeCollidesWithPackage,
+ arguments,
+ arguments,
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd,
+ compUnitDecl.compilationResult);
+}
+public void typeMismatchError(TypeBinding resultType, TypeBinding expectedType, ASTNode location) {
+ String resultTypeName = new String(resultType.readableName());
+ String expectedTypeName = new String(expectedType.readableName());
+ String resultTypeShortName = new String(resultType.shortReadableName());
+ String expectedTypeShortName = new String(expectedType.shortReadableName());
+ if (resultTypeShortName.equals(expectedTypeShortName)){
+ resultTypeShortName = resultTypeName;
+ expectedTypeShortName = expectedTypeName;
+ }
+ this.handle(
+ IProblem.TypeMismatch,
+ new String[] {resultTypeName, expectedTypeName},
+ new String[] {resultTypeShortName, expectedTypeShortName},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void typeMismatchErrorActualTypeExpectedType(Expression expression, TypeBinding constantType, TypeBinding expectedType) {
+ String constantTypeName = new String(constantType.readableName());
+ String expectedTypeName = new String(expectedType.readableName());
+ String constantTypeShortName = new String(constantType.shortReadableName());
+ String expectedTypeShortName = new String(expectedType.shortReadableName());
+ if (constantTypeShortName.equals(expectedTypeShortName)){
+ constantTypeShortName = constantTypeName;
+ expectedTypeShortName = expectedTypeName;
+ }
+ this.handle(
+ IProblem.TypeMismatch,
+ new String[] {constantTypeName, expectedTypeName},
+ new String[] {constantTypeShortName, expectedTypeShortName},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void undefinedLabel(BranchStatement statement) {
+ String[] arguments = new String[] {new String(statement.label)};
+ this.handle(
+ IProblem.UndefinedLabel,
+ arguments,
+ arguments,
+ statement.sourceStart,
+ statement.sourceEnd);
+}
+public void undocumentedEmptyBlock(int blockStart, int blockEnd) {
+ String[] arguments = new String[] {};
+ this.handle(
+ IProblem.UndocumentedEmptyBlock,
+ arguments,
+ arguments,
+ blockStart,
+ blockEnd);
+}
+public void unexpectedStaticModifierForField(SourceTypeBinding type, FieldDeclaration fieldDecl) {
+ String[] arguments = new String[] {new String(fieldDecl.name)};
+ this.handle(
+ IProblem.UnexpectedStaticModifierForField,
+ arguments,
+ arguments,
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void unexpectedStaticModifierForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
+ String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};
+ this.handle(
+ IProblem.UnexpectedStaticModifierForMethod,
+ arguments,
+ arguments,
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void unhandledException(TypeBinding exceptionType, ASTNode location) {
+
+ boolean insideDefaultConstructor =
+ (this.referenceContext instanceof ConstructorDeclaration)
+ && ((ConstructorDeclaration)this.referenceContext).isDefaultConstructor();
+ boolean insideImplicitConstructorCall =
+ (location instanceof ExplicitConstructorCall)
+ && (((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper);
+
+ this.handle(
+ insideDefaultConstructor
+ ? IProblem.UnhandledExceptionInDefaultConstructor
+ : (insideImplicitConstructorCall
+ ? IProblem.UndefinedConstructorInImplicitConstructorCall
+ : IProblem.UnhandledException),
+ new String[] {new String(exceptionType.readableName())},
+ new String[] {new String(exceptionType.shortReadableName())},
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void uninitializedBlankFinalField(FieldBinding binding, ASTNode location) {
+ String[] arguments = new String[] {new String(binding.readableName())};
+ this.handle(
+ IProblem.UninitializedBlankFinalField,
+ arguments,
+ arguments,
+ location.sourceStart,
+ fieldLocation(binding, location));
+}
+public void uninitializedLocalVariable(LocalVariableBinding binding, ASTNode location) {
+ String[] arguments = new String[] {new String(binding.readableName())};
+ this.handle(
+ IProblem.UninitializedLocalVariable,
+ arguments,
+ arguments,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void unmatchedBracket(int position, ReferenceContext context, CompilationResult compilationResult) {
+ this.handle(
+ IProblem.UnmatchedBracket,
+ NoArgument,
+ NoArgument,
+ position,
+ position,
+ context,
+ compilationResult);
+}
+public void unnecessaryCast(CastExpression castExpression) {
+ TypeBinding castedExpressionType = castExpression.expression.resolvedType;
+ this.handle(
+ IProblem.UnnecessaryCast,
+ new String[]{ new String(castedExpressionType.readableName()), new String(castExpression.resolvedType.readableName())},
+ new String[]{ new String(castedExpressionType.shortReadableName()), new String(castExpression.resolvedType.shortReadableName())},
+ castExpression.sourceStart,
+ castExpression.sourceEnd);
+}
+public void unnecessaryCastForArgument(CastExpression castExpression, TypeBinding parameterType) {
+ TypeBinding castedExpressionType = castExpression.expression.resolvedType;
+ this.handle(
+ IProblem.UnnecessaryArgumentCast,
+ new String[]{ new String(castedExpressionType.readableName()), new String(castExpression.resolvedType.readableName()), new String(parameterType.readableName())},
+ new String[]{ new String(castedExpressionType.shortReadableName()), new String(castExpression.resolvedType.shortReadableName()), new String(parameterType.shortReadableName())},
+ castExpression.sourceStart,
+ castExpression.sourceEnd);
+}
+public void unnecessaryInstanceof(InstanceOfExpression instanceofExpression, TypeBinding checkType) {
+ TypeBinding expressionType = instanceofExpression.expression.resolvedType;
+ this.handle(
+ IProblem.UnnecessaryInstanceof,
+ new String[]{ new String(expressionType.readableName()), new String(checkType.readableName())},
+ new String[]{ new String(expressionType.shortReadableName()), new String(checkType.shortReadableName())},
+ instanceofExpression.sourceStart,
+ instanceofExpression.sourceEnd);
+}
+public void unqualifiedFieldAccess(NameReference reference, FieldBinding field) {
+ int end = reference.sourceEnd;
+ if (reference instanceof QualifiedNameReference) {
+ QualifiedNameReference qref = (QualifiedNameReference) reference;
+ end = (int) qref.sourcePositions[0];
+ }
+ this.handle(
+ IProblem.UnqualifiedFieldAccess,
+ new String[] {new String(field.declaringClass.readableName()), new String(field.name)},
+ new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)},
+ reference.sourceStart,
+ end);
+}
+public void unnecessaryElse(ASTNode location) {
+ this.handle(
+ IProblem.UnnecessaryElse,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void unnecessaryEnclosingInstanceSpecification(Expression expression, ReferenceBinding targetType) {
+ this.handle(
+ IProblem.IllegalEnclosingInstanceSpecification,
+ new String[]{ new String(targetType.readableName())},
+ new String[]{ new String(targetType.shortReadableName())},
+ expression.sourceStart,
+ expression.sourceEnd);
+}
+public void unreachableCatchBlock(ReferenceBinding exceptionType, ASTNode location) {
+ this.handle(
+ IProblem.UnreachableCatch,
+ new String[] {
+ new String(exceptionType.readableName()),
+ },
+ new String[] {
+ new String(exceptionType.shortReadableName()),
+ },
+ location.sourceStart,
+ location.sourceEnd);
+}
+public void unreachableCode(Statement statement) {
+ this.handle(
+ IProblem.CodeCannotBeReached,
+ NoArgument,
+ NoArgument,
+ statement.sourceStart,
+ statement.sourceEnd);
+}
+public void unresolvableReference(NameReference nameRef, Binding binding) {
+ int severity = Error;
+/* also need to check that the searchedType is the receiver type
+ if (binding instanceof ProblemBinding) {
+ ProblemBinding problem = (ProblemBinding) binding;
+ if (problem.searchType != null && problem.searchType.isHierarchyInconsistent())
+ severity = SecondaryError;
+ }
+*/
+ String[] arguments = new String[] {new String(binding.readableName())};
+ int end = nameRef.sourceEnd;
+ if (nameRef instanceof QualifiedNameReference) {
+ QualifiedNameReference ref = (QualifiedNameReference) nameRef;
+ if (ref.indexOfFirstFieldBinding >= 1)
+ end = (int) ref.sourcePositions[ref.indexOfFirstFieldBinding - 1];
+ }
+ this.handle(
+ IProblem.UndefinedName,
+ arguments,
+ arguments,
+ severity,
+ nameRef.sourceStart,
+ end);
+}
+public void unusedArgument(LocalDeclaration localDecl) {
+
+ String[] arguments = new String[] {new String(localDecl.name)};
+ this.handle(
+ IProblem.ArgumentIsNeverUsed,
+ arguments,
+ arguments,
+ localDecl.sourceStart,
+ localDecl.sourceEnd);
+}
+public void unusedDeclaredThrownException(ReferenceBinding exceptionType, AbstractMethodDeclaration method, ASTNode location) {
+ if (method.isConstructor()) {
+ this.handle(
+ IProblem.UnusedConstructorDeclaredThrownException,
+ new String[] {
+ new String(method.binding.declaringClass.readableName()),
+ parametersAsString(method.binding),
+ new String(exceptionType.readableName()),
+ },
+ new String[] {
+ new String(method.binding.declaringClass.shortReadableName()),
+ parametersAsShortString(method.binding),
+ new String(exceptionType.shortReadableName()),
+ },
+ location.sourceStart,
+ location.sourceEnd);
+ } else {
+ this.handle(
+ IProblem.UnusedMethodDeclaredThrownException,
+ new String[] {
+ new String(method.binding.declaringClass.readableName()),
+ new String(method.selector),
+ parametersAsString(method.binding),
+ new String(exceptionType.readableName()),
+ },
+ new String[] {
+ new String(method.binding.declaringClass.shortReadableName()),
+ new String(method.selector),
+ parametersAsShortString(method.binding),
+ new String(exceptionType.shortReadableName()),
+ },
+ location.sourceStart,
+ location.sourceEnd);
+ }
+}
+public void unusedImport(ImportReference importRef) {
+ String[] arguments = new String[] { CharOperation.toString(importRef.tokens) };
+ this.handle(
+ IProblem.UnusedImport,
+ arguments,
+ arguments,
+ importRef.sourceStart,
+ importRef.sourceEnd);
+}
+public void unusedLocalVariable(LocalDeclaration localDecl) {
+ String[] arguments = new String[] {new String(localDecl.name)};
+ this.handle(
+ IProblem.LocalVariableIsNeverUsed,
+ arguments,
+ arguments,
+ localDecl.sourceStart,
+ localDecl.sourceEnd);
+}
+public void unusedPrivateConstructor(ConstructorDeclaration constructorDecl) {
+
+ if (computeSeverity(IProblem.UnusedPrivateConstructor) == Ignore) return;
+
+ // no complaint for no-arg constructors (or default ones) - known pattern to block instantiation
+ if (constructorDecl.arguments == null || constructorDecl.arguments.length == 0) return;
+
+ MethodBinding constructor = constructorDecl.binding;
+ this.handle(
+ IProblem.UnusedPrivateConstructor,
+ new String[] {
+ new String(constructor.declaringClass.readableName()),
+ parametersAsString(constructor)
+ },
+ new String[] {
+ new String(constructor.declaringClass.shortReadableName()),
+ parametersAsShortString(constructor)
+ },
+ constructorDecl.sourceStart,
+ constructorDecl.sourceEnd);
+}
+public void unusedPrivateField(FieldDeclaration fieldDecl) {
+
+ if (computeSeverity(IProblem.UnusedPrivateField) == Ignore) return;
+
+ FieldBinding field = fieldDecl.binding;
+
+ if (CharOperation.equals(TypeConstants.SERIALVERSIONUID, field.name)
+ && field.isStatic()
+ && field.isFinal()
+ && BaseTypes.LongBinding == field.type) {
+ return; // do not report unused serialVersionUID field
+ }
+ if (CharOperation.equals(TypeConstants.SERIALPERSISTENTFIELDS, field.name)
+ && field.isStatic()
+ && field.isFinal()
+ && field.type.dimensions() == 1
+ && CharOperation.equals(TypeConstants.CharArray_JAVA_IO_OBJECTSTREAMFIELD, field.type.leafComponentType().readableName())) {
+ return; // do not report unused serialPersistentFields field
+ }
+ this.handle(
+ IProblem.UnusedPrivateField,
+ new String[] {
+ new String(field.declaringClass.readableName()),
+ new String(field.name),
+ },
+ new String[] {
+ new String(field.declaringClass.shortReadableName()),
+ new String(field.name),
+ },
+ fieldDecl.sourceStart,
+ fieldDecl.sourceEnd);
+}
+public void unusedPrivateMethod(AbstractMethodDeclaration methodDecl) {
+
+ if (computeSeverity(IProblem.UnusedPrivateMethod) == Ignore) return;
+
+ MethodBinding method = methodDecl.binding;
+
+ // no report for serialization support 'void readObject(ObjectInputStream)'
+ if (!method.isStatic()
+ && BaseTypes.VoidBinding == method.returnType
+ && method.parameters.length == 1
+ && method.parameters[0].dimensions() == 0
+ && CharOperation.equals(method.selector, TypeConstants.READOBJECT)
+ && CharOperation.equals(TypeConstants.CharArray_JAVA_IO_OBJECTINPUTSTREAM, method.parameters[0].readableName())) {
+ return;
+ }
+ // no report for serialization support 'void writeObject(ObjectOutputStream)'
+ if (!method.isStatic()
+ && BaseTypes.VoidBinding == method.returnType
+ && method.parameters.length == 1
+ && method.parameters[0].dimensions() == 0
+ && CharOperation.equals(method.selector, TypeConstants.WRITEOBJECT)
+ && CharOperation.equals(TypeConstants.CharArray_JAVA_IO_OBJECTOUTPUTSTREAM, method.parameters[0].readableName())) {
+ return;
+ }
+ // no report for serialization support 'Object readResolve()'
+ if (!method.isStatic()
+ && TypeIds.T_Object == method.returnType.id
+ && method.parameters.length == 0
+ && CharOperation.equals(method.selector, TypeConstants.READRESOLVE)) {
+ return;
+ }
+ // no report for serialization support 'Object writeReplace()'
+ if (!method.isStatic()
+ && TypeIds.T_Object == method.returnType.id
+ && method.parameters.length == 0
+ && CharOperation.equals(method.selector, TypeConstants.WRITEREPLACE)) {
+ return;
+ }
+ this.handle(
+ IProblem.UnusedPrivateMethod,
+ new String[] {
+ new String(method.declaringClass.readableName()),
+ new String(method.selector),
+ parametersAsString(method)
+ },
+ new String[] {
+ new String(method.declaringClass.shortReadableName()),
+ new String(method.selector),
+ parametersAsShortString(method)
+ },
+ methodDecl.sourceStart,
+ methodDecl.sourceEnd);
+}
+public void unusedPrivateType(TypeDeclaration typeDecl) {
+
+ if (computeSeverity(IProblem.UnusedPrivateType) == Ignore) return;
+
+ ReferenceBinding type = typeDecl.binding;
+ this.handle(
+ IProblem.UnusedPrivateType,
+ new String[] {
+ new String(type.readableName()),
+ },
+ new String[] {
+ new String(type.shortReadableName()),
+ },
+ typeDecl.sourceStart,
+ typeDecl.sourceEnd);
+}
+public void useAssertAsAnIdentifier(int sourceStart, int sourceEnd) {
+ this.handle(
+ IProblem.UseAssertAsAnIdentifier,
+ NoArgument,
+ NoArgument,
+ sourceStart,
+ sourceEnd);
+}
+
+public void variableTypeCannotBeVoid(AbstractVariableDeclaration varDecl) {
+ String[] arguments = new String[] {new String(varDecl.name)};
+ this.handle(
+ IProblem.VariableTypeCannotBeVoid,
+ arguments,
+ arguments,
+ varDecl.sourceStart,
+ varDecl.sourceEnd);
+}
+public void variableTypeCannotBeVoidArray(AbstractVariableDeclaration varDecl) {
+ String[] arguments = new String[] {new String(varDecl.name)};
+ this.handle(
+ IProblem.VariableTypeCannotBeVoidArray,
+ arguments,
+ arguments,
+ varDecl.sourceStart,
+ varDecl.sourceEnd);
+}
+public void visibilityConflict(MethodBinding currentMethod, MethodBinding inheritedMethod) {
+ this.handle(
+ // Cannot reduce the visibility of the inherited method from %1
+ // 8.4.6.3 - The access modifier of an hiding method must provide at least as much access as the hidden method.
+ // 8.4.6.3 - The access modifier of an overiding method must provide at least as much access as the overriden method.
+ IProblem.MethodReducesVisibility,
+ new String[] {new String(inheritedMethod.declaringClass.readableName())},
+ new String[] {new String(inheritedMethod.declaringClass.shortReadableName())},
+ currentMethod.sourceStart(),
+ currentMethod.sourceEnd());
+}
+public void nonExternalizedStringLiteral(ASTNode location) {
+ this.handle(
+ IProblem.NonExternalizedStringLiteral,
+ NoArgument,
+ NoArgument,
+ location.sourceStart,
+ location.sourceEnd);
+}
+
+public void noMoreAvailableSpaceForConstant(TypeDeclaration typeDeclaration) {
+ this.handle(
+ IProblem.TooManyBytesForStringConstant,
+ new String[]{ new String(typeDeclaration.binding.readableName())},
+ new String[]{ new String(typeDeclaration.binding.shortReadableName())},
+ Abort | Error,
+ typeDeclaration.sourceStart,
+ typeDeclaration.sourceEnd);
+}
+
+public void noMoreAvailableSpaceInConstantPool(TypeDeclaration typeDeclaration) {
+ this.handle(
+ IProblem.TooManyConstantsInConstantPool,
+ new String[]{ new String(typeDeclaration.binding.readableName())},
+ new String[]{ new String(typeDeclaration.binding.shortReadableName())},
+ Abort | Error,
+ typeDeclaration.sourceStart,
+ typeDeclaration.sourceEnd);
+}
+
+private boolean isKeyword(int token) {
+ switch(token) {
+ case TerminalTokens.TokenNameabstract:
+ case TerminalTokens.TokenNameassert:
+ case TerminalTokens.TokenNamebyte:
+ case TerminalTokens.TokenNamebreak:
+ case TerminalTokens.TokenNameboolean:
+ case TerminalTokens.TokenNamecase:
+ case TerminalTokens.TokenNamechar:
+ case TerminalTokens.TokenNamecatch:
+ case TerminalTokens.TokenNameclass:
+ case TerminalTokens.TokenNamecontinue:
+ case TerminalTokens.TokenNamedo:
+ case TerminalTokens.TokenNamedouble:
+ case TerminalTokens.TokenNamedefault:
+ case TerminalTokens.TokenNameelse:
+ case TerminalTokens.TokenNameextends:
+ case TerminalTokens.TokenNamefor:
+ case TerminalTokens.TokenNamefinal:
+ case TerminalTokens.TokenNamefloat:
+ case TerminalTokens.TokenNamefalse:
+ case TerminalTokens.TokenNamefinally:
+ case TerminalTokens.TokenNameif:
+ case TerminalTokens.TokenNameint:
+ case TerminalTokens.TokenNameimport:
+ case TerminalTokens.TokenNameinterface:
+ case TerminalTokens.TokenNameimplements:
+ case TerminalTokens.TokenNameinstanceof:
+ case TerminalTokens.TokenNamelong:
+ case TerminalTokens.TokenNamenew:
+ case TerminalTokens.TokenNamenull:
+ case TerminalTokens.TokenNamenative:
+ case TerminalTokens.TokenNamepublic:
+ case TerminalTokens.TokenNamepackage:
+ case TerminalTokens.TokenNameprivate:
+ case TerminalTokens.TokenNameprotected:
+ case TerminalTokens.TokenNamereturn:
+ case TerminalTokens.TokenNameshort:
+ case TerminalTokens.TokenNamesuper:
+ case TerminalTokens.TokenNamestatic:
+ case TerminalTokens.TokenNameswitch:
+ case TerminalTokens.TokenNamestrictfp:
+ case TerminalTokens.TokenNamesynchronized:
+ case TerminalTokens.TokenNametry:
+ case TerminalTokens.TokenNamethis:
+ case TerminalTokens.TokenNametrue:
+ case TerminalTokens.TokenNamethrow:
+ case TerminalTokens.TokenNamethrows:
+ case TerminalTokens.TokenNametransient:
+ case TerminalTokens.TokenNamevoid:
+ case TerminalTokens.TokenNamevolatile:
+ case TerminalTokens.TokenNamewhile:
+ return true;
+ default:
+ return false;
+ }
+}
+
+private boolean isLiteral(int token) {
+ switch(token) {
+ case TerminalTokens.TokenNameIntegerLiteral:
+ case TerminalTokens.TokenNameLongLiteral:
+ case TerminalTokens.TokenNameFloatingPointLiteral:
+ case TerminalTokens.TokenNameDoubleLiteral:
+ case TerminalTokens.TokenNameStringLiteral:
+ case TerminalTokens.TokenNameCharacterLiteral:
+ return true;
+ default:
+ return false;
+ }
+}
+
+private boolean isIdentifier(int token) {
+ return token == TerminalTokens.TokenNameIdentifier;
+}
+
+private void syntaxError(
+ int id,
+ int startPosition,
+ int endPosition,
+ int currentKind,
+ char[] currentTokenSource,
+ String errorTokenName,
+ String expectedToken) {
+
+ String eTokenName;
+ if (isKeyword(currentKind) ||
+ isLiteral(currentKind) ||
+ isIdentifier(currentKind)) { //$NON-NLS-1$
+ eTokenName = new String(currentTokenSource);
+ } else {
+ eTokenName = errorTokenName;
+ }
+
+ String[] arguments;
+ if(expectedToken != null) {
+ arguments = new String[] {eTokenName, expectedToken};
+ } else {
+ arguments = new String[] {eTokenName};
+ }
+ this.handle(
+ id,
+ arguments,
+ arguments,
+ startPosition,
+ endPosition);
+}
+
+public void parseErrorInsertBeforeToken(
+ int start,
+ int end,
+ int currentKind,
+ char[] errorTokenSource,
+ String errorTokenName,
+ String expectedToken){
+ this.syntaxError(
+ IProblem.ParsingErrorInsertTokenBefore,
+ start,
+ end,
+ currentKind,
+ errorTokenSource,
+ errorTokenName,
+ expectedToken);
+}
+public void parseErrorInsertAfterToken(
+ int start,
+ int end,
+ int currentKind,
+ char[] errorTokenSource,
+ String errorTokenName,
+ String expectedToken){
+ this.syntaxError(
+ IProblem.ParsingErrorInsertTokenAfter,
+ start,
+ end,
+ currentKind,
+ errorTokenSource,
+ errorTokenName,
+ expectedToken);
+}
+public void parseErrorDeleteToken(
+ int start,
+ int end,
+ int currentKind,
+ char[] errorTokenSource,
+ String errorTokenName){
+ this.syntaxError(
+ IProblem.ParsingErrorDeleteToken,
+ start,
+ end,
+ currentKind,
+ errorTokenSource,
+ errorTokenName,
+ null);
+}
+public void parseErrorReplaceToken(
+ int start,
+ int end,
+ int currentKind,
+ char[] errorTokenSource,
+ String errorTokenName,
+ String expectedToken){
+ this.syntaxError(
+ IProblem.ParsingError,
+ start,
+ end,
+ currentKind,
+ errorTokenSource,
+ errorTokenName,
+ expectedToken);
+}
+public void parseErrorInvalidToken(
+ int start,
+ int end,
+ int currentKind,
+ char[] errorTokenSource,
+ String errorTokenName,
+ String expectedToken){
+ this.syntaxError(
+ IProblem.ParsingErrorInvalidToken,
+ start,
+ end,
+ currentKind,
+ errorTokenSource,
+ errorTokenName,
+ expectedToken);
+}
+public void parseErrorUnexpectedEnd(
+ int start,
+ int end){
+
+ String[] arguments;
+ if(this.referenceContext instanceof ConstructorDeclaration) {
+ arguments = new String[] {Util.bind("parser.endOfConstructor")}; //$NON-NLS-1$
+ } else if(this.referenceContext instanceof MethodDeclaration) {
+ arguments = new String[] {Util.bind("parser.endOfMethod")}; //$NON-NLS-1$
+ } else if(this.referenceContext instanceof TypeDeclaration) {
+ arguments = new String[] {Util.bind("parser.endOfInitializer")}; //$NON-NLS-1$
+ } else {
+ arguments = new String[] {Util.bind("parser.endOfFile")}; //$NON-NLS-1$
+ }
+ this.handle(
+ IProblem.ParsingErrorUnexpectedEOF,
+ arguments,
+ arguments,
+ start,
+ end);
+}
+public void parseErrorMergeTokens(
+ int start,
+ int end,
+ String expectedToken){
+ String[] arguments = new String[] {expectedToken};
+ this.handle(
+ IProblem.ParsingErrorMergeTokens,
+ arguments,
+ arguments,
+ start,
+ end);
+}
+public void parseErrorMisplacedConstruct(
+ int start,
+ int end){
+ this.handle(
+ IProblem.ParsingErrorMisplacedConstruct,
+ NoArgument,
+ NoArgument,
+ start,
+ end);
+}
+public void parseErrorNoSuggestion(
+ int start,
+ int end,
+ int currentKind,
+ char[] errorTokenSource,
+ String errorTokenName){
+ this.syntaxError(
+ IProblem.ParsingErrorNoSuggestion,
+ start,
+ end,
+ currentKind,
+ errorTokenSource,
+ errorTokenName,
+ null);
+}
+public void parseErrorDeleteTokens(
+ int start,
+ int end){
+ this.handle(
+ IProblem.ParsingErrorDeleteTokens,
+ NoArgument,
+ NoArgument,
+ start,
+ end);
+}
+public void parseErrorNoSuggestionForTokens(
+ int start,
+ int end){
+ this.handle(
+ IProblem.ParsingErrorNoSuggestionForTokens,
+ NoArgument,
+ NoArgument,
+ start,
+ end);
+}
+public void parseErrorReplaceTokens(
+ int start,
+ int end,
+ String expectedToken){
+ String[] arguments = new String[] {expectedToken};
+ this.handle(
+ IProblem.ParsingErrorReplaceTokens,
+ arguments,
+ arguments,
+ start,
+ end);
+}
+public void parseErrorInsertToComplete(
+ int start,
+ int end,
+ String inserted,
+ String completed){
+ String[] arguments = new String[] {inserted, completed};
+ this.handle(
+ IProblem.ParsingErrorInsertToComplete,
+ arguments,
+ arguments,
+ start,
+ end);
+}
+public void parseErrorInsertToCompleteScope(
+ int start,
+ int end,
+ String inserted){
+ String[] arguments = new String[] {inserted};
+ this.handle(
+ IProblem.ParsingErrorInsertToCompleteScope,
+ arguments,
+ arguments,
+ start,
+ end);
+}
+public void parseErrorInsertToCompletePhrase(
+ int start,
+ int end,
+ String inserted){
+ String[] arguments = new String[] {inserted};
+ this.handle(
+ IProblem.ParsingErrorInsertToCompletePhrase,
+ arguments,
+ arguments,
+ start,
+ end);
+}
+public void wrongSequenceOfExceptionTypesError(TryStatement statement, TypeBinding exceptionType, int under, TypeBinding hidingExceptionType) {
+ //the two catch block under and upper are in an incorrect order.
+ //under should be define BEFORE upper in the source
+
+ TypeReference typeRef = statement.catchArguments[under].type;
+ this.handle(
+ IProblem.InvalidCatchBlockSequence,
+ new String[] {
+ new String(exceptionType.readableName()),
+ new String(hidingExceptionType.readableName()),
+ },
+ new String[] {
+ new String(exceptionType.shortReadableName()),
+ new String(hidingExceptionType.shortReadableName()),
+ },
+ typeRef.sourceStart,
+ typeRef.sourceEnd);
+}
+
+}
projects / org.ibex.tool.git / blobdiff