Java Code Examples for org.eclipse.jdt.internal.compiler.lookup.Binding#ARRAY_TYPE

public IPackageBinding getPackage() {
	if (this.binding != null) {
		switch (this.binding.kind()) {
			case Binding.BASE_TYPE :
			case Binding.ARRAY_TYPE :
			case Binding.TYPE_PARAMETER : // includes capture scenario
			case Binding.WILDCARD_TYPE :
			case Binding.INTERSECTION_TYPE:
				return null;
		}
		IPackageBinding packageBinding = this.resolver.getPackageBinding(this.binding.getPackage());
		if (packageBinding != null) return packageBinding;
	}
	if (this.innerTypeBinding != null && this.dimensions > 0) {
		return null;
	}
	CompilationUnitScope scope = this.resolver.scope();
	if (scope != null) {
		return this.resolver.getPackageBinding(scope.getCurrentPackage());
	}
	return null;
}
 

IBinding getBinding(org.eclipse.jdt.internal.compiler.lookup.Binding binding) {
	switch (binding.kind()) {
		case Binding.PACKAGE:
			return getPackageBinding((org.eclipse.jdt.internal.compiler.lookup.PackageBinding) binding);
		case Binding.TYPE:
		case Binding.BASE_TYPE:
		case Binding.GENERIC_TYPE:
		case Binding.PARAMETERIZED_TYPE:
		case Binding.RAW_TYPE:
			return getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) binding);
		case Binding.ARRAY_TYPE:
		case Binding.TYPE_PARAMETER:
			return new TypeBinding(this, (org.eclipse.jdt.internal.compiler.lookup.TypeBinding) binding);
		case Binding.METHOD:
			return getMethodBinding((org.eclipse.jdt.internal.compiler.lookup.MethodBinding) binding);
		case Binding.FIELD:
		case Binding.LOCAL:
			return getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.VariableBinding) binding);
	}
	return null;
}
 

/**
 * Create a new element that knows what kind it is even if the binding is unresolved.
 */
public Element newElement(Binding binding, ElementKind kindHint) {
	if (binding == null)
		return null;
	switch (binding.kind()) {
	case Binding.FIELD:
	case Binding.LOCAL:
	case Binding.VARIABLE:
		return new VariableElementImpl(_env, (VariableBinding) binding);
	case Binding.TYPE:
	case Binding.GENERIC_TYPE:
		ReferenceBinding referenceBinding = (ReferenceBinding)binding;
		if ((referenceBinding.tagBits & TagBits.HasMissingType) != 0) {
			return new ErrorTypeElement(this._env, referenceBinding);
		}
		if (CharOperation.equals(referenceBinding.sourceName, TypeConstants.PACKAGE_INFO_NAME)) {
			return new PackageElementImpl(_env, referenceBinding.fPackage);
		}
		return new TypeElementImpl(_env, referenceBinding, kindHint);
	case Binding.METHOD:
		return new ExecutableElementImpl(_env, (MethodBinding)binding);
	case Binding.RAW_TYPE:
	case Binding.PARAMETERIZED_TYPE:
		return new TypeElementImpl(_env, ((ParameterizedTypeBinding)binding).genericType(), kindHint);
	case Binding.PACKAGE:
		return new PackageElementImpl(_env, (PackageBinding)binding);
	case Binding.TYPE_PARAMETER:
		return new TypeParameterElementImpl(_env, (TypeVariableBinding)binding);
		// TODO: fill in the rest of these
	case Binding.IMPORT:
	case Binding.ARRAY_TYPE:
	case Binding.BASE_TYPE:
	case Binding.WILDCARD_TYPE:
	case Binding.INTERSECTION_TYPE:
		throw new UnsupportedOperationException("NYI: binding type " + binding.kind()); //$NON-NLS-1$
	}
	return null;
}
 

public IPackageBinding getPackage() {
	switch (this.binding.kind()) {
		case Binding.BASE_TYPE :
		case Binding.ARRAY_TYPE :
		case Binding.TYPE_PARAMETER : // includes capture scenario
		case Binding.WILDCARD_TYPE :
		case Binding.INTERSECTION_TYPE:
		case Binding.INTERSECTION_CAST_TYPE:
			return null;
	}
	ReferenceBinding referenceBinding = (ReferenceBinding) this.binding;
	return this.resolver.getPackageBinding(referenceBinding.getPackage());
}
 

public synchronized ITypeBinding getSuperclass() {
	if (this.binding == null)
		return null;
	switch (this.binding.kind()) {
		case Binding.ARRAY_TYPE :
		case Binding.BASE_TYPE :
			return null;
		default:
			// no superclass for interface types (interface | annotation type)
			if (this.binding.isInterface())
				return null;
	}
	ReferenceBinding superclass = null;
	try {
		superclass = ((ReferenceBinding)this.binding).superclass();
	} catch (RuntimeException e) {
		/* in case a method cannot be resolvable due to missing jars on the classpath
		 * see https://bugs.eclipse.org/bugs/show_bug.cgi?id=57871
		 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=63550
		 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=64299
		 */
		org.eclipse.jdt.internal.core.util.Util.log(e, "Could not retrieve superclass"); //$NON-NLS-1$
		return this.resolver.resolveWellKnownType("java.lang.Object"); //$NON-NLS-1$
	}
	if (superclass == null) {
		return null;
	}
	return this.resolver.getTypeBinding(superclass);
}
 

/**
 * Given a binding of uncertain type, try to create the right sort of TypeMirror for it.
 */
public TypeMirror newTypeMirror(Binding binding) {
	switch (binding.kind()) {
	case Binding.FIELD:
	case Binding.LOCAL:
	case Binding.VARIABLE:
		// For variables, return the type of the variable
		return newTypeMirror(((VariableBinding)binding).type);
		
	case Binding.PACKAGE:
		return getNoType(TypeKind.PACKAGE);
		
	case Binding.IMPORT:
		throw new UnsupportedOperationException("NYI: import type " + binding.kind()); //$NON-NLS-1$

	case Binding.METHOD:
		return new ExecutableTypeImpl(_env, (MethodBinding) binding);
		
	case Binding.TYPE:
	case Binding.RAW_TYPE:
	case Binding.GENERIC_TYPE:
	case Binding.PARAMETERIZED_TYPE:
		ReferenceBinding referenceBinding = (ReferenceBinding) binding;
		if ((referenceBinding.tagBits & TagBits.HasMissingType) != 0) {
			return getErrorType(referenceBinding);
		}
		return new DeclaredTypeImpl(_env, (ReferenceBinding)binding);
		
	case Binding.ARRAY_TYPE:
		return new ArrayTypeImpl(_env, (ArrayBinding)binding);
		
	case Binding.BASE_TYPE:
		BaseTypeBinding btb = (BaseTypeBinding)binding;
		switch (btb.id) {
			case TypeIds.T_void:
				return getNoType(TypeKind.VOID);
			case TypeIds.T_null:
				return getNullType();
			default:
				return getPrimitiveType(btb);
		}

	case Binding.WILDCARD_TYPE:
	case Binding.INTERSECTION_TYPE: // TODO compatible, but shouldn't it really be an intersection type?
		return new WildcardTypeImpl(_env, (WildcardBinding) binding);

	case Binding.TYPE_PARAMETER:
		return new TypeVariableImpl(_env, (TypeVariableBinding) binding);
	}
	return null;
}
 

public synchronized ITypeBinding[] getInterfaces() {
	if (this.prototype != null) {
		return this.prototype.getInterfaces();
	}
	if (this.interfaces != null) {
		return this.interfaces;
	}
	if (this.binding == null)
		return this.interfaces = NO_TYPE_BINDINGS;
	switch (this.binding.kind()) {
		case Binding.ARRAY_TYPE :
		case Binding.BASE_TYPE :
			return this.interfaces = NO_TYPE_BINDINGS;
	}
	ReferenceBinding referenceBinding = (ReferenceBinding) this.binding;
	ReferenceBinding[] internalInterfaces = null;
	try {
		internalInterfaces = referenceBinding.superInterfaces();
	} catch (RuntimeException e) {
		/* in case a method cannot be resolvable due to missing jars on the classpath
		 * see https://bugs.eclipse.org/bugs/show_bug.cgi?id=57871
		 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=63550
		 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=64299
		 */
		org.eclipse.jdt.internal.core.util.Util.log(e, "Could not retrieve interfaces"); //$NON-NLS-1$
	}
	int length = internalInterfaces == null ? 0 : internalInterfaces.length;
	if (length != 0) {
		ITypeBinding[] newInterfaces = new ITypeBinding[length];
		int interfacesCounter = 0;
		for (int i = 0; i < length; i++) {
			ITypeBinding typeBinding = this.resolver.getTypeBinding(internalInterfaces[i]);
			if (typeBinding == null) {
				continue;
			}
			newInterfaces[interfacesCounter++] = typeBinding;
		}
		if (length != interfacesCounter) {
			System.arraycopy(newInterfaces, 0, (newInterfaces = new ITypeBinding[interfacesCounter]), 0, interfacesCounter);
		}
		return this.interfaces = newInterfaces;
	}
	return this.interfaces = NO_TYPE_BINDINGS;
}
 

public String getName() {
	StringBuffer buffer;
	switch (this.binding.kind()) {

		case Binding.WILDCARD_TYPE :
		case Binding.INTERSECTION_TYPE:
			WildcardBinding wildcardBinding = (WildcardBinding) this.binding;
			buffer = new StringBuffer();
			buffer.append(TypeConstants.WILDCARD_NAME);
			if (wildcardBinding.bound != null) {
				switch(wildcardBinding.boundKind) {
			        case Wildcard.SUPER :
			        	buffer.append(TypeConstants.WILDCARD_SUPER);
			            break;
			        case Wildcard.EXTENDS :
			        	buffer.append(TypeConstants.WILDCARD_EXTENDS);
				}
				buffer.append(getBound().getName());
			}
			return String.valueOf(buffer);

		case Binding.TYPE_PARAMETER :
			if (isCapture()) {
				return NO_NAME;
			}
			TypeVariableBinding typeVariableBinding = (TypeVariableBinding) this.binding;
			return new String(typeVariableBinding.sourceName);

		case Binding.PARAMETERIZED_TYPE :
			ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) this.binding;
			buffer = new StringBuffer();
			buffer.append(parameterizedTypeBinding.sourceName());
			ITypeBinding[] tArguments = getTypeArguments();
			final int typeArgumentsLength = tArguments.length;
			if (typeArgumentsLength != 0) {
				buffer.append('<');
				for (int i = 0; i < typeArgumentsLength; i++) {
					if (i > 0) {
						buffer.append(',');
					}
					buffer.append(tArguments[i].getName());
				}
				buffer.append('>');
			}
			return String.valueOf(buffer);

		case Binding.RAW_TYPE :
			return getTypeDeclaration().getName();

		case Binding.ARRAY_TYPE :
			ITypeBinding elementType = getElementType();
			if (elementType.isLocal() || elementType.isAnonymous() || elementType.isCapture()) {
				return NO_NAME;
			}
			int dimensions = getDimensions();
			char[] brackets = new char[dimensions * 2];
			for (int i = dimensions * 2 - 1; i >= 0; i -= 2) {
				brackets[i] = ']';
				brackets[i - 1] = '[';
			}
			buffer = new StringBuffer(elementType.getName());
			buffer.append(brackets);
			return String.valueOf(buffer);

		default :
			if (isPrimitive() || isNullType()) {
				BaseTypeBinding baseTypeBinding = (BaseTypeBinding) this.binding;
				return new String(baseTypeBinding.simpleName);
			}
			if (isAnonymous()) {
				return NO_NAME;
			}
			return new String(this.binding.sourceName());
	}
}