@Override protected ParameterizedTypeReference doCopyInto(ITypeReferenceOwner owner) { LightweightTypeReference copiedOuter = outer.copyInto(owner); InnerTypeReference result = new InnerTypeReference(owner, copiedOuter, getType()); copyTypeArguments(result, owner); return result; }
@Override public ParameterizedTypeReference toInstanceTypeReference() { ParameterizedTypeReference outerInstanceTypeReference = ((ParameterizedTypeReference) outer).toInstanceTypeReference(); InnerTypeReference result = getOwner().newParameterizedTypeReference(outerInstanceTypeReference, getType()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.addTypeArgument(typeArgument.getInvariantBoundSubstitute()); } return result; } }
@Override protected LightweightTypeReference doVisitInnerTypeReference(InnerTypeReference reference, Visiting visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; LightweightTypeReference outer = reference.getOuter().accept(this, visiting); ParameterizedTypeReference result = getOwner().newParameterizedTypeReference(outer, reference.getType()); for(LightweightTypeReference argument: reference.getTypeArguments()) { result.addTypeArgument(visitTypeArgument(argument, visiting)); } return result; }
@Override public JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper) { if (isTypeVisible(visibilityHelper)) { JvmInnerTypeReference result = getTypesFactory().createJvmInnerTypeReference(); result.setType(getType()); result.setOuter((JvmParameterizedTypeReference) outer.toJavaCompliantTypeReference()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.getArguments().add(typeArgument.toJavaCompliantTypeReference()); } return result; } else { return toJavaCompliantTypeReference(getSuperTypes(), visibilityHelper); } }
@Override protected SubstitutionResult doVisitInnerTypeReference(InnerTypeReference reference, VarianceInfo varianceInfo) { JvmType type = reference.getType(); if (!(type instanceof JvmTypeParameter) && EcoreUtil.isAncestor(boundary, type)) { SubstitutionResult visited = reference.getSuperTypes().get(0).accept(this, varianceInfo); switch(varianceInfo) { case IN: SubstitutionResult visitedOuter = reference.getOuter().accept(this, varianceInfo); InnerTypeReference result = owner.newParameterizedTypeReference(visitedOuter.typeReference, reference.getType()); boolean didSubstitute = visitedOuter.didSubstitute; for(LightweightTypeReference argument: reference.getTypeArguments()) { SubstitutionResult visited = visitTypeArgument(argument, VarianceInfo.INVARIANT); result.addTypeArgument(visited.typeReference); didSubstitute = didSubstitute || visited.didSubstitute;
@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 protected void doVisitInnerTypeReference(final InnerTypeReference reference) { reference.getOuter().accept(this); this.appender.append("."); this.appender.append(reference.getType().getSimpleName()); boolean _isEmpty = reference.getTypeArguments().isEmpty(); boolean _not = (!_isEmpty); if (_not) { this.appender.append("<"); this.appendCommaSeparated(reference.getTypeArguments()); this.appender.append(">"); } }
@Override public JvmTypeReference toTypeReference() { JvmInnerTypeReference result = getTypesFactory().createJvmInnerTypeReference(); result.setType(getType()); result.setOuter((JvmParameterizedTypeReference) outer.toTypeReference()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.getArguments().add(typeArgument.toTypeReference()); } return result; }
@Override public ParameterizedTypeReference toInstanceTypeReference() { LightweightTypeReference outerInstanceTypeReference = ((ParameterizedTypeReference) outer).toInstanceTypeReference(); InnerTypeReference result = new InnerTypeReference(getOwner(), outerInstanceTypeReference, getType()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.addTypeArgument(typeArgument.getInvariantBoundSubstitute()); } return result; } }
@Override protected void doVisitInnerTypeReference(InnerTypeReference reference, StringBuilder param) { reference.getOuter().accept(this, param); param.append("."); doVisitParameterizedTypeReference(reference, param); }
@Override public InnerTypeReference newParameterizedTypeReference(LightweightTypeReference outer, JvmType type) { if (!factory.isInner(type)) { throw new IllegalArgumentException(String.valueOf(type)); } return new InnerTypeReference(this, outer, type); }
@Override protected String getAsString(String type, Function<LightweightTypeReference, String> format) { type = format.apply(outer) + "$" + getType().getSimpleName(); return super.getAsString(type, format); }
@Override public LightweightTypeReference doVisitInnerTypeReference(JvmInnerTypeReference reference) { JvmType type = getType(reference); if (type == null || type.eIsProxy()) { return createUnknownTypeReference(reference); } if (!isInner(type)) { return doVisitParameterizedTypeReference(reference); } JvmParameterizedTypeReference outer = reference.getOuter(); if (outer == null) return doVisitParameterizedTypeReference(reference); ParameterizedTypeReference lightweightOuter = (ParameterizedTypeReference) outer.accept(this); // constructor call instead of owner.newParameterized to avoid second check for isInner(..) InnerTypeReference result = new InnerTypeReference(owner, lightweightOuter, type); for(JvmTypeReference argument: reference.getArguments()) { result.addTypeArgument(visit(argument).getWrapperTypeIfPrimitive()); } return result; }
@Override protected Boolean doVisitInnerTypeReference(InnerTypeReference reference, LightweightTraversalData data) { if (!reference.getOuter().accept(this, data)) { return super.doVisitInnerTypeReference(reference, data); } return Boolean.TRUE; }
@Override public ParameterizedTypeReference newParameterizedTypeReference(JvmType type) { ParameterizedTypeReference result; if (factory.isInner(type)) { ParameterizedTypeReference outer = newParameterizedTypeReference((JvmDeclaredType)type.eContainer()); result = new InnerTypeReference(this, outer, type); } else { result = new ParameterizedTypeReference(this, type); } return result; }
@Override protected void doVisitInnerTypeReference(InnerTypeReference reference) { reference.getOuter().accept(this); super.doVisitInnerTypeReference(reference); } @Override
@Override protected void doVisitInnerTypeReference(InnerTypeReference reference, ParameterizedTypeReference declaration) { super.doVisitInnerTypeReference(reference, declaration); outerVisit(declaration, reference.getOuter()); }
@Override protected Boolean doVisitInnerTypeReference(InnerTypeReference reference) { Boolean result = reference.getOuter().accept(this) && doVisitParameterizedTypeReference(reference); return result; }