Java ITypeBinding.isTypeVariable方法代碼示例

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
public static boolean containsTypeVariables(ITypeBinding type) {
	if (type.isTypeVariable()) {
		return true;
	}
	if (type.isArray()) {
		return containsTypeVariables(type.getElementType());
	}
	if (type.isCapture()) {
		return containsTypeVariables(type.getWildcard());
	}
	if (type.isParameterizedType()) {
		return containsTypeVariables(type.getTypeArguments());
	}
	if (type.isWildcardType() && type.getBound() != null) {
		return containsTypeVariables(type.getBound());
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
@Override
public void endVisit(SimpleName node) {
	if (skipNode(node) || node.isDeclaration()) {
		return;
	}
	IBinding binding = node.resolveBinding();
	if (binding instanceof IVariableBinding) {
		IVariableBinding variable = (IVariableBinding) binding;
		if (!variable.isField()) {
			setFlowInfo(node, new LocalFlowInfo(variable, FlowInfo.READ, fFlowContext));
		}
	} else if (binding instanceof ITypeBinding) {
		ITypeBinding type = (ITypeBinding) binding;
		if (type.isTypeVariable()) {
			setFlowInfo(node, new TypeVariableFlowInfo(type, fFlowContext));
		}
	}
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
public IAnnotationBinding[] removeUnwantedTypeAnnotations(IAnnotationBinding[] annotations, TypeLocation location, ITypeBinding type) {
	if (location == TypeLocation.OTHER) {
		return NO_ANNOTATIONS;
	}
	if(type.isTypeVariable() || type.isWildcardType()) {
		return annotations;
	}
	boolean excludeAllNullAnnotations = NEVER_NULLNESS_LOCATIONS.contains(location);
	if (excludeAllNullAnnotations || fNonNullByDefaultLocations.contains(location)) {
		ArrayList<IAnnotationBinding> list= new ArrayList<>(annotations.length);
		for (IAnnotationBinding annotation : annotations) {
			ITypeBinding annotationType= annotation.getAnnotationType();
			if (annotationType != null) {
				if (annotationType.getQualifiedName().equals(fNonNullAnnotationName)) {
					// ignore @NonNull
				} else if (excludeAllNullAnnotations && annotationType.getQualifiedName().equals(fNullableAnnotationName)) {
					// also ignore @Nullable
				} else {
					list.add(annotation);
				}
			} else {
				list.add(annotation);
			}
		}
		return list.size() == annotations.length ? annotations : list.toArray(new IAnnotationBinding[list.size()]);
	} else {
		return annotations;
	}
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
private static boolean sameParameter(ITypeBinding type, String candidate, IType scope) throws JavaModelException {
	if (type.getDimensions() != Signature.getArrayCount(candidate)) {
		return false;
	}

	// Normalizes types
	if (type.isArray()) {
		type= type.getElementType();
	}
	candidate= Signature.getElementType(candidate);

	if ((Signature.getTypeSignatureKind(candidate) == Signature.BASE_TYPE_SIGNATURE) != type.isPrimitive()) {
		return false;
	}

	if (type.isPrimitive() || type.isTypeVariable()) {
		return type.getName().equals(Signature.toString(candidate));
	} else {
		// normalize (quick hack until binding.getJavaElement works)
		candidate= Signature.getTypeErasure(candidate);
		type= type.getErasure();

		if (candidate.charAt(Signature.getArrayCount(candidate)) == Signature.C_RESOLVED) {
			return Signature.toString(candidate).equals(Bindings.getFullyQualifiedName(type));
		} else {
			String[][] qualifiedCandidates= scope.resolveType(Signature.toString(candidate));
			if (qualifiedCandidates == null || qualifiedCandidates.length == 0) {
				return false;
			}
			String packageName= type.getPackage().isUnnamed() ? "" : type.getPackage().getName(); //$NON-NLS-1$
			String typeName= getTypeQualifiedName(type);
			for (int i= 0; i < qualifiedCandidates.length; i++) {
				String[] qualifiedCandidate= qualifiedCandidates[i];
				if (	qualifiedCandidate[0].equals(packageName) &&
						qualifiedCandidate[1].equals(typeName)) {
					return true;
				}
			}
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * Translate a typeBinding with a formal type parameter into one with fully substituted type
 * based on the enclosing type
 * @param typeBinding: e.g., virtual field of type <E extends java.lang.Object>
 * @param actualBinding: the enclosing type, e.g., class ArrayList<courses.Course> 
 * 						where the generic type declaration is class ArrayList<E> {...}
 * @return typeBinding with the type substitution performed, e.g., courses.Course
 */
public static ITypeBinding translateFtoA(ITypeBinding typeBinding, ITypeBinding actualBinding) {
	ITypeBinding toTypeBindingActual = typeBinding;

	// HACK: Introduced bugs!		
	// Check that it is a generic type, to avoid generating a type that does not exist!
	// if(!typeBinding.isGenericType()) {
	// 	return typeBinding;
	// }
	
	// HACK: Introduced bugs!
	 if (typeBinding.isEqualTo(actualBinding)) {
		return typeBinding;
	 }
	
	// Instantiate generic types...
	if (actualBinding.isParameterizedType()) {
		ITypeBinding[] typeParameters = actualBinding.getErasure().getTypeParameters();
		int pIndex = -1;
		int index = 0;
		for(ITypeBinding typeParameter : typeParameters ) {
			if ( typeParameter.isEqualTo(typeBinding) ) {
				pIndex = index;
				break;
			}
			index++;
		}
		ITypeBinding[] typeArguments = actualBinding.getTypeArguments();
		if ( typeBinding.isTypeVariable() && typeArguments != null && pIndex != -1  && pIndex < typeArguments.length) {
			toTypeBindingActual = typeArguments[pIndex];
		}
		else {
			String[] typeArgumentString = getParameters(typeArguments);
			String bindingKey = BindingKey.createParameterizedTypeBindingKey(typeBinding.getKey(), typeArgumentString);
			toTypeBindingActual = GenHelper.mapBindingKeyToTypeBinding(bindingKey);
		}
	}
	


	return toTypeBindingActual;
}