java/org/eclipse/xtend/lib/macro/declaration/TypeReference.java

/*******************************************************************************
 * Copyright (c) 2013 itemis AG (http://www.itemis.eu) and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *******************************************************************************/
package org.eclipse.xtend.lib.macro.declaration;

import java.util.List;

import com.google.common.annotations.Beta;

/**
 * @author Sven Efftinge
 * @noimplement This interface is not intended to be implemented by clients.
 */
@Beta
public interface TypeReference extends Element {
	
	/**
	 * Returns a text representation using the simple names of the involved types.
	 * 
	 * I.e. for 
	 * 
	 *   'java.util.List<? extends java.math.BigDecimal>' this method returns
	 *   'List<? extends BigDecimal>'
	 * 
	 * @return the simple name of this type reference
	 */
	String getSimpleName();
	
	/**
	 * returns the text representation using the qualified names of the involved types.
	 * 
	 * @return the qualified name of this type reference
	 */
	String getName();

	/**
	 * @return the referenced type.
	 */
	Type getType();

	/**
	 * @return the type arguments
	 */
	List<TypeReference> getActualTypeArguments();

	/**
	 * @return whether this is a wildcard reference
	 */
	boolean isWildCard();

	/**
	 * @return the upper bounds
	 */
	TypeReference getUpperBound();

	/**
	 * @return the lower bounds
	 */
	TypeReference getLowerBound();

	/**
	 * @return whether this is an array
	 */
	boolean isArray();

	/**
	 * @return the component type if this tye reference is an array type reference, <code>null</code> otherwise.
	 */
	TypeReference getArrayComponentType();

	/**
	 * @return whether this is the any type, The any type is the subtype of every reference type and its only instance is <code>null</code>.
	 */
	boolean isAnyType();

	/**
	 * @return whether this is a primitive type (i.e. one of boolean, char, byte, short, int, long, float, double).
	 */
	boolean isPrimitive();

	/**
	 * @return the corresponding wrapper <code>TypeReference</code> if this type references is a primitive type. Returns <code>this</code> otherwise.
	 */
	TypeReference getWrapperIfPrimitive();

	/**
	 * Checks whether this type is one of the wrapper types for the primitive value types.
	 * 
	 * @return wither this is one of the wrapper types for the primitive value types.
	 */
	boolean isWrapper();

	/**
	 * @return the corresponding primitive <code>TypeReference</code> if this type references is a wrapper type. Returns <code>this</code> otherwise.
	 */
	TypeReference getPrimitiveIfWrapper();

	/**
	 * @return whether this type is 'void' (doesn't include 'java.lang.Void')
	 */
	boolean isVoid();

	/**
	 * Determines if the specified <code>TypeReference</code> parameter can be assigned to this 
	 * <code>TypeReference</code>. It returns <code>true</code> if so;
	 * otherwise it returns <code>false</code>.
	 * 
	 * @param typeReference
	 * @return returns <code>true</code> is the specified type reference parameter can be assigned to this type reference.
	 */
	boolean isAssignableFrom(TypeReference typeReference);
	
	/**
	 * Whether the given type reference is an inferred reference. 
	 * That is the type is to be computed from some Expression, e.g. a method body or a field initializer.
	 * 
	 * Inferred type references can only be used as handles, and will through an {@link UnsupportedOperationException} on every method other than
	 * 
	 * <ul>
	 *  <li>{@link #toString()}</li>
	 *  <li>{@link #equals(Object)}</li>
	 *  <li>{@link #hashCode()}</li>
	 * </ul>
	 * 
	 * @return whether this type reference is an inferred type reference.
	 */
	boolean isInferred();
	
	/**
	 * @return the supertypes (superclass and interfaces) directly implemented/extended by this type
	 * @since 2.7
	 */
	Iterable<? extends TypeReference> getDeclaredSuperTypes();
	
	/**
	 * @return the resolved methods directly declared by this type
	 * @since 2.7
	 */
	Iterable<? extends ResolvedMethod> getDeclaredResolvedMethods();
	
	/**
	 * @return the resolved constructors directly declared by this type
	 * @since 2.7
	 */
	Iterable<? extends ResolvedConstructor> getDeclaredResolvedConstructors();
	
	/**
	 * Computes all the resolved methods that can be called on this type, either because they were
	 * declared directly by the type or by one of its supertypes.
	 * For overloaded methods, the one declared closest to this type is used. E.g. when
	 * called on the class <code>C</code> in this hierarchy:
	 * 
	 * <pre>
	 * class A {
	 *  def CharSequence foo()
	 * }
	 * class B extends A {
	 *  override String foo()
	 * }
	 * class C extends B {}
	 * <pre>
	 * 
	 * B#foo() would be contained, but not A#foo().
	 * 
	 * @return the resolved methods declared in this type and its supertypes. 
	 * @since 2.7
	 */
	Iterable<? extends ResolvedMethod> getAllResolvedMethods();
	
//	/**
//	 * Checks whether this {@link TypeReference} refers to the same type as the other one.
//	 * @param other the type to test equivalence against
//	 * @return true if this type and the given type are equivalent
//	 * @since 2.7
//	 */
//	boolean is(TypeReference other);

	/**
	 * Checks whether this type reference equals the given type reference.
	 * 
	 * For type References where {@link #isInferred()} is <code>true</code>, the implementation is based on
	 * identity of the underlying AST.
	 *  
	 * @param obj
	 * @return whether the given obj is the same instance
	 * @since 2.7
	 */
	public boolean equals(Object obj);
	
	/**
	 * Value-based for all {@link TypeReference}s where {@link #isInferred()} is <code>false</code>.
	 * @since 2.7
	 */
	public int hashCode();
	
	/**
	 * A string representation for this type reference. If this reference is resolved, it will
	 * return the simple name of this reference. Otherwise a technical information about the inferred type
	 * reference.
	 * 
	 * @return a string representation
	 * 
	 * @since 2.8
	 */
	@Override
	public String toString();
}