@Override public boolean apply(JvmTypeReference input) { return input.getType() == referencedType; } })) {
public boolean isJsonType(final JvmTypeReference typeReference) { final String typeRefQNameString = typeReference.getQualifiedName(); return this.jsonTypeNames.contains(typeRefQNameString); }
static void appendArguments(StringBuilder result, List<JvmTypeReference> arguments, char innerClassDelimiter, NameType nameType) { if (arguments == null || arguments.isEmpty()) return; int wasLength = result.length(); for (JvmTypeReference argument : arguments) { if (result.length() != wasLength) result.append(", "); switch(nameType) { case ID: result.append(argument.getIdentifier()); break; case QUALIFIED: result.append(argument.getQualifiedName(innerClassDelimiter)); break; case SIMPLE: result.append(argument.getSimpleName()); break; case TO_STRING: result.append(argument.toString()); break; } } }
@Override public String getSimpleName() { JvmTypeReference resolvedDelegate = getDelegate(); if (resolvedDelegate == null || resolvedDelegate.eIsProxy()) return null; return resolvedDelegate.getSimpleName(); }
@Override public String getQualifiedName(char innerClassDelimiter) { JvmTypeReference resolvedDelegate = getDelegate(); if (resolvedDelegate == null || resolvedDelegate.eIsProxy()) return null; return resolvedDelegate.getQualifiedName(innerClassDelimiter); }
protected SignatureHashBuilder appendType(JvmTypeReference ref) { if (ref != null && ref.getIdentifier() != null) { append(ref.getIdentifier()); } else { append("*unresolved*"); } return this; }
public String getSuperTypeName(JvmTypeReference typeReference) { if (typeReference instanceof JvmParameterizedTypeReference) { JvmType rawType = typeReference.getType(); if (rawType != null && !rawType.eIsProxy()) { return rawType.getIdentifier(); } return null; } else { return typeReference.getIdentifier(); } } });
@Override public StringBuilder doVisitTypeReference(JvmTypeReference reference, StringBuilder param) { param.append(reference.getSimpleName()); return param; }
@Check public void checkTypeParameterConstraintIsValid(JvmTypeParameter typeParameter) { if(!typeParameter.getConstraints().isEmpty()) { for(JvmTypeConstraint constraint: typeParameter.getConstraints()) { JvmTypeReference typeReference = constraint.getTypeReference(); if(typeReference instanceof JvmGenericArrayTypeReference) error(String.format("The array type %s cannot be used as a type parameter bound", typeReference.getSimpleName()), typeReference, null, INVALID_TYPE_PARAMETER_BOUNDS); else if (typeReference.getType() instanceof JvmTypeParameter && typeParameter.getConstraints().size() > 1) error(String.format("The type parameter %s cannot be used as a type parameter bound with additional bounds", typeReference.getSimpleName()), typeReference, null, INVALID_TYPE_PARAMETER_BOUNDS); } } }
@Override public String getIdentifier() { JvmTypeReference resolvedDelegate = getDelegate(); if (resolvedDelegate == null || resolvedDelegate.eIsProxy()) return null; return resolvedDelegate.getIdentifier(); }
/** Replies if the type candidate is a proxy (unresolved type) or a subtype of the given super type. * * @param candidate the type to test. * @param jvmSuperType the expected JVM super-type. * @param sarlSuperType the expected SARL super-type. * @param onlyInterface <code>true</code> if only interface types are matching; <code>false</code> if * not-interface types are matching. * @return <code>true</code> if the candidate is a sub-type of the super-type. */ public boolean isProxyOrSubTypeOf(JvmTypeReference candidate, Class<?> jvmSuperType, Class<? extends XtendTypeDeclaration> sarlSuperType, boolean onlyInterface) { if (candidate.eIsProxy()) { return true; } return isSubTypeOf(candidate, jvmSuperType, sarlSuperType, onlyInterface); }
/** * Creates a clone of the given {@link JvmTypeReference} without resolving any proxies. * The clone will be associated with the original element by means of {@link JvmModelAssociator associations}. * * @param typeRef the type reference to be cloned. * @return a clone of typeRef, <code>null</code> if typeRef is <code>null</code> or a {@link JvmUnknownTypeReference} * if there is a problem with the typeRef. */ /* @Nullable */ public JvmTypeReference cloneWithProxies(/* @Nullable */ JvmTypeReference typeRef) { if(typeRef == null) return null; if (typeRef instanceof JvmParameterizedTypeReference && !typeRef.eIsProxy() && !typeRef.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE)) { JvmUnknownTypeReference unknownTypeReference = typesFactory.createJvmUnknownTypeReference(); return unknownTypeReference; } return cloneAndAssociate(typeRef); }
@Override public StringBuilder visit(JvmTypeReference reference, StringBuilder param) { if (reference == null) return null; return reference.accept(this, param); }
protected void acceptType(JvmTypeReference ref) { if (ref instanceof XFunctionTypeRef || ref instanceof JvmWildcardTypeReference || ref instanceof JvmGenericArrayTypeReference || ref instanceof JvmCompoundTypeReference || (ref.eContainer() instanceof XFunctionTypeRef && ref.eContainmentFeature() == JVM_SPECIALIZED_TYPE_REFERENCE__EQUIVALENT) || NodeModelUtils.findActualNodeFor(ref) == null) return; else acceptPreferredType(ref); }
@Override public JvmTypeReference getEquivalent() { if (equivalent == null) { IJvmTypeReferenceProvider provider = getTypeProvider(); if (provider != null) { JvmTypeReference result = provider.getTypeReference(this); if (equivalent == null || equivalent != result) { if (result != null && (result.eResource() != null || result.eContainer() != null)) { JvmDelegateTypeReference delegate = TypesFactory.eINSTANCE.createJvmDelegateTypeReference(); delegate.setDelegate(result); result = delegate; } if (result != null) { boolean wasDeliver = eDeliver(); try { eSetDeliver(false); setEquivalent(result); } finally { eSetDeliver(wasDeliver); } } } } else { equivalent = null; } } return equivalent; }
protected JvmParameterizedTypeReference createEquivalentWithoutWildcards(JvmType rawType, boolean procedure) { TypesFactory typesFactory = TypesFactory.eINSTANCE; JvmParameterizedTypeReference result = typesFactory.createJvmParameterizedTypeReference(); result.setType(rawType); for(JvmTypeReference paramType: Lists.newArrayList(getParamTypes())) { JvmTypeReference wrapped = wrapIfNecessary(paramType); if (wrapped == null || wrapped.eContainer() != null) { JvmDelegateTypeReference delegate = typesFactory.createJvmDelegateTypeReference(); delegate.setDelegate(wrapped); result.getArguments().add(delegate); } else { result.getArguments().add(wrapped); } } { if (!procedure) { JvmTypeReference wrapped = wrapIfNecessary(getReturnType()); if (wrapped == null || wrapped.eContainer() != null) { JvmDelegateTypeReference delegate = typesFactory.createJvmDelegateTypeReference(); delegate.setDelegate(wrapped); result.getArguments().add(delegate); } else { result.getArguments().add(wrapped); } } } return result; }
@Override public String getIdentifier() { JvmTypeReference componentType = getComponentType(); if (componentType != null) return componentType.getIdentifier() + "[]"; return null; }
protected boolean isMatchesSignature(JvmFormalParameter parameter, JvmFormalParameter candidateParameter, TypeParameterSubstitutor<?> substitutor, ITypeReferenceOwner owner) { JvmTypeReference parameterType = parameter.getParameterType(); if (parameterType == null || parameterType.getType() == null) { return false; } String identifier = parameterType.getIdentifier(); LightweightTypeReference candidateParameterType = substitutor.substitute(owner.toLightweightTypeReference(candidateParameter.getParameterType())); return identifier.equals(candidateParameterType.getJavaIdentifier()); }