@Override protected InnerFunctionTypeReference doCopyInto(ITypeReferenceOwner owner) { LightweightTypeReference copiedOuter = outer.copyInto(owner); InnerFunctionTypeReference result = new InnerFunctionTypeReference(owner, copiedOuter, getType()); copyTypeArguments(result, owner); return result; }
@Override protected LightweightTypeReference doVisitInnerFunctionTypeReference(InnerFunctionTypeReference reference, Visiting visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; LightweightTypeReference outer = reference.getOuter().accept(this, visiting); InnerFunctionTypeReference result = getOwner().newFunctionTypeReference(outer, reference.getType()); enhanceFunctionType(reference, result, visiting); return result; }
@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 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 void doVisitInnerFunctionTypeReference(final InnerFunctionTypeReference reference) { boolean _isJava = this.appender.isJava(); if (_isJava) { 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(">"); } } else { this.appender.append("("); this.appendCommaSeparated(reference.getParameterTypes()); this.appender.append(")=>"); LightweightTypeReference _returnType = reference.getReturnType(); boolean _tripleEquals = (_returnType == null); if (_tripleEquals) { this.appender.append("void"); } else { reference.getReturnType().accept(this); } } }
@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 public JvmTypeReference getEquivalentTypeReference() { JvmInnerTypeReference result = getTypesFactory().createJvmInnerTypeReference(); result.setType(getType()); result.setOuter((JvmParameterizedTypeReference) outer.toTypeReference()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.getArguments().add(typeArgument.toTypeReference()); } return result; }
@Override protected SubstitutionResult doVisitInnerFunctionTypeReference(InnerFunctionTypeReference reference, VarianceInfo varianceInfo) { SubstitutionResult visitedOuter = reference.getOuter().accept(this, varianceInfo); InnerFunctionTypeReference result = owner.newFunctionTypeReference(visitedOuter.typeReference, reference.getType()); return doSubstituteFunctionType(reference, result, visitedOuter.didSubstitute); }
@Override protected void doVisitInnerFunctionTypeReference(InnerFunctionTypeReference reference, ParameterizedTypeReference declaration) { super.doVisitInnerFunctionTypeReference(reference, declaration); outerVisit(declaration, reference.getOuter()); }
@Override public InnerFunctionTypeReference newFunctionTypeReference(LightweightTypeReference outer, JvmType type) { if (!factory.isInner(type)) { throw new IllegalArgumentException(String.valueOf(type)); } return new InnerFunctionTypeReference(this, outer, type); }
@Override protected String getAsStringNoFunctionType(String type, Function<LightweightTypeReference, String> format) { type = format.apply(outer) + "$" + getType().getSimpleName(); return super.getAsStringNoFunctionType(type, format); }
@Override protected Boolean doVisitInnerFunctionTypeReference(InnerFunctionTypeReference reference, LightweightTraversalData data) { if (!reference.getOuter().accept(this, data)) { return super.doVisitInnerFunctionTypeReference(reference, data); } return Boolean.TRUE; }
@Override public FunctionTypeReference newFunctionTypeReference(JvmType type) { FunctionTypeReference result; if (factory.isInner(type)) { ParameterizedTypeReference outer = newParameterizedTypeReference((JvmDeclaredType)type.eContainer()); result = new InnerFunctionTypeReference(this, outer, type); } else { result = new FunctionTypeReference(this, type); } return result; }
@Override protected Boolean doVisitInnerFunctionTypeReference(InnerFunctionTypeReference reference) { Boolean result = reference.getOuter().accept(this) && doVisitParameterizedTypeReference(reference); return result; }
@Override public LightweightTypeReference doVisitFunctionTypeReference(XFunctionTypeRef reference) { JvmTypeReference equivalent = reference.getEquivalent(); if (equivalent == null) { return super.doVisitFunctionTypeReference(reference); } FunctionTypeReference result; // constructors used below to avoid subsequent checks for isInner which was supposed to be done by // the computation of the equivalent if (equivalent.eClass() == TypesPackage.Literals.JVM_INNER_TYPE_REFERENCE) { JvmParameterizedTypeReference outer = ((JvmInnerTypeReference) equivalent).getOuter(); LightweightTypeReference outerEquivalent = outer.accept(this); result = new InnerFunctionTypeReference(owner, outerEquivalent, reference.getType()); } else { result = new FunctionTypeReference(owner, reference.getType()); } if (equivalent instanceof JvmParameterizedTypeReference) { for(JvmTypeReference argument: ((JvmParameterizedTypeReference)equivalent).getArguments()) { result.addTypeArgument(visit(argument)); } } for(JvmTypeReference parameter: reference.getParamTypes()) { result.addParameterType(visit(parameter)); } if (reference.getReturnType() != null) { result.setReturnType(visit(reference.getReturnType())); } return result; }