@Override public LightweightTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference) { JvmType type = reference.getType(); if (type == parameter) {// recursively bound recursive[0] = true; } return super.doVisitParameterizedTypeReference(reference); } };
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; } } }
@Override public List<JvmType> doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Resource resource) { JvmType type = reference.getType(); if (type != null && !type.eIsProxy()) { if (type instanceof JvmTypeParameter) { return getRawTypesFromConstraints(((JvmTypeParameter) type).getConstraints(), resource); } return Collections.singletonList(type); } return Collections.emptyList(); }
@Override public List<JvmType> doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Resource resource) { JvmType type = reference.getType(); if (type != null && !type.eIsProxy()) { if (type instanceof JvmTypeParameter) { return getRawTypesFromConstraints(((JvmTypeParameter) type).getConstraints(), resource); } return Collections.singletonList(type); } return Collections.emptyList(); }
@Override public TypeConformanceResult doVisitAnyTypeReference(JvmParameterizedTypeReference left, JvmAnyTypeReference right, TypeConformanceComputationArgument.Internal<JvmParameterizedTypeReference> param) { JvmType leftType = left.getType(); if (isUnresolved(leftType)) { return TypeConformanceResult.FAILED; } if (leftType instanceof JvmPrimitiveType) { return TypeConformanceResult.FAILED; } if (isPrimitiveVoid(leftType)) { return TypeConformanceResult.FAILED; } return TypeConformanceResult.SUCCESS; }
/** * @param typeReference may be {@code null} * @return all public, non-static operations that are annotated with @FixtureMethod, inherited methods included, never {@code null} */ private Iterable<JvmOperation> getFixtureMethods(final JvmParameterizedTypeReference typeReference) { JvmType _type = null; if (typeReference!=null) { _type=typeReference.getType(); } final JvmType type = _type; if ((type instanceof JvmDeclaredType)) { return this.getFixtureMethods(((JvmDeclaredType)type)); } return CollectionLiterals.<JvmOperation>emptyList(); }
@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; }
/** * @return the fixture type if the given interaction type (may be null!) */ public JvmType getFixtureType(final InteractionType interactionType) { MethodReference _defaultMethod = null; if (interactionType!=null) { _defaultMethod=interactionType.getDefaultMethod(); } JvmParameterizedTypeReference _typeReference = null; if (_defaultMethod!=null) { _typeReference=_defaultMethod.getTypeReference(); } JvmType _type = null; if (_typeReference!=null) { _type=_typeReference.getType(); } return _type; }
@Check public void checkDeprecated(JvmParameterizedTypeReference type) { if (!isIgnored(DEPRECATED_MEMBER_REFERENCE)) { JvmType jvmType = type.getType(); checkDeprecated( jvmType, type, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE); } }
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 TypeConformanceResult doVisitParameterizedTypeReference(JvmParameterizedTypeReference leftReference, JvmParameterizedTypeReference rightReference, TypeConformanceComputationArgument.Internal<JvmParameterizedTypeReference> param) { JvmType leftType = leftReference.getType(); if (isUnresolved(leftType)) return TypeConformanceResult.FAILED; JvmType rightType = rightReference.getType(); if (isUnresolved(rightType)) return TypeConformanceResult.FAILED; if (isPrimitiveVoid(leftType)) { if (isPrimitiveVoid(rightType)) { return TypeConformanceResult.SUCCESS; } return TypeConformanceResult.FAILED; } if (isPrimitiveVoid(rightType)) { return TypeConformanceResult.FAILED; } return isConformant(leftType, rightType, leftReference, rightReference, param); }
public IScope createTypeScope(EObject context, EReference reference) { if (context.eClass() == TypesPackage.Literals.JVM_INNER_TYPE_REFERENCE) { JvmInnerTypeReference casted = (JvmInnerTypeReference) context; JvmParameterizedTypeReference outerType = casted.getOuter(); JvmType outerRawType = outerType.getType(); if (outerRawType instanceof JvmDeclaredType) { Iterable<JvmDeclaredType> nestedTypes = ((JvmDeclaredType) outerRawType).getAllNestedTypes(); List<IEObjectDescription> descriptions = Lists.newArrayList(); for(JvmDeclaredType nestedType: nestedTypes) { descriptions.add(EObjectDescription.create(nestedType.getSimpleName(), nestedType)); } return new SimpleScope(descriptions); } return IScope.NULLSCOPE; } else { final IScope delegateScope = getDelegate().getScope(context, reference); return delegateScope; } }
private static void createInfoCall(IExpressionBuilder builder, String message) { final JvmParameterizedTypeReference capacity = builder.newTypeRef(null, LOGGING_CAPACITY_NAME); final String objectType = Object.class.getName(); final String objectArrayType = objectType + "[]"; //$NON-NLS-1$ final JvmOperation infoMethod = Iterables.find( ((JvmDeclaredType) capacity.getType()).getDeclaredOperations(), it -> { if (Objects.equals(it.getSimpleName(), "info") //$NON-NLS-1$ && it.getParameters().size() == 2) { final String type1 = it.getParameters().get(0).getParameterType().getIdentifier(); final String type2 = it.getParameters().get(1).getParameterType().getIdentifier(); return Objects.equals(objectType, type1) && Objects.equals(objectArrayType, type2); } return false; }, null); if (infoMethod != null) { builder.setExpression("info(\"" + message + "\")"); //$NON-NLS-1$ //$NON-NLS-2$ ((XFeatureCall) builder.getXExpression()).setFeature(infoMethod); } }
@Check public void checkTypeArgsAgainstTypeParameters(JvmParameterizedTypeReference typeRef) { JvmType type = typeRef.getType(); if(type instanceof JvmGenericType && !type.eIsProxy()) { int numTypeParameters = ((JvmGenericType) type).getTypeParameters().size(); if(typeRef.getArguments().size() > 0) { if (numTypeParameters == 0) { errorTypeIsNotGeneric(type, typeRef); } else if(numTypeParameters != typeRef.getArguments().size()) { StringBuilder message = new StringBuilder(64); message.append("Incorrect number of arguments for type "); message = proxyAwareUIStrings.appendTypeSignature(type, message); message.append("; it cannot be parameterized with arguments "); message = proxyAwareUIStrings.appendTypeArguments(typeRef, message); if (message != null) { error(message.toString(), IssueCodes.INVALID_NUMBER_OF_TYPE_ARGUMENTS, typeRef); } } } else if(numTypeParameters > 0) { warnRawType(type, typeRef); } } else if (type != null && !type.eIsProxy() && !typeRef.getArguments().isEmpty()) { errorTypeIsNotGeneric(type, typeRef); } }
/** Add an annotation. * @param type the qualified name of the annotation */ public void addAnnotation(String type) { if (!Strings.isEmpty(type)) { XAnnotation annotation = XAnnotationsFactory.eINSTANCE.createXAnnotation(); annotation.setAnnotationType(newTypeRef(getSarlAction(), type).getType()); getSarlAction().getAnnotations().add(annotation); } }
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 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; }
@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; }
@Override public JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Pair<Resource, Set<JvmType>> context) { 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) { Set<JvmType> recursionGuard = context.getSecond(); if (recursionGuard.add(type)) { return getRawTypeFromConstraints(((JvmTypeParameter) type).getConstraints(), context); } else { return createObjectReference(context.getFirst()); } } } return reference; }