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()); } }
protected void _inferTypes(final StringValue reference, final TypeInformation information) { JavaTransitiveInstancesKey _javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(String.class); TypeJudgement _typeJudgement = new TypeJudgement(reference, _javaTransitiveInstancesKey); information.provideType(_typeJudgement); }
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); }
/** * @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))); }
@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(); }
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 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 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)));
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); } }
/** * @since 1.3 */ @Override public IInputKey getDeclaredType(Expression ex) { if (ex instanceof ParameterRef) { Type type = ((ParameterRef) ex).getReferredParam().getType(); if (typeSystem.isValidType(type)) { return typeSystem.extractTypeDescriptor(type); } } else if (ex instanceof Variable) { final Type type = ((Variable)ex).getType(); if (typeSystem.isValidType(type)) { return typeSystem.extractTypeDescriptor(type); } } else if (ex instanceof AggregatedValue) { List<JvmType> returnTypes = AggregatorUtil.getReturnTypes(((AggregatedValue) ex).getAggregator()); if (returnTypes.size() == 1) { JvmType jvmType = returnTypes.get(0); return new JavaTransitiveInstancesKey(jvmType.getIdentifier()); } } return null; }