private void serializeTypeArguments(JvmParameterizedTypeReference reference, EObject context, IAppendable tracedAppendable, boolean withoutConstraints, boolean paramsToWildcard, boolean paramsToObject) { if (!reference.getArguments().isEmpty()) { tracedAppendable.append("<"); for(int i = 0; i < reference.getArguments().size(); i++) { if (i != 0) { tracedAppendable.append(", "); } serialize(reference.getArguments().get(i), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, false); } tracedAppendable.append(">"); } }
@Check public void checkTypeArgumentsNotPrimitive(JvmParameterizedTypeReference typeRef) { EList<JvmTypeReference> arguments = typeRef.getArguments(); for (int i=0;i<arguments.size();i++) { JvmTypeReference jvmTypeReference = arguments.get(i); checkNotPrimitive(jvmTypeReference); } }
@Override public Boolean apply(final JvmOperation it) { return Boolean.valueOf((it.getSimpleName().startsWith("bind") && (IterableExtensions.<JvmTypeReference>head(((JvmParameterizedTypeReference) it.getReturnType()).getArguments()) != null))); } };
protected boolean isInvalidWildcard(JvmTypeReference typeRef) { if (typeRef instanceof JvmWildcardTypeReference) return true; else if (typeRef instanceof JvmParameterizedTypeReference) { for(JvmTypeReference typeArgument: ((JvmParameterizedTypeReference) typeRef).getArguments()) { if(typeArgument instanceof JvmWildcardTypeReference) return true; } } else if (typeRef instanceof JvmSpecializedTypeReference) { return isInvalidWildcard(((JvmSpecializedTypeReference) typeRef).getEquivalent()); } return false; }
@Override public Boolean doVisitParameterizedTypeReference(final JvmParameterizedTypeReference it) { return Boolean.valueOf(((this.doVisitTypeReference(it)).booleanValue() || IterableExtensions.<JvmTypeReference>exists(it.getArguments(), ((Function1<JvmTypeReference, Boolean>) (JvmTypeReference it_1) -> { return this.visit(it_1); })))); }
@Override public StringBuilder doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, StringBuilder param) { JvmType type = reference.getType(); if (type == null || type.eIsProxy()) { return null; } param.append(type.getSimpleName()); List<JvmTypeReference> typeArguments = reference.getArguments(); if (typeArguments.isEmpty()) return param; param.append("<"); for(int i = 0, size = typeArguments.size(); i < size; i++) { if (i != 0) { param.append(", "); } param = visit(typeArguments.get(i), param); if (param == null) { return null; } } param.append(">"); return param; }
private JvmTypeReference enhanceTypeReference(ParameterizedType parameterizedType, JvmParameterizedTypeReference result) { result.setType(createProxy(parameterizedType.getRawType())); Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); if (actualTypeArguments.length != 0) { InternalEList<JvmTypeReference> arguments = (InternalEList<JvmTypeReference>)result.getArguments(); for (Type actualTypeArgument : actualTypeArguments) { JvmTypeReference argument = createTypeArgument(actualTypeArgument); arguments.addUnique(argument); } } return result; }
public JvmTypeReference getArgument(JvmTypeReference left, int index) { if (left.getType() instanceof JvmGenericType) { List<JvmTypeParameter> typeParameters = ((JvmGenericType) left.getType()).getTypeParameters(); if (typeParameters.size() <= index) { throw new IllegalArgumentException("The type " + left.getType().getIdentifier() + " cannot be parameterized with more than " + typeParameters.size() + " type arguments."); } if (left instanceof JvmParameterizedTypeReference) { List<JvmTypeReference> arguments = ((JvmParameterizedTypeReference) left).getArguments(); if (arguments.size() == typeParameters.size()) { return arguments.get(index); } } final JvmTypeParameter jvmTypeParameter = typeParameters.get(index); return createTypeRef(jvmTypeParameter); } throw new IllegalArgumentException(left.getType().getIdentifier() + " is not generic."); }
protected JvmParameterizedTypeReference createSuperTypeReference(JvmType superType, XConstructorCall constructorCall) { JvmParameterizedTypeReference result = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference(); result.setType(superType); for(JvmTypeReference typeReference: constructorCall.getTypeArguments()) { result.getArguments().add(typesBuilder.cloneWithProxies(typeReference)); } return result; }
@Override public JvmTypeReference toTypeReference() { JvmParameterizedTypeReference result = getTypesFactory().createJvmParameterizedTypeReference(); result.setType(type); if (typeArguments != null) { for(LightweightTypeReference typeArgument: typeArguments) { result.getArguments().add(typeArgument.toTypeReference()); } } return result; }
public JvmTypeReference getArgument(JvmTypeReference left, int index) { if (left.getType() instanceof JvmGenericType) { List<JvmTypeParameter> typeParameters = ((JvmGenericType) left.getType()).getTypeParameters(); if (typeParameters.size() <= index) { throw new IllegalArgumentException("The type " + left.getType().getIdentifier() + " cannot be parameterized with more than " + typeParameters.size() + " type arguments."); } if (left instanceof JvmParameterizedTypeReference) { List<JvmTypeReference> arguments = ((JvmParameterizedTypeReference) left).getArguments(); if (arguments.size() == typeParameters.size()) { return arguments.get(index); } } final JvmTypeParameter jvmTypeParameter = typeParameters.get(index); return createTypeRef(jvmTypeParameter); } throw new IllegalArgumentException(left.getType().getIdentifier() + " is not generic."); }
static String computeFor(JvmParameterizedTypeReference typeReference, char innerClassDelimiter, NameType nameType) { if (typeReference.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE)) { StringBuilder mutableResult = new StringBuilder(64); JvmType type = typeReference.getType(); switch(nameType) { case ID: mutableResult.append(type.getIdentifier()); break; case QUALIFIED: mutableResult.append(type.getQualifiedName(innerClassDelimiter)); break; case SIMPLE: mutableResult.append(type.getSimpleName()); break; case TO_STRING: mutableResult.append(type.getIdentifier()); break; } if (typeReference.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__ARGUMENTS)) { mutableResult.append("<"); appendArguments(mutableResult, typeReference.getArguments(), innerClassDelimiter, nameType); mutableResult.append(">"); return mutableResult.toString(); } return mutableResult.toString(); } return null; }
@Check public void checkTypeReferenceIsNotVoid(XExpression expression) { for (EObject eObject : expression.eContents()) { if (eObject instanceof JvmTypeReference) { JvmTypeReference typeRef = (JvmTypeReference) eObject; if (isPrimitiveVoid(typeRef)) { if (typeRef.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) { if (!((JvmParameterizedTypeReference) typeRef).getArguments().isEmpty()) { continue; } } error("Primitive void cannot be used here.", typeRef, null, INVALID_USE_OF_TYPE); } } } }
JvmTypeReference eraseGenerics(final JvmTypeReference reference) { JvmTypeReference _xifexpression = null; if ((reference instanceof JvmParameterizedTypeReference)) { final Function1<JvmTypeReference, JvmTypeReference> _function = (JvmTypeReference it) -> { return BodyCodeGenerator.this.typeReferences.wildcard(); }; _xifexpression = BodyCodeGenerator.this.typeReferences.typeRef(((JvmParameterizedTypeReference)reference).getType(), ((JvmTypeReference[])Conversions.unwrapArray(ListExtensions.<JvmTypeReference, JvmTypeReference>map(((JvmParameterizedTypeReference)reference).getArguments(), _function), JvmTypeReference.class))); } else { _xifexpression = reference; } return _xifexpression; }
private static void computeFor(JvmParameterizedTypeReference typeReference, char innerClassDelimiter, NameType nameType, StringBuilder result) { if (typeReference.eClass() == TypesPackage.Literals.JVM_INNER_TYPE_REFERENCE) { JvmParameterizedTypeReference outer = ((JvmInnerTypeReference) typeReference).getOuter(); if (outer != null) { computeFor(outer, innerClassDelimiter, nameType, result); if (result.length() != 0) { JvmType type = typeReference.getType(); result.append(innerClassDelimiter); result.append(type.getSimpleName()); } else { appendType(typeReference, innerClassDelimiter, nameType, result); } } else { appendType(typeReference, innerClassDelimiter, nameType, result); } } else { appendType(typeReference, innerClassDelimiter, nameType, result); } if (typeReference.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__ARGUMENTS)) { result.append("<"); appendArguments(result, typeReference.getArguments(), innerClassDelimiter, nameType); result.append(">"); } }
@Override public JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper) { if (isTypeVisible(visibilityHelper)) { JvmParameterizedTypeReference result = getTypesFactory().createJvmParameterizedTypeReference(); result.setType(type); if (typeArguments != null) { for(LightweightTypeReference typeArgument: typeArguments) { result.getArguments().add(typeArgument.toJavaCompliantTypeReference()); } } return result; } else { return toJavaCompliantTypeReference(getSuperTypes(), visibilityHelper); } }
@Override public LightweightTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference) { JvmType type = getType(reference); if (type == null || type.eIsProxy()) { return createUnknownTypeReference(reference); } ParameterizedTypeReference result = owner.newParameterizedTypeReference(type); for(JvmTypeReference argument: reference.getArguments()) { result.addTypeArgument(visit(argument).getWrapperTypeIfPrimitive()); } return result; }
static JvmParameterizedTypeReference parseType(Notifier context, String typeName, AbstractBuilder caller) { ResourceSet resourceSet = toResource(context).getResourceSet(); URI uri = caller.computeUnusedUri(resourceSet); Resource resource = caller.getResourceFactory().createResource(uri); resourceSet.getResources().add(resource); try (StringInputStream is = new StringInputStream(generateTypenameCode(typeName))) { resource.load(is, null); SarlScript script = resource.getContents().isEmpty() ? null : (SarlScript) resource.getContents().get(0); SarlEvent topElement = (SarlEvent) script.getXtendTypes().get(0); SarlField member = (SarlField) topElement.getMembers().get(0); JvmTypeReference reference = member.getType(); if (reference instanceof JvmParameterizedTypeReference) { final JvmParameterizedTypeReference pref = (JvmParameterizedTypeReference) reference; if (!pref.getArguments().isEmpty()) { EcoreUtil2.resolveAll(resource); return pref; } } } catch (Exception exception) { throw new TypeNotPresentException(typeName, exception); } finally { resourceSet.getResources().remove(resource); } throw new TypeNotPresentException(typeName, null); }
@Override /* @Nullable */ public LightweightTypeReference getSuperType(JvmType rawType) { Object rawResult = internalGetSuperType(rawType); if (rawResult instanceof ParameterizedTypeReference) { return (LightweightTypeReference) rawResult; } else if (rawResult != null) { JvmTypeReference superType = (JvmTypeReference) rawResult; if (isRawType()) { return createRawTypeReference(rawType); } if (superType.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) { if (((JvmParameterizedTypeReference) superType).getArguments().isEmpty()) { return getOwner().newParameterizedTypeReference(rawType); } } LightweightTypeReference unresolved = getOwner().toLightweightTypeReference(rawType); TypeParameterSubstitutor<?> substitutor = createSubstitutor(); LightweightTypeReference result = substitutor.substitute(unresolved); return result; } return null; }
private LightweightTypeReference getSuperTypeByName(String typeName, boolean interfaceType) { JvmTypeReference superType = getSuperTypeByName(typeName, interfaceType, type, new RecursionGuard<JvmType>()); if (superType != null) { JvmType rawType = superType.getType(); if (isRawType()) { return createRawTypeReference(rawType); } if (superType.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) { if (((JvmParameterizedTypeReference) superType).getArguments().isEmpty()) { return getOwner().newParameterizedTypeReference(rawType); } } LightweightTypeReference unresolved = getOwner().toLightweightTypeReference(rawType); TypeParameterSubstitutor<?> substitutor = createSubstitutor(); LightweightTypeReference result = substitutor.substitute(unresolved); return result; } return null; }