import java.util.ArrayList;

import java.util.Iterator;

import org.eclipse.jdt.core.IBuffer;

import org.eclipse.jdt.core.IMember;

import org.eclipse.jdt.core.IOpenable;

import org.eclipse.jdt.core.ISourceRange;

	/*

	 * Returns the correct method binding according to whether the selection is on the method declaration

	 * or on the inheritDoc tag in its javadoc.

	 */

	private MethodBinding getCorrectMethodBinding(MethodBinding binding) {

		if (this.parser.javadocParser instanceof SelectionJavadocParser) {

			if (((SelectionJavadocParser)this.parser.javadocParser).inheritDocTagSelected){

				try {

					Object res = findMethodWithAttachedDocInHierarchy(binding);

					if (res instanceof MethodBinding) {

						return (MethodBinding) res;

					}

				} catch (JavaModelException e) {

					return null;

				}

			}

		}

		return binding;

	}

	protected MethodBinding findOverriddenMethodInType(ReferenceBinding overriddenType, MethodBinding overriding) throws JavaModelException {

		if (overriddenType == null)

			return null;

		MethodBinding[] overriddenMethods= overriddenType.availableMethods();

		LookupEnvironment lookupEnv = this.lookupEnvironment;

		if (lookupEnv != null && overriddenMethods != null) {

			for (int i= 0; i < overriddenMethods.length; i++) {

				if (lookupEnv.methodVerifier().isMethodSubsignature(overriding, overriddenMethods[i])) {

					return overriddenMethods[i];

				}

			}

		}

		return null;

	}

	private Object findMethodWithAttachedDocInHierarchy(final MethodBinding method) throws JavaModelException {

		ReferenceBinding type= method.declaringClass;

		final SelectionRequestor requestor1 = (SelectionRequestor) this.requestor;

		return new InheritDocVisitor() {

			public Object visit(ReferenceBinding currType) throws JavaModelException {

				MethodBinding overridden =  findOverriddenMethodInType(currType, method);

				if (overridden == null)

					return InheritDocVisitor.CONTINUE;

				TypeBinding args[] = overridden.parameters;

				String names[] = new String[args.length];

				for (int i = 0; i < args.length; i++) {

					names[i] = Signature.createTypeSignature(args[i].sourceName(), false);

				}

				IMember member = (IMember) requestor1.findMethodFromBinding(overridden, names, overridden.declaringClass);

				if (member == null)

					return InheritDocVisitor.CONTINUE;

				if (member.getAttachedJavadoc(null) != null ) {  

					// for binary methods with attached javadoc and no source attached

					return overridden;

				}

				IOpenable openable = member.getOpenable();

				if (openable == null)

					return InheritDocVisitor.CONTINUE;

				IBuffer buf= openable.getBuffer();

				if (buf == null) {

					// no source attachment found. This method maybe the one. Stop.

					return InheritDocVisitor.STOP_BRANCH;

				}

				ISourceRange javadocRange= member.getJavadocRange();

				if (javadocRange == null)

					return InheritDocVisitor.CONTINUE;	// this method doesn't have javadoc, continue to look.

				String rawJavadoc= buf.getText(javadocRange.getOffset(), javadocRange.getLength());

				if (rawJavadoc != null) {

					return overridden;

				}

				return InheritDocVisitor.CONTINUE;

			}

		}.visitInheritDoc(type);

	}

	/**

	 * Implements the "Algorithm for Inheriting Method Comments" as specified for

	 * <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/solaris/javadoc.html#inheritingcomments">1.4.2</a>,

	 * <a href="http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/javadoc.html#inheritingcomments">1.5</a>, and

	 * <a href="http://java.sun.com/javase/6/docs/technotes/tools/windows/javadoc.html#inheritingcomments">1.6</a>.

	 *

	 * <p>

	 * Unfortunately, the implementation is broken in Javadoc implementations since 1.5, see

	 * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6376959">Sun's bug</a>.

	 * </p>

	 *

	 * <p>

	 * We adhere to the spec.

	 * </p>

	 */

	static abstract class InheritDocVisitor {

		public static final Object STOP_BRANCH= new Object() {

			public String toString() { return "STOP_BRANCH"; } //$NON-NLS-1$

		};

		public static final Object CONTINUE= new Object() {

			public String toString() { return "CONTINUE"; } //$NON-NLS-1$

		};

		/**

		 * Visits a type and decides how the visitor should proceed.

		 *

		 * @param currType the current type

		 * @return <ul>

		 *         <li>{@link #STOP_BRANCH} to indicate that no Javadoc has been found and visiting

		 *         super types should stop here</li>

		 *         <li>{@link #CONTINUE} to indicate that no Javadoc has been found and visiting

		 *         super types should continue</li>

		 *         <li>an {@link Object} or <code>null</code>, to indicate that visiting should be

		 *         cancelled immediately. The returned value is the result of

		 *         {@link #visitInheritDoc(ReferenceBinding)}</li>

		 *         </ul>

		 * @throws JavaModelException unexpected problem

		 * @see #visitInheritDoc(ReferenceBinding)

		 */

		public abstract Object visit(ReferenceBinding currType) throws JavaModelException;

		/**

		 * Visits the super types of the given <code>currentType</code>.

		 *

		 * @param currentType the starting type

		 * @return the result from a call to {@link #visit(ReferenceBinding)}, or <code>null</code> if none of

		 *         the calls returned a result

		 * @throws JavaModelException unexpected problem

		 */

		public Object visitInheritDoc(ReferenceBinding currentType) throws JavaModelException {

			ArrayList visited= new ArrayList();

			visited.add(currentType);

			Object result= visitInheritDocInterfaces(visited, currentType);

			if (result != InheritDocVisitor.CONTINUE)

				return result;

			ReferenceBinding superClass= currentType.superclass();

			while (superClass != null && ! visited.contains(superClass)) {

				result= visit(superClass);

				if (result == InheritDocVisitor.STOP_BRANCH) {

					return null;

				} else if (result == InheritDocVisitor.CONTINUE) {

					visited.add(superClass);

					result= visitInheritDocInterfaces(visited, superClass);

					if (result != InheritDocVisitor.CONTINUE)

						return result;

					else

						superClass= superClass.superclass();

				} else {

					return result;

				}

			}

			return null;

		}

		/**

		 * Visits the super interfaces of the given type in the given hierarchy, thereby skipping already visited types.

		 * 

		 * @param visited set of visited types

		 * @param currentType type whose super interfaces should be visited

		 * @return the result, or {@link #CONTINUE} if no result has been found

		 * @throws JavaModelException unexpected problem

		 */

		private Object visitInheritDocInterfaces(ArrayList visited, ReferenceBinding currentType) throws JavaModelException {

			ArrayList toVisitChildren= new ArrayList();

			ReferenceBinding[] superInterfaces= currentType.superInterfaces();

			for (int i= 0; i < superInterfaces.length; i++) {

				ReferenceBinding superInterface= superInterfaces[i];

				if (visited.contains(superInterface))

					continue;

				visited.add(superInterface);

				Object result= visit(superInterface);

				if (result == InheritDocVisitor.STOP_BRANCH) {

					//skip

				} else if (result == InheritDocVisitor.CONTINUE) {

					toVisitChildren.add(superInterface);

				} else {

					return result;

				}

			}

			for (Iterator iter= toVisitChildren.iterator(); iter.hasNext(); ) {

				ReferenceBinding child= (ReferenceBinding) iter.next();

				Object result= visitInheritDocInterfaces(visited, child);

				if (result != InheritDocVisitor.CONTINUE)

					return result;

			}

			return InheritDocVisitor.CONTINUE;

		}

	}

import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// Flag raised when selection is done on inheritDoc javadoc tag

	boolean inheritDocSelected;

		this.inheritDocSelected = false;

		} else if (this.inheritDocSelected) {

			// no selection node when inheritDoc tag is selected

			// But we need to detect it to enable code select on inheritDoc

			ReferenceContext referenceContext = scope.referenceContext();

			if (referenceContext instanceof MethodDeclaration) {

				throw new SelectionNodeFound(((MethodDeclaration) referenceContext).binding);

			}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	public boolean inheritDocTagSelected;

		this.inheritDocTagSelected = false;

		} else if (this.inheritDocTagSelected) {

			((SelectionJavadoc) this.docComment).inheritDocSelected = true;

	/*

	 * Sets a flag to denote that selection has taken place on an inheritDoc tag

	 */

	protected void parseInheritDocTag() {

		if (this.tagSourceStart == this.selectionStart && this.tagSourceEnd == this.selectionEnd)

			this.inheritDocTagSelected = true;

	}

							if (this.inlineTagStarted) {

								// parse a 'valid' inheritDoc tag

								parseInheritDocTag();

							}

	protected void parseInheritDocTag() {

		// do nothing

	}

import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;

/**

 * This method returns an IMethod element from the given method and declaring type bindings. However,

 * unlike {@link Util#findMethod(IType, char[], String[], boolean)} , this does not require an IType to get 

 * the IMethod element.

 * @param method the given method binding

 * @param signatures the type signatures of the method arguments

 * @param declaringClass the binding of the method's declaring class

 * @return an IMethod corresponding to the method binding given, or null if none is found.

 */

public IJavaElement findMethodFromBinding(MethodBinding method, String[] signatures, ReferenceBinding declaringClass) {

	IType foundType = this.resolveType(declaringClass.qualifiedPackageName(), declaringClass.qualifiedSourceName(), NameLookup.ACCEPT_CLASSES & NameLookup.ACCEPT_INTERFACES);

	if (foundType != null) {

		if (foundType instanceof BinaryType) {

			try {

				return Util.findMethod(foundType, method.selector, signatures, method.isConstructor());

			} catch (JavaModelException e) {

				return null;

			}

		} else {

			return foundType.getMethod(new String(method.selector), signatures);

		}

	}

	return null;

}

	/**

	 * Finds the IMethod element corresponding to the given selector, 

	 * without creating a new dummy instance of a binary method. 

	 * @param type the type in which the method is declared

	 * @param selector the method name

	 * @param paramTypeSignatures the type signatures of the method arguments

	 * @param isConstructor whether we're looking for a constructor

	 * @return an IMethod if found, otherwise null

	 * @throws JavaModelException

	 */

	public static IMethod findMethod(IType type, char[] selector, String[] paramTypeSignatures, boolean isConstructor) throws JavaModelException {

		IMethod method = null;

		int startingIndex = 0;

		String[] args;

		IType enclosingType = type.getDeclaringType();

		// If the method is a constructor of a non-static inner type, add the enclosing type as an 

		// additional parameter to the constructor

		if (enclosingType != null

				&& isConstructor

				&& !Flags.isStatic(type.getFlags())) {

			args = new String[paramTypeSignatures.length+1];

			startingIndex = 1;

			args[0] = Signature.createTypeSignature(enclosingType.getFullyQualifiedName(), true);

		} else {

			args = new String[paramTypeSignatures.length];

		}

		int length = args.length;

		for(int i = startingIndex;	i< length ; i++){

			args[i] = new String(paramTypeSignatures[i-startingIndex]);

		}

		method = type.getMethod(new String(selector), args);

		IMethod[] methods = type.findMethods(method);

		if (methods != null && methods.length > 0) {

			method = methods[0];

		}

		return method;

	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// To verify that inheritDoc tag is recognized as a valid selection and

	// pressing F3 on it navigates to the overriden method with the javadoc according to spec

	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor

	public void testBug171019() throws CoreException {

		this.wcOwner = new WorkingCopyOwner() {};

		this.workingCopies = new ICompilationUnit[1];

		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",

			"package b171019;\n" +

			"interface X {\n" +

			"   /**\n" +

			"	 * Main desc of foo..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"interface Y extends X {\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 */\n" +

			"	void foo(int x);\n\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to Y.foo(String)

			"	 */\n" +

			"	void foo(String s);\n" +

			"}\n"

		);

		IJavaElement[] elements = new IJavaElement[2];

		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);

		elements[1] = selectMethod(this.workingCopies[0], "@inheritDoc", 2);

		assertElementsEqual("Invalid selection(s)",

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 

			"foo(String) [in Y [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",

			elements

		);

	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// To verify that inheritDoc tag is recognized as a valid selection and

	// pressing F3 on it navigates to the overriden method with the javadoc according to spec

	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor

	public void testBug171019b() throws CoreException {

		this.wcOwner = new WorkingCopyOwner() {};

		this.workingCopies = new ICompilationUnit[1];

		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",

			"package b171019;\n" +

			"interface X {\n" +

			"   /**\n" +

			"	 * Main desc of foo..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"class X1 implements X{\n" +

			"	void foo(int x){}\n" +

			"}\n" +

			"class Y extends X1 {\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 */\n" +

			"	void foo(int x);\n\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to Y.foo(String)

			"	 */\n" +

			"	void foo(String s);\n" +

			"}\n"

		);

		IJavaElement[] elements = new IJavaElement[2];

		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);

		elements[1] = selectMethod(this.workingCopies[0], "@inheritDoc", 2);

		assertElementsEqual("Invalid selection(s)",

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 

			"foo(String) [in Y [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",

			elements

		);

	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// To verify that inheritDoc tag is recognized as a valid selection and

	// pressing F3 on it navigates to the overriden method with the javadoc according to spec

	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor

	public void testBug171019c() throws CoreException {

		this.wcOwner = new WorkingCopyOwner() {};

		this.workingCopies = new ICompilationUnit[1];

		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",

			"package b171019;\n" +

			"interface X1 {\n" +

			"   /**\n" +

			"	 * Main desc of foo in X1..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"interface X2 {\n" +

			"   /**\n" +

			"	 * Main desc of foo in X2..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"class X implements X1 {\n" +

			"   /**\n" +

			"	 * X desc of foo..\n" +

			"	 */\n" +

			"	void foo(int x){}\n" +

			"}\n" +

			"class Y extends X implements X2 {\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to X2.foo(int)

			"	 */\n" +

			"	void foo(int x);\n\n" +

			"}\n"

		);

		IJavaElement[] elements = new IJavaElement[1];

		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);

		assertElementsEqual("Invalid selection(s)",

			"foo(int) [in X2 [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",

			elements

		);

	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// To verify that inheritDoc tag is recognized as a valid selection and

	// pressing F3 on it navigates to the overriden method with the javadoc according to spec

	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor

	public void testBug171019d() throws CoreException {

		this.wcOwner = new WorkingCopyOwner() {};

		this.workingCopies = new ICompilationUnit[1];

		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",

			"package b171019;\n" +

			"interface X1 {\n" +

			"   /**\n" +

			"	 * Main desc of foo in X1..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"interface X2 {\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"class X implements X1 {\n" +

			"   /**\n" +

			"	 * X desc of foo..\n" +

			"	 */\n" +

			"	void foo(int x){}\n" +

			"}\n" +

			"class Y extends X implements X2 {\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 */\n" +

			"	void foo(int x);\n\n" +

			"}\n"

		);

		IJavaElement[] elements = new IJavaElement[1];

		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);

		assertElementsEqual("Invalid selection(s)",

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",

			elements

		);

	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// To verify that inheritDoc tag is recognized as a valid selection and

	// pressing F3 on it navigates to the overriden method with the javadoc according to spec

	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor

	public void testBug171019e() throws CoreException {

		this.wcOwner = new WorkingCopyOwner() {};

		this.workingCopies = new ICompilationUnit[1];

		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",

			"package b171019;\n" +

			"interface X {\n" +

			"   /**\n" +

			"	 * Main desc of foo..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"interface Y {\n" +

			"	void foo(String str);\n" +

			"}\n" +

			"abstract class Z implements X, Y {\n" +

			"	/**\n" +

			"	 * {@inheritDoc}\n" +	// navigates to X.foo(int)

			"	 */\n" +

			"	void foo(int x) {\n" +

			"	}\n" +

			"}"

		);

		IJavaElement[] elements = new IJavaElement[1];

		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);

		assertElementsEqual("Invalid selection(s)",

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",

			elements

		);

	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019

	// To verify that inheritDoc tag is recognized as a valid selection and

	// pressing F3 on it navigates to the overriden method with the javadoc according to spec

	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor

	// Here the inheritDoc should work when it occurs inside another valid block tag viz.

	// @param, @throws, @exception, @return

	public void testBug171019f() throws CoreException {

		this.wcOwner = new WorkingCopyOwner() {};

		this.workingCopies = new ICompilationUnit[1];

		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",

			"package b171019;\n" +

			"interface X {\n" +

			"   /**\n" +

			"	 * Main desc of foo..\n" +

			"	 */\n" +

			"	void foo(int x);\n" +

			"}\n" +

			"interface Y extends X {\n" +

			"   /**\n" +

			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 * @param {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 * @return {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 * @throws {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 * @exception {@inheritDoc}\n" +	// should navigate to X.foo(int)

			"	 */\n" +

			"	void foo(int x);\n\n" +

			"}\n"

		);

		IJavaElement[] elements = new IJavaElement[4];

		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);

		elements[1] = selectMethod(this.workingCopies[0], "@inheritDoc", 2);

		elements[2] = selectMethod(this.workingCopies[0], "@inheritDoc", 3);

		elements[3] = selectMethod(this.workingCopies[0], "@inheritDoc", 4);

		assertElementsEqual("Invalid selection(s)",

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 

			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",

			elements

		);

	}