Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2012 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation Samrat Dhillon samrat.dhillon@gmail.com - Search for method references is returning methods as overriden even if the superclass's method is only package-visible - https://bugs.eclipse.org/357547 /
13
 
14
 package org.eclipse.jdt.internal.core.search.matching;
15
 
17
 
18
 import  org.eclipse.core.resources.IResource;
19
 import  org.eclipse.core.runtime.*;
28
 
29
 public class MethodLocator extends PatternLocator {
30
 
31
 protected MethodPattern pattern;
33
 
34
 //extra reference info
35
 public char[][][] allSuperDeclaringTypeNames;
36
 
37
 // This is set only if focus is null. In these cases
38
 // it will be hard to determine if the super class is of the same package
39
 // at a latter point. Hence, this array is created with all the super class 
40
 // names of the same package name as of the matching class name.
41
 // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=357547
42
 private char[][][] samePkgSuperDeclaringTypeNames;
43
 
45
 //method declarations which parameters verification fail
47
 
48
 
49
 public MethodLocator(MethodPattern pattern) {
50
 	super(pattern);
51
 
52
 	this. = pattern;
54
 }
55
 /*
56
  * Clear caches
57
  */
58
 protected void clear() {
60
 }
61
 protected int fineGrain() {
62
 	return this..;
63
 }
64
 
66
 	if (binding == null) return null;
67
 	ReferenceBinding superBinding = binding.superclass();
68
 	int level = resolveLevelForType(this.., this.., superBinding);
69
 	if (level != ) return superBinding;
70
 	// matches superclass
71
 	if (!binding.isInterface() && !CharOperation.equals(binding.compoundName, .)) {
72
 		superBinding = getMatchingSuper(superBinding);
73
 		if (superBinding != null) return superBinding;
74
 	}
75
 	// matches interfaces
76
 	ReferenceBinding[] interfaces = binding.superInterfaces();
77
 	if (interfaces == null) return null;
78
 	for (int i = 0; i < interfaces.length; i++) {
80
 		if (level != ) return interfaces[i];
81
 		superBinding = getMatchingSuper(interfaces[i]);
82
 		if (superBinding != null) return superBinding;
83
 	}
84
 	return null;
85
 }
86
 
87
 private MethodBinding getMethodBinding(ReferenceBinding type, char[] methodName, TypeBinding[] argumentTypes) {
88
 	MethodBinding[] methods = type.getMethods(methodName);
89
 	MethodBinding method = null;
90
 	methodsLoop: for (int i=0, length=methods.length; i<length; i++) {
91
 		method = methods[i];
92
 		TypeBinding[] parameters = method.parameters;
93
 		if (argumentTypes.length == parameters.length) {
94
 			for (int j=0,l=parameters.length; j<l; j++) {
95
 				if (parameters[j].erasure() != argumentTypes[j].erasure()) {
96
 					continue methodsLoop;
97
 				}
98
 			}
99
 			return method;
100
		}
101
	}
102
	return null;
105
public void initializePolymorphicSearch(MatchLocator locator) {
106
	long start = 0;
108
		start = System.currentTimeMillis();
109
	}
110
	try {
111
		SuperTypeNamesCollector namesCollector = 
113
				this.,
116
				locator,
118
				locator.progressMonitor);
119
		this. = namesCollector.collect();
121
		this. = locator;	
122
	} catch (JavaModelException e) {
123
		// inaccurate matches will be found
124
	}
126
		..println("Time to initialize polymorphic search: "+(System.currentTimeMillis()-start)); //$NON-NLS-1$
127
	}
129
/*
130
 * Return whether a type name is in pattern all super declaring types names.
131
 */
132
private boolean isTypeInSuperDeclaringTypeNames(char[][] typeName) {
133
	if (this. == null) return false;
134
	int length = this..length;
135
	for (int i= 0; i<length; i++) {
136
		if (CharOperation.equals(this.[i], typeName)) {
137
			return true;
138
		}
139
	}
140
	return false;
Returns whether the code gen will use an invoke virtual for this message send or not. 
146
protected boolean isVirtualInvoke(MethodBinding method, MessageSend messageSend) {
147
		return !method.isStatic() && !method.isPrivate() && !messageSend.isSuperAccess()
148
			&& !(method.isDefault() && this.. != null 
149
			&& !CharOperation.equals(this.., method.declaringClass.qualifiedPackageName()));
151
public int match(ASTNode node, MatchingNodeSet nodeSet) {
152
	int declarationsLevel = ;
153
	if (this..) {
154
		if (node instanceof ImportReference) {
155
			// With static import, we can have static method reference in import reference
156
			ImportReference importRef = (ImportReference) node;
157
			int length = importRef.tokens.length-1;
158
			if (importRef.isStatic() && ((importRef.bits & .) == 0) && matchesName(this.., importRef.tokens[length])) {
159
				char[][] compoundName = new char[length][];
160
				System.arraycopy(importRef.tokens, 0, compoundName, 0, length);
161
				char[] declaringType = CharOperation.concat(this.., this.., '.');
162
				if (matchesName(declaringType, CharOperation.concatWith(compoundName, '.'))) {
163
					declarationsLevel = this.. ?  : ;
164
				}
165
			}
166
		}
167
	}
168
	return nodeSet.addMatch(node, declarationsLevel);
170
//public int match(ConstructorDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
171
//public int match(Expression node, MatchingNodeSet nodeSet) - SKIP IT
172
//public int match(FieldDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
173
public int match(MethodDeclaration node, MatchingNodeSet nodeSet) {
176
	// Verify method name
177
	if (!matchesName(this.., node.selector)) return ;
179
	// Verify parameters types
180
	boolean resolve = this..;
181
	if (this.. != null) {
182
		int length = this...length;
183
		ASTNode[] args = node.arguments;
184
		int argsLength = args == null ? 0 : args.length;
185
		if (length != argsLength) return ;
186
		for (int i = 0; i < argsLength; i++) {
187
			if (args != null && !matchesTypeReference(this..[i], ((Argument) args[i]).)) {
188
				// Do not return as impossible when source level is at least 1.5
189
				if (this.) {
190
					if (!this..) {
191
						// Set resolution flag on node set in case of types was inferred in parameterized types from generic ones...
192
					 	// (see  bugs https://bugs.eclipse.org/bugs/show_bug.cgi?id=79990, 96761, 96763)
193
						nodeSet.mustResolve = true;
194
						resolve = true;
195
					}
197
				} else {
199
				}
200
			}
201
		}
202
	}
204
	// Verify type arguments (do not reject if pattern has no argument as it can be an erasure match)
206
		if (node.typeParameters == null || node.typeParameters.length != this...length) return ;
207
	}
209
	// Method declaration may match pattern
210
	return nodeSet.addMatch(node, resolve ?  : );
212
public int match(MemberValuePair node, MatchingNodeSet nodeSet) {
215
	if (!matchesName(this.., node.name)) return ;
217
	return nodeSet.addMatch(node, this.. ?  : );
219
public int match(MessageSend node, MatchingNodeSet nodeSet) {
222
	if (!matchesName(this.., node.selector)) return ;
223
	if (this.. != null && (!this.. || ((node.bits & .) != 0))) {
224
		int length = this...length;
225
		ASTNode[] args = node.arguments;
226
		int argsLength = args == null ? 0 : args.length;
227
		if (length != argsLength) return ;
228
	}
230
	return nodeSet.addMatch(node, this.. ?  : );
232
//public int match(Reference node, MatchingNodeSet nodeSet) - SKIP IT
233
public int match(Annotation node, MatchingNodeSet nodeSet) {
235
	MemberValuePair[] pairs = node.memberValuePairs();
236
	if (pairs == null || pairs.length == 0) return ;
238
	int length = pairs.length;
239
	MemberValuePair pair = null;
240
	for (int i=0; i<length; i++) {
241
		pair = node.memberValuePairs()[i];
242
		if (matchesName(this.., pair.name)) {
243
			ASTNode possibleNode = (node instanceof SingleMemberAnnotation) ? (ASTNode) node : pair;
244
			return nodeSet.addMatch(possibleNode, this.. ?  : );
245
		}
246
	}
249
//public int match(TypeDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
250
//public int match(TypeReference node, MatchingNodeSet nodeSet) - SKIP IT
252
protected int matchContainer() {
253
	if (this..) {
254
		// need to look almost everywhere to find in javadocs and static import
256
	}
259
/* (non-Javadoc)
260
 * @see org.eclipse.jdt.internal.core.search.matching.PatternLocator#matchLevelAndReportImportRef(org.eclipse.jdt.internal.compiler.ast.ImportReference, org.eclipse.jdt.internal.compiler.lookup.Binding, org.eclipse.jdt.internal.core.search.matching.MatchLocator)
261
 * Accept to report match of static field on static import
262
 */
263
protected void matchLevelAndReportImportRef(ImportReference importRef, Binding binding, MatchLocator locator) throws CoreException {
264
	if (importRef.isStatic() && binding instanceof MethodBinding) {
265
		super.matchLevelAndReportImportRef(importRef, binding, locator);
266
	}
268
protected int matchMethod(MethodBinding method, boolean skipImpossibleArg) {
269
	if (!matchesName(this.., method.selector)) return ;
271
	int level = ;
272
	// look at return type only if declaring type is not specified
273
	if (this.. == null) {
274
		// TODO (frederic) use this call to refine accuracy on return type
275
		// int newLevel = resolveLevelForType(this.pattern.returnSimpleName, this.pattern.returnQualification, this.pattern.returnTypeArguments, 0, method.returnType);
276
		int newLevel = resolveLevelForType(this.., this.., method.returnType);
277
		if (level > newLevel) {
278
			if (newLevel == ) return ;
279
			level = newLevel; // can only be downgraded
280
		}
281
	}
283
	// parameter types
284
	int parameterCount = this.. == null ? -1 : this...length;
285
	if (parameterCount > -1) {
286
		// global verification
287
		if (method.parameters == null) return ;
288
		if (parameterCount != method.parameters.length) return ;
289
		if (!method.isValidBinding() && ((ProblemMethodBinding)method).problemId() == .) {
290
			// return inaccurate match for ambiguous call (bug 80890)
292
		}
293
		boolean foundTypeVariable = false;
294
		// verify each parameter
295
		for (int i = 0; i < parameterCount; i++) {
296
			TypeBinding argType = method.parameters[i];
297
			int newLevel = ;
298
			if (argType.isMemberType()) {
299
				// only compare source name for member type (bug 41018)
300
				newLevel = CharOperation.match(this..[i], argType.sourceName(), this.)
303
			} else {
304
				// TODO (frederic) use this call to refine accuracy on parameter types
305
//				 newLevel = resolveLevelForType(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i], this.pattern.parametersTypeArguments[i], 0, argType);
307
			}
308
			if (level > newLevel) {
309
				if (newLevel == ) {
310
					if (skipImpossibleArg) {
311
						// Do not consider match as impossible while finding declarations and source level >= 1.5
312
					 	// (see  bugs https://bugs.eclipse.org/bugs/show_bug.cgi?id=79990, 96761, 96763)
313
						newLevel = level;
314
					} else if (argType.isTypeVariable()) {
315
						newLevel = level;
316
						foundTypeVariable = true;
317
					} else {
319
					}
320
				}
321
				level = newLevel; // can only be downgraded
322
			}
323
		}
324
		if (foundTypeVariable) {
325
			if (!method.isStatic() && !method.isPrivate()) {
326
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=123836, No point in textually comparing type variables, captures etc with concrete types. 
327
				MethodBinding focusMethodBinding = this..getMethodBinding(this.);
328
				if (focusMethodBinding != null) {
329
					if (matchOverriddenMethod(focusMethodBinding.declaringClass, focusMethodBinding, method)) {
331
					}
332
				}
333
			} 
335
		}
336
	}
338
	return level;
340
// This works for only methods of parameterized types.
341
private boolean matchOverriddenMethod(ReferenceBinding type, MethodBinding method, MethodBinding matchMethod) {
342
	if (type == null || this.. == null) return false;
344
	// matches superclass
345
	if (!type.isInterface() && !CharOperation.equals(type.compoundName, .)) {
346
		ReferenceBinding superClass = type.superclass();
347
		if (superClass.isParameterizedType()) {
348
			MethodBinding[] methods = superClass.getMethods(this..);
349
			int length = methods.length;
350
			for (int i = 0; i<length; i++) {
351
				if (methods[i].areParametersEqual(method)) {
352
					if (matchMethod == null) {
353
						if (methodParametersEqualsPattern(methods[i].original())) return true;
354
					} else {
355
						if (methods[i].original().areParametersEqual(matchMethod)) return true;
356
					}
357
				}
358
			}
359
		}
360
		if (matchOverriddenMethod(superClass, method, matchMethod)) {
361
			return true;
362
		}
363
	}
365
	// matches interfaces
366
	ReferenceBinding[] interfaces = type.superInterfaces();
367
	if (interfaces == null) return false;
368
	int iLength = interfaces.length;
369
	for (int i = 0; i<iLength; i++) {
370
		if (interfaces[i].isParameterizedType()) {
371
			MethodBinding[] methods = interfaces[i].getMethods(this..);
372
			int length = methods.length;
373
			for (int j = 0; j<length; j++) {
374
				if (methods[j].areParametersEqual(method)) {
375
					if (matchMethod == null) {
376
						if (methodParametersEqualsPattern(methods[j].original())) return true;
377
					} else {
378
						if (methods[j].original().areParametersEqual(matchMethod)) return true;
379
					}
380
				}
381
			}
382
		}
383
		if (matchOverriddenMethod(interfaces[i], method, matchMethod)) {
384
			return true;
385
		}
386
	}
387
	return false;
389
protected void matchReportReference(ASTNode reference, IJavaElement element, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
390
	matchReportReference(reference, element, null, null, elementBinding, accuracy, locator);

See also:
org.eclipse.jdt.internal.core.search.matching.PatternLocator.matchReportReference(org.eclipse.jdt.internal.compiler.ast.ASTNode, org.eclipse.jdt.core.IJavaElement, Binding, int, org.eclipse.jdt.internal.core.search.matching.MatchLocator)
395
protected void matchReportReference(ASTNode reference, IJavaElement element, IJavaElement localElement, IJavaElement[] otherElements, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
396
	MethodBinding methodBinding = (reference instanceof MessageSend) ? ((MessageSend)reference).: ((elementBinding instanceof MethodBinding) ? (MethodBinding) elementBinding : null);
398
		if (methodBinding == null) return;
399
		// need exact match to be able to open on type ref
400
		if (accuracy != .) return;
402
		// element that references the method must be included in the enclosing element
404
		while (element != null && !declPattern.enclosingElement.equals(element))
405
			element = element.getParent();
406
		if (element != null) {
407
			reportDeclaration(methodBinding, locator, declPattern.knownMethods);
408
		}
409
	} else {
410
		MethodReferenceMatch methodReferenceMatch = locator.newMethodReferenceMatch(element, elementBinding, accuracy, -1, -1, false /*not constructor*/, false/*not synthetic*/, reference);
411
		methodReferenceMatch.setLocalElement(localElement);
412
		this. = methodReferenceMatch;
413
		if (this.. && reference instanceof MessageSend) {
414
			IJavaElement focus = this..;
415
			// verify closest match if pattern was bound
416
			// (see bug 70827)
417
			if (focus != null && focus.getElementType() == .) {
418
				if (methodBinding != null && methodBinding.declaringClass != null) {
419
					boolean isPrivate = Flags.isPrivate(((IMethod) focus).getFlags());
420
					if (isPrivate && !CharOperation.equals(methodBinding.declaringClass.sourceName, focus.getParent().getElementName().toCharArray())) {
421
						return; // finally the match was not possible
422
					}
423
				}
424
			}
425
			matchReportReference((MessageSend)reference, locator, accuracy, ((MessageSend)reference).);
426
		} else {
427
			if (reference instanceof SingleMemberAnnotation) {
428
				reference = ((SingleMemberAnnotation)reference).memberValuePairs()[0];
429
				this..setImplicit(true);
430
			}
431
			int offset = reference.sourceStart;
432
			int length =  reference.sourceEnd - offset + 1;
433
			this..setOffset(offset);
434
			this..setLength(length);
435
			locator.report(this.);
436
		}
437
	}
439
void matchReportReference(MessageSend messageSend, MatchLocator locator, int accuracy, MethodBinding methodBinding) throws CoreException {
441
	// Look if there's a need to special report for parameterized type
442
	boolean isParameterized = false;
443
	if (methodBinding instanceof ParameterizedGenericMethodBinding) { // parameterized generic method
444
		isParameterized = true;
446
		// Update match regarding method type arguments
447
		ParameterizedGenericMethodBinding parameterizedMethodBinding = (ParameterizedGenericMethodBinding) methodBinding;
448
		this..setRaw(parameterizedMethodBinding.isRaw);
449
		TypeBinding[] typeArguments = /*parameterizedMethodBinding.isRaw ? null :*/ parameterizedMethodBinding.typeArguments;
450
		updateMatch(typeArguments, locator, this.., this..hasMethodParameters());
452
		// Update match regarding declaring class type arguments
453
		if (methodBinding.declaringClass.isParameterizedType() || methodBinding.declaringClass.isRawType()) {
454
			ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)methodBinding.declaringClass;
455
			if (!this..hasTypeArguments() && this..hasMethodArguments() || parameterizedBinding.isParameterizedWithOwnVariables()) {
456
				// special case for pattern which defines method arguments but not its declaring type
457
				// in this case, we do not refine accuracy using declaring type arguments...!
458
			} else {
459
				updateMatch(parameterizedBinding, this..getTypeArguments(), this..hasTypeParameters(), 0, locator);
460
			}
461
		} else if (this..hasTypeArguments()) {
463
		}
465
		// Update match regarding method parameters
466
		// TODO ? (frederic)
468
		// Update match regarding method return type
469
		// TODO ? (frederic)
471
		// Special case for errors
472
		if (this..getRule() != 0 && messageSend.resolvedType == null) {
474
		}
475
	} else if (methodBinding instanceof ParameterizedMethodBinding) {
476
		isParameterized = true;
477
		if (methodBinding.declaringClass.isParameterizedType() || methodBinding.declaringClass.isRawType()) {
478
			ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)methodBinding.declaringClass;
479
			if (!parameterizedBinding.isParameterizedWithOwnVariables()) {
480
				if ((accuracy & ( | )) != 0) {
481
					// type parameters need to be compared with the class that is really being searched
482
					// https://bugs.eclipse.org/375971
483
					ReferenceBinding refBinding = getMatchingSuper(((ReferenceBinding)messageSend.actualReceiverType));
484
					if (refBinding instanceof ParameterizedTypeBinding) {
485
						parameterizedBinding = ((ParameterizedTypeBinding)refBinding);
486
					}
487
				}
488
				if ((accuracy & ) == 0) {
489
					// not able to get the type parameters if the match is super
490
					updateMatch(parameterizedBinding, this..getTypeArguments(), this..hasTypeParameters(), 0, locator);
491
				}
492
			}
493
		} else if (this..hasTypeArguments()) {
495
		}
497
		// Update match regarding method parameters
498
		// TODO ? (frederic)
500
		// Update match regarding method return type
501
		// TODO ? (frederic)
503
		// Special case for errors
504
		if (this..getRule() != 0 && messageSend.resolvedType == null) {
506
		}
507
	} else if (this..hasMethodArguments()) { // binding has no type params, compatible erasure if pattern does
509
	}
511
	// See whether it is necessary to report or not
512
	if (this..getRule() == 0) return; // impossible match
513
	boolean report = (this. && this..isErasure()) || (this. && this..isEquivalent()) || this..isExact();
514
	if (!report) return;
516
	// Report match
517
	int offset = (int) (messageSend.nameSourcePosition >>> 32);
518
	this..setOffset(offset);
519
	this..setLength(messageSend.sourceEnd - offset + 1);
520
	 if (isParameterized && this..hasMethodArguments())  {
521
		locator.reportAccurateParameterizedMethodReference(this., messageSend, messageSend.typeArguments);
522
	} else {
523
		locator.report(this.);
524
	}
526
/*
527
 * Return whether method parameters are equals to pattern ones.
528
 */
529
private boolean methodParametersEqualsPattern(MethodBinding method) {
530
	TypeBinding[] methodParameters = method.parameters;
532
	int length = methodParameters.length;
533
	if (length != this...length) return false;
535
	for (int i = 0; i < length; i++) {
536
		char[] paramQualifiedName = qualifiedPattern(this..[i], this..[i]);
537
		if (!CharOperation.match(paramQualifiedName, methodParameters[i].readableName(), this.)) {
538
			return false;
539
		}
540
	}
541
	return true;
543
public SearchMatch newDeclarationMatch(ASTNode reference, IJavaElement element, Binding elementBinding, int accuracy, int length, MatchLocator locator) {
544
	if (elementBinding != null) {
545
		MethodBinding methodBinding = (MethodBinding) elementBinding;
546
		// If method parameters verification was not valid, then try to see if method arguments can match a method in hierarchy
548
			// First see if this reference has already been resolved => report match if validated
549
			Boolean report = (Boolean) this..get(reference);
550
			if (report != null) {
551
				if (report.booleanValue()) {
552
					return super.newDeclarationMatch(reference, element, elementBinding, accuracy, length, locator);
553
				}
554
				return null;
555
			}
556
			if (matchOverriddenMethod(methodBinding.declaringClass, methodBinding, null)) {
558
				return super.newDeclarationMatch(reference, element, elementBinding, accuracy, length, locator);
559
			}
560
			if (isTypeInSuperDeclaringTypeNames(methodBinding.declaringClass.compoundName)) {
561
				MethodBinding patternBinding = locator.getMethodBinding(this.);
562
				if (patternBinding != null) {
563
					if (!matchOverriddenMethod(patternBinding.declaringClass, patternBinding, methodBinding)) {
565
						return null;
566
					}
567
				}
569
				return super.newDeclarationMatch(reference, element, elementBinding, accuracy, length, locator);
570
			}
572
			return null;
573
		}
574
	}
575
	return super.newDeclarationMatch(reference, element, elementBinding, accuracy, length, locator);
577
protected int referenceType() {
580
protected void reportDeclaration(MethodBinding methodBinding, MatchLocator locator, SimpleSet knownMethods) throws CoreException {
581
	ReferenceBinding declaringClass = methodBinding.declaringClass;
582
	IType type = locator.lookupType(declaringClass);
583
	if (type == null) return; // case of a secondary type
585
	// Report match for binary
586
	if (type.isBinary()) {
587
		IMethod method = null;
588
		TypeBinding[] parameters = methodBinding.original().;
589
		int parameterLength = parameters.length;
590
		char[][] parameterTypes = new char[parameterLength][];
591
		for (int i = 0; i<parameterLength; i++) {
592
			char[] typeName = parameters[i].qualifiedSourceName();
593
			for (int j=0, dim=parameters[i].dimensions(); j<dim; j++) {
594
				typeName = CharOperation.concat(typeName, new char[] {'[', ']'});
595
			}
596
			parameterTypes[i] = typeName;
597
		}
598
		method = locator.createBinaryMethodHandle(type, methodBinding.selector, parameterTypes);
599
		if (method == null || knownMethods.addIfNotIncluded(method) == null) return;
601
		IResource resource = type.getResource();
602
		if (resource == null)
603
			resource = type.getJavaProject().getProject();
605
		locator.reportBinaryMemberDeclaration(resource, method, methodBinding, info, .);
606
		return;
607
	}
609
	// When source is available, report match if method is found in the declaring type
610
	IResource resource = type.getResource();
611
	if (declaringClass instanceof ParameterizedTypeBinding)
612
		declaringClass = ((ParameterizedTypeBinding) declaringClass).genericType();
613
	ClassScope scope = ((SourceTypeBinding) declaringClass).;
614
	if (scope != null) {
615
		TypeDeclaration typeDecl = scope.referenceContext;
616
		AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(methodBinding.original());
617
		if (methodDecl != null) {
618
			// Create method handle from method declaration
619
			String methodName = new String(methodBinding.selector);
620
			Argument[] arguments = methodDecl.arguments;
621
			int length = arguments == null ? 0 : arguments.length;
622
			String[] parameterTypes = new String[length];
623
			for (int i = 0; i  < length; i++) {
624
				char[][] typeName = arguments[i]..getParameterizedTypeName();
625
				parameterTypes[i] = Signature.createTypeSignature(CharOperation.concatWith(typeName, '.'), false);
626
			}
627
			IMethod method = type.getMethod(methodName, parameterTypes);
628
			if (method == null || knownMethods.addIfNotIncluded(method) == null) return;
630
			// Create and report corresponding match
631
			int offset = methodDecl.sourceStart;
632
			this. = new MethodDeclarationMatch(method, ., offset, methodDecl.sourceEnd-offset+1, locator.getParticipant(), resource);
633
			locator.report(this.);
634
		}
635
	}
637
public int resolveLevel(ASTNode possibleMatchingNode) {
638
	if (this..) {
639
		if (possibleMatchingNode instanceof MessageSend) {
640
			return resolveLevel((MessageSend) possibleMatchingNode);
641
		}
642
		if (possibleMatchingNode instanceof SingleMemberAnnotation) {
643
			SingleMemberAnnotation annotation = (SingleMemberAnnotation) possibleMatchingNode;
644
			return resolveLevel(annotation.memberValuePairs()[0].);
645
		}
646
		if (possibleMatchingNode instanceof MemberValuePair) {
647
			MemberValuePair memberValuePair = (MemberValuePair) possibleMatchingNode;
648
			return resolveLevel(memberValuePair.binding);
649
		}
650
	}
652
		if (possibleMatchingNode instanceof MethodDeclaration) {
653
			return resolveLevel(((MethodDeclaration) possibleMatchingNode).);
654
		}
655
	}
658
public int resolveLevel(Binding binding) {
659
	if (binding == null) return ;
660
	if (!(binding instanceof MethodBinding)) return ;
662
	MethodBinding method = (MethodBinding) binding;
663
	boolean skipVerif = this.. && this.;
664
	int methodLevel = matchMethod(method, skipVerif);
665
	if (methodLevel == ) {
666
		if (method != method.original()) methodLevel = matchMethod(method.original(), skipVerif);
667
		if (methodLevel == ) {
669
		} else {
670
			method = method.original();
671
		}
672
	}
674
	// declaring type
675
	if (this.. == null && this.. == null) return methodLevel; // since any declaring class will do
677
	boolean subType = !method.isStatic() && !method.isPrivate();
678
	if (subType && this.. != null && method.declaringClass != null && method.declaringClass.fPackage != null) {
679
		subType = CharOperation.compareWith(this.., method.declaringClass.fPackage.shortReadableName()) == 0;
680
	}
681
	int declaringLevel = subType
682
		? resolveLevelAsSubtype(this.., this.., method.declaringClass, method.selector, null, method.declaringClass.qualifiedPackageName(), method.isDefault())
684
	return (methodLevel & ) > (declaringLevel & ) ? declaringLevel : methodLevel; // return the weaker match
686
protected int resolveLevel(MessageSend messageSend) {
687
	MethodBinding method = messageSend.binding;
688
	if (method == null) {
690
	}
691
	if (messageSend.resolvedType == null) {
692
		// Closest match may have different argument numbers when ProblemReason is NotFound
693
		// see MessageSend#resolveType(BlockScope)
694
		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=97322
695
		int argLength = messageSend.arguments == null ? 0 : messageSend.arguments.length;
696
		if (this.. == null || argLength == this...length) {
698
		}
700
	}
702
	int methodLevel = matchMethod(method, false);
703
	if (methodLevel == ) {
704
		if (method != method.original()) methodLevel = matchMethod(method.original(), false);
705
		if (methodLevel == ) return ;
706
		method = method.original();
707
	}
709
	// receiver type
710
	if (this.. == null && this.. == null) return methodLevel; // since any declaring class will do
712
	int declaringLevel;
713
	if (isVirtualInvoke(method, messageSend) && (messageSend.actualReceiverType instanceof ReferenceBinding)) {
714
		ReferenceBinding methodReceiverType = (ReferenceBinding) messageSend.actualReceiverType;
715
		declaringLevel = resolveLevelAsSubtype(this.., this.., methodReceiverType, method.selector, method.parameters, methodReceiverType.qualifiedPackageName(), method.isDefault());
716
		if (declaringLevel == ) {
717
			if (method.declaringClass == null || this. == null) {
718
				declaringLevel = ;
719
			} else {
720
				char[][][] superTypeNames = (method.isDefault() && this.. == null) ? this.: this.;
721
				if (superTypeNames != null && resolveLevelAsSuperInvocation(methodReceiverType, method.parameters, superTypeNames, true)) {
722
						declaringLevel = methodLevel // since this is an ACCURATE_MATCH so return the possibly weaker match
723
							| ; // this is an overridden method => add flavor to returned level
724
				}
725
			}
726
		}
727
		if ((declaringLevel & ) != 0) {
728
			// level got some flavors => return it
729
			return declaringLevel;
730
		}
731
	} else {
732
		declaringLevel = resolveLevelForType(this.., this.., method.declaringClass);
733
	}
734
	return (methodLevel & ) > (declaringLevel & ) ? declaringLevel : methodLevel; // return the weaker match
Returns whether the given reference type binding matches or is a subtype of a type that matches the given qualified pattern. Returns ACCURATE_MATCH if it does. Returns INACCURATE_MATCH if resolve fails Returns IMPOSSIBLE_MATCH if it doesn't. 
744
protected int resolveLevelAsSubtype(char[] simplePattern, char[] qualifiedPattern, ReferenceBinding type, char[] methodName, TypeBinding[] argumentTypes, char[] packageName, boolean isDefault) {
745
	if (type == null) return ;
747
	int level = resolveLevelForType(simplePattern, qualifiedPattern, type);
748
	if (level != ) {
749
		if (isDefault && !CharOperation.equals(packageName, type.qualifiedPackageName())) {
751
		}
752
		MethodBinding method = argumentTypes == null ? null : getMethodBinding(type, methodName, argumentTypes);
753
		if (((method != null && !method.isAbstract()) || !type.isAbstract()) && !type.isInterface()) { // if concrete, then method is overridden
755
		}
756
		return level;
757
	}
759
	// matches superclass
760
	if (!type.isInterface() && !CharOperation.equals(type.compoundName, .)) {
761
		level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, type.superclass(), methodName, argumentTypes, packageName, isDefault);
762
		if (level != ) {
763
			if (argumentTypes != null) {
764
				// need to verify if method may be overridden
765
				MethodBinding method = getMethodBinding(type, methodName, argumentTypes);
766
				if (method != null) { // one method match in hierarchy
767
					if ((level & ) != 0) {
768
						// this method is already overridden on a super class, current match is impossible
770
					}
771
					if (!method.isAbstract() && !type.isInterface()) {
772
						// store the fact that the method is overridden
774
					}
775
				}
776
			}
777
			return level | ; // add flavor to returned level
778
		}
779
	}
781
	// matches interfaces
782
	ReferenceBinding[] interfaces = type.superInterfaces();
783
	if (interfaces == null) return ;
784
	for (int i = 0; i < interfaces.length; i++) {
785
		level = resolveLevelAsSubtype(simplePattern, qualifiedPattern, interfaces[i], methodName, null, packageName, isDefault);
786
		if (level != ) {
787
			if (!type.isAbstract() && !type.isInterface()) { // if concrete class, then method is overridden
789
			}
790
			return level | ; // add flavor to returned level
791
		}
792
	}
796
/*
797
 * Return whether the given type binding or one of its possible super interfaces
798
 * matches a type in the declaring type names hierarchy.
799
 */
800
private boolean resolveLevelAsSuperInvocation(ReferenceBinding type, TypeBinding[] argumentTypes, char[][][] superTypeNames, boolean methodAlreadyVerified) {
801
	char[][] compoundName = type.compoundName;
802
	for (int i = 0, max = superTypeNames.length; i < max; i++) {
803
		if (CharOperation.equals(superTypeNames[i], compoundName)) {
804
			// need to verify if the type implements the pattern method
805
			if (methodAlreadyVerified) return true; // already verified before enter into this method (see resolveLevel(MessageSend))
806
			MethodBinding[] methods = type.getMethods(this..);
807
			for (int j=0, length=methods.length; j<length; j++) {
808
				MethodBinding method = methods[j];
809
				TypeBinding[] parameters = method.parameters;
810
				if (argumentTypes.length == parameters.length) {
811
					boolean found = true;
812
					for (int k=0,l=parameters.length; k<l; k++) {
813
						if (parameters[k].erasure() != argumentTypes[k].erasure()) {
814
							found = false;
815
							break;
816
						}
817
					}
818
					if (found) {
819
						return true;
820
					}
821
				}
822
			}
823
			break;
824
		}
825
	}
827
	// If the given type is an interface then a common super interface may be found
828
	// in a parallel branch of the super hierarchy, so we need to verify all super interfaces.
829
	// If it's a class then there's only one possible branch for the hierarchy and
830
	// this branch has been already verified by the test above
831
	if (type.isInterface()) {
832
		ReferenceBinding[] interfaces = type.superInterfaces();
833
		if (interfaces == null) return false;
834
		for (int i = 0; i < interfaces.length; i++) {
835
			if (resolveLevelAsSuperInvocation(interfaces[i], argumentTypes, superTypeNames, false)) {
836
				return true;
837
			}
838
		}
839
	}
840
	return false;
842
public String toString() {
843
	return "Locator for " + this..toString(); //$NON-NLS-1$