if (reference.getArguments().size() != other.getArguments().size()) { return Boolean.FALSE; if (reference.getType() != other.getType()) { JvmType plainOverridingType = reference.getType(); JvmType plainOverriddenType = param.getType(); if (plainOverridingType instanceof JvmTypeParameter && plainOverriddenType instanceof JvmTypeParameter) { int typeParamCount = reference.getArguments().size(); for (int i = 0; i < typeParamCount; i++) { JvmTypeReference myTypeArgument = reference.getArguments().get(i); JvmTypeReference otherTypeArgument = other.getArguments().get(i); if (!visit(myTypeArgument, otherTypeArgument)) { return Boolean.FALSE;
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; }
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(">"); } }
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; }
@Override public JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Boolean replaceWildcards) { if (replaceWildcards) { JvmType type = reference.getType(); if (type instanceof JvmTypeParameter) { if (isRawTypeContext() || boundParameters.containsKey(type)) { result.setType(type); if (!isRawTypeContext()) { List<JvmTypeReference> copiedArguments = Lists.newArrayListWithCapacity(reference.getArguments().size()); boolean wasNull = false; for(JvmTypeReference argument: reference.getArguments()) { JvmTypeReference copiedReference = visit(argument, Boolean.FALSE); if (copiedReference == null) { result.getArguments().addAll(copiedArguments);
@Override public LightweightTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference) { JvmType type = reference.getType(); if (type == parameter) {// recursively bound recursive[0] = true; } return super.doVisitParameterizedTypeReference(reference); } };
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(">"); } }
@Override public JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Resource resource) { JvmType type = reference.getType(); if (type != null && !type.eIsProxy()) { if (type instanceof JvmTypeParameterDeclarator) { if (!((JvmTypeParameterDeclarator) type).getTypeParameters().isEmpty()) { JvmParameterizedTypeReference result = factory.createJvmParameterizedTypeReference(); result.setType(type); return result; } } else if (type instanceof JvmTypeParameter) { return getRawTypeFromConstraints(((JvmTypeParameter) type).getConstraints(), resource); } } return reference; }
protected JvmTypeReference createLocalTypeReference(Type type, JvmTypeParameterDeclarator container, GenericDeclaration member) { if (type instanceof GenericArrayType) { GenericArrayType arrayType = (GenericArrayType) type; Type componentType = arrayType.getGenericComponentType(); return createLocalArrayTypeReference(componentType, container, member); } else if (type instanceof TypeVariable<?>) { TypeVariable<?> typeVariable = (TypeVariable<?>) type; JvmParameterizedTypeReference result = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference(); int idx = Arrays.asList(member.getTypeParameters()).indexOf(typeVariable); result.setType(container.getTypeParameters().get(idx)); return result; } throw new IllegalArgumentException(type.toString()); }
/** Generate the implemented types for the given SARL statement. * * @param context the context of the generation. * @param owner the JVM element to change. * @param defaultJvmType the default JVM type. * @param defaultSarlType the default SARL type. * @param implementedtypes the implemented types. */ protected void appendConstrainedImplements( GenerationContext context, JvmGenericType owner, Class<?> defaultJvmType, Class<? extends XtendTypeDeclaration> defaultSarlType, List<? extends JvmParameterizedTypeReference> implementedtypes) { boolean explicitType = false; for (final JvmParameterizedTypeReference superType : implementedtypes) { if (!Objects.equal(owner.getIdentifier(), superType.getIdentifier()) && superType.getType() instanceof JvmGenericType /*&& this.inheritanceHelper.isProxyOrSubTypeOf(superType, defaultJvmType, defaultSarlType, true)*/) { owner.getSuperTypes().add(this.typeBuilder.cloneWithProxies(superType)); context.incrementSerial(superType.getIdentifier().hashCode()); explicitType = true; } } if (!explicitType) { final JvmTypeReference type = this._typeReferenceBuilder.typeRef(defaultJvmType); owner.getSuperTypes().add(type); context.incrementSerial(type.getIdentifier().hashCode()); } }
@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; }
/** * Contexts: * SimpleTypeReference returns JvmParameterizedTypeReference * * Constraint: * type=[JvmType|ValidID] */ protected void sequence_SimpleTypeReference(ISerializationContext context, JvmParameterizedTypeReference semanticObject) { if (errorAcceptor != null) { if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); feeder.accept(grammarAccess.getSimpleTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_0_1(), semanticObject.eGet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE, false)); feeder.finish(); }
static String computeFor(JvmParameterizedTypeReference typeReference, char innerClassDelimiter, NameType nameType) { if (typeReference.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE)) { StringBuilder mutableResult = new StringBuilder(64); computeFor(typeReference, innerClassDelimiter, nameType, mutableResult); return mutableResult.toString(); } return null; }
@Override public JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Boolean replaceWildcards) { if (replaceWildcards) { JvmType type = reference.getType(); if (type instanceof JvmTypeParameter) { if (isRawTypeContext() || boundParameters.containsKey(type)) { JvmTypeReference bound = getBoundArgument((JvmTypeParameter) type); if (isRecursive(type, bound)) { // TODO find the reason for this recursion // System.out.println("Recursion2"); return bound; } return visit(bound, replaceWildcards); } } JvmParameterizedTypeReference result = typesFactory.createJvmParameterizedTypeReference(); result.setType(type); if (!isRawTypeContext()) { for(JvmTypeReference argument: reference.getArguments()) { final JvmTypeReference visit = visit(argument, Boolean.FALSE); result.getArguments().add(visit); } } return result; } else { return super.doVisitParameterizedTypeReference(reference, replaceWildcards); } }
private static void appendType(JvmParameterizedTypeReference typeReference, char innerClassDelimiter, NameType nameType, StringBuilder result) { JvmType type = typeReference.getType(); if (type != null) { switch(nameType) { case ID: result.append(type.getIdentifier()); break; case QUALIFIED: result.append(type.getQualifiedName(innerClassDelimiter)); break; case SIMPLE: result.append(type.getSimpleName()); break; case TO_STRING: result.append(type.getIdentifier()); break; } } }
@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 JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Resource resource) { JvmType type = reference.getType(); if (type != null && !type.eIsProxy()) { if (type instanceof JvmTypeParameterDeclarator) { if (!((JvmTypeParameterDeclarator) type).getTypeParameters().isEmpty()) { JvmParameterizedTypeReference result = factory.createJvmParameterizedTypeReference(); result.setType(type); return result; } } else if (type instanceof JvmTypeParameter) { return getRawTypeFromConstraints(((JvmTypeParameter) type).getConstraints(), resource); } } return reference; }
protected JvmTypeReference createLocalTypeReference(Type type, JvmTypeParameterDeclarator container, GenericDeclaration member) { if (type instanceof GenericArrayType) { GenericArrayType arrayType = (GenericArrayType) type; Type componentType = arrayType.getGenericComponentType(); return createLocalArrayTypeReference(componentType, container, member); } else if (type instanceof TypeVariable<?>) { TypeVariable<?> typeVariable = (TypeVariable<?>) type; JvmParameterizedTypeReference result = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference(); int idx = Arrays.asList(member.getTypeParameters()).indexOf(typeVariable); result.setType(container.getTypeParameters().get(idx)); return result; } throw new IllegalArgumentException(type.toString()); }
String superTypeId; try { superTypeId = superType.getIdentifier(); } catch (Exception ex) { logInternalError(ex); && superType.getType() instanceof JvmGenericType context.incrementSerial(superType.getIdentifier().hashCode()); explicitType = true;
/** * Contexts: * TypeReferenceNoTypeArgs returns JvmParameterizedTypeReference * TypeReferenceWithTypeArgs.JvmGenericArrayTypeReference_1_1_0_0 returns JvmParameterizedTypeReference * * Constraint: * type=[JvmType|QualifiedName] */ protected void sequence_TypeReferenceNoTypeArgs(ISerializationContext context, JvmParameterizedTypeReference semanticObject) { if (errorAcceptor != null) { if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); feeder.accept(grammarAccess.getTypeReferenceNoTypeArgsAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE, false)); feeder.finish(); }