private boolean canAssignToArrayType(ArrayType lhs) { if (fDimensions == lhs.fDimensions) { // primitive type don't have any conversion for arrays. if (fElementType.getKind() == PRIMITIVE_TYPE || lhs.fElementType.getKind() == PRIMITIVE_TYPE) return fElementType.isTypeEquivalentTo(lhs.fElementType); return fElementType.canAssignTo(lhs.fElementType); } if (fDimensions < lhs.fDimensions) return false; return isArrayLhsCompatible(lhs.fElementType); }
@Override public boolean equals(Object o) { if (!(o instanceof SuperTypesOfSingleton)) return false; SuperTypesOfSingleton other= (SuperTypesOfSingleton) o; return other.fLowerBound.equals(fLowerBound); }
private ConstraintVariable2 getElementTypeCv(TType elementType, ConstraintVariable2 expressionCv, Map<String, IndependentTypeVariable2> methodTypeVariables) { if (elementType.isTypeVariable()) { ConstraintVariable2 elementTypeCv= methodTypeVariables.get(elementType.getBindingKey()); if (elementTypeCv != null) return elementTypeCv; if (expressionCv != null) return getElementVariable(expressionCv, (TypeVariable) elementType); } return null; }
private boolean canAssignFirstBoundTo(TType lhs) { if (fBounds.length > 0 && fBounds[0].isArrayType()) { // capture of ? extends X[] return fBounds[0].canAssignTo(lhs); } return false; }
protected final boolean canAssignOneBoundTo(TType lhs) { if (fBounds.length == 0) return lhs.isJavaLangObject(); for (int i= 0; i < fBounds.length; i++) { if (fBounds[i].canAssignTo(lhs)) return true; } return false; }
private boolean isParametricType(TType type) { return type.isParameterizedType() || type.isGenericType() || (type.isRawType() && type.getTypeDeclaration().isGenericType()) ; }
protected void initialize(TType elementType, int dimensions) { fElementType= elementType; fDimensions= dimensions; if (fElementType.isStandardType() || fElementType.isGenericType() || fElementType.isPrimitiveType()) { fErasure= this; } else { fErasure= getEnvironment().createArrayType(elementType.getErasure(), dimensions); } }
protected final ITypeSet computeTypeEstimate(final ConstraintVariable2 variable) { final TType type= variable.getType(); if (variable instanceof ImmutableTypeVariable2 || !type.getErasure().equals(fModel.getSubType().getErasure())) return SuperTypeSet.createTypeSet(type); final TType[] types= type.getInterfaces(); for (int index= 0; index < types.length; index++) { if (types[index].getName().startsWith(fName) && types[index].getErasure().equals(fModel.getSuperType().getErasure())) return SuperTypeSet.createTypeSet(type, types[index]); } return SuperTypeSet.createTypeSet(type); } }
public ArrayType createArrayType(TType elementType, int dimensions) { Assert.isTrue(! elementType.isArrayType()); Assert.isTrue(! elementType.isAnonymous()); Assert.isTrue(dimensions > 0); int index= dimensions - 1; Map<TType, ArrayType> arrayTypes= getArrayTypesMap(index); ArrayType result= arrayTypes.get(elementType); if (result != null) return result; result= new ArrayType(this, BindingKey.createArrayTypeBindingKey(elementType.getBindingKey(), dimensions)); arrayTypes.put(elementType, result); result.initialize(elementType, dimensions); return result; }
protected void initialize(ITypeBinding binding, TType elementType) { Assert.isTrue(binding.isArray()); super.initialize(binding); fElementType= elementType; fDimensions= binding.getDimensions(); if (fElementType.isStandardType() || fElementType.isGenericType() || fElementType.isPrimitiveType()) { fErasure= this; } else { fErasure= getEnvironment().create(binding.getErasure()); } }
@Override protected boolean isTypeEquivalentTo(TType other) { int otherElementType= other.getKind(); if (otherElementType == RAW_TYPE || otherElementType == PARAMETERIZED_TYPE) return getErasure().isTypeEquivalentTo(other.getErasure()); return super.isTypeEquivalentTo(other); }
@Override public String toString() { return "<" + fID + ": subTypes(" + fUpperBound.getPrettySignature() + ")>"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } }
public String getName() { StringBuffer result= new StringBuffer(fElementType.getName()); for (int i= 0; i < fDimensions; i++) { result.append("[]"); //$NON-NLS-1$ } return result.toString(); }
public Object next() { TType result= (TType) fWorklist.pop(); TType[] subTypes= result.getSubTypes(); for (int i= 0; i < subTypes.length; i++) fWorklist.push(subTypes[i].getTypeDeclaration()); return result; }
/** * Computes the initial type estimate for the specified constraint variable. * * @param variable the constraint variable * @return the initial type estimate */ protected ITypeSet computeTypeEstimate(final ConstraintVariable2 variable) { final TType type= variable.getType(); if (variable instanceof ImmutableTypeVariable2 || !type.getErasure().equals(fModel.getSubType().getErasure())) return SuperTypeSet.createTypeSet(type); return SuperTypeSet.createTypeSet(type, fModel.getSuperType()); }
@Override public boolean isSingleton() { return getElementTypeOf(fUpperBound).getSubTypes().length == 0; }
/* package */ final boolean isUnbounded() { if (fBounds.length == 0) return true; return fBounds[0].isJavaLangObject(); }
public static ITypeBinding[] createTypeBindings(TType[] types, IJavaProject project) { final Map<String, Object> mapping= new HashMap<>(); List<String> keys= new ArrayList<>(); for (int i= 0; i < types.length; i++) { TType type= types[i]; String bindingKey= type.getBindingKey(); mapping.put(bindingKey, type); keys.add(bindingKey); } ASTParser parser= ASTParser.newParser(IASTSharedValues.SHARED_AST_LEVEL); parser.setProject(project); parser.setResolveBindings(true); parser.createASTs(new ICompilationUnit[0], keys.toArray(new String[keys.size()]), new ASTRequestor() { @Override public void acceptBinding(String bindingKey, IBinding binding) { mapping.put(bindingKey, binding); } }, null); ITypeBinding[] result= new ITypeBinding[types.length]; for (int i= 0; i < types.length; i++) { TType type= types[i]; String bindingKey= type.getBindingKey(); Object value= mapping.get(bindingKey); if (value instanceof ITypeBinding) { result[i]= (ITypeBinding)value; } } return result; }
protected final boolean checkAssignmentBound(TType rhs) { if (fBounds.length == 0) return true; for (int i= 0; i < fBounds.length; i++) { if (rhs.canAssignTo(fBounds[i])) return true; } return false; }
public TypeSet upperBound() { if (fMembers.size() == 1) return new SingletonTypeSet((TType) fMembers.iterator().next(), getTypeSetEnvironment()); if (fMembers.contains(getJavaLangObject())) return new SingletonTypeSet(getJavaLangObject(), getTypeSetEnvironment()); EnumeratedTypeSet result= new EnumeratedTypeSet(getTypeSetEnvironment()); // Add to result each element of fMembers that has no proper supertype in fMembers result.fMembers.addAll(fMembers); for(Iterator iter= fMembers.iterator(); iter.hasNext(); ) { TType t= (TType) iter.next(); if (t.isArrayType()) { ArrayType at= (ArrayType) t; int numDims= at.getDimensions(); for(Iterator subIter=TTypes.getAllSubTypesIterator(at.getElementType()); subIter.hasNext(); ) { result.fMembers.remove(TTypes.createArrayType(((TType) subIter.next()), numDims)); } } else { for (Iterator iterator= TTypes.getAllSubTypesIterator(t); iterator.hasNext();) { result.fMembers.remove(iterator.next()); } } } result.initComplete(); return result; }