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