/plug-ins/helios/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SourceMethod.java

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

 * Copyright (c) 2000, 2008 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

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

package org.eclipse.jdt.internal.core;



import org.eclipse.jdt.core.Flags;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IMemberValuePair;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.ITypeParameter;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.core.Signature;

import org.eclipse.jdt.core.compiler.CharOperation;

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

import org.eclipse.jdt.internal.core.util.Util;



/**

 * @see IMethod

 */



public class SourceMethod extends NamedMember implements IMethod {



	/**

	 * The parameter type signatures of the method - stored locally to perform equality test.

	 * <code>null</code> indicates no parameters.

	 */

	protected String[] parameterTypes;



	protected SourceMethod(JavaElement parent, String name, String[] parameterTypes) {

		super(parent, name);

		// Assertion disabled since bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=179011

		// Assert.isTrue(name.indexOf('.') == -1);

		if (parameterTypes == null) {

			this.parameterTypes= CharOperation.NO_STRINGS;

		} else {

			this.parameterTypes= parameterTypes;

		}

	}



	protected void closing(Object info) throws JavaModelException {

		super.closing(info);

		SourceMethodElementInfo elementInfo= (SourceMethodElementInfo)info;

		ITypeParameter[] typeParameters= elementInfo.typeParameters;

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

			((TypeParameter)typeParameters[i]).close();

		}

	}



	public boolean equals(Object o) {

		if (!(o instanceof SourceMethod))

			return false;

		return super.equals(o) && Util.equalArraysOrNull(this.parameterTypes, ((SourceMethod)o).parameterTypes);

	}



	public IMemberValuePair getDefaultValue() throws JavaModelException {

		SourceMethodElementInfo sourceMethodInfo= (SourceMethodElementInfo)getElementInfo();

		if (sourceMethodInfo.isAnnotationMethod()) {

			return ((SourceAnnotationMethodInfo)sourceMethodInfo).defaultValue;

		}

		return null;

	}



	/**

	 * @see IJavaElement

	 */

	public int getElementType() {

		return METHOD;

	}



	/**

	 * @see IMethod

	 */

	public String[] getExceptionTypes() throws JavaModelException {

		SourceMethodElementInfo info= (SourceMethodElementInfo)getElementInfo();

		char[][] exs= info.getExceptionTypeNames();

		return CompilationUnitStructureRequestor.convertTypeNamesToSigs(exs);

	}



	/**

	 * @see JavaElement#getHandleMemento(StringBuffer)

	 */

	protected void getHandleMemento(StringBuffer buff) {

		((JavaElement)getParent()).getHandleMemento(buff);

		char delimiter= getHandleMementoDelimiter();

		buff.append(delimiter);

		escapeMementoName(buff, getElementName());

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

			buff.append(delimiter);

			escapeMementoName(buff, this.parameterTypes[i]);

		}

		if (this.occurrenceCount > 1) {

			buff.append(JEM_COUNT);

			buff.append(this.occurrenceCount);

		}

	}



	/**

	 * @see JavaElement#getHandleMemento()

	 */

	protected char getHandleMementoDelimiter() {

		return JavaElement.JEM_METHOD;

	}



/* (non-Javadoc)

 * @see org.eclipse.jdt.core.IMethod#getKey()

 */

	public String getKey() {

		try {

			return getKey(this, false/*don't open*/);

		} catch (JavaModelException e) {

			// happen only if force open is true

			return null;

		}

	}



	/**

	 * @see IMethod

	 */

	public int getNumberOfParameters() {

		return this.parameterTypes == null ? 0 : this.parameterTypes.length;

	}



	/**

	 * @see IMethod

	 */

	public String[] getParameterNames() throws JavaModelException {

		SourceMethodElementInfo info= (SourceMethodElementInfo)getElementInfo();

		char[][] names= info.getArgumentNames();

		return CharOperation.toStrings(names);

	}



	/**

	 * @see IMethod

	 */

	public String[] getParameterTypes() {

		return this.parameterTypes;

	}



	public ITypeParameter getTypeParameter(String typeParameterName) {

		return new TypeParameter(this, typeParameterName);

	}



	public ITypeParameter[] getTypeParameters() throws JavaModelException {

		SourceMethodElementInfo info= (SourceMethodElementInfo)getElementInfo();

		return info.typeParameters;

	}



	/**

	 * @see IMethod#getTypeParameterSignatures()

	 * @since 3.0

	 * @deprecated

	 */

	public String[] getTypeParameterSignatures() throws JavaModelException {

		ITypeParameter[] typeParameters= getTypeParameters();

		int length= typeParameters.length;

		String[] typeParameterSignatures= new String[length];

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

			TypeParameter typeParameter= (TypeParameter)typeParameters[i];

			TypeParameterElementInfo info= (TypeParameterElementInfo)typeParameter.getElementInfo();

			char[][] bounds= info.bounds;

			if (bounds == null) {

				typeParameterSignatures[i]= Signature.createTypeParameterSignature(typeParameter.getElementName(), CharOperation.NO_STRINGS);

			} else {

				int boundsLength= bounds.length;

				char[][] boundSignatures= new char[boundsLength][];

				for (int j= 0; j < boundsLength; j++) {

					boundSignatures[j]= Signature.createCharArrayTypeSignature(bounds[j], false);

				}

				typeParameterSignatures[i]= new String(Signature.createTypeParameterSignature(typeParameter.getElementName().toCharArray(), boundSignatures));

			}

		}

		return typeParameterSignatures;

	}



/*

 * @see JavaElement#getPrimaryElement(boolean)

 */

	public IJavaElement getPrimaryElement(boolean checkOwner) {

		if (checkOwner) {

			CompilationUnit cu= (CompilationUnit)getAncestor(COMPILATION_UNIT);

			if (cu.isPrimary())

				return this;

		}

		IJavaElement primaryParent= this.parent.getPrimaryElement(false);

		return ((IType)primaryParent).getMethod(this.name, this.parameterTypes);

	}



	public String[] getRawParameterNames() throws JavaModelException {

		return getParameterNames();

	}



	/**

	 * @see IMethod

	 */

	public String getReturnType() throws JavaModelException {

		SourceMethodElementInfo info= (SourceMethodElementInfo)getElementInfo();

		return Signature.createTypeSignature(info.getReturnTypeName(), false);

	}



	/**

	 * @see IMethod

	 */

	public String getSignature() throws JavaModelException {

		SourceMethodElementInfo info= (SourceMethodElementInfo)getElementInfo();

		return Signature.createMethodSignature(this.parameterTypes, Signature.createTypeSignature(info.getReturnTypeName(), false));

	}



	/**

	 * @see org.eclipse.jdt.internal.core.JavaElement#hashCode()

	 */

	public int hashCode() {

		int hash= super.hashCode();

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

			hash= Util.combineHashCodes(hash, this.parameterTypes[i].hashCode());

		}

		return hash;

	}



	/**

	 * @see IMethod

	 */

	public boolean isConstructor() throws JavaModelException {

		if (!getElementName().equals(this.parent.getElementName())) {

			// faster than reaching the info

			return false;

		}

		SourceMethodElementInfo info= (SourceMethodElementInfo)getElementInfo();

		return info.isConstructor();

	}



	/**

	 * @see IMethod#isMainMethod()

	 */

	public boolean isMainMethod() throws JavaModelException {

		return this.isMainMethod(this);

	}



/* (non-Javadoc)

 * @see org.eclipse.jdt.core.IMethod#isResolved()

 */

	public boolean isResolved() {

		return false;

	}



	/**

	 * @see IMethod#isSimilar(IMethod)

	 */

	public boolean isSimilar(IMethod method) {

		return areSimilarMethods(

				getElementName(), getParameterTypes(),

				method.getElementName(), method.getParameterTypes(),

				null);

	}



	/**

 */

	public String readableName() {



		StringBuffer buffer= new StringBuffer(super.readableName());

		buffer.append('(');

		int length;

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

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

				buffer.append(Signature.toString(this.parameterTypes[i]));

				if (i < length - 1) {

					buffer.append(", "); //$NON-NLS-1$

				}

			}

		}

		buffer.append(')');

		return buffer.toString();

	}



	public JavaElement resolved(Binding binding) {

		SourceRefElement resolvedHandle= new ResolvedSourceMethod(this.parent, this.name, this.parameterTypes, new String(binding.computeUniqueKey()));

		resolvedHandle.occurrenceCount= this.occurrenceCount;

		return resolvedHandle;

	}



	/**

	 * @private Debugging purposes

	 */

	protected void toStringInfo(int tab, StringBuffer buffer, Object info, boolean showResolvedInfo) {

		buffer.append(tabString(tab));

		if (info == null) {

			toStringName(buffer);

			buffer.append(" (not open)"); //$NON-NLS-1$

		} else if (info == NO_INFO) {

			toStringName(buffer);

		} else {

			SourceMethodElementInfo methodInfo= (SourceMethodElementInfo)info;

			int flags= methodInfo.getModifiers();

			if (Flags.isStatic(flags)) {

				buffer.append("static "); //$NON-NLS-1$

			}

			if (!methodInfo.isConstructor()) {

				buffer.append(methodInfo.getReturnTypeName());

				buffer.append(' ');

			}

			toStringName(buffer, flags);

		}

	}



	protected void toStringName(StringBuffer buffer) {

		toStringName(buffer, 0);

	}



	protected void toStringName(StringBuffer buffer, int flags) {

		buffer.append(getElementName());

		buffer.append('(');

		String[] parameters= getParameterTypes();

		int length;

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

			boolean isVarargs= Flags.isVarargs(flags);

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

				try {

					if (i < length - 1) {

						buffer.append(Signature.toString(parameters[i]));

						buffer.append(", "); //$NON-NLS-1$

					} else if (isVarargs) {

						// remove array from signature

						String parameter= parameters[i].substring(1);

						buffer.append(Signature.toString(parameter));

						buffer.append(" ..."); //$NON-NLS-1$

					} else {

						buffer.append(Signature.toString(parameters[i]));

					}

				} catch (IllegalArgumentException e) {

					// parameter signature is malformed

					buffer.append("*** invalid signature: "); //$NON-NLS-1$

					buffer.append(parameters[i]);

				}

			}

		}

		buffer.append(')');

		if (this.occurrenceCount > 1) {

			buffer.append("#"); //$NON-NLS-1$

			buffer.append(this.occurrenceCount);

		}

	}

}