import org.eclipse.jdt.core.search.SearchMatch;

}

public SearchMatch newDeclarationMatch(ASTNode reference, IJavaElement element, int accuracy, int length, MatchLocator locator) {

	SearchMatch match = null;

	int offset = reference.sourceStart;

	if (this.pattern.findReferences) {

		if (reference instanceof TypeDeclaration) {

			TypeDeclaration type = (TypeDeclaration) reference;

			AbstractMethodDeclaration[] methods = type.methods;

			if (methods != null) {

				for (int i = 0, max = methods.length; i < max; i++) {

					AbstractMethodDeclaration method = methods[i];

					boolean synthetic = method.isDefaultConstructor() && method.sourceStart < type.bodyStart;

					match = locator.newConstructorReferenceMatch(element, accuracy, offset, length, type, synthetic);

				}

			}

		} else if (reference instanceof ConstructorDeclaration) {

			ConstructorDeclaration constructor = (ConstructorDeclaration) reference;

			ExplicitConstructorCall call = constructor.constructorCall;

			boolean synthetic = call != null && call.isSuperAccess();

			match = locator.newConstructorReferenceMatch(element, accuracy, offset, length, constructor, synthetic);

		}

	}

	if (match != null) {

		return match;

	}

	// super implementation...

    return locator.newDeclarationMatch(element, accuracy, reference.sourceStart, length);

public SearchMatch newConstructorReferenceMatch(

		IJavaElement enclosingElement,

		int accuracy,

		int offset,  

		int length,

		ASTNode reference,

		boolean synthetic) {

	SearchParticipant participant = getParticipant(); 

	IResource resource = this.currentPossibleMatch.resource;

	boolean insideDocComment = (reference.bits & ASTNode.InsideJavadoc) != 0;

	return new ConstructorReferenceMatch(enclosingElement, accuracy, offset, length, insideDocComment, synthetic, participant, resource);

}

public SearchMatch newDeclarationMatch(ASTNode reference, IJavaElement element, int accuracy, int length, MatchLocator locator) {

	PatternLocator closestPattern = null;

	int level = IMPOSSIBLE_MATCH;

	for (int i = 0, pl = this.patternLocators.length; i < pl; i++) {

		PatternLocator patternLocator = this.patternLocators[i];

		int newLevel = patternLocator.referenceType() == 0 ? IMPOSSIBLE_MATCH : patternLocator.resolveLevel(reference);

		if (newLevel > level) {

			closestPattern = patternLocator;

			if (newLevel == ACCURATE_MATCH) break;

			level = newLevel;

		}

	}

	if (closestPattern != null) {

	    return closestPattern.newDeclarationMatch(reference, element, accuracy, length, locator);

	}

	// super implementation...

    return locator.newDeclarationMatch(element, accuracy, reference.sourceStart, length);

}

public SearchMatch newDeclarationMatch(ASTNode reference, IJavaElement element, int accuracy, int length, MatchLocator locator) {

    return locator.newDeclarationMatch(element, accuracy, reference.sourceStart, length);

}

/*******************************************************************************

 * Copyright (c) 2000, 2004 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Common Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/cpl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.jdt.core.search;

import org.eclipse.core.resources.IResource;

import org.eclipse.jdt.core.IJavaElement;

/**

 * A Java search match that represents a constructor reference.

 * The element is the inner-most enclosing member that references this method.

 * <p>

 * This class is intended to be instantiated and subclassed by clients.

 * </p>

 * 

 * @since 3.1

 */

public class ConstructorReferenceMatch extends SearchMatch {

	private boolean synthetic;

	/**

	 * Creates a new method reference match.

	 * 

	 * @param enclosingElement the inner-most enclosing member that references this method

	 * @param accuracy one of {@link #A_ACCURATE} or {@link #A_INACCURATE}

	 * @param offset the offset the match starts at, or -1 if unknown

	 * @param length the length of the match, or -1 if unknown

	 * @param insideDocComment <code>true</code> if this search match is inside a doc

	 * comment, and <code>false</code> otherwise

	 * @param synthetic <code>true</code> if this search match is a synthetic constructor

	 * <code>false</code> otherwise

	 * @param participant the search participant that created the match

	 * @param resource the resource of the element

	 */

	public ConstructorReferenceMatch(IJavaElement enclosingElement, int accuracy, int offset, int length, boolean insideDocComment, boolean synthetic, SearchParticipant participant, IResource resource) {

		super(enclosingElement, accuracy, offset, length, participant, resource);

		setInsideDocComment(insideDocComment);

		this.synthetic = synthetic;

	}

	/**

	 * Returns whether the constructor reference is synthetic or not.

	 * Note that a constructor reference can be synthetic when default constructor declaration is used

	 * or imlicit super constructor is called.

	 * 

	 * @return whether the constructor reference is synthetic or not.

	 */

	public final boolean isSynthetic() {

		return this.synthetic;

	}

}