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 7e72de4..9758077 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,20 +1,60 @@ -/******************************************************************************* - * 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 v1.0 - * which accompanies this distribution, and is available at +/*********************************************************************************************************************************** + * 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 v1.0 which accompanies this distribution, and is available at * http://www.eclipse.org/legal/cpl-v10.html * - * Contributors: - * IBM Corporation - initial API and implementation - *******************************************************************************/ + * 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.InvalidInputException; 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.ast.ASTNode; +import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.AbstractVariableDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.AllocationExpression; +import net.sourceforge.phpdt.internal.compiler.ast.Argument; +import net.sourceforge.phpdt.internal.compiler.ast.ArrayAllocationExpression; +import net.sourceforge.phpdt.internal.compiler.ast.ArrayReference; +import net.sourceforge.phpdt.internal.compiler.ast.Assignment; +import net.sourceforge.phpdt.internal.compiler.ast.BinaryExpression; +import net.sourceforge.phpdt.internal.compiler.ast.CaseStatement; +import net.sourceforge.phpdt.internal.compiler.ast.CastExpression; +import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.CompoundAssignment; +import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.DefaultCase; +import net.sourceforge.phpdt.internal.compiler.ast.EqualExpression; +import net.sourceforge.phpdt.internal.compiler.ast.ExplicitConstructorCall; +import net.sourceforge.phpdt.internal.compiler.ast.Expression; +import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.FieldReference; +import net.sourceforge.phpdt.internal.compiler.ast.InstanceOfExpression; +import net.sourceforge.phpdt.internal.compiler.ast.IntLiteral; +import net.sourceforge.phpdt.internal.compiler.ast.Literal; +import net.sourceforge.phpdt.internal.compiler.ast.LocalDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.LongLiteral; +import net.sourceforge.phpdt.internal.compiler.ast.MessageSend; +import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.NameReference; +import net.sourceforge.phpdt.internal.compiler.ast.NumberLiteral; +import net.sourceforge.phpdt.internal.compiler.ast.QualifiedNameReference; +import net.sourceforge.phpdt.internal.compiler.ast.Reference; +import net.sourceforge.phpdt.internal.compiler.ast.ReturnStatement; +import net.sourceforge.phpdt.internal.compiler.ast.SingleNameReference; +import net.sourceforge.phpdt.internal.compiler.ast.Statement; +import net.sourceforge.phpdt.internal.compiler.ast.ThisReference; +import net.sourceforge.phpdt.internal.compiler.ast.ThrowStatement; +import net.sourceforge.phpdt.internal.compiler.ast.TryStatement; +import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration; +import net.sourceforge.phpdt.internal.compiler.ast.TypeReference; +import net.sourceforge.phpdt.internal.compiler.ast.UnaryExpression; +import net.sourceforge.phpdt.internal.compiler.env.IConstants; +import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions; import net.sourceforge.phpdt.internal.compiler.impl.Constant; import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext; import net.sourceforge.phpdt.internal.compiler.lookup.Binding; @@ -24,7 +64,6 @@ 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; @@ -33,319 +72,314 @@ 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, - IProblemFactory problemFactory) { - //CompilerOptions options, IProblemFactory problemFactory) { - super(policy, problemFactory);//options, problemFactory); + CompilerOptions options, IProblemFactory problemFactory) { + + // IProblemFactory problemFactory) { + super(policy, options, problemFactory); // ), problemFactory); } + public void abortDueToInternalError(String errorMessage) { - String[] arguments = new String[]{errorMessage}; + String[] arguments = new String[] { errorMessage }; this.handle(IProblem.Unclassified, arguments, arguments, Error | Abort, 0, 0); } - public void abortDueToInternalError(String errorMessage, AstNode location) { - String[] arguments = new String[]{errorMessage}; + + public void abortDueToInternalError(String errorMessage, ASTNode location) { + String[] arguments = new String[] { errorMessage }; this.handle(IProblem.Unclassified, arguments, arguments, Error | Abort, location.sourceStart, location.sourceEnd); } + public void abstractMethodCannotBeOverridden(SourceTypeBinding type, MethodBinding concreteMethod) { this.handle( - // %1 must be abstract since it cannot override the inherited - // package-private abstract method %2 - IProblem.AbstractMethodCannotBeOverridden, new String[]{ + // %1 must be abstract since it cannot override the inherited + // package-private abstract method %2 + IProblem.AbstractMethodCannotBeOverridden, new String[] { new String(type.sourceName()), new String(CharOperation.concat( concreteMethod.declaringClass.readableName(), - concreteMethod.readableName(), '.'))}, - new String[]{ + concreteMethod.readableName(), '.')) }, + new String[] { new String(type.sourceName()), new String(CharOperation.concat( concreteMethod.declaringClass .shortReadableName(), concreteMethod - .shortReadableName(), '.'))}, type + .shortReadableName(), '.')) }, type .sourceStart(), type.sourceEnd()); } + public void abstractMethodInAbstractClass(SourceTypeBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.AbstractMethodInAbstractClass, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void abstractMethodMustBeImplemented(SourceTypeBinding type, MethodBinding abstractMethod) { this.handle( - // Must implement the inherited abstract method %1 + // Must implement the inherited abstract method %1 // 8.4.3 - Every non-abstract subclass of an abstract type, A, // must provide a concrete implementation of all of A's // methods. IProblem.AbstractMethodMustBeImplemented, - new String[]{new String(CharOperation.concat( + new String[] { new String(CharOperation.concat( abstractMethod.declaringClass.readableName(), - abstractMethod.readableName(), '.'))}, - new String[]{new String(CharOperation.concat( + abstractMethod.readableName(), '.')) }, + new String[] { new String(CharOperation.concat( abstractMethod.declaringClass.shortReadableName(), - abstractMethod.shortReadableName(), '.'))}, type + abstractMethod.shortReadableName(), '.')) }, type .sourceStart(), type.sourceEnd()); } + public void abstractMethodNeedingNoBody(AbstractMethodDeclaration method) { this.handle(IProblem.BodyForAbstractMethod, NoArgument, NoArgument, method.sourceStart, method.sourceEnd, method, method .compilationResult()); } - public void alreadyDefinedLabel(char[] labelName, AstNode location) { - String[] arguments = new String[]{new String(labelName)}; + + public void alreadyDefinedLabel(char[] labelName, ASTNode location) { + String[] arguments = new String[] { new String(labelName) }; this.handle(IProblem.DuplicateLabel, arguments, arguments, location.sourceStart, location.sourceEnd); } + public void anonymousClassCannotExtendFinalClass(Expression expression, TypeBinding type) { this.handle(IProblem.AnonymousClassCannotExtendFinalClass, - new String[]{new String(type.readableName())}, - new String[]{new String(type.shortReadableName())}, + 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)}; + String[] arguments = new String[] { new String(methodDecl.selector), + new String(arg.name) }; this.handle(IProblem.ArgumentTypeCannotBeVoid, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void argumentTypeCannotBeVoidArray(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, Argument arg) { - String[] arguments = new String[]{new String(methodDecl.selector), - new String(arg.name)}; + String[] arguments = new String[] { new String(methodDecl.selector), + new String(arg.name) }; this.handle(IProblem.ArgumentTypeCannotBeVoidArray, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void argumentTypeProblem(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, Argument arg, TypeBinding expectedType) { int problemId = expectedType.problemId(); int id; switch (problemId) { - case NotFound : - // 1 - id = IProblem.ArgumentTypeNotFound; - break; - case NotVisible : - // 2 - id = IProblem.ArgumentTypeNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.ArgumentTypeAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.ArgumentTypeInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.ArgumentTypeInheritedNameHidesEnclosingName; - break; - case NoError : + case NotFound: + // 1 + id = IProblem.ArgumentTypeNotFound; + break; + case NotVisible: + // 2 + id = IProblem.ArgumentTypeNotVisible; + break; + case Ambiguous: + // 3 + id = IProblem.ArgumentTypeAmbiguous; + break; + case InternalNameProvided: + // 4 + id = IProblem.ArgumentTypeInternalNameProvided; + break; + case InheritedNameHidesEnclosingName: + // 5 + id = IProblem.ArgumentTypeInheritedNameHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; + default: + needImplementation(); // want to fail to see why we were + // here... + return; } - 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())}, + 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, NoArgument, NoArgument, sourceStart, sourceEnd); } + public void assignmentHasNoEffect(Assignment assignment, char[] name) { - String[] arguments = new String[]{new String(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())}, + this.handle(IProblem.VoidMethodReturnsValue, new String[] { new String( + expectedType.readableName()) }, new String[] { new String( + expectedType.shortReadableName()) }, returnStatement.sourceStart, returnStatement.sourceEnd); } + public void attemptToReturnVoidValue(ReturnStatement returnStatement) { this.handle(IProblem.MethodReturnsVoid, NoArgument, NoArgument, returnStatement.sourceStart, returnStatement.sourceEnd); } - //public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location) + + // public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location) // { - // String[] arguments = new String[] {new String(location.selector), + // 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); - // } - //} + // if (location.isConstructor()) { + // this.handle( + // IProblem.BytecodeExceeds64KLimitForConstructor, + // arguments, + // arguments, + // Error | Abort, + // location.sourceStart, + // location.sourceEnd); + // } else { + // this.handle( + // IProblem.BytecodeExceeds64KLimit, + // arguments, + // arguments, + // Error | Abort, + // location.sourceStart, + // location.sourceEnd); + // } + // } public void bytecodeExceeds64KLimit(TypeDeclaration location) { this.handle(IProblem.BytecodeExceeds64KLimitForClinit, NoArgument, NoArgument, Error | Abort, location.sourceStart, location.sourceEnd); } + public void cannotAllocateVoidArray(Expression expression) { this.handle(IProblem.CannotAllocateVoidArray, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } - public void cannotAssignToFinalField(FieldBinding field, AstNode location) { - this.handle(IProblem.FinalFieldAssignment, new String[]{ - (field.declaringClass == null ? "array" : new String( - field.declaringClass.readableName())), //$NON-NLS-1$ - new String(field.readableName())}, new String[]{ - (field.declaringClass == null ? "array" : new String( - field.declaringClass.shortReadableName())), //$NON-NLS-1$ - new String(field.shortReadableName())}, location.sourceStart, - location.sourceEnd); - } + + public void cannotAssignToFinalField(FieldBinding field, ASTNode location) { + this + .handle( + IProblem.FinalFieldAssignment, + new String[] { + (field.declaringClass == null ? "array" : new String(field.declaringClass.readableName())), //$NON-NLS-1$ + new String(field.readableName()) }, + new String[] { + (field.declaringClass == null ? "array" : new String(field.declaringClass.shortReadableName())), //$NON-NLS-1$ + new String(field.shortReadableName()) }, + location.sourceStart, location.sourceEnd); + } + public void cannotAssignToFinalLocal(LocalVariableBinding local, - AstNode location) { - String[] arguments = new String[]{new String(local.readableName())}; + 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())}; + ASTNode location) { + String[] arguments = new String[] { new String(local.readableName()) }; this.handle(IProblem.FinalOuterLocalAssignment, arguments, arguments, location.sourceStart, location.sourceEnd); } + public void cannotDeclareLocalInterface(char[] interfaceName, int sourceStart, int sourceEnd) { - String[] arguments = new String[]{new String(interfaceName)}; + String[] arguments = new String[] { new String(interfaceName) }; this.handle(IProblem.CannotDefineInterfaceInLocalType, arguments, arguments, sourceStart, sourceEnd); } + public void cannotDefineDimensionsAndInitializer( ArrayAllocationExpression expresssion) { this.handle(IProblem.CannotDefineDimensionExpressionsWithInit, NoArgument, NoArgument, expresssion.sourceStart, expresssion.sourceEnd); } + public void cannotDireclyInvokeAbstractMethod(MessageSend messageSend, MethodBinding method) { - this.handle(IProblem.DirectInvocationOfAbstractMethod, new String[]{ + this.handle(IProblem.DirectInvocationOfAbstractMethod, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass.shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, + parametersAsShortString(method) }, messageSend.sourceStart, messageSend.sourceEnd); } - public void cannotImportPackage(ImportReference importRef) { - String[] arguments = new String[]{CharOperation - .toString(importRef.tokens)}; - this.handle(IProblem.CannotImportPackage, arguments, arguments, - importRef.sourceStart, importRef.sourceEnd); - } + + // public void cannotImportPackage(ImportReference importRef) { + // String[] arguments = new + // String[]{CharOperation.toString(importRef.tokens)}; + // this.handle(IProblem.CannotImportPackage, arguments, arguments, + // importRef.sourceStart, importRef.sourceEnd); + // } public void cannotInstantiate(TypeReference typeRef, TypeBinding type) { this.handle(IProblem.InvalidClassInstantiation, - new String[]{new String(type.readableName())}, - new String[]{new String(type.shortReadableName())}, + 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())}; + ASTNode location) { + String[] arguments = new String[] { new String(local.readableName()) }; this.handle(IProblem.OuterLocalMustBeFinal, arguments, arguments, location.sourceStart, location.sourceEnd); } - public void cannotReturnInInitializer(AstNode location) { + + public void cannotReturnInInitializer(ASTNode location) { this.handle(IProblem.CannotReturnInInitializer, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } + public void cannotThrowNull(ThrowStatement statement) { this.handle(IProblem.CannotThrowNull, NoArgument, NoArgument, statement.sourceStart, statement.sourceEnd); } + public void cannotThrowType(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, TypeReference exceptionType, TypeBinding expectedType) { - this.handle(IProblem.CannotThrowType, new String[]{new String( - expectedType.readableName())}, new String[]{new String( - expectedType.shortReadableName())}, exceptionType.sourceStart, + 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) { + + public void cannotUseSuperInJavaLangObject(ASTNode reference) { this.handle(IProblem.ObjectHasNoSuperclass, NoArgument, NoArgument, reference.sourceStart, reference.sourceEnd); } + public void cannotUseSuperInCodeSnippet(int start, int end) { this.handle(IProblem.CannotUseSuperInCodeSnippet, NoArgument, NoArgument, Error | Abort, start, end); } + public void caseExpressionMustBeConstant(Expression expression) { this.handle(IProblem.NonConstantExpression, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void classExtendFinalClass(SourceTypeBinding type, TypeReference superclass, TypeBinding expectedType) { String name = new String(type.sourceName()); @@ -353,253 +387,258 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { String expectedShortName = new String(expectedType.shortReadableName()); if (expectedShortName.equals(name)) expectedShortName = expectedFullName; - this.handle(IProblem.ClassExtendFinalClass, new String[]{ - expectedFullName, name}, new String[]{expectedShortName, name}, - superclass.sourceStart, superclass.sourceEnd); + this.handle(IProblem.ClassExtendFinalClass, new String[] { + expectedFullName, name }, new String[] { expectedShortName, + name }, superclass.sourceStart, superclass.sourceEnd); } + public void codeSnippetMissingClass(String missing, int start, int end) { - String[] arguments = new String[]{missing}; + String[] arguments = new String[] { missing }; this.handle(IProblem.CodeSnippetMissingClass, arguments, arguments, Error | Abort, start, end); } + public void codeSnippetMissingMethod(String className, String missingMethod, String argumentTypes, int start, int end) { - String[] arguments = new String[]{className, missingMethod, - argumentTypes}; + String[] arguments = new String[] { className, missingMethod, + argumentTypes }; this.handle(IProblem.CodeSnippetMissingMethod, arguments, arguments, Error | Abort, start, end); } + /* - * Given the current configuration, answers which category the problem - * falls into: Error | Warning | Ignore + * Given the current configuration, answers which category the problem falls + * into: Error | Warning | Ignore */ - //public int computeSeverity(int problemId){ - // - // // severity can have been preset on the problem - //// if ((problem.severity & Fatal) != 0){ - //// return Error; - //// } - // - // // if not then check whether it is a configurable problem - // 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; - // } - //} - //public void conditionalArgumentsIncompatibleTypes(ConditionalExpression + public int computeSeverity(int problemId) { + + // severity can have been preset on the problem + // if ((problem.severity & Fatal) != 0){ + // return Error; + // } + + // if not then check whether it is a configurable problem + switch (problemId) { + case IProblem.PHPIncludeNotExistWarning: + return this.options + .getSeverity(CompilerOptions.PHPIncludeNotExistWarning); + case IProblem.PHPVarDeprecatedWarning: + return this.options + .getSeverity(CompilerOptions.PHPVarDeprecatedWarning); + case IProblem.PHPBadStyleKeywordWarning: + return this.options + .getSeverity(CompilerOptions.PHPBadStyleKeywordWarning); + case IProblem.PHPBadStyleUppercaseIdentifierWarning: + return this.options + .getSeverity(CompilerOptions.PHPBadStyleUppercaseIdentifierWarning); + + case IProblem.UninitializedLocalVariable: + return this.options + .getSeverity(CompilerOptions.UninitializedLocalVariableWarning); + case IProblem.CodeCannotBeReached: + return this.options + .getSeverity(CompilerOptions.CodeCannotBeReachedWarning); + + case IProblem.MaskedCatch: + return this.options.getSeverity(CompilerOptions.MaskedCatchBlock); + + case IProblem.UnusedImport: + return this.options.getSeverity(CompilerOptions.UnusedImport); + + case IProblem.MethodButWithConstructorName: + return this.options + .getSeverity(CompilerOptions.MethodWithConstructorName); + + case IProblem.OverridingNonVisibleMethod: + return this.options + .getSeverity(CompilerOptions.OverriddenPackageDefaultMethod); + + case IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod: + case IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod: + return this.options + .getSeverity(CompilerOptions.IncompatibleNonInheritedInterfaceMethod); + + case IProblem.OverridingDeprecatedMethod: + case IProblem.UsingDeprecatedType: + case IProblem.UsingDeprecatedMethod: + case IProblem.UsingDeprecatedConstructor: + case IProblem.UsingDeprecatedField: + return this.options.getSeverity(CompilerOptions.UsingDeprecatedAPI); + + case IProblem.LocalVariableIsNeverUsed: + return this.options + .getSeverity(CompilerOptions.UnusedLocalVariable); + + case IProblem.ArgumentIsNeverUsed: + return this.options.getSeverity(CompilerOptions.UnusedArgument); + + case IProblem.NoImplicitStringConversionForCharArrayExpression: + return this.options + .getSeverity(CompilerOptions.NoImplicitStringConversion); + + case IProblem.NeedToEmulateFieldReadAccess: + case IProblem.NeedToEmulateFieldWriteAccess: + case IProblem.NeedToEmulateMethodAccess: + case IProblem.NeedToEmulateConstructorAccess: + return this.options.getSeverity(CompilerOptions.AccessEmulation); + + case IProblem.NonExternalizedStringLiteral: + return this.options + .getSeverity(CompilerOptions.NonExternalizedString); + + case IProblem.UseAssertAsAnIdentifier: + return this.options + .getSeverity(CompilerOptions.AssertUsedAsAnIdentifier); + + case IProblem.NonStaticAccessToStaticMethod: + case IProblem.NonStaticAccessToStaticField: + return this.options + .getSeverity(CompilerOptions.NonStaticAccessToStatic); + + // case IProblem.IndirectAccessToStaticMethod : + // case IProblem.IndirectAccessToStaticField : + // case IProblem.IndirectAccessToStaticType : + // return + // this.options.getSeverity(CompilerOptions.IndirectStaticAccess); + + case IProblem.AssignmentHasNoEffect: + return this.options.getSeverity(CompilerOptions.NoEffectAssignment); + + case IProblem.UnusedPrivateConstructor: + case IProblem.UnusedPrivateMethod: + case IProblem.UnusedPrivateField: + case IProblem.UnusedPrivateType: + return this.options + .getSeverity(CompilerOptions.UnusedPrivateMember); + + case IProblem.Task: + return Warning; + + // case IProblem.LocalVariableHidingLocalVariable: + // case IProblem.LocalVariableHidingField: + // case IProblem.ArgumentHidingLocalVariable: + // case IProblem.ArgumentHidingField: + // return + // this.options.getSeverity(CompilerOptions.LocalVariableHiding); + + // case IProblem.FieldHidingLocalVariable: + // case IProblem.FieldHidingField: + // return this.options.getSeverity(CompilerOptions.FieldHiding); + + // case IProblem.PossibleAccidentalBooleanAssignment: + // return + // this.options.getSeverity(CompilerOptions.AccidentalBooleanAssign); + + // case IProblem.SuperfluousSemicolon: + // return + // this.options.getSeverity(CompilerOptions.SuperfluousSemicolon); + // + // case IProblem.UndocumentedEmptyBlock: + // return + // this.options.getSeverity(CompilerOptions.UndocumentedEmptyBlock); + // + // case IProblem.UnnecessaryCast: + // case IProblem.UnnecessaryArgumentCast: + // case IProblem.UnnecessaryInstanceof: + // return + // this.options.getSeverity(CompilerOptions.UnnecessaryTypeCheck); + // + // case IProblem.FinallyMustCompleteNormally: + // return + // this.options.getSeverity(CompilerOptions.FinallyBlockNotCompleting); + // + // case IProblem.UnusedMethodDeclaredThrownException: + // case IProblem.UnusedConstructorDeclaredThrownException: + // return + // this.options.getSeverity(CompilerOptions.UnusedDeclaredThrownException); + // + // case IProblem.UnqualifiedFieldAccess: + // return + // this.options.getSeverity(CompilerOptions.UnqualifiedFieldAccess); + + /* + * Javadoc syntax errors + */ + // Javadoc explicit IDs + // case IProblem.JavadocUnexpectedTag: + // case IProblem.JavadocDuplicateReturnTag: + // case IProblem.JavadocInvalidThrowsClass: + // case IProblem.JavadocInvalidSeeReference: + // case IProblem.JavadocInvalidSeeHref: + // case IProblem.JavadocInvalidSeeArgs: + // case IProblem.JavadocInvalidTag: + // return this.options.getSeverity(CompilerOptions.InvalidJavadoc); + /* + * Javadoc tags resolved references errors + */ + // case IProblem.JavadocInvalidParamName: + // case IProblem.JavadocDuplicateParamName: + // case IProblem.JavadocMissingParamName: + // case IProblem.JavadocInvalidThrowsClassName: + // case IProblem.JavadocDuplicateThrowsClassName: + // case IProblem.JavadocMissingThrowsClassName: + // case IProblem.JavadocMissingSeeReference: + // case IProblem.JavadocUsingDeprecatedField: + // case IProblem.JavadocUsingDeprecatedConstructor: + // case IProblem.JavadocUsingDeprecatedMethod: + // case IProblem.JavadocUsingDeprecatedType: + // case IProblem.JavadocUndefinedField: + // case IProblem.JavadocNotVisibleField: + // case IProblem.JavadocAmbiguousField: + // case IProblem.JavadocUndefinedConstructor: + // case IProblem.JavadocNotVisibleConstructor: + // case IProblem.JavadocAmbiguousConstructor: + // case IProblem.JavadocUndefinedMethod: + // case IProblem.JavadocNotVisibleMethod: + // case IProblem.JavadocAmbiguousMethod: + // case IProblem.JavadocParameterMismatch: + // case IProblem.JavadocUndefinedType: + // case IProblem.JavadocNotVisibleType: + // case IProblem.JavadocAmbiguousType: + // case IProblem.JavadocInternalTypeNameProvided: + // case IProblem.JavadocNoMessageSendOnArrayType: + // case IProblem.JavadocNoMessageSendOnBaseType: + // if (!this.options.reportInvalidJavadocTags) + // return ProblemSeverities.Ignore; + // else + // return this.options.getSeverity(CompilerOptions.InvalidJavadoc); + /* + * Javadoc missing tags errors + */ + // case IProblem.JavadocMissingParamTag: + // case IProblem.JavadocMissingReturnTag: + // case IProblem.JavadocMissingThrowsTag: + // return + // this.options.getSeverity(CompilerOptions.MissingJavadocTags); + /* + * Missing Javadoc errors + */ + // case IProblem.JavadocMissing: + // return + // this.options.getSeverity(CompilerOptions.MissingJavadocComments); + // by default problems are errors. + default: + return Error; + } + } + + // public void conditionalArgumentsIncompatibleTypes(ConditionalExpression // expression, TypeBinding trueType, TypeBinding falseType) { - // this.handle( - // IProblem.IncompatibleTypesInConditionalOperator, - // new String[] {new String(trueType.readableName()), new + // this.handle( + // IProblem.IncompatibleTypesInConditionalOperator, + // new String[] {new String(trueType.readableName()), new // String(falseType.readableName())}, - // new String[] {new String(trueType.sourceName()), new + // new String[] {new String(trueType.sourceName()), new // String(falseType.sourceName())}, - // expression.sourceStart, - // expression.sourceEnd); - //} - public void conflictingImport(ImportReference importRef) { - String[] arguments = new String[]{CharOperation - .toString(importRef.tokens)}; - this.handle(IProblem.ConflictingImport, arguments, arguments, - importRef.sourceStart, importRef.sourceEnd); - } + // expression.sourceStart, + // expression.sourceEnd); + // } + // public void conflictingImport(ImportReference importRef) { + // String[] arguments = new + // String[]{CharOperation.toString(importRef.tokens)}; + // this.handle(IProblem.ConflictingImport, arguments, arguments, + // importRef.sourceStart, importRef.sourceEnd); + // } public void constantOutOfFormat(NumberLiteral lit) { // the literal is not in a correct format // this code is called on IntLiteral and LongLiteral @@ -616,17 +655,18 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { radix = 8; Radix = "Octal"; //$NON-NLS-1$ } - //look for the first digit that is incorrect + // look for the first digit that is incorrect int place = -1; - label : for (int i = radix == 8 ? 1 : 2; i < source.length; i++) { + label: for (int i = radix == 8 ? 1 : 2; i < source.length; i++) { if (Character.digit(source[i], radix) == -1) { place = i; break label; } } - String[] arguments = new String[]{Radix + " " - + new String(source) + " (digit " - + new String(new char[]{source[place]}) + ")"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + 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, arguments, arguments, lit.sourceStart, lit.sourceEnd); return; @@ -637,90 +677,102 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { this.constantOutOfRange(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())}; + String[] arguments = new String[] { new String(lit.source()) }; this.handle(IProblem.NumericValueOutOfRange, arguments, arguments, lit.sourceStart, lit.sourceEnd); } - public void deprecatedField(FieldBinding field, AstNode location) { - this.handle(IProblem.UsingDeprecatedField, new String[]{ + + 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.name) }, new String[] { new String(field.declaringClass.shortReadableName()), - new String(field.name)}, location.sourceStart, + new String(field.name) }, location.sourceStart, location.sourceEnd); } - public void deprecatedMethod(MethodBinding method, AstNode location) { + + public void deprecatedMethod(MethodBinding method, ASTNode location) { if (method.isConstructor()) - this.handle(IProblem.UsingDeprecatedConstructor, new String[]{ + this.handle(IProblem.UsingDeprecatedConstructor, new String[] { new String(method.declaringClass.readableName()), - parametersAsString(method)}, new String[]{ + parametersAsString(method) }, new String[] { new String(method.declaringClass.shortReadableName()), - parametersAsShortString(method)}, location.sourceStart, + parametersAsShortString(method) }, location.sourceStart, location.sourceEnd); else - this.handle(IProblem.UsingDeprecatedMethod, new String[]{ + this.handle(IProblem.UsingDeprecatedMethod, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass .shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, + parametersAsShortString(method) }, location.sourceStart, location.sourceEnd); } - public void deprecatedType(TypeBinding type, AstNode location) { + + public void deprecatedType(TypeBinding type, ASTNode location) { if (location == null) return; // 1G828DN - no type ref for synthetic arguments - this.handle(IProblem.UsingDeprecatedType, new String[]{new String(type - .readableName())}, new String[]{new String(type - .shortReadableName())}, location.sourceStart, + 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())}; + + public void duplicateCase(CaseStatement statement, Constant constant) { + String[] arguments = new String[] { String.valueOf(constant.intValue()) }; this.handle(IProblem.DuplicateCase, arguments, arguments, statement.sourceStart, statement.sourceEnd); } + public void duplicateDefaultCase(DefaultCase statement) { this.handle(IProblem.DuplicateDefaultCase, NoArgument, NoArgument, statement.sourceStart, statement.sourceEnd); } + public void duplicateFieldInType(SourceTypeBinding type, FieldDeclaration fieldDecl) { - this.handle(IProblem.DuplicateField, new String[]{ - new String(type.sourceName()), 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, arguments, arguments, - importRef.sourceStart, importRef.sourceEnd); + 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, arguments, arguments, + // importRef.sourceStart, importRef.sourceEnd); + // } public void duplicateInitializationOfBlankFinalField(FieldBinding field, Reference reference) { - String[] arguments = new String[]{new String(field.readableName())}; + String[] arguments = new String[] { new String(field.readableName()) }; this.handle(IProblem.DuplicateBlankFinalFieldInitialization, arguments, arguments, reference.sourceStart, reference.sourceEnd); } + public void duplicateInitializationOfFinalLocal(LocalVariableBinding local, - AstNode location) { - String[] arguments = new String[]{new String(local.readableName())}; + ASTNode location) { + String[] arguments = new String[] { new String(local.readableName()) }; this.handle(IProblem.DuplicateFinalLocalInitialization, arguments, arguments, location.sourceStart, location.sourceEnd); } + public void duplicateMethodInType(SourceTypeBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(methodDecl.selector), - new String(type.sourceName())}; + String[] arguments = new String[] { new String(methodDecl.selector), + new String(type.sourceName()) }; this.handle(IProblem.DuplicateMethod, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void duplicateModifierForField(ReferenceBinding type, FieldDeclaration fieldDecl) { /* @@ -728,58 +780,64 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { * DuplicateModifierForField, new String[] {fieldDecl.name()}, * fieldDecl.modifiers.sourceStart, fieldDecl.modifiers.sourceEnd)); */ - String[] arguments = new String[]{fieldDecl.name()}; + String[] arguments = new String[] { fieldDecl.name() }; this.handle(IProblem.DuplicateModifierForField, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void duplicateModifierForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) { this.handle(IProblem.DuplicateModifierForMethod, - new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}, new String[]{ + new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }, new String[] { new String(type.shortReadableName()), - new String(methodDecl.selector)}, + new String(methodDecl.selector) }, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void duplicateModifierForType(SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.DuplicateModifierForType, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void duplicateModifierForVariable(LocalDeclaration localDecl, boolean complainForArgument) { - String[] arguments = new String[]{localDecl.name()}; - this.handle(complainForArgument - ? IProblem.DuplicateModifierForArgument + String[] arguments = new String[] { localDecl.name() }; + this.handle(complainForArgument ? IProblem.DuplicateModifierForArgument : IProblem.DuplicateModifierForVariable, arguments, arguments, localDecl.sourceStart, localDecl.sourceEnd); } + public void duplicateNestedType(TypeDeclaration typeDecl) { - String[] arguments = new String[]{new String(typeDecl.name)}; + String[] arguments = new String[] { new String(typeDecl.name) }; this.handle(IProblem.DuplicateNestedType, arguments, arguments, typeDecl.sourceStart, typeDecl.sourceEnd); } + public void duplicateSuperinterface(SourceTypeBinding type, TypeDeclaration typeDecl, ReferenceBinding superType) { - this.handle(IProblem.DuplicateSuperInterface, new String[]{ + this.handle(IProblem.DuplicateSuperInterface, new String[] { new String(superType.readableName()), - new String(type.sourceName())}, new String[]{ + new String(type.sourceName()) }, new String[] { new String(superType.shortReadableName()), - new String(type.sourceName())}, typeDecl.sourceStart, + new String(type.sourceName()) }, typeDecl.sourceStart, typeDecl.sourceEnd); } + public void duplicateTypes(CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) { - String[] arguments = new String[]{ + String[] arguments = new String[] { new String(compUnitDecl.getFileName()), - new String(typeDecl.name)}; + new String(typeDecl.name) }; this.referenceContext = typeDecl; // report the problem against the - // type not the entire compilation - // unit + // type not the entire compilation + // unit this.handle(IProblem.DuplicateTypes, arguments, arguments, typeDecl.sourceStart, typeDecl.sourceEnd, compUnitDecl.compilationResult); } + public void errorNoMethodFor(MessageSend messageSend, TypeBinding recType, TypeBinding[] params) { StringBuffer buffer = new StringBuffer(); @@ -792,125 +850,130 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { buffer.append(new String(params[i].readableName())); shortBuffer.append(new String(params[i].shortReadableName())); } - this.handle(recType.isArrayType() - ? IProblem.NoMessageSendOnArrayType - : IProblem.NoMessageSendOnBaseType, new String[]{ + 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), buffer.toString() }, + new String[] { new String(recType.shortReadableName()), new String(messageSend.selector), - shortBuffer.toString()}, messageSend.sourceStart, + 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$ + + public void errorThisSuperInStatic(ASTNode reference) { + String[] arguments = new String[] { reference.isSuper() ? "super" : "this" }; //$NON-NLS-2$ //$NON-NLS-1$ this.handle(IProblem.ThisInStaticContext, arguments, arguments, reference.sourceStart, reference.sourceEnd); } + public void exceptionTypeProblem(SourceTypeBinding type, AbstractMethodDeclaration methodDecl, TypeReference exceptionType, TypeBinding expectedType) { int problemId = expectedType.problemId(); int id; switch (problemId) { - case NotFound : - // 1 - id = IProblem.ExceptionTypeNotFound; - break; - case NotVisible : - // 2 - id = IProblem.ExceptionTypeNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.ExceptionTypeAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.ExceptionTypeInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.ExceptionTypeInheritedNameHidesEnclosingName; - break; - case NoError : + case NotFound: + // 1 + id = IProblem.ExceptionTypeNotFound; + break; + case NotVisible: + // 2 + id = IProblem.ExceptionTypeNotVisible; + break; + case Ambiguous: + // 3 + id = IProblem.ExceptionTypeAmbiguous; + break; + case InternalNameProvided: + // 4 + id = IProblem.ExceptionTypeInternalNameProvided; + break; + case InheritedNameHidesEnclosingName: + // 5 + id = IProblem.ExceptionTypeInheritedNameHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; + default: + needImplementation(); // want to fail to see why we were + // here... + return; } - this.handle(id, new String[]{new String(methodDecl.selector), - new String(expectedType.readableName())}, new String[]{ + this.handle(id, new String[] { new String(methodDecl.selector), + new String(expectedType.readableName()) }, new String[] { new String(methodDecl.selector), - new String(expectedType.shortReadableName())}, + 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, NoArgument, NoArgument, reference.sourceStart, reference.sourceEnd); } + public void fieldTypeProblem(SourceTypeBinding type, FieldDeclaration fieldDecl, TypeBinding expectedType) { int problemId = expectedType.problemId(); int id; switch (problemId) { - case NotFound : - // 1 - id = IProblem.FieldTypeNotFound; - break; - case NotVisible : - // 2 - id = IProblem.FieldTypeNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.FieldTypeAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.FieldTypeInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.FieldTypeInheritedNameHidesEnclosingName; - break; - case NoError : + case NotFound: + // 1 + id = IProblem.FieldTypeNotFound; + break; + case NotVisible: + // 2 + id = IProblem.FieldTypeNotVisible; + break; + case Ambiguous: + // 3 + id = IProblem.FieldTypeAmbiguous; + break; + case InternalNameProvided: + // 4 + id = IProblem.FieldTypeInternalNameProvided; + break; + case InheritedNameHidesEnclosingName: + // 5 + id = IProblem.FieldTypeInheritedNameHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; + default: + needImplementation(); // want to fail to see why we were + // here... + return; } - this.handle(id, new String[]{fieldDecl.name(), + this.handle(id, new String[] { fieldDecl.name(), new String(type.sourceName()), - new String(expectedType.readableName())}, new String[]{ + new String(expectedType.readableName()) }, new String[] { fieldDecl.name(), new String(type.sourceName()), - new String(expectedType.shortReadableName())}, + new String(expectedType.shortReadableName()) }, fieldDecl.type.sourceStart, fieldDecl.type.sourceEnd); } + public void finalMethodCannotBeOverridden(MethodBinding currentMethod, MethodBinding inheritedMethod) { this.handle( - // Cannot override the final method from %1 + // Cannot override the final method from %1 // 8.4.3.3 - Final methods cannot be overridden or hidden. IProblem.FinalMethodCannotBeOverridden, - new String[]{new String(inheritedMethod.declaringClass - .readableName())}, new String[]{new String( - inheritedMethod.declaringClass.shortReadableName())}, + new String[] { new String(inheritedMethod.declaringClass + .readableName()) }, new String[] { new String( + inheritedMethod.declaringClass.shortReadableName()) }, currentMethod.sourceStart(), currentMethod.sourceEnd()); } + public void forwardReference(Reference reference, int indexInQualification, TypeBinding type) { this.handle(IProblem.ReferenceToForwardField, NoArgument, NoArgument, reference.sourceStart, reference.sourceEnd); } + // use this private API when the compilation unit result can be found // through the // reference context. Otherwise, use the other API taking a problem and a @@ -925,6 +988,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .compilationResult()); referenceContext = null; } + // use this private API when the compilation unit result can be found // through the // reference context. Otherwise, use the other API taking a problem and a @@ -939,6 +1003,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .compilationResult()); referenceContext = null; } + // use this private API when the compilation unit result cannot be found // through the // reference context. @@ -950,11 +1015,13 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { unitResult); referenceContext = null; } + public void hidingEnclosingType(TypeDeclaration typeDecl) { - String[] arguments = new String[]{new String(typeDecl.name)}; + String[] arguments = new String[] { new String(typeDecl.name) }; this.handle(IProblem.HidingEnclosingType, arguments, arguments, typeDecl.sourceStart, typeDecl.sourceEnd); } + public void hierarchyCircularity(SourceTypeBinding sourceType, ReferenceBinding superType, TypeReference reference) { int start = 0; @@ -962,7 +1029,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { String typeName = ""; //$NON-NLS-1$ String shortTypeName = ""; //$NON-NLS-1$ if (reference == null) { // can only happen when java.lang.Object is - // busted + // busted start = sourceType.sourceStart(); end = sourceType.sourceEnd(); typeName = new String(superType.readableName()); @@ -975,188 +1042,209 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { 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); + 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); + 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())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.HierarchyHasProblems, arguments, arguments, type .sourceStart(), type.sourceEnd()); } + public void illegalAbstractModifierCombinationForMethod( ReferenceBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.IllegalAbstractModifierCombinationForMethod, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void illegalModifierCombinationFinalAbstractForClass( SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalModifierCombinationFinalAbstractForClass, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalModifierCombinationFinalVolatileForField( ReferenceBinding type, FieldDeclaration fieldDecl) { - String[] arguments = new String[]{fieldDecl.name()}; + String[] arguments = new String[] { fieldDecl.name() }; this.handle(IProblem.IllegalModifierCombinationFinalVolatileForField, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void illegalModifierForClass(SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalModifierForClass, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalModifierForField(ReferenceBinding type, FieldDeclaration fieldDecl) { - String[] arguments = new String[]{fieldDecl.name()}; + String[] arguments = new String[] { fieldDecl.name() }; this.handle(IProblem.IllegalModifierForField, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void illegalModifierForInterface(SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalModifierForInterface, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalModifierForInterfaceField(ReferenceBinding type, FieldDeclaration fieldDecl) { - String[] arguments = new String[]{fieldDecl.name()}; + String[] arguments = new String[] { fieldDecl.name() }; this.handle(IProblem.IllegalModifierForInterfaceField, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void illegalModifierForInterfaceMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.IllegalModifierForInterfaceMethod, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void illegalModifierForLocalClass(SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalModifierForLocalClass, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalModifierForMemberClass(SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalModifierForMemberClass, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalModifierForMemberInterface(SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalModifierForMemberInterface, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalModifierForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.IllegalModifierForMethod, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void illegalModifierForVariable(LocalDeclaration localDecl, boolean complainAsArgument) { - String[] arguments = new String[]{localDecl.name()}; - this.handle(complainAsArgument - ? IProblem.IllegalModifierForArgument + String[] arguments = new String[] { localDecl.name() }; + this.handle(complainAsArgument ? IProblem.IllegalModifierForArgument : IProblem.IllegalModifierForVariable, arguments, arguments, localDecl.sourceStart, localDecl.sourceEnd); } + public void illegalPrimitiveOrArrayTypeForEnclosingInstance( - TypeBinding enclosingType, AstNode location) { + TypeBinding enclosingType, ASTNode location) { this.handle(IProblem.IllegalPrimitiveOrArrayTypeForEnclosingInstance, - new String[]{new String(enclosingType.readableName())}, - new String[]{new String(enclosingType.shortReadableName())}, + 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())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalStaticModifierForMemberType, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalVisibilityModifierCombinationForField( ReferenceBinding type, FieldDeclaration fieldDecl) { - String[] arguments = new String[]{new String(fieldDecl.name())}; + String[] arguments = new String[] { new String(fieldDecl.name()) }; this.handle(IProblem.IllegalVisibilityModifierCombinationForField, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void illegalVisibilityModifierCombinationForMemberType( SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalVisibilityModifierCombinationForMemberType, arguments, arguments, type.sourceStart(), type.sourceEnd()); } + public void illegalVisibilityModifierCombinationForMethod( ReferenceBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.IllegalVisibilityModifierCombinationForMethod, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void illegalVisibilityModifierForInterfaceMemberType( SourceTypeBinding type) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.IllegalVisibilityModifierForInterfaceMemberType, arguments, arguments, type.sourceStart(), type.sourceEnd()); } - public void illegalVoidExpression(AstNode location) { + + public void illegalVoidExpression(ASTNode location) { this.handle(IProblem.InvalidVoidExpression, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } - public void importProblem(ImportReference importRef, Binding expectedImport) { - int problemId = expectedImport.problemId(); - int id; - switch (problemId) { - case NotFound : - // 1 - id = IProblem.ImportNotFound; - break; - case NotVisible : - // 2 - id = IProblem.ImportNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.ImportAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.ImportInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.ImportInheritedNameHidesEnclosingName; - break; - case NoError : - // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; - } - String argument; - if (expectedImport instanceof ProblemReferenceBinding) { - argument = CharOperation - .toString(((ProblemReferenceBinding) expectedImport).compoundName); - } else { - argument = CharOperation.toString(importRef.tokens); - } - String[] arguments = new String[]{argument}; - this.handle(id, arguments, arguments, importRef.sourceStart, - importRef.sourceEnd); - } + + // public void importProblem(ImportReference importRef, Binding + // expectedImport) { + // int problemId = expectedImport.problemId(); + // int id; + // switch (problemId) { + // case NotFound : + // // 1 + // id = IProblem.ImportNotFound; + // break; + // case NotVisible : + // // 2 + // id = IProblem.ImportNotVisible; + // break; + // case Ambiguous : + // // 3 + // id = IProblem.ImportAmbiguous; + // break; + // case InternalNameProvided : + // // 4 + // id = IProblem.ImportInternalNameProvided; + // break; + // case InheritedNameHidesEnclosingName : + // // 5 + // id = IProblem.ImportInheritedNameHidesEnclosingName; + // break; + // case NoError : + // // 0 + // default : + // needImplementation(); // want to fail to see why we were + // // here... + // return; + // } + // String argument; + // if (expectedImport instanceof ProblemReferenceBinding) { + // argument = CharOperation + // .toString(((ProblemReferenceBinding) expectedImport).compoundName); + // } else { + // argument = CharOperation.toString(importRef.tokens); + // } + // 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) { @@ -1164,8 +1252,8 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { int id; if (currentMethod.declaringClass.isInterface() && !inheritedMethod.isPublic()) { // interface inheriting - // Object protected - // method + // Object protected + // method id = IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod; } else { id = IProblem.IncompatibleExceptionInThrowsClause; @@ -1177,7 +1265,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { // 9.4.4 - The type of exception in the throws // clause is incompatible. id, - new String[]{ + new String[] { new String(exceptionType.sourceName()), new String( CharOperation @@ -1186,8 +1274,8 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .readableName(), inheritedMethod .readableName(), - '.'))}, - new String[]{ + '.')) }, + new String[] { new String(exceptionType.sourceName()), new String( CharOperation @@ -1196,7 +1284,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .shortReadableName(), inheritedMethod .shortReadableName(), - '.'))}, + '.')) }, currentMethod.sourceStart(), currentMethod .sourceEnd()); } else @@ -1207,7 +1295,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { // 9.4.4 - The type of exception in the throws // clause is incompatible. IProblem.IncompatibleExceptionInInheritedMethodThrowsClause, - new String[]{ + new String[] { new String(exceptionType.sourceName()), new String(CharOperation.concat( currentMethod.declaringClass @@ -1220,8 +1308,8 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .readableName(), inheritedMethod .readableName(), - '.'))}, - new String[]{ + '.')) }, + new String[] { new String(exceptionType.sourceName()), new String(CharOperation.concat( currentMethod.declaringClass @@ -1235,9 +1323,10 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .shortReadableName(), inheritedMethod .shortReadableName(), - '.'))}, type + '.')) }, type .sourceStart(), type.sourceEnd()); } + public void incompatibleReturnType(MethodBinding currentMethod, MethodBinding inheritedMethod) { StringBuffer methodSignature = new StringBuffer(); @@ -1250,27 +1339,30 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { int id; if (currentMethod.declaringClass.isInterface() && !inheritedMethod.isPublic()) { // interface inheriting - // Object protected method + // Object protected method id = IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod; } else { id = IProblem.IncompatibleReturnType; } - this.handle(id, new String[]{methodSignature.toString()}, - new String[]{shortSignature.toString()}, currentMethod + this.handle(id, new String[] { methodSignature.toString() }, + new String[] { shortSignature.toString() }, currentMethod .sourceStart(), currentMethod.sourceEnd()); } + public void incorrectLocationForEmptyDimension( ArrayAllocationExpression expression, int index) { this.handle(IProblem.IllegalDimension, NoArgument, NoArgument, expression.dimensions[index + 1].sourceStart, expression.dimensions[index + 1].sourceEnd); } + public void incorrectSwitchType(Expression expression, TypeBinding testType) { - this.handle(IProblem.IncorrectSwitchType, new String[]{new String( - testType.readableName())}, new String[]{new String(testType - .shortReadableName())}, expression.sourceStart, + this.handle(IProblem.IncorrectSwitchType, new String[] { new String( + testType.readableName()) }, new String[] { new String(testType + .shortReadableName()) }, expression.sourceStart, expression.sourceEnd); } + public void inheritedMethodReducesVisibility(SourceTypeBinding type, MethodBinding concreteMethod, MethodBinding[] abstractMethods) { StringBuffer concreteSignature = new StringBuffer(); @@ -1281,16 +1373,18 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .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[]{ + // 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[]{ + .readableName()) }, new String[] { new String(shortSignature.toString()), new String(abstractMethods[0].declaringClass - .shortReadableName())}, type.sourceStart(), + .shortReadableName()) }, type.sourceStart(), type.sourceEnd()); } + public void inheritedMethodsHaveIncompatibleReturnTypes( SourceTypeBinding type, MethodBinding[] inheritedMethods, int length) { StringBuffer methodSignatures = new StringBuffer(); @@ -1309,40 +1403,47 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { } } this.handle( - // Return type is incompatible with %1 + // Return type is incompatible with %1 // 9.4.2 - The return type from the method is incompatible with // the declaration. - IProblem.IncompatibleReturnType, new String[]{methodSignatures - .toString()}, new String[]{shortSignatures.toString()}, + IProblem.IncompatibleReturnType, + new String[] { methodSignatures.toString() }, + new String[] { shortSignatures.toString() }, type.sourceStart(), type.sourceEnd()); } + public void initializerMustCompleteNormally(FieldDeclaration fieldDecl) { this.handle(IProblem.InitializerMustCompleteNormally, NoArgument, NoArgument, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void innerTypesCannotDeclareStaticInitializers( - ReferenceBinding innerType, AstNode location) { + ReferenceBinding innerType, ASTNode location) { this.handle(IProblem.CannotDefineStaticInitializerInLocalType, - new String[]{new String(innerType.readableName())}, - new String[]{new String(innerType.shortReadableName())}, + new String[] { new String(innerType.readableName()) }, + new String[] { new String(innerType.shortReadableName()) }, location.sourceStart, location.sourceEnd); } + public void interfaceCannotHaveConstructors( ConstructorDeclaration constructor) { this.handle(IProblem.InterfaceCannotHaveConstructors, NoArgument, NoArgument, constructor.sourceStart, constructor.sourceEnd, constructor, constructor.compilationResult()); } + public void interfaceCannotHaveInitializers(SourceTypeBinding type, FieldDeclaration fieldDecl) { - String[] arguments = new String[]{new String(type.sourceName())}; + String[] arguments = new String[] { new String(type.sourceName()) }; this.handle(IProblem.InterfaceCannotHaveInitializers, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } - public void invalidBreak(AstNode location) { + + public void invalidBreak(ASTNode location) { this.handle(IProblem.InvalidBreak, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } + public void invalidConstructor(Statement statement, MethodBinding targetConstructor) { boolean insideDefaultConstructor = (referenceContext instanceof ConstructorDeclaration) @@ -1350,291 +1451,297 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .isDefaultConstructor(); boolean insideImplicitConstructorCall = (statement instanceof ExplicitConstructorCall) && (((ExplicitConstructorCall) statement).accessMode == ExplicitConstructorCall.ImplicitSuper); - int flag = IProblem.UndefinedConstructor; //default... + int flag = IProblem.UndefinedConstructor; // default... switch (targetConstructor.problemId()) { - case NotFound : - if (insideDefaultConstructor) { - flag = IProblem.UndefinedConstructorInDefaultConstructor; - } else if (insideImplicitConstructorCall) { - flag = IProblem.UndefinedConstructorInImplicitConstructorCall; - } else { - flag = IProblem.UndefinedConstructor; - } - break; - case NotVisible : - if (insideDefaultConstructor) { - flag = IProblem.NotVisibleConstructorInDefaultConstructor; - } else if (insideImplicitConstructorCall) { - flag = IProblem.NotVisibleConstructorInImplicitConstructorCall; - } else { - flag = IProblem.NotVisibleConstructor; - } - break; - case Ambiguous : - if (insideDefaultConstructor) { - flag = IProblem.AmbiguousConstructorInDefaultConstructor; - } else if (insideImplicitConstructorCall) { - flag = IProblem.AmbiguousConstructorInImplicitConstructorCall; - } else { - flag = IProblem.AmbiguousConstructor; - } - break; - case NoError : + case NotFound: + if (insideDefaultConstructor) { + flag = IProblem.UndefinedConstructorInDefaultConstructor; + } else if (insideImplicitConstructorCall) { + flag = IProblem.UndefinedConstructorInImplicitConstructorCall; + } else { + flag = IProblem.UndefinedConstructor; + } + break; + case NotVisible: + if (insideDefaultConstructor) { + flag = IProblem.NotVisibleConstructorInDefaultConstructor; + } else if (insideImplicitConstructorCall) { + flag = IProblem.NotVisibleConstructorInImplicitConstructorCall; + } else { + flag = IProblem.NotVisibleConstructor; + } + break; + case Ambiguous: + if (insideDefaultConstructor) { + flag = IProblem.AmbiguousConstructorInDefaultConstructor; + } else if (insideImplicitConstructorCall) { + flag = IProblem.AmbiguousConstructorInImplicitConstructorCall; + } else { + flag = IProblem.AmbiguousConstructor; + } + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - break; + default: + needImplementation(); // want to fail to see why we were + // here... + break; } - this.handle(flag, new String[]{ + this.handle(flag, new String[] { new String(targetConstructor.declaringClass.readableName()), - parametersAsString(targetConstructor)}, - new String[]{ + parametersAsString(targetConstructor) }, + new String[] { new String(targetConstructor.declaringClass .shortReadableName()), - parametersAsShortString(targetConstructor)}, + parametersAsShortString(targetConstructor) }, statement.sourceStart, statement.sourceEnd); } - public void invalidContinue(AstNode location) { + + public void invalidContinue(ASTNode location) { this.handle(IProblem.InvalidContinue, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } + public void invalidEnclosingType(Expression expression, TypeBinding type, ReferenceBinding enclosingType) { if (enclosingType.isAnonymousType()) enclosingType = enclosingType.superclass(); int flag = IProblem.UndefinedType; // default switch (type.problemId()) { - case NotFound : - // 1 - flag = IProblem.UndefinedType; - break; - case NotVisible : - // 2 - flag = IProblem.NotVisibleType; - break; - case Ambiguous : - // 3 - flag = IProblem.AmbiguousType; - break; - case InternalNameProvided : - flag = IProblem.InternalTypeNameProvided; - break; - case NoError : + case NotFound: + // 1 + flag = IProblem.UndefinedType; + break; + case NotVisible: + // 2 + flag = IProblem.NotVisibleType; + break; + case Ambiguous: + // 3 + flag = IProblem.AmbiguousType; + break; + case InternalNameProvided: + flag = IProblem.InternalTypeNameProvided; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - break; + default: + needImplementation(); // want to fail to see why we were + // here... + break; } - this.handle(flag, new String[]{new String(enclosingType.readableName()) - + "." + new String(type.readableName())}, //$NON-NLS-1$ - new String[]{new String(enclosingType.shortReadableName()) - + "." + new String(type.shortReadableName())}, //$NON-NLS-1$ + this.handle(flag, new String[] { new String(enclosingType + .readableName()) + + "." + new String(type.readableName()) }, //$NON-NLS-1$ + new String[] { new String(enclosingType.shortReadableName()) + + "." + new String(type.shortReadableName()) }, //$NON-NLS-1$ expression.sourceStart, expression.sourceEnd); } + public void invalidExpressionAsStatement(Expression expression) { this.handle(IProblem.InvalidExpressionAsStatement, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void invalidField(FieldReference fieldRef, TypeBinding searchedType) { int severity = Error; int flag = IProblem.UndefinedField; FieldBinding field = fieldRef.binding; switch (field.problemId()) { - case NotFound : - flag = IProblem.UndefinedField; - /* - * also need to check that the searchedType is the receiver - * type if (searchedType.isHierarchyInconsistent()) severity = - * SecondaryError; - */ - break; - case NotVisible : - flag = IProblem.NotVisibleField; - break; - case Ambiguous : - flag = IProblem.AmbiguousField; - break; - case NonStaticReferenceInStaticContext : - flag = IProblem.NonStaticFieldFromStaticInvocation; - break; - case NonStaticReferenceInConstructorInvocation : - flag = IProblem.InstanceFieldDuringConstructorInvocation; - break; - 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 : + case NotFound: + flag = IProblem.UndefinedField; + /* + * also need to check that the searchedType is the receiver type if + * (searchedType.isHierarchyInconsistent()) severity = + * SecondaryError; + */ + break; + case NotVisible: + flag = IProblem.NotVisibleField; + break; + case Ambiguous: + flag = IProblem.AmbiguousField; + break; + case NonStaticReferenceInStaticContext: + flag = IProblem.NonStaticFieldFromStaticInvocation; + break; + case NonStaticReferenceInConstructorInvocation: + flag = IProblem.InstanceFieldDuringConstructorInvocation; + break; + 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; + default: + needImplementation(); // want to fail to see why we were + // here... + break; } - String[] arguments = new String[]{new String(field.readableName())}; + String[] arguments = new String[] { new String(field.readableName()) }; this.handle(flag, arguments, arguments, severity, fieldRef.sourceStart, fieldRef.sourceEnd); } + public void invalidField(NameReference nameRef, FieldBinding field) { int flag = IProblem.UndefinedField; switch (field.problemId()) { - case NotFound : - flag = IProblem.UndefinedField; - break; - case NotVisible : - flag = IProblem.NotVisibleField; - break; - case Ambiguous : - flag = IProblem.AmbiguousField; - break; - case NonStaticReferenceInStaticContext : - flag = IProblem.NonStaticFieldFromStaticInvocation; - break; - case NonStaticReferenceInConstructorInvocation : - flag = IProblem.InstanceFieldDuringConstructorInvocation; - break; - 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 : + case NotFound: + flag = IProblem.UndefinedField; + break; + case NotVisible: + flag = IProblem.NotVisibleField; + break; + case Ambiguous: + flag = IProblem.AmbiguousField; + break; + case NonStaticReferenceInStaticContext: + flag = IProblem.NonStaticFieldFromStaticInvocation; + break; + case NonStaticReferenceInConstructorInvocation: + flag = IProblem.InstanceFieldDuringConstructorInvocation; + break; + 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; + default: + needImplementation(); // want to fail to see why we were + // here... + break; } - String[] arguments = new String[]{new String(field.readableName())}; + String[] arguments = new String[] { new String(field.readableName()) }; this.handle(flag, arguments, arguments, nameRef.sourceStart, nameRef.sourceEnd); } + public void invalidField(QualifiedNameReference nameRef, FieldBinding field, int index, TypeBinding searchedType) { - //the resolution of the index-th field of qname failed - //qname.otherBindings[index] is the binding that has produced the + // the resolution of the index-th field of qname failed + // qname.otherBindings[index] is the binding that has produced the // error - //The different targetted errors should be : - //UndefinedField - //NotVisibleField - //AmbiguousField + // The different targetted errors should be : + // UndefinedField + // NotVisibleField + // AmbiguousField if (searchedType.isBaseType()) { - this.handle(IProblem.NoFieldOnBaseType, new String[]{ + this.handle(IProblem.NoFieldOnBaseType, new String[] { new String(searchedType.readableName()), CharOperation.toString(CharOperation.subarray( nameRef.tokens, 0, index)), - new String(nameRef.tokens[index])}, new String[]{ + new String(nameRef.tokens[index]) }, new String[] { new String(searchedType.sourceName()), CharOperation.toString(CharOperation.subarray( nameRef.tokens, 0, index)), - new String(nameRef.tokens[index])}, nameRef.sourceStart, + new String(nameRef.tokens[index]) }, nameRef.sourceStart, nameRef.sourceEnd); return; } int flag = IProblem.UndefinedField; switch (field.problemId()) { - case NotFound : - flag = IProblem.UndefinedField; - /* - * also need to check that the searchedType is the receiver - * type if (searchedType.isHierarchyInconsistent()) severity = - * SecondaryError; - */ - break; - case NotVisible : - flag = IProblem.NotVisibleField; - break; - case Ambiguous : - flag = IProblem.AmbiguousField; - break; - case NonStaticReferenceInStaticContext : - flag = IProblem.NonStaticFieldFromStaticInvocation; - break; - case NonStaticReferenceInConstructorInvocation : - flag = IProblem.InstanceFieldDuringConstructorInvocation; - break; - 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 : + case NotFound: + flag = IProblem.UndefinedField; + /* + * also need to check that the searchedType is the receiver type if + * (searchedType.isHierarchyInconsistent()) severity = + * SecondaryError; + */ + break; + case NotVisible: + flag = IProblem.NotVisibleField; + break; + case Ambiguous: + flag = IProblem.AmbiguousField; + break; + case NonStaticReferenceInStaticContext: + flag = IProblem.NonStaticFieldFromStaticInvocation; + break; + case NonStaticReferenceInConstructorInvocation: + flag = IProblem.InstanceFieldDuringConstructorInvocation; + break; + 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; + 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))}; + String[] arguments = new String[] { CharOperation + .toString(CharOperation.subarray(nameRef.tokens, 0, index + 1)) }; this.handle(flag, arguments, arguments, nameRef.sourceStart, nameRef.sourceEnd); } + public void invalidMethod(MessageSend messageSend, MethodBinding method) { // CODE should be UPDATED according to error coding in the different // method binding errors // The different targetted errors should be : - // UndefinedMethod - // NotVisibleMethod - // AmbiguousMethod - // InheritedNameHidesEnclosingName - // InstanceMethodDuringConstructorInvocation + // UndefinedMethod + // NotVisibleMethod + // AmbiguousMethod + // InheritedNameHidesEnclosingName + // InstanceMethodDuringConstructorInvocation // StaticMethodRequested - int flag = IProblem.UndefinedMethod; //default... + int flag = IProblem.UndefinedMethod; // default... switch (method.problemId()) { - case NotFound : - flag = IProblem.UndefinedMethod; - break; - case NotVisible : - flag = IProblem.NotVisibleMethod; - break; - case Ambiguous : - flag = IProblem.AmbiguousMethod; - break; - case InheritedNameHidesEnclosingName : - flag = IProblem.InheritedMethodHidesEnclosingName; - break; - case NonStaticReferenceInConstructorInvocation : - flag = IProblem.InstanceMethodDuringConstructorInvocation; - break; - 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 : + case NotFound: + flag = IProblem.UndefinedMethod; + break; + case NotVisible: + flag = IProblem.NotVisibleMethod; + break; + case Ambiguous: + flag = IProblem.AmbiguousMethod; + break; + case InheritedNameHidesEnclosingName: + flag = IProblem.InheritedMethodHidesEnclosingName; + break; + case NonStaticReferenceInConstructorInvocation: + flag = IProblem.InstanceMethodDuringConstructorInvocation; + break; + 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... - break; + default: + needImplementation(); // want to fail to see why we were + // here... + break; } if (flag == IProblem.UndefinedMethod) { ProblemMethodBinding problemMethod = (ProblemMethodBinding) method; @@ -1651,41 +1758,43 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { this .handle( IProblem.ParameterMismatch, - new String[]{ + new String[] { new String( problemMethod.closestMatch.declaringClass .readableName()), new String( problemMethod.closestMatch.selector), closestParameterTypeNames, - parameterTypeNames}, - new String[]{ + parameterTypeNames }, + new String[] { new String( problemMethod.closestMatch.declaringClass .shortReadableName()), new String( problemMethod.closestMatch.selector), closestParameterTypeShortNames, - parameterTypeShortNames}, + parameterTypeShortNames }, (int) (messageSend.nameSourcePosition >>> 32), (int) messageSend.nameSourcePosition); return; } } - this.handle(flag, new String[]{ + this.handle(flag, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass.shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, + parametersAsShortString(method) }, (int) (messageSend.nameSourcePosition >>> 32), (int) messageSend.nameSourcePosition); } + public void invalidNullToSynchronize(Expression expression) { this.handle(IProblem.InvalidNullToSynchronized, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void invalidOperator(BinaryExpression expression, TypeBinding leftType, TypeBinding rightType) { String leftName = new String(leftType.readableName()); @@ -1696,12 +1805,13 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { leftShortName = leftName; rightShortName = rightName; } - this.handle(IProblem.InvalidOperator, new String[]{ - expression.operatorToString(), leftName + ", " + rightName}, //$NON-NLS-1$ - new String[]{expression.operatorToString(), - leftShortName + ", " + rightShortName}, //$NON-NLS-1$ + this.handle(IProblem.InvalidOperator, new String[] { + expression.operatorToString(), leftName + ", " + rightName }, //$NON-NLS-1$ + new String[] { expression.operatorToString(), + leftShortName + ", " + rightShortName }, //$NON-NLS-1$ expression.sourceStart, expression.sourceEnd); } + public void invalidOperator(CompoundAssignment assign, TypeBinding leftType, TypeBinding rightType) { String leftName = new String(leftType.readableName()); @@ -1712,297 +1822,835 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { leftShortName = leftName; rightShortName = rightName; } - this.handle(IProblem.InvalidOperator, new String[]{ - assign.operatorToString(), leftName + ", " + rightName}, //$NON-NLS-1$ - new String[]{assign.operatorToString(), - leftShortName + ", " + rightShortName}, //$NON-NLS-1$ + this.handle(IProblem.InvalidOperator, new String[] { + assign.operatorToString(), leftName + ", " + rightName }, //$NON-NLS-1$ + new String[] { assign.operatorToString(), + leftShortName + ", " + rightShortName }, //$NON-NLS-1$ assign.sourceStart, assign.sourceEnd); } + public void invalidOperator(UnaryExpression expression, TypeBinding type) { this.handle(IProblem.InvalidOperator, - new String[]{expression.operatorToString(), - new String(type.readableName())}, new String[]{ + new String[] { expression.operatorToString(), + new String(type.readableName()) }, new String[] { expression.operatorToString(), - new String(type.shortReadableName())}, + new String(type.shortReadableName()) }, expression.sourceStart, expression.sourceEnd); } - public void invalidParenthesizedExpression(AstNode reference) { + + public void invalidParenthesizedExpression(ASTNode reference) { this.handle(IProblem.InvalidParenthesizedExpression, NoArgument, NoArgument, reference.sourceStart, reference.sourceEnd); } + public void invalidSuperclass(SourceTypeBinding type, TypeReference superclassRef, ReferenceBinding expectedType) { int problemId = expectedType.problemId(); int id; switch (problemId) { - case NotFound : - // 1 - id = IProblem.SuperclassNotFound; - break; - case NotVisible : - // 2 - id = IProblem.SuperclassNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.SuperclassAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.SuperclassInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.SuperclassInheritedNameHidesEnclosingName; - break; - case NoError : + case NotFound: + // 1 + id = IProblem.SuperclassNotFound; + break; + case NotVisible: + // 2 + id = IProblem.SuperclassNotVisible; + break; + case Ambiguous: + // 3 + id = IProblem.SuperclassAmbiguous; + break; + case InternalNameProvided: + // 4 + id = IProblem.SuperclassInternalNameProvided; + break; + case InheritedNameHidesEnclosingName: + // 5 + id = IProblem.SuperclassInheritedNameHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; + default: + needImplementation(); // want to fail to see why we were + // here... + return; } - this.handle(id, new String[]{new String(expectedType.readableName()), - new String(type.sourceName())}, new String[]{ + 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, + new String(type.sourceName()) }, superclassRef.sourceStart, superclassRef.sourceEnd); } + public void invalidSuperinterface(SourceTypeBinding type, TypeReference superinterfaceRef, ReferenceBinding expectedType) { int problemId = expectedType.problemId(); int id; switch (problemId) { - case NotFound : - // 1 - id = IProblem.InterfaceNotFound; - break; - case NotVisible : - // 2 - id = IProblem.InterfaceNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.InterfaceAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.InterfaceInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.InterfaceInheritedNameHidesEnclosingName; - break; - case NoError : + case NotFound: + // 1 + id = IProblem.InterfaceNotFound; + break; + case NotVisible: + // 2 + id = IProblem.InterfaceNotVisible; + break; + case Ambiguous: + // 3 + id = IProblem.InterfaceAmbiguous; + break; + case InternalNameProvided: + // 4 + id = IProblem.InterfaceInternalNameProvided; + break; + case InheritedNameHidesEnclosingName: + // 5 + id = IProblem.InterfaceInheritedNameHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; + default: + needImplementation(); // want to fail to see why we were + // here... + return; } - this.handle(id, new String[]{new String(expectedType.readableName()), - new String(type.sourceName())}, new String[]{ + 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, + new String(type.sourceName()) }, superinterfaceRef.sourceStart, superinterfaceRef.sourceEnd); } - public void invalidType(AstNode location, TypeBinding type) { + + public void invalidType(ASTNode location, TypeBinding type) { int flag = IProblem.UndefinedType; // default switch (type.problemId()) { - case NotFound : - flag = IProblem.UndefinedType; - break; - case NotVisible : - flag = IProblem.NotVisibleType; - break; - case Ambiguous : - flag = IProblem.AmbiguousType; - break; - case InternalNameProvided : - flag = IProblem.InternalTypeNameProvided; - break; - case InheritedNameHidesEnclosingName : - flag = IProblem.InheritedTypeHidesEnclosingName; - break; - case NoError : + case NotFound: + flag = IProblem.UndefinedType; + break; + case NotVisible: + flag = IProblem.NotVisibleType; + break; + case Ambiguous: + flag = IProblem.AmbiguousType; + break; + case InternalNameProvided: + flag = IProblem.InternalTypeNameProvided; + break; + case InheritedNameHidesEnclosingName: + flag = IProblem.InheritedTypeHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - break; + default: + needImplementation(); // want to fail to see why we were + // here... + break; } - this.handle(flag, new String[]{new String(type.readableName())}, - new String[]{new String(type.shortReadableName())}, + 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, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void invalidTypeToSynchronize(Expression expression, TypeBinding type) { this.handle(IProblem.InvalidTypeToSynchronized, - new String[]{new String(type.readableName())}, - new String[]{new String(type.shortReadableName())}, + new String[] { new String(type.readableName()) }, + new String[] { new String(type.shortReadableName()) }, expression.sourceStart, expression.sourceEnd); } + public void invalidUnaryExpression(Expression expression) { this.handle(IProblem.InvalidUnaryExpression, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void isClassPathCorrect(char[][] wellKnownTypeName, CompilationUnitDeclaration compUnitDecl) { referenceContext = compUnitDecl; - String[] arguments = new String[]{CharOperation - .toString(wellKnownTypeName)}; + String[] arguments = new String[] { CharOperation + .toString(wellKnownTypeName) }; this.handle(IProblem.IsClassPathCorrect, arguments, arguments, - AbortCompilation | Error, compUnitDecl == null - ? 0 - : compUnitDecl.sourceStart, compUnitDecl == null - ? 1 + AbortCompilation | Error, compUnitDecl == null ? 0 + : compUnitDecl.sourceStart, compUnitDecl == null ? 1 : compUnitDecl.sourceEnd); } - public void maskedExceptionHandler(ReferenceBinding exceptionType, - AstNode location) { - this.handle(IProblem.MaskedCatch, NoArgument, NoArgument, - location.sourceStart, location.sourceEnd); + + public void javadocDuplicatedReturnTag(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocDuplicateReturnTag, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocDeprecatedField(FieldBinding field, ASTNode location, + int modifiers) { + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + this.handle(IProblem.JavadocUsingDeprecatedField, new String[] { + new String(field.declaringClass.readableName()), + new String(field.name) }, new String[] { + new String(field.declaringClass.shortReadableName()), + new String(field.name) }, location.sourceStart, + location.sourceEnd); + } + } + + public void javadocDeprecatedMethod(MethodBinding method, ASTNode location, + int modifiers) { + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + if (method.isConstructor()) { + this + .handle(IProblem.JavadocUsingDeprecatedConstructor, + new String[] { + new String(method.declaringClass + .readableName()), + parametersAsString(method) }, + new String[] { + new String(method.declaringClass + .shortReadableName()), + parametersAsShortString(method) }, + location.sourceStart, location.sourceEnd); + } else { + this + .handle(IProblem.JavadocUsingDeprecatedMethod, + new String[] { + new String(method.declaringClass + .readableName()), + new String(method.selector), + parametersAsString(method) }, + new String[] { + new String(method.declaringClass + .shortReadableName()), + new String(method.selector), + parametersAsShortString(method) }, + location.sourceStart, location.sourceEnd); + } + } + } + + public void javadocDeprecatedType(TypeBinding type, ASTNode location, + int modifiers) { + if (location == null) + return; // 1G828DN - no type ref for synthetic arguments + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + this.handle(IProblem.JavadocUsingDeprecatedType, + new String[] { new String(type.readableName()) }, + new String[] { new String(type.shortReadableName()) }, + location.sourceStart, location.sourceEnd); + } + } + + // public void javadocDuplicatedParamTag(JavadocSingleNameReference param, + // int modifiers) { + // if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + // modifiers)) { + // String[] arguments = new String[] {String.valueOf(param.token)}; + // this.handle(IProblem.JavadocDuplicateParamName, arguments, arguments, + // param.sourceStart, param.sourceEnd); + // } + // } + public void javadocDuplicatedThrowsClassName(TypeReference typeReference, + int modifiers) { + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + String[] arguments = new String[] { String + .valueOf(typeReference.resolvedType.sourceName()) }; + this.handle(IProblem.JavadocDuplicateThrowsClassName, arguments, + arguments, typeReference.sourceStart, + typeReference.sourceEnd); + } + } + + public void javadocErrorNoMethodFor(MessageSend messageSend, + TypeBinding recType, TypeBinding[] params, int modifiers) { + StringBuffer buffer = new StringBuffer(); + StringBuffer shortBuffer = new StringBuffer(); + for (int i = 0, length = params.length; i < length; i++) { + if (i != 0) { + buffer.append(", "); //$NON-NLS-1$ + shortBuffer.append(", "); //$NON-NLS-1$ + } + buffer.append(new String(params[i].readableName())); + shortBuffer.append(new String(params[i].shortReadableName())); + } + + int id = recType.isArrayType() ? IProblem.JavadocNoMessageSendOnArrayType + : IProblem.JavadocNoMessageSendOnBaseType; + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + this.handle(id, new String[] { new String(recType.readableName()), + new String(messageSend.selector), buffer.toString() }, + new String[] { new String(recType.shortReadableName()), + new String(messageSend.selector), + shortBuffer.toString() }, messageSend.sourceStart, + messageSend.sourceEnd); + } + } + + public void javadocInvalidConstructor(Statement statement, + MethodBinding targetConstructor, int modifiers) { + + if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + return; + } + // boolean insideDefaultConstructor = + // (this.referenceContext instanceof ConstructorDeclaration) + // && + // ((ConstructorDeclaration)this.referenceContext).isDefaultConstructor(); + // boolean insideImplicitConstructorCall = + // (statement instanceof ExplicitConstructorCall) + // && (((ExplicitConstructorCall) statement).accessMode == + // ExplicitConstructorCall.ImplicitSuper); + + int id = IProblem.JavadocUndefinedConstructor; // default... + switch (targetConstructor.problemId()) { + case NotFound: + // if (insideDefaultConstructor){ + // id = IProblem.JavadocUndefinedConstructorInDefaultConstructor; + // } else if (insideImplicitConstructorCall){ + // id = + // IProblem.JavadocUndefinedConstructorInImplicitConstructorCall; + // } else { + id = IProblem.JavadocUndefinedConstructor; + // } + break; + case NotVisible: + // if (insideDefaultConstructor){ + // id = IProblem.JavadocNotVisibleConstructorInDefaultConstructor; + // } else if (insideImplicitConstructorCall){ + // id = + // IProblem.JavadocNotVisibleConstructorInImplicitConstructorCall; + // } else { + id = IProblem.JavadocNotVisibleConstructor; + // } + break; + case Ambiguous: + // if (insideDefaultConstructor){ + // id = IProblem.AmbiguousConstructorInDefaultConstructor; + // } else if (insideImplicitConstructorCall){ + // id = IProblem.AmbiguousConstructorInImplicitConstructorCall; + // } else { + id = IProblem.JavadocAmbiguousConstructor; + // } + break; + case NoError: // 0 + default: + needImplementation(); // want to fail to see why we were here... + break; + } + + this.handle(id, new String[] { + new String(targetConstructor.declaringClass.readableName()), + parametersAsString(targetConstructor) }, + new String[] { + new String(targetConstructor.declaringClass + .shortReadableName()), + parametersAsShortString(targetConstructor) }, + statement.sourceStart, statement.sourceEnd); + } + + public void javadocAmbiguousMethodReference(int sourceStart, int sourceEnd, + Binding fieldBinding, int modifiers) { + int id = IProblem.JavadocAmbiguousMethodReference; + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + String[] arguments = new String[] { new String(fieldBinding + .readableName()) }; + handle(id, arguments, arguments, sourceStart, sourceEnd); + } + } + + /* + * Similar implementation than invalidField(FieldReference...) Note that + * following problem id cannot occur for Javadoc: - + * NonStaticReferenceInStaticContext : - + * NonStaticReferenceInConstructorInvocation : - ReceiverTypeNotVisible : + */ + public void javadocInvalidField(int sourceStart, int sourceEnd, + Binding fieldBinding, TypeBinding searchedType, int modifiers) { + int id = IProblem.JavadocUndefinedField; + switch (fieldBinding.problemId()) { + case NotFound: + id = IProblem.JavadocUndefinedField; + break; + case NotVisible: + id = IProblem.JavadocNotVisibleField; + break; + case Ambiguous: + id = IProblem.JavadocAmbiguousField; + break; + case InheritedNameHidesEnclosingName: + id = IProblem.JavadocInheritedFieldHidesEnclosingName; + break; + case NoError: // 0 + default: + needImplementation(); // want to fail to see why we were here... + break; + } + + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + String[] arguments = new String[] { new String(fieldBinding + .readableName()) }; + handle(id, arguments, arguments, sourceStart, sourceEnd); + } + } + + /* + * Similar implementation than invalidMethod(MessageSend...) Note that + * following problem id cannot occur for Javadoc: - + * NonStaticReferenceInStaticContext : - + * NonStaticReferenceInConstructorInvocation : - ReceiverTypeNotVisible : + */ + public void javadocInvalidMethod(MessageSend messageSend, + MethodBinding method, int modifiers) { + if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + return; + } + int id = IProblem.JavadocUndefinedMethod; // default... + switch (method.problemId()) { + case NotFound: + id = IProblem.JavadocUndefinedMethod; + break; + case NotVisible: + id = IProblem.JavadocNotVisibleMethod; + break; + case Ambiguous: + id = IProblem.JavadocAmbiguousMethod; + break; + case InheritedNameHidesEnclosingName: + id = IProblem.JavadocInheritedMethodHidesEnclosingName; + break; + case NoError: // 0 + default: + needImplementation(); // want to fail to see why we were here... + break; + } + + if (id == IProblem.JavadocUndefinedMethod) { + ProblemMethodBinding problemMethod = (ProblemMethodBinding) method; + if (problemMethod.closestMatch != null) { + String closestParameterTypeNames = parametersAsString(problemMethod.closestMatch); + String parameterTypeNames = parametersAsString(method); + String closestParameterTypeShortNames = parametersAsShortString(problemMethod.closestMatch); + String parameterTypeShortNames = parametersAsShortString(method); + if (closestParameterTypeShortNames + .equals(parameterTypeShortNames)) { + closestParameterTypeShortNames = closestParameterTypeNames; + parameterTypeShortNames = parameterTypeNames; + } + this + .handle( + IProblem.JavadocParameterMismatch, + new String[] { + new String( + problemMethod.closestMatch.declaringClass + .readableName()), + new String( + problemMethod.closestMatch.selector), + closestParameterTypeNames, + parameterTypeNames }, + new String[] { + new String( + problemMethod.closestMatch.declaringClass + .shortReadableName()), + new String( + problemMethod.closestMatch.selector), + closestParameterTypeShortNames, + parameterTypeShortNames }, + (int) (messageSend.nameSourcePosition >>> 32), + (int) messageSend.nameSourcePosition); + return; + } + } + + this.handle(id, new String[] { + new String(method.declaringClass.readableName()), + new String(method.selector), parametersAsString(method) }, + new String[] { + new String(method.declaringClass.shortReadableName()), + new String(method.selector), + parametersAsShortString(method) }, + (int) (messageSend.nameSourcePosition >>> 32), + (int) messageSend.nameSourcePosition); } + + // public void javadocInvalidParamName(JavadocSingleNameReference param, int + // modifiers) { + // if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + // modifiers)) { + // String[] arguments = new String[] {String.valueOf(param.token)}; + // this.handle(IProblem.JavadocInvalidParamName, arguments, arguments, + // param.sourceStart, param.sourceEnd); + // } + // } + public void javadocInvalidSeeReference(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocInvalidSeeReference, NoArgument, + NoArgument, sourceStart, sourceEnd); + } + + public void javadocInvalidSeeReferenceArgs(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocInvalidSeeArgs, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocInvalidSeeUrlReference(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocInvalidSeeHref, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocInvalidTag(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocInvalidTag, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocInvalidThrowsClass(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocInvalidThrowsClass, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocInvalidThrowsClassName(TypeReference typeReference, + int modifiers) { + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + String[] arguments = new String[] { String + .valueOf(typeReference.resolvedType.sourceName()) }; + this.handle(IProblem.JavadocInvalidThrowsClassName, arguments, + arguments, typeReference.sourceStart, + typeReference.sourceEnd); + } + } + + public void javadocInvalidType(ASTNode location, TypeBinding type, + int modifiers) { + if (javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, + modifiers)) { + int id = IProblem.JavadocUndefinedType; // default + switch (type.problemId()) { + case NotFound: + id = IProblem.JavadocUndefinedType; + break; + case NotVisible: + id = IProblem.JavadocNotVisibleType; + break; + case Ambiguous: + id = IProblem.JavadocAmbiguousType; + break; + case InternalNameProvided: + id = IProblem.JavadocInternalTypeNameProvided; + break; + case InheritedNameHidesEnclosingName: + id = IProblem.JavadocInheritedNameHidesEnclosingTypeName; + break; + case NoError: // 0 + default: + needImplementation(); // want to fail to see why we were + // here... + break; + } + this.handle(id, new String[] { new String(type.readableName()) }, + new String[] { new String(type.shortReadableName()) }, + location.sourceStart, location.sourceEnd); + } + } + + public void javadocMalformedSeeReference(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocMalformedSeeReference, NoArgument, + NoArgument, sourceStart, sourceEnd); + } + + public void javadocMissing(int sourceStart, int sourceEnd, int modifiers) { + boolean overriding = (modifiers & (CompilerModifiers.AccImplementing + CompilerModifiers.AccOverriding)) != 0; + boolean report = (this.options + .getSeverity(CompilerOptions.MissingJavadocComments) != ProblemSeverities.Ignore) + && (!overriding || this.options.reportMissingJavadocCommentsOverriding); + if (report) { + String arg = javadocVisibilityArgument( + this.options.reportMissingJavadocCommentsVisibility, + modifiers); + if (arg != null) { + String[] arguments = new String[] { arg }; + this.handle(IProblem.JavadocMissing, arguments, arguments, + sourceStart, sourceEnd); + } + } + } + + public void javadocMissingParamName(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocMissingParamName, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocMissingParamTag(Argument param, int modifiers) { + boolean overriding = (modifiers & (CompilerModifiers.AccImplementing + CompilerModifiers.AccOverriding)) != 0; + boolean report = (this.options + .getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore) + && (!overriding || this.options.reportMissingJavadocTagsOverriding); + if (report + && javadocVisibility( + this.options.reportMissingJavadocTagsVisibility, + modifiers)) { + String[] arguments = new String[] { String.valueOf(param.name) }; + this.handle(IProblem.JavadocMissingParamTag, arguments, arguments, + param.sourceStart, param.sourceEnd); + } + } + + public void javadocMissingReturnTag(int sourceStart, int sourceEnd, + int modifiers) { + boolean overriding = (modifiers & (CompilerModifiers.AccImplementing + CompilerModifiers.AccOverriding)) != 0; + boolean report = (this.options + .getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore) + && (!overriding || this.options.reportMissingJavadocTagsOverriding); + if (report + && javadocVisibility( + this.options.reportMissingJavadocTagsVisibility, + modifiers)) { + this.handle(IProblem.JavadocMissingReturnTag, NoArgument, + NoArgument, sourceStart, sourceEnd); + } + } + + public void javadocMissingSeeReference(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocMissingSeeReference, NoArgument, + NoArgument, sourceStart, sourceEnd); + } + + public void javadocMissingThrowsClassName(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocMissingThrowsClassName, NoArgument, + NoArgument, sourceStart, sourceEnd); + } + + public void javadocMissingThrowsTag(TypeReference typeRef, int modifiers) { + boolean overriding = (modifiers & (CompilerModifiers.AccImplementing + CompilerModifiers.AccOverriding)) != 0; + boolean report = (this.options + .getSeverity(CompilerOptions.MissingJavadocTags) != ProblemSeverities.Ignore) + && (!overriding || this.options.reportMissingJavadocTagsOverriding); + if (report + && javadocVisibility( + this.options.reportMissingJavadocTagsVisibility, + modifiers)) { + String[] arguments = new String[] { String + .valueOf(typeRef.resolvedType.sourceName()) }; + this.handle(IProblem.JavadocMissingThrowsTag, arguments, arguments, + typeRef.sourceStart, typeRef.sourceEnd); + } + } + + public void javadocUnexpectedTag(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocUnexpectedTag, NoArgument, NoArgument, + sourceStart, sourceEnd); + } + + public void javadocUnterminatedInlineTag(int sourceStart, int sourceEnd) { + this.handle(IProblem.JavadocUnterminatedInlineTag, NoArgument, + NoArgument, sourceStart, sourceEnd); + } + + private boolean javadocVisibility(int visibility, int modifiers) { + switch (modifiers & CompilerModifiers.AccVisibilityMASK) { + case IConstants.AccPublic: + return true; + case IConstants.AccProtected: + return (visibility != IConstants.AccPublic); + // case IConstants.AccDefault: + // return (visibility == IConstants.AccDefault || visibility == + // IConstants.AccPrivate); + case IConstants.AccPrivate: + return (visibility == IConstants.AccPrivate); + } + return true; + } + + private String javadocVisibilityArgument(int visibility, int modifiers) { + String argument = null; + switch (modifiers & CompilerModifiers.AccVisibilityMASK) { + case IConstants.AccPublic: + argument = CompilerOptions.PUBLIC; + break; + case IConstants.AccProtected: + if (visibility != IConstants.AccPublic) { + argument = CompilerOptions.PROTECTED; + } + break; + // case IConstants.AccDefault: + // if (visibility == IConstants.AccDefault || visibility == + // IConstants.AccPrivate) { + // argument = CompilerOptions.DEFAULT; + // } + // break; + case IConstants.AccPrivate: + if (visibility == IConstants.AccPrivate) { + argument = CompilerOptions.PRIVATE; + } + break; + } + return argument; + } + public void methodNeedingAbstractModifier(MethodDeclaration methodDecl) { this.handle(IProblem.MethodRequiresBody, NoArgument, NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void methodNeedingNoBody(MethodDeclaration methodDecl) { this.handle( - // ((methodDecl.modifiers & CompilerModifiers.AccNative) != 0) ? - // IProblem.BodyForNativeMethod : IProblem.BodyForAbstractMethod, + // ((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, NoArgument, NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } - //public void missingEnclosingInstanceSpecification(ReferenceBinding - // enclosingType, AstNode location) { - // boolean insideConstructorCall = - // (location instanceof ExplicitConstructorCall) - // && (((ExplicitConstructorCall) location).accessMode == + + // 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); - //} + // 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, NoArgument, NoArgument, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void missingSemiColon(Expression expression) { this.handle(IProblem.MissingSemiColon, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void mustDefineDimensionsOrInitializer( ArrayAllocationExpression expression) { this.handle(IProblem.MustDefineEitherDimensionExpressionsOrInitializer, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void mustSpecifyPackage(CompilationUnitDeclaration compUnitDecl) { - String[] arguments = new String[]{new String(compUnitDecl.getFileName())}; + String[] arguments = new String[] { new String(compUnitDecl + .getFileName()) }; this.handle(IProblem.MustSpecifyPackage, arguments, arguments, compUnitDecl.sourceStart, compUnitDecl.sourceStart + 1); } + public void mustUseAStaticMethod(MessageSend messageSend, MethodBinding method) { - this.handle(IProblem.StaticMethodRequested, new String[]{ + this.handle(IProblem.StaticMethodRequested, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass.shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, + 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)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.NativeMethodsCannotBeStrictfp, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void needImplementation() { this.abortDueToInternalError(Util.bind("abort.missingCode")); //$NON-NLS-1$ } + public void needToEmulateFieldReadAccess(FieldBinding field, - AstNode location) { - this.handle(IProblem.NeedToEmulateFieldReadAccess, new String[]{ + ASTNode location) { + this.handle(IProblem.NeedToEmulateFieldReadAccess, new String[] { new String(field.declaringClass.readableName()), - new String(field.name)}, new String[]{ + new String(field.name) }, new String[] { new String(field.declaringClass.shortReadableName()), - new String(field.name)}, location.sourceStart, + new String(field.name) }, location.sourceStart, location.sourceEnd); } + public void needToEmulateFieldWriteAccess(FieldBinding field, - AstNode location) { - this.handle(IProblem.NeedToEmulateFieldWriteAccess, new String[]{ + ASTNode location) { + this.handle(IProblem.NeedToEmulateFieldWriteAccess, new String[] { new String(field.declaringClass.readableName()), - new String(field.name)}, new String[]{ + new String(field.name) }, new String[] { new String(field.declaringClass.shortReadableName()), - new String(field.name)}, location.sourceStart, + new String(field.name) }, location.sourceStart, location.sourceEnd); } - public void needToEmulateMethodAccess(MethodBinding method, AstNode location) { + + public void needToEmulateMethodAccess(MethodBinding method, ASTNode location) { if (method.isConstructor()) - this.handle(IProblem.NeedToEmulateConstructorAccess, new String[]{ + this.handle(IProblem.NeedToEmulateConstructorAccess, new String[] { new String(method.declaringClass.readableName()), - parametersAsString(method)}, new String[]{ + parametersAsString(method) }, new String[] { new String(method.declaringClass.shortReadableName()), - parametersAsShortString(method)}, location.sourceStart, + parametersAsShortString(method) }, location.sourceStart, location.sourceEnd); else - this.handle(IProblem.NeedToEmulateMethodAccess, new String[]{ + this.handle(IProblem.NeedToEmulateMethodAccess, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass .shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, + parametersAsShortString(method) }, location.sourceStart, location.sourceEnd); } + public void nestedClassCannotDeclareInterface(TypeDeclaration typeDecl) { - String[] arguments = new String[]{new String(typeDecl.name)}; + String[] arguments = new String[] { new String(typeDecl.name) }; this.handle(IProblem.CannotDefineInterfaceInLocalType, arguments, arguments, typeDecl.sourceStart, typeDecl.sourceEnd); } + public void noMoreAvailableSpaceForArgument(LocalVariableBinding local, - AstNode location) { - String[] arguments = new String[]{new String(local.name)}; - this.handle(local instanceof SyntheticArgumentBinding - ? IProblem.TooManySyntheticArgumentSlots - : IProblem.TooManyArgumentSlots, arguments, arguments, Abort - | Error, location.sourceStart, location.sourceEnd); + ASTNode location) { + String[] arguments = new String[] { new String(local.name) }; + this + .handle( + local instanceof SyntheticArgumentBinding ? IProblem.TooManySyntheticArgumentSlots + : IProblem.TooManyArgumentSlots, arguments, + arguments, Abort | Error, location.sourceStart, + location.sourceEnd); } + public void noMoreAvailableSpaceForLocal(LocalVariableBinding local, - AstNode location) { - String[] arguments = new String[]{new String(local.name)}; + ASTNode location) { + String[] arguments = new String[] { new String(local.name) }; this.handle(IProblem.TooManyLocalVariableSlots, arguments, arguments, Abort | Error, location.sourceStart, location.sourceEnd); } + public void noSuchEnclosingInstance(TypeBinding targetType, - AstNode location, boolean isConstructorCall) { + ASTNode location, boolean isConstructorCall) { int id; if (isConstructorCall) { - //28 = No enclosing instance of type {0} is available due to some + // 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 + // 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}). @@ -2012,19 +2660,20 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { .isMemberType() || (((AllocationExpression) location).binding.declaringClass .isAnonymousType() && ((AllocationExpression) location).binding.declaringClass .superclass().isMemberType()))) { - //21 = No enclosing instance of type {0} is accessible. Must + // 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 + // 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())}, + 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()); @@ -2035,10 +2684,11 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { leftShortName = leftName; rightShortName = rightName; } - this.handle(IProblem.IncompatibleTypesInEqualityOperator, new String[]{ - leftName, rightName}, new String[]{leftShortName, - rightShortName}, expression.sourceStart, expression.sourceEnd); + this.handle(IProblem.IncompatibleTypesInEqualityOperator, new String[] { + leftName, rightName }, new String[] { leftShortName, + rightShortName }, expression.sourceStart, expression.sourceEnd); } + public void notCompatibleTypesError(InstanceOfExpression expression, TypeBinding leftType, TypeBinding rightType) { String leftName = new String(leftType.readableName()); @@ -2050,14 +2700,16 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { rightShortName = rightName; } this.handle(IProblem.IncompatibleTypesInConditionalOperator, - new String[]{leftName, rightName}, new String[]{leftShortName, - rightShortName}, expression.sourceStart, - expression.sourceEnd); + 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()); @@ -2068,58 +2720,62 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { leftShortName = leftName; rightShortName = rightName; } - this.handle(IProblem.TypeMismatch, new String[]{leftName, rightName}, - new String[]{leftShortName, rightShortName}, + this.handle(IProblem.TypeMismatch, + new String[] { leftName, rightName }, new String[] { + leftShortName, rightShortName }, assignment.sourceStart, assignment.sourceEnd); } + public void overridesDeprecatedMethod(MethodBinding localMethod, MethodBinding inheritedMethod) { - this.handle(IProblem.OverridingDeprecatedMethod, new String[]{ + this.handle(IProblem.OverridingDeprecatedMethod, new String[] { new String(CharOperation.concat(localMethod.declaringClass .readableName(), localMethod.readableName(), '.')), - new String(inheritedMethod.declaringClass.readableName())}, - new String[]{ + new String(inheritedMethod.declaringClass.readableName()) }, + new String[] { new String(CharOperation.concat( localMethod.declaringClass.shortReadableName(), localMethod.shortReadableName(), '.')), new String(inheritedMethod.declaringClass - .shortReadableName())}, localMethod + .shortReadableName()) }, localMethod .sourceStart(), localMethod.sourceEnd()); } + public void overridesPackageDefaultMethod(MethodBinding localMethod, MethodBinding inheritedMethod) { - this.handle(IProblem.OverridingNonVisibleMethod, new String[]{ + this.handle(IProblem.OverridingNonVisibleMethod, new String[] { new String(CharOperation.concat(localMethod.declaringClass .readableName(), localMethod.readableName(), '.')), - new String(inheritedMethod.declaringClass.readableName())}, - new String[]{ + new String(inheritedMethod.declaringClass.readableName()) }, + new String[] { new String(CharOperation.concat( localMethod.declaringClass.shortReadableName(), localMethod.shortReadableName(), '.')), new String(inheritedMethod.declaringClass - .shortReadableName())}, localMethod + .shortReadableName()) }, localMethod .sourceStart(), localMethod.sourceEnd()); } - public void packageCollidesWithType(CompilationUnitDeclaration compUnitDecl) { - String[] arguments = new String[]{CharOperation - .toString(compUnitDecl.currentPackage.tokens)}; - this.handle(IProblem.PackageCollidesWithType, arguments, arguments, - compUnitDecl.currentPackage.sourceStart, - compUnitDecl.currentPackage.sourceEnd); - } + + // public void packageCollidesWithType(CompilationUnitDeclaration + // compUnitDecl) { + // String[] arguments = new String[]{CharOperation + // .toString(compUnitDecl.currentPackage.tokens)}; + // this.handle(IProblem.PackageCollidesWithType, arguments, arguments, + // compUnitDecl.currentPackage.sourceStart, + // compUnitDecl.currentPackage.sourceEnd); + // } public void packageIsNotExpectedPackage( CompilationUnitDeclaration compUnitDecl) { - String[] arguments = new String[]{CharOperation + String[] arguments = new String[] { CharOperation .toString(compUnitDecl.compilationResult.compilationUnit - .getPackageName())}; + .getPackageName()) }; this.handle(IProblem.PackageIsNotExpectedPackage, arguments, arguments, - compUnitDecl.currentPackage == null - ? 0 + compUnitDecl.currentPackage == null ? 0 : compUnitDecl.currentPackage.sourceStart, - compUnitDecl.currentPackage == null - ? 0 + compUnitDecl.currentPackage == null ? 0 : compUnitDecl.currentPackage.sourceEnd); } + private String parametersAsString(MethodBinding method) { TypeBinding[] params = method.parameters; StringBuffer buffer = new StringBuffer(); @@ -2130,6 +2786,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { } return buffer.toString(); } + private String parametersAsShortString(MethodBinding method) { TypeBinding[] params = method.parameters; StringBuffer buffer = new StringBuffer(); @@ -2140,27 +2797,29 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { } return buffer.toString(); } + public void parseError(int startPosition, int endPosition, char[] currentTokenSource, String errorTokenName, String[] possibleTokens) { - if (possibleTokens.length == 0) { //no suggestion available + if (possibleTokens.length == 0) { // no suggestion available if (isKeyword(currentTokenSource)) { - String[] arguments = new String[]{new String(currentTokenSource)}; + String[] arguments = new String[] { new String( + currentTokenSource) }; this.handle(IProblem.ParsingErrorOnKeywordNoSuggestion, - arguments, arguments, + arguments, arguments, // this is the current -invalid- token position startPosition, endPosition); return; } else { - String[] arguments = new String[]{errorTokenName}; + String[] arguments = new String[] { errorTokenName }; this.handle(IProblem.ParsingErrorNoSuggestion, arguments, - arguments, + arguments, // this is the current -invalid- token position startPosition, endPosition); return; } } - //build a list of probable right tokens + // build a list of probable right tokens StringBuffer list = new StringBuffer(20); for (int i = 0, max = possibleTokens.length; i < max; i++) { if (i > 0) @@ -2170,14 +2829,14 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { list.append('"'); } if (isKeyword(currentTokenSource)) { - String[] arguments = new String[]{new String(currentTokenSource), - list.toString()}; - this.handle(IProblem.ParsingErrorOnKeyword, arguments, arguments, + String[] arguments = new String[] { new String(currentTokenSource), + list.toString() }; + this.handle(IProblem.ParsingErrorOnKeyword, arguments, arguments, // this is the current -invalid- token position startPosition, endPosition); return; } - //extract the literal when it's a literal + // extract the literal when it's a literal if ((errorTokenName.equals("IntegerLiteral")) || //$NON-NLS-1$ (errorTokenName.equals("LongLiteral")) || //$NON-NLS-1$ (errorTokenName.equals("FloatingPointLiteral")) || //$NON-NLS-1$ @@ -2187,101 +2846,109 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { (errorTokenName.equals("Identifier"))) { //$NON-NLS-1$ errorTokenName = new String(currentTokenSource); } - String[] arguments = new String[]{errorTokenName, list.toString()}; - this.handle(IProblem.ParsingError, arguments, arguments, + String[] arguments = new String[] { errorTokenName, list.toString() }; + this.handle(IProblem.ParsingError, 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[]{ + // type not the entire compilation + // unit + String[] arguments = new String[] { new String(compUnitDecl.getFileName()), - new String(typeDecl.name)}; + new String(typeDecl.name) }; this.handle(IProblem.PublicClassMustMatchFileName, arguments, arguments, typeDecl.sourceStart, typeDecl.sourceEnd, compUnitDecl.compilationResult); } + public void recursiveConstructorInvocation( ExplicitConstructorCall constructorCall) { - this.handle(IProblem.RecursiveConstructorInvocation, new String[]{ + this.handle(IProblem.RecursiveConstructorInvocation, new String[] { new String(constructorCall.binding.declaringClass .readableName()), - parametersAsString(constructorCall.binding)}, new String[]{ + parametersAsString(constructorCall.binding) }, new String[] { new String(constructorCall.binding.declaringClass .shortReadableName()), - parametersAsShortString(constructorCall.binding)}, + parametersAsShortString(constructorCall.binding) }, constructorCall.sourceStart, constructorCall.sourceEnd); } + public void redefineArgument(Argument arg) { - String[] arguments = new String[]{new String(arg.name)}; + String[] arguments = new String[] { new String(arg.name) }; this.handle(IProblem.RedefinedArgument, arguments, arguments, arg.sourceStart, arg.sourceEnd); } + public void redefineLocal(LocalDeclaration localDecl) { - String[] arguments = new String[]{new String(localDecl.name)}; + String[] arguments = new String[] { new String(localDecl.name) }; this.handle(IProblem.RedefinedLocal, arguments, arguments, localDecl.sourceStart, localDecl.sourceEnd); } + public void referenceMustBeArrayTypeAt(TypeBinding arrayType, ArrayReference arrayRef) { - this.handle(IProblem.ArrayReferenceRequired, new String[]{new String( - arrayType.readableName())}, new String[]{new String(arrayType - .shortReadableName())}, arrayRef.sourceStart, + 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)}; + String[] arguments = new String[] { new String(methodDecl.selector) }; this.handle(IProblem.ReturnTypeCannotBeVoidArray, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } + public void returnTypeProblem(SourceTypeBinding type, MethodDeclaration methodDecl, TypeBinding expectedType) { int problemId = expectedType.problemId(); int id; switch (problemId) { - case NotFound : - // 1 - id = IProblem.ReturnTypeNotFound; - break; - case NotVisible : - // 2 - id = IProblem.ReturnTypeNotVisible; - break; - case Ambiguous : - // 3 - id = IProblem.ReturnTypeAmbiguous; - break; - case InternalNameProvided : - // 4 - id = IProblem.ReturnTypeInternalNameProvided; - break; - case InheritedNameHidesEnclosingName : - // 5 - id = IProblem.ReturnTypeInheritedNameHidesEnclosingName; - break; - case NoError : + case NotFound: + // 1 + id = IProblem.ReturnTypeNotFound; + break; + case NotVisible: + // 2 + id = IProblem.ReturnTypeNotVisible; + break; + case Ambiguous: + // 3 + id = IProblem.ReturnTypeAmbiguous; + break; + case InternalNameProvided: + // 4 + id = IProblem.ReturnTypeInternalNameProvided; + break; + case InheritedNameHidesEnclosingName: + // 5 + id = IProblem.ReturnTypeInheritedNameHidesEnclosingName; + break; + case NoError: // 0 - default : - needImplementation(); // want to fail to see why we were - // here... - return; + default: + needImplementation(); // want to fail to see why we were + // here... + return; } - this.handle(id, new String[]{new String(methodDecl.selector), - new String(expectedType.readableName())}, new String[]{ + this.handle(id, new String[] { new String(methodDecl.selector), + new String(expectedType.readableName()) }, new String[] { new String(methodDecl.selector), - new String(expectedType.shortReadableName())}, + new String(expectedType.shortReadableName()) }, methodDecl.returnType.sourceStart, methodDecl.returnType.sourceEnd); } + public void scannerError(Parser parser, String errorTokenName) { Scanner scanner = parser.scanner; int flag = IProblem.ParsingErrorNoSuggestion; int startPos = scanner.startPosition; - //special treatment for recognized errors.... + // special treatment for recognized errors.... if (errorTokenName.equals(Scanner.END_OF_SOURCE)) flag = IProblem.EndOfSource; else if (errorTokenName.equals(Scanner.INVALID_HEXA)) @@ -2313,146 +2980,160 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { flag = IProblem.UnterminatedComment; else if (errorTokenName.equals(Scanner.INVALID_CHAR_IN_STRING)) flag = IProblem.UnterminatedString; - String[] arguments = flag == IProblem.ParsingErrorNoSuggestion - ? new String[]{errorTokenName} + String[] arguments = flag == IProblem.ParsingErrorNoSuggestion ? new String[] { errorTokenName } : NoArgument; - this.handle(flag, arguments, arguments, - // this is the current -invalid- token position + this.handle(flag, arguments, arguments, + // this is the current -invalid- token position startPos, scanner.currentPosition - 1, parser.compilationUnit.compilationResult); } - public void shouldReturn(TypeBinding returnType, AstNode location) { - this.handle(IProblem.ShouldReturnValue, new String[]{new String( - returnType.readableName())}, new String[]{new String(returnType - .shortReadableName())}, location.sourceStart, + + public void shouldReturn(TypeBinding returnType, ASTNode location) { + this.handle(IProblem.ShouldReturnValue, new String[] { new String( + returnType.readableName()) }, new String[] { new String( + returnType.shortReadableName()) }, location.sourceStart, location.sourceEnd); } + public void signalNoImplicitStringConversionForCharArrayExpression( Expression expression) { this.handle(IProblem.NoImplicitStringConversionForCharArrayExpression, NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd); } + public void staticAndInstanceConflict(MethodBinding currentMethod, MethodBinding inheritedMethod) { if (currentMethod.isStatic()) this.handle( - // This static method cannot hide the instance method from %1 + // This static method cannot hide the instance method from + // %1 // 8.4.6.4 - If a class inherits more than one method with // the same signature a static (non-abstract) method cannot // hide an instance method. IProblem.CannotHideAnInstanceMethodWithAStaticMethod, - new String[]{new String(inheritedMethod.declaringClass - .readableName())}, - new String[]{new String(inheritedMethod.declaringClass - .shortReadableName())}, - currentMethod.sourceStart(), currentMethod.sourceEnd()); + new String[] { new String(inheritedMethod.declaringClass + .readableName()) }, + new String[] { new String(inheritedMethod.declaringClass + .shortReadableName()) }, currentMethod + .sourceStart(), currentMethod.sourceEnd()); else this.handle( - // This instance method cannot override the static method from %1 + // This instance method cannot override the static method + // from %1 // 8.4.6.4 - If a class inherits more than one method with // the same signature an instance (non-abstract) method // cannot override a static method. IProblem.CannotOverrideAStaticMethodWithAnInstanceMethod, - new String[]{new String(inheritedMethod.declaringClass - .readableName())}, - new String[]{new String(inheritedMethod.declaringClass - .shortReadableName())}, - currentMethod.sourceStart(), currentMethod.sourceEnd()); + 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())}; + String[] arguments = new String[] { new String(field.readableName()) }; this.handle(IProblem.NonStaticFieldFromStaticInvocation, arguments, arguments, fieldRef.sourceStart, fieldRef.sourceEnd); } + public void staticFieldAccessToNonStaticVariable( QualifiedNameReference nameRef, FieldBinding field) { - String[] arguments = new String[]{new String(field.readableName())}; + String[] arguments = new String[] { new String(field.readableName()) }; this.handle(IProblem.NonStaticFieldFromStaticInvocation, arguments, arguments, nameRef.sourceStart, nameRef.sourceEnd); } + public void staticFieldAccessToNonStaticVariable( SingleNameReference nameRef, FieldBinding field) { - String[] arguments = new String[]{new String(field.readableName())}; + String[] arguments = new String[] { new String(field.readableName()) }; this.handle(IProblem.NonStaticFieldFromStaticInvocation, arguments, arguments, nameRef.sourceStart, nameRef.sourceEnd); } + public void staticInheritedMethodConflicts(SourceTypeBinding type, MethodBinding concreteMethod, MethodBinding[] abstractMethods) { this.handle( - // The static method %1 conflicts with the abstract method in %2 + // The static method %1 conflicts with the abstract method in %2 // 8.4.6.4 - If a class inherits more than one method with the // same signature it is an error for one to be static // (non-abstract) and the other abstract. - IProblem.StaticInheritedMethodConflicts, new String[]{ + IProblem.StaticInheritedMethodConflicts, new String[] { new String(concreteMethod.readableName()), new String(abstractMethods[0].declaringClass - .readableName())}, new String[]{ + .readableName()) }, new String[] { new String(concreteMethod.readableName()), new String(abstractMethods[0].declaringClass - .shortReadableName())}, type.sourceStart(), + .shortReadableName()) }, type.sourceStart(), type.sourceEnd()); } - public void stringConstantIsExceedingUtf8Limit(AstNode location) { + + public void stringConstantIsExceedingUtf8Limit(ASTNode location) { this.handle(IProblem.StringConstantIsExceedingUtf8Limit, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } + public void superclassMustBeAClass(SourceTypeBinding type, TypeReference superclassRef, ReferenceBinding superType) { - this.handle(IProblem.SuperclassMustBeAClass, new String[]{ + this.handle(IProblem.SuperclassMustBeAClass, new String[] { new String(superType.readableName()), - new String(type.sourceName())}, new String[]{ + new String(type.sourceName()) }, new String[] { new String(superType.shortReadableName()), - new String(type.sourceName())}, superclassRef.sourceStart, + new String(type.sourceName()) }, superclassRef.sourceStart, superclassRef.sourceEnd); } + public void superinterfaceMustBeAnInterface(SourceTypeBinding type, TypeDeclaration typeDecl, ReferenceBinding superType) { - this.handle(IProblem.SuperInterfaceMustBeAnInterface, new String[]{ + this.handle(IProblem.SuperInterfaceMustBeAnInterface, new String[] { new String(superType.readableName()), - new String(type.sourceName())}, new String[]{ + new String(type.sourceName()) }, new String[] { new String(superType.shortReadableName()), - new String(type.sourceName())}, typeDecl.sourceStart, + 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.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, + 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, + 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()); @@ -2463,24 +3144,26 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { leftShortName = leftName; rightShortName = rightName; } - this.handle(IProblem.IllegalCast, new String[]{rightName, leftName}, - new String[]{rightShortName, leftShortName}, + this.handle(IProblem.IllegalCast, new String[] { rightName, leftName }, + new String[] { rightShortName, leftShortName }, expression.sourceStart, expression.sourceEnd); } + public void typeCollidesWithPackage( CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) { this.referenceContext = typeDecl; // report the problem against the - // type not the entire compilation - // unit - String[] arguments = new String[]{ + // type not the entire compilation + // unit + String[] arguments = new String[] { new String(compUnitDecl.getFileName()), - new String(typeDecl.name)}; + new String(typeDecl.name) }; this.handle(IProblem.TypeCollidesWithPackage, arguments, arguments, typeDecl.sourceStart, typeDecl.sourceEnd, compUnitDecl.compilationResult); } + public void typeMismatchError(TypeBinding resultType, - TypeBinding expectedType, AstNode location) { + TypeBinding expectedType, ASTNode location) { String resultTypeName = new String(resultType.readableName()); String expectedTypeName = new String(expectedType.readableName()); String resultTypeShortName = new String(resultType.shortReadableName()); @@ -2490,11 +3173,12 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { resultTypeShortName = resultTypeName; expectedTypeShortName = expectedTypeName; } - this.handle(IProblem.TypeMismatch, new String[]{resultTypeName, - expectedTypeName}, new String[]{resultTypeShortName, - expectedTypeShortName}, location.sourceStart, + this.handle(IProblem.TypeMismatch, new String[] { resultTypeName, + expectedTypeName }, new String[] { resultTypeShortName, + expectedTypeShortName }, location.sourceStart, location.sourceEnd); } + public void typeMismatchErrorActualTypeExpectedType(Expression expression, TypeBinding constantType, TypeBinding expectedType) { String constantTypeName = new String(constantType.readableName()); @@ -2507,30 +3191,34 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { constantTypeShortName = constantTypeName; expectedTypeShortName = expectedTypeName; } - this.handle(IProblem.TypeMismatch, new String[]{constantTypeName, - expectedTypeName}, new String[]{constantTypeShortName, - expectedTypeShortName}, expression.sourceStart, + this.handle(IProblem.TypeMismatch, new String[] { constantTypeName, + expectedTypeName }, new String[] { constantTypeShortName, + expectedTypeShortName }, expression.sourceStart, expression.sourceEnd); } - public void undefinedLabel(BranchStatement statement) { - String[] arguments = new String[]{new String(statement.label)}; - this.handle(IProblem.UndefinedLabel, arguments, arguments, - statement.sourceStart, statement.sourceEnd); - } + + // public void undefinedLabel(BranchStatement statement) { + // String[] arguments = new String[] { new String(statement.label) }; + // this.handle(IProblem.UndefinedLabel, arguments, arguments, + // statement.sourceStart, statement.sourceEnd); + // } + public void unexpectedStaticModifierForField(SourceTypeBinding type, FieldDeclaration fieldDecl) { - String[] arguments = new String[]{fieldDecl.name()}; + String[] arguments = new String[] { fieldDecl.name() }; this.handle(IProblem.UnexpectedStaticModifierForField, arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void unexpectedStaticModifierForMethod(ReferenceBinding type, AbstractMethodDeclaration methodDecl) { - String[] arguments = new String[]{new String(type.sourceName()), - new String(methodDecl.selector)}; + String[] arguments = new String[] { new String(type.sourceName()), + new String(methodDecl.selector) }; this.handle(IProblem.UnexpectedStaticModifierForMethod, arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd); } - public void unhandledException(TypeBinding exceptionType, AstNode location) { + + public void unhandledException(TypeBinding exceptionType, ASTNode location) { boolean insideDefaultConstructor = (referenceContext instanceof ConstructorDeclaration) && ((ConstructorDeclaration) referenceContext) .isDefaultConstructor(); @@ -2538,69 +3226,64 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { && (((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper); this .handle( - insideDefaultConstructor - ? IProblem.UnhandledExceptionInDefaultConstructor - : (insideImplicitConstructorCall - ? IProblem.UndefinedConstructorInImplicitConstructorCall + insideDefaultConstructor ? IProblem.UnhandledExceptionInDefaultConstructor + : (insideImplicitConstructorCall ? IProblem.UndefinedConstructorInImplicitConstructorCall : IProblem.UnhandledException), - new String[]{new String(exceptionType.readableName())}, - new String[]{new String(exceptionType - .shortReadableName())}, location.sourceStart, + 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())}; + ASTNode location) { + String[] arguments = new String[] { new String(binding.readableName()) }; this.handle(IProblem.UninitializedBlankFinalField, 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, arguments, arguments, - location.sourceStart, location.sourceEnd); - } + public void unmatchedBracket(int position, ReferenceContext context, CompilationResult compilationResult) { this.handle(IProblem.UnmatchedBracket, NoArgument, NoArgument, position, position, context, compilationResult); } + public void unnecessaryEnclosingInstanceSpecification( Expression expression, ReferenceBinding targetType) { this.handle(IProblem.IllegalEnclosingInstanceSpecification, - new String[]{new String(targetType.readableName())}, - new String[]{new String(targetType.shortReadableName())}, + new String[] { new String(targetType.readableName()) }, + new String[] { new String(targetType.shortReadableName()) }, expression.sourceStart, expression.sourceEnd); } - public void unnecessaryReceiverForStaticMethod(AstNode location, + + public void unnecessaryReceiverForStaticMethod(ASTNode location, MethodBinding method) { - this.handle(IProblem.NonStaticAccessToStaticMethod, new String[]{ + this.handle(IProblem.NonStaticAccessToStaticMethod, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass.shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, location.sourceStart, - location.sourceEnd); + parametersAsShortString(method) }, + location.sourceStart, location.sourceEnd); } - public void unnecessaryReceiverForStaticField(AstNode location, + + public void unnecessaryReceiverForStaticField(ASTNode location, FieldBinding field) { - this.handle(IProblem.NonStaticAccessToStaticField, new String[]{ + this.handle(IProblem.NonStaticAccessToStaticField, new String[] { new String(field.declaringClass.readableName()), - new String(field.name)}, new String[]{ + new String(field.name) }, new String[] { new String(field.declaringClass.shortReadableName()), - new String(field.name)}, location.sourceStart, + new String(field.name) }, location.sourceStart, location.sourceEnd); } - public void unreachableCode(Statement statement) { - this.handle(IProblem.CodeCannotBeReached, NoArgument, NoArgument, - statement.sourceStart, statement.sourceEnd); - } + public void unreachableExceptionHandler(ReferenceBinding exceptionType, - AstNode location) { + ASTNode location) { this.handle(IProblem.UnreachableCatch, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } + public void unresolvableReference(NameReference nameRef, Binding binding) { int severity = Error; /* @@ -2610,26 +3293,29 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { * problem.searchType.isHierarchyInconsistent()) severity = * SecondaryError; } */ - String[] arguments = new String[]{new String(binding.readableName())}; + String[] arguments = new String[] { new String(binding.readableName()) }; this.handle(IProblem.UndefinedName, arguments, arguments, severity, nameRef.sourceStart, nameRef.sourceEnd); } + public void unusedArgument(LocalDeclaration localDecl) { - String[] arguments = new String[]{localDecl.name()}; + String[] arguments = new String[] { localDecl.name() }; this.handle(IProblem.ArgumentIsNeverUsed, arguments, arguments, localDecl.sourceStart, localDecl.sourceEnd); } - public void unusedImport(ImportReference importRef) { - String[] arguments = new String[]{CharOperation - .toString(importRef.tokens)}; - this.handle(IProblem.UnusedImport, arguments, arguments, - importRef.sourceStart, importRef.sourceEnd); - } + + // public void unusedImport(ImportReference importRef) { + // String[] arguments = new + // String[]{CharOperation.toString(importRef.tokens)}; + // this.handle(IProblem.UnusedImport, arguments, arguments, + // importRef.sourceStart, importRef.sourceEnd); + // } public void unusedLocalVariable(LocalDeclaration localDecl) { - String[] arguments = new String[]{localDecl.name()}; + String[] arguments = new String[] { localDecl.name() }; this.handle(IProblem.LocalVariableIsNeverUsed, arguments, arguments, localDecl.sourceStart, localDecl.sourceEnd); } + public void unusedPrivateConstructor(ConstructorDeclaration constructorDecl) { if (computeSeverity(IProblem.UnusedPrivateConstructor) == Ignore) return; @@ -2639,13 +3325,14 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { || constructorDecl.arguments.length == 0) return; MethodBinding constructor = constructorDecl.binding; - this.handle(IProblem.UnusedPrivateConstructor, new String[]{ + this.handle(IProblem.UnusedPrivateConstructor, new String[] { new String(constructor.declaringClass.readableName()), - parametersAsString(constructor)}, new String[]{ + parametersAsString(constructor) }, new String[] { new String(constructor.declaringClass.shortReadableName()), - parametersAsShortString(constructor)}, + parametersAsShortString(constructor) }, constructorDecl.sourceStart, constructorDecl.sourceEnd); } + public void unusedPrivateField(FieldDeclaration fieldDecl) { if (computeSeverity(IProblem.UnusedPrivateField) == Ignore) return; @@ -2655,13 +3342,14 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { && TypeBinding.LongBinding == field.type) { return; // do not report unused serialVersionUID field } - this.handle(IProblem.UnusedPrivateField, new String[]{ + this.handle(IProblem.UnusedPrivateField, new String[] { new String(field.declaringClass.readableName()), - new String(field.name),}, new String[]{ + new String(field.name), }, new String[] { new String(field.declaringClass.shortReadableName()), - new String(field.name),}, fieldDecl.sourceStart, + new String(field.name), }, fieldDecl.sourceStart, fieldDecl.sourceEnd); } + public void unusedPrivateMethod(AbstractMethodDeclaration methodDecl) { if (computeSeverity(IProblem.UnusedPrivateMethod) == Ignore) return; @@ -2708,84 +3396,92 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { TypeConstants.WRITEREPLACE)) { return; } - this.handle(IProblem.UnusedPrivateMethod, new String[]{ + this.handle(IProblem.UnusedPrivateMethod, new String[] { new String(method.declaringClass.readableName()), - new String(method.selector), parametersAsString(method)}, - new String[]{ + new String(method.selector), parametersAsString(method) }, + new String[] { new String(method.declaringClass.shortReadableName()), new String(method.selector), - parametersAsShortString(method)}, + 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, + this.handle(IProblem.UnusedPrivateType, new String[] { new String(type + .readableName()), }, new String[] { new String(type + .shortReadableName()), }, typeDecl.sourceStart, typeDecl.sourceEnd); } + public void useAssertAsAnIdentifier(int sourceStart, int sourceEnd) { this.handle(IProblem.UseAssertAsAnIdentifier, NoArgument, NoArgument, sourceStart, sourceEnd); } + public void variableTypeCannotBeVoid(AbstractVariableDeclaration varDecl) { - String[] arguments = new String[]{new String(varDecl.name)}; + String[] arguments = new String[] { new String(varDecl.name) }; this.handle(IProblem.VariableTypeCannotBeVoid, arguments, arguments, varDecl.sourceStart, varDecl.sourceEnd); } + public void variableTypeCannotBeVoidArray( AbstractVariableDeclaration varDecl) { - String[] arguments = new String[]{new String(varDecl.name)}; + String[] arguments = new String[] { new String(varDecl.name) }; this.handle(IProblem.VariableTypeCannotBeVoidArray, arguments, arguments, varDecl.sourceStart, varDecl.sourceEnd); } + public void visibilityConflict(MethodBinding currentMethod, MethodBinding inheritedMethod) { this.handle( - // Cannot reduce the visibility of the inherited method from %1 + // Cannot reduce the visibility of the inherited method from %1 // 8.4.6.3 - The access modifier of an hiding method must // provide at least as much access as the hidden method. // 8.4.6.3 - The access modifier of an overiding method must // provide at least as much access as the overriden method. - IProblem.MethodReducesVisibility, new String[]{new String( - inheritedMethod.declaringClass.readableName())}, - new String[]{new String(inheritedMethod.declaringClass - .shortReadableName())}, currentMethod.sourceStart(), + IProblem.MethodReducesVisibility, new String[] { new String( + inheritedMethod.declaringClass.readableName()) }, + new String[] { new String(inheritedMethod.declaringClass + .shortReadableName()) }, currentMethod.sourceStart(), currentMethod.sourceEnd()); } + public void wrongSequenceOfExceptionTypesError(TryStatement statement, int under, int upper) { - //the two catch block under and upper are in an incorrect order. - //under should be define BEFORE upper in the source + // the two catch block under and upper are in an incorrect order. + // under should be define BEFORE upper in the source TypeReference typeRef = statement.catchArguments[under].type; this.handle(IProblem.UnreachableCatch, NoArgument, NoArgument, typeRef.sourceStart, typeRef.sourceEnd); } - public void nonExternalizedStringLiteral(AstNode location) { + + public void nonExternalizedStringLiteral(ASTNode location) { this.handle(IProblem.NonExternalizedStringLiteral, NoArgument, NoArgument, location.sourceStart, location.sourceEnd); } + public void noMoreAvailableSpaceForConstant(TypeDeclaration typeDeclaration) { - this - .handle(IProblem.TooManyBytesForStringConstant, - new String[]{new String(typeDeclaration.binding - .readableName())}, new String[]{new String( - typeDeclaration.binding.shortReadableName())}, - Abort | Error, typeDeclaration.sourceStart, - typeDeclaration.sourceEnd); - } + 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); - } + this.handle(IProblem.TooManyConstantsInConstantPool, + new String[] { new String(typeDeclaration.binding + .readableName()) }, new String[] { new String( + typeDeclaration.binding.shortReadableName()) }, Abort + | Error, typeDeclaration.sourceStart, + typeDeclaration.sourceEnd); + } + private boolean isKeyword(char[] tokenSource) { /* * This code is heavily grammar dependant @@ -2806,77 +3502,77 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { int nextToken = scanner.getNextToken(); if (nextToken == Scanner.TokenNameEOF && scanner.startPosition == scanner.source.length) { // to - // handle - // case - // where - // we - // had - // an - // ArrayIndexOutOfBoundsException + // handle + // case + // where + // we + // had + // an + // ArrayIndexOutOfBoundsException // while reading the last token switch (token) { - case Scanner.TokenNameERROR : - if (CharOperation.equals("goto".toCharArray(), - currentKeyword) - || CharOperation.equals("const".toCharArray(), - currentKeyword)) { //$NON-NLS-1$ //$NON-NLS-2$ - return true; - } else { - return false; - } - 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.TokenNameclass : - case Scanner.TokenNamecontinue : - case Scanner.TokenNamedo : - // case Scanner.TokenNamedouble: - case Scanner.TokenNamedefault : - case Scanner.TokenNameelse : - case Scanner.TokenNameextends : - case Scanner.TokenNamefor : - // case Scanner.TokenNamefinal: - // case Scanner.TokenNamefloat: - case Scanner.TokenNamefalse : - case Scanner.TokenNamefinally : - case Scanner.TokenNameif : - // case Scanner.TokenNameint: - // case Scanner.TokenNameimport: - case Scanner.TokenNameinterface : - case Scanner.TokenNameimplements : - case Scanner.TokenNameinstanceof : - // case Scanner.TokenNamelong: - case Scanner.TokenNamenew : - case Scanner.TokenNamenull : - // case Scanner.TokenNamenative: - case Scanner.TokenNamepublic : - // case Scanner.TokenNamepackage: - case Scanner.TokenNameprivate : - case Scanner.TokenNameprotected : - case Scanner.TokenNamereturn : - // case Scanner.TokenNameshort: - case Scanner.TokenNamesuper : - case Scanner.TokenNamestatic : - case Scanner.TokenNameswitch : - // case Scanner.TokenNamestrictfp: - // case Scanner.TokenNamesynchronized: - case Scanner.TokenNametry : - case Scanner.TokenNamethis : - case Scanner.TokenNametrue : - case Scanner.TokenNamethrow : - // case Scanner.TokenNamethrows: - // case Scanner.TokenNametransient: - // case Scanner.TokenNamevoid: - // case Scanner.TokenNamevolatile: - case Scanner.TokenNamewhile : + case Scanner.TokenNameERROR: + if (CharOperation.equals("goto".toCharArray(), + currentKeyword) + || CharOperation.equals( + "const".toCharArray(), currentKeyword)) { //$NON-NLS-1$ //$NON-NLS-2$ return true; - default : + } else { return false; + } + 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.TokenNameclass: + case Scanner.TokenNamecontinue: + case Scanner.TokenNamedo: + // case Scanner.TokenNamedouble: + case Scanner.TokenNamedefault: + case Scanner.TokenNameelse: + case Scanner.TokenNameextends: + case Scanner.TokenNamefor: + // case Scanner.TokenNamefinal: + // case Scanner.TokenNamefloat: + // case Scanner.TokenNamefalse : + case Scanner.TokenNamefinally: + case Scanner.TokenNameif: + // case Scanner.TokenNameint: + // case Scanner.TokenNameimport: + case Scanner.TokenNameinterface: + case Scanner.TokenNameimplements: + case Scanner.TokenNameinstanceof: + // case Scanner.TokenNamelong: + case Scanner.TokenNamenew: + // case Scanner.TokenNamenull : + // case Scanner.TokenNamenative: + case Scanner.TokenNamepublic: + // case Scanner.TokenNamepackage: + case Scanner.TokenNameprivate: + case Scanner.TokenNameprotected: + case Scanner.TokenNamereturn: + // case Scanner.TokenNameshort: + case Scanner.TokenNamesuper: + case Scanner.TokenNamestatic: + case Scanner.TokenNameswitch: + // case Scanner.TokenNamestrictfp: + // case Scanner.TokenNamesynchronized: + case Scanner.TokenNametry: + // case Scanner.TokenNamethis : + // case Scanner.TokenNametrue : + case Scanner.TokenNamethrow: + // case Scanner.TokenNamethrows: + // case Scanner.TokenNametransient: + // case Scanner.TokenNamevoid: + // case Scanner.TokenNamevolatile: + case Scanner.TokenNamewhile: + return true; + default: + return false; } } else { return false; @@ -2885,6 +3581,7 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { return false; } } + // jsurfer start public void phpParsingError(String[] messageArguments, int problemStartPosition, int problemEndPosition, @@ -2893,4 +3590,76 @@ public class ProblemReporter extends ProblemHandler implements ProblemReasons { problemStartPosition, problemEndPosition, context, compilationResult); } -} + +// public void phpParsingWarning(String[] messageArguments, +// int problemStartPosition, int problemEndPosition, +// ReferenceContext context, CompilationResult compilationResult) { +// this.handle(IProblem.PHPParsingWarning, NoArgument, messageArguments, +// problemStartPosition, problemEndPosition, context, +// compilationResult); +// } + + public void phpVarDeprecatedWarning(int problemStartPosition, + int problemEndPosition, ReferenceContext context, + CompilationResult compilationResult) { + if (computeSeverity(IProblem.PHPVarDeprecatedWarning) == Ignore) + return; + this.handle(IProblem.PHPVarDeprecatedWarning, NoArgument, + new String[] {}, problemStartPosition, problemEndPosition, + context, compilationResult); + } + + public void phpIncludeNotExistWarning(String[] messageArguments, + int problemStartPosition, int problemEndPosition, + ReferenceContext context, CompilationResult compilationResult) { + if (computeSeverity(IProblem.PHPIncludeNotExistWarning) == Ignore) + return; + this.handle(IProblem.PHPIncludeNotExistWarning, NoArgument, + messageArguments, problemStartPosition, problemEndPosition, + context, compilationResult); + } + + public void phpKeywordWarning(String[] messageArguments, + int problemStartPosition, int problemEndPosition, + ReferenceContext context, CompilationResult compilationResult) { + if (computeSeverity(IProblem.PHPBadStyleKeywordWarning) == Ignore) + return; + this.handle(IProblem.PHPBadStyleKeywordWarning, NoArgument, + messageArguments, problemStartPosition, problemEndPosition, + context, compilationResult); + } + + public void phpUppercaseIdentifierWarning(int problemStartPosition, + int problemEndPosition, ReferenceContext context, + CompilationResult compilationResult) { + if (computeSeverity(IProblem.PHPBadStyleUppercaseIdentifierWarning) == Ignore) + return; + this.handle(IProblem.PHPBadStyleUppercaseIdentifierWarning, NoArgument, + new String[] {}, problemStartPosition, problemEndPosition, + context, compilationResult); + } + + public void uninitializedLocalVariable(String token, + int problemStartPosition, int problemEndPosition, + ReferenceContext context, CompilationResult compilationResult) { + if (computeSeverity(IProblem.UninitializedLocalVariable) == Ignore) + return; + // String[] arguments = new String[] { new + // String(binding.readableName()) }; + String[] arguments = new String[] { token }; + this.handle(IProblem.UninitializedLocalVariable, arguments, arguments, + problemStartPosition, problemEndPosition, context, + compilationResult); + } + + public void unreachableCode(String token, int problemStartPosition, + int problemEndPosition, ReferenceContext context, + CompilationResult compilationResult) { + if (computeSeverity(IProblem.CodeCannotBeReached) == Ignore) + return; + this.handle(IProblem.CodeCannotBeReached, NoArgument, new String[] {}, + problemStartPosition, problemEndPosition, context, + compilationResult); + } + +} \ No newline at end of file