/** * This is a hook for the {@link TypeConformanceComputer} to implement the type argument check. */ protected int doIsConformantTypeArguments(LightweightTypeReference left, LightweightTypeReference right, int flags) { if (left.isRawType() != right.isRawType()) { return flags | SUCCESS | RAW_TYPE_CONVERSION; } return flags | SUCCESS; }
@Override public boolean isRawType() { return component.isRawType(); }
@Override public boolean isRawType() { for(LightweightTypeReference component: expose(components)) { if (component.isRawType()) return true; } return false; }
@Override public boolean isRawType() { if (internalGetResolvedTo() != null) return resolvedTo.isRawType(); return false; }
@Override protected boolean isRawTypeContext() { LightweightTypeReference receiverType = getReceiverType(); if(receiverType != null && receiverType.isRawType()) { return true; } return false; }
private boolean isAllRawType() { for(LightweightTypeReference component: expose(components)) { if (!component.isRawType()) return false; } return true; }
@Override public boolean isRawType() { return super.isRawType() || outer.isRawType(); }
@Override public boolean isRawType() { return super.isRawType() || outer.isRawType(); }
@Override protected boolean isRawTypeContext() { if (isThisOrSuper()) return false; LightweightTypeReference receiverType = getReceiverType(); if(receiverType != null && receiverType.isRawType()) { return true; } return false; }
@Override public int isConformant(LightweightTypeReference left, LightweightTypeReference right, int flags) { if (left == right && left != null) return flags | SUCCESS; if ((flags & RAW_TYPE) != 0 || ((left.isRawType() || right.isRawType()) && (flags & ALLOW_RAW_TYPE_CONVERSION) != 0)) { int result = rawTypeConformanceComputer.isConformant(left, right, flags); if ((result & SUCCESS) != 0) { if (left.isRawType() != right.isRawType() && left.hasTypeArguments() != right.hasTypeArguments()) { result |= RAW_TYPE_CONVERSION; } } else { return isSynonymConformant(result, left, right, flags); } return result; } int result = doIsConformant(left, right, flags); result = isSynonymConformant(result, left, right, flags); if ((result & SUCCESS) == 0) result |= INCOMPATIBLE; return result; }
protected void propageResolvedTypeToConstraints(List<LightweightBoundTypeArgument> hints) { if (!resolvedTo.isRawType()) { for(LightweightBoundTypeArgument hint: hints) { LightweightTypeReference hintReference = hint.getTypeReference(); if (hintReference != null && !hintReference.isRawType() && hint.getSource() == BoundTypeArgumentSource.CONSTRAINT) { DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(getOwner()) { @Override protected BoundTypeArgumentSource getTypeArgumentSource() { return BoundTypeArgumentSource.INFERRED_CONSTRAINT; } @Override protected void addHint(UnboundTypeReference typeParameter, LightweightTypeReference reference) { if (typeParameter.getHandle() != getHandle()) super.addHint(typeParameter, reference); } }; collector.processPairedReferences(hintReference, resolvedTo); } } } }
private ArrayTypeReference doTryConvertToArray(ParameterizedTypeReference typeReference) { LightweightTypeReference parameterizedIterable = typeReference.getSuperType(Iterable.class); if (parameterizedIterable != null) { ITypeReferenceOwner owner = typeReference.getOwner(); if (parameterizedIterable.isRawType()) { // return Object[] List<LightweightTypeReference> superTypes = parameterizedIterable.getSuperTypes(); if (superTypes.isEmpty()) { return null; } LightweightTypeReference objectType = superTypes.get(0); ArrayTypeReference array = owner.newArrayTypeReference(objectType); return array; } else { LightweightTypeReference componentType = parameterizedIterable.getTypeArguments().get(0).getUpperBoundSubstitute(); ArrayTypeReference array = owner.newArrayTypeReference(componentType); return array; } } return null; }
protected boolean isRawTypeInheritance() { List<LightweightTypeReference> superTypes = getContextType().getAllSuperTypes(); JvmDeclaredType declaringType = getDeclaration().getDeclaringType(); for(LightweightTypeReference superType: superTypes) { if (superType.getType() == declaringType && superType.isRawType()) { return true; } } return false; } }
@Override protected LightweightTypeReference deferredBindTypeArgument(ITypeExpectation expectation, LightweightTypeReference type) { LightweightTypeReference result = super.deferredBindTypeArgument(expectation, type); LightweightTypeReference expectedType = expectation.getExpectedType(); if (expectedType != null && getConstructorCall().getTypeArguments().isEmpty() && !result.isRawType() && !getDeclaredTypeParameters().isEmpty()) { if (!expectedType.isAssignableFrom(result, TypeConformanceComputationArgument.DEFAULT)) { LightweightTypeReference rawFeatureType = result.getRawTypeReference(); if (expectedType.isAssignableFrom(rawFeatureType)) { result = rawFeatureType; getTypeParameterMapping().clear(); } } } return result; }
public static void resolveAgainstActualType(final LightweightTypeReference declaredType, LightweightTypeReference actualType, Collection<JvmTypeParameter> typeParameters, Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> typeParameterMapping, BoundTypeArgumentSource source, ITypeReferenceOwner owner) { if (declaredType.isRawType() || actualType.isRawType()) return; TypeArgumentFromComputedTypeCollector implementation = new TypeArgumentFromComputedTypeCollector(typeParameters, source, owner); implementation.populateTypeParameterMapping(declaredType, actualType); Map<JvmTypeParameter, List<LightweightBoundTypeArgument>> parameterMapping = implementation.rawGetTypeParameterMapping(); for(Map.Entry<JvmTypeParameter, List<LightweightBoundTypeArgument>> entry: parameterMapping.entrySet()) { LightweightMergedBoundTypeArgument boundTypeArgument = typeParameterMapping.get(entry.getKey()); if (boundTypeArgument != null ) { List<LightweightBoundTypeArgument> computedBoundTypeArguments = entry.getValue(); for(LightweightBoundTypeArgument computedBoundTypeArgument: computedBoundTypeArguments) { if (computedBoundTypeArgument.getSource() == BoundTypeArgumentSource.RESOLVED) { VarianceInfo varianceInfo = computedBoundTypeArgument.getDeclaredVariance().mergeDeclaredWithActual(computedBoundTypeArgument.getActualVariance()); typeParameterMapping.put(entry.getKey(), new LightweightMergedBoundTypeArgument(computedBoundTypeArgument.getTypeReference(), varianceInfo)); } else if (boundTypeArgument.getTypeReference() instanceof UnboundTypeReference) { UnboundTypeReference typeReference = (UnboundTypeReference) boundTypeArgument.getTypeReference(); if (!typeReference.internalIsResolved()) { if (!(computedBoundTypeArgument.getTypeReference() instanceof UnboundTypeReference) || ((UnboundTypeReference) computedBoundTypeArgument.getTypeReference()).getHandle() != typeReference.getHandle()) typeReference.acceptHint(computedBoundTypeArgument); } } } } } }