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()); } }
private Iterable<JavaTransitiveInstancesKey> minimizeJavaTypeList(final Iterable<JavaTransitiveInstancesKey> types) { final Function1<JavaTransitiveInstancesKey, Boolean> _function = (JavaTransitiveInstancesKey it) -> { return Boolean.valueOf(((it.getInstanceClass() != null) && (!Objects.equal(it.getInstanceClass(), Object.class)))); }; final Function1<JavaTransitiveInstancesKey, Class<?>> _function_1 = (JavaTransitiveInstancesKey it) -> { return it.getInstanceClass(); }; final Iterable<Class<?>> nonTopTypes = IterableExtensions.<Class<?>>filterNull(IterableExtensions.<JavaTransitiveInstancesKey, Class<?>>map(IterableExtensions.<JavaTransitiveInstancesKey>filter(types, _function), _function_1)); final HashSet<Class<?>> javaTypes = CollectionLiterals.<Class<?>>newHashSet(((Class<?>[])Conversions.unwrapArray(nonTopTypes, Class.class))); final Consumer<Class<?>> _function_2 = (Class<?> key) -> { final Function1<Class<?>, Boolean> _function_3 = (Class<?> it) -> { return Boolean.valueOf(((!Objects.equal(it, key)) && key.isAssignableFrom(it))); }; CollectionExtensions.<Class<?>>removeAll(javaTypes, IterableExtensions.<Class<?>>filter(javaTypes, _function_3)); }; nonTopTypes.forEach(_function_2); final Function1<Class<?>, JavaTransitiveInstancesKey> _function_3 = (Class<?> it) -> { return new JavaTransitiveInstancesKey(it); }; return IterableExtensions.<Class<?>, JavaTransitiveInstancesKey>map(javaTypes, _function_3); }
private Class<?> forceGetWrapperInstanceClass(JavaTransitiveInstancesKey key) { Class<?> instanceClass; try { instanceClass = key.forceGetWrapperInstanceClass(); } catch (ClassNotFoundException e) { logger.error("Could not load instance class for type constraint " + key.getWrappedKey(), e); instanceClass = null; } return instanceClass; }
/** * @since 1.5 */ public Class<?> getJavaClass(final JavaTransitiveInstancesKey javaKey) { Class<?> javaTypeClass = javaKey.getInstanceClass(); boolean _isPrimitive = javaTypeClass.isPrimitive(); if (_isPrimitive) { javaTypeClass = AbstractTypeSystem.getWrapperClassForType(javaTypeClass); } return javaTypeClass; }
private String calculateIssueData(IInputKey input) { if (input instanceof EClassTransitiveInstancesKey) { return ((EClassTransitiveInstancesKey) input).getEmfKey().getName(); } else if (input instanceof EDataTypeInSlotsKey) { EDataType datatype = ((EDataTypeInSlotsKey) input).getEmfKey(); if (datatype instanceof EEnum) { return datatype.getName(); } else { // In case of non-enum datatypes use corresponding Java type instead return IssueCodes.JAVA_TYPE_PREFIX + typeSystem.getJavaClassName((EDataTypeInSlotsKey) input); } } else if (input instanceof JavaTransitiveInstancesKey) { return IssueCodes.JAVA_TYPE_PREFIX + ((JavaTransitiveInstancesKey) input).getWrappedKey(); } return null; }
if (key instanceof JavaTransitiveInstancesKey) { _matched=true; final String clazz = ((JavaTransitiveInstancesKey)key).getPrettyPrintableName(); StringConcatenation _builder = new StringConcatenation(); _builder.append("new ");
Class<?> clazz = ((JavaTransitiveInstancesKey) type).getInstanceClass(); validateJavaFeatureAccess(clazz, tokens, ref, validator); } else if (type instanceof EClassTransitiveInstancesKey) {
@Override public JvmTypeReference toJvmTypeReference(final IInputKey type, final EObject context) { if ((type instanceof EClassTransitiveInstancesKey)) { return this.getJvmType(((EClassTransitiveInstancesKey)type).getEmfKey(), context); } else { if ((type instanceof EDataTypeInSlotsKey)) { return this.getJvmType(((EDataTypeInSlotsKey)type).getEmfKey(), context); } else { if ((type instanceof JavaTransitiveInstancesKey)) { final String wrappedKey = ((JavaTransitiveInstancesKey)type).getWrappedKey(); boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(wrappedKey); boolean _not = (!_isNullOrEmpty); if (_not) { return this.typeReferences.getTypeForName(wrappedKey, context); } } } } return this.typeReferences.getTypeForName(Object.class, context); }
protected void _inferTypes(final StringValue reference, final TypeInformation information) { JavaTransitiveInstancesKey _javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(String.class); TypeJudgement _typeJudgement = new TypeJudgement(reference, _javaTransitiveInstancesKey); information.provideType(_typeJudgement); }
Class<?> instanceClass = ((JavaTransitiveInstancesKey) implyingKey).getInstanceClass(); if (instanceClass != null) { // resolution successful JavaTransitiveInstancesKey impliedSuper = new JavaTransitiveInstancesKey(superclass); result.add(new InputKeyImplication(implyingKey, impliedSuper, Arrays.asList(0))); JavaTransitiveInstancesKey impliedInterface = new JavaTransitiveInstancesKey(superInterface); result.add(new InputKeyImplication(implyingKey, impliedInterface, Arrays.asList(0))); JavaTransitiveInstancesKey implied = new JavaTransitiveInstancesKey(instanceClass); result.add(new InputKeyImplication(implyingKey, implied, Arrays.asList(0)));
if ((expectedType instanceof JavaTransitiveInstancesKey)) { if ((actualType instanceof JavaTransitiveInstancesKey)) { final Class<?> expectedJavaClass_1 = ((JavaTransitiveInstancesKey)expectedType).getInstanceClass(); final Class<?> actualJavaClass_1 = ((JavaTransitiveInstancesKey)actualType).getInstanceClass(); return (((expectedJavaClass_1 != null) && (actualJavaClass_1 != null)) && expectedJavaClass_1.isAssignableFrom(actualJavaClass_1)); } else {
protected void _inferTypes(final BoolValue reference, final TypeInformation information) { JavaTransitiveInstancesKey _javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(Boolean.class); TypeJudgement _typeJudgement = new TypeJudgement(reference, _javaTransitiveInstancesKey); information.provideType(_typeJudgement); }
protected void _inferTypes(final ListValue reference, final TypeInformation information) { JavaTransitiveInstancesKey _javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(List.class); TypeJudgement _typeJudgement = new TypeJudgement(reference, _javaTransitiveInstancesKey); information.provideType(_typeJudgement); }
/** * @since 1.3 */ @Override public IInputKey getDeclaredType(Expression ex) { if (ex instanceof BoolValue) { return new JavaTransitiveInstancesKey(Boolean.class); } else if (ex instanceof NumberValue) { Class<? extends Number> javaType = literals.getJavaType(((NumberValue) ex).getValue()); return new JavaTransitiveInstancesKey(javaType); } else if (ex instanceof ListValue) { return new JavaTransitiveInstancesKey(List.class); } else if (ex instanceof StringValue) { return new JavaTransitiveInstancesKey(String.class); } else if (ex instanceof EnumValue) { EnumValue reference = (EnumValue) ex; if (reference.getEnumeration() != null) { return typeSystem.classifierToInputKey(reference.getLiteral().getEEnum()); } } return super.getDeclaredType(ex); }
private void gatherTypeConstraint(TypeCheckConstraint constraint, PatternModelAcceptor<?> acceptor) { String variableName = getVariableName(constraint.getVar(), acceptor); String className = ((JavaType)constraint.getType()).getClassRef().getIdentifier(); IInputKey inputKey = new JavaTransitiveInstancesKey(className); acceptor.acceptTypeCheckConstraint(ImmutableList.of(variableName), inputKey); }
@Override public IInputKey extractTypeDescriptor(final Type type) { Preconditions.checkArgument((((type instanceof ClassType) || (type instanceof ReferenceType)) || (type instanceof JavaType)), EMFTypeSystem.NON_EMF_TYPE_ENCOUNTERED, type.getClass()); if ((type instanceof ClassType)) { final EClassifier classifier = ((ClassType)type).getClassname(); return this.classifierToInputKey(classifier); } else { if ((type instanceof ReferenceType)) { EStructuralFeature _refname = ((ReferenceType)type).getRefname(); EClassifier _eType = null; if (_refname!=null) { _eType=_refname.getEType(); } return this.classifierToInputKey(_eType); } else { if ((type instanceof JavaType)) { String _identifier = ((JavaType)type).getClassRef().getIdentifier(); return new JavaTransitiveInstancesKey(_identifier); } } } throw new UnsupportedOperationException(); }
/** * @since 1.3 */ @Override public Set<IInputKey> minimizeTypeInformation(final Set<IInputKey> types, final boolean mergeWithSupertypes) { int _size = types.size(); boolean _equals = (_size == 1); if (_equals) { return types; } final Iterable<JavaTransitiveInstancesKey> eJavaTypes = this.minimizeJavaTypeList(IterableExtensions.<JavaTransitiveInstancesKey>filterNull(Iterables.<JavaTransitiveInstancesKey>filter(types, JavaTransitiveInstancesKey.class))); final Function1<EDataTypeInSlotsKey, Boolean> _function = (EDataTypeInSlotsKey it) -> { boolean _xblockexpression = false; { Class<?> _wrapperClassForType = AbstractTypeSystem.getWrapperClassForType(it.getEmfKey().getInstanceClass()); final JavaTransitiveInstancesKey javaType = new JavaTransitiveInstancesKey(_wrapperClassForType); final Function1<JavaTransitiveInstancesKey, Boolean> _function_1 = (JavaTransitiveInstancesKey it_1) -> { return Boolean.valueOf(Objects.equal(it_1, javaType)); }; boolean _exists = IterableExtensions.<JavaTransitiveInstancesKey>exists(eJavaTypes, _function_1); _xblockexpression = (!_exists); } return Boolean.valueOf(_xblockexpression); }; final Iterable<EDataTypeInSlotsKey> eDataTypes = IterableExtensions.<EDataTypeInSlotsKey>filter(this.minimizeEDataTypeList(IterableExtensions.<EDataTypeInSlotsKey>filterNull(Iterables.<EDataTypeInSlotsKey>filter(types, EDataTypeInSlotsKey.class))), _function); final Iterable<EClassTransitiveInstancesKey> eClassTypes = this.minimizeEClassKeyList(IterableExtensions.<EClassTransitiveInstancesKey>filterNull(Iterables.<EClassTransitiveInstancesKey>filter(types, EClassTransitiveInstancesKey.class)), mergeWithSupertypes); return IterableExtensions.<IInputKey>toSet(Iterables.<IInputKey>concat(eClassTypes, Iterables.<IInputKey>concat(eDataTypes, eJavaTypes))); }
private void preprocessParameters(PatternModelAcceptor<?> acceptor) { for (Variable variable : pattern.getParameters()) { if (variable.getType() instanceof ClassType) { EClassifier classifier = ((ClassType) variable.getType()).getClassname(); IInputKey inputKey = typeSystem.classifierToInputKey(classifier); acceptor.acceptTypeConstraint(ImmutableList.of(variable.getName()), inputKey); } else if (variable.getType() instanceof JavaType) { JvmDeclaredType classRef = ((JavaType) variable.getType()).getClassRef(); IInputKey inputKey = new JavaTransitiveInstancesKey(classRef.getIdentifier()); acceptor.acceptTypeCheckConstraint(ImmutableList.of(variable.getName()), inputKey); } } acceptor.acceptExportedParameters(pattern.getParameters().stream().map(Variable::getName).collect(Collectors.toList())); }
JavaTransitiveInstancesKey _javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(_identifier); TypeJudgement _typeJudgement = new TypeJudgement(reference, _javaTransitiveInstancesKey); information.provideType(_typeJudgement); JavaTransitiveInstancesKey _javaTransitiveInstancesKey_1 = new JavaTransitiveInstancesKey(_identifier_1); ValueReference _get = callParameters.get(index); String _identifier_2 = parameterTypes.get(i).getIdentifier(); JavaTransitiveInstancesKey _javaTransitiveInstancesKey_2 = new JavaTransitiveInstancesKey(_identifier_2); ConditionalJudgement _conditionalJudgement = new ConditionalJudgement(reference, _javaTransitiveInstancesKey_1, _get, _javaTransitiveInstancesKey_2); information.provideType(_conditionalJudgement); ValueReference _get_1 = callParameters.get(index); String _identifier_3 = parameterTypes.get(i).getIdentifier(); JavaTransitiveInstancesKey _javaTransitiveInstancesKey_3 = new JavaTransitiveInstancesKey(_identifier_3); String _identifier_4 = returnTypes_1.get(i).getIdentifier(); JavaTransitiveInstancesKey _javaTransitiveInstancesKey_4 = new JavaTransitiveInstancesKey(_identifier_4); ConditionalJudgement _conditionalJudgement_1 = new ConditionalJudgement(_get_1, _javaTransitiveInstancesKey_3, reference, _javaTransitiveInstancesKey_4); information.provideType(_conditionalJudgement_1);
/** * @since 1.5 */ protected void _inferTypes(final NumberValue reference, final TypeInformation information) { if (((reference.getValue() != null) && (!reference.getValue().eIsProxy()))) { final Class<? extends Number> type = this.literals.getJavaType(reference.getValue()); JavaTransitiveInstancesKey _javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(type); TypeJudgement _typeJudgement = new TypeJudgement(reference, _javaTransitiveInstancesKey); information.provideType(_typeJudgement); } }