X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/problem/ProblemReporter.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/problem/ProblemReporter.java index 1d4f0bf..5bdab62 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/problem/ProblemReporter.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/problem/ProblemReporter.java @@ -1,43 +1,105 @@ /******************************************************************************* - * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others. + * Copyright (c) 2000, 2003 IBM Corporation and others. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Common Public License v0.5 + * 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-v05.html + * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: * IBM Corporation - initial API and implementation - ******************************************************************************/ + *******************************************************************************/ package net.sourceforge.phpdt.internal.compiler.problem; +import net.sourceforge.phpdt.core.compiler.CharOperation; import net.sourceforge.phpdt.core.compiler.IProblem; -import net.sourceforge.phpdt.core.compiler.ITerminalSymbols; import net.sourceforge.phpdt.core.compiler.InvalidInputException; -import net.sourceforge.phpdt.internal.compiler.*; -import net.sourceforge.phpdt.internal.compiler.ast.*; -import net.sourceforge.phpdt.internal.compiler.lookup.*; -import net.sourceforge.phpdt.internal.compiler.parser.*; -import net.sourceforge.phpdt.internal.compiler.util.*; -import net.sourceforge.phpdt.internal.compiler.impl.*; +import net.sourceforge.phpdt.internal.compiler.CompilationResult; +import net.sourceforge.phpdt.internal.compiler.IErrorHandlingPolicy; +import net.sourceforge.phpdt.internal.compiler.IProblemFactory; +import net.sourceforge.phpdt.internal.compiler.impl.Constant; +import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext; +import net.sourceforge.phpdt.internal.compiler.lookup.Binding; +import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers; +import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.ProblemMethodBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReasons; +import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReferenceBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticArgumentBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding; +import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants; +import net.sourceforge.phpdt.internal.compiler.parser.Parser; +import net.sourceforge.phpdt.internal.compiler.parser.Scanner; +import net.sourceforge.phpdt.internal.compiler.util.Util; +import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractVariableDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.AllocationExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.Argument; +import net.sourceforge.phpeclipse.internal.compiler.ast.ArrayAllocationExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.ArrayReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.Assignment; +import net.sourceforge.phpeclipse.internal.compiler.ast.AstNode; +import net.sourceforge.phpeclipse.internal.compiler.ast.BinaryExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.BranchStatement; +import net.sourceforge.phpeclipse.internal.compiler.ast.Case; +import net.sourceforge.phpeclipse.internal.compiler.ast.CastExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.CompoundAssignment; +import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.DefaultCase; +import net.sourceforge.phpeclipse.internal.compiler.ast.EqualExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.ExplicitConstructorCall; +import net.sourceforge.phpeclipse.internal.compiler.ast.Expression; +import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.FieldReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.ImportReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.InstanceOfExpression; +import net.sourceforge.phpeclipse.internal.compiler.ast.IntLiteral; +import net.sourceforge.phpeclipse.internal.compiler.ast.Literal; +import net.sourceforge.phpeclipse.internal.compiler.ast.LocalDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.LongLiteral; +import net.sourceforge.phpeclipse.internal.compiler.ast.MessageSend; +import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.NameReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.NumberLiteral; +import net.sourceforge.phpeclipse.internal.compiler.ast.QualifiedNameReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.Reference; +import net.sourceforge.phpeclipse.internal.compiler.ast.ReturnStatement; +import net.sourceforge.phpeclipse.internal.compiler.ast.SingleNameReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.Statement; +import net.sourceforge.phpeclipse.internal.compiler.ast.ThisReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.ThrowStatement; +import net.sourceforge.phpeclipse.internal.compiler.ast.TryStatement; +import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration; +import net.sourceforge.phpeclipse.internal.compiler.ast.TypeReference; +import net.sourceforge.phpeclipse.internal.compiler.ast.UnaryExpression; public class ProblemReporter extends ProblemHandler implements ProblemReasons { public ReferenceContext referenceContext; -public ProblemReporter(IErrorHandlingPolicy policy, CompilerOptions options, IProblemFactory problemFactory) { - super(policy, options, problemFactory); +public ProblemReporter(IErrorHandlingPolicy policy, IProblemFactory problemFactory) { +//CompilerOptions options, IProblemFactory problemFactory) { + super(policy, problemFactory);//options, problemFactory); } public void abortDueToInternalError(String errorMessage) { + String[] arguments = new String[] {errorMessage}; this.handle( IProblem.Unclassified, - new String[] {errorMessage}, + arguments, + arguments, Error | Abort, 0, 0); } public void abortDueToInternalError(String errorMessage, AstNode location) { + String[] arguments = new String[] {errorMessage}; this.handle( IProblem.Unclassified, - new String[] {errorMessage}, + arguments, + arguments, Error | Abort, location.sourceStart, location.sourceEnd); @@ -47,14 +109,30 @@ public void abstractMethodCannotBeOverridden(SourceTypeBinding type, MethodBindi 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(concreteMethod.readableName())}, + 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, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } @@ -69,43 +147,57 @@ public void abstractMethodMustBeImplemented(SourceTypeBinding type, MethodBindin 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, - new String[0], + 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, - new String[] {new String(labelName)}, - location.sourceStart, + arguments, + arguments, + location.sourceStart, location.sourceEnd); } public void anonymousClassCannotExtendFinalClass(Expression expression, TypeBinding type) { this.handle( IProblem.AnonymousClassCannotExtendFinalClass, new String[] {new String(type.readableName())}, + new String[] {new String(type.shortReadableName())}, expression.sourceStart, expression.sourceEnd); } public void argumentTypeCannotBeVoid(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, Argument arg) { + String[] arguments = new String[] {new String(methodDecl.selector), new String(arg.name)}; this.handle( IProblem.ArgumentTypeCannotBeVoid, - new String[] {new String(methodDecl.selector), new String(arg.name)}, + 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, - new String[] {new String(methodDecl.selector), new String(arg.name)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } @@ -136,42 +228,68 @@ public void argumentTypeProblem(SourceTypeBinding type, AbstractMethodDeclaratio this.handle( id, new String[] {new String(methodDecl.selector), arg.name(), new String(expectedType.readableName())}, + new String[] {new String(methodDecl.selector), arg.name(), new String(expectedType.shortReadableName())}, arg.type.sourceStart, arg.type.sourceEnd); } public void arrayConstantsOnlyInArrayInitializers(int sourceStart, int sourceEnd) { this.handle( IProblem.ArrayConstantsOnlyInArrayInitializers, - new String[0], + 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, - new String[] {}, + NoArgument, + NoArgument, returnStatement.sourceStart, returnStatement.sourceEnd); } -public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location) { - this.handle( - IProblem.BytecodeExceeds64KLimit, - new String[] {new String(location.selector)}, - Error | Abort, - location.sourceStart, - location.sourceEnd); -} +//public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location) { +// String[] arguments = new String[] {new String(location.selector), parametersAsString(location.binding)}; +// if (location.isConstructor()) { +// this.handle( +// IProblem.BytecodeExceeds64KLimitForConstructor, +// arguments, +// arguments, +// Error | Abort, +// location.sourceStart, +// location.sourceEnd); +// } else { +// this.handle( +// IProblem.BytecodeExceeds64KLimit, +// arguments, +// arguments, +// Error | Abort, +// location.sourceStart, +// location.sourceEnd); +// } +//} public void bytecodeExceeds64KLimit(TypeDeclaration location) { this.handle( IProblem.BytecodeExceeds64KLimitForClinit, - new String[0], + NoArgument, + NoArgument, Error | Abort, location.sourceStart, location.sourceEnd); @@ -179,7 +297,8 @@ public void bytecodeExceeds64KLimit(TypeDeclaration location) { public void cannotAllocateVoidArray(Expression expression) { this.handle( IProblem.CannotAllocateVoidArray, - new String[] {}, + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } @@ -189,27 +308,44 @@ public void cannotAssignToFinalField(FieldBinding field, AstNode location) { 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, - new String[] {new String(local.readableName())}, + 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, - new String[] {new String(interfaceName)}, + arguments, + arguments, sourceStart, sourceEnd); } public void cannotDefineDimensionsAndInitializer(ArrayAllocationExpression expresssion) { this.handle( IProblem.CannotDefineDimensionExpressionsWithInit, - new String[0], + NoArgument, + NoArgument, expresssion.sourceStart, expresssion.sourceEnd); } @@ -217,13 +353,16 @@ public void cannotDireclyInvokeAbstractMethod(MessageSend messageSend, MethodBin this.handle( IProblem.DirectInvocationOfAbstractMethod, new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)}, + new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)}, messageSend.sourceStart, messageSend.sourceEnd); } public void cannotImportPackage(ImportReference importRef) { + String[] arguments = new String[] {CharOperation.toString(importRef.tokens)}; this.handle( IProblem.CannotImportPackage, - new String[] {CharOperation.toString(importRef.tokens)}, + arguments, + arguments, importRef.sourceStart, importRef.sourceEnd); } @@ -231,27 +370,32 @@ 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, - new String[] {new String(local.readableName())}, + arguments, + arguments, location.sourceStart, location.sourceEnd); } public void cannotReturnInInitializer(AstNode location) { this.handle( IProblem.CannotReturnInInitializer, - new String[0], + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } public void cannotThrowNull(ThrowStatement statement) { this.handle( IProblem.CannotThrowNull, - new String[0], + NoArgument, + NoArgument, statement.sourceStart, statement.sourceEnd); } @@ -259,20 +403,23 @@ public void cannotThrowType(SourceTypeBinding type, AbstractMethodDeclaration me this.handle( IProblem.CannotThrowType, new String[] {new String(expectedType.readableName())}, + new String[] {new String(expectedType.shortReadableName())}, exceptionType.sourceStart, exceptionType.sourceEnd); } public void cannotUseSuperInJavaLangObject(AstNode reference) { this.handle( IProblem.ObjectHasNoSuperclass, - new String[0], + NoArgument, + NoArgument, reference.sourceStart, reference.sourceEnd); } public void cannotUseSuperInCodeSnippet(int start, int end) { this.handle( IProblem.CannotUseSuperInCodeSnippet, - new String[0], + NoArgument, + NoArgument, Error | Abort, start, end); @@ -280,29 +427,39 @@ public void cannotUseSuperInCodeSnippet(int start, int end) { public void caseExpressionMustBeConstant(Expression expression) { this.handle( IProblem.NonConstantExpression, - new String[0], + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } public void classExtendFinalClass(SourceTypeBinding type, TypeReference superclass, TypeBinding expectedType) { + String name = new String(type.sourceName()); + String expectedFullName = new String(expectedType.readableName()); + String expectedShortName = new String(expectedType.shortReadableName()); + if (expectedShortName.equals(name)) expectedShortName = expectedFullName; this.handle( IProblem.ClassExtendFinalClass, - new String[] {new String(expectedType.readableName()), new String(type.sourceName())}, + new String[] {expectedFullName, name}, + new String[] {expectedShortName, name}, superclass.sourceStart, superclass.sourceEnd); } public void codeSnippetMissingClass(String missing, int start, int end) { + String[] arguments = new String[]{missing}; this.handle( IProblem.CodeSnippetMissingClass, - new String[]{ missing }, + 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, - new String[]{ className, missingMethod, argumentTypes }, + arguments, + arguments, Error | Abort, start, end); @@ -312,188 +469,222 @@ public void codeSnippetMissingMethod(String className, String missingMethod, Str * 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; +//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 +// int errorThreshold = options.errorThreshold; +// int warningThreshold = options.warningThreshold; +// +// switch(problemId){ +// +// case IProblem.UnreachableCatch : +// case IProblem.CodeCannotBeReached : +// if ((errorThreshold & CompilerOptions.UnreachableCode) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.UnreachableCode) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.MaskedCatch : +// if ((errorThreshold & CompilerOptions.MaskedCatchBlock) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.MaskedCatchBlock) != 0){ +// return Warning; +// } +// return Ignore; +// +///* +// case Never Used : +// if ((errorThreshold & ParsingOptionalError) != 0){ +// return Error; +// } +// if ((warningThreshold & ParsingOptionalError) != 0){ +// return Warning; +// } +// return Ignore; +//*/ +// case IProblem.ImportNotFound : +// case IProblem.ImportNotVisible : +// case IProblem.ImportAmbiguous : +// case IProblem.ImportInternalNameProvided : +// case IProblem.ImportInheritedNameHidesEnclosingName : +// case IProblem.DuplicateImport : +// case IProblem.ConflictingImport : +// case IProblem.CannotImportPackage : +// if ((errorThreshold & CompilerOptions.ImportProblem) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.ImportProblem) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.UnusedImport : +// // if import problem are disabled, then ignore +// if ((errorThreshold & CompilerOptions.ImportProblem) == 0 +// && (warningThreshold & CompilerOptions.ImportProblem) == 0){ +// return Ignore; +// } +// if ((errorThreshold & CompilerOptions.UnusedImport) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.UnusedImport) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.MethodButWithConstructorName : +// if ((errorThreshold & CompilerOptions.MethodWithConstructorName) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.MethodWithConstructorName) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.OverridingNonVisibleMethod : +// if ((errorThreshold & CompilerOptions.OverriddenPackageDefaultMethod) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.OverriddenPackageDefaultMethod) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod : +// case IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod : +// if ((errorThreshold & CompilerOptions.IncompatibleNonInheritedInterfaceMethod) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.IncompatibleNonInheritedInterfaceMethod) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.OverridingDeprecatedMethod : +// case IProblem.UsingDeprecatedType : +// case IProblem.UsingDeprecatedMethod : +// case IProblem.UsingDeprecatedConstructor : +// case IProblem.UsingDeprecatedField : +// if ((errorThreshold & CompilerOptions.UsingDeprecatedAPI) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.UsingDeprecatedAPI) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.LocalVariableIsNeverUsed : +// if ((errorThreshold & CompilerOptions.UnusedLocalVariable) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.UnusedLocalVariable) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.ArgumentIsNeverUsed : +// if ((errorThreshold & CompilerOptions.UnusedArgument) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.UnusedArgument) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.NoImplicitStringConversionForCharArrayExpression : +// if ((errorThreshold & CompilerOptions.NoImplicitStringConversion) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.NoImplicitStringConversion) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.NeedToEmulateFieldReadAccess : +// case IProblem.NeedToEmulateFieldWriteAccess : +// case IProblem.NeedToEmulateMethodAccess : +// case IProblem.NeedToEmulateConstructorAccess : +// if ((errorThreshold & CompilerOptions.AccessEmulation) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.AccessEmulation) != 0){ +// return Warning; +// } +// return Ignore; +// case IProblem.NonExternalizedStringLiteral : +// if ((errorThreshold & CompilerOptions.NonExternalizedString) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.NonExternalizedString) != 0){ +// return Warning; +// } +// return Ignore; +// case IProblem.UseAssertAsAnIdentifier : +// if ((errorThreshold & CompilerOptions.AssertUsedAsAnIdentifier) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.AssertUsedAsAnIdentifier) != 0){ +// return Warning; +// } +// return Ignore; +// case IProblem.NonStaticAccessToStaticMethod : +// case IProblem.NonStaticAccessToStaticField : +// if ((errorThreshold & CompilerOptions.StaticAccessReceiver) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.StaticAccessReceiver) != 0){ +// return Warning; +// } +// return Ignore; +// case IProblem.AssignmentHasNoEffect: +// if ((errorThreshold & CompilerOptions.NoEffectAssignment) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.NoEffectAssignment) != 0){ +// return Warning; +// } +// return Ignore; +// case IProblem.UnusedPrivateConstructor: +// case IProblem.UnusedPrivateMethod: +// case IProblem.UnusedPrivateField: +// case IProblem.UnusedPrivateType: +// if ((errorThreshold & CompilerOptions.UnusedPrivateMember) != 0){ +// return Error; +// } +// if ((warningThreshold & CompilerOptions.UnusedPrivateMember) != 0){ +// return Warning; +// } +// return Ignore; +// +// case IProblem.Task : +// return Warning; +// default: +// return Error; // } - - // if not then check whether it is a configurable problem - int errorThreshold = options.errorThreshold; - int warningThreshold = options.warningThreshold; - - switch(problemId){ - - case IProblem.UnreachableCatch : - case IProblem.CodeCannotBeReached : - if ((errorThreshold & CompilerOptions.UnreachableCode) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.UnreachableCode) != 0){ - return Warning; - } - return Ignore; - - case IProblem.MaskedCatch : - if ((errorThreshold & CompilerOptions.MaskedCatchBlock) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.MaskedCatchBlock) != 0){ - return Warning; - } - return Ignore; - -/* - case Never Used : - if ((errorThreshold & ParsingOptionalError) != 0){ - return Error; - } - if ((warningThreshold & ParsingOptionalError) != 0){ - return Warning; - } - return Ignore; -*/ - case IProblem.ImportNotFound : - case IProblem.ImportNotVisible : - case IProblem.ImportAmbiguous : - case IProblem.ImportInternalNameProvided : - case IProblem.ImportInheritedNameHidesEnclosingName : - case IProblem.DuplicateImport : - case IProblem.ConflictingImport : - case IProblem.CannotImportPackage : - if ((errorThreshold & CompilerOptions.ImportProblem) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.ImportProblem) != 0){ - return Warning; - } - return Ignore; - - case IProblem.UnusedImport : - // if import problem are disabled, then ignore - if ((errorThreshold & CompilerOptions.ImportProblem) == 0 - && (warningThreshold & CompilerOptions.ImportProblem) == 0){ - return Ignore; - } - if ((errorThreshold & CompilerOptions.UnusedImport) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.UnusedImport) != 0){ - return Warning; - } - return Ignore; - -/* - case UnnecessaryEnclosingInstanceSpecification : - if ((errorThreshold & UnnecessaryEnclosingInstance) != 0){ - return Error; - } - if ((warningThreshold & UnnecessaryEnclosingInstance) != 0){ - return Warning; - } - return Ignore; -*/ - case IProblem.MethodButWithConstructorName : - if ((errorThreshold & CompilerOptions.MethodWithConstructorName) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.MethodWithConstructorName) != 0){ - return Warning; - } - return Ignore; - - case IProblem.OverridingNonVisibleMethod : - if ((errorThreshold & CompilerOptions.OverriddenPackageDefaultMethod) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.OverriddenPackageDefaultMethod) != 0){ - return Warning; - } - return Ignore; - - case IProblem.OverridingDeprecatedMethod : - case IProblem.UsingDeprecatedType : - case IProblem.UsingDeprecatedMethod : - case IProblem.UsingDeprecatedConstructor : - case IProblem.UsingDeprecatedField : - if ((errorThreshold & CompilerOptions.UsingDeprecatedAPI) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.UsingDeprecatedAPI) != 0){ - return Warning; - } - return Ignore; - - case IProblem.LocalVariableIsNeverUsed : - if ((errorThreshold & CompilerOptions.UnusedLocalVariable) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.UnusedLocalVariable) != 0){ - return Warning; - } - return Ignore; - - case IProblem.ArgumentIsNeverUsed : - if ((errorThreshold & CompilerOptions.UnusedArgument) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.UnusedArgument) != 0){ - return Warning; - } - return Ignore; - - case IProblem.NoImplicitStringConversionForCharArrayExpression : - if ((errorThreshold & CompilerOptions.NoImplicitStringConversion) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.NoImplicitStringConversion) != 0){ - return Warning; - } - return Ignore; - - case IProblem.NeedToEmulateFieldReadAccess : - case IProblem.NeedToEmulateFieldWriteAccess : - case IProblem.NeedToEmulateMethodAccess : - case IProblem.NeedToEmulateConstructorAccess : - if ((errorThreshold & CompilerOptions.AccessEmulation) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.AccessEmulation) != 0){ - return Warning; - } - return Ignore; - case IProblem.NonExternalizedStringLiteral : - if ((errorThreshold & CompilerOptions.NonExternalizedString) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.NonExternalizedString) != 0){ - return Warning; - } - return Ignore; - case IProblem.UseAssertAsAnIdentifier : - if ((errorThreshold & CompilerOptions.AssertUsedAsAnIdentifier) != 0){ - return Error; - } - if ((warningThreshold & CompilerOptions.AssertUsedAsAnIdentifier) != 0){ - return Warning; - } - return Ignore; - 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())}, - expression.sourceStart, - expression.sourceEnd); -} +//} +//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, - new String[] {CharOperation.toString(importRef.tokens)}, + arguments, + arguments, importRef.sourceStart, importRef.sourceEnd); } @@ -522,10 +713,12 @@ public void constantOutOfFormat(NumberLiteral lit) { break label; } } + String[] arguments = new String[] {Radix + " " + new String(source) + " (digit " + new String(new char[] {source[place]}) + ")"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ this.handle( IProblem.NumericValueOutOfRange, - new String[] {Radix + " " + new String(source) + " (digit " + new String(new char[] {source[place]}) + ")"}, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + arguments, + arguments, lit.sourceStart, lit.sourceEnd); return; @@ -539,10 +732,11 @@ public void constantOutOfFormat(NumberLiteral lit) { public void constantOutOfRange(Literal lit) { // lit is some how out of range of it declared type // example 9999999999999999999999999999999999999999999999999999999999999999999 - + String[] arguments = new String[] {new String(lit.source())}; this.handle( IProblem.NumericValueOutOfRange, - new String[] {new String(lit.source())}, + arguments, + arguments, lit.sourceStart, lit.sourceEnd); } @@ -550,6 +744,7 @@ 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); } @@ -558,12 +753,14 @@ public void deprecatedMethod(MethodBinding method, AstNode location) { this.handle( IProblem.UsingDeprecatedConstructor, new String[] {new String(method.declaringClass.readableName()), parametersAsString(method)}, + new String[] {new String(method.declaringClass.shortReadableName()), parametersAsShortString(method)}, location.sourceStart, location.sourceEnd); else this.handle( IProblem.UsingDeprecatedMethod, new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)}, + new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)}, location.sourceStart, location.sourceEnd); } @@ -572,20 +769,24 @@ public void deprecatedType(TypeBinding type, AstNode location) { this.handle( IProblem.UsingDeprecatedType, new String[] {new String(type.readableName())}, + new String[] {new String(type.shortReadableName())}, location.sourceStart, location.sourceEnd); } public void duplicateCase(Case statement, Constant constant) { + String[] arguments = new String[] {String.valueOf(constant.intValue())}; this.handle( IProblem.DuplicateCase, - new String[] {String.valueOf(constant.intValue())}, + arguments, + arguments, statement.sourceStart, statement.sourceEnd); } public void duplicateDefaultCase(DefaultCase statement) { this.handle( IProblem.DuplicateDefaultCase, - new String[0], + NoArgument, + NoArgument, statement.sourceStart, statement.sourceEnd); } @@ -593,34 +794,43 @@ public void duplicateFieldInType(SourceTypeBinding type, FieldDeclaration fieldD this.handle( IProblem.DuplicateField, new String[] {new String(type.sourceName()), fieldDecl.name()}, + new String[] {new String(type.shortReadableName()), fieldDecl.name()}, fieldDecl.sourceStart, fieldDecl.sourceEnd); } public void duplicateImport(ImportReference importRef) { + String[] arguments = new String[] {CharOperation.toString(importRef.tokens)}; this.handle( IProblem.DuplicateImport, - new String[] {CharOperation.toString(importRef.tokens)}, + 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, - new String[] {new String(field.readableName())}, + arguments, + arguments, reference.sourceStart, reference.sourceEnd); } -public void duplicateInitializationOfFinalLocal(LocalVariableBinding local, NameReference reference) { +public void duplicateInitializationOfFinalLocal(LocalVariableBinding local, AstNode location) { + String[] arguments = new String[] { new String(local.readableName())}; this.handle( IProblem.DuplicateFinalLocalInitialization, - new String[] {new String(local.readableName())}, - reference.sourceStart, - reference.sourceEnd); + arguments, + arguments, + location.sourceStart, + location.sourceEnd); } public void duplicateMethodInType(SourceTypeBinding type, AbstractMethodDeclaration methodDecl) { + String[] arguments = new String[] {new String(methodDecl.selector), new String(type.sourceName())}; this.handle( IProblem.DuplicateMethod, - new String[] {new String(methodDecl.selector), new String(type.sourceName())}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } @@ -633,10 +843,11 @@ public void duplicateModifierForField(ReferenceBinding type, FieldDeclaration fi fieldDecl.modifiers.sourceStart, fieldDecl.modifiers.sourceEnd)); */ - + String[] arguments = new String[] {fieldDecl.name()}; this.handle( IProblem.DuplicateModifierForField, - new String[] {fieldDecl.name()}, + arguments, + arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } @@ -644,29 +855,36 @@ public void duplicateModifierForMethod(ReferenceBinding type, AbstractMethodDecl 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, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void duplicateModifierForVariable(LocalDeclaration localDecl, boolean complainForArgument) { + String[] arguments = new String[] {localDecl.name()}; this.handle( complainForArgument - ? IProblem.DuplicateModifierForArgument + ? IProblem.DuplicateModifierForArgument : IProblem.DuplicateModifierForVariable, - new String[] {localDecl.name()}, + arguments, + arguments, localDecl.sourceStart, localDecl.sourceEnd); } public void duplicateNestedType(TypeDeclaration typeDecl) { + String[] arguments = new String[] {new String(typeDecl.name)}; this.handle( IProblem.DuplicateNestedType, - new String[] {new String(typeDecl.name)}, + arguments, + arguments, typeDecl.sourceStart, typeDecl.sourceEnd); } @@ -676,36 +894,48 @@ public void duplicateSuperinterface(SourceTypeBinding type, TypeDeclaration type new String[] { new String(superType.readableName()), new String(type.sourceName())}, + new String[] { + new String(superType.shortReadableName()), + new String(type.sourceName())}, typeDecl.sourceStart, typeDecl.sourceEnd); } public void duplicateTypes(CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) { + String[] arguments = new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)}; this.referenceContext = typeDecl; // report the problem against the type not the entire compilation unit this.handle( IProblem.DuplicateTypes, - new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)}, + arguments, + arguments, typeDecl.sourceStart, typeDecl.sourceEnd, compUnitDecl.compilationResult); } 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) + 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())); } this.handle( recType.isArrayType() ? IProblem.NoMessageSendOnArrayType : IProblem.NoMessageSendOnBaseType, 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, - new String[] {reference.isSuper() ? "super" : "this"}, //$NON-NLS-2$ //$NON-NLS-1$ + arguments, + arguments, reference.sourceStart, reference.sourceEnd); } @@ -736,13 +966,23 @@ public void exceptionTypeProblem(SourceTypeBinding type, AbstractMethodDeclarati this.handle( id, new String[] {new String(methodDecl.selector), new String(expectedType.readableName())}, + new String[] {new String(methodDecl.selector), new String(expectedType.shortReadableName())}, exceptionType.sourceStart, exceptionType.sourceEnd); } +public void expressionShouldBeAVariable(Expression expression) { + this.handle( + IProblem.ExpressionShouldBeAVariable, + NoArgument, + NoArgument, + expression.sourceStart, + expression.sourceEnd); +} public void fieldsOrThisBeforeConstructorInvocation(ThisReference reference) { this.handle( IProblem.ThisSuperDuringConstructorInvocation, - new String[0], + NoArgument, + NoArgument, reference.sourceStart, reference.sourceEnd); } @@ -773,6 +1013,7 @@ public void fieldTypeProblem(SourceTypeBinding type, FieldDeclaration fieldDecl, this.handle( id, new String[] {fieldDecl.name(), new String(type.sourceName()), new String(expectedType.readableName())}, + new String[] {fieldDecl.name(), new String(type.sourceName()), new String(expectedType.shortReadableName())}, fieldDecl.type.sourceStart, fieldDecl.type.sourceEnd); } @@ -782,13 +1023,15 @@ public void finalMethodCannotBeOverridden(MethodBinding currentMethod, MethodBin // 8.4.3.3 - Final methods cannot be overridden or hidden. IProblem.FinalMethodCannotBeOverridden, new String[] {new String(inheritedMethod.declaringClass.readableName())}, + new String[] {new String(inheritedMethod.declaringClass.shortReadableName())}, currentMethod.sourceStart(), currentMethod.sourceEnd()); } public void forwardReference(Reference reference, int indexInQualification, TypeBinding type) { this.handle( IProblem.ReferenceToForwardField, - new String[] {}, + NoArgument, + NoArgument, reference.sourceStart, reference.sourceEnd); } @@ -799,12 +1042,14 @@ public void forwardReference(Reference reference, int indexInQualification, Type private void handle( int problemId, String[] problemArguments, + String[] messageArguments, int problemStartPosition, int problemEndPosition){ this.handle( problemId, problemArguments, + messageArguments, problemStartPosition, problemEndPosition, referenceContext, @@ -818,6 +1063,7 @@ private void handle( private void handle( int problemId, String[] problemArguments, + String[] messageArguments, int severity, int problemStartPosition, int problemEndPosition){ @@ -825,6 +1071,7 @@ private void handle( this.handle( problemId, problemArguments, + messageArguments, severity, problemStartPosition, problemEndPosition, @@ -838,6 +1085,7 @@ private void handle( private void handle( int problemId, String[] problemArguments, + String[] messageArguments, int problemStartPosition, int problemEndPosition, CompilationResult unitResult){ @@ -845,6 +1093,7 @@ private void handle( this.handle( problemId, problemArguments, + messageArguments, problemStartPosition, problemEndPosition, referenceContext, @@ -852,9 +1101,11 @@ private void handle( referenceContext = null; } public void hidingEnclosingType(TypeDeclaration typeDecl) { + String[] arguments = new String[] {new String(typeDecl.name)}; this.handle( IProblem.HidingEnclosingType, - new String[] {new String(typeDecl.name)}, + arguments, + arguments, typeDecl.sourceStart, typeDecl.sourceEnd); } @@ -862,128 +1113,163 @@ public void hierarchyCircularity(SourceTypeBinding sourceType, ReferenceBinding int start = 0; int end = 0; String typeName = ""; //$NON-NLS-1$ + String shortTypeName = ""; //$NON-NLS-1$ if (reference == null) { // can only happen when java.lang.Object is busted start = sourceType.sourceStart(); end = sourceType.sourceEnd(); typeName = new String(superType.readableName()); + shortTypeName = new String(superType.sourceName()); } else { start = reference.sourceStart; end = reference.sourceEnd; - typeName = CharOperation.toString(reference.getTypeName()); + char[][] qName = reference.getTypeName(); + typeName = CharOperation.toString(qName); + shortTypeName = new String(qName[qName.length-1]); } if (sourceType == superType) this.handle( IProblem.HierarchyCircularitySelfReference, new String[] {new String(sourceType.sourceName()), typeName}, + new String[] {new String(sourceType.sourceName()), shortTypeName}, start, end); else this.handle( IProblem.HierarchyCircularity, new String[] {new String(sourceType.sourceName()), typeName}, + new String[] {new String(sourceType.sourceName()), shortTypeName}, start, end); } public void hierarchyHasProblems(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.HierarchyHasProblems, - new String[] {new String(type.sourceName())}, + 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, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } public void illegalModifierCombinationFinalAbstractForClass(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalModifierCombinationFinalAbstractForClass, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalModifierCombinationFinalVolatileForField(ReferenceBinding type, FieldDeclaration fieldDecl) { + String[] arguments = new String[] {fieldDecl.name()}; + this.handle( IProblem.IllegalModifierCombinationFinalVolatileForField, - new String[] {fieldDecl.name()}, + arguments, + arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } public void illegalModifierForClass(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalModifierForClass, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalModifierForField(ReferenceBinding type, FieldDeclaration fieldDecl) { + String[] arguments = new String[] {fieldDecl.name()}; this.handle( IProblem.IllegalModifierForField, - new String[] {fieldDecl.name()}, + arguments, + arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } public void illegalModifierForInterface(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalModifierForInterface, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalModifierForInterfaceField(ReferenceBinding type, FieldDeclaration fieldDecl) { + String[] arguments = new String[] {fieldDecl.name()}; this.handle( IProblem.IllegalModifierForInterfaceField, - new String[] {fieldDecl.name()}, + 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, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } public void illegalModifierForLocalClass(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalModifierForLocalClass, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalModifierForMemberClass(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalModifierForMemberClass, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalModifierForMemberInterface(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalModifierForMemberInterface, - new String[] {new String(type.sourceName())}, + 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, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } public void illegalModifierForVariable(LocalDeclaration localDecl, boolean complainAsArgument) { + String[] arguments = new String[] {localDecl.name()}; this.handle( complainAsArgument ? IProblem.IllegalModifierForArgument : IProblem.IllegalModifierForVariable, - new String[] {localDecl.name()}, + arguments, + arguments, localDecl.sourceStart, localDecl.sourceEnd); } @@ -991,48 +1277,60 @@ public void illegalPrimitiveOrArrayTypeForEnclosingInstance(TypeBinding enclosin 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, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalVisibilityModifierCombinationForField(ReferenceBinding type, FieldDeclaration fieldDecl) { + String[] arguments = new String[] {new String(fieldDecl.name())}; this.handle( IProblem.IllegalVisibilityModifierCombinationForField, - new String[] {new String(fieldDecl.name())}, + arguments, + arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } public void illegalVisibilityModifierCombinationForMemberType(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalVisibilityModifierCombinationForMemberType, - new String[] {new String(type.sourceName())}, + 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, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } public void illegalVisibilityModifierForInterfaceMemberType(SourceTypeBinding type) { + String[] arguments = new String[] {new String(type.sourceName())}; this.handle( IProblem.IllegalVisibilityModifierForInterfaceMemberType, - new String[] {new String(type.sourceName())}, + arguments, + arguments, type.sourceStart(), type.sourceEnd()); } public void illegalVoidExpression(AstNode location) { this.handle( IProblem.InvalidVoidExpression, - new String[] {}, + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } @@ -1066,14 +1364,22 @@ public void importProblem(ImportReference importRef, Binding expectedImport) { } else { argument = CharOperation.toString(importRef.tokens); } - this.handle(id, new String[] {argument}, importRef.sourceStart, importRef.sourceEnd); + String[] arguments = new String[]{argument}; + this.handle(id, arguments, arguments, importRef.sourceStart, importRef.sourceEnd); } public void incompatibleExceptionInThrowsClause(SourceTypeBinding type, MethodBinding currentMethod, MethodBinding inheritedMethod, ReferenceBinding exceptionType) { - if (type == currentMethod.declaringClass) + 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. - IProblem.IncompatibleExceptionInThrowsClause, + id, new String[] { new String(exceptionType.sourceName()), new String( @@ -1081,9 +1387,16 @@ public void incompatibleExceptionInThrowsClause(SourceTypeBinding type, MethodBi 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 + } 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. @@ -1100,6 +1413,18 @@ public void incompatibleExceptionInThrowsClause(SourceTypeBinding type, MethodBi 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()); } @@ -1110,28 +1435,31 @@ public void incompatibleReturnType(MethodBinding currentMethod, MethodBinding in .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( - // Return type is incompatible with %1 - // 9.4.2 - The return type from the method is incompatible with the declaration. - IProblem.IncompatibleReturnType, + id, new String[] {methodSignature.toString()}, + new String[] {shortSignature.toString()}, currentMethod.sourceStart(), currentMethod.sourceEnd()); } -public void incorrectEnclosingInstanceReference( - QualifiedThisReference reference, - TypeBinding qualificationType) { - - this.handle( - IProblem.IncorrectEnclosingInstanceReference, - new String[] { new String(qualificationType.readableName())}, - reference.sourceStart, - reference.sourceEnd); -} public void incorrectLocationForEmptyDimension(ArrayAllocationExpression expression, int index) { this.handle( IProblem.IllegalDimension, - new String[0], + NoArgument, + NoArgument, expression.dimensions[index + 1].sourceStart, expression.dimensions[index + 1].sourceEnd); } @@ -1139,6 +1467,7 @@ 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); } @@ -1148,24 +1477,39 @@ public void inheritedMethodReducesVisibility(SourceTypeBinding type, MethodBindi .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[] { 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()); - if (i != 0) + 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( @@ -1173,13 +1517,15 @@ public void inheritedMethodsHaveIncompatibleReturnTypes(SourceTypeBinding type, // 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, - new String[0], + NoArgument, + NoArgument, fieldDecl.sourceStart, fieldDecl.sourceEnd); } @@ -1187,29 +1533,35 @@ public void innerTypesCannotDeclareStaticInitializers(ReferenceBinding innerType 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, - new String[0], + 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, - new String[] {new String(type.sourceName())}, + arguments, + arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } public void invalidBreak(AstNode location) { this.handle( IProblem.InvalidBreak, - new String[0], + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } @@ -1261,18 +1613,21 @@ public void invalidConstructor(Statement statement, MethodBinding targetConstruc this.handle( flag, new String[] {new String(targetConstructor.declaringClass.readableName()), parametersAsString(targetConstructor)}, + new String[] {new String(targetConstructor.declaringClass.shortReadableName()), parametersAsShortString(targetConstructor)}, statement.sourceStart, statement.sourceEnd); } public void invalidContinue(AstNode location) { this.handle( IProblem.InvalidContinue, - new String[0], + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } -public void invalidEnclosingType(Expression expression, TypeBinding type, TypeBinding enclosingType) { +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 @@ -1296,13 +1651,15 @@ public void invalidEnclosingType(Expression expression, TypeBinding type, TypeBi this.handle( flag, new String[] {new String(enclosingType.readableName()) + "." + new String(type.readableName())}, //$NON-NLS-1$ + new String[] {new String(enclosingType.shortReadableName()) + "." + new String(type.shortReadableName())}, //$NON-NLS-1$ expression.sourceStart, expression.sourceEnd); } public void invalidExpressionAsStatement(Expression expression){ this.handle( IProblem.InvalidExpressionAsStatement, - new String[0], + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } @@ -1333,15 +1690,26 @@ public void invalidField(FieldReference fieldRef, TypeBinding searchedType) { case InheritedNameHidesEnclosingName : flag = IProblem.InheritedFieldHidesEnclosingName; break; + case ReceiverTypeNotVisible : + this.handle( + IProblem.NotVisibleType, + 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( flag, - new String[] {new String(field.readableName())}, + arguments, + arguments, severity, fieldRef.sourceStart, fieldRef.sourceEnd); @@ -1367,14 +1735,24 @@ public void invalidField(NameReference nameRef, FieldBinding field) { case InheritedNameHidesEnclosingName : flag = 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( flag, - new String[] {new String(field.readableName())}, + arguments, + arguments, nameRef.sourceStart, nameRef.sourceEnd); } @@ -1394,6 +1772,10 @@ public void invalidField(QualifiedNameReference nameRef, FieldBinding field, int 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, nameRef.sourceEnd); return; @@ -1423,14 +1805,24 @@ public void invalidField(QualifiedNameReference nameRef, FieldBinding field, int case InheritedNameHidesEnclosingName : flag = 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( flag, - new String[] {CharOperation.toString(CharOperation.subarray(nameRef.tokens, 0, index + 1))}, + arguments, + arguments, nameRef.sourceStart, nameRef.sourceEnd); } @@ -1464,6 +1856,15 @@ public void invalidMethod(MessageSend messageSend, MethodBinding method) { case NonStaticReferenceInStaticContext : flag = IProblem.StaticMethodRequested; break; + case ReceiverTypeNotVisible : + this.handle( + IProblem.NotVisibleType, + new String[] {new String(method.declaringClass.leafComponentType().readableName())}, + new String[] {new String(method.declaringClass.leafComponentType().shortReadableName())}, + messageSend.receiver.sourceStart, + messageSend.receiver.sourceEnd); + return; + case NoError : // 0 default : needImplementation(); // want to fail to see why we were here... @@ -1473,13 +1874,28 @@ public void invalidMethod(MessageSend messageSend, MethodBinding method) { if (flag == IProblem.UndefinedMethod) { ProblemMethodBinding problemMethod = (ProblemMethodBinding) method; if (problemMethod.closestMatch != null) { + String closestParameterTypeNames = parametersAsString(problemMethod.closestMatch); + String parameterTypeNames = parametersAsString(method); + String closestParameterTypeShortNames = parametersAsShortString(problemMethod.closestMatch); + String parameterTypeShortNames = parametersAsShortString(method); + if (closestParameterTypeShortNames.equals(parameterTypeShortNames)){ + closestParameterTypeShortNames = closestParameterTypeNames; + parameterTypeShortNames = parameterTypeNames; + } this.handle( IProblem.ParameterMismatch, new String[] { new String(problemMethod.closestMatch.declaringClass.readableName()), new String(problemMethod.closestMatch.selector), - parametersAsString(problemMethod.closestMatch), - parametersAsString(method)}, + 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; @@ -1491,31 +1907,57 @@ public void invalidMethod(MessageSend messageSend, MethodBinding method) { new String[] { new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)}, + new String[] { + new String(method.declaringClass.shortReadableName()), + new String(method.selector), parametersAsShortString(method)}, (int) (messageSend.nameSourcePosition >>> 32), (int) messageSend.nameSourcePosition); } public void invalidNullToSynchronize(Expression expression) { this.handle( IProblem.InvalidNullToSynchronized, - new String[0], + 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(), - new String(leftType.readableName()) + ", " + new String(rightType.readableName())}, //$NON-NLS-1$ + 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(), - new String(leftType.readableName()) + ", " + new String(rightType.readableName())}, //$NON-NLS-1$ + leftName + ", " + rightName}, //$NON-NLS-1$ + new String[] { + assign.operatorToString(), + leftShortName + ", " + rightShortName}, //$NON-NLS-1$ assign.sourceStart, assign.sourceEnd); } @@ -1523,9 +1965,18 @@ public void invalidOperator(UnaryExpression expression, TypeBinding type) { this.handle( IProblem.InvalidOperator, new String[] {expression.operatorToString(), new String(type.readableName())}, + new String[] {expression.operatorToString(), new String(type.shortReadableName())}, expression.sourceStart, expression.sourceEnd); } +public void invalidParenthesizedExpression(AstNode reference) { + this.handle( + IProblem.InvalidParenthesizedExpression, + NoArgument, + NoArgument, + reference.sourceStart, + reference.sourceEnd); +} public void invalidSuperclass(SourceTypeBinding type, TypeReference superclassRef, ReferenceBinding expectedType) { int problemId = expectedType.problemId(); int id; @@ -1553,6 +2004,7 @@ public void invalidSuperclass(SourceTypeBinding type, TypeReference superclassRe this.handle( id, new String[] {new String(expectedType.readableName()), new String(type.sourceName())}, + new String[] {new String(expectedType.shortReadableName()), new String(type.sourceName())}, superclassRef.sourceStart, superclassRef.sourceEnd); } @@ -1583,6 +2035,7 @@ public void invalidSuperinterface(SourceTypeBinding type, TypeReference superint this.handle( id, new String[] {new String(expectedType.readableName()), new String(type.sourceName())}, + new String[] {new String(expectedType.shortReadableName()), new String(type.sourceName())}, superinterfaceRef.sourceStart, superinterfaceRef.sourceEnd); } @@ -1613,13 +2066,15 @@ public void invalidType(AstNode location, TypeBinding type) { this.handle( flag, new String[] {new String(type.readableName())}, + new String[] {new String(type.shortReadableName())}, location.sourceStart, location.sourceEnd); } public void invalidTypeReference(Expression expression) { this.handle( IProblem.InvalidTypeExpression, - new String[0], + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } @@ -1627,21 +2082,25 @@ public void invalidTypeToSynchronize(Expression expression, TypeBinding type) { this.handle( IProblem.InvalidTypeToSynchronized, new String[] {new String(type.readableName())}, + new String[] {new String(type.shortReadableName())}, expression.sourceStart, expression.sourceEnd); } public void invalidUnaryExpression(Expression expression) { this.handle( IProblem.InvalidUnaryExpression, - new String[0], + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } public void isClassPathCorrect(char[][] wellKnownTypeName, CompilationUnitDeclaration compUnitDecl) { referenceContext = compUnitDecl; + String[] arguments = new String[] {CharOperation.toString(wellKnownTypeName)}; this.handle( IProblem.IsClassPathCorrect, - new String[] {CharOperation.toString(wellKnownTypeName)}, + arguments, + arguments, AbortCompilation | Error, compUnitDecl == null ? 0 : compUnitDecl.sourceStart, compUnitDecl == null ? 1 : compUnitDecl.sourceEnd); @@ -1649,62 +2108,80 @@ public void isClassPathCorrect(char[][] wellKnownTypeName, CompilationUnitDeclar public void maskedExceptionHandler(ReferenceBinding exceptionType, AstNode location) { this.handle( IProblem.MaskedCatch, - new String[0], + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } public void methodNeedingAbstractModifier(MethodDeclaration methodDecl) { this.handle( IProblem.MethodRequiresBody, - new String[0], + NoArgument, + NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } public void methodNeedingNoBody(MethodDeclaration methodDecl) { this.handle( - ((methodDecl.modifiers & CompilerModifiers.AccNative) != 0) ? IProblem.BodyForNativeMethod : IProblem.BodyForAbstractMethod, - new String[0], +// ((methodDecl.modifiers & CompilerModifiers.AccNative) != 0) ? IProblem.BodyForNativeMethod : IProblem.BodyForAbstractMethod, + IProblem.BodyForAbstractMethod, + NoArgument, + NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } public void methodWithConstructorName(MethodDeclaration methodDecl) { this.handle( IProblem.MethodButWithConstructorName, - new String[0], + NoArgument, + NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } -public void missingEnclosingInstanceSpecification(ReferenceBinding enclosingType, AstNode location) { - boolean insideConstructorCall = - (location instanceof ExplicitConstructorCall) - && (((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper); - - this.handle( - insideConstructorCall - ? IProblem.MissingEnclosingInstanceForConstructorCall - : IProblem.MissingEnclosingInstance, - new String[] {new String(enclosingType.readableName())}, - location.sourceStart, - location.sourceEnd); -} +//public void missingEnclosingInstanceSpecification(ReferenceBinding enclosingType, AstNode location) { +// boolean insideConstructorCall = +// (location instanceof ExplicitConstructorCall) +// && (((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper); +// +// this.handle( +// insideConstructorCall +// ? IProblem.MissingEnclosingInstanceForConstructorCall +// : IProblem.MissingEnclosingInstance, +// new String[] {new String(enclosingType.readableName())}, +// new String[] {new String(enclosingType.shortReadableName())}, +// location.sourceStart, +// location.sourceEnd); +//} public void missingReturnType(AbstractMethodDeclaration methodDecl) { this.handle( IProblem.MissingReturnType, - new String[0], + NoArgument, + NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } +public void missingSemiColon(Expression expression){ + this.handle( + IProblem.MissingSemiColon, + NoArgument, + NoArgument, + expression.sourceStart, + expression.sourceEnd); +} public void mustDefineDimensionsOrInitializer(ArrayAllocationExpression expression) { this.handle( IProblem.MustDefineEitherDimensionExpressionsOrInitializer, - new String[0], + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } public void mustSpecifyPackage(CompilationUnitDeclaration compUnitDecl) { + String[] arguments = new String[] {new String(compUnitDecl.getFileName())}; this.handle( IProblem.MustSpecifyPackage, - new String[] {new String(compUnitDecl.getFileName())}, + arguments, + arguments, compUnitDecl.sourceStart, compUnitDecl.sourceStart + 1); } @@ -1712,13 +2189,17 @@ public void mustUseAStaticMethod(MessageSend messageSend, MethodBinding method) this.handle( IProblem.StaticMethodRequested, new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)}, + new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)}, messageSend.sourceStart, messageSend.sourceEnd); } + public void nativeMethodsCannotBeStrictfp(ReferenceBinding type, AbstractMethodDeclaration methodDecl) { + String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)}; this.handle( IProblem.NativeMethodsCannotBeStrictfp, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } @@ -1729,6 +2210,7 @@ public void needToEmulateFieldReadAccess(FieldBinding field, AstNode location) { this.handle( IProblem.NeedToEmulateFieldReadAccess, new String[] {new String(field.declaringClass.readableName()), new String(field.name)}, + new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)}, location.sourceStart, location.sourceEnd); } @@ -1736,6 +2218,7 @@ public void needToEmulateFieldWriteAccess(FieldBinding field, AstNode location) this.handle( IProblem.NeedToEmulateFieldWriteAccess, new String[] {new String(field.declaringClass.readableName()), new String(field.name)}, + new String[] {new String(field.declaringClass.shortReadableName()), new String(field.name)}, location.sourceStart, location.sourceEnd); } @@ -1750,6 +2233,10 @@ public void needToEmulateMethodAccess( new String(method.declaringClass.readableName()), parametersAsString(method) }, + new String[] { + new String(method.declaringClass.shortReadableName()), + parametersAsShortString(method) + }, location.sourceStart, location.sourceEnd); else @@ -1760,59 +2247,149 @@ public void needToEmulateMethodAccess( new String(method.selector), parametersAsString(method) }, + new String[] { + new String(method.declaringClass.shortReadableName()), + new String(method.selector), + parametersAsShortString(method) + }, location.sourceStart, location.sourceEnd); } public void nestedClassCannotDeclareInterface(TypeDeclaration typeDecl) { + String[] arguments = new String[] {new String(typeDecl.name)}; this.handle( IProblem.CannotDefineInterfaceInLocalType, - new String[] {new String(typeDecl.name)}, + arguments, + arguments, typeDecl.sourceStart, typeDecl.sourceEnd); } public void noMoreAvailableSpaceForArgument(LocalVariableBinding local, AstNode location) { + String[] arguments = new String[]{ new String(local.name) }; this.handle( - IProblem.TooManyArgumentSlots, - new String[]{ new String(local.name) }, + local instanceof SyntheticArgumentBinding + ? IProblem.TooManySyntheticArgumentSlots + : IProblem.TooManyArgumentSlots, + arguments, + arguments, Abort | Error, location.sourceStart, location.sourceEnd); } public void noMoreAvailableSpaceForLocal(LocalVariableBinding local, AstNode location) { + String[] arguments = new String[]{ new String(local.name) }; this.handle( IProblem.TooManyLocalVariableSlots, - new String[]{ new String(local.name) }, + arguments, + arguments, Abort | Error, 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[] {new String(leftType.readableName()), new String(rightType.readableName())}, + 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[] {new String(leftType.readableName()), new String(rightType.readableName())}, + new String[] {leftName, rightName }, + new String[] {leftShortName, rightShortName }, expression.sourceStart, expression.sourceEnd); } +public void objectCannotHaveSuperTypes(SourceTypeBinding type) { + this.handle( + IProblem.ObjectCannotHaveSuperTypes, + NoArgument, + NoArgument, + type.sourceStart(), + type.sourceEnd()); +} public void operatorOnlyValidOnNumericType(CompoundAssignment assignment, TypeBinding leftType, TypeBinding rightType) { + String leftName = new String(leftType.readableName()); + String rightName = new String(rightType.readableName()); + String leftShortName = new String(leftType.shortReadableName()); + String rightShortName = new String(rightType.shortReadableName()); + if (leftShortName.equals(rightShortName)){ + leftShortName = leftName; + rightShortName = rightName; + } this.handle( IProblem.TypeMismatch, - new String[] {new String(leftType.readableName()), new String(rightType.readableName())}, + new String[] {leftName, rightName }, + new String[] {leftShortName, rightShortName }, assignment.sourceStart, assignment.sourceEnd); } -public void overridesDeprecatedMethod(MethodBinding currentMethod, MethodBinding inheritedMethod) { +public void overridesDeprecatedMethod(MethodBinding localMethod, MethodBinding inheritedMethod) { this.handle( IProblem.OverridingDeprecatedMethod, - new String[] {new String(inheritedMethod.declaringClass.readableName())}, - currentMethod.sourceStart(), - currentMethod.sourceEnd()); + 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( @@ -1824,20 +2401,31 @@ public void overridesPackageDefaultMethod(MethodBinding localMethod, MethodBindi 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, - new String[] {CharOperation.toString(compUnitDecl.currentPackage.tokens)}, + 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, - new String[] {CharOperation.toString(compUnitDecl.compilationResult.compilationUnit.getPackageName())}, + arguments, + arguments, compUnitDecl.currentPackage == null ? 0 : compUnitDecl.currentPackage.sourceStart, compUnitDecl.currentPackage == null ? 0 : compUnitDecl.currentPackage.sourceEnd); } @@ -1851,6 +2439,16 @@ private String parametersAsString(MethodBinding method) { } return buffer.toString(); } +private String parametersAsShortString(MethodBinding method) { + TypeBinding[] params = method.parameters; + StringBuffer buffer = new StringBuffer(); + for (int i = 0, length = params.length; i < length; i++) { + if (i != 0) + buffer.append(", "); //$NON-NLS-1$ + buffer.append(new String(params[i].shortReadableName())); + } + return buffer.toString(); +} public void parseError( int startPosition, int endPosition, @@ -1860,17 +2458,21 @@ public void parseError( if (possibleTokens.length == 0) { //no suggestion available if (isKeyword(currentTokenSource)) { + String[] arguments = new String[] {new String(currentTokenSource)}; this.handle( IProblem.ParsingErrorOnKeywordNoSuggestion, - new String[] {new String(currentTokenSource)}, + arguments, + arguments, // this is the current -invalid- token position startPosition, endPosition); return; } else { + String[] arguments = new String[] {errorTokenName}; this.handle( IProblem.ParsingErrorNoSuggestion, - new String[] {errorTokenName}, + arguments, + arguments, // this is the current -invalid- token position startPosition, endPosition); @@ -1889,9 +2491,11 @@ public void parseError( } if (isKeyword(currentTokenSource)) { + String[] arguments = new String[] {new String(currentTokenSource), list.toString()}; this.handle( IProblem.ParsingErrorOnKeyword, - new String[] {new String(currentTokenSource), list.toString()}, + arguments, + arguments, // this is the current -invalid- token position startPosition, endPosition); @@ -1908,78 +2512,57 @@ public void parseError( errorTokenName = new String(currentTokenSource); } + String[] arguments = new String[] {errorTokenName, list.toString()}; this.handle( IProblem.ParsingError, - new String[] {errorTokenName, list.toString()}, + arguments, + arguments, // this is the current -invalid- token position startPosition, endPosition); } 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, - new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)}, + arguments, + arguments, typeDecl.sourceStart, typeDecl.sourceEnd, compUnitDecl.compilationResult); } -/* - * Flag all constructors involved in a cycle, we know we have a cycle. - */ -public void recursiveConstructorInvocation(TypeDeclaration typeDeclaration) { - - // propagate the reference count, negative counts means leading to a super constructor invocation (directly or indirectly) - boolean hasChanged; - AbstractMethodDeclaration[] methods = typeDeclaration.methods; - int max = methods.length; - do { - hasChanged = false; - for(int i = 0; i < max; i++){ - if (methods[i].isConstructor()){ - ConstructorDeclaration constructor = (ConstructorDeclaration) methods[i]; - if (constructor.referenceCount > 0){ - ConstructorDeclaration targetConstructor = constructor.constructorCall == null - ? null - : (ConstructorDeclaration)(typeDeclaration.declarationOf(constructor.constructorCall.binding)); - if ((targetConstructor == null) || (targetConstructor.referenceCount < 0)){ - hasChanged = true; - constructor.referenceCount = -1; - } - } - } - } - } while (hasChanged); +public void recursiveConstructorInvocation(ExplicitConstructorCall constructorCall) { - // all remaining constructors with a positive count are still involved in a cycle - for(int i = 0; i < max; i++){ - if (methods[i].isConstructor()){ - ConstructorDeclaration constructor = (ConstructorDeclaration) methods[i]; - if (constructor.referenceCount > 0){ - this.referenceContext = constructor; - this.handle( - IProblem.RecursiveConstructorInvocation, - new String[] { - new String(constructor.constructorCall.binding.declaringClass.readableName()), - parametersAsString(constructor.constructorCall.binding) - }, - constructor.constructorCall.sourceStart, - constructor.constructorCall.sourceEnd); - } - } - } + this.handle( + IProblem.RecursiveConstructorInvocation, + new String[] { + new String(constructorCall.binding.declaringClass.readableName()), + parametersAsString(constructorCall.binding) + }, + new String[] { + new String(constructorCall.binding.declaringClass.shortReadableName()), + parametersAsShortString(constructorCall.binding) + }, + constructorCall.sourceStart, + constructorCall.sourceEnd); } + public void redefineArgument(Argument arg) { + String[] arguments = new String[] {new String(arg.name)}; this.handle( IProblem.RedefinedArgument, - new String[] {new String(arg.name)}, + arguments, + arguments, arg.sourceStart, arg.sourceEnd); } public void redefineLocal(LocalDeclaration localDecl) { + String[] arguments = new String[] {new String(localDecl.name)}; this.handle( IProblem.RedefinedLocal, - new String[] {new String(localDecl.name)}, + arguments, + arguments, localDecl.sourceStart, localDecl.sourceEnd); } @@ -1987,13 +2570,16 @@ public void referenceMustBeArrayTypeAt(TypeBinding arrayType, ArrayReference arr 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, - new String[] {new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } @@ -2024,6 +2610,7 @@ public void returnTypeProblem(SourceTypeBinding type, MethodDeclaration methodDe this.handle( id, new String[] {new String(methodDecl.selector), new String(expectedType.readableName())}, + new String[] {new String(methodDecl.selector), new String(expectedType.shortReadableName())}, methodDecl.returnType.sourceStart, methodDecl.returnType.sourceEnd); } @@ -2073,11 +2660,13 @@ public void scannerError(Parser parser, String errorTokenName) { if (errorTokenName.equals(Scanner.INVALID_CHAR_IN_STRING)) flag = IProblem.UnterminatedString; + String[] arguments = flag == IProblem.ParsingErrorNoSuggestion + ? new String[] {errorTokenName} + : NoArgument; this.handle( flag, - flag == IProblem.ParsingErrorNoSuggestion - ? new String[] {errorTokenName} - : new String[0], + arguments, + arguments, // this is the current -invalid- token position startPos, scanner.currentPosition - 1, @@ -2087,13 +2676,15 @@ 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, - new String[] {}, + NoArgument, + NoArgument, expression.sourceStart, expression.sourceEnd); } @@ -2104,6 +2695,7 @@ public void staticAndInstanceConflict(MethodBinding currentMethod, MethodBinding // 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 @@ -2112,27 +2704,34 @@ public void staticAndInstanceConflict(MethodBinding currentMethod, MethodBinding // 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(FieldReference fieldRef, FieldBinding field) { + String[] arguments = new String[] {new String(field.readableName())}; this.handle( IProblem.NonStaticFieldFromStaticInvocation, - new String[] {new String(field.readableName())}, + arguments, + arguments, fieldRef.sourceStart, fieldRef.sourceEnd); } public void staticFieldAccessToNonStaticVariable(QualifiedNameReference nameRef, FieldBinding field){ + String[] arguments = new String[] {new String(field.readableName())}; this.handle( IProblem.NonStaticFieldFromStaticInvocation, - new String[] { new String(field.readableName())}, + arguments, + arguments, nameRef.sourceStart, nameRef.sourceEnd); } public void staticFieldAccessToNonStaticVariable(SingleNameReference nameRef, FieldBinding field) { + String[] arguments = new String[] {new String(field.readableName())}; this.handle( IProblem.NonStaticFieldFromStaticInvocation, - new String[] {new String(field.readableName())}, + arguments, + arguments, nameRef.sourceStart, nameRef.sourceEnd); } @@ -2144,13 +2743,17 @@ public void staticInheritedMethodConflicts(SourceTypeBinding type, MethodBinding new String[] { new String(concreteMethod.readableName()), new String(abstractMethods[0].declaringClass.readableName())}, + new String[] { + new String(concreteMethod.readableName()), + new String(abstractMethods[0].declaringClass.shortReadableName())}, type.sourceStart(), type.sourceEnd()); } public void stringConstantIsExceedingUtf8Limit(AstNode location) { this.handle( IProblem.StringConstantIsExceedingUtf8Limit, - new String[0], + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } @@ -2158,6 +2761,7 @@ public void superclassMustBeAClass(SourceTypeBinding type, TypeReference supercl 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); } @@ -2165,57 +2769,127 @@ public void superinterfaceMustBeAnInterface(SourceTypeBinding type, TypeDeclarat this.handle( IProblem.SuperInterfaceMustBeAnInterface, new String[] {new String(superType.readableName()), new String(type.sourceName())}, + new String[] {new String(superType.shortReadableName()), new String(type.sourceName())}, typeDecl.sourceStart, typeDecl.sourceEnd); } +public void task(String tag, String message, String priority, int start, int end){ + this.handle( + IProblem.Task, + new String[] { tag, message, priority/*secret argument that is not surfaced in getMessage()*/}, + new String[] { tag, message, priority/*secret argument that is not surfaced in getMessage()*/}, + start, + end); +} +public void tooManyDimensions(AstNode expression) { + this.handle( + IProblem.TooManyArrayDimensions, + NoArgument, + NoArgument, + expression.sourceStart, + expression.sourceEnd); +} +public void tooManyFields(TypeDeclaration typeDeclaration) { + this.handle( + IProblem.TooManyFields, + new String[]{ new String(typeDeclaration.binding.readableName())}, + new String[]{ new String(typeDeclaration.binding.shortReadableName())}, + Abort | Error, + typeDeclaration.sourceStart, + typeDeclaration.sourceEnd); +} +public void tooManyMethods(TypeDeclaration typeDeclaration) { + this.handle( + IProblem.TooManyMethods, + new String[]{ new String(typeDeclaration.binding.readableName())}, + new String[]{ new String(typeDeclaration.binding.shortReadableName())}, + Abort | Error, + typeDeclaration.sourceStart, + typeDeclaration.sourceEnd); +} public void typeCastError(CastExpression expression, TypeBinding leftType, TypeBinding rightType) { + String leftName = new String(leftType.readableName()); + String rightName = new String(rightType.readableName()); + String leftShortName = new String(leftType.shortReadableName()); + String rightShortName = new String(rightType.shortReadableName()); + if (leftShortName.equals(rightShortName)){ + leftShortName = leftName; + rightShortName = rightName; + } this.handle( IProblem.IllegalCast, - new String[] {new String(rightType.readableName()), new String(leftType.readableName())}, + 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, - new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)}, + arguments, + arguments, typeDecl.sourceStart, typeDecl.sourceEnd, compUnitDecl.compilationResult); } public void typeMismatchError(TypeBinding resultType, TypeBinding expectedType, AstNode location) { + String resultTypeName = new String(resultType.readableName()); + String expectedTypeName = new String(expectedType.readableName()); + String resultTypeShortName = new String(resultType.shortReadableName()); + String expectedTypeShortName = new String(expectedType.shortReadableName()); + if (resultTypeShortName.equals(expectedTypeShortName)){ + resultTypeShortName = resultTypeName; + expectedTypeShortName = expectedTypeName; + } this.handle( IProblem.TypeMismatch, - new String[] {new String(resultType.readableName()), new String(expectedType.readableName())}, + new String[] {resultTypeName, expectedTypeName}, + new String[] {resultTypeShortName, expectedTypeShortName}, location.sourceStart, location.sourceEnd); } public void typeMismatchErrorActualTypeExpectedType(Expression expression, TypeBinding constantType, TypeBinding expectedType) { + String constantTypeName = new String(constantType.readableName()); + String expectedTypeName = new String(expectedType.readableName()); + String constantTypeShortName = new String(constantType.shortReadableName()); + String expectedTypeShortName = new String(expectedType.shortReadableName()); + if (constantTypeShortName.equals(expectedTypeShortName)){ + constantTypeShortName = constantTypeName; + expectedTypeShortName = expectedTypeName; + } this.handle( IProblem.TypeMismatch, - new String[] {new String(constantType.readableName()), new String(expectedType.readableName())}, + new String[] {constantTypeName, expectedTypeName}, + new String[] {constantTypeShortName, expectedTypeShortName}, expression.sourceStart, expression.sourceEnd); } public void undefinedLabel(BranchStatement statement) { + String[] arguments = new String[] {new String(statement.label)}; this.handle( IProblem.UndefinedLabel, - new String[] {new String(statement.label)}, + arguments, + arguments, statement.sourceStart, statement.sourceEnd); } public void unexpectedStaticModifierForField(SourceTypeBinding type, FieldDeclaration fieldDecl) { + String[] arguments = new String[] {fieldDecl.name()}; this.handle( IProblem.UnexpectedStaticModifierForField, - new String[] {fieldDecl.name()}, + 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, - new String[] {new String(type.sourceName()), new String(methodDecl.selector)}, + arguments, + arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } @@ -2235,20 +2909,25 @@ public void unhandledException(TypeBinding exceptionType, AstNode location) { ? 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, - new String[] {new String(binding.readableName())}, + arguments, + arguments, location.sourceStart, location.sourceEnd); } public void uninitializedLocalVariable(LocalVariableBinding binding, AstNode location) { + String[] arguments = new String[] {new String(binding.readableName())}; this.handle( IProblem.UninitializedLocalVariable, - new String[] {new String(binding.readableName())}, + arguments, + arguments, location.sourceStart, location.sourceEnd); } @@ -2256,7 +2935,8 @@ public void unmatchedBracket(int position, ReferenceContext context, Compilation this.handle( IProblem.UnmatchedBracket, - new String[] {}, + NoArgument, + NoArgument, position, position, context, @@ -2266,20 +2946,39 @@ public void unnecessaryEnclosingInstanceSpecification(Expression expression, Ref this.handle( IProblem.IllegalEnclosingInstanceSpecification, new String[]{ new String(targetType.readableName())}, + new String[]{ new String(targetType.shortReadableName())}, expression.sourceStart, expression.sourceEnd); } +public void unnecessaryReceiverForStaticMethod(AstNode location, MethodBinding method) { + this.handle( + IProblem.NonStaticAccessToStaticMethod, + new String[] {new String(method.declaringClass.readableName()), new String(method.selector), parametersAsString(method)}, + new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), parametersAsShortString(method)}, + location.sourceStart, + location.sourceEnd); +} +public void unnecessaryReceiverForStaticField(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, + location.sourceEnd); +} public void unreachableCode(Statement statement) { this.handle( IProblem.CodeCannotBeReached, - new String[0], + NoArgument, + NoArgument, statement.sourceStart, statement.sourceEnd); } public void unreachableExceptionHandler(ReferenceBinding exceptionType, AstNode location) { this.handle( IProblem.UnreachableCatch, - new String[0], + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } @@ -2292,54 +2991,182 @@ public void unresolvableReference(NameReference nameRef, Binding binding) { severity = SecondaryError; } */ + String[] arguments = new String[] {new String(binding.readableName())}; this.handle( IProblem.UndefinedName, - new String[] {new String(binding.readableName())}, + arguments, + arguments, severity, nameRef.sourceStart, nameRef.sourceEnd); } public void unusedArgument(LocalDeclaration localDecl) { + + String[] arguments = new String[] {localDecl.name()}; this.handle( IProblem.ArgumentIsNeverUsed, - new String[] {localDecl.name()}, + arguments, + arguments, localDecl.sourceStart, localDecl.sourceEnd); } public void unusedImport(ImportReference importRef) { + String[] arguments = new String[] { CharOperation.toString(importRef.tokens) }; this.handle( IProblem.UnusedImport, - new String[] { CharOperation.toString(importRef.tokens) }, + arguments, + arguments, importRef.sourceStart, importRef.sourceEnd); } public void unusedLocalVariable(LocalDeclaration localDecl) { + String[] arguments = new String[] {localDecl.name()}; this.handle( IProblem.LocalVariableIsNeverUsed, - new String[] {localDecl.name()}, + arguments, + arguments, localDecl.sourceStart, localDecl.sourceEnd); } +public void unusedPrivateConstructor(ConstructorDeclaration constructorDecl) { + + if (computeSeverity(IProblem.UnusedPrivateConstructor) == Ignore) return; + + // no complaint for no-arg constructors (or default ones) - known pattern to block instantiation + if (constructorDecl.arguments == null || constructorDecl.arguments.length == 0) return; + + MethodBinding constructor = constructorDecl.binding; + this.handle( + IProblem.UnusedPrivateConstructor, + new String[] { + new String(constructor.declaringClass.readableName()), + parametersAsString(constructor) + }, + new String[] { + new String(constructor.declaringClass.shortReadableName()), + parametersAsShortString(constructor) + }, + constructorDecl.sourceStart, + constructorDecl.sourceEnd); +} +public void unusedPrivateField(FieldDeclaration fieldDecl) { + + if (computeSeverity(IProblem.UnusedPrivateField) == Ignore) return; + + FieldBinding field = fieldDecl.binding; + + if (CharOperation.equals(TypeConstants.SERIALVERSIONUID, field.name) + && field.isStatic() + && field.isFinal() + && TypeBinding.LongBinding == field.type) { + return; // do not report unused serialVersionUID 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() + && TypeBinding.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() + && TypeBinding.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() + && TypeBinding.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() + && TypeBinding.T_Object == method.returnType.id + && method.parameters.length == 0 + && CharOperation.equals(method.selector, TypeConstants.WRITEREPLACE)) { + return; + } + this.handle( + IProblem.UnusedPrivateMethod, + new String[] { + new String(method.declaringClass.readableName()), + new String(method.selector), + parametersAsString(method) + }, + new String[] { + new String(method.declaringClass.shortReadableName()), + new String(method.selector), + parametersAsShortString(method) + }, + methodDecl.sourceStart, + methodDecl.sourceEnd); +} +public void unusedPrivateType(TypeDeclaration typeDecl) { + + if (computeSeverity(IProblem.UnusedPrivateType) == Ignore) return; + ReferenceBinding type = typeDecl.binding; + this.handle( + IProblem.UnusedPrivateType, + new String[] { + new String(type.readableName()), + }, + new String[] { + new String(type.shortReadableName()), + }, + typeDecl.sourceStart, + typeDecl.sourceEnd); +} public void useAssertAsAnIdentifier(int sourceStart, int sourceEnd) { this.handle( IProblem.UseAssertAsAnIdentifier, - new String[0], + NoArgument, + NoArgument, sourceStart, sourceEnd); } public void variableTypeCannotBeVoid(AbstractVariableDeclaration varDecl) { + String[] arguments = new String[] {new String(varDecl.name)}; this.handle( IProblem.VariableTypeCannotBeVoid, - new String[] {new String(varDecl.name)}, + arguments, + arguments, varDecl.sourceStart, varDecl.sourceEnd); } public void variableTypeCannotBeVoidArray(AbstractVariableDeclaration varDecl) { + String[] arguments = new String[] {new String(varDecl.name)}; this.handle( IProblem.VariableTypeCannotBeVoidArray, - new String[] {new String(varDecl.name)}, + arguments, + arguments, varDecl.sourceStart, varDecl.sourceEnd); } @@ -2350,6 +3177,7 @@ public void visibilityConflict(MethodBinding currentMethod, MethodBinding inheri // 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()); } @@ -2357,15 +3185,11 @@ public void wrongSequenceOfExceptionTypesError(TryStatement statement, int under //the two catch block under and upper are in an incorrect order. //under should be define BEFORE upper in the source - //notice that the compiler could arrange automatically the - //correct order - and the only error would be on cycle .... - //on this one again , java is compiler-driven instead of being - //user-driven ..... - TypeReference typeRef = statement.catchArguments[under].type; this.handle( IProblem.UnreachableCatch, - new String[0], + NoArgument, + NoArgument, typeRef.sourceStart, typeRef.sourceEnd); } @@ -2373,15 +3197,27 @@ public void wrongSequenceOfExceptionTypesError(TryStatement statement, int under public void nonExternalizedStringLiteral(AstNode location) { this.handle( IProblem.NonExternalizedStringLiteral, - new String[] {}, + NoArgument, + NoArgument, location.sourceStart, location.sourceEnd); } +public void noMoreAvailableSpaceForConstant(TypeDeclaration typeDeclaration) { + this.handle( + IProblem.TooManyBytesForStringConstant, + new String[]{ new String(typeDeclaration.binding.readableName())}, + new String[]{ new String(typeDeclaration.binding.shortReadableName())}, + Abort | Error, + typeDeclaration.sourceStart, + typeDeclaration.sourceEnd); +} + public void noMoreAvailableSpaceInConstantPool(TypeDeclaration typeDeclaration) { this.handle( IProblem.TooManyConstantsInConstantPool, new String[]{ new String(typeDeclaration.binding.readableName())}, + new String[]{ new String(typeDeclaration.binding.shortReadableName())}, Abort | Error, typeDeclaration.sourceStart, typeDeclaration.sourceEnd); @@ -2406,7 +3242,7 @@ private boolean isKeyword(char[] tokenSource) { return false; } int nextToken= scanner.getNextToken(); - if (nextToken == ITerminalSymbols.TokenNameEOF + if (nextToken == Scanner.TokenNameEOF && scanner.startPosition == scanner.source.length) { // to handle case where we had an ArrayIndexOutOfBoundsException // while reading the last token switch(token) { @@ -2416,75 +3252,56 @@ private boolean isKeyword(char[] tokenSource) { } else { return false; } - case Scanner.TokenNameas: - case Scanner.TokenNameand: -// case Scanner.TokenNameabstract: + case Scanner.TokenNameabstract: // case Scanner.TokenNameassert: // case Scanner.TokenNamebyte: case Scanner.TokenNamebreak: // case Scanner.TokenNameboolean: case Scanner.TokenNamecase: // case Scanner.TokenNamechar: -// case Scanner.TokenNamecatch: + case Scanner.TokenNamecatch: case Scanner.TokenNameclass: case Scanner.TokenNamecontinue: case Scanner.TokenNamedo: // case Scanner.TokenNamedouble: case Scanner.TokenNamedefault: - case Scanner.TokenNameecho: - case Scanner.TokenNameendif: - case Scanner.TokenNameendfor: - case Scanner.TokenNameendforeach: - case Scanner.TokenNameendswitch: - case Scanner.TokenNameendwhile: case Scanner.TokenNameelse: case Scanner.TokenNameextends: case Scanner.TokenNamefor: // case Scanner.TokenNamefinal: // case Scanner.TokenNamefloat: case Scanner.TokenNamefalse: -// case Scanner.TokenNamefinally: - case Scanner.TokenNameglobal: + case Scanner.TokenNamefinally: case Scanner.TokenNameif: - case Scanner.TokenNameinclude: - case Scanner.TokenNameinclude_once: // case Scanner.TokenNameint: // case Scanner.TokenNameimport: -// case Scanner.TokenNameinterface: -// case Scanner.TokenNameimplements: -// case Scanner.TokenNameinstanceof: - case Scanner.TokenNamelist: + case Scanner.TokenNameinterface: + case Scanner.TokenNameimplements: + case Scanner.TokenNameinstanceof: // case Scanner.TokenNamelong: case Scanner.TokenNamenew: case Scanner.TokenNamenull: // case Scanner.TokenNamenative: - case Scanner.TokenNameold_function: - case Scanner.TokenNameor: - case Scanner.TokenNameprint: -// case Scanner.TokenNamepublic: + case Scanner.TokenNamepublic: // case Scanner.TokenNamepackage: -// case Scanner.TokenNameprivate: -// case Scanner.TokenNameprotected: - case Scanner.TokenNamerequire: - case Scanner.TokenNamerequire_once: + case Scanner.TokenNameprivate: + case Scanner.TokenNameprotected: case Scanner.TokenNamereturn: // case Scanner.TokenNameshort: -// case Scanner.TokenNamesuper: + case Scanner.TokenNamesuper: case Scanner.TokenNamestatic: case Scanner.TokenNameswitch: // case Scanner.TokenNamestrictfp: // case Scanner.TokenNamesynchronized: -// case Scanner.TokenNametry: -// case Scanner.TokenNamethis: + case Scanner.TokenNametry: + case Scanner.TokenNamethis: case Scanner.TokenNametrue: -// case Scanner.TokenNamethrow: + case Scanner.TokenNamethrow: // case Scanner.TokenNamethrows: // case Scanner.TokenNametransient: - case Scanner.TokenNamevar: // case Scanner.TokenNamevoid: // case Scanner.TokenNamevolatile: case Scanner.TokenNamewhile: - case Scanner.TokenNamexor: return true; default: return false; @@ -2498,4 +3315,16 @@ private boolean isKeyword(char[] tokenSource) { } } +// jsurfer start +public void phpParsingError(String[] messageArguments, int problemStartPosition, int problemEndPosition, ReferenceContext context, CompilationResult compilationResult) { + + this.handle( + IProblem.PHPParsingError, + NoArgument, + messageArguments, + problemStartPosition, + problemEndPosition, + context, + compilationResult); +} }