@Override public LightweightTypeReference substitute(LightweightTypeReference original) { return original.getRawTypeReference(); }
public ExtensionScopeHelper(LightweightTypeReference argumentType) { this.argumentType = argumentType; this.rawArgumentType = argumentType.getRawTypeReference(); }
public ContextualVisibilityHelper(IVisibilityHelper parent, LightweightTypeReference contextType, String packageName) { this.parent = parent; this.rawContextType = contextType.getRawTypeReference().getType(); this.packageName = packageName; }
protected boolean isSameErasure(AbstractResolvedOperation overriding, AbstractResolvedOperation overridden) { List<LightweightTypeReference> overridingParameterTypes = overriding.getResolvedParameterTypes(); List<LightweightTypeReference> overriddenParameterTypes = overridden.getResolvedParameterTypes(); if (overridingParameterTypes.size() != overriddenParameterTypes.size()) { return false; } for(int i = 0; i < overridingParameterTypes.size(); i++) { LightweightTypeReference overridingParameterType = overridingParameterTypes.get(i); LightweightTypeReference overriddenParameterType = overriddenParameterTypes.get(i); String erasedOverridingParameterTypeIdentifier = overridingParameterType.getRawTypeReference().getJavaIdentifier(); String erasedOverriddenParameterTypeIdentifier = overriddenParameterType.getRawTypeReference().getJavaIdentifier(); if (!erasedOverridingParameterTypeIdentifier.equals(erasedOverriddenParameterTypeIdentifier)) { return false; } } return true; }
public ContextualVisibilityHelper(IVisibilityHelper parent, LightweightTypeReference contextType) { this.parent = parent; this.rawContextType = contextType.getRawTypeReference().getType(); if (rawContextType instanceof JvmDeclaredType) { this.packageName = ((JvmDeclaredType) rawContextType).getPackageName(); } }
@Override public String getResolvedErasureSignature() { JvmExecutable declaration = getDeclaration(); List<LightweightTypeReference> parameterTypes = getResolvedParameterTypes(); StringBuilder result = new StringBuilder(declaration.getSimpleName().length() + 2 + 20 * parameterTypes.size()); result.append(declaration.getSimpleName()); result.append('('); for(int i = 0; i < parameterTypes.size(); i++) { if (i != 0) { result.append(','); } result.append(parameterTypes.get(i).getRawTypeReference().getJavaIdentifier()); } result.append(')'); return result.toString(); }
@Override public LightweightTypeReference getRawTypeReference() { LightweightTypeReference rawComponent = component.getRawTypeReference(); if (rawComponent == component) { return this; } return getOwner().newArrayTypeReference(rawComponent); }
protected void accept(JvmExecutable executable) { // TODO handle generic exceptions for(JvmTypeReference exception: executable.getExceptions()) { accept(delegate.toLightweightReference(exception).getRawTypeReference()); } }
protected LightweightTypeReference getParameterType(JvmFormalParameter p) { JvmTypeReference parameterType = p.getParameterType(); JvmType type = parameterType.getType(); if (type == null) return null; return owner.toPlainTypeReference(type).getRawTypeReference(); }
@Override public LightweightTypeReference getRawTypeReference() { if (typeArguments == null && type.eClass() != TypesPackage.Literals.JVM_TYPE_PARAMETER) { return this; } if (type.eClass() != TypesPackage.Literals.JVM_TYPE_PARAMETER) { return getOwner().newParameterizedTypeReference(type); } // TODO optimize return super.getRawTypeReference(); }
protected void populateLists(List<QualifiedName> localNames, List<String> localTypes) { Collection<IEObjectDescription> elements = session.getLocalElements(); for(IEObjectDescription desc: elements) { if (TypesPackage.Literals.JVM_IDENTIFIABLE_ELEMENT.isSuperTypeOf(desc.getEClass())) { localNames.add(desc.getName()); JvmIdentifiableElement identifiable = (JvmIdentifiableElement) desc.getEObjectOrProxy(); LightweightTypeReference type = types.getActualType(identifiable); if (type != null) { localTypes.add(type.getRawTypeReference().getIdentifier()); } else { localTypes.add(null); } } } } }
@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; }
@Override public LightweightTypeReference getRawTypeReference() { if (isAllRawType()) { return this; } CompoundTypeReference result = getOwner().newCompoundTypeReference(isSynonym()); for(LightweightTypeReference component: expose(components)) { result.addComponent(component.getRawTypeReference()); } return result; }
@Override protected void addHint(UnboundTypeReference typeParameter, LightweightTypeReference reference) { LightweightTypeReference wrapped = reference.getWrapperTypeIfPrimitive(); typeParameter.acceptHint(wrapped, BoundTypeArgumentSource.RESOLVED, getOrigin(), getExpectedVariance(), getActualVariance()); LightweightTypeReference typeParameterReference = reference.getOwner().newParameterizedTypeReference(typeParameter.getTypeParameter()); if (validParameterTypes && !typeParameterReference.getRawTypeReference().isAssignableFrom(reference)) { validParameterTypes = false; } } }.processPairedReferences(operationParameterType, closureParameterType);
@Override public LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { DeclaratorTypeArgumentCollector typeArgumentCollector = new ConstraintAwareTypeArgumentCollector(owner); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> typeParameterMapping = typeArgumentCollector.getTypeParameterMapping(reference); TypeParameterSubstitutor<?> substitutor = new UnboundTypeParameterPreservingSubstitutor(typeParameterMapping, owner); JvmGenericType iterable = (JvmGenericType) owner.getServices().getTypeReferences().findDeclaredType(Iterable.class, owner.getContextResourceSet()); if (iterable == null) { return owner.newReferenceToObject(); } LightweightTypeReference substituteMe = owner.newParameterizedTypeReference(iterable.getTypeParameters().get(0)); LightweightTypeReference substitutedArgument = substitutor.substitute(substituteMe).getUpperBoundSubstitute(); if (substitutedArgument.getType() instanceof JvmTypeParameter && !(owner.getDeclaredTypeParameters().contains(substitutedArgument.getType()))) { return substitutedArgument.getRawTypeReference(); } return substitutedArgument; }
@Override public LightweightTypeReference getRawTypeReference() { if (isRawType()) { return this; } LightweightTypeReference rawOuter = outer.getRawTypeReference(); JvmType type = getType(); if (type.eClass() != TypesPackage.Literals.JVM_TYPE_PARAMETER) { return getOwner().newParameterizedTypeReference(rawOuter, type); } return getServices().getRawTypeHelper().getRawTypeReference(this, getOwner().getContextResourceSet()); }
@Override public LightweightTypeReference getRawTypeReference() { if (isRawType()) { return this; } LightweightTypeReference rawOuter = outer.getRawTypeReference(); JvmType type = getType(); if (type.eClass() != TypesPackage.Literals.JVM_TYPE_PARAMETER) { return getOwner().newParameterizedTypeReference(rawOuter, type); } return getServices().getRawTypeHelper().getRawTypeReference(this, getOwner().getContextResourceSet()); }
private void convertListToArray( final LightweightTypeReference arrayTypeReference, final ITreeAppendable appendable, final Later expression) { appendable.append("(("); appendable.append(arrayTypeReference); appendable.append(")"); appendable.append(Conversions.class); appendable.append(".unwrapArray("); expression.exec(appendable); LightweightTypeReference rawTypeArrayReference = arrayTypeReference.getRawTypeReference(); appendable.append(", "); appendable.append(rawTypeArrayReference.getComponentType()); appendable.append(".class))"); }
/** * Same as {@link LightweightTypeReference#isSubtypeOf(Class)} but does not accept synonym types as subtypes. */ protected boolean isSubtypeButNotSynonym(LightweightTypeReference expectation, Class<?> clazz) { if (expectation.isType(clazz)) { return true; } ITypeReferenceOwner owner = expectation.getOwner(); JvmType declaredType = owner.getServices().getTypeReferences().findDeclaredType(clazz, owner.getContextResourceSet()); if (declaredType == null) { return false; } LightweightTypeReference superType = owner.newParameterizedTypeReference(declaredType); // don't allow synonyms, e.g. Iterable is not considered to be a supertype of Functions.Function0 boolean result = superType.isAssignableFrom(expectation.getRawTypeReference(), new TypeConformanceComputationArgument(false, false, true, true, false, false)); return result; }
protected void _computeTypes(XInstanceOfExpression object, ITypeComputationState state) { ITypeComputationState expressionState = state.withExpectation(state.getReferenceOwner().newReferenceToObject()); expressionState.computeTypes(object.getExpression()); JvmTypeReference type = object.getType(); if (type != null && type.getType() instanceof JvmTypeParameter) { LightweightTypeReference lightweightReference = state.getReferenceOwner().toLightweightTypeReference(type); LightweightTypeReference rawTypeRef = lightweightReference.getRawTypeReference(); state.addDiagnostic(new EObjectDiagnosticImpl( Severity.ERROR, IssueCodes.INVALID_USE_OF_TYPE_PARAMETER, "Cannot perform instanceof check against type parameter "+lightweightReference.getHumanReadableName()+". Use its erasure "+rawTypeRef.getHumanReadableName()+" instead since further generic type information will be erased at runtime.", object.getType(), null, -1, new String[] { })); } LightweightTypeReference bool = getRawTypeForName(Boolean.TYPE, state); state.acceptActualType(bool); }