/******************************************************************************* | |
* 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.wst.jsdt.internal.compiler.problem; | |
import org.eclipse.wst.jsdt.core.compiler.CharOperation; | |
import org.eclipse.wst.jsdt.core.compiler.IProblem; | |
import org.eclipse.wst.jsdt.internal.compiler.*; | |
import org.eclipse.wst.jsdt.internal.compiler.ast.*; | |
import org.eclipse.wst.jsdt.internal.compiler.env.IConstants; | |
import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions; | |
import org.eclipse.wst.jsdt.internal.compiler.impl.ReferenceContext; | |
import org.eclipse.wst.jsdt.internal.compiler.lookup.*; | |
import org.eclipse.wst.jsdt.internal.compiler.parser.*; | |
import org.eclipse.wst.jsdt.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 annotationTypeMemberDeclarationWithConstructorName(AnnotationTypeMemberDeclaration annotationTypeMemberDeclaration) { | |
this.handle( | |
IProblem.AnnotationButConstructorName, | |
NoArgument, | |
NoArgument, | |
annotationTypeMemberDeclaration.sourceStart, | |
annotationTypeMemberDeclaration.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 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 boundsMustBeAnInterface(ASTNode location, TypeBinding type) { | |
this.handle( | |
IProblem.BoundsMustBeAnInterface, | |
new String[] {new String(type.readableName())}, | |
new String[] {new String(type.shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location) { | |
if (location.isConstructor()) { | |
this.handle( | |
IProblem.BytecodeExceeds64KLimitForConstructor, | |
new String[] {new String(location.selector), parametersAsString(location.binding.parameters, false)}, | |
new String[] {new String(location.selector), parametersAsString(location.binding.parameters, true)}, | |
Error | Abort, | |
location.sourceStart, | |
location.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.BytecodeExceeds64KLimit, | |
new String[] {new String(location.selector), parametersAsString(location.binding.parameters, false)}, | |
new String[] {new String(location.selector), parametersAsString(location.binding.parameters, true)}, | |
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.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsString(method.parameters, true)}, | |
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 cannotUseSuperInCodeSnippet(int start, int end) { | |
this.handle( | |
IProblem.CannotUseSuperInCodeSnippet, | |
NoArgument, | |
NoArgument, | |
Error | Abort, | |
start, | |
end); | |
} | |
public void cannotUseSuperInJavaLangObject(ASTNode reference) { | |
this.handle( | |
IProblem.ObjectHasNoSuperclass, | |
NoArgument, | |
NoArgument, | |
reference.sourceStart, | |
reference.sourceEnd); | |
} | |
public void caseExpressionMustBeConstant(Expression expression) { | |
this.handle( | |
IProblem.NonConstantExpression, | |
NoArgument, | |
NoArgument, | |
expression.sourceStart, | |
expression.sourceEnd); | |
} | |
public void classExtendFinalClass(SourceTypeBinding type, TypeReference superclass, TypeBinding superTypeBinding) { | |
String name = new String(type.sourceName()); | |
String superTypeFullName = new String(superTypeBinding.readableName()); | |
String superTypeShortName = new String(superTypeBinding.shortReadableName()); | |
if (superTypeShortName.equals(name)) superTypeShortName = superTypeFullName; | |
this.handle( | |
IProblem.ClassExtendFinalClass, | |
new String[] {superTypeFullName, name}, | |
new String[] {superTypeShortName, 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.UseEnumAsAnIdentifier : | |
return this.options.getSeverity(CompilerOptions.EnumUsedAsAnIdentifier); | |
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); | |
case IProblem.UnsafeRawConstructorInvocation: | |
case IProblem.UnsafeRawMethodInvocation: | |
case IProblem.UnsafeRawConversion: | |
case IProblem.UnsafeRawFieldAssignment: | |
case IProblem.UnsafeGenericCast: | |
case IProblem.UnsafeReturnTypeOverride: | |
return this.options.getSeverity(CompilerOptions.UnsafeTypeOperation); | |
case IProblem.FinalBoundForTypeVariable: | |
return this.options.getSeverity(CompilerOptions.FinalParameterBound); | |
case IProblem.MissingSerialVersion: | |
return this.options.getSeverity(CompilerOptions.MissingSerialVersion); | |
case IProblem.ForbiddenReference: | |
return this.options.getSeverity(CompilerOptions.ForbiddenReference); | |
/* | |
* Javadoc syntax errors | |
*/ | |
case IProblem.JavadocUnexpectedTag: | |
case IProblem.JavadocDuplicateReturnTag: | |
case IProblem.JavadocInvalidThrowsClass: | |
case IProblem.JavadocInvalidReference: | |
case IProblem.JavadocMalformedSeeReference: | |
case IProblem.JavadocInvalidSeeHref: | |
case IProblem.JavadocInvalidSeeArgs: | |
case IProblem.JavadocInvalidTag: | |
case IProblem.JavadocUnterminatedInlineTag: | |
case IProblem.JavadocMissingHashCharacter: | |
case IProblem.JavadocEmptyReturnTag: | |
case IProblem.JavadocUnexpectedText: | |
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.JavadocMissingReference: | |
case IProblem.JavadocInvalidValueReference: | |
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 corruptedSignature(TypeBinding enclosingType, char[] signature, int position) { | |
this.handle( | |
IProblem.CorruptedSignature, | |
new String[] { new String(enclosingType.readableName()), new String(signature), String.valueOf(position) }, | |
new String[] { new String(enclosingType.shortReadableName()), new String(signature), String.valueOf(position) }, | |
Error | Abort, | |
0, | |
0); | |
} | |
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.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), parametersAsString(method.parameters, true)}, | |
location.sourceStart, | |
location.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.UsingDeprecatedMethod, | |
new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsString(method.parameters, true)}, | |
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) { | |
MethodBinding method = methodDecl.binding; | |
boolean duplicateErasure = false; | |
if ((method.modifiers & CompilerModifiers.AccGenericSignature) != 0) { | |
// chech it occurs in parameters (the bit is set for return type | params | thrown exceptions | |
for (int i = 0, length = method.parameters.length; i < length; i++) { | |
if ((method.parameters[i].tagBits & TagBits.HasTypeVariable) != 0) { | |
duplicateErasure = true; | |
break; | |
} | |
} | |
} | |
if (duplicateErasure) { | |
int length = method.parameters.length; | |
TypeBinding[] erasures = new TypeBinding[length]; | |
for (int i = 0; i < length; i++) { | |
erasures[i] = method.parameters[i].erasure(); | |
} | |
this.handle( | |
IProblem.DuplicateMethodErasure, | |
new String[] { | |
new String(methodDecl.selector), | |
new String(method.declaringClass.readableName()), | |
parametersAsString(method.parameters, false), | |
parametersAsString(erasures, false) } , | |
new String[] { | |
new String(methodDecl.selector), | |
new String(method.declaringClass.shortReadableName()), | |
parametersAsString(method.parameters, true), | |
parametersAsString(erasures, true) }, | |
methodDecl.sourceStart, | |
methodDecl.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.DuplicateMethod, | |
new String[] { | |
new String(methodDecl.selector), | |
new String(method.declaringClass.readableName()), | |
parametersAsString(method.parameters, false)}, | |
new String[] { | |
new String(methodDecl.selector), | |
new String(method.declaringClass.shortReadableName()), | |
parametersAsString(method.parameters, true)}, | |
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 duplicateTypeParameterInType(TypeParameter typeParameter) { | |
this.handle( | |
IProblem.DuplicateTypeVariable, | |
new String[] { new String(typeParameter.name)}, | |
new String[] { new String(typeParameter.name)}, | |
typeParameter.sourceStart, | |
typeParameter.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 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 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 finalVariableBound(TypeVariableBinding typeVariable, TypeReference typeRef) { | |
this.handle( | |
IProblem.FinalBoundForTypeVariable, | |
new String[] { new String(typeVariable.sourceName), new String(typeRef.resolvedType.readableName())}, | |
new String[] { new String(typeVariable.sourceName), new String(typeRef.resolvedType.shortReadableName())}, | |
typeRef.sourceStart, | |
typeRef.sourceEnd); | |
} | |
public void forbiddenReference(TypeBinding type, ASTNode location, String visibilityRuleOwner) { | |
if (location == null) return; | |
this.handle( | |
IProblem.ForbiddenReference, | |
new String[] {new String(type.readableName()), visibilityRuleOwner}, | |
new String[] {new String(type.shortReadableName()), visibilityRuleOwner}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void forwardReference(Reference reference, int indexInQualification, TypeBinding type) { | |
this.handle( | |
IProblem.ReferenceToForwardField, | |
NoArgument, | |
NoArgument, | |
reference.sourceStart, | |
reference.sourceEnd); | |
} | |
public void forwardTypeVariableReference(ASTNode location, TypeVariableBinding type) { | |
this.handle( | |
IProblem.ReferenceToForwardTypeVariable, | |
new String[] {new String(type.readableName())}, | |
new String[] {new String(type.shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void genericTypeCannotExtendThrowable(TypeDeclaration typeDecl) { | |
this.handle( | |
IProblem.GenericTypeCannotExtendThrowable, | |
new String[]{ new String(typeDecl.binding.readableName()) }, | |
new String[]{ new String(typeDecl.binding.shortReadableName()) }, | |
typeDecl.superclass.sourceStart, | |
typeDecl.superclass.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 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; | |
} | |
// 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; | |
} | |
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 = new String(superType.readableName()); | |
String shortTypeName = new String(superType.sourceName()); | |
if (reference == null) { // can only happen when java.lang.Object is busted | |
start = sourceType.sourceStart(); | |
end = sourceType.sourceEnd(); | |
} else { | |
start = reference.sourceStart; | |
end = reference.sourceEnd; | |
if (sourceType != superType) { | |
char[][] qName = reference.getTypeName(); | |
typeName = CharOperation.toString(qName); | |
shortTypeName = new String(qName[qName.length-1]); | |
} | |
} | |
if (sourceType == superType) | |
this.handle( | |
IProblem.HierarchyCircularitySelfReference, | |
new String[] {typeName}, | |
new String[] {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 illegalClassLiteralForTypeVariable(TypeVariableBinding variable, ASTNode location) { | |
String[] arguments = new String[] { new String(variable.sourceName) }; | |
this.handle( | |
IProblem.IllegalClassLiteralForTypeVariable, | |
arguments, | |
arguments, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void illegalExtendedDimensions(AnnotationTypeMemberDeclaration annotationTypeMemberDeclaration) { | |
this.handle( | |
IProblem.IllegalExtendedDimensions, | |
NoArgument, | |
NoArgument, | |
annotationTypeMemberDeclaration.sourceStart, | |
annotationTypeMemberDeclaration.sourceEnd); | |
} | |
public void illegalGenericArray(TypeBinding leadtComponentType, ASTNode location) { | |
this.handle( | |
IProblem.IllegalGenericArray, | |
new String[]{ new String(leadtComponentType.readableName())}, | |
new String[]{ new String(leadtComponentType.shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void illegalInstanceOfGenericType(TypeBinding checkedType, ASTNode location) { | |
if (checkedType.isTypeVariable()) { | |
this.handle( | |
IProblem.IllegalInstanceofTypeParameter, | |
new String[] { new String(checkedType.readableName()), new String(checkedType.erasure().readableName())}, | |
new String[] { new String(checkedType.shortReadableName()), new String(checkedType.erasure().shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
return; | |
} | |
this.handle( | |
IProblem.IllegalInstanceofParameterizedType, | |
new String[] { new String(checkedType.readableName()), new String(checkedType.erasure().sourceName())}, | |
new String[] { new String(checkedType.shortReadableName()), new String(checkedType.erasure().sourceName())}, | |
location.sourceStart, | |
location.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 illegalUsageOfQualifiedTypeReference(QualifiedTypeReference qualifiedTypeReference) { | |
StringBuffer buffer = new StringBuffer(); | |
char[][] tokens = qualifiedTypeReference.tokens; | |
for (int i = 0; i < tokens.length; i++) { | |
if (i > 0) buffer.append('.'); | |
buffer.append(tokens[i]); | |
} | |
String[] arguments = new String[] { String.valueOf(buffer)}; | |
this.handle( | |
IProblem.IllegalUsageOfQualifiedTypeReference, | |
arguments, | |
arguments, | |
qualifiedTypeReference.sourceStart, | |
qualifiedTypeReference.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) { | |
if (expectedImport.problemId() == NotFound) { | |
char[][] tokens = expectedImport instanceof ProblemReferenceBinding | |
? ((ProblemReferenceBinding) expectedImport).compoundName | |
: importRef.tokens; | |
String[] arguments = new String[]{CharOperation.toString(tokens)}; | |
this.handle( | |
IProblem.ImportNotFound, | |
arguments, | |
arguments, | |
importRef.sourceStart, | |
(int) importRef.sourcePositions[tokens.length - 1]); | |
return; | |
} | |
invalidType(importRef, (TypeBinding)expectedImport); | |
} | |
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 incorrectArityForParameterizedType(ASTNode location, TypeBinding type, TypeBinding[] argumentTypes) { | |
if (location == null) { | |
this.handle( | |
IProblem.IncorrectArityForParameterizedType, | |
new String[] {new String(type.readableName()), parametersAsString(argumentTypes, false)}, | |
new String[] {new String(type.shortReadableName()), parametersAsString(argumentTypes, true)}, | |
AbortCompilation | Error, | |
0, | |
1); | |
} | |
this.handle( | |
IProblem.IncorrectArityForParameterizedType, | |
new String[] {new String(type.readableName()), parametersAsString(argumentTypes, false)}, | |
new String[] {new String(type.shortReadableName()), parametersAsString(argumentTypes, true)}, | |
location.sourceStart, | |
location.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 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 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.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsString(method.parameters, true)}, | |
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 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... | |
MethodBinding shownConstructor = targetConstructor; | |
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; | |
} | |
ProblemMethodBinding problemConstructor = (ProblemMethodBinding) targetConstructor; | |
if (problemConstructor.closestMatch != null) { | |
shownConstructor = problemConstructor.closestMatch.original(); | |
} | |
break; | |
case Ambiguous : | |
if (insideDefaultConstructor){ | |
id = IProblem.AmbiguousConstructorInDefaultConstructor; | |
} else if (insideImplicitConstructorCall){ | |
id = IProblem.AmbiguousConstructorInImplicitConstructorCall; | |
} else { | |
id = IProblem.AmbiguousConstructor; | |
} | |
break; | |
case ParameterBoundMismatch : | |
problemConstructor = (ProblemMethodBinding) targetConstructor; | |
ParameterizedGenericMethodBinding substitutedConstructor = (ParameterizedGenericMethodBinding) problemConstructor.closestMatch; | |
shownConstructor = substitutedConstructor.original(); | |
TypeBinding typeArgument = targetConstructor.parameters[0]; | |
TypeVariableBinding typeParameter = (TypeVariableBinding) targetConstructor.parameters[1]; | |
this.handle( | |
IProblem.GenericConstructorTypeArgumentMismatch, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, false), | |
new String(shownConstructor.declaringClass.readableName()), | |
parametersAsString(substitutedConstructor.parameters, false), | |
new String(typeArgument.readableName()), | |
new String(typeParameter.sourceName), | |
parameterBoundAsString(typeParameter, false) }, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, true), | |
new String(shownConstructor.declaringClass.shortReadableName()), | |
parametersAsString(substitutedConstructor.parameters, true), | |
new String(typeArgument.shortReadableName()), | |
new String(typeParameter.sourceName), | |
parameterBoundAsString(typeParameter, true) }, | |
statement.sourceStart, | |
statement.sourceEnd); | |
return; | |
case TypeParameterArityMismatch : | |
problemConstructor = (ProblemMethodBinding) targetConstructor; | |
shownConstructor = problemConstructor.closestMatch; | |
if (shownConstructor.typeVariables == TypeConstants.NoTypeVariables) { | |
this.handle( | |
IProblem.NonGenericConstructor, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, false), | |
new String(shownConstructor.declaringClass.readableName()), | |
parametersAsString(targetConstructor.parameters, false) }, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, true), | |
new String(shownConstructor.declaringClass.shortReadableName()), | |
parametersAsString(targetConstructor.parameters, true) }, | |
statement.sourceStart, | |
statement.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.IncorrectArityForParameterizedConstructor , | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, false), | |
new String(shownConstructor.declaringClass.readableName()), | |
parametersAsString(shownConstructor.typeVariables, false), | |
parametersAsString(targetConstructor.parameters, false) }, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, true), | |
new String(shownConstructor.declaringClass.shortReadableName()), | |
parametersAsString(shownConstructor.typeVariables, true), | |
parametersAsString(targetConstructor.parameters, true) }, | |
statement.sourceStart, | |
statement.sourceEnd); | |
} | |
return; | |
case ParameterizedMethodTypeMismatch : | |
problemConstructor = (ProblemMethodBinding) targetConstructor; | |
shownConstructor = problemConstructor.closestMatch; | |
this.handle( | |
IProblem.ParameterizedConstructorArgumentTypeMismatch, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, false), | |
new String(shownConstructor.declaringClass.readableName()), | |
parametersAsString(((ParameterizedGenericMethodBinding)shownConstructor).typeArguments, false), | |
parametersAsString(targetConstructor.parameters, false) }, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, true), | |
new String(shownConstructor.declaringClass.shortReadableName()), | |
parametersAsString(((ParameterizedGenericMethodBinding)shownConstructor).typeArguments, true), | |
parametersAsString(targetConstructor.parameters, true) }, | |
statement.sourceStart, | |
statement.sourceEnd); | |
return; | |
case TypeArgumentsForRawGenericMethod : | |
problemConstructor = (ProblemMethodBinding) targetConstructor; | |
shownConstructor = problemConstructor.closestMatch; | |
this.handle( | |
IProblem.TypeArgumentsForRawGenericConstructor, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, false), | |
new String(shownConstructor.declaringClass.readableName()), | |
parametersAsString(targetConstructor.parameters, false) }, | |
new String[] { | |
new String(shownConstructor.declaringClass.sourceName()), | |
parametersAsString(shownConstructor.parameters, true), | |
new String(shownConstructor.declaringClass.shortReadableName()), | |
parametersAsString(targetConstructor.parameters, true) }, | |
statement.sourceStart, | |
statement.sourceEnd); | |
return; | |
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(shownConstructor.parameters, false)}, | |
new String[] {new String(targetConstructor.declaringClass.shortReadableName()), parametersAsString(shownConstructor.parameters, true)}, | |
statement.sourceStart, | |
statement.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 invalidExplicitConstructorCall(ASTNode location) { | |
this.handle( | |
IProblem.InvalidExplicitConstructorCall, | |
NoArgument, | |
NoArgument, | |
location.sourceStart, | |
location.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 invalidFileNameForPackageAnnotations(Annotation annotation) { | |
this.handle( | |
IProblem.InvalidFileNameForPackageAnnotations, | |
NoArgument, | |
NoArgument, | |
annotation.sourceStart, | |
annotation.sourceEnd); | |
} | |
public void invalidMethod(MessageSend messageSend, MethodBinding method) { | |
int id = IProblem.UndefinedMethod; //default... | |
MethodBinding shownMethod = method; | |
switch (method.problemId()) { | |
case NotFound : | |
id = IProblem.UndefinedMethod; | |
ProblemMethodBinding problemMethod = (ProblemMethodBinding) method; | |
if (problemMethod.closestMatch != null) { | |
shownMethod = problemMethod.closestMatch; | |
String closestParameterTypeNames = parametersAsString(shownMethod.parameters, false); | |
String parameterTypeNames = parametersAsString(method.parameters, false); | |
String closestParameterTypeShortNames = parametersAsString(shownMethod.parameters, true); | |
String parameterTypeShortNames = parametersAsString(method.parameters, true); | |
if (closestParameterTypeShortNames.equals(parameterTypeShortNames)){ | |
closestParameterTypeShortNames = closestParameterTypeNames; | |
parameterTypeShortNames = parameterTypeNames; | |
} | |
this.handle( | |
IProblem.ParameterMismatch, | |
new String[] { | |
new String(shownMethod.declaringClass.readableName()), | |
new String(shownMethod.selector), | |
closestParameterTypeNames, | |
parameterTypeNames | |
}, | |
new String[] { | |
new String(shownMethod.declaringClass.shortReadableName()), | |
new String(shownMethod.selector), | |
closestParameterTypeShortNames, | |
parameterTypeShortNames | |
}, | |
(int) (messageSend.nameSourcePosition >>> 32), | |
(int) messageSend.nameSourcePosition); | |
return; | |
} | |
break; | |
case NotVisible : | |
id = IProblem.NotVisibleMethod; | |
problemMethod = (ProblemMethodBinding) method; | |
if (problemMethod.closestMatch != null) { | |
shownMethod = problemMethod.closestMatch.original(); | |
} | |
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 ParameterBoundMismatch : | |
problemMethod = (ProblemMethodBinding) method; | |
ParameterizedGenericMethodBinding substitutedMethod = (ParameterizedGenericMethodBinding) problemMethod.closestMatch; | |
shownMethod = substitutedMethod.original(); | |
TypeBinding typeArgument = method.parameters[0]; | |
TypeVariableBinding typeParameter = (TypeVariableBinding) method.parameters[1]; | |
this.handle( | |
IProblem.GenericMethodTypeArgumentMismatch, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, false), | |
new String(shownMethod.declaringClass.readableName()), | |
parametersAsString(substitutedMethod.parameters, false), | |
new String(typeArgument.readableName()), | |
new String(typeParameter.sourceName), | |
parameterBoundAsString(typeParameter, false) }, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, true), | |
new String(shownMethod.declaringClass.shortReadableName()), | |
parametersAsString(substitutedMethod.parameters, true), | |
new String(typeArgument.shortReadableName()), | |
new String(typeParameter.sourceName), | |
parameterBoundAsString(typeParameter, true) }, | |
(int) (messageSend.nameSourcePosition >>> 32), | |
(int) messageSend.nameSourcePosition); | |
return; | |
case TypeParameterArityMismatch : | |
problemMethod = (ProblemMethodBinding) method; | |
shownMethod = problemMethod.closestMatch; | |
if (shownMethod.typeVariables == TypeConstants.NoTypeVariables) { | |
this.handle( | |
IProblem.NonGenericMethod , | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, false), | |
new String(shownMethod.declaringClass.readableName()), | |
parametersAsString(method.parameters, false) }, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, true), | |
new String(shownMethod.declaringClass.shortReadableName()), | |
parametersAsString(method.parameters, true) }, | |
(int) (messageSend.nameSourcePosition >>> 32), | |
(int) messageSend.nameSourcePosition); | |
} else { | |
this.handle( | |
IProblem.IncorrectArityForParameterizedMethod , | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, false), | |
new String(shownMethod.declaringClass.readableName()), | |
parametersAsString(shownMethod.typeVariables, false), | |
parametersAsString(method.parameters, false) }, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, true), | |
new String(shownMethod.declaringClass.shortReadableName()), | |
parametersAsString(shownMethod.typeVariables, true), | |
parametersAsString(method.parameters, true) }, | |
(int) (messageSend.nameSourcePosition >>> 32), | |
(int) messageSend.nameSourcePosition); | |
} | |
return; | |
case ParameterizedMethodTypeMismatch : | |
problemMethod = (ProblemMethodBinding) method; | |
shownMethod = problemMethod.closestMatch; | |
this.handle( | |
IProblem.ParameterizedMethodArgumentTypeMismatch, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, false), | |
new String(shownMethod.declaringClass.readableName()), | |
parametersAsString(((ParameterizedGenericMethodBinding)shownMethod).typeArguments, false), | |
parametersAsString(method.parameters, false) }, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, true), | |
new String(shownMethod.declaringClass.shortReadableName()), | |
parametersAsString(((ParameterizedGenericMethodBinding)shownMethod).typeArguments, true), | |
parametersAsString(method.parameters, true) }, | |
(int) (messageSend.nameSourcePosition >>> 32), | |
(int) messageSend.nameSourcePosition); | |
return; | |
case TypeArgumentsForRawGenericMethod : | |
problemMethod = (ProblemMethodBinding) method; | |
shownMethod = problemMethod.closestMatch; | |
this.handle( | |
IProblem.TypeArgumentsForRawGenericMethod , | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, false), | |
new String(shownMethod.declaringClass.readableName()), | |
parametersAsString(method.parameters, false) }, | |
new String[] { | |
new String(shownMethod.selector), | |
parametersAsString(shownMethod.parameters, true), | |
new String(shownMethod.declaringClass.shortReadableName()), | |
parametersAsString(method.parameters, true) }, | |
(int) (messageSend.nameSourcePosition >>> 32), | |
(int) messageSend.nameSourcePosition); | |
return; | |
case NoError : // 0 | |
default : | |
needImplementation(); // want to fail to see why we were here... | |
break; | |
} | |
this.handle( | |
id, | |
new String[] { | |
new String(method.declaringClass.readableName()), | |
new String(shownMethod.selector), parametersAsString(shownMethod.parameters, false)}, | |
new String[] { | |
new String(method.declaringClass.shortReadableName()), | |
new String(shownMethod.selector), parametersAsString(shownMethod.parameters, true)}, | |
(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 invalidParameterizedExceptionType(TypeBinding exceptionType, ASTNode location) { | |
this.handle( | |
IProblem.InvalidParameterizedExceptionType, | |
new String[] {new String(exceptionType.readableName())}, | |
new String[] {new String(exceptionType.shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void invalidParenthesizedExpression(ASTNode reference) { | |
this.handle( | |
IProblem.InvalidParenthesizedExpression, | |
NoArgument, | |
NoArgument, | |
reference.sourceStart, | |
reference.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 NonStaticReferenceInStaticContext : | |
id = IProblem.TypeVariableReferenceFromStaticContext; | |
break; | |
case IllegalSuperTypeVariable : | |
id = IProblem.IllegalTypeVariableSuperReference; | |
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]; | |
} else if (location instanceof QualifiedTypeReference) { | |
QualifiedTypeReference ref = (QualifiedTypeReference) location; | |
if (type instanceof ReferenceBinding) { | |
char[][] name = ((ReferenceBinding) type).compoundName; | |
end = (int) ref.sourcePositions[name.length - 1]; | |
} | |
} else if (location instanceof ImportReference) { | |
ImportReference ref = (ImportReference) location; | |
if (type instanceof ReferenceBinding) { | |
char[][] name = ((ReferenceBinding) type).compoundName; | |
end = (int) ref.sourcePositions[name.length - 1]; | |
} | |
} | |
this.handle( | |
id, | |
new String[] {new String(type.readableName()) }, | |
new String[] {new String(type.shortReadableName())}, | |
location.sourceStart, | |
end); | |
} | |
public void invalidTypeForCollection(Expression expression) { | |
this.handle( | |
IProblem.InvalidTypeForCollection, | |
NoArgument, | |
NoArgument, | |
expression.sourceStart, | |
expression.sourceEnd); | |
} | |
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 invalidTypeVariableAsException(TypeBinding exceptionType, ASTNode location) { | |
this.handle( | |
IProblem.InvalidTypeVariableExceptionType, | |
new String[] {new String(exceptionType.readableName())}, | |
new String[] {new String(exceptionType.shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void invalidUnaryExpression(Expression expression) { | |
this.handle( | |
IProblem.InvalidUnaryExpression, | |
NoArgument, | |
NoArgument, | |
expression.sourceStart, | |
expression.sourceEnd); | |
} | |
public void invalidUsageOfAnnotation(Annotation annotation) { | |
this.handle( | |
IProblem.InvalidUsageOfAnnotations, | |
NoArgument, | |
NoArgument, | |
annotation.sourceStart, | |
annotation.sourceEnd); | |
} | |
public void invalidUsageOfAnnotationDeclarations(AnnotationTypeDeclaration annotationTypeDeclaration) { | |
this.handle( | |
IProblem.InvalidUsageOfAnnotationDeclarations, | |
NoArgument, | |
NoArgument, | |
annotationTypeDeclaration.sourceStart, | |
annotationTypeDeclaration.sourceEnd); | |
} | |
public void invalidUsageOfEnumDeclarations(EnumDeclaration enumDeclaration) { | |
this.handle( | |
IProblem.InvalidUsageOfEnumDeclarations, | |
NoArgument, | |
NoArgument, | |
enumDeclaration.sourceStart, | |
enumDeclaration.sourceEnd); | |
} | |
public void invalidUsageOfForeachStatements(LocalDeclaration elementVariable, Expression collection) { | |
this.handle( | |
IProblem.InvalidUsageOfForeachStatements, | |
NoArgument, | |
NoArgument, | |
elementVariable.declarationSourceStart, | |
collection.sourceEnd); | |
} | |
public void invalidUsageOfStaticImports(ImportReference staticImport) { | |
this.handle( | |
IProblem.InvalidUsageOfStaticImports, | |
NoArgument, | |
NoArgument, | |
staticImport.declarationSourceStart, | |
staticImport.declarationSourceEnd); | |
} | |
public void invalidUsageOfTypeArguments(TypeReference firstTypeReference, TypeReference lastTypeReference) { | |
this.handle( | |
IProblem.InvalidUsageOfTypeArguments, | |
NoArgument, | |
NoArgument, | |
firstTypeReference.sourceStart, | |
lastTypeReference.sourceEnd); | |
} | |
public void invalidUsageOfTypeParameters(TypeParameter firstTypeParameter, TypeParameter lastTypeParameter) { | |
this.handle( | |
IProblem.InvalidUsageOfTypeParameters, | |
NoArgument, | |
NoArgument, | |
firstTypeParameter.declarationSourceStart, | |
lastTypeParameter.declarationSourceEnd); | |
} | |
public void invalidUsageOfVarargs(Argument argument) { | |
this.handle( | |
IProblem.InvalidUsageOfVarargs, | |
NoArgument, | |
NoArgument, | |
argument.type.sourceStart, | |
argument.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); | |
} | |
private boolean isIdentifier(int token) { | |
return token == TerminalTokens.TokenNameIdentifier; | |
} | |
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; | |
} | |
} | |
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); | |
} | |
} | |
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.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), parametersAsString(method.parameters, true)}, | |
location.sourceStart, | |
location.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.JavadocUsingDeprecatedMethod, | |
new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsString(method.parameters, true)}, | |
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 javadocDuplicatedReturnTag(int sourceStart, int sourceEnd){ | |
this.handle(IProblem.JavadocDuplicateReturnTag, NoArgument, NoArgument, sourceStart, 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 javadocEmptyReturnTag(int sourceStart, int sourceEnd) { | |
this.handle(IProblem.JavadocEmptyReturnTag, NoArgument, NoArgument, sourceStart, 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.parameters, false)}, | |
new String[] {new String(targetConstructor.declaringClass.shortReadableName()), parametersAsString(targetConstructor.parameters, true)}, | |
statement.sourceStart, | |
statement.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.parameters, false); | |
String parameterTypeNames = parametersAsString(method.parameters, false); | |
String closestParameterTypeShortNames = parametersAsString(problemMethod.closestMatch.parameters, true); | |
String parameterTypeShortNames = parametersAsString(method.parameters, true); | |
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.parameters, false)}, | |
new String[] { | |
new String(method.declaringClass.shortReadableName()), | |
new String(method.selector), parametersAsString(method.parameters, true)}, | |
(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 javadocInvalidReference(int sourceStart, int sourceEnd) { | |
this.handle(IProblem.JavadocInvalidReference, 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 javadocInvalidValueReference(int sourceStart, int sourceEnd) { | |
this.handle(IProblem.JavadocInvalidValueReference, NoArgument, NoArgument, sourceStart, 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 javadocMissingHashCharacter(int sourceStart, int sourceEnd, String ref){ | |
String[] arguments = new String[] { ref }; | |
this.handle(IProblem.JavadocMissingHashCharacter, 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 javadocMissingReference(int sourceStart, int sourceEnd){ | |
this.handle(IProblem.JavadocMissingReference, NoArgument, NoArgument, sourceStart, 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 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 javadocUnexpectedText(int sourceStart, int sourceEnd) { | |
this.handle(IProblem.JavadocUnexpectedText, 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 methodNameClash(MethodBinding currentMethod, MethodBinding inheritedMethod) { | |
this.handle( | |
IProblem.MethodNameClash, | |
new String[] { | |
new String(currentMethod.selector), | |
parametersAsString(currentMethod.original().parameters, false), | |
new String(currentMethod.declaringClass.readableName()), | |
parametersAsString(inheritedMethod.original().parameters, false), | |
new String(inheritedMethod.declaringClass.readableName()), | |
}, | |
new String[] { | |
new String(currentMethod.selector), | |
parametersAsString(currentMethod.original().parameters, true), | |
new String(currentMethod.declaringClass.shortReadableName()), | |
parametersAsString(inheritedMethod.original().parameters, true), | |
new String(inheritedMethod.declaringClass.shortReadableName()), | |
}, | |
currentMethod.sourceStart(), | |
currentMethod.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 parameterizedMemberTypeMissingArguments(ASTNode location, TypeBinding type) { | |
if (location == null) { // binary case | |
this.handle( | |
IProblem.MissingArgumentsForParameterizedMemberType, | |
new String[] {new String(type.readableName())}, | |
new String[] {new String(type.shortReadableName())}, | |
AbortCompilation | Error, | |
0, | |
1); | |
return; | |
} | |
this.handle( | |
IProblem.MissingArgumentsForParameterizedMemberType, | |
new String[] {new String(type.readableName())}, | |
new String[] {new String(type.shortReadableName())}, | |
location.sourceStart, | |
location.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 missingSerialVersion(TypeDeclaration typeDecl) { | |
String[] arguments = new String[] {new String(typeDecl.name)}; | |
this.handle( | |
IProblem.MissingSerialVersion, | |
arguments, | |
arguments, | |
typeDecl.sourceStart, | |
typeDecl.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.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsString(method.parameters, true)}, | |
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 needToEmulateFieldAccess(FieldBinding field, ASTNode location, boolean isReadAccess) { | |
this.handle( | |
isReadAccess | |
? IProblem.NeedToEmulateFieldReadAccess | |
: 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.parameters, false) | |
}, | |
new String[] { | |
new String(method.declaringClass.shortReadableName()), | |
parametersAsString(method.parameters, true) | |
}, | |
location.sourceStart, | |
location.sourceEnd); | |
else | |
this.handle( | |
IProblem.NeedToEmulateMethodAccess, | |
new String[] { | |
new String(method.declaringClass.readableName()), | |
new String(method.selector), | |
parametersAsString(method.parameters, false) | |
}, | |
new String[] { | |
new String(method.declaringClass.shortReadableName()), | |
new String(method.selector), | |
parametersAsString(method.parameters, true) | |
}, | |
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 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 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 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); | |
} | |
public void nonExternalizedStringLiteral(ASTNode location) { | |
this.handle( | |
IProblem.NonExternalizedStringLiteral, | |
NoArgument, | |
NoArgument, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void nonGenericTypeCannotBeParameterized(ASTNode location, TypeBinding type, TypeBinding[] argumentTypes) { | |
if (location == null) { // binary case | |
this.handle( | |
IProblem.NonGenericType, | |
new String[] {new String(type.readableName()), parametersAsString(argumentTypes, false)}, | |
new String[] {new String(type.shortReadableName()), parametersAsString(argumentTypes, true)}, | |
AbortCompilation | Error, | |
0, | |
1); | |
return; | |
} | |
this.handle( | |
IProblem.NonGenericType, | |
new String[] {new String(type.readableName()), parametersAsString(argumentTypes, false)}, | |
new String[] {new String(type.shortReadableName()), parametersAsString(argumentTypes, true)}, | |
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 nonStaticAccessToStaticMethod(ASTNode location, MethodBinding method) { | |
this.handle( | |
IProblem.NonStaticAccessToStaticMethod, | |
new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method.parameters, false)}, | |
new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsString(method.parameters, true)}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
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 notCompatibleTypesErrorInForeach(Expression 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.IncompatibleTypesInForeach, | |
new String[] {leftName, rightName }, | |
new String[] {leftShortName, rightShortName }, | |
expression.sourceStart, | |
expression.sourceEnd); | |
} | |
public void objectCannotBeGeneric(TypeDeclaration typeDecl) { | |
this.handle( | |
IProblem.ObjectCannotBeGeneric, | |
NoArgument, | |
NoArgument, | |
typeDecl.typeParameters[0].sourceStart, | |
typeDecl.typeParameters[typeDecl.typeParameters.length-1].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 parameterBoundAsString(TypeVariableBinding typeVariable, boolean makeShort) { | |
StringBuffer nameBuffer = new StringBuffer(10); | |
if (typeVariable.firstBound == typeVariable.superclass) { | |
nameBuffer.append(makeShort ? typeVariable.superclass.shortReadableName() : typeVariable.superclass.readableName()); | |
} | |
int length; | |
if ((length = typeVariable.superInterfaces.length) > 0) { | |
for (int i = 0; i < length; i++) { | |
if (i > 0 || typeVariable.firstBound == typeVariable.superclass) nameBuffer.append(" & "); //$NON-NLS-1$ | |
nameBuffer.append(makeShort ? typeVariable.superInterfaces[i].shortReadableName() : typeVariable.superInterfaces[i].readableName()); | |
} | |
} | |
return nameBuffer.toString(); | |
} | |
private String parametersAsString(TypeBinding[] params, boolean makeShort) { | |
StringBuffer buffer = new StringBuffer(10); | |
for (int i = 0, length = params.length; i < length; i++) { | |
if (i != 0) | |
buffer.append(", "); //$NON-NLS-1$ | |
buffer.append(new String(makeShort ? params[i].shortReadableName() : params[i].readableName())); | |
} | |
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 parseErrorDeleteToken( | |
int start, | |
int end, | |
int currentKind, | |
char[] errorTokenSource, | |
String errorTokenName){ | |
this.syntaxError( | |
IProblem.ParsingErrorDeleteToken, | |
start, | |
end, | |
currentKind, | |
errorTokenSource, | |
errorTokenName, | |
null); | |
} | |
public void parseErrorDeleteTokens( | |
int start, | |
int end){ | |
this.handle( | |
IProblem.ParsingErrorDeleteTokens, | |
NoArgument, | |
NoArgument, | |
start, | |
end); | |
} | |
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 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 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 parseErrorInsertToCompletePhrase( | |
int start, | |
int end, | |
String inserted){ | |
String[] arguments = new String[] {inserted}; | |
this.handle( | |
IProblem.ParsingErrorInsertToCompletePhrase, | |
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 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 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 parseErrorNoSuggestionForTokens( | |
int start, | |
int end){ | |
this.handle( | |
IProblem.ParsingErrorNoSuggestionForTokens, | |
NoArgument, | |
NoArgument, | |
start, | |
end); | |
} | |
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 parseErrorReplaceTokens( | |
int start, | |
int end, | |
String expectedToken){ | |
String[] arguments = new String[] {expectedToken}; | |
this.handle( | |
IProblem.ParsingErrorReplaceTokens, | |
arguments, | |
arguments, | |
start, | |
end); | |
} | |
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 possibleAccidentalBooleanAssignment(Assignment assignment) { | |
this.handle( | |
IProblem.PossibleAccidentalBooleanAssignment, | |
NoArgument, | |
NoArgument, | |
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 rawMemberTypeCannotBeParameterized(ASTNode location, ReferenceBinding type, TypeBinding[] argumentTypes) { | |
if (location == null) { // binary case | |
this.handle( | |
IProblem.RawMemberTypeCannotBeParameterized, | |
new String[] {new String(type.readableName()), parametersAsString(argumentTypes, false), new String(type.enclosingType().readableName())}, | |
new String[] {new String(type.shortReadableName()), parametersAsString(argumentTypes, true), new String(type.enclosingType().shortReadableName())}, | |
AbortCompilation | Error, | |
0, | |
1); | |
return; | |
} | |
this.handle( | |
IProblem.RawMemberTypeCannotBeParameterized, | |
new String[] {new String(type.readableName()), parametersAsString(argumentTypes, false), new String(type.enclosingType().readableName())}, | |
new String[] {new String(type.shortReadableName()), parametersAsString(argumentTypes, true), new String(type.enclosingType().shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void recursiveConstructorInvocation(ExplicitConstructorCall constructorCall) { | |
this.handle( | |
IProblem.RecursiveConstructorInvocation, | |
new String[] { | |
new String(constructorCall.binding.declaringClass.readableName()), | |
parametersAsString(constructorCall.binding.parameters, false) | |
}, | |
new String[] { | |
new String(constructorCall.binding.declaringClass.shortReadableName()), | |
parametersAsString(constructorCall.binding.parameters, true) | |
}, | |
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 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_DIGIT)) | |
flag = IProblem.InvalidDigit; | |
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 staticMemberOfParameterizedType(ASTNode location, ReferenceBinding type) { | |
if (location == null) { // binary case | |
this.handle( | |
IProblem.StaticMemberOfParameterizedType, | |
new String[] {new String(type.readableName()), new String(type.enclosingType().readableName()), }, | |
new String[] {new String(type.shortReadableName()), new String(type.enclosingType().shortReadableName()), }, | |
AbortCompilation | Error, | |
0, | |
1); | |
return; | |
} | |
this.handle( | |
IProblem.StaticMemberOfParameterizedType, | |
new String[] {new String(type.readableName()), new String(type.enclosingType().readableName()), }, | |
new String[] {new String(type.shortReadableName()), new String(type.enclosingType().shortReadableName()), }, | |
location.sourceStart, | |
location.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, TypeReference superInterfaceRef, 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())}, | |
superInterfaceRef.sourceStart, | |
superInterfaceRef.sourceEnd); | |
} | |
public void superinterfacesCollide(ReferenceBinding type, TypeDeclaration typeDecl, ReferenceBinding superType, ReferenceBinding inheritedSuperType) { | |
this.handle( | |
IProblem.SuperInterfacesCollide, | |
new String[] {new String(superType.readableName()), new String(inheritedSuperType.readableName()), new String(type.sourceName())}, | |
new String[] {new String(superType.shortReadableName()), new String(inheritedSuperType.shortReadableName()), new String(type.sourceName())}, | |
typeDecl.sourceStart, | |
typeDecl.sourceEnd); | |
} | |
public void superTypeCannotUseWildcard(SourceTypeBinding type, TypeReference superclass, TypeBinding superTypeBinding) { | |
String name = new String(type.sourceName()); | |
String superTypeFullName = new String(superTypeBinding.readableName()); | |
String superTypeShortName = new String(superTypeBinding.shortReadableName()); | |
if (superTypeShortName.equals(name)) superTypeShortName = superTypeFullName; | |
this.handle( | |
IProblem.SuperTypeUsingWildcard, | |
new String[] {superTypeFullName, name}, | |
new String[] {superTypeShortName, name}, | |
superclass.sourceStart, | |
superclass.sourceEnd); | |
} | |
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 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 actualType, TypeBinding expectedType, ASTNode location) { | |
this.handle( | |
IProblem.TypeMismatch, | |
new String[] {new String(actualType.readableName()), new String(expectedType.readableName())}, | |
new String[] {new String(actualType.shortReadableName()), new String(expectedType.shortReadableName())}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void typeMismatchError(TypeBinding typeArgument, TypeVariableBinding typeParameter, ReferenceBinding genericType, ASTNode location) { | |
if (location == null) { // binary case | |
this.handle( | |
IProblem.TypeArgumentMismatch, | |
new String[] { new String(typeArgument.readableName()), new String(genericType.readableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, false) }, | |
new String[] { new String(typeArgument.shortReadableName()), new String(genericType.shortReadableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, true) }, | |
AbortCompilation | Error, | |
0, | |
1); | |
return; | |
} | |
this.handle( | |
IProblem.TypeArgumentMismatch, | |
new String[] { new String(typeArgument.readableName()), new String(genericType.readableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, false) }, | |
new String[] { new String(typeArgument.shortReadableName()), new String(genericType.shortReadableName()), new String(typeParameter.sourceName), parameterBoundAsString(typeParameter, true) }, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void undefinedLabel(BranchStatement statement) { | |
String[] arguments = new String[] {new String(statement.label)}; | |
this.handle( | |
IProblem.UndefinedLabel, | |
arguments, | |
arguments, | |
statement.sourceStart, | |
statement.sourceEnd); | |
} | |
// can only occur inside binaries | |
public void undefinedTypeVariableSignature(char[] variableName, ReferenceBinding binaryType) { | |
this.handle( | |
IProblem.UndefinedTypeVariable, | |
new String[] {new String(variableName), new String(binaryType.readableName()) }, | |
new String[] {new String(variableName), new String(binaryType.shortReadableName())}, | |
AbortCompilation | Error, | |
0, | |
1); | |
} | |
public void undocumentedEmptyBlock(int blockStart, int blockEnd) { | |
this.handle( | |
IProblem.UndocumentedEmptyBlock, | |
NoArgument, | |
NoArgument, | |
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 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 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 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 unsafeCast(CastExpression castExpression) { | |
TypeBinding castedExpressionType = castExpression.expression.resolvedType; | |
this.handle( | |
IProblem.UnsafeGenericCast, | |
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 unsafeRawConversion(Expression expression, TypeBinding expressionType, TypeBinding expectedType) { | |
this.handle( | |
IProblem.UnsafeRawConversion, | |
new String[] { new String(expressionType.readableName()), new String(expectedType.readableName()), new String(expectedType.erasure().readableName()) }, | |
new String[] { new String(expressionType.shortReadableName()), new String(expectedType.shortReadableName()), new String(expectedType.erasure().shortReadableName()) }, | |
expression.sourceStart, | |
expression.sourceEnd); | |
} | |
public void unsafeRawFieldAssignment(FieldBinding rawField, TypeBinding expressionType, ASTNode location) { | |
this.handle( | |
IProblem.UnsafeRawFieldAssignment, | |
new String[] { | |
new String(expressionType.readableName()), new String(rawField.name), new String(rawField.declaringClass.readableName()), new String(rawField.declaringClass.erasure().readableName()) }, | |
new String[] { | |
new String(expressionType.shortReadableName()), new String(rawField.name), new String(rawField.declaringClass.shortReadableName()), new String(rawField.declaringClass.erasure().shortReadableName()) }, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void unsafeRawInvocation(ASTNode location, TypeBinding receiverType, MethodBinding method) { | |
if (method.isConstructor()) { | |
this.handle( | |
IProblem.UnsafeRawConstructorInvocation, | |
new String[] { | |
new String(receiverType.readableName()), | |
parametersAsString(method.original().parameters, false), | |
new String(receiverType.erasure().readableName()), | |
}, | |
new String[] { | |
new String(receiverType.shortReadableName()), | |
parametersAsString(method.original().parameters, true), | |
new String(receiverType.erasure().shortReadableName()), | |
}, | |
location.sourceStart, | |
location.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.UnsafeRawMethodInvocation, | |
new String[] { | |
new String(method.selector), | |
parametersAsString(method.original().parameters, false), | |
new String(receiverType.readableName()), | |
new String(receiverType.erasure().readableName()), | |
}, | |
new String[] { | |
new String(method.selector), | |
parametersAsString(method.original().parameters, true), | |
new String(receiverType.shortReadableName()), | |
new String(receiverType.erasure().shortReadableName()), | |
}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
} | |
public void unsafeReturnTypeOverride(MethodBinding currentMethod, MethodBinding inheritedMethod, ASTNode location) { | |
this.handle( | |
IProblem.UnsafeReturnTypeOverride, | |
new String[] { | |
new String(currentMethod.returnType.readableName()), | |
new String(currentMethod.selector), | |
parametersAsString(currentMethod.original().parameters, false), | |
new String(currentMethod.declaringClass.readableName()), | |
new String(inheritedMethod.returnType.readableName()), | |
//new String(inheritedMethod.returnType.erasure().readableName()), | |
}, | |
new String[] { | |
new String(currentMethod.returnType.shortReadableName()), | |
new String(currentMethod.selector), | |
parametersAsString(currentMethod.original().parameters, true), | |
new String(currentMethod.declaringClass.shortReadableName()), | |
new String(inheritedMethod.returnType.shortReadableName()), | |
//new String(inheritedMethod.returnType.erasure().shortReadableName()), | |
}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
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.parameters, false), | |
new String(exceptionType.readableName()), | |
}, | |
new String[] { | |
new String(method.binding.declaringClass.shortReadableName()), | |
parametersAsString(method.binding.parameters, true), | |
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.parameters, false), | |
new String(exceptionType.readableName()), | |
}, | |
new String[] { | |
new String(method.binding.declaringClass.shortReadableName()), | |
new String(method.selector), | |
parametersAsString(method.binding.parameters, true), | |
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.parameters, false) | |
}, | |
new String[] { | |
new String(constructor.declaringClass.shortReadableName()), | |
parametersAsString(constructor.parameters, true) | |
}, | |
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.parameters, false) | |
}, | |
new String[] { | |
new String(method.declaringClass.shortReadableName()), | |
new String(method.selector), | |
parametersAsString(method.parameters, true) | |
}, | |
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 useEnumAsAnIdentifier(int sourceStart, int sourceEnd) { | |
this.handle( | |
IProblem.UseEnumAsAnIdentifier, | |
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 wildcardAssignment(TypeBinding variableType, TypeBinding expressionType, ASTNode location) { | |
this.handle( | |
IProblem.WildcardFieldAssignment, | |
new String[] { | |
new String(expressionType.readableName()), new String(variableType.readableName()) }, | |
new String[] { | |
new String(expressionType.shortReadableName()), new String(variableType.shortReadableName()) }, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
public void wildcardInvocation(ASTNode location, TypeBinding receiverType, MethodBinding method, TypeBinding[] arguments) { | |
TypeBinding offendingArgument = null; | |
TypeBinding offendingParameter = null; | |
for (int i = 0, length = method.parameters.length; i < length; i++) { | |
TypeBinding parameter = method.parameters[i]; | |
if (parameter.isWildcard() && (((WildcardBinding) parameter).kind != Wildcard.SUPER)) { | |
offendingParameter = parameter; | |
offendingArgument = arguments[i]; | |
break; | |
} | |
} | |
if (method.isConstructor()) { | |
this.handle( | |
IProblem.WildcardConstructorInvocation, | |
new String[] { | |
new String(receiverType.sourceName()), | |
parametersAsString(method.parameters, false), | |
new String(receiverType.readableName()), | |
parametersAsString(arguments, false), | |
new String(offendingArgument.readableName()), | |
new String(offendingParameter.readableName()), | |
}, | |
new String[] { | |
new String(receiverType.sourceName()), | |
parametersAsString(method.parameters, true), | |
new String(receiverType.shortReadableName()), | |
parametersAsString(arguments, true), | |
new String(offendingArgument.shortReadableName()), | |
new String(offendingParameter.shortReadableName()), | |
}, | |
location.sourceStart, | |
location.sourceEnd); | |
} else { | |
this.handle( | |
IProblem.WildcardMethodInvocation, | |
new String[] { | |
new String(method.selector), | |
parametersAsString(method.parameters, false), | |
new String(receiverType.readableName()), | |
parametersAsString(arguments, false), | |
new String(offendingArgument.readableName()), | |
new String(offendingParameter.readableName()), | |
}, | |
new String[] { | |
new String(method.selector), | |
parametersAsString(method.parameters, true), | |
new String(receiverType.shortReadableName()), | |
parametersAsString(arguments, true), | |
new String(offendingArgument.shortReadableName()), | |
new String(offendingParameter.shortReadableName()), | |
}, | |
location.sourceStart, | |
location.sourceEnd); | |
} | |
} | |
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); | |
} | |
} |