protected String getRawTypeIdentifier(JvmTypeReference reference) { if (reference instanceof JvmParameterizedTypeReference) { JvmType typeOrProxy = (JvmType) reference.eGet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE, false); if (typeOrProxy.eIsProxy()) { URI uri = ((InternalEObject) typeOrProxy).eProxyURI(); if (URIHelperConstants.PROTOCOL.equals(uri.scheme())) { if (URIHelperConstants.PRIMITIVES.regionMatches( 1, uri.segment(0), 0, URIHelperConstants.PRIMITIVES.length() - 1)) { String fragment = uri.fragment(); return fragment; } else if (URIHelperConstants.OBJECTS.regionMatches( 1, uri.segment(0), 0, URIHelperConstants.OBJECTS.length() - 2)) { String fragment = uri.fragment(); if (fragment.lastIndexOf('/') == -1) return fragment; } } } } RawTypeReferenceComputer strategy = new RawTypeReferenceComputer(TypesFactory.eINSTANCE); JvmTypeReference result = strategy.getRawTypeReference(reference, eResource()); if (result == null) return null; JvmType rawResult = result.getType(); return rawResult == null ? null : rawResult.getIdentifier(); }
@Test public void testEmptyListAsAnnotationValueDefault() { try { StringConcatenation _builder = new StringConcatenation(); _builder.append("annotation Foo {"); _builder.newLine(); _builder.append("\t"); _builder.append("String[] bar = #[]"); _builder.newLine(); _builder.append("}"); _builder.newLine(); String _string = _builder.toString(); XtendAnnotationType _annotationType = this.annotationType(_string); JvmAnnotationType _inferredAnnotationType = this._iXtendJvmAssociations.getInferredAnnotationType(_annotationType); EList<JvmMember> _members = _inferredAnnotationType.getMembers(); JvmMember _head = IterableExtensions.<JvmMember>head(_members); final JvmOperation inferred = ((JvmOperation) _head); JvmTypeReference _returnType = inferred.getReturnType(); String _identifier = _returnType.getIdentifier(); Assert.assertEquals("java.lang.String[]", _identifier); JvmAnnotationValue _defaultValue = inferred.getDefaultValue(); Assert.assertTrue((_defaultValue instanceof JvmStringAnnotationValue)); JvmAnnotationValue _defaultValue_1 = inferred.getDefaultValue(); EList<String> _values = ((JvmStringAnnotationValue) _defaultValue_1).getValues(); boolean _isEmpty = _values.isEmpty(); Assert.assertTrue(_isEmpty); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
protected boolean areArgumentTypesValid(JvmExecutable exectuable, List<XExpression> arguments) { int numberOfParameters = exectuable.getParameters().size(); int parametersToCheck = exectuable.isVarArgs() ? numberOfParameters - 1 : numberOfParameters; for (int i = 0; i < parametersToCheck; i++) { JvmTypeReference parameterType = exectuable.getParameters().get(i).getParameterType(); XExpression argument = arguments.get(i); JvmTypeReference argumentType = getTypeProvider().getType(argument, true); if (parameterType == null) return true; if (!isCompatibleArgument(parameterType, argumentType)) return false; } if (exectuable.isVarArgs()) { int lastParamIndex = numberOfParameters - 1; JvmTypeReference lastParameterType = exectuable.getParameters().get(lastParamIndex).getParameterType(); if (!(lastParameterType.getType() instanceof JvmArrayType)) throw new IllegalStateException("Unexpected var arg type: " + lastParameterType); JvmTypeReference varArgType = ((JvmArrayType) lastParameterType.getType()).getComponentType(); if (arguments.size() == numberOfParameters) { XExpression lastArgument = arguments.get(lastParamIndex); JvmTypeReference lastArgumentType = getTypeProvider().getType(lastArgument, true); if (isCompatibleArgument(lastParameterType, lastArgumentType)) return true; if (!isCompatibleArgument(varArgType, lastArgumentType)) return false; } else { for (int i = lastParamIndex; i < arguments.size(); i++) { XExpression argumentExpression = arguments.get(i); JvmTypeReference argumentType = getTypeProvider().getType(argumentExpression, true); if (!isCompatibleArgument(varArgType, argumentType)) return false; } } } return true; }
protected SignatureHashBuilder appendType(JvmTypeReference ref) { if (ref != null && ref.getIdentifier() != null) { append(ref.getIdentifier()); } else { append("*unresolved*"); } return this; }
@Override public JvmTypeReference getExtendedClass() { for (JvmTypeReference candidate : getSuperTypes()) { if (candidate.getType() instanceof JvmGenericType && !((JvmGenericType) candidate.getType()).isInterface()) return candidate; } return null; }
protected boolean isCompatibleArgument( JvmTypeReference declaredType, JvmTypeReference actualType) { if (actualType == null) return true; if (actualType.getType() instanceof JvmTypeParameter) { JvmTypeParameter type = (JvmTypeParameter) actualType.getType(); if (type.getConstraints().isEmpty()) return true; for (JvmTypeConstraint constraint : type.getConstraints()) { if (isCompatibleArgument(declaredType, constraint.getTypeReference())) return true; } return false; } return conformance.isConformant(declaredType, actualType, true); }
public Iterable<? extends JvmFeature> getFeaturesForType(JvmTypeReference declType) { if (declType instanceof JvmAnyTypeReference || declType instanceof JvmMultiTypeReference) { return Collections.emptyList(); } if (declType != null && declType.getType() instanceof JvmDeclaredType) { return filter( filter(((JvmDeclaredType) declType.getType()).getMembers(), JvmFeature.class), new Predicate<JvmFeature>() { public boolean apply(JvmFeature input) { return !(input instanceof JvmConstructor); } }); } return emptySet(); }
protected void createInheritedFeatureNodes( IOutlineNode parentNode, JvmDeclaredType baseType, Set<JvmFeature> processedFeatures, int inheritanceDepth, JvmTypeReference superType) { if (superType.getType() instanceof JvmDeclaredType) { JvmDeclaredType superClass = ((JvmGenericType) superType.getType()); EObject xtendSuperClass = associations.getPrimarySourceElement(superType.getType()); createFeatureNodesForType( parentNode, (XtendTypeDeclaration) xtendSuperClass, superClass, baseType, processedFeatures, inheritanceDepth + 1); } }
protected SignatureHashBuilder appendSuperTypeSignatures(JvmDeclaredType type) { Set<JvmTypeReference> allSuperTypes = superTypeCollector.collectSuperTypes(type); Collection<JvmType> transformedSuperTypes = Lists.newArrayList( (Iterables.transform( allSuperTypes, new Function<JvmTypeReference, JvmType>() { public JvmType apply(JvmTypeReference input) { return input.getType(); } }))); // The inheritance hierarchy contains cycles -> stop calculation here if (transformedSuperTypes.contains(type)) return this; for (JvmTypeReference superType : allSuperTypes) { append("super "); superType.accept( new org.eclipse.xtext.common.types.util.AbstractTypeReferenceVisitor.InheritanceAware< Void>() { @Override public Void doVisitTypeReference(JvmTypeReference reference) { if (reference.getType() instanceof JvmDeclaredType) append(hashProvider.getHash((JvmDeclaredType) reference.getType())); else append(reference.getIdentifier()); return null; } @Override public Void doVisitParameterizedTypeReference( JvmParameterizedTypeReference reference) { doVisitTypeReference(reference); append("<"); for (JvmTypeReference typeArgument : reference.getArguments()) { append(typeArgument.getIdentifier()); append(","); } append(">"); return null; } }); append("\n"); } return this; }
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."); }
@Test public void testInterfaceImplicitSuperType() { try { StringConcatenation _builder = new StringConcatenation(); _builder.append("interface Foo {"); _builder.newLine(); _builder.append("}"); _builder.newLine(); String _string = _builder.toString(); XtendInterface _interfaze = this.interfaze(_string); final JvmGenericType inferred = this._iXtendJvmAssociations.getInferredType(_interfaze); EList<JvmTypeReference> _superTypes = inferred.getSuperTypes(); int _size = _superTypes.size(); Assert.assertEquals(1, _size); EList<JvmTypeReference> _superTypes_1 = inferred.getSuperTypes(); JvmTypeReference _head = IterableExtensions.<JvmTypeReference>head(_superTypes_1); String _identifier = _head.getIdentifier(); Assert.assertEquals("java.lang.Object", _identifier); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
public boolean isNullOrProxy(final JvmTypeReference reference) { return reference == null || reference.getType() == null || reference.getType().eIsProxy(); }
public boolean is(final JvmTypeReference reference, final Class<?> clazz) { if (isNullOrProxy(reference)) return false; final boolean equals = clazz.getCanonicalName().equals(reference.getType().getIdentifier()); return equals; }
protected void addNameAndDescription( final ContentAssistEntry entry, final JvmFeature feature, final boolean withParents, final int insignificantParameters, final String shortName, final LightweightTypeReferenceFactory converter) { final StringBuilder labelBuilder = new StringBuilder(shortName); final StringBuilder descriptionBuilder = new StringBuilder(); if ((feature instanceof JvmOperation)) { if (withParents) { labelBuilder.append("("); this.appendParameters( labelBuilder, ((JvmExecutable) feature), insignificantParameters, converter); labelBuilder.append(")"); } final JvmTypeReference returnType = ((JvmOperation) feature).getReturnType(); boolean _and = false; boolean _notEquals = (!Objects.equal(returnType, null)); if (!_notEquals) { _and = false; } else { String _simpleName = returnType.getSimpleName(); boolean _notEquals_1 = (!Objects.equal(_simpleName, null)); _and = _notEquals_1; } if (_and) { labelBuilder.append(" : "); LightweightTypeReference _lightweightReference = converter.toLightweightReference(returnType); String _humanReadableName = _lightweightReference.getHumanReadableName(); labelBuilder.append(_humanReadableName); } JvmDeclaredType _declaringType = ((JvmOperation) feature).getDeclaringType(); LightweightTypeReference _plainTypeReference = converter.toPlainTypeReference(_declaringType); String _humanReadableName_1 = _plainTypeReference.getHumanReadableName(); descriptionBuilder.append(_humanReadableName_1); if ((!withParents)) { descriptionBuilder.append("."); String _simpleName_1 = ((JvmOperation) feature).getSimpleName(); descriptionBuilder.append(_simpleName_1); descriptionBuilder.append("()"); } } else { if ((feature instanceof JvmField)) { labelBuilder.append(" : "); JvmTypeReference _type = ((JvmField) feature).getType(); boolean _notEquals_2 = (!Objects.equal(_type, null)); if (_notEquals_2) { JvmTypeReference _type_1 = ((JvmField) feature).getType(); LightweightTypeReference _lightweightReference_1 = converter.toLightweightReference(_type_1); final String fieldType = _lightweightReference_1.getHumanReadableName(); boolean _notEquals_3 = (!Objects.equal(fieldType, null)); if (_notEquals_3) { labelBuilder.append(fieldType); } } JvmDeclaredType _declaringType_1 = ((JvmField) feature).getDeclaringType(); LightweightTypeReference _plainTypeReference_1 = converter.toPlainTypeReference(_declaringType_1); String _humanReadableName_2 = _plainTypeReference_1.getHumanReadableName(); descriptionBuilder.append(_humanReadableName_2); } else { if ((feature instanceof JvmConstructor)) { if (withParents) { labelBuilder.append("("); this.appendParameters( labelBuilder, ((JvmExecutable) feature), insignificantParameters, converter); labelBuilder.append(")"); } } } } String _string = labelBuilder.toString(); entry.setLabel(_string); String _string_1 = descriptionBuilder.toString(); entry.setDescription(_string_1); }
public void generateBodyAnnotations(final XPackage pack) { final HashSet<ETypedElement> processed = CollectionLiterals.<ETypedElement>newHashSet(); EList<XClassifier> _classifiers = pack.getClassifiers(); for (final XClassifier xClassifier : _classifiers) { if ((xClassifier instanceof XDataType)) { final XDataType xDataType = ((XDataType) xClassifier); XDataTypeMapping _mapping = this.mappings.getMapping(xDataType); final EDataType eDataType = _mapping.getEDataType(); final XBlockExpression createBody = xDataType.getCreateBody(); XDataTypeMapping _mapping_1 = this.mappings.getMapping(xDataType); final JvmOperation creator = _mapping_1.getCreator(); boolean _and = false; boolean _notEquals = (!Objects.equal(createBody, null)); if (!_notEquals) { _and = false; } else { boolean _notEquals_1 = (!Objects.equal(creator, null)); _and = (_notEquals && _notEquals_1); } if (_and) { final XcoreAppendable appendable = this.createAppendable(); EList<JvmFormalParameter> _parameters = creator.getParameters(); JvmFormalParameter _get = _parameters.get(0); appendable.declareVariable(_get, "it"); JvmTypeReference _returnType = creator.getReturnType(); Set<JvmTypeReference> _emptySet = Collections.<JvmTypeReference>emptySet(); this.compiler.compile(createBody, appendable, _returnType, _emptySet); String _string = appendable.toString(); String _extractBody = this.extractBody(_string); EcoreUtil.setAnnotation(eDataType, GenModelPackage.eNS_URI, "create", _extractBody); } final XBlockExpression convertBody = xDataType.getConvertBody(); XDataTypeMapping _mapping_2 = this.mappings.getMapping(xDataType); final JvmOperation converter = _mapping_2.getConverter(); boolean _and_1 = false; boolean _notEquals_2 = (!Objects.equal(convertBody, null)); if (!_notEquals_2) { _and_1 = false; } else { boolean _notEquals_3 = (!Objects.equal(converter, null)); _and_1 = (_notEquals_2 && _notEquals_3); } if (_and_1) { final XcoreAppendable appendable_1 = this.createAppendable(); EList<JvmFormalParameter> _parameters_1 = converter.getParameters(); JvmFormalParameter _get_1 = _parameters_1.get(0); appendable_1.declareVariable(_get_1, "it"); JvmTypeReference _returnType_1 = converter.getReturnType(); Set<JvmTypeReference> _emptySet_1 = Collections.<JvmTypeReference>emptySet(); this.compiler.compile(convertBody, appendable_1, _returnType_1, _emptySet_1); String _string_1 = appendable_1.toString(); String _extractBody_1 = this.extractBody(_string_1); EcoreUtil.setAnnotation(eDataType, GenModelPackage.eNS_URI, "convert", _extractBody_1); } } else { final XClass xClass = ((XClass) xClassifier); XClassMapping _mapping_3 = this.mappings.getMapping(xClass); final EClass eClass = _mapping_3.getEClass(); EList<EStructuralFeature> _eAllStructuralFeatures = eClass.getEAllStructuralFeatures(); for (final EStructuralFeature eStructuralFeature : _eAllStructuralFeatures) { boolean _add = processed.add(eStructuralFeature); if (_add) { final XStructuralFeature xFeature = this.mappings.getXFeature(eStructuralFeature); boolean _notEquals_4 = (!Objects.equal(xFeature, null)); if (_notEquals_4) { final XBlockExpression getBody = xFeature.getGetBody(); boolean _notEquals_5 = (!Objects.equal(getBody, null)); if (_notEquals_5) { XFeatureMapping _mapping_4 = this.mappings.getMapping(xFeature); final JvmOperation getter = _mapping_4.getGetter(); final XcoreAppendable appendable_2 = this.createAppendable(); JvmTypeReference _returnType_2 = getter.getReturnType(); Set<JvmTypeReference> _emptySet_2 = Collections.<JvmTypeReference>emptySet(); this.compiler.compile(getBody, appendable_2, _returnType_2, _emptySet_2); String _string_2 = appendable_2.toString(); String _extractBody_2 = this.extractBody(_string_2); EcoreUtil.setAnnotation( eStructuralFeature, GenModelPackage.eNS_URI, "get", _extractBody_2); } } } } EList<EOperation> _eAllOperations = eClass.getEAllOperations(); for (final EOperation eOperation : _eAllOperations) { boolean _add_1 = processed.add(eOperation); if (_add_1) { final XOperation xOperation = this.mappings.getXOperation(eOperation); boolean _notEquals_6 = (!Objects.equal(xOperation, null)); if (_notEquals_6) { final XBlockExpression body = xOperation.getBody(); boolean _notEquals_7 = (!Objects.equal(body, null)); if (_notEquals_7) { XOperationMapping _mapping_5 = this.mappings.getMapping(xOperation); final JvmOperation jvmOperation = _mapping_5.getJvmOperation(); boolean _notEquals_8 = (!Objects.equal(jvmOperation, null)); if (_notEquals_8) { final XcoreAppendable appendable_3 = this.createAppendable(); JvmDeclaredType _declaringType = jvmOperation.getDeclaringType(); appendable_3.declareVariable(_declaringType, "this"); JvmDeclaredType _declaringType_1 = jvmOperation.getDeclaringType(); EList<JvmTypeReference> _superTypes = _declaringType_1.getSuperTypes(); final JvmTypeReference superType = IterableExtensions.<JvmTypeReference>head(_superTypes); boolean _notEquals_9 = (!Objects.equal(superType, null)); if (_notEquals_9) { JvmType _type = superType.getType(); appendable_3.declareVariable(_type, "super"); } EList<JvmFormalParameter> _parameters_2 = jvmOperation.getParameters(); for (final JvmFormalParameter parameter : _parameters_2) { String _name = parameter.getName(); appendable_3.declareVariable(parameter, _name); } JvmTypeReference _returnType_3 = jvmOperation.getReturnType(); EList<JvmTypeReference> _exceptions = jvmOperation.getExceptions(); HashSet<JvmTypeReference> _hashSet = new HashSet<JvmTypeReference>(_exceptions); this.compiler.compile(body, appendable_3, _returnType_3, _hashSet); String _string_3 = appendable_3.toString(); String _extractBody_3 = this.extractBody(_string_3); EcoreUtil.setAnnotation( eOperation, GenModelPackage.eNS_URI, "body", _extractBody_3); } } } } } } } }
protected void assertCommonSuperType(String expected, List<JvmTypeReference> refs) { JvmTypeReference type = getComputer().getCommonSuperType(refs); assertEquals(expected, type.getIdentifier()); }
protected void convertFunctionType( final JvmTypeReference expectedType, final JvmTypeReference functionType, final ITreeAppendable appendable, final Later expression, XExpression context) { // JvmTypeReference resolvedLeft = closures.getResolvedExpectedType(expectedType, // functionType); if (expectedType.getIdentifier().equals(Object.class.getName()) || EcoreUtil.equals(expectedType.getType(), functionType.getType()) || ((expectedType instanceof JvmSynonymTypeReference) && Iterables.any( ((JvmSynonymTypeReference) expectedType).getReferences(), new Predicate<JvmTypeReference>() { public boolean apply(@Nullable JvmTypeReference ref) { return EcoreUtil.equals(ref.getType(), functionType.getType()); } }))) { // same raw type but different type parameters // at this point we know that we are compatible so we have to convince the Java compiler about // that ;-) if (!getTypeConformanceComputer().isConformant(expectedType, functionType)) { // insert a cast appendable.append("("); serialize(expectedType, context, appendable); appendable.append(")"); } expression.exec(appendable); return; } JvmOperation operation = closures.findImplementingOperation(expectedType, context.eResource()); if (operation == null) { throw new IllegalStateException( "expected type " + expectedType + " not mappable from " + functionType); } JvmType declaringType = (expectedType instanceof JvmParameterizedTypeReference) ? expectedType.getType() : operation.getDeclaringType(); final JvmTypeReference typeReferenceWithPlaceHolder = getTypeReferences().createTypeRef(declaringType); ITypeArgumentContext typeArgumentContext = contextProvider.getTypeArgumentContext( new TypeArgumentContextProvider.AbstractRequest() { @Override public JvmTypeReference getExpectedType() { return functionType; } @Override public JvmTypeReference getDeclaredType() { return typeReferenceWithPlaceHolder; } @Override public String toString() { return "TypeConvertingCompiler.convertFunctionType [expected=" + functionType + ",declared=" + typeReferenceWithPlaceHolder + "]"; } }); JvmTypeReference resolvedExpectedType = typeArgumentContext.resolve(typeReferenceWithPlaceHolder); appendable.append("new "); serialize(resolvedExpectedType, context, appendable, true, false); appendable.append("() {"); appendable.increaseIndentation().increaseIndentation(); appendable.newLine().append("public "); serialize( typeArgumentContext.resolve(operation.getReturnType()), context, appendable, true, false); appendable.append(" ").append(operation.getSimpleName()).append("("); EList<JvmFormalParameter> params = operation.getParameters(); for (Iterator<JvmFormalParameter> iterator = params.iterator(); iterator.hasNext(); ) { JvmFormalParameter p = iterator.next(); final String name = p.getName(); serialize( typeArgumentContext.resolve(p.getParameterType()), context, appendable, false, false); appendable.append(" ").append(name); if (iterator.hasNext()) appendable.append(","); } appendable.append(") {"); appendable.increaseIndentation(); if (!getTypeReferences().is(operation.getReturnType(), Void.TYPE)) appendable.newLine().append("return "); else appendable.newLine(); expression.exec(appendable); appendable.append("."); JvmOperation actualOperation = closures.findImplementingOperation(functionType, context.eResource()); appendable.append(actualOperation.getSimpleName()); appendable.append("("); for (Iterator<JvmFormalParameter> iterator = params.iterator(); iterator.hasNext(); ) { JvmFormalParameter p = iterator.next(); final String name = p.getName(); appendable.append(name); if (iterator.hasNext()) appendable.append(","); } appendable.append(");"); appendable.decreaseIndentation(); appendable.newLine().append("}"); appendable.decreaseIndentation().decreaseIndentation(); appendable.newLine().append("}"); }
public boolean isArray(JvmTypeReference type) { if (isNullOrProxy(type)) return false; return type instanceof JvmGenericArrayTypeReference || type.getType() instanceof JvmArrayType; }
private String getTypeName(JvmTypeReference type) { return type.getQualifiedName(); }
protected JvmType getRawType(JvmTypeReference reference) { RawTypeReferenceComputer strategy = new RawTypeReferenceComputer(TypesFactory.eINSTANCE); JvmTypeReference result = strategy.getRawTypeReference(reference, eResource()); return result == null ? null : result.getType(); }
public void serialize( final JvmTypeReference type, EObject context, IAppendable appendable, boolean withoutConstraints, boolean paramsToWildcard, boolean paramsToObject, boolean allowPrimitives) { IAppendable tracedAppendable = appendable; boolean tracing = false; if (appendable instanceof ITreeAppendable && type.eResource() == context.eResource()) { tracedAppendable = ((ITreeAppendable) appendable).trace(type); tracing = true; } if (type instanceof JvmWildcardTypeReference) { JvmWildcardTypeReference wildcard = (JvmWildcardTypeReference) type; if (!withoutConstraints) { tracedAppendable.append("?"); } if (!wildcard.getConstraints().isEmpty()) { for (JvmTypeConstraint constraint : wildcard.getConstraints()) { if (constraint instanceof JvmLowerBound) { if (!withoutConstraints) tracedAppendable.append(" super "); serialize( constraint.getTypeReference(), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, false); return; } } boolean first = true; for (JvmTypeConstraint constraint : wildcard.getConstraints()) { if (constraint instanceof JvmUpperBound) { if (first) { if (!withoutConstraints) tracedAppendable.append(" extends "); first = false; } else { if (withoutConstraints) throw new IllegalStateException( "cannot have two upperbounds if type should be printed without constraints"); tracedAppendable.append(" & "); } serialize( constraint.getTypeReference(), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, false); } } } else if (withoutConstraints) { tracedAppendable.append("Object"); } } else if (type instanceof JvmGenericArrayTypeReference) { serialize( ((JvmGenericArrayTypeReference) type).getComponentType(), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, true); tracedAppendable.append("[]"); } else if (type instanceof JvmParameterizedTypeReference) { JvmParameterizedTypeReference parameterized = (JvmParameterizedTypeReference) type; if ((paramsToWildcard || paramsToObject) && parameterized.getType() instanceof JvmTypeParameter) { JvmTypeParameter parameter = (JvmTypeParameter) parameterized.getType(); if (!isLocalTypeParameter(context, parameter)) { if (paramsToWildcard) tracedAppendable.append("?"); else tracedAppendable.append("Object"); return; } } JvmType jvmType = allowPrimitives ? type.getType() : primitives.asWrapperTypeIfPrimitive(type).getType(); if (tracing) { ITextRegion region = locationProvider.getFullTextRegion( type, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE, 0); if (region instanceof ITextRegionWithLineInformation) { ((ITreeAppendable) tracedAppendable) .trace(new LocationData((ITextRegionWithLineInformation) region, null)) .append(jvmType); } else { tracedAppendable.append(jvmType); } } else { tracedAppendable.append(jvmType); } if (!parameterized.getArguments().isEmpty()) { tracedAppendable.append("<"); for (int i = 0; i < parameterized.getArguments().size(); i++) { if (i != 0) { tracedAppendable.append(","); } serialize( parameterized.getArguments().get(i), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, false); } tracedAppendable.append(">"); } } else if (type instanceof JvmAnyTypeReference) { tracedAppendable.append("Object"); } else if (type instanceof JvmMultiTypeReference) { serialize( resolveMultiType(type, context), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, allowPrimitives); } else if (type instanceof JvmDelegateTypeReference) { JvmTypeReference delegate = ((JvmDelegateTypeReference) type).getDelegate(); if (delegate != null) serialize( delegate, context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, allowPrimitives); else tracedAppendable.append("Object"); } else if (type instanceof JvmSpecializedTypeReference) { serialize( ((JvmSpecializedTypeReference) type).getEquivalent(), context, tracedAppendable, withoutConstraints, paramsToWildcard, paramsToObject, allowPrimitives); } else if (type instanceof JvmUnknownTypeReference) { if (type.eIsSet(TypesPackage.Literals.JVM_UNKNOWN_TYPE_REFERENCE__QUALIFIED_NAME)) { tracedAppendable.append(type.getQualifiedName()); } else { tracedAppendable.append("Object"); } } else { throw new IllegalArgumentException(String.valueOf(type)); } }
protected boolean identifierStartWith(JvmTypeReference typeReference, String prefix) { String identifier = typeReference.getType().getIdentifier(); if (identifier != null) return identifier.startsWith(prefix); return false; }