@Override public String getJavaIdentifier() { return component.getJavaIdentifier() + "[]"; }
@Override public String apply(/* @Nullable */ LightweightTypeReference reference) { if (reference == null) throw new NullPointerException("reference"); return reference.getJavaIdentifier(); } }
@Override public String getName() { return this.getDelegate().getJavaIdentifier(); }
@Override public String getJavaIdentifier() { return toJavaType().getJavaIdentifier(); }
protected void addIdentifier(LightweightTypeReference type, Set<String> allNames, Set<String> allBoundNames) { if (type instanceof UnboundTypeReference && !type.isResolved()) { allNames.add(((UnboundTypeReference) type).getHandle().toString()); } else { String identifier = type.getJavaIdentifier(); allNames.add(identifier); allBoundNames.add(identifier); } }
protected String getIdentifier(LightweightTypeReference type) { if (type instanceof UnboundTypeReference && !type.isResolved()) return ((UnboundTypeReference) type).getHandle().toString(); return type.getJavaIdentifier(); }
protected boolean isSameErasure(AbstractResolvedOperation overriding, AbstractResolvedOperation overridden) { List<LightweightTypeReference> overridingParameterTypes = overriding.getResolvedParameterTypes(); List<LightweightTypeReference> overriddenParameterTypes = overridden.getResolvedParameterTypes(); if (overridingParameterTypes.size() != overriddenParameterTypes.size()) { return false; } for(int i = 0; i < overridingParameterTypes.size(); i++) { LightweightTypeReference overridingParameterType = overridingParameterTypes.get(i); LightweightTypeReference overriddenParameterType = overriddenParameterTypes.get(i); String erasedOverridingParameterTypeIdentifier = overridingParameterType.getRawTypeReference().getJavaIdentifier(); String erasedOverriddenParameterTypeIdentifier = overriddenParameterType.getRawTypeReference().getJavaIdentifier(); if (!erasedOverridingParameterTypeIdentifier.equals(erasedOverriddenParameterTypeIdentifier)) { return false; } } return true; }
@Override public String getResolvedSignature() { JvmExecutable declaration = getDeclaration(); List<LightweightTypeReference> parameterTypes = getResolvedParameterTypes(); StringBuilder result = new StringBuilder(declaration.getSimpleName().length() + 2 + 30 * parameterTypes.size()); result.append(declaration.getSimpleName()); result.append('('); for(int i = 0; i < parameterTypes.size(); i++) { if (i != 0) { result.append(','); } result.append(parameterTypes.get(i).getJavaIdentifier()); } result.append(')'); return result.toString(); }
@Override public String getResolvedErasureSignature() { JvmExecutable declaration = getDeclaration(); List<LightweightTypeReference> parameterTypes = getResolvedParameterTypes(); StringBuilder result = new StringBuilder(declaration.getSimpleName().length() + 2 + 20 * parameterTypes.size()); result.append(declaration.getSimpleName()); result.append('('); for(int i = 0; i < parameterTypes.size(); i++) { if (i != 0) { result.append(','); } result.append(parameterTypes.get(i).getRawTypeReference().getJavaIdentifier()); } result.append(')'); return result.toString(); }
LightweightTypeReference overridingParameterType = overridingParameterTypes.get(i); LightweightTypeReference overriddenParameterType = overriddenParameterTypes.get(i); String overridingParameterTypeIdentifier = overridingParameterType.getJavaIdentifier(); if (!overridingParameterTypeIdentifier.equals(overriddenParameterType.getJavaIdentifier())) { if (!overriding.getTypeParameters().isEmpty()) { return false; LightweightTypeReference overriddenParameterType = overriddenParameterTypes.get(i); LightweightTypeReference erasureType = overriddenParameterType.getRawTypeReference(); String overridingParameterTypeIdentifier = overridingParameterType.getJavaIdentifier(); if (!overridingParameterTypeIdentifier.equals(erasureType.getJavaIdentifier())) { return false;
@Override public String getJavaIdentifier() { if (internalIsResolved()) { return resolvedTo.getJavaIdentifier(); } return getIdentifier(); }
if (!overridingSuperTypes.get(0).getJavaIdentifier().equals(resolved.getJavaIdentifier())) { return false; Set<String> overridingSuperTypeNames = Sets.newHashSetWithExpectedSize(overriddenSuperTypes.size()); for(LightweightTypeReference overridingSuperType: overridingSuperTypes) { overridingSuperTypeNames.add(overridingSuperType.getJavaIdentifier()); if (!overridingSuperTypeNames.contains(resolved.getJavaIdentifier())) { return false;
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()); }
protected void addReturnTypeDetails(AbstractResolvedOperation overriding, AbstractResolvedOperation overridden, EnumSet<OverrideCheckDetails> result) { LightweightTypeReference overridingReturnType = overriding.getResolvedReturnType(); LightweightTypeReference overriddenReturnType = overridden.getResolvedReturnType(); TypeConformanceComputationArgument conformanceArgument = new TypeConformanceComputationArgument(false, false, false, false, false, false); if (!overriddenReturnType.isAssignableFrom(overridingReturnType, conformanceArgument)) { if (overriding.getTypeParameters().isEmpty() && !overridden.getTypeParameters().isEmpty()) { TypeConformanceComputationArgument rawConformanceArgument = new TypeConformanceComputationArgument(true, false, false, false, false, false); if (!overriddenReturnType.isAssignableFrom(overridingReturnType, rawConformanceArgument)) { result.add(OverrideCheckDetails.RETURN_MISMATCH); } else { result.add(OverrideCheckDetails.UNCHECKED_CONVERSION_REQUIRED); if (overridingReturnType.getRawTypeReference().getType() != overriddenReturnType.getRawTypeReference().getType()) { result.add(OverrideCheckDetails.COVARIANT_RETURN); } } } else { result.add(OverrideCheckDetails.RETURN_MISMATCH); } } else if (!overriddenReturnType.getJavaIdentifier().equals(overridingReturnType.getJavaIdentifier())) { if (!overridden.isRawTypeInheritance() && overriding.getTypeParameters().isEmpty() && !overridden.getTypeParameters().isEmpty()) { if (overridden.getTypeParameters().contains(overridden.getDeclaration().getReturnType().getType())) { result.add(OverrideCheckDetails.UNCHECKED_CONVERSION_REQUIRED); } } result.add(OverrideCheckDetails.COVARIANT_RETURN); } }
public IInputKey getExpressionType() { LightweightTypeReference expressionType = xbaseResolver.resolveTypes(xExpression).getReturnType(xExpression); if (expressionType == null) { return new JavaTransitiveInstancesKey(Object.class); } else if (expressionType instanceof UnknownTypeReference) { return new JavaTransitiveInstancesKey(Object.class); } else { return new JavaTransitiveInstancesKey(expressionType.getWrapperTypeIfPrimitive().getJavaIdentifier()); } }
if (!toBeConvertedTo.getJavaIdentifier().equals(actualType.getJavaIdentifier())) { doCastConversion(toBeConvertedTo, appendable, new Later() { @Override
dataType = EcoreFactory.eINSTANCE.createEDataType(); dataType.setName(type.getSimpleName()); dataType.setInstanceClassName(type.getJavaIdentifier());