net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/problem/ProblemReporter.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.problem;
  12 import net.sourceforge.phpdt.core.compiler.CharOperation;
  13 import net.sourceforge.phpdt.core.compiler.IProblem;
  14 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
  15 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
  16 import net.sourceforge.phpdt.internal.compiler.IErrorHandlingPolicy;
  17 import net.sourceforge.phpdt.internal.compiler.IProblemFactory;
  18 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
  19 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  20 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
  21 import net.sourceforge.phpdt.internal.compiler.lookup.Binding;
  22 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
  23 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
  24 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
  25 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemMethodBinding;
  26 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReasons;
  27 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  28 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  29 import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticArgumentBinding;
  30 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  31 import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
  32 import net.sourceforge.phpdt.internal.compiler.parser.Parser;
  33 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
  34 import net.sourceforge.phpdt.internal.compiler.util.Util;
  35 import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration;
  36 import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractVariableDeclaration;
  37 import net.sourceforge.phpeclipse.internal.compiler.ast.AllocationExpression;
  38 import net.sourceforge.phpeclipse.internal.compiler.ast.Argument;
  39 import net.sourceforge.phpeclipse.internal.compiler.ast.ArrayAllocationExpression;
  40 import net.sourceforge.phpeclipse.internal.compiler.ast.ArrayReference;
  41 import net.sourceforge.phpeclipse.internal.compiler.ast.Assignment;
  42 import net.sourceforge.phpeclipse.internal.compiler.ast.AstNode;
  43 import net.sourceforge.phpeclipse.internal.compiler.ast.BinaryExpression;
  44 import net.sourceforge.phpeclipse.internal.compiler.ast.BranchStatement;
  45 import net.sourceforge.phpeclipse.internal.compiler.ast.Case;
  46 import net.sourceforge.phpeclipse.internal.compiler.ast.CastExpression;
  47 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
  48 import net.sourceforge.phpeclipse.internal.compiler.ast.CompoundAssignment;
  49 import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration;
  50 import net.sourceforge.phpeclipse.internal.compiler.ast.DefaultCase;
  51 import net.sourceforge.phpeclipse.internal.compiler.ast.EqualExpression;
  52 import net.sourceforge.phpeclipse.internal.compiler.ast.ExplicitConstructorCall;
  53 import net.sourceforge.phpeclipse.internal.compiler.ast.Expression;
  54 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
  55 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldReference;
  56 import net.sourceforge.phpeclipse.internal.compiler.ast.InstanceOfExpression;
  57 import net.sourceforge.phpeclipse.internal.compiler.ast.IntLiteral;
  58 import net.sourceforge.phpeclipse.internal.compiler.ast.Literal;
  59 import net.sourceforge.phpeclipse.internal.compiler.ast.LocalDeclaration;
  60 import net.sourceforge.phpeclipse.internal.compiler.ast.LongLiteral;
  61 import net.sourceforge.phpeclipse.internal.compiler.ast.MessageSend;
  62 import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
  63 import net.sourceforge.phpeclipse.internal.compiler.ast.NameReference;
  64 import net.sourceforge.phpeclipse.internal.compiler.ast.NumberLiteral;
  65 import net.sourceforge.phpeclipse.internal.compiler.ast.QualifiedNameReference;
  66 import net.sourceforge.phpeclipse.internal.compiler.ast.Reference;
  67 import net.sourceforge.phpeclipse.internal.compiler.ast.ReturnStatement;
  68 import net.sourceforge.phpeclipse.internal.compiler.ast.SingleNameReference;
  69 import net.sourceforge.phpeclipse.internal.compiler.ast.Statement;
  70 import net.sourceforge.phpeclipse.internal.compiler.ast.ThisReference;
  71 import net.sourceforge.phpeclipse.internal.compiler.ast.ThrowStatement;
  72 import net.sourceforge.phpeclipse.internal.compiler.ast.TryStatement;
  73 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
  74 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeReference;
  75 import net.sourceforge.phpeclipse.internal.compiler.ast.UnaryExpression;
  76 public class ProblemReporter extends ProblemHandler implements ProblemReasons {
  77   public ReferenceContext referenceContext;
  78   public ProblemReporter(IErrorHandlingPolicy policy,
  79       CompilerOptions options,
  80       IProblemFactory problemFactory) {
  81
  82    // IProblemFactory problemFactory) {
  83     super(policy, options, problemFactory); //), problemFactory);
  84   }
  85   public void abortDueToInternalError(String errorMessage) {
  86     String[] arguments = new String[]{errorMessage};
  87     this.handle(IProblem.Unclassified, arguments, arguments, Error | Abort, 0,
  88         0);
  89   }
  90   public void abortDueToInternalError(String errorMessage, AstNode location) {
  91     String[] arguments = new String[]{errorMessage};
  92     this.handle(IProblem.Unclassified, arguments, arguments, Error | Abort,
  93         location.sourceStart, location.sourceEnd);
  94   }
  95   public void abstractMethodCannotBeOverridden(SourceTypeBinding type,
  96       MethodBinding concreteMethod) {
  97     this
  98         .handle(
  99         // %1 must be abstract since it cannot override the inherited
 100             // package-private abstract method %2
 101             IProblem.AbstractMethodCannotBeOverridden, new String[]{
 102                 new String(type.sourceName()),
 103                 new String(CharOperation.concat(concreteMethod.declaringClass
 104                     .readableName(), concreteMethod.readableName(), '.'))},
 105             new String[]{
 106                 new String(type.sourceName()),
 107                 new String(CharOperation.concat(concreteMethod.declaringClass
 108                     .shortReadableName(), concreteMethod.shortReadableName(),
 109                     '.'))}, type.sourceStart(), type.sourceEnd());
 110   }
 111   public void abstractMethodInAbstractClass(SourceTypeBinding type,
 112       AbstractMethodDeclaration methodDecl) {
 113     String[] arguments = new String[]{new String(type.sourceName()),
 114         new String(methodDecl.selector)};
 115     this.handle(IProblem.AbstractMethodInAbstractClass, arguments, arguments,
 116         methodDecl.sourceStart, methodDecl.sourceEnd);
 117   }
 118   public void abstractMethodMustBeImplemented(SourceTypeBinding type,
 119       MethodBinding abstractMethod) {
 120     this.handle(
 121     // Must implement the inherited abstract method %1
 122         // 8.4.3 - Every non-abstract subclass of an abstract type, A,
 123         // must provide a concrete implementation of all of A's
 124         // methods.
 125         IProblem.AbstractMethodMustBeImplemented, new String[]{new String(
 126             CharOperation.concat(abstractMethod.declaringClass.readableName(),
 127                 abstractMethod.readableName(), '.'))},
 128         new String[]{new String(CharOperation.concat(
 129             abstractMethod.declaringClass.shortReadableName(), abstractMethod
 130                 .shortReadableName(), '.'))}, type.sourceStart(), type
 131             .sourceEnd());
 132   }
 133   public void abstractMethodNeedingNoBody(AbstractMethodDeclaration method) {
 134     this.handle(IProblem.BodyForAbstractMethod, NoArgument, NoArgument,
 135         method.sourceStart, method.sourceEnd, method, method
 136             .compilationResult());
 137   }
 138   public void alreadyDefinedLabel(char[] labelName, AstNode location) {
 139     String[] arguments = new String[]{new String(labelName)};
 140     this.handle(IProblem.DuplicateLabel, arguments, arguments,
 141         location.sourceStart, location.sourceEnd);
 142   }
 143   public void anonymousClassCannotExtendFinalClass(Expression expression,
 144       TypeBinding type) {
 145     this.handle(IProblem.AnonymousClassCannotExtendFinalClass,
 146         new String[]{new String(type.readableName())}, new String[]{new String(
 147             type.shortReadableName())}, expression.sourceStart,
 148         expression.sourceEnd);
 149   }
 150   public void argumentTypeCannotBeVoid(SourceTypeBinding type,
 151       AbstractMethodDeclaration methodDecl, Argument arg) {
 152     String[] arguments = new String[]{new String(methodDecl.selector),
 153         new String(arg.name)};
 154     this.handle(IProblem.ArgumentTypeCannotBeVoid, arguments, arguments,
 155         methodDecl.sourceStart, methodDecl.sourceEnd);
 156   }
 157   public void argumentTypeCannotBeVoidArray(SourceTypeBinding type,
 158       AbstractMethodDeclaration methodDecl, Argument arg) {
 159     String[] arguments = new String[]{new String(methodDecl.selector),
 160         new String(arg.name)};
 161     this.handle(IProblem.ArgumentTypeCannotBeVoidArray, arguments, arguments,
 162         methodDecl.sourceStart, methodDecl.sourceEnd);
 163   }
 164   public void argumentTypeProblem(SourceTypeBinding type,
 165       AbstractMethodDeclaration methodDecl, Argument arg,
 166       TypeBinding expectedType) {
 167     int problemId = expectedType.problemId();
 168     int id;
 169     switch (problemId) {
 170       case NotFound :
 171         // 1
 172         id = IProblem.ArgumentTypeNotFound;
 173         break;
 174       case NotVisible :
 175         // 2
 176         id = IProblem.ArgumentTypeNotVisible;
 177         break;
 178       case Ambiguous :
 179         // 3
 180         id = IProblem.ArgumentTypeAmbiguous;
 181         break;
 182       case InternalNameProvided :
 183         // 4
 184         id = IProblem.ArgumentTypeInternalNameProvided;
 185         break;
 186       case InheritedNameHidesEnclosingName :
 187         // 5
 188         id = IProblem.ArgumentTypeInheritedNameHidesEnclosingName;
 189         break;
 190       case NoError :
 191       // 0
 192       default :
 193         needImplementation(); // want to fail to see why we were
 194         // here...
 195         return;
 196     }
 197     this.handle(id, new String[]{new String(methodDecl.selector), arg.name(),
 198         new String(expectedType.readableName())}, new String[]{
 199         new String(methodDecl.selector), arg.name(),
 200         new String(expectedType.shortReadableName())}, arg.type.sourceStart,
 201         arg.type.sourceEnd);
 202   }
 203   public void arrayConstantsOnlyInArrayInitializers(int sourceStart,
 204       int sourceEnd) {
 205     this.handle(IProblem.ArrayConstantsOnlyInArrayInitializers, NoArgument,
 206         NoArgument, sourceStart, sourceEnd);
 207   }
 208   public void assignmentHasNoEffect(Assignment assignment, char[] name) {
 209     String[] arguments = new String[]{new String(name)};
 210     this.handle(IProblem.AssignmentHasNoEffect, arguments, arguments,
 211         assignment.sourceStart, assignment.sourceEnd);
 212   }
 213   public void attemptToReturnNonVoidExpression(ReturnStatement returnStatement,
 214       TypeBinding expectedType) {
 215     this.handle(IProblem.VoidMethodReturnsValue, new String[]{new String(
 216         expectedType.readableName())}, new String[]{new String(expectedType
 217         .shortReadableName())}, returnStatement.sourceStart,
 218         returnStatement.sourceEnd);
 219   }
 220   public void attemptToReturnVoidValue(ReturnStatement returnStatement) {
 221     this.handle(IProblem.MethodReturnsVoid, NoArgument, NoArgument,
 222         returnStatement.sourceStart, returnStatement.sourceEnd);
 223   }
 224   //public void bytecodeExceeds64KLimit(AbstractMethodDeclaration location)
 225   // {
 226   //    String[] arguments = new String[] {new String(location.selector),
 227   // parametersAsString(location.binding)};
 228   //    if (location.isConstructor()) {
 229   //            this.handle(
 230   //                    IProblem.BytecodeExceeds64KLimitForConstructor,
 231   //                    arguments,
 232   //                    arguments,
 233   //                    Error | Abort,
 234   //                    location.sourceStart,
 235   //                    location.sourceEnd);
 236   //    } else {
 237   //            this.handle(
 238   //                    IProblem.BytecodeExceeds64KLimit,
 239   //                    arguments,
 240   //                    arguments,
 241   //                    Error | Abort,
 242   //                    location.sourceStart,
 243   //                    location.sourceEnd);
 244   //    }
 245   //}
 246   public void bytecodeExceeds64KLimit(TypeDeclaration location) {
 247     this.handle(IProblem.BytecodeExceeds64KLimitForClinit, NoArgument,
 248         NoArgument, Error | Abort, location.sourceStart, location.sourceEnd);
 249   }
 250   public void cannotAllocateVoidArray(Expression expression) {
 251     this.handle(IProblem.CannotAllocateVoidArray, NoArgument, NoArgument,
 252         expression.sourceStart, expression.sourceEnd);
 253   }
 254   public void cannotAssignToFinalField(FieldBinding field, AstNode location) {
 255     this.handle(IProblem.FinalFieldAssignment, new String[]{
 256         (field.declaringClass == null ? "array" : new String(
 257             field.declaringClass.readableName())), //$NON-NLS-1$
 258         new String(field.readableName())}, new String[]{
 259         (field.declaringClass == null ? "array" : new String(
 260             field.declaringClass.shortReadableName())), //$NON-NLS-1$
 261         new String(field.shortReadableName())}, location.sourceStart,
 262         location.sourceEnd);
 263   }
 264   public void cannotAssignToFinalLocal(LocalVariableBinding local,
 265       AstNode location) {
 266     String[] arguments = new String[]{new String(local.readableName())};
 267     this.handle(IProblem.NonBlankFinalLocalAssignment, arguments, arguments,
 268         location.sourceStart, location.sourceEnd);
 269   }
 270   public void cannotAssignToFinalOuterLocal(LocalVariableBinding local,
 271       AstNode location) {
 272     String[] arguments = new String[]{new String(local.readableName())};
 273     this.handle(IProblem.FinalOuterLocalAssignment, arguments, arguments,
 274         location.sourceStart, location.sourceEnd);
 275   }
 276   public void cannotDeclareLocalInterface(char[] interfaceName,
 277       int sourceStart, int sourceEnd) {
 278     String[] arguments = new String[]{new String(interfaceName)};
 279     this.handle(IProblem.CannotDefineInterfaceInLocalType, arguments,
 280         arguments, sourceStart, sourceEnd);
 281   }
 282   public void cannotDefineDimensionsAndInitializer(
 283       ArrayAllocationExpression expresssion) {
 284     this.handle(IProblem.CannotDefineDimensionExpressionsWithInit, NoArgument,
 285         NoArgument, expresssion.sourceStart, expresssion.sourceEnd);
 286   }
 287   public void cannotDireclyInvokeAbstractMethod(MessageSend messageSend,
 288       MethodBinding method) {
 289     this.handle(IProblem.DirectInvocationOfAbstractMethod, new String[]{
 290         new String(method.declaringClass.readableName()),
 291         new String(method.selector), parametersAsString(method)}, new String[]{
 292         new String(method.declaringClass.shortReadableName()),
 293         new String(method.selector), parametersAsShortString(method)},
 294         messageSend.sourceStart, messageSend.sourceEnd);
 295   }
 296 //  public void cannotImportPackage(ImportReference importRef) {
 297 //    String[] arguments = new String[]{CharOperation.toString(importRef.tokens)};
 298 //    this.handle(IProblem.CannotImportPackage, arguments, arguments,
 299 //        importRef.sourceStart, importRef.sourceEnd);
 300 //  }
 301   public void cannotInstantiate(TypeReference typeRef, TypeBinding type) {
 302     this.handle(IProblem.InvalidClassInstantiation, new String[]{new String(
 303         type.readableName())},
 304         new String[]{new String(type.shortReadableName())},
 305         typeRef.sourceStart, typeRef.sourceEnd);
 306   }
 307   public void cannotReferToNonFinalOuterLocal(LocalVariableBinding local,
 308       AstNode location) {
 309     String[] arguments = new String[]{new String(local.readableName())};
 310     this.handle(IProblem.OuterLocalMustBeFinal, arguments, arguments,
 311         location.sourceStart, location.sourceEnd);
 312   }
 313   public void cannotReturnInInitializer(AstNode location) {
 314     this.handle(IProblem.CannotReturnInInitializer, NoArgument, NoArgument,
 315         location.sourceStart, location.sourceEnd);
 316   }
 317   public void cannotThrowNull(ThrowStatement statement) {
 318     this.handle(IProblem.CannotThrowNull, NoArgument, NoArgument,
 319         statement.sourceStart, statement.sourceEnd);
 320   }
 321   public void cannotThrowType(SourceTypeBinding type,
 322       AbstractMethodDeclaration methodDecl, TypeReference exceptionType,
 323       TypeBinding expectedType) {
 324     this.handle(IProblem.CannotThrowType, new String[]{new String(expectedType
 325         .readableName())}, new String[]{new String(expectedType
 326         .shortReadableName())}, exceptionType.sourceStart,
 327         exceptionType.sourceEnd);
 328   }
 329   public void cannotUseSuperInJavaLangObject(AstNode reference) {
 330     this.handle(IProblem.ObjectHasNoSuperclass, NoArgument, NoArgument,
 331         reference.sourceStart, reference.sourceEnd);
 332   }
 333   public void cannotUseSuperInCodeSnippet(int start, int end) {
 334     this.handle(IProblem.CannotUseSuperInCodeSnippet, NoArgument, NoArgument,
 335         Error | Abort, start, end);
 336   }
 337   public void caseExpressionMustBeConstant(Expression expression) {
 338     this.handle(IProblem.NonConstantExpression, NoArgument, NoArgument,
 339         expression.sourceStart, expression.sourceEnd);
 340   }
 341   public void classExtendFinalClass(SourceTypeBinding type,
 342       TypeReference superclass, TypeBinding expectedType) {
 343     String name = new String(type.sourceName());
 344     String expectedFullName = new String(expectedType.readableName());
 345     String expectedShortName = new String(expectedType.shortReadableName());
 346     if (expectedShortName.equals(name))
 347       expectedShortName = expectedFullName;
 348     this.handle(IProblem.ClassExtendFinalClass, new String[]{expectedFullName,
 349         name}, new String[]{expectedShortName, name}, superclass.sourceStart,
 350         superclass.sourceEnd);
 351   }
 352   public void codeSnippetMissingClass(String missing, int start, int end) {
 353     String[] arguments = new String[]{missing};
 354     this.handle(IProblem.CodeSnippetMissingClass, arguments, arguments, Error
 355         | Abort, start, end);
 356   }
 357   public void codeSnippetMissingMethod(String className, String missingMethod,
 358       String argumentTypes, int start, int end) {
 359     String[] arguments = new String[]{className, missingMethod, argumentTypes};
 360     this.handle(IProblem.CodeSnippetMissingMethod, arguments, arguments, Error
 361         | Abort, start, end);
 362   }
 363   /*
 364    * Given the current configuration, answers which category the problem
 365    * falls into:
 366    *            Error | Warning | Ignore
 367    */
 368   public int computeSeverity(int problemId){
 369
 370         // severity can have been preset on the problem
 371 //      if ((problem.severity & Fatal) != 0){
 372 //              return Error;
 373 //      }
 374
 375         // if not then check whether it is a configurable problem
 376         switch(problemId){
 377             case IProblem.PHPVarDeprecatedWarning :
 378                   return this.options.getSeverity(CompilerOptions.PHPVarDeprecatedWarning);
 379             case IProblem.PHPBadStyleKeywordWarning :
 380                   return this.options.getSeverity(CompilerOptions.PHPBadStyleKeywordWarning);
 381             case IProblem.PHPBadStyleUppercaseIdentifierWarning :
 382               return this.options.getSeverity(CompilerOptions.PHPBadStyleUppercaseIdentifierWarning);
 383
 384                 case IProblem.MaskedCatch :
 385                         return this.options.getSeverity(CompilerOptions.MaskedCatchBlock);
 386
 387                 case IProblem.UnusedImport :
 388                         return this.options.getSeverity(CompilerOptions.UnusedImport);
 389
 390                 case IProblem.MethodButWithConstructorName :
 391                         return this.options.getSeverity(CompilerOptions.MethodWithConstructorName);
 392
 393                 case IProblem.OverridingNonVisibleMethod :
 394                         return this.options.getSeverity(CompilerOptions.OverriddenPackageDefaultMethod);
 395
 396                 case IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod :
 397                 case IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod :
 398                         return this.options.getSeverity(CompilerOptions.IncompatibleNonInheritedInterfaceMethod);
 399
 400                 case IProblem.OverridingDeprecatedMethod :
 401                 case IProblem.UsingDeprecatedType :
 402                 case IProblem.UsingDeprecatedMethod :
 403                 case IProblem.UsingDeprecatedConstructor :
 404                 case IProblem.UsingDeprecatedField :
 405                         return this.options.getSeverity(CompilerOptions.UsingDeprecatedAPI);
 406
 407                 case IProblem.LocalVariableIsNeverUsed :
 408                         return this.options.getSeverity(CompilerOptions.UnusedLocalVariable);
 409
 410                 case IProblem.ArgumentIsNeverUsed :
 411                         return this.options.getSeverity(CompilerOptions.UnusedArgument);
 412
 413                 case IProblem.NoImplicitStringConversionForCharArrayExpression :
 414                         return this.options.getSeverity(CompilerOptions.NoImplicitStringConversion);
 415
 416                 case IProblem.NeedToEmulateFieldReadAccess :
 417                 case IProblem.NeedToEmulateFieldWriteAccess :
 418                 case IProblem.NeedToEmulateMethodAccess :
 419                 case IProblem.NeedToEmulateConstructorAccess :
 420                         return this.options.getSeverity(CompilerOptions.AccessEmulation);
 421
 422                 case IProblem.NonExternalizedStringLiteral :
 423                         return this.options.getSeverity(CompilerOptions.NonExternalizedString);
 424
 425                 case IProblem.UseAssertAsAnIdentifier :
 426                         return this.options.getSeverity(CompilerOptions.AssertUsedAsAnIdentifier);
 427
 428                 case IProblem.NonStaticAccessToStaticMethod :
 429                 case IProblem.NonStaticAccessToStaticField :
 430                         return this.options.getSeverity(CompilerOptions.NonStaticAccessToStatic);
 431
 432 //              case IProblem.IndirectAccessToStaticMethod :
 433 //              case IProblem.IndirectAccessToStaticField :
 434 //              case IProblem.IndirectAccessToStaticType :
 435 //                      return this.options.getSeverity(CompilerOptions.IndirectStaticAccess);
 436
 437                 case IProblem.AssignmentHasNoEffect:
 438                         return this.options.getSeverity(CompilerOptions.NoEffectAssignment);
 439
 440                 case IProblem.UnusedPrivateConstructor:
 441                 case IProblem.UnusedPrivateMethod:
 442                 case IProblem.UnusedPrivateField:
 443                 case IProblem.UnusedPrivateType:
 444                         return this.options.getSeverity(CompilerOptions.UnusedPrivateMember);
 445
 446                 case IProblem.Task :
 447                         return Warning;
 448
 449 //              case IProblem.LocalVariableHidingLocalVariable:
 450 //              case IProblem.LocalVariableHidingField:
 451 //              case IProblem.ArgumentHidingLocalVariable:
 452 //              case IProblem.ArgumentHidingField:
 453 //                      return this.options.getSeverity(CompilerOptions.LocalVariableHiding);
 454
 455 //              case IProblem.FieldHidingLocalVariable:
 456 //              case IProblem.FieldHidingField:
 457 //                      return this.options.getSeverity(CompilerOptions.FieldHiding);
 458
 459 //              case IProblem.PossibleAccidentalBooleanAssignment:
 460 //                      return this.options.getSeverity(CompilerOptions.AccidentalBooleanAssign);
 461
 462 //              case IProblem.SuperfluousSemicolon:
 463 //                      return this.options.getSeverity(CompilerOptions.SuperfluousSemicolon);
 464 //
 465 //              case IProblem.UndocumentedEmptyBlock:
 466 //                      return this.options.getSeverity(CompilerOptions.UndocumentedEmptyBlock);
 467 //
 468 //              case IProblem.UnnecessaryCast:
 469 //              case IProblem.UnnecessaryArgumentCast:
 470 //              case IProblem.UnnecessaryInstanceof:
 471 //                      return this.options.getSeverity(CompilerOptions.UnnecessaryTypeCheck);
 472 //
 473 //              case IProblem.FinallyMustCompleteNormally:
 474 //                      return this.options.getSeverity(CompilerOptions.FinallyBlockNotCompleting);
 475 //
 476 //              case IProblem.UnusedMethodDeclaredThrownException:
 477 //              case IProblem.UnusedConstructorDeclaredThrownException:
 478 //                      return this.options.getSeverity(CompilerOptions.UnusedDeclaredThrownException);
 479 //
 480 //              case IProblem.UnqualifiedFieldAccess:
 481 //                      return this.options.getSeverity(CompilerOptions.UnqualifiedFieldAccess);
 482
 483                 /*
 484                  * Javadoc syntax errors
 485                  */
 486                 // Javadoc explicit IDs
 487 //              case IProblem.JavadocUnexpectedTag:
 488 //              case IProblem.JavadocDuplicateReturnTag:
 489 //              case IProblem.JavadocInvalidThrowsClass:
 490 //              case IProblem.JavadocInvalidSeeReference:
 491 //              case IProblem.JavadocInvalidSeeHref:
 492 //              case IProblem.JavadocInvalidSeeArgs:
 493 //              case IProblem.JavadocInvalidTag:
 494 //                      return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
 495
 496                 /*
 497                  * Javadoc tags resolved references errors
 498                  */
 499 //              case IProblem.JavadocInvalidParamName:
 500 //              case IProblem.JavadocDuplicateParamName:
 501 //              case IProblem.JavadocMissingParamName:
 502 //              case IProblem.JavadocInvalidThrowsClassName:
 503 //              case IProblem.JavadocDuplicateThrowsClassName:
 504 //              case IProblem.JavadocMissingThrowsClassName:
 505 //              case IProblem.JavadocMissingSeeReference:
 506 //              case IProblem.JavadocUsingDeprecatedField:
 507 //              case IProblem.JavadocUsingDeprecatedConstructor:
 508 //              case IProblem.JavadocUsingDeprecatedMethod:
 509 //              case IProblem.JavadocUsingDeprecatedType:
 510 //              case IProblem.JavadocUndefinedField:
 511 //              case IProblem.JavadocNotVisibleField:
 512 //              case IProblem.JavadocAmbiguousField:
 513 //              case IProblem.JavadocUndefinedConstructor:
 514 //              case IProblem.JavadocNotVisibleConstructor:
 515 //              case IProblem.JavadocAmbiguousConstructor:
 516 //              case IProblem.JavadocUndefinedMethod:
 517 //              case IProblem.JavadocNotVisibleMethod:
 518 //              case IProblem.JavadocAmbiguousMethod:
 519 //              case IProblem.JavadocParameterMismatch:
 520 //              case IProblem.JavadocUndefinedType:
 521 //              case IProblem.JavadocNotVisibleType:
 522 //              case IProblem.JavadocAmbiguousType:
 523 //              case IProblem.JavadocInternalTypeNameProvided:
 524 //              case IProblem.JavadocNoMessageSendOnArrayType:
 525 //              case IProblem.JavadocNoMessageSendOnBaseType:
 526 //                      if (!this.options.reportInvalidJavadocTags)
 527 //                              return ProblemSeverities.Ignore;
 528 //                      else
 529 //                              return this.options.getSeverity(CompilerOptions.InvalidJavadoc);
 530
 531                 /*
 532                  * Javadoc missing tags errors
 533                  */
 534 //              case IProblem.JavadocMissingParamTag:
 535 //              case IProblem.JavadocMissingReturnTag:
 536 //              case IProblem.JavadocMissingThrowsTag:
 537 //                      return this.options.getSeverity(CompilerOptions.MissingJavadocTags);
 538
 539                 /*
 540                  * Missing Javadoc errors
 541                  */
 542 //              case IProblem.JavadocMissing:
 543 //                      return this.options.getSeverity(CompilerOptions.MissingJavadocComments);
 544
 545                 // by default problems are errors.
 546                 default:
 547                         return Error;
 548         }
 549   }
 550   //public void conditionalArgumentsIncompatibleTypes(ConditionalExpression
 551   // expression, TypeBinding trueType, TypeBinding falseType) {
 552   //    this.handle(
 553   //            IProblem.IncompatibleTypesInConditionalOperator,
 554   //            new String[] {new String(trueType.readableName()), new
 555   // String(falseType.readableName())},
 556   //            new String[] {new String(trueType.sourceName()), new
 557   // String(falseType.sourceName())},
 558   //            expression.sourceStart,
 559   //            expression.sourceEnd);
 560   //}
 561 //  public void conflictingImport(ImportReference importRef) {
 562 //    String[] arguments = new String[]{CharOperation.toString(importRef.tokens)};
 563 //    this.handle(IProblem.ConflictingImport, arguments, arguments,
 564 //        importRef.sourceStart, importRef.sourceEnd);
 565 //  }
 566   public void constantOutOfFormat(NumberLiteral lit) {
 567     // the literal is not in a correct format
 568     // this code is called on IntLiteral and LongLiteral
 569     // example 000811 ...the 8 is uncorrect.
 570     if ((lit instanceof LongLiteral) || (lit instanceof IntLiteral)) {
 571       char[] source = lit.source();
 572       try {
 573         final String Radix;
 574         final int radix;
 575         if ((source[1] == 'x') || (source[1] == 'X')) {
 576           radix = 16;
 577           Radix = "Hexa"; //$NON-NLS-1$
 578         } else {
 579           radix = 8;
 580           Radix = "Octal"; //$NON-NLS-1$
 581         }
 582         //look for the first digit that is incorrect
 583         int place = -1;
 584         label : for (int i = radix == 8 ? 1 : 2; i < source.length; i++) {
 585           if (Character.digit(source[i], radix) == -1) {
 586             place = i;
 587             break label;
 588           }
 589         }
 590         String[] arguments = new String[]{Radix + " " + new String(source)
 591             + " (digit " + new String(new char[]{source[place]}) + ")"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 592         this.handle(IProblem.NumericValueOutOfRange, arguments, arguments,
 593             lit.sourceStart, lit.sourceEnd);
 594         return;
 595       } catch (IndexOutOfBoundsException ex) {
 596       }
 597       // just in case .... use a predefined error..
 598       // we should never come here...(except if the code changes !)
 599       this.constantOutOfRange(lit);
 600     }
 601   }
 602   public void constantOutOfRange(Literal lit) {
 603     // lit is some how out of range of it declared type
 604     // example
 605     // 9999999999999999999999999999999999999999999999999999999999999999999
 606     String[] arguments = new String[]{new String(lit.source())};
 607     this.handle(IProblem.NumericValueOutOfRange, arguments, arguments,
 608         lit.sourceStart, lit.sourceEnd);
 609   }
 610   public void deprecatedField(FieldBinding field, AstNode location) {
 611     this.handle(IProblem.UsingDeprecatedField,
 612         new String[]{new String(field.declaringClass.readableName()),
 613             new String(field.name)}, new String[]{
 614             new String(field.declaringClass.shortReadableName()),
 615             new String(field.name)}, location.sourceStart, location.sourceEnd);
 616   }
 617   public void deprecatedMethod(MethodBinding method, AstNode location) {
 618     if (method.isConstructor())
 619       this.handle(IProblem.UsingDeprecatedConstructor, new String[]{
 620           new String(method.declaringClass.readableName()),
 621           parametersAsString(method)}, new String[]{
 622           new String(method.declaringClass.shortReadableName()),
 623           parametersAsShortString(method)}, location.sourceStart,
 624           location.sourceEnd);
 625     else
 626       this.handle(IProblem.UsingDeprecatedMethod, new String[]{
 627           new String(method.declaringClass.readableName()),
 628           new String(method.selector), parametersAsString(method)},
 629           new String[]{new String(method.declaringClass.shortReadableName()),
 630               new String(method.selector), parametersAsShortString(method)},
 631           location.sourceStart, location.sourceEnd);
 632   }
 633   public void deprecatedType(TypeBinding type, AstNode location) {
 634     if (location == null)
 635       return; // 1G828DN - no type ref for synthetic arguments
 636     this.handle(IProblem.UsingDeprecatedType, new String[]{new String(type
 637         .readableName())}, new String[]{new String(type.shortReadableName())},
 638         location.sourceStart, location.sourceEnd);
 639   }
 640   public void duplicateCase(Case statement, Constant constant) {
 641     String[] arguments = new String[]{String.valueOf(constant.intValue())};
 642     this.handle(IProblem.DuplicateCase, arguments, arguments,
 643         statement.sourceStart, statement.sourceEnd);
 644   }
 645   public void duplicateDefaultCase(DefaultCase statement) {
 646     this.handle(IProblem.DuplicateDefaultCase, NoArgument, NoArgument,
 647         statement.sourceStart, statement.sourceEnd);
 648   }
 649   public void duplicateFieldInType(SourceTypeBinding type,
 650       FieldDeclaration fieldDecl) {
 651     this.handle(IProblem.DuplicateField, new String[]{
 652         new String(type.sourceName()), fieldDecl.name()}, new String[]{
 653         new String(type.shortReadableName()), fieldDecl.name()},
 654         fieldDecl.sourceStart, fieldDecl.sourceEnd);
 655   }
 656 //  public void duplicateImport(ImportReference importRef) {
 657 //    String[] arguments = new String[]{CharOperation.toString(importRef.tokens)};
 658 //    this.handle(IProblem.DuplicateImport, arguments, arguments,
 659 //        importRef.sourceStart, importRef.sourceEnd);
 660 //  }
 661   public void duplicateInitializationOfBlankFinalField(FieldBinding field,
 662       Reference reference) {
 663     String[] arguments = new String[]{new String(field.readableName())};
 664     this.handle(IProblem.DuplicateBlankFinalFieldInitialization, arguments,
 665         arguments, reference.sourceStart, reference.sourceEnd);
 666   }
 667   public void duplicateInitializationOfFinalLocal(LocalVariableBinding local,
 668       AstNode location) {
 669     String[] arguments = new String[]{new String(local.readableName())};
 670     this.handle(IProblem.DuplicateFinalLocalInitialization, arguments,
 671         arguments, location.sourceStart, location.sourceEnd);
 672   }
 673   public void duplicateMethodInType(SourceTypeBinding type,
 674       AbstractMethodDeclaration methodDecl) {
 675     String[] arguments = new String[]{new String(methodDecl.selector),
 676         new String(type.sourceName())};
 677     this.handle(IProblem.DuplicateMethod, arguments, arguments,
 678         methodDecl.sourceStart, methodDecl.sourceEnd);
 679   }
 680   public void duplicateModifierForField(ReferenceBinding type,
 681       FieldDeclaration fieldDecl) {
 682     /*
 683      * to highlight modifiers use: this.handle( new Problem(
 684      * DuplicateModifierForField, new String[] {fieldDecl.name()},
 685      * fieldDecl.modifiers.sourceStart, fieldDecl.modifiers.sourceEnd));
 686      */
 687     String[] arguments = new String[]{fieldDecl.name()};
 688     this.handle(IProblem.DuplicateModifierForField, arguments, arguments,
 689         fieldDecl.sourceStart, fieldDecl.sourceEnd);
 690   }
 691   public void duplicateModifierForMethod(ReferenceBinding type,
 692       AbstractMethodDeclaration methodDecl) {
 693     this.handle(IProblem.DuplicateModifierForMethod, new String[]{
 694         new String(type.sourceName()), new String(methodDecl.selector)},
 695         new String[]{new String(type.shortReadableName()),
 696             new String(methodDecl.selector)}, methodDecl.sourceStart,
 697         methodDecl.sourceEnd);
 698   }
 699   public void duplicateModifierForType(SourceTypeBinding type) {
 700     String[] arguments = new String[]{new String(type.sourceName())};
 701     this.handle(IProblem.DuplicateModifierForType, arguments, arguments, type
 702         .sourceStart(), type.sourceEnd());
 703   }
 704   public void duplicateModifierForVariable(LocalDeclaration localDecl,
 705       boolean complainForArgument) {
 706     String[] arguments = new String[]{localDecl.name()};
 707     this.handle(complainForArgument
 708         ? IProblem.DuplicateModifierForArgument
 709         : IProblem.DuplicateModifierForVariable, arguments, arguments,
 710         localDecl.sourceStart, localDecl.sourceEnd);
 711   }
 712   public void duplicateNestedType(TypeDeclaration typeDecl) {
 713     String[] arguments = new String[]{new String(typeDecl.name)};
 714     this.handle(IProblem.DuplicateNestedType, arguments, arguments,
 715         typeDecl.sourceStart, typeDecl.sourceEnd);
 716   }
 717   public void duplicateSuperinterface(SourceTypeBinding type,
 718       TypeDeclaration typeDecl, ReferenceBinding superType) {
 719     this.handle(IProblem.DuplicateSuperInterface, new String[]{
 720         new String(superType.readableName()), new String(type.sourceName())},
 721         new String[]{new String(superType.shortReadableName()),
 722             new String(type.sourceName())}, typeDecl.sourceStart,
 723         typeDecl.sourceEnd);
 724   }
 725   public void duplicateTypes(CompilationUnitDeclaration compUnitDecl,
 726       TypeDeclaration typeDecl) {
 727     String[] arguments = new String[]{new String(compUnitDecl.getFileName()),
 728         new String(typeDecl.name)};
 729     this.referenceContext = typeDecl; // report the problem against the
 730     // type not the entire compilation
 731     // unit
 732     this.handle(IProblem.DuplicateTypes, arguments, arguments,
 733         typeDecl.sourceStart, typeDecl.sourceEnd,
 734         compUnitDecl.compilationResult);
 735   }
 736   public void errorNoMethodFor(MessageSend messageSend, TypeBinding recType,
 737       TypeBinding[] params) {
 738     StringBuffer buffer = new StringBuffer();
 739     StringBuffer shortBuffer = new StringBuffer();
 740     for (int i = 0, length = params.length; i < length; i++) {
 741       if (i != 0) {
 742         buffer.append(", "); //$NON-NLS-1$
 743         shortBuffer.append(", "); //$NON-NLS-1$
 744       }
 745       buffer.append(new String(params[i].readableName()));
 746       shortBuffer.append(new String(params[i].shortReadableName()));
 747     }
 748     this.handle(recType.isArrayType()
 749         ? IProblem.NoMessageSendOnArrayType
 750         : IProblem.NoMessageSendOnBaseType, new String[]{
 751         new String(recType.readableName()), new String(messageSend.selector),
 752         buffer.toString()}, new String[]{
 753         new String(recType.shortReadableName()),
 754         new String(messageSend.selector), shortBuffer.toString()},
 755         messageSend.sourceStart, messageSend.sourceEnd);
 756   }
 757   public void errorThisSuperInStatic(AstNode reference) {
 758     String[] arguments = new String[]{reference.isSuper() ? "super" : "this"}; //$NON-NLS-2$ //$NON-NLS-1$
 759     this.handle(IProblem.ThisInStaticContext, arguments, arguments,
 760         reference.sourceStart, reference.sourceEnd);
 761   }
 762   public void exceptionTypeProblem(SourceTypeBinding type,
 763       AbstractMethodDeclaration methodDecl, TypeReference exceptionType,
 764       TypeBinding expectedType) {
 765     int problemId = expectedType.problemId();
 766     int id;
 767     switch (problemId) {
 768       case NotFound :
 769         // 1
 770         id = IProblem.ExceptionTypeNotFound;
 771         break;
 772       case NotVisible :
 773         // 2
 774         id = IProblem.ExceptionTypeNotVisible;
 775         break;
 776       case Ambiguous :
 777         // 3
 778         id = IProblem.ExceptionTypeAmbiguous;
 779         break;
 780       case InternalNameProvided :
 781         // 4
 782         id = IProblem.ExceptionTypeInternalNameProvided;
 783         break;
 784       case InheritedNameHidesEnclosingName :
 785         // 5
 786         id = IProblem.ExceptionTypeInheritedNameHidesEnclosingName;
 787         break;
 788       case NoError :
 789       // 0
 790       default :
 791         needImplementation(); // want to fail to see why we were
 792         // here...
 793         return;
 794     }
 795     this.handle(id, new String[]{new String(methodDecl.selector),
 796         new String(expectedType.readableName())}, new String[]{
 797         new String(methodDecl.selector),
 798         new String(expectedType.shortReadableName())},
 799         exceptionType.sourceStart, exceptionType.sourceEnd);
 800   }
 801   public void expressionShouldBeAVariable(Expression expression) {
 802     this.handle(IProblem.ExpressionShouldBeAVariable, NoArgument, NoArgument,
 803         expression.sourceStart, expression.sourceEnd);
 804   }
 805   public void fieldsOrThisBeforeConstructorInvocation(ThisReference reference) {
 806     this.handle(IProblem.ThisSuperDuringConstructorInvocation, NoArgument,
 807         NoArgument, reference.sourceStart, reference.sourceEnd);
 808   }
 809   public void fieldTypeProblem(SourceTypeBinding type,
 810       FieldDeclaration fieldDecl, TypeBinding expectedType) {
 811     int problemId = expectedType.problemId();
 812     int id;
 813     switch (problemId) {
 814       case NotFound :
 815         // 1
 816         id = IProblem.FieldTypeNotFound;
 817         break;
 818       case NotVisible :
 819         // 2
 820         id = IProblem.FieldTypeNotVisible;
 821         break;
 822       case Ambiguous :
 823         // 3
 824         id = IProblem.FieldTypeAmbiguous;
 825         break;
 826       case InternalNameProvided :
 827         // 4
 828         id = IProblem.FieldTypeInternalNameProvided;
 829         break;
 830       case InheritedNameHidesEnclosingName :
 831         // 5
 832         id = IProblem.FieldTypeInheritedNameHidesEnclosingName;
 833         break;
 834       case NoError :
 835       // 0
 836       default :
 837         needImplementation(); // want to fail to see why we were
 838         // here...
 839         return;
 840     }
 841     this.handle(id,
 842         new String[]{fieldDecl.name(), new String(type.sourceName()),
 843             new String(expectedType.readableName())}, new String[]{
 844             fieldDecl.name(), new String(type.sourceName()),
 845             new String(expectedType.shortReadableName())},
 846         fieldDecl.type.sourceStart, fieldDecl.type.sourceEnd);
 847   }
 848   public void finalMethodCannotBeOverridden(MethodBinding currentMethod,
 849       MethodBinding inheritedMethod) {
 850     this.handle(
 851     // Cannot override the final method from %1
 852         // 8.4.3.3 - Final methods cannot be overridden or hidden.
 853         IProblem.FinalMethodCannotBeOverridden, new String[]{new String(
 854             inheritedMethod.declaringClass.readableName())},
 855         new String[]{new String(inheritedMethod.declaringClass
 856             .shortReadableName())}, currentMethod.sourceStart(), currentMethod
 857             .sourceEnd());
 858   }
 859   public void forwardReference(Reference reference, int indexInQualification,
 860       TypeBinding type) {
 861     this.handle(IProblem.ReferenceToForwardField, NoArgument, NoArgument,
 862         reference.sourceStart, reference.sourceEnd);
 863   }
 864   // use this private API when the compilation unit result can be found
 865   // through the
 866   // reference context. Otherwise, use the other API taking a problem and a
 867   // compilation result
 868   // as arguments
 869   private void handle(int problemId, String[] problemArguments,
 870       String[] messageArguments, int problemStartPosition,
 871       int problemEndPosition) {
 872     this.handle(problemId, problemArguments, messageArguments,
 873         problemStartPosition, problemEndPosition, referenceContext,
 874         referenceContext == null ? null : referenceContext.compilationResult());
 875     referenceContext = null;
 876   }
 877   // use this private API when the compilation unit result can be found
 878   // through the
 879   // reference context. Otherwise, use the other API taking a problem and a
 880   // compilation result
 881   // as arguments
 882   private void handle(int problemId, String[] problemArguments,
 883       String[] messageArguments, int severity, int problemStartPosition,
 884       int problemEndPosition) {
 885     this.handle(problemId, problemArguments, messageArguments, severity,
 886         problemStartPosition, problemEndPosition, referenceContext,
 887         referenceContext == null ? null : referenceContext.compilationResult());
 888     referenceContext = null;
 889   }
 890   // use this private API when the compilation unit result cannot be found
 891   // through the
 892   // reference context.
 893   private void handle(int problemId, String[] problemArguments,
 894       String[] messageArguments, int problemStartPosition,
 895       int problemEndPosition, CompilationResult unitResult) {
 896     this.handle(problemId, problemArguments, messageArguments,
 897         problemStartPosition, problemEndPosition, referenceContext, unitResult);
 898     referenceContext = null;
 899   }
 900   public void hidingEnclosingType(TypeDeclaration typeDecl) {
 901     String[] arguments = new String[]{new String(typeDecl.name)};
 902     this.handle(IProblem.HidingEnclosingType, arguments, arguments,
 903         typeDecl.sourceStart, typeDecl.sourceEnd);
 904   }
 905   public void hierarchyCircularity(SourceTypeBinding sourceType,
 906       ReferenceBinding superType, TypeReference reference) {
 907     int start = 0;
 908     int end = 0;
 909     String typeName = ""; //$NON-NLS-1$
 910     String shortTypeName = ""; //$NON-NLS-1$
 911     if (reference == null) { // can only happen when java.lang.Object is
 912       // busted
 913       start = sourceType.sourceStart();
 914       end = sourceType.sourceEnd();
 915       typeName = new String(superType.readableName());
 916       shortTypeName = new String(superType.sourceName());
 917     } else {
 918       start = reference.sourceStart;
 919       end = reference.sourceEnd;
 920       char[][] qName = reference.getTypeName();
 921       typeName = CharOperation.toString(qName);
 922       shortTypeName = new String(qName[qName.length - 1]);
 923     }
 924     if (sourceType == superType)
 925       this.handle(IProblem.HierarchyCircularitySelfReference, new String[]{
 926           new String(sourceType.sourceName()), typeName}, new String[]{
 927           new String(sourceType.sourceName()), shortTypeName}, start, end);
 928     else
 929       this.handle(IProblem.HierarchyCircularity, new String[]{
 930           new String(sourceType.sourceName()), typeName}, new String[]{
 931           new String(sourceType.sourceName()), shortTypeName}, start, end);
 932   }
 933   public void hierarchyHasProblems(SourceTypeBinding type) {
 934     String[] arguments = new String[]{new String(type.sourceName())};
 935     this.handle(IProblem.HierarchyHasProblems, arguments, arguments, type
 936         .sourceStart(), type.sourceEnd());
 937   }
 938   public void illegalAbstractModifierCombinationForMethod(
 939       ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
 940     String[] arguments = new String[]{new String(type.sourceName()),
 941         new String(methodDecl.selector)};
 942     this.handle(IProblem.IllegalAbstractModifierCombinationForMethod,
 943         arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd);
 944   }
 945   public void illegalModifierCombinationFinalAbstractForClass(
 946       SourceTypeBinding type) {
 947     String[] arguments = new String[]{new String(type.sourceName())};
 948     this.handle(IProblem.IllegalModifierCombinationFinalAbstractForClass,
 949         arguments, arguments, type.sourceStart(), type.sourceEnd());
 950   }
 951   public void illegalModifierCombinationFinalVolatileForField(
 952       ReferenceBinding type, FieldDeclaration fieldDecl) {
 953     String[] arguments = new String[]{fieldDecl.name()};
 954     this.handle(IProblem.IllegalModifierCombinationFinalVolatileForField,
 955         arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd);
 956   }
 957   public void illegalModifierForClass(SourceTypeBinding type) {
 958     String[] arguments = new String[]{new String(type.sourceName())};
 959     this.handle(IProblem.IllegalModifierForClass, arguments, arguments, type
 960         .sourceStart(), type.sourceEnd());
 961   }
 962   public void illegalModifierForField(ReferenceBinding type,
 963       FieldDeclaration fieldDecl) {
 964     String[] arguments = new String[]{fieldDecl.name()};
 965     this.handle(IProblem.IllegalModifierForField, arguments, arguments,
 966         fieldDecl.sourceStart, fieldDecl.sourceEnd);
 967   }
 968   public void illegalModifierForInterface(SourceTypeBinding type) {
 969     String[] arguments = new String[]{new String(type.sourceName())};
 970     this.handle(IProblem.IllegalModifierForInterface, arguments, arguments,
 971         type.sourceStart(), type.sourceEnd());
 972   }
 973   public void illegalModifierForInterfaceField(ReferenceBinding type,
 974       FieldDeclaration fieldDecl) {
 975     String[] arguments = new String[]{fieldDecl.name()};
 976     this.handle(IProblem.IllegalModifierForInterfaceField, arguments,
 977         arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd);
 978   }
 979   public void illegalModifierForInterfaceMethod(ReferenceBinding type,
 980       AbstractMethodDeclaration methodDecl) {
 981     String[] arguments = new String[]{new String(type.sourceName()),
 982         new String(methodDecl.selector)};
 983     this.handle(IProblem.IllegalModifierForInterfaceMethod, arguments,
 984         arguments, methodDecl.sourceStart, methodDecl.sourceEnd);
 985   }
 986   public void illegalModifierForLocalClass(SourceTypeBinding type) {
 987     String[] arguments = new String[]{new String(type.sourceName())};
 988     this.handle(IProblem.IllegalModifierForLocalClass, arguments, arguments,
 989         type.sourceStart(), type.sourceEnd());
 990   }
 991   public void illegalModifierForMemberClass(SourceTypeBinding type) {
 992     String[] arguments = new String[]{new String(type.sourceName())};
 993     this.handle(IProblem.IllegalModifierForMemberClass, arguments, arguments,
 994         type.sourceStart(), type.sourceEnd());
 995   }
 996   public void illegalModifierForMemberInterface(SourceTypeBinding type) {
 997     String[] arguments = new String[]{new String(type.sourceName())};
 998     this.handle(IProblem.IllegalModifierForMemberInterface, arguments,
 999         arguments, type.sourceStart(), type.sourceEnd());
1000   }
1001   public void illegalModifierForMethod(ReferenceBinding type,
1002       AbstractMethodDeclaration methodDecl) {
1003     String[] arguments = new String[]{new String(type.sourceName()),
1004         new String(methodDecl.selector)};
1005     this.handle(IProblem.IllegalModifierForMethod, arguments, arguments,
1006         methodDecl.sourceStart, methodDecl.sourceEnd);
1007   }
1008   public void illegalModifierForVariable(LocalDeclaration localDecl,
1009       boolean complainAsArgument) {
1010     String[] arguments = new String[]{localDecl.name()};
1011     this.handle(complainAsArgument
1012         ? IProblem.IllegalModifierForArgument
1013         : IProblem.IllegalModifierForVariable, arguments, arguments,
1014         localDecl.sourceStart, localDecl.sourceEnd);
1015   }
1016   public void illegalPrimitiveOrArrayTypeForEnclosingInstance(
1017       TypeBinding enclosingType, AstNode location) {
1018     this.handle(IProblem.IllegalPrimitiveOrArrayTypeForEnclosingInstance,
1019         new String[]{new String(enclosingType.readableName())},
1020         new String[]{new String(enclosingType.shortReadableName())},
1021         location.sourceStart, location.sourceEnd);
1022   }
1023   public void illegalStaticModifierForMemberType(SourceTypeBinding type) {
1024     String[] arguments = new String[]{new String(type.sourceName())};
1025     this.handle(IProblem.IllegalStaticModifierForMemberType, arguments,
1026         arguments, type.sourceStart(), type.sourceEnd());
1027   }
1028   public void illegalVisibilityModifierCombinationForField(
1029       ReferenceBinding type, FieldDeclaration fieldDecl) {
1030     String[] arguments = new String[]{new String(fieldDecl.name())};
1031     this.handle(IProblem.IllegalVisibilityModifierCombinationForField,
1032         arguments, arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd);
1033   }
1034   public void illegalVisibilityModifierCombinationForMemberType(
1035       SourceTypeBinding type) {
1036     String[] arguments = new String[]{new String(type.sourceName())};
1037     this.handle(IProblem.IllegalVisibilityModifierCombinationForMemberType,
1038         arguments, arguments, type.sourceStart(), type.sourceEnd());
1039   }
1040   public void illegalVisibilityModifierCombinationForMethod(
1041       ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
1042     String[] arguments = new String[]{new String(type.sourceName()),
1043         new String(methodDecl.selector)};
1044     this.handle(IProblem.IllegalVisibilityModifierCombinationForMethod,
1045         arguments, arguments, methodDecl.sourceStart, methodDecl.sourceEnd);
1046   }
1047   public void illegalVisibilityModifierForInterfaceMemberType(
1048       SourceTypeBinding type) {
1049     String[] arguments = new String[]{new String(type.sourceName())};
1050     this.handle(IProblem.IllegalVisibilityModifierForInterfaceMemberType,
1051         arguments, arguments, type.sourceStart(), type.sourceEnd());
1052   }
1053   public void illegalVoidExpression(AstNode location) {
1054     this.handle(IProblem.InvalidVoidExpression, NoArgument, NoArgument,
1055         location.sourceStart, location.sourceEnd);
1056   }
1057 //  public void importProblem(ImportReference importRef, Binding expectedImport) {
1058 //    int problemId = expectedImport.problemId();
1059 //    int id;
1060 //    switch (problemId) {
1061 //      case NotFound :
1062 //        // 1
1063 //        id = IProblem.ImportNotFound;
1064 //        break;
1065 //      case NotVisible :
1066 //        // 2
1067 //        id = IProblem.ImportNotVisible;
1068 //        break;
1069 //      case Ambiguous :
1070 //        // 3
1071 //        id = IProblem.ImportAmbiguous;
1072 //        break;
1073 //      case InternalNameProvided :
1074 //        // 4
1075 //        id = IProblem.ImportInternalNameProvided;
1076 //        break;
1077 //      case InheritedNameHidesEnclosingName :
1078 //        // 5
1079 //        id = IProblem.ImportInheritedNameHidesEnclosingName;
1080 //        break;
1081 //      case NoError :
1082 //      // 0
1083 //      default :
1084 //        needImplementation(); // want to fail to see why we were
1085 //        // here...
1086 //        return;
1087 //    }
1088 //    String argument;
1089 //    if (expectedImport instanceof ProblemReferenceBinding) {
1090 //      argument = CharOperation
1091 //          .toString(((ProblemReferenceBinding) expectedImport).compoundName);
1092 //    } else {
1093 //      argument = CharOperation.toString(importRef.tokens);
1094 //    }
1095 //    String[] arguments = new String[]{argument};
1096 //    this.handle(id, arguments, arguments, importRef.sourceStart,
1097 //        importRef.sourceEnd);
1098 //  }
1099   public void incompatibleExceptionInThrowsClause(SourceTypeBinding type,
1100       MethodBinding currentMethod, MethodBinding inheritedMethod,
1101       ReferenceBinding exceptionType) {
1102     if (type == currentMethod.declaringClass) {
1103       int id;
1104       if (currentMethod.declaringClass.isInterface()
1105           && !inheritedMethod.isPublic()) { // interface inheriting
1106         // Object protected
1107         // method
1108         id = IProblem.IncompatibleExceptionInThrowsClauseForNonInheritedInterfaceMethod;
1109       } else {
1110         id = IProblem.IncompatibleExceptionInThrowsClause;
1111       }
1112       this.handle(
1113       // Exception %1 is not compatible with throws
1114           // clause in %2
1115           // 9.4.4 - The type of exception in the throws
1116           // clause is incompatible.
1117           id, new String[]{
1118               new String(exceptionType.sourceName()),
1119               new String(CharOperation.concat(inheritedMethod.declaringClass
1120                   .readableName(), inheritedMethod.readableName(), '.'))},
1121           new String[]{
1122               new String(exceptionType.sourceName()),
1123               new String(CharOperation.concat(inheritedMethod.declaringClass
1124                   .shortReadableName(), inheritedMethod.shortReadableName(),
1125                   '.'))}, currentMethod.sourceStart(), currentMethod
1126               .sourceEnd());
1127     } else
1128       this.handle(
1129       // Exception %1 in throws clause of %2 is not
1130           // compatible with %3
1131           // 9.4.4 - The type of exception in the throws
1132           // clause is incompatible.
1133           IProblem.IncompatibleExceptionInInheritedMethodThrowsClause,
1134           new String[]{
1135               new String(exceptionType.sourceName()),
1136               new String(CharOperation.concat(currentMethod.declaringClass
1137                   .sourceName(), currentMethod.readableName(), '.')),
1138               new String(CharOperation.concat(inheritedMethod.declaringClass
1139                   .readableName(), inheritedMethod.readableName(), '.'))},
1140           new String[]{
1141               new String(exceptionType.sourceName()),
1142               new String(CharOperation.concat(currentMethod.declaringClass
1143                   .sourceName(), currentMethod.shortReadableName(), '.')),
1144               new String(CharOperation.concat(inheritedMethod.declaringClass
1145                   .shortReadableName(), inheritedMethod.shortReadableName(),
1146                   '.'))}, type.sourceStart(), type.sourceEnd());
1147   }
1148   public void incompatibleReturnType(MethodBinding currentMethod,
1149       MethodBinding inheritedMethod) {
1150     StringBuffer methodSignature = new StringBuffer();
1151     methodSignature.append(inheritedMethod.declaringClass.readableName())
1152         .append('.').append(inheritedMethod.readableName());
1153     StringBuffer shortSignature = new StringBuffer();
1154     shortSignature.append(inheritedMethod.declaringClass.shortReadableName())
1155         .append('.').append(inheritedMethod.shortReadableName());
1156     int id;
1157     if (currentMethod.declaringClass.isInterface()
1158         && !inheritedMethod.isPublic()) { // interface inheriting
1159       // Object protected method
1160       id = IProblem.IncompatibleReturnTypeForNonInheritedInterfaceMethod;
1161     } else {
1162       id = IProblem.IncompatibleReturnType;
1163     }
1164     this.handle(id, new String[]{methodSignature.toString()},
1165         new String[]{shortSignature.toString()}, currentMethod.sourceStart(),
1166         currentMethod.sourceEnd());
1167   }
1168   public void incorrectLocationForEmptyDimension(
1169       ArrayAllocationExpression expression, int index) {
1170     this.handle(IProblem.IllegalDimension, NoArgument, NoArgument,
1171         expression.dimensions[index + 1].sourceStart,
1172         expression.dimensions[index + 1].sourceEnd);
1173   }
1174   public void incorrectSwitchType(Expression expression, TypeBinding testType) {
1175     this.handle(IProblem.IncorrectSwitchType, new String[]{new String(testType
1176         .readableName())},
1177         new String[]{new String(testType.shortReadableName())},
1178         expression.sourceStart, expression.sourceEnd);
1179   }
1180   public void inheritedMethodReducesVisibility(SourceTypeBinding type,
1181       MethodBinding concreteMethod, MethodBinding[] abstractMethods) {
1182     StringBuffer concreteSignature = new StringBuffer();
1183     concreteSignature.append(concreteMethod.declaringClass.readableName())
1184         .append('.').append(concreteMethod.readableName());
1185     StringBuffer shortSignature = new StringBuffer();
1186     shortSignature.append(concreteMethod.declaringClass.shortReadableName())
1187         .append('.').append(concreteMethod.shortReadableName());
1188     this.handle(
1189     // The inherited method %1 cannot hide the public abstract method in %2
1190         IProblem.InheritedMethodReducesVisibility, new String[]{
1191             new String(concreteSignature.toString()),
1192             new String(abstractMethods[0].declaringClass.readableName())},
1193         new String[]{new String(shortSignature.toString()),
1194             new String(abstractMethods[0].declaringClass.shortReadableName())},
1195         type.sourceStart(), type.sourceEnd());
1196   }
1197   public void inheritedMethodsHaveIncompatibleReturnTypes(
1198       SourceTypeBinding type, MethodBinding[] inheritedMethods, int length) {
1199     StringBuffer methodSignatures = new StringBuffer();
1200     StringBuffer shortSignatures = new StringBuffer();
1201     for (int i = length; --i >= 0;) {
1202       methodSignatures
1203           .append(inheritedMethods[i].declaringClass.readableName())
1204           .append('.').append(inheritedMethods[i].readableName());
1205       shortSignatures.append(
1206           inheritedMethods[i].declaringClass.shortReadableName()).append('.')
1207           .append(inheritedMethods[i].shortReadableName());
1208       if (i != 0) {
1209         methodSignatures.append(", "); //$NON-NLS-1$
1210         shortSignatures.append(", "); //$NON-NLS-1$
1211       }
1212     }
1213     this.handle(
1214     // Return type is incompatible with %1
1215         // 9.4.2 - The return type from the method is incompatible with
1216         // the declaration.
1217         IProblem.IncompatibleReturnType, new String[]{methodSignatures
1218             .toString()}, new String[]{shortSignatures.toString()}, type
1219             .sourceStart(), type.sourceEnd());
1220   }
1221   public void initializerMustCompleteNormally(FieldDeclaration fieldDecl) {
1222     this.handle(IProblem.InitializerMustCompleteNormally, NoArgument,
1223         NoArgument, fieldDecl.sourceStart, fieldDecl.sourceEnd);
1224   }
1225   public void innerTypesCannotDeclareStaticInitializers(
1226       ReferenceBinding innerType, AstNode location) {
1227     this.handle(IProblem.CannotDefineStaticInitializerInLocalType,
1228         new String[]{new String(innerType.readableName())},
1229         new String[]{new String(innerType.shortReadableName())},
1230         location.sourceStart, location.sourceEnd);
1231   }
1232   public void interfaceCannotHaveConstructors(ConstructorDeclaration constructor) {
1233     this.handle(IProblem.InterfaceCannotHaveConstructors, NoArgument,
1234         NoArgument, constructor.sourceStart, constructor.sourceEnd,
1235         constructor, constructor.compilationResult());
1236   }
1237   public void interfaceCannotHaveInitializers(SourceTypeBinding type,
1238       FieldDeclaration fieldDecl) {
1239     String[] arguments = new String[]{new String(type.sourceName())};
1240     this.handle(IProblem.InterfaceCannotHaveInitializers, arguments, arguments,
1241         fieldDecl.sourceStart, fieldDecl.sourceEnd);
1242   }
1243   public void invalidBreak(AstNode location) {
1244     this.handle(IProblem.InvalidBreak, NoArgument, NoArgument,
1245         location.sourceStart, location.sourceEnd);
1246   }
1247   public void invalidConstructor(Statement statement,
1248       MethodBinding targetConstructor) {
1249     boolean insideDefaultConstructor = (referenceContext instanceof ConstructorDeclaration)
1250         && ((ConstructorDeclaration) referenceContext).isDefaultConstructor();
1251     boolean insideImplicitConstructorCall = (statement instanceof ExplicitConstructorCall)
1252         && (((ExplicitConstructorCall) statement).accessMode == ExplicitConstructorCall.ImplicitSuper);
1253     int flag = IProblem.UndefinedConstructor; //default...
1254     switch (targetConstructor.problemId()) {
1255       case NotFound :
1256         if (insideDefaultConstructor) {
1257           flag = IProblem.UndefinedConstructorInDefaultConstructor;
1258         } else if (insideImplicitConstructorCall) {
1259           flag = IProblem.UndefinedConstructorInImplicitConstructorCall;
1260         } else {
1261           flag = IProblem.UndefinedConstructor;
1262         }
1263         break;
1264       case NotVisible :
1265         if (insideDefaultConstructor) {
1266           flag = IProblem.NotVisibleConstructorInDefaultConstructor;
1267         } else if (insideImplicitConstructorCall) {
1268           flag = IProblem.NotVisibleConstructorInImplicitConstructorCall;
1269         } else {
1270           flag = IProblem.NotVisibleConstructor;
1271         }
1272         break;
1273       case Ambiguous :
1274         if (insideDefaultConstructor) {
1275           flag = IProblem.AmbiguousConstructorInDefaultConstructor;
1276         } else if (insideImplicitConstructorCall) {
1277           flag = IProblem.AmbiguousConstructorInImplicitConstructorCall;
1278         } else {
1279           flag = IProblem.AmbiguousConstructor;
1280         }
1281         break;
1282       case NoError :
1283       // 0
1284       default :
1285         needImplementation(); // want to fail to see why we were
1286         // here...
1287         break;
1288     }
1289     this.handle(flag, new String[]{
1290         new String(targetConstructor.declaringClass.readableName()),
1291         parametersAsString(targetConstructor)}, new String[]{
1292         new String(targetConstructor.declaringClass.shortReadableName()),
1293         parametersAsShortString(targetConstructor)}, statement.sourceStart,
1294         statement.sourceEnd);
1295   }
1296   public void invalidContinue(AstNode location) {
1297     this.handle(IProblem.InvalidContinue, NoArgument, NoArgument,
1298         location.sourceStart, location.sourceEnd);
1299   }
1300   public void invalidEnclosingType(Expression expression, TypeBinding type,
1301       ReferenceBinding enclosingType) {
1302     if (enclosingType.isAnonymousType())
1303       enclosingType = enclosingType.superclass();
1304     int flag = IProblem.UndefinedType; // default
1305     switch (type.problemId()) {
1306       case NotFound :
1307         // 1
1308         flag = IProblem.UndefinedType;
1309         break;
1310       case NotVisible :
1311         // 2
1312         flag = IProblem.NotVisibleType;
1313         break;
1314       case Ambiguous :
1315         // 3
1316         flag = IProblem.AmbiguousType;
1317         break;
1318       case InternalNameProvided :
1319         flag = IProblem.InternalTypeNameProvided;
1320         break;
1321       case NoError :
1322       // 0
1323       default :
1324         needImplementation(); // want to fail to see why we were
1325         // here...
1326         break;
1327     }
1328     this.handle(flag, new String[]{new String(enclosingType.readableName())
1329         + "." + new String(type.readableName())}, //$NON-NLS-1$
1330         new String[]{new String(enclosingType.shortReadableName()) + "."
1331             + new String(type.shortReadableName())}, //$NON-NLS-1$
1332         expression.sourceStart, expression.sourceEnd);
1333   }
1334   public void invalidExpressionAsStatement(Expression expression) {
1335     this.handle(IProblem.InvalidExpressionAsStatement, NoArgument, NoArgument,
1336         expression.sourceStart, expression.sourceEnd);
1337   }
1338   public void invalidField(FieldReference fieldRef, TypeBinding searchedType) {
1339     int severity = Error;
1340     int flag = IProblem.UndefinedField;
1341     FieldBinding field = fieldRef.binding;
1342     switch (field.problemId()) {
1343       case NotFound :
1344         flag = IProblem.UndefinedField;
1345         /*
1346          * also need to check that the searchedType is the receiver type if
1347          * (searchedType.isHierarchyInconsistent()) severity = SecondaryError;
1348          */
1349         break;
1350       case NotVisible :
1351         flag = IProblem.NotVisibleField;
1352         break;
1353       case Ambiguous :
1354         flag = IProblem.AmbiguousField;
1355         break;
1356       case NonStaticReferenceInStaticContext :
1357         flag = IProblem.NonStaticFieldFromStaticInvocation;
1358         break;
1359       case NonStaticReferenceInConstructorInvocation :
1360         flag = IProblem.InstanceFieldDuringConstructorInvocation;
1361         break;
1362       case InheritedNameHidesEnclosingName :
1363         flag = IProblem.InheritedFieldHidesEnclosingName;
1364         break;
1365       case ReceiverTypeNotVisible :
1366         this.handle(IProblem.NotVisibleType, new String[]{new String(
1367             searchedType.leafComponentType().readableName())},
1368             new String[]{new String(searchedType.leafComponentType()
1369                 .shortReadableName())}, fieldRef.receiver.sourceStart,
1370             fieldRef.receiver.sourceEnd);
1371         return;
1372       case NoError :
1373       // 0
1374       default :
1375         needImplementation(); // want to fail to see why we were
1376         // here...
1377         break;
1378     }
1379     String[] arguments = new String[]{new String(field.readableName())};
1380     this.handle(flag, arguments, arguments, severity, fieldRef.sourceStart,
1381         fieldRef.sourceEnd);
1382   }
1383   public void invalidField(NameReference nameRef, FieldBinding field) {
1384     int flag = IProblem.UndefinedField;
1385     switch (field.problemId()) {
1386       case NotFound :
1387         flag = IProblem.UndefinedField;
1388         break;
1389       case NotVisible :
1390         flag = IProblem.NotVisibleField;
1391         break;
1392       case Ambiguous :
1393         flag = IProblem.AmbiguousField;
1394         break;
1395       case NonStaticReferenceInStaticContext :
1396         flag = IProblem.NonStaticFieldFromStaticInvocation;
1397         break;
1398       case NonStaticReferenceInConstructorInvocation :
1399         flag = IProblem.InstanceFieldDuringConstructorInvocation;
1400         break;
1401       case InheritedNameHidesEnclosingName :
1402         flag = IProblem.InheritedFieldHidesEnclosingName;
1403         break;
1404       case ReceiverTypeNotVisible :
1405         this.handle(IProblem.NotVisibleType, new String[]{new String(
1406             field.declaringClass.leafComponentType().readableName())},
1407             new String[]{new String(field.declaringClass.leafComponentType()
1408                 .shortReadableName())}, nameRef.sourceStart, nameRef.sourceEnd);
1409         return;
1410       case NoError :
1411       // 0
1412       default :
1413         needImplementation(); // want to fail to see why we were
1414         // here...
1415         break;
1416     }
1417     String[] arguments = new String[]{new String(field.readableName())};
1418     this.handle(flag, arguments, arguments, nameRef.sourceStart,
1419         nameRef.sourceEnd);
1420   }
1421   public void invalidField(QualifiedNameReference nameRef, FieldBinding field,
1422       int index, TypeBinding searchedType) {
1423     //the resolution of the index-th field of qname failed
1424     //qname.otherBindings[index] is the binding that has produced the
1425     // error
1426     //The different targetted errors should be :
1427     //UndefinedField
1428     //NotVisibleField
1429     //AmbiguousField
1430     if (searchedType.isBaseType()) {
1431       this.handle(IProblem.NoFieldOnBaseType, new String[]{
1432           new String(searchedType.readableName()),
1433           CharOperation.toString(CharOperation.subarray(nameRef.tokens, 0,
1434               index)), new String(nameRef.tokens[index])}, new String[]{
1435           new String(searchedType.sourceName()),
1436           CharOperation.toString(CharOperation.subarray(nameRef.tokens, 0,
1437               index)), new String(nameRef.tokens[index])}, nameRef.sourceStart,
1438           nameRef.sourceEnd);
1439       return;
1440     }
1441     int flag = IProblem.UndefinedField;
1442     switch (field.problemId()) {
1443       case NotFound :
1444         flag = IProblem.UndefinedField;
1445         /*
1446          * also need to check that the searchedType is the receiver type if
1447          * (searchedType.isHierarchyInconsistent()) severity = SecondaryError;
1448          */
1449         break;
1450       case NotVisible :
1451         flag = IProblem.NotVisibleField;
1452         break;
1453       case Ambiguous :
1454         flag = IProblem.AmbiguousField;
1455         break;
1456       case NonStaticReferenceInStaticContext :
1457         flag = IProblem.NonStaticFieldFromStaticInvocation;
1458         break;
1459       case NonStaticReferenceInConstructorInvocation :
1460         flag = IProblem.InstanceFieldDuringConstructorInvocation;
1461         break;
1462       case InheritedNameHidesEnclosingName :
1463         flag = IProblem.InheritedFieldHidesEnclosingName;
1464         break;
1465       case ReceiverTypeNotVisible :
1466         this.handle(IProblem.NotVisibleType, new String[]{new String(
1467             searchedType.leafComponentType().readableName())},
1468             new String[]{new String(searchedType.leafComponentType()
1469                 .shortReadableName())}, nameRef.sourceStart, nameRef.sourceEnd);
1470         return;
1471       case NoError :
1472       // 0
1473       default :
1474         needImplementation(); // want to fail to see why we were
1475         // here...
1476         break;
1477     }
1478     String[] arguments = new String[]{CharOperation.toString(CharOperation
1479         .subarray(nameRef.tokens, 0, index + 1))};
1480     this.handle(flag, arguments, arguments, nameRef.sourceStart,
1481         nameRef.sourceEnd);
1482   }
1483   public void invalidMethod(MessageSend messageSend, MethodBinding method) {
1484     // CODE should be UPDATED according to error coding in the different
1485     // method binding errors
1486     // The different targetted errors should be :
1487     //  UndefinedMethod
1488     //  NotVisibleMethod
1489     //  AmbiguousMethod
1490     //  InheritedNameHidesEnclosingName
1491     //  InstanceMethodDuringConstructorInvocation
1492     // StaticMethodRequested
1493     int flag = IProblem.UndefinedMethod; //default...
1494     switch (method.problemId()) {
1495       case NotFound :
1496         flag = IProblem.UndefinedMethod;
1497         break;
1498       case NotVisible :
1499         flag = IProblem.NotVisibleMethod;
1500         break;
1501       case Ambiguous :
1502         flag = IProblem.AmbiguousMethod;
1503         break;
1504       case InheritedNameHidesEnclosingName :
1505         flag = IProblem.InheritedMethodHidesEnclosingName;
1506         break;
1507       case NonStaticReferenceInConstructorInvocation :
1508         flag = IProblem.InstanceMethodDuringConstructorInvocation;
1509         break;
1510       case NonStaticReferenceInStaticContext :
1511         flag = IProblem.StaticMethodRequested;
1512         break;
1513       case ReceiverTypeNotVisible :
1514         this.handle(IProblem.NotVisibleType, new String[]{new String(
1515             method.declaringClass.leafComponentType().readableName())},
1516             new String[]{new String(method.declaringClass.leafComponentType()
1517                 .shortReadableName())}, messageSend.receiver.sourceStart,
1518             messageSend.receiver.sourceEnd);
1519         return;
1520       case NoError :
1521       // 0
1522       default :
1523         needImplementation(); // want to fail to see why we were
1524         // here...
1525         break;
1526     }
1527     if (flag == IProblem.UndefinedMethod) {
1528       ProblemMethodBinding problemMethod = (ProblemMethodBinding) method;
1529       if (problemMethod.closestMatch != null) {
1530         String closestParameterTypeNames = parametersAsString(problemMethod.closestMatch);
1531         String parameterTypeNames = parametersAsString(method);
1532         String closestParameterTypeShortNames = parametersAsShortString(problemMethod.closestMatch);
1533         String parameterTypeShortNames = parametersAsShortString(method);
1534         if (closestParameterTypeShortNames.equals(parameterTypeShortNames)) {
1535           closestParameterTypeShortNames = closestParameterTypeNames;
1536           parameterTypeShortNames = parameterTypeNames;
1537         }
1538         this.handle(IProblem.ParameterMismatch,
1539             new String[]{
1540                 new String(problemMethod.closestMatch.declaringClass
1541                     .readableName()),
1542                 new String(problemMethod.closestMatch.selector),
1543                 closestParameterTypeNames, parameterTypeNames}, new String[]{
1544                 new String(problemMethod.closestMatch.declaringClass
1545                     .shortReadableName()),
1546                 new String(problemMethod.closestMatch.selector),
1547                 closestParameterTypeShortNames, parameterTypeShortNames},
1548             (int) (messageSend.nameSourcePosition >>> 32),
1549             (int) messageSend.nameSourcePosition);
1550         return;
1551       }
1552     }
1553     this.handle(flag, new String[]{
1554         new String(method.declaringClass.readableName()),
1555         new String(method.selector), parametersAsString(method)}, new String[]{
1556         new String(method.declaringClass.shortReadableName()),
1557         new String(method.selector), parametersAsShortString(method)},
1558         (int) (messageSend.nameSourcePosition >>> 32),
1559         (int) messageSend.nameSourcePosition);
1560   }
1561   public void invalidNullToSynchronize(Expression expression) {
1562     this.handle(IProblem.InvalidNullToSynchronized, NoArgument, NoArgument,
1563         expression.sourceStart, expression.sourceEnd);
1564   }
1565   public void invalidOperator(BinaryExpression expression,
1566       TypeBinding leftType, TypeBinding rightType) {
1567     String leftName = new String(leftType.readableName());
1568     String rightName = new String(rightType.readableName());
1569     String leftShortName = new String(leftType.shortReadableName());
1570     String rightShortName = new String(rightType.shortReadableName());
1571     if (leftShortName.equals(rightShortName)) {
1572       leftShortName = leftName;
1573       rightShortName = rightName;
1574     }
1575     this.handle(IProblem.InvalidOperator, new String[]{
1576         expression.operatorToString(), leftName + ", " + rightName}, //$NON-NLS-1$
1577         new String[]{expression.operatorToString(),
1578             leftShortName + ", " + rightShortName}, //$NON-NLS-1$
1579         expression.sourceStart, expression.sourceEnd);
1580   }
1581   public void invalidOperator(CompoundAssignment assign, TypeBinding leftType,
1582       TypeBinding rightType) {
1583     String leftName = new String(leftType.readableName());
1584     String rightName = new String(rightType.readableName());
1585     String leftShortName = new String(leftType.shortReadableName());
1586     String rightShortName = new String(rightType.shortReadableName());
1587     if (leftShortName.equals(rightShortName)) {
1588       leftShortName = leftName;
1589       rightShortName = rightName;
1590     }
1591     this.handle(IProblem.InvalidOperator, new String[]{
1592         assign.operatorToString(), leftName + ", " + rightName}, //$NON-NLS-1$
1593         new String[]{assign.operatorToString(),
1594             leftShortName + ", " + rightShortName}, //$NON-NLS-1$
1595         assign.sourceStart, assign.sourceEnd);
1596   }
1597   public void invalidOperator(UnaryExpression expression, TypeBinding type) {
1598     this.handle(IProblem.InvalidOperator, new String[]{
1599         expression.operatorToString(), new String(type.readableName())},
1600         new String[]{expression.operatorToString(),
1601             new String(type.shortReadableName())}, expression.sourceStart,
1602         expression.sourceEnd);
1603   }
1604   public void invalidParenthesizedExpression(AstNode reference) {
1605     this.handle(IProblem.InvalidParenthesizedExpression, NoArgument,
1606         NoArgument, reference.sourceStart, reference.sourceEnd);
1607   }
1608   public void invalidSuperclass(SourceTypeBinding type,
1609       TypeReference superclassRef, ReferenceBinding expectedType) {
1610     int problemId = expectedType.problemId();
1611     int id;
1612     switch (problemId) {
1613       case NotFound :
1614         // 1
1615         id = IProblem.SuperclassNotFound;
1616         break;
1617       case NotVisible :
1618         // 2
1619         id = IProblem.SuperclassNotVisible;
1620         break;
1621       case Ambiguous :
1622         // 3
1623         id = IProblem.SuperclassAmbiguous;
1624         break;
1625       case InternalNameProvided :
1626         // 4
1627         id = IProblem.SuperclassInternalNameProvided;
1628         break;
1629       case InheritedNameHidesEnclosingName :
1630         // 5
1631         id = IProblem.SuperclassInheritedNameHidesEnclosingName;
1632         break;
1633       case NoError :
1634       // 0
1635       default :
1636         needImplementation(); // want to fail to see why we were
1637         // here...
1638         return;
1639     }
1640     this.handle(id, new String[]{new String(expectedType.readableName()),
1641         new String(type.sourceName())}, new String[]{
1642         new String(expectedType.shortReadableName()),
1643         new String(type.sourceName())}, superclassRef.sourceStart,
1644         superclassRef.sourceEnd);
1645   }
1646   public void invalidSuperinterface(SourceTypeBinding type,
1647       TypeReference superinterfaceRef, ReferenceBinding expectedType) {
1648     int problemId = expectedType.problemId();
1649     int id;
1650     switch (problemId) {
1651       case NotFound :
1652         // 1
1653         id = IProblem.InterfaceNotFound;
1654         break;
1655       case NotVisible :
1656         // 2
1657         id = IProblem.InterfaceNotVisible;
1658         break;
1659       case Ambiguous :
1660         // 3
1661         id = IProblem.InterfaceAmbiguous;
1662         break;
1663       case InternalNameProvided :
1664         // 4
1665         id = IProblem.InterfaceInternalNameProvided;
1666         break;
1667       case InheritedNameHidesEnclosingName :
1668         // 5
1669         id = IProblem.InterfaceInheritedNameHidesEnclosingName;
1670         break;
1671       case NoError :
1672       // 0
1673       default :
1674         needImplementation(); // want to fail to see why we were
1675         // here...
1676         return;
1677     }
1678     this.handle(id, new String[]{new String(expectedType.readableName()),
1679         new String(type.sourceName())}, new String[]{
1680         new String(expectedType.shortReadableName()),
1681         new String(type.sourceName())}, superinterfaceRef.sourceStart,
1682         superinterfaceRef.sourceEnd);
1683   }
1684   public void invalidType(AstNode location, TypeBinding type) {
1685     int flag = IProblem.UndefinedType; // default
1686     switch (type.problemId()) {
1687       case NotFound :
1688         flag = IProblem.UndefinedType;
1689         break;
1690       case NotVisible :
1691         flag = IProblem.NotVisibleType;
1692         break;
1693       case Ambiguous :
1694         flag = IProblem.AmbiguousType;
1695         break;
1696       case InternalNameProvided :
1697         flag = IProblem.InternalTypeNameProvided;
1698         break;
1699       case InheritedNameHidesEnclosingName :
1700         flag = IProblem.InheritedTypeHidesEnclosingName;
1701         break;
1702       case NoError :
1703       // 0
1704       default :
1705         needImplementation(); // want to fail to see why we were
1706         // here...
1707         break;
1708     }
1709     this.handle(flag, new String[]{new String(type.readableName())},
1710         new String[]{new String(type.shortReadableName())},
1711         location.sourceStart, location.sourceEnd);
1712   }
1713   public void invalidTypeReference(Expression expression) {
1714     this.handle(IProblem.InvalidTypeExpression, NoArgument, NoArgument,
1715         expression.sourceStart, expression.sourceEnd);
1716   }
1717   public void invalidTypeToSynchronize(Expression expression, TypeBinding type) {
1718     this.handle(IProblem.InvalidTypeToSynchronized, new String[]{new String(
1719         type.readableName())},
1720         new String[]{new String(type.shortReadableName())},
1721         expression.sourceStart, expression.sourceEnd);
1722   }
1723   public void invalidUnaryExpression(Expression expression) {
1724     this.handle(IProblem.InvalidUnaryExpression, NoArgument, NoArgument,
1725         expression.sourceStart, expression.sourceEnd);
1726   }
1727   public void isClassPathCorrect(char[][] wellKnownTypeName,
1728       CompilationUnitDeclaration compUnitDecl) {
1729     referenceContext = compUnitDecl;
1730     String[] arguments = new String[]{CharOperation.toString(wellKnownTypeName)};
1731     this.handle(IProblem.IsClassPathCorrect, arguments, arguments,
1732         AbortCompilation | Error, compUnitDecl == null
1733             ? 0
1734             : compUnitDecl.sourceStart, compUnitDecl == null
1735             ? 1
1736             : compUnitDecl.sourceEnd);
1737   }
1738   public void maskedExceptionHandler(ReferenceBinding exceptionType,
1739       AstNode location) {
1740     this.handle(IProblem.MaskedCatch, NoArgument, NoArgument,
1741         location.sourceStart, location.sourceEnd);
1742   }
1743   public void methodNeedingAbstractModifier(MethodDeclaration methodDecl) {
1744     this.handle(IProblem.MethodRequiresBody, NoArgument, NoArgument,
1745         methodDecl.sourceStart, methodDecl.sourceEnd);
1746   }
1747   public void methodNeedingNoBody(MethodDeclaration methodDecl) {
1748     this.handle(
1749     //          ((methodDecl.modifiers & CompilerModifiers.AccNative) != 0) ?
1750         // IProblem.BodyForNativeMethod : IProblem.BodyForAbstractMethod,
1751         IProblem.BodyForAbstractMethod, NoArgument, NoArgument,
1752         methodDecl.sourceStart, methodDecl.sourceEnd);
1753   }
1754   public void methodWithConstructorName(MethodDeclaration methodDecl) {
1755     this.handle(IProblem.MethodButWithConstructorName, NoArgument, NoArgument,
1756         methodDecl.sourceStart, methodDecl.sourceEnd);
1757   }
1758   //public void missingEnclosingInstanceSpecification(ReferenceBinding
1759   // enclosingType, AstNode location) {
1760   //    boolean insideConstructorCall =
1761   //            (location instanceof ExplicitConstructorCall)
1762   //                    && (((ExplicitConstructorCall) location).accessMode ==
1763   // ExplicitConstructorCall.ImplicitSuper);
1764   //
1765   //    this.handle(
1766   //            insideConstructorCall
1767   //                    ? IProblem.MissingEnclosingInstanceForConstructorCall
1768   //                    : IProblem.MissingEnclosingInstance,
1769   //            new String[] {new String(enclosingType.readableName())},
1770   //            new String[] {new String(enclosingType.shortReadableName())},
1771   //            location.sourceStart,
1772   //            location.sourceEnd);
1773   //}
1774   public void missingReturnType(AbstractMethodDeclaration methodDecl) {
1775     this.handle(IProblem.MissingReturnType, NoArgument, NoArgument,
1776         methodDecl.sourceStart, methodDecl.sourceEnd);
1777   }
1778   public void missingSemiColon(Expression expression) {
1779     this.handle(IProblem.MissingSemiColon, NoArgument, NoArgument,
1780         expression.sourceStart, expression.sourceEnd);
1781   }
1782   public void mustDefineDimensionsOrInitializer(
1783       ArrayAllocationExpression expression) {
1784     this.handle(IProblem.MustDefineEitherDimensionExpressionsOrInitializer,
1785         NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd);
1786   }
1787   public void mustSpecifyPackage(CompilationUnitDeclaration compUnitDecl) {
1788     String[] arguments = new String[]{new String(compUnitDecl.getFileName())};
1789     this.handle(IProblem.MustSpecifyPackage, arguments, arguments,
1790         compUnitDecl.sourceStart, compUnitDecl.sourceStart + 1);
1791   }
1792   public void mustUseAStaticMethod(MessageSend messageSend, MethodBinding method) {
1793     this.handle(IProblem.StaticMethodRequested, new String[]{
1794         new String(method.declaringClass.readableName()),
1795         new String(method.selector), parametersAsString(method)}, new String[]{
1796         new String(method.declaringClass.shortReadableName()),
1797         new String(method.selector), parametersAsShortString(method)},
1798         messageSend.sourceStart, messageSend.sourceEnd);
1799   }
1800   public void nativeMethodsCannotBeStrictfp(ReferenceBinding type,
1801       AbstractMethodDeclaration methodDecl) {
1802     String[] arguments = new String[]{new String(type.sourceName()),
1803         new String(methodDecl.selector)};
1804     this.handle(IProblem.NativeMethodsCannotBeStrictfp, arguments, arguments,
1805         methodDecl.sourceStart, methodDecl.sourceEnd);
1806   }
1807   public void needImplementation() {
1808     this.abortDueToInternalError(Util.bind("abort.missingCode")); //$NON-NLS-1$
1809   }
1810   public void needToEmulateFieldReadAccess(FieldBinding field, AstNode location) {
1811     this.handle(IProblem.NeedToEmulateFieldReadAccess,
1812         new String[]{new String(field.declaringClass.readableName()),
1813             new String(field.name)}, new String[]{
1814             new String(field.declaringClass.shortReadableName()),
1815             new String(field.name)}, location.sourceStart, location.sourceEnd);
1816   }
1817   public void needToEmulateFieldWriteAccess(FieldBinding field, AstNode location) {
1818     this.handle(IProblem.NeedToEmulateFieldWriteAccess,
1819         new String[]{new String(field.declaringClass.readableName()),
1820             new String(field.name)}, new String[]{
1821             new String(field.declaringClass.shortReadableName()),
1822             new String(field.name)}, location.sourceStart, location.sourceEnd);
1823   }
1824   public void needToEmulateMethodAccess(MethodBinding method, AstNode location) {
1825     if (method.isConstructor())
1826       this.handle(IProblem.NeedToEmulateConstructorAccess, new String[]{
1827           new String(method.declaringClass.readableName()),
1828           parametersAsString(method)}, new String[]{
1829           new String(method.declaringClass.shortReadableName()),
1830           parametersAsShortString(method)}, location.sourceStart,
1831           location.sourceEnd);
1832     else
1833       this.handle(IProblem.NeedToEmulateMethodAccess, new String[]{
1834           new String(method.declaringClass.readableName()),
1835           new String(method.selector), parametersAsString(method)},
1836           new String[]{new String(method.declaringClass.shortReadableName()),
1837               new String(method.selector), parametersAsShortString(method)},
1838           location.sourceStart, location.sourceEnd);
1839   }
1840   public void nestedClassCannotDeclareInterface(TypeDeclaration typeDecl) {
1841     String[] arguments = new String[]{new String(typeDecl.name)};
1842     this.handle(IProblem.CannotDefineInterfaceInLocalType, arguments,
1843         arguments, typeDecl.sourceStart, typeDecl.sourceEnd);
1844   }
1845   public void noMoreAvailableSpaceForArgument(LocalVariableBinding local,
1846       AstNode location) {
1847     String[] arguments = new String[]{new String(local.name)};
1848     this.handle(local instanceof SyntheticArgumentBinding
1849         ? IProblem.TooManySyntheticArgumentSlots
1850         : IProblem.TooManyArgumentSlots, arguments, arguments, Abort | Error,
1851         location.sourceStart, location.sourceEnd);
1852   }
1853   public void noMoreAvailableSpaceForLocal(LocalVariableBinding local,
1854       AstNode location) {
1855     String[] arguments = new String[]{new String(local.name)};
1856     this.handle(IProblem.TooManyLocalVariableSlots, arguments, arguments, Abort
1857         | Error, location.sourceStart, location.sourceEnd);
1858   }
1859   public void noSuchEnclosingInstance(TypeBinding targetType, AstNode location,
1860       boolean isConstructorCall) {
1861     int id;
1862     if (isConstructorCall) {
1863       //28 = No enclosing instance of type {0} is available due to some
1864       // intermediate constructor invocation
1865       id = IProblem.EnclosingInstanceInConstructorCall;
1866     } else if ((location instanceof ExplicitConstructorCall)
1867         && ((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper) {
1868       //20 = No enclosing instance of type {0} is accessible to invoke
1869       // the super constructor. Must define a constructor and explicitly
1870       // qualify its super constructor invocation with an instance of {0}
1871       // (e.g. x.super() where x is an instance of {0}).
1872       id = IProblem.MissingEnclosingInstanceForConstructorCall;
1873     } else if (location instanceof AllocationExpression
1874         && (((AllocationExpression) location).binding.declaringClass
1875             .isMemberType() || (((AllocationExpression) location).binding.declaringClass
1876             .isAnonymousType() && ((AllocationExpression) location).binding.declaringClass
1877             .superclass().isMemberType()))) {
1878       //21 = No enclosing instance of type {0} is accessible. Must
1879       // qualify the allocation with an enclosing instance of type {0}
1880       // (e.g. x.new A() where x is an instance of {0}).
1881       id = IProblem.MissingEnclosingInstance;
1882     } else { // default
1883       //22 = No enclosing instance of the type {0} is accessible in
1884       // scope
1885       id = IProblem.IncorrectEnclosingInstanceReference;
1886     }
1887     this.handle(id, new String[]{new String(targetType.readableName())},
1888         new String[]{new String(targetType.shortReadableName())},
1889         location.sourceStart, location.sourceEnd);
1890   }
1891   public void notCompatibleTypesError(EqualExpression expression,
1892       TypeBinding leftType, TypeBinding rightType) {
1893     String leftName = new String(leftType.readableName());
1894     String rightName = new String(rightType.readableName());
1895     String leftShortName = new String(leftType.shortReadableName());
1896     String rightShortName = new String(rightType.shortReadableName());
1897     if (leftShortName.equals(rightShortName)) {
1898       leftShortName = leftName;
1899       rightShortName = rightName;
1900     }
1901     this.handle(IProblem.IncompatibleTypesInEqualityOperator, new String[]{
1902         leftName, rightName}, new String[]{leftShortName, rightShortName},
1903         expression.sourceStart, expression.sourceEnd);
1904   }
1905   public void notCompatibleTypesError(InstanceOfExpression expression,
1906       TypeBinding leftType, TypeBinding rightType) {
1907     String leftName = new String(leftType.readableName());
1908     String rightName = new String(rightType.readableName());
1909     String leftShortName = new String(leftType.shortReadableName());
1910     String rightShortName = new String(rightType.shortReadableName());
1911     if (leftShortName.equals(rightShortName)) {
1912       leftShortName = leftName;
1913       rightShortName = rightName;
1914     }
1915     this.handle(IProblem.IncompatibleTypesInConditionalOperator, new String[]{
1916         leftName, rightName}, new String[]{leftShortName, rightShortName},
1917         expression.sourceStart, expression.sourceEnd);
1918   }
1919   public void objectCannotHaveSuperTypes(SourceTypeBinding type) {
1920     this.handle(IProblem.ObjectCannotHaveSuperTypes, NoArgument, NoArgument,
1921         type.sourceStart(), type.sourceEnd());
1922   }
1923   public void operatorOnlyValidOnNumericType(CompoundAssignment assignment,
1924       TypeBinding leftType, TypeBinding rightType) {
1925     String leftName = new String(leftType.readableName());
1926     String rightName = new String(rightType.readableName());
1927     String leftShortName = new String(leftType.shortReadableName());
1928     String rightShortName = new String(rightType.shortReadableName());
1929     if (leftShortName.equals(rightShortName)) {
1930       leftShortName = leftName;
1931       rightShortName = rightName;
1932     }
1933     this.handle(IProblem.TypeMismatch, new String[]{leftName, rightName},
1934         new String[]{leftShortName, rightShortName}, assignment.sourceStart,
1935         assignment.sourceEnd);
1936   }
1937   public void overridesDeprecatedMethod(MethodBinding localMethod,
1938       MethodBinding inheritedMethod) {
1939     this.handle(IProblem.OverridingDeprecatedMethod, new String[]{
1940         new String(CharOperation.concat(localMethod.declaringClass
1941             .readableName(), localMethod.readableName(), '.')),
1942         new String(inheritedMethod.declaringClass.readableName())},
1943         new String[]{
1944             new String(CharOperation.concat(localMethod.declaringClass
1945                 .shortReadableName(), localMethod.shortReadableName(), '.')),
1946             new String(inheritedMethod.declaringClass.shortReadableName())},
1947         localMethod.sourceStart(), localMethod.sourceEnd());
1948   }
1949   public void overridesPackageDefaultMethod(MethodBinding localMethod,
1950       MethodBinding inheritedMethod) {
1951     this.handle(IProblem.OverridingNonVisibleMethod, new String[]{
1952         new String(CharOperation.concat(localMethod.declaringClass
1953             .readableName(), localMethod.readableName(), '.')),
1954         new String(inheritedMethod.declaringClass.readableName())},
1955         new String[]{
1956             new String(CharOperation.concat(localMethod.declaringClass
1957                 .shortReadableName(), localMethod.shortReadableName(), '.')),
1958             new String(inheritedMethod.declaringClass.shortReadableName())},
1959         localMethod.sourceStart(), localMethod.sourceEnd());
1960   }
1961 //  public void packageCollidesWithType(CompilationUnitDeclaration compUnitDecl) {
1962 //    String[] arguments = new String[]{CharOperation
1963 //        .toString(compUnitDecl.currentPackage.tokens)};
1964 //    this.handle(IProblem.PackageCollidesWithType, arguments, arguments,
1965 //        compUnitDecl.currentPackage.sourceStart,
1966 //        compUnitDecl.currentPackage.sourceEnd);
1967 //  }
1968   public void packageIsNotExpectedPackage(
1969       CompilationUnitDeclaration compUnitDecl) {
1970     String[] arguments = new String[]{CharOperation
1971         .toString(compUnitDecl.compilationResult.compilationUnit
1972             .getPackageName())};
1973     this.handle(IProblem.PackageIsNotExpectedPackage, arguments, arguments,
1974         compUnitDecl.currentPackage == null
1975             ? 0
1976             : compUnitDecl.currentPackage.sourceStart,
1977         compUnitDecl.currentPackage == null
1978             ? 0
1979             : compUnitDecl.currentPackage.sourceEnd);
1980   }
1981   private String parametersAsString(MethodBinding method) {
1982     TypeBinding[] params = method.parameters;
1983     StringBuffer buffer = new StringBuffer();
1984     for (int i = 0, length = params.length; i < length; i++) {
1985       if (i != 0)
1986         buffer.append(", "); //$NON-NLS-1$
1987       buffer.append(new String(params[i].readableName()));
1988     }
1989     return buffer.toString();
1990   }
1991   private String parametersAsShortString(MethodBinding method) {
1992     TypeBinding[] params = method.parameters;
1993     StringBuffer buffer = new StringBuffer();
1994     for (int i = 0, length = params.length; i < length; i++) {
1995       if (i != 0)
1996         buffer.append(", "); //$NON-NLS-1$
1997       buffer.append(new String(params[i].shortReadableName()));
1998     }
1999     return buffer.toString();
2000   }
2001   public void parseError(int startPosition, int endPosition,
2002       char[] currentTokenSource, String errorTokenName, String[] possibleTokens) {
2003     if (possibleTokens.length == 0) { //no suggestion available
2004       if (isKeyword(currentTokenSource)) {
2005         String[] arguments = new String[]{new String(currentTokenSource)};
2006         this.handle(IProblem.ParsingErrorOnKeywordNoSuggestion, arguments,
2007             arguments,
2008             // this is the current -invalid- token position
2009             startPosition, endPosition);
2010         return;
2011       } else {
2012         String[] arguments = new String[]{errorTokenName};
2013         this.handle(IProblem.ParsingErrorNoSuggestion, arguments, arguments,
2014         // this is the current -invalid- token position
2015             startPosition, endPosition);
2016         return;
2017       }
2018     }
2019     //build a list of probable right tokens
2020     StringBuffer list = new StringBuffer(20);
2021     for (int i = 0, max = possibleTokens.length; i < max; i++) {
2022       if (i > 0)
2023         list.append(", "); //$NON-NLS-1$
2024       list.append('"');
2025       list.append(possibleTokens[i]);
2026       list.append('"');
2027     }
2028     if (isKeyword(currentTokenSource)) {
2029       String[] arguments = new String[]{new String(currentTokenSource),
2030           list.toString()};
2031       this.handle(IProblem.ParsingErrorOnKeyword, arguments, arguments,
2032       // this is the current -invalid- token position
2033           startPosition, endPosition);
2034       return;
2035     }
2036     //extract the literal when it's a literal
2037     if ((errorTokenName.equals("IntegerLiteral")) || //$NON-NLS-1$
2038         (errorTokenName.equals("LongLiteral")) || //$NON-NLS-1$
2039         (errorTokenName.equals("FloatingPointLiteral")) || //$NON-NLS-1$
2040         (errorTokenName.equals("DoubleLiteral")) || //$NON-NLS-1$
2041         (errorTokenName.equals("StringLiteral")) || //$NON-NLS-1$
2042         (errorTokenName.equals("CharacterLiteral")) || //$NON-NLS-1$
2043         (errorTokenName.equals("Identifier"))) { //$NON-NLS-1$
2044       errorTokenName = new String(currentTokenSource);
2045     }
2046     String[] arguments = new String[]{errorTokenName, list.toString()};
2047     this.handle(IProblem.ParsingError, arguments, arguments,
2048     // this is the current -invalid- token position
2049         startPosition, endPosition);
2050   }
2051   public void publicClassMustMatchFileName(
2052       CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) {
2053     this.referenceContext = typeDecl; // report the problem against the
2054     // type not the entire compilation
2055     // unit
2056     String[] arguments = new String[]{new String(compUnitDecl.getFileName()),
2057         new String(typeDecl.name)};
2058     this.handle(IProblem.PublicClassMustMatchFileName, arguments, arguments,
2059         typeDecl.sourceStart, typeDecl.sourceEnd,
2060         compUnitDecl.compilationResult);
2061   }
2062   public void recursiveConstructorInvocation(
2063       ExplicitConstructorCall constructorCall) {
2064     this.handle(IProblem.RecursiveConstructorInvocation, new String[]{
2065         new String(constructorCall.binding.declaringClass.readableName()),
2066         parametersAsString(constructorCall.binding)}, new String[]{
2067         new String(constructorCall.binding.declaringClass.shortReadableName()),
2068         parametersAsShortString(constructorCall.binding)},
2069         constructorCall.sourceStart, constructorCall.sourceEnd);
2070   }
2071   public void redefineArgument(Argument arg) {
2072     String[] arguments = new String[]{new String(arg.name)};
2073     this.handle(IProblem.RedefinedArgument, arguments, arguments,
2074         arg.sourceStart, arg.sourceEnd);
2075   }
2076   public void redefineLocal(LocalDeclaration localDecl) {
2077     String[] arguments = new String[]{new String(localDecl.name)};
2078     this.handle(IProblem.RedefinedLocal, arguments, arguments,
2079         localDecl.sourceStart, localDecl.sourceEnd);
2080   }
2081   public void referenceMustBeArrayTypeAt(TypeBinding arrayType,
2082       ArrayReference arrayRef) {
2083     this.handle(IProblem.ArrayReferenceRequired, new String[]{new String(
2084         arrayType.readableName())}, new String[]{new String(arrayType
2085         .shortReadableName())}, arrayRef.sourceStart, arrayRef.sourceEnd);
2086   }
2087   public void returnTypeCannotBeVoidArray(SourceTypeBinding type,
2088       MethodDeclaration methodDecl) {
2089     String[] arguments = new String[]{new String(methodDecl.selector)};
2090     this.handle(IProblem.ReturnTypeCannotBeVoidArray, arguments, arguments,
2091         methodDecl.sourceStart, methodDecl.sourceEnd);
2092   }
2093   public void returnTypeProblem(SourceTypeBinding type,
2094       MethodDeclaration methodDecl, TypeBinding expectedType) {
2095     int problemId = expectedType.problemId();
2096     int id;
2097     switch (problemId) {
2098       case NotFound :
2099         // 1
2100         id = IProblem.ReturnTypeNotFound;
2101         break;
2102       case NotVisible :
2103         // 2
2104         id = IProblem.ReturnTypeNotVisible;
2105         break;
2106       case Ambiguous :
2107         // 3
2108         id = IProblem.ReturnTypeAmbiguous;
2109         break;
2110       case InternalNameProvided :
2111         // 4
2112         id = IProblem.ReturnTypeInternalNameProvided;
2113         break;
2114       case InheritedNameHidesEnclosingName :
2115         // 5
2116         id = IProblem.ReturnTypeInheritedNameHidesEnclosingName;
2117         break;
2118       case NoError :
2119       // 0
2120       default :
2121         needImplementation(); // want to fail to see why we were
2122         // here...
2123         return;
2124     }
2125     this.handle(id, new String[]{new String(methodDecl.selector),
2126         new String(expectedType.readableName())}, new String[]{
2127         new String(methodDecl.selector),
2128         new String(expectedType.shortReadableName())},
2129         methodDecl.returnType.sourceStart, methodDecl.returnType.sourceEnd);
2130   }
2131   public void scannerError(Parser parser, String errorTokenName) {
2132     Scanner scanner = parser.scanner;
2133     int flag = IProblem.ParsingErrorNoSuggestion;
2134     int startPos = scanner.startPosition;
2135     //special treatment for recognized errors....
2136     if (errorTokenName.equals(Scanner.END_OF_SOURCE))
2137       flag = IProblem.EndOfSource;
2138     else if (errorTokenName.equals(Scanner.INVALID_HEXA))
2139       flag = IProblem.InvalidHexa;
2140     else if (errorTokenName.equals(Scanner.INVALID_OCTAL))
2141       flag = IProblem.InvalidOctal;
2142     else if (errorTokenName.equals(Scanner.INVALID_CHARACTER_CONSTANT))
2143       flag = IProblem.InvalidCharacterConstant;
2144     else if (errorTokenName.equals(Scanner.INVALID_ESCAPE))
2145       flag = IProblem.InvalidEscape;
2146     else if (errorTokenName.equals(Scanner.INVALID_UNICODE_ESCAPE)) {
2147       flag = IProblem.InvalidUnicodeEscape;
2148       // better locate the error message
2149       char[] source = scanner.source;
2150       int checkPos = scanner.currentPosition - 1;
2151       if (checkPos >= source.length)
2152         checkPos = source.length - 1;
2153       while (checkPos >= startPos) {
2154         if (source[checkPos] == '\\')
2155           break;
2156         checkPos--;
2157       }
2158       startPos = checkPos;
2159     } else if (errorTokenName.equals(Scanner.INVALID_FLOAT))
2160       flag = IProblem.InvalidFloat;
2161     else if (errorTokenName.equals(Scanner.UNTERMINATED_STRING))
2162       flag = IProblem.UnterminatedString;
2163     else if (errorTokenName.equals(Scanner.UNTERMINATED_COMMENT))
2164       flag = IProblem.UnterminatedComment;
2165     else if (errorTokenName.equals(Scanner.INVALID_CHAR_IN_STRING))
2166       flag = IProblem.UnterminatedString;
2167     String[] arguments = flag == IProblem.ParsingErrorNoSuggestion
2168         ? new String[]{errorTokenName}
2169         : NoArgument;
2170     this.handle(flag, arguments, arguments,
2171     // this is the current -invalid- token position
2172         startPos, scanner.currentPosition - 1,
2173         parser.compilationUnit.compilationResult);
2174   }
2175   public void shouldReturn(TypeBinding returnType, AstNode location) {
2176     this.handle(IProblem.ShouldReturnValue, new String[]{new String(returnType
2177         .readableName())}, new String[]{new String(returnType
2178         .shortReadableName())}, location.sourceStart, location.sourceEnd);
2179   }
2180   public void signalNoImplicitStringConversionForCharArrayExpression(
2181       Expression expression) {
2182     this.handle(IProblem.NoImplicitStringConversionForCharArrayExpression,
2183         NoArgument, NoArgument, expression.sourceStart, expression.sourceEnd);
2184   }
2185   public void staticAndInstanceConflict(MethodBinding currentMethod,
2186       MethodBinding inheritedMethod) {
2187     if (currentMethod.isStatic())
2188       this
2189           .handle(
2190           // This static method cannot hide the instance method from %1
2191               // 8.4.6.4 - If a class inherits more than one method with
2192               // the same signature a static (non-abstract) method cannot
2193               // hide an instance method.
2194               IProblem.CannotHideAnInstanceMethodWithAStaticMethod,
2195               new String[]{new String(inheritedMethod.declaringClass
2196                   .readableName())}, new String[]{new String(
2197                   inheritedMethod.declaringClass.shortReadableName())},
2198               currentMethod.sourceStart(), currentMethod.sourceEnd());
2199     else
2200       this
2201           .handle(
2202           // This instance method cannot override the static method from %1
2203               // 8.4.6.4 - If a class inherits more than one method with
2204               // the same signature an instance (non-abstract) method
2205               // cannot override a static method.
2206               IProblem.CannotOverrideAStaticMethodWithAnInstanceMethod,
2207               new String[]{new String(inheritedMethod.declaringClass
2208                   .readableName())}, new String[]{new String(
2209                   inheritedMethod.declaringClass.shortReadableName())},
2210               currentMethod.sourceStart(), currentMethod.sourceEnd());
2211   }
2212   public void staticFieldAccessToNonStaticVariable(FieldReference fieldRef,
2213       FieldBinding field) {
2214     String[] arguments = new String[]{new String(field.readableName())};
2215     this.handle(IProblem.NonStaticFieldFromStaticInvocation, arguments,
2216         arguments, fieldRef.sourceStart, fieldRef.sourceEnd);
2217   }
2218   public void staticFieldAccessToNonStaticVariable(
2219       QualifiedNameReference nameRef, FieldBinding field) {
2220     String[] arguments = new String[]{new String(field.readableName())};
2221     this.handle(IProblem.NonStaticFieldFromStaticInvocation, arguments,
2222         arguments, nameRef.sourceStart, nameRef.sourceEnd);
2223   }
2224   public void staticFieldAccessToNonStaticVariable(SingleNameReference nameRef,
2225       FieldBinding field) {
2226     String[] arguments = new String[]{new String(field.readableName())};
2227     this.handle(IProblem.NonStaticFieldFromStaticInvocation, arguments,
2228         arguments, nameRef.sourceStart, nameRef.sourceEnd);
2229   }
2230   public void staticInheritedMethodConflicts(SourceTypeBinding type,
2231       MethodBinding concreteMethod, MethodBinding[] abstractMethods) {
2232     this.handle(
2233     // The static method %1 conflicts with the abstract method in %2
2234         // 8.4.6.4 - If a class inherits more than one method with the
2235         // same signature it is an error for one to be static
2236         // (non-abstract) and the other abstract.
2237         IProblem.StaticInheritedMethodConflicts, new String[]{
2238             new String(concreteMethod.readableName()),
2239             new String(abstractMethods[0].declaringClass.readableName())},
2240         new String[]{new String(concreteMethod.readableName()),
2241             new String(abstractMethods[0].declaringClass.shortReadableName())},
2242         type.sourceStart(), type.sourceEnd());
2243   }
2244   public void stringConstantIsExceedingUtf8Limit(AstNode location) {
2245     this.handle(IProblem.StringConstantIsExceedingUtf8Limit, NoArgument,
2246         NoArgument, location.sourceStart, location.sourceEnd);
2247   }
2248   public void superclassMustBeAClass(SourceTypeBinding type,
2249       TypeReference superclassRef, ReferenceBinding superType) {
2250     this.handle(IProblem.SuperclassMustBeAClass, new String[]{
2251         new String(superType.readableName()), new String(type.sourceName())},
2252         new String[]{new String(superType.shortReadableName()),
2253             new String(type.sourceName())}, superclassRef.sourceStart,
2254         superclassRef.sourceEnd);
2255   }
2256   public void superinterfaceMustBeAnInterface(SourceTypeBinding type,
2257       TypeDeclaration typeDecl, ReferenceBinding superType) {
2258     this.handle(IProblem.SuperInterfaceMustBeAnInterface, new String[]{
2259         new String(superType.readableName()), new String(type.sourceName())},
2260         new String[]{new String(superType.shortReadableName()),
2261             new String(type.sourceName())}, typeDecl.sourceStart,
2262         typeDecl.sourceEnd);
2263   }
2264   public void task(String tag, String message, String priority, int start,
2265       int end) {
2266     this.handle(IProblem.Task, new String[]{tag, message, priority/*
2267                                                                    * secret
2268                                                                    * argument
2269                                                                    * that is
2270                                                                    * not
2271                                                                    * surfaced
2272                                                                    * in
2273                                                                    * getMessage()
2274                                                                    */}, new String[]{tag, message, priority/*
2275                                               * secret argument that is not
2276                                               * surfaced in getMessage()
2277                                               */}, start, end);
2278   }
2279   public void tooManyDimensions(AstNode expression) {
2280     this.handle(IProblem.TooManyArrayDimensions, NoArgument, NoArgument,
2281         expression.sourceStart, expression.sourceEnd);
2282   }
2283   public void tooManyFields(TypeDeclaration typeDeclaration) {
2284     this.handle(IProblem.TooManyFields, new String[]{new String(
2285         typeDeclaration.binding.readableName())}, new String[]{new String(
2286         typeDeclaration.binding.shortReadableName())}, Abort | Error,
2287         typeDeclaration.sourceStart, typeDeclaration.sourceEnd);
2288   }
2289   public void tooManyMethods(TypeDeclaration typeDeclaration) {
2290     this.handle(IProblem.TooManyMethods, new String[]{new String(
2291         typeDeclaration.binding.readableName())}, new String[]{new String(
2292         typeDeclaration.binding.shortReadableName())}, Abort | Error,
2293         typeDeclaration.sourceStart, typeDeclaration.sourceEnd);
2294   }
2295   public void typeCastError(CastExpression expression, TypeBinding leftType,
2296       TypeBinding rightType) {
2297     String leftName = new String(leftType.readableName());
2298     String rightName = new String(rightType.readableName());
2299     String leftShortName = new String(leftType.shortReadableName());
2300     String rightShortName = new String(rightType.shortReadableName());
2301     if (leftShortName.equals(rightShortName)) {
2302       leftShortName = leftName;
2303       rightShortName = rightName;
2304     }
2305     this.handle(IProblem.IllegalCast, new String[]{rightName, leftName},
2306         new String[]{rightShortName, leftShortName}, expression.sourceStart,
2307         expression.sourceEnd);
2308   }
2309   public void typeCollidesWithPackage(CompilationUnitDeclaration compUnitDecl,
2310       TypeDeclaration typeDecl) {
2311     this.referenceContext = typeDecl; // report the problem against the
2312     // type not the entire compilation
2313     // unit
2314     String[] arguments = new String[]{new String(compUnitDecl.getFileName()),
2315         new String(typeDecl.name)};
2316     this.handle(IProblem.TypeCollidesWithPackage, arguments, arguments,
2317         typeDecl.sourceStart, typeDecl.sourceEnd,
2318         compUnitDecl.compilationResult);
2319   }
2320   public void typeMismatchError(TypeBinding resultType,
2321       TypeBinding expectedType, AstNode location) {
2322     String resultTypeName = new String(resultType.readableName());
2323     String expectedTypeName = new String(expectedType.readableName());
2324     String resultTypeShortName = new String(resultType.shortReadableName());
2325     String expectedTypeShortName = new String(expectedType.shortReadableName());
2326     if (resultTypeShortName.equals(expectedTypeShortName)) {
2327       resultTypeShortName = resultTypeName;
2328       expectedTypeShortName = expectedTypeName;
2329     }
2330     this.handle(IProblem.TypeMismatch, new String[]{resultTypeName,
2331         expectedTypeName}, new String[]{resultTypeShortName,
2332         expectedTypeShortName}, location.sourceStart, location.sourceEnd);
2333   }
2334   public void typeMismatchErrorActualTypeExpectedType(Expression expression,
2335       TypeBinding constantType, TypeBinding expectedType) {
2336     String constantTypeName = new String(constantType.readableName());
2337     String expectedTypeName = new String(expectedType.readableName());
2338     String constantTypeShortName = new String(constantType.shortReadableName());
2339     String expectedTypeShortName = new String(expectedType.shortReadableName());
2340     if (constantTypeShortName.equals(expectedTypeShortName)) {
2341       constantTypeShortName = constantTypeName;
2342       expectedTypeShortName = expectedTypeName;
2343     }
2344     this.handle(IProblem.TypeMismatch, new String[]{constantTypeName,
2345         expectedTypeName}, new String[]{constantTypeShortName,
2346         expectedTypeShortName}, expression.sourceStart, expression.sourceEnd);
2347   }
2348   public void undefinedLabel(BranchStatement statement) {
2349     String[] arguments = new String[]{new String(statement.label)};
2350     this.handle(IProblem.UndefinedLabel, arguments, arguments,
2351         statement.sourceStart, statement.sourceEnd);
2352   }
2353   public void unexpectedStaticModifierForField(SourceTypeBinding type,
2354       FieldDeclaration fieldDecl) {
2355     String[] arguments = new String[]{fieldDecl.name()};
2356     this.handle(IProblem.UnexpectedStaticModifierForField, arguments,
2357         arguments, fieldDecl.sourceStart, fieldDecl.sourceEnd);
2358   }
2359   public void unexpectedStaticModifierForMethod(ReferenceBinding type,
2360       AbstractMethodDeclaration methodDecl) {
2361     String[] arguments = new String[]{new String(type.sourceName()),
2362         new String(methodDecl.selector)};
2363     this.handle(IProblem.UnexpectedStaticModifierForMethod, arguments,
2364         arguments, methodDecl.sourceStart, methodDecl.sourceEnd);
2365   }
2366   public void unhandledException(TypeBinding exceptionType, AstNode location) {
2367     boolean insideDefaultConstructor = (referenceContext instanceof ConstructorDeclaration)
2368         && ((ConstructorDeclaration) referenceContext).isDefaultConstructor();
2369     boolean insideImplicitConstructorCall = (location instanceof ExplicitConstructorCall)
2370         && (((ExplicitConstructorCall) location).accessMode == ExplicitConstructorCall.ImplicitSuper);
2371     this.handle(insideDefaultConstructor
2372         ? IProblem.UnhandledExceptionInDefaultConstructor
2373         : (insideImplicitConstructorCall
2374             ? IProblem.UndefinedConstructorInImplicitConstructorCall
2375             : IProblem.UnhandledException), new String[]{new String(
2376         exceptionType.readableName())}, new String[]{new String(exceptionType
2377         .shortReadableName())}, location.sourceStart, location.sourceEnd);
2378   }
2379   public void uninitializedBlankFinalField(FieldBinding binding,
2380       AstNode location) {
2381     String[] arguments = new String[]{new String(binding.readableName())};
2382     this.handle(IProblem.UninitializedBlankFinalField, arguments, arguments,
2383         location.sourceStart, location.sourceEnd);
2384   }
2385   public void uninitializedLocalVariable(LocalVariableBinding binding,
2386       AstNode location) {
2387     String[] arguments = new String[]{new String(binding.readableName())};
2388     this.handle(IProblem.UninitializedLocalVariable, arguments, arguments,
2389         location.sourceStart, location.sourceEnd);
2390   }
2391   public void unmatchedBracket(int position, ReferenceContext context,
2392       CompilationResult compilationResult) {
2393     this.handle(IProblem.UnmatchedBracket, NoArgument, NoArgument, position,
2394         position, context, compilationResult);
2395   }
2396   public void unnecessaryEnclosingInstanceSpecification(Expression expression,
2397       ReferenceBinding targetType) {
2398     this.handle(IProblem.IllegalEnclosingInstanceSpecification,
2399         new String[]{new String(targetType.readableName())},
2400         new String[]{new String(targetType.shortReadableName())},
2401         expression.sourceStart, expression.sourceEnd);
2402   }
2403   public void unnecessaryReceiverForStaticMethod(AstNode location,
2404       MethodBinding method) {
2405     this.handle(IProblem.NonStaticAccessToStaticMethod, new String[]{
2406         new String(method.declaringClass.readableName()),
2407         new String(method.selector), parametersAsString(method)}, new String[]{
2408         new String(method.declaringClass.shortReadableName()),
2409         new String(method.selector), parametersAsShortString(method)},
2410         location.sourceStart, location.sourceEnd);
2411   }
2412   public void unnecessaryReceiverForStaticField(AstNode location,
2413       FieldBinding field) {
2414     this.handle(IProblem.NonStaticAccessToStaticField,
2415         new String[]{new String(field.declaringClass.readableName()),
2416             new String(field.name)}, new String[]{
2417             new String(field.declaringClass.shortReadableName()),
2418             new String(field.name)}, location.sourceStart, location.sourceEnd);
2419   }
2420   public void unreachableCode(Statement statement) {
2421     this.handle(IProblem.CodeCannotBeReached, NoArgument, NoArgument,
2422         statement.sourceStart, statement.sourceEnd);
2423   }
2424   public void unreachableExceptionHandler(ReferenceBinding exceptionType,
2425       AstNode location) {
2426     this.handle(IProblem.UnreachableCatch, NoArgument, NoArgument,
2427         location.sourceStart, location.sourceEnd);
2428   }
2429   public void unresolvableReference(NameReference nameRef, Binding binding) {
2430     int severity = Error;
2431     /*
2432      * also need to check that the searchedType is the receiver type if
2433      * (binding instanceof ProblemBinding) { ProblemBinding problem =
2434      * (ProblemBinding) binding; if (problem.searchType != null &&
2435      * problem.searchType.isHierarchyInconsistent()) severity = SecondaryError; }
2436      */
2437     String[] arguments = new String[]{new String(binding.readableName())};
2438     this.handle(IProblem.UndefinedName, arguments, arguments, severity,
2439         nameRef.sourceStart, nameRef.sourceEnd);
2440   }
2441   public void unusedArgument(LocalDeclaration localDecl) {
2442     String[] arguments = new String[]{localDecl.name()};
2443     this.handle(IProblem.ArgumentIsNeverUsed, arguments, arguments,
2444         localDecl.sourceStart, localDecl.sourceEnd);
2445   }
2446 //  public void unusedImport(ImportReference importRef) {
2447 //    String[] arguments = new String[]{CharOperation.toString(importRef.tokens)};
2448 //    this.handle(IProblem.UnusedImport, arguments, arguments,
2449 //        importRef.sourceStart, importRef.sourceEnd);
2450 //  }
2451   public void unusedLocalVariable(LocalDeclaration localDecl) {
2452     String[] arguments = new String[]{localDecl.name()};
2453     this.handle(IProblem.LocalVariableIsNeverUsed, arguments, arguments,
2454         localDecl.sourceStart, localDecl.sourceEnd);
2455   }
2456   public void unusedPrivateConstructor(ConstructorDeclaration constructorDecl) {
2457     if (computeSeverity(IProblem.UnusedPrivateConstructor) == Ignore)
2458       return;
2459     // no complaint for no-arg constructors (or default ones) - known
2460     // pattern to block instantiation
2461     if (constructorDecl.arguments == null
2462         || constructorDecl.arguments.length == 0)
2463       return;
2464     MethodBinding constructor = constructorDecl.binding;
2465     this.handle(IProblem.UnusedPrivateConstructor, new String[]{
2466         new String(constructor.declaringClass.readableName()),
2467         parametersAsString(constructor)}, new String[]{
2468         new String(constructor.declaringClass.shortReadableName()),
2469         parametersAsShortString(constructor)}, constructorDecl.sourceStart,
2470         constructorDecl.sourceEnd);
2471   }
2472   public void unusedPrivateField(FieldDeclaration fieldDecl) {
2473     if (computeSeverity(IProblem.UnusedPrivateField) == Ignore)
2474       return;
2475     FieldBinding field = fieldDecl.binding;
2476     if (CharOperation.equals(TypeConstants.SERIALVERSIONUID, field.name)
2477         && field.isStatic() && field.isFinal()
2478         && TypeBinding.LongBinding == field.type) {
2479       return; // do not report unused serialVersionUID field
2480     }
2481     this.handle(IProblem.UnusedPrivateField, new String[]{
2482         new String(field.declaringClass.readableName()),
2483         new String(field.name),}, new String[]{
2484         new String(field.declaringClass.shortReadableName()),
2485         new String(field.name),}, fieldDecl.sourceStart, fieldDecl.sourceEnd);
2486   }
2487   public void unusedPrivateMethod(AbstractMethodDeclaration methodDecl) {
2488     if (computeSeverity(IProblem.UnusedPrivateMethod) == Ignore)
2489       return;
2490     MethodBinding method = methodDecl.binding;
2491     // no report for serialization support 'void
2492     // readObject(ObjectInputStream)'
2493     if (!method.isStatic()
2494         && TypeBinding.VoidBinding == method.returnType
2495         && method.parameters.length == 1
2496         && method.parameters[0].dimensions() == 0
2497         && CharOperation.equals(method.selector, TypeConstants.READOBJECT)
2498         && CharOperation.equals(
2499             TypeConstants.CharArray_JAVA_IO_OBJECTINPUTSTREAM,
2500             method.parameters[0].readableName())) {
2501       return;
2502     }
2503     // no report for serialization support 'void
2504     // writeObject(ObjectOutputStream)'
2505     if (!method.isStatic()
2506         && TypeBinding.VoidBinding == method.returnType
2507         && method.parameters.length == 1
2508         && method.parameters[0].dimensions() == 0
2509         && CharOperation.equals(method.selector, TypeConstants.WRITEOBJECT)
2510         && CharOperation.equals(
2511             TypeConstants.CharArray_JAVA_IO_OBJECTOUTPUTSTREAM,
2512             method.parameters[0].readableName())) {
2513       return;
2514     }
2515     // no report for serialization support 'Object readResolve()'
2516     if (!method.isStatic() && TypeBinding.T_Object == method.returnType.id
2517         && method.parameters.length == 0
2518         && CharOperation.equals(method.selector, TypeConstants.READRESOLVE)) {
2519       return;
2520     }
2521     // no report for serialization support 'Object writeReplace()'
2522     if (!method.isStatic() && TypeBinding.T_Object == method.returnType.id
2523         && method.parameters.length == 0
2524         && CharOperation.equals(method.selector, TypeConstants.WRITEREPLACE)) {
2525       return;
2526     }
2527     this.handle(IProblem.UnusedPrivateMethod, new String[]{
2528         new String(method.declaringClass.readableName()),
2529         new String(method.selector), parametersAsString(method)}, new String[]{
2530         new String(method.declaringClass.shortReadableName()),
2531         new String(method.selector), parametersAsShortString(method)},
2532         methodDecl.sourceStart, methodDecl.sourceEnd);
2533   }
2534   public void unusedPrivateType(TypeDeclaration typeDecl) {
2535     if (computeSeverity(IProblem.UnusedPrivateType) == Ignore)
2536       return;
2537     ReferenceBinding type = typeDecl.binding;
2538     this.handle(IProblem.UnusedPrivateType, new String[]{new String(type
2539         .readableName()),},
2540         new String[]{new String(type.shortReadableName()),},
2541         typeDecl.sourceStart, typeDecl.sourceEnd);
2542   }
2543   public void useAssertAsAnIdentifier(int sourceStart, int sourceEnd) {
2544     this.handle(IProblem.UseAssertAsAnIdentifier, NoArgument, NoArgument,
2545         sourceStart, sourceEnd);
2546   }
2547   public void variableTypeCannotBeVoid(AbstractVariableDeclaration varDecl) {
2548     String[] arguments = new String[]{new String(varDecl.name)};
2549     this.handle(IProblem.VariableTypeCannotBeVoid, arguments, arguments,
2550         varDecl.sourceStart, varDecl.sourceEnd);
2551   }
2552   public void variableTypeCannotBeVoidArray(AbstractVariableDeclaration varDecl) {
2553     String[] arguments = new String[]{new String(varDecl.name)};
2554     this.handle(IProblem.VariableTypeCannotBeVoidArray, arguments, arguments,
2555         varDecl.sourceStart, varDecl.sourceEnd);
2556   }
2557   public void visibilityConflict(MethodBinding currentMethod,
2558       MethodBinding inheritedMethod) {
2559     this.handle(
2560     //  Cannot reduce the visibility of the inherited method from %1
2561         // 8.4.6.3 - The access modifier of an hiding method must
2562         // provide at least as much access as the hidden method.
2563         // 8.4.6.3 - The access modifier of an overiding method must
2564         // provide at least as much access as the overriden method.
2565         IProblem.MethodReducesVisibility, new String[]{new String(
2566             inheritedMethod.declaringClass.readableName())},
2567         new String[]{new String(inheritedMethod.declaringClass
2568             .shortReadableName())}, currentMethod.sourceStart(), currentMethod
2569             .sourceEnd());
2570   }
2571   public void wrongSequenceOfExceptionTypesError(TryStatement statement,
2572       int under, int upper) {
2573     //the two catch block under and upper are in an incorrect order.
2574     //under should be define BEFORE upper in the source
2575     TypeReference typeRef = statement.catchArguments[under].type;
2576     this.handle(IProblem.UnreachableCatch, NoArgument, NoArgument,
2577         typeRef.sourceStart, typeRef.sourceEnd);
2578   }
2579   public void nonExternalizedStringLiteral(AstNode location) {
2580     this.handle(IProblem.NonExternalizedStringLiteral, NoArgument, NoArgument,
2581         location.sourceStart, location.sourceEnd);
2582   }
2583   public void noMoreAvailableSpaceForConstant(TypeDeclaration typeDeclaration) {
2584     this.handle(IProblem.TooManyBytesForStringConstant,
2585         new String[]{new String(typeDeclaration.binding.readableName())},
2586         new String[]{new String(typeDeclaration.binding.shortReadableName())},
2587         Abort | Error, typeDeclaration.sourceStart, typeDeclaration.sourceEnd);
2588   }
2589   public void noMoreAvailableSpaceInConstantPool(TypeDeclaration typeDeclaration) {
2590     this.handle(IProblem.TooManyConstantsInConstantPool,
2591         new String[]{new String(typeDeclaration.binding.readableName())},
2592         new String[]{new String(typeDeclaration.binding.shortReadableName())},
2593         Abort | Error, typeDeclaration.sourceStart, typeDeclaration.sourceEnd);
2594   }
2595   private boolean isKeyword(char[] tokenSource) {
2596     /*
2597      * This code is heavily grammar dependant
2598      */
2599     if (tokenSource == null) {
2600       return false;
2601     }
2602     try {
2603       Scanner scanner = new Scanner();
2604       scanner.setSource(tokenSource);
2605       int token = scanner.getNextToken();
2606       char[] currentKeyword;
2607       try {
2608         currentKeyword = scanner.getCurrentIdentifierSource();
2609       } catch (ArrayIndexOutOfBoundsException e) {
2610         return false;
2611       }
2612       int nextToken = scanner.getNextToken();
2613       if (nextToken == Scanner.TokenNameEOF
2614           && scanner.startPosition == scanner.source.length) { // to
2615         // handle
2616         // case
2617         // where
2618         // we
2619         // had
2620         // an
2621         // ArrayIndexOutOfBoundsException
2622         // while reading the last token
2623         switch (token) {
2624           case Scanner.TokenNameERROR :
2625             if (CharOperation.equals("goto".toCharArray(), currentKeyword)
2626                 || CharOperation.equals("const".toCharArray(), currentKeyword)) { //$NON-NLS-1$ //$NON-NLS-2$
2627               return true;
2628             } else {
2629               return false;
2630             }
2631           case Scanner.TokenNameabstract :
2632           //                            case Scanner.TokenNameassert:
2633           //                            case Scanner.TokenNamebyte:
2634           case Scanner.TokenNamebreak :
2635           //                            case Scanner.TokenNameboolean:
2636           case Scanner.TokenNamecase :
2637           //                            case Scanner.TokenNamechar:
2638           case Scanner.TokenNamecatch :
2639           case Scanner.TokenNameclass :
2640           case Scanner.TokenNamecontinue :
2641           case Scanner.TokenNamedo :
2642           //                            case Scanner.TokenNamedouble:
2643           case Scanner.TokenNamedefault :
2644           case Scanner.TokenNameelse :
2645           case Scanner.TokenNameextends :
2646           case Scanner.TokenNamefor :
2647           //                            case Scanner.TokenNamefinal:
2648           //                            case Scanner.TokenNamefloat:
2649           //                                    case Scanner.TokenNamefalse :
2650           case Scanner.TokenNamefinally :
2651           case Scanner.TokenNameif :
2652           //                            case Scanner.TokenNameint:
2653           //                            case Scanner.TokenNameimport:
2654           case Scanner.TokenNameinterface :
2655           case Scanner.TokenNameimplements :
2656           case Scanner.TokenNameinstanceof :
2657           //                            case Scanner.TokenNamelong:
2658           case Scanner.TokenNamenew :
2659           //                                    case Scanner.TokenNamenull :
2660           //                            case Scanner.TokenNamenative:
2661           case Scanner.TokenNamepublic :
2662           //                            case Scanner.TokenNamepackage:
2663           case Scanner.TokenNameprivate :
2664           case Scanner.TokenNameprotected :
2665           case Scanner.TokenNamereturn :
2666           //                            case Scanner.TokenNameshort:
2667           case Scanner.TokenNamesuper :
2668           case Scanner.TokenNamestatic :
2669           case Scanner.TokenNameswitch :
2670           //                            case Scanner.TokenNamestrictfp:
2671           //                            case Scanner.TokenNamesynchronized:
2672           case Scanner.TokenNametry :
2673 //          case Scanner.TokenNamethis :
2674           //                                    case Scanner.TokenNametrue :
2675           case Scanner.TokenNamethrow :
2676           //                            case Scanner.TokenNamethrows:
2677           //                            case Scanner.TokenNametransient:
2678           //                            case Scanner.TokenNamevoid:
2679           //                            case Scanner.TokenNamevolatile:
2680           case Scanner.TokenNamewhile :
2681             return true;
2682           default :
2683             return false;
2684         }
2685       } else {
2686         return false;
2687       }
2688     } catch (InvalidInputException e) {
2689       return false;
2690     }
2691   }
2692   // jsurfer start
2693   public void phpParsingError(String[] messageArguments,
2694       int problemStartPosition, int problemEndPosition,
2695       ReferenceContext context, CompilationResult compilationResult) {
2696     this.handle(IProblem.PHPParsingError, NoArgument, messageArguments,
2697         problemStartPosition, problemEndPosition, context, compilationResult);
2698   }
2699   public void phpParsingWarning(String[] messageArguments,
2700       int problemStartPosition, int problemEndPosition,
2701       ReferenceContext context, CompilationResult compilationResult) {
2702     this.handle(IProblem.PHPParsingWarning, NoArgument, messageArguments,
2703         problemStartPosition, problemEndPosition, context, compilationResult);
2704   }
2705   public void phpVarDeprecatedWarning(
2706       int problemStartPosition, int problemEndPosition,
2707       ReferenceContext context, CompilationResult compilationResult) {
2708     if (computeSeverity(IProblem.PHPVarDeprecatedWarning) == Ignore)
2709       return;
2710     this.handle(IProblem.PHPVarDeprecatedWarning, NoArgument, new String[]{},
2711         problemStartPosition, problemEndPosition, context, compilationResult);
2712   }
2713
2714   public void phpKeywordWarning(String[] messageArguments,
2715       int problemStartPosition, int problemEndPosition,
2716       ReferenceContext context, CompilationResult compilationResult) {
2717     if (computeSeverity(IProblem.PHPBadStyleKeywordWarning) == Ignore)
2718       return;
2719     this.handle(IProblem.PHPBadStyleKeywordWarning, NoArgument, messageArguments,
2720         problemStartPosition, problemEndPosition, context, compilationResult);
2721   }
2722
2723   public void phpUppercaseIdentifierWarning(
2724       int problemStartPosition, int problemEndPosition,
2725       ReferenceContext context, CompilationResult compilationResult) {
2726     if (computeSeverity(IProblem.PHPBadStyleUppercaseIdentifierWarning) == Ignore)
2727       return;
2728     this.handle(IProblem.PHPBadStyleUppercaseIdentifierWarning, NoArgument, new String[]{},
2729         problemStartPosition, problemEndPosition, context, compilationResult);
2730   }
2731 }