protected JvmTypeReference param(JvmTypeConstraint... constraints) {
JvmParameterizedTypeReference result =
TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
JvmTypeParameter parameter = TypesFactory.eINSTANCE.createJvmTypeParameter();
parameter.getConstraints().addAll(Arrays.asList(constraints));
result.setType(parameter);
return result;
}
protected SignatureHashBuilder appendTypeParameter(JvmTypeParameter p) {
if (p != null && p.getIdentifier() != null) {
append(p.getIdentifier());
} else {
append("*unresolved*");
}
return this;
}
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);
}
protected void copyAndFixTypeParameters(
List<JvmTypeParameter> typeParameters, JvmTypeParameterDeclarator target) {
for (JvmTypeParameter typeParameter : typeParameters) {
final JvmTypeParameter clonedTypeParameter = cloneWithProxies(typeParameter);
target.getTypeParameters().add(clonedTypeParameter);
boolean upperBoundSeen = false;
for (JvmTypeConstraint constraint : clonedTypeParameter.getConstraints()) {
if (constraint instanceof JvmUpperBound) {
upperBoundSeen = true;
break;
}
}
if (!upperBoundSeen) {
JvmUpperBound upperBound = typesFactory.createJvmUpperBound();
upperBound.setTypeReference(typeReferences.getTypeForName(Object.class, typeParameter));
clonedTypeParameter.getConstraints().add(upperBound);
}
associator.associate(typeParameter, clonedTypeParameter);
}
}
@Check
public void checkStartsWithCapital(final JvmTypeParameter ne) {
String _name = ne.getName();
char _charAt = _name.charAt(0);
boolean _isUpperCase = Character.isUpperCase(_charAt);
boolean _not = (!_isUpperCase);
if (_not) {
this.error(
"Type parameter name must start with a capital",
TypesPackage.Literals.JVM_TYPE_PARAMETER__NAME);
}
}
public boolean isLocalTypeParameter(EObject context, JvmTypeParameter parameter) {
if (context == parameter.getDeclarator()) return true;
if (context instanceof JvmOperation && ((JvmOperation) context).isStatic()) return false;
if (context instanceof JvmDeclaredType && ((JvmDeclaredType) context).isStatic()) return false;
JvmIdentifiableElement jvmElement = contextProvider.getLogicalContainer(context);
if (jvmElement != null) {
return isLocalTypeParameter(jvmElement, parameter);
}
EObject container = context.eContainer();
if (container == null) {
return false;
}
return isLocalTypeParameter(container, parameter);
}
protected IScope createTypeScope(
JvmIdentifiableElement context, EReference reference, IScope parentScope) {
if (context == null) return parentScope;
if (context.eContainer() instanceof JvmIdentifiableElement) {
parentScope =
createTypeScope((JvmIdentifiableElement) context.eContainer(), reference, parentScope);
}
if (context instanceof JvmGenericType) {
JvmGenericType genericType = (JvmGenericType) context;
List<IEObjectDescription> descriptions = Lists.newArrayList();
if (genericType.getSimpleName() != null) {
QualifiedName inferredDeclaringTypeName = QualifiedName.create(genericType.getSimpleName());
descriptions.add(EObjectDescription.create(inferredDeclaringTypeName, genericType));
}
for (JvmTypeParameter param : genericType.getTypeParameters()) {
if (param.getSimpleName() != null) {
QualifiedName paramName = QualifiedName.create(param.getSimpleName());
descriptions.add(EObjectDescription.create(paramName, param));
}
}
if (!descriptions.isEmpty()) return MapBasedScope.createScope(parentScope, descriptions);
} else if (context instanceof JvmOperation) {
JvmOperation operation = (JvmOperation) context;
List<IEObjectDescription> descriptions = null;
for (JvmTypeParameter param : operation.getTypeParameters()) {
if (param.getSimpleName() != null) {
if (descriptions == null) descriptions = Lists.newArrayList();
QualifiedName paramName = QualifiedName.create(param.getSimpleName());
descriptions.add(EObjectDescription.create(paramName, param));
}
}
if (descriptions != null && !descriptions.isEmpty())
return MapBasedScope.createScope(parentScope, descriptions);
}
return parentScope;
}
protected IScope getLocalElementsScope(
IScope parent, IScope globalScope, EObject context, EReference reference) {
IScope result = parent;
QualifiedName name = getQualifiedNameOfLocalElement(context);
boolean ignoreCase = isIgnoreCase(reference);
ISelectable resourceOnlySelectable = getAllDescriptions(context.eResource());
ISelectable globalScopeSelectable = new ScopeBasedSelectable(globalScope);
// imports
List<ImportNormalizer> explicitImports = getImportedNamespaceResolvers(context, ignoreCase);
if (!explicitImports.isEmpty()) {
result =
createImportScope(
result,
explicitImports,
globalScopeSelectable,
reference.getEReferenceType(),
ignoreCase);
}
// local element
if (name != null) {
ImportNormalizer localNormalizer = doCreateImportNormalizer(name, true, ignoreCase);
result =
createImportScope(
result,
singletonList(localNormalizer),
resourceOnlySelectable,
reference.getEReferenceType(),
ignoreCase);
}
// scope for jvm elements
Set<EObject> elements = associations.getJvmElements(context);
for (EObject derivedJvmElement : elements) {
// scope for JvmDeclaredTypes
if (derivedJvmElement instanceof JvmDeclaredType) {
JvmDeclaredType declaredType = (JvmDeclaredType) derivedJvmElement;
QualifiedName jvmTypeName = getQualifiedNameOfLocalElement(declaredType);
if (declaredType.getDeclaringType() == null
&& !Strings.isEmpty(declaredType.getPackageName())) {
QualifiedName packageName =
this.qualifiedNameConverter.toQualifiedName(declaredType.getPackageName());
ImportNormalizer normalizer = doCreateImportNormalizer(packageName, true, ignoreCase);
result =
createImportScope(
result,
singletonList(normalizer),
globalScopeSelectable,
reference.getEReferenceType(),
ignoreCase);
}
if (jvmTypeName != null && !jvmTypeName.equals(name)) {
ImportNormalizer localNormalizer =
doCreateImportNormalizer(jvmTypeName, true, ignoreCase);
result =
createImportScope(
result,
singletonList(localNormalizer),
resourceOnlySelectable,
reference.getEReferenceType(),
ignoreCase);
}
}
// scope for JvmTypeParameterDeclarator
if (derivedJvmElement instanceof JvmTypeParameterDeclarator) {
JvmTypeParameterDeclarator parameterDeclarator =
(JvmTypeParameterDeclarator) derivedJvmElement;
List<IEObjectDescription> descriptions = null;
for (JvmTypeParameter param : parameterDeclarator.getTypeParameters()) {
if (param.getSimpleName() != null) {
if (descriptions == null) descriptions = Lists.newArrayList();
QualifiedName paramName = QualifiedName.create(param.getSimpleName());
descriptions.add(EObjectDescription.create(paramName, param));
}
}
if (descriptions != null && !descriptions.isEmpty())
result = MapBasedScope.createScope(result, descriptions);
}
}
return result;
}