Examples with LightweightTypeReference org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference used on opensource projects

Example 66 with LightweightTypeReference

use of org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference in project xtext-xtend by eclipse.

the class BoundTypeArgumentMergerTest method mergeWithSource.

public LightweightMergedBoundTypeArgument mergeWithSource(final Object source, final Triple<String, VarianceInfo, VarianceInfo>... mergeUs) {
    try {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("def void method(");
        final Function1<Triple<String, VarianceInfo, VarianceInfo>, CharSequence> _function = (Triple<String, VarianceInfo, VarianceInfo> it) -> {
            return it.getFirst();
        };
        String _join = IterableExtensions.<Triple<String, VarianceInfo, VarianceInfo>>join(((Iterable<Triple<String, VarianceInfo, VarianceInfo>>) Conversions.doWrapArray(mergeUs)), null, " p, ", " p", _function);
        _builder.append(_join);
        _builder.append(") {}");
        final String signature = _builder.toString();
        final XtendFunction function = this.function(signature.toString());
        final JvmOperation operation = this._iXtendJvmAssociations.getDirectlyInferredOperation(function);
        final ArrayList<LightweightBoundTypeArgument> mergable = CollectionLiterals.<LightweightBoundTypeArgument>newArrayList();
        final Procedure2<JvmFormalParameter, Integer> _function_1 = (JvmFormalParameter p, Integer i) -> {
            final Triple<String, VarianceInfo, VarianceInfo> input = mergeUs[(i).intValue()];
            LightweightTypeReference _lightweightTypeReference = this.toLightweightTypeReference(p.getParameterType());
            Object _elvis = null;
            if (source != null) {
                _elvis = source;
            } else {
                Object _object = new Object();
                _elvis = _object;
            }
            VarianceInfo _second = input.getSecond();
            VarianceInfo _third = input.getThird();
            LightweightBoundTypeArgument _lightweightBoundTypeArgument = new LightweightBoundTypeArgument(_lightweightTypeReference, null, _elvis, _second, _third);
            mergable.add(_lightweightBoundTypeArgument);
        };
        IterableExtensions.<JvmFormalParameter>forEach(operation.getParameters(), _function_1);
        return this.merger.merge(mergable, this.getOwner());
    } catch (Throwable _e) {
        throw Exceptions.sneakyThrow(_e);
    }
}

Example 67 with LightweightTypeReference

use of org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference in project xtext-xtend by eclipse.

the class CommonSuperTypeTest method getEquivalent.

public String getEquivalent(final ParameterizedTypeReference type) {
    boolean _isEmpty = type.getTypeArguments().isEmpty();
    if (_isEmpty) {
        return type.getType().getSimpleName();
    }
    StringConcatenation _builder = new StringConcatenation();
    String _simpleName = type.getType().getSimpleName();
    _builder.append(_simpleName);
    _builder.append("<");
    final Function1<LightweightTypeReference, CharSequence> _function = (LightweightTypeReference it) -> {
        return it.getSimpleName();
    };
    String _join = IterableExtensions.<LightweightTypeReference>join(type.getTypeArguments(), ", ", _function);
    _builder.append(_join);
    _builder.append(">");
    return _builder.toString();
}

Example 68 with LightweightTypeReference

use of org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference in project xtext-xtend by eclipse.

the class CommonSuperTypeTest method isSuperTypeOf.

public Object isSuperTypeOf(final Pair<String, String> superTypeAndParam, final String... types) {
    try {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("def ");
        {
            boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(superTypeAndParam.getValue());
            boolean _not = (!_isNullOrEmpty);
            if (_not) {
                _builder.append("<");
                String _value = superTypeAndParam.getValue();
                _builder.append(_value);
                _builder.append("> ");
            }
        }
        _builder.append("void method(");
        {
            boolean _hasElements = false;
            for (final String type : types) {
                if (!_hasElements) {
                    _hasElements = true;
                } else {
                    _builder.appendImmediate(", ", "");
                }
                String _fixup = this.fixup(type);
                _builder.append(_fixup);
                _builder.append(" t");
            }
        }
        _builder.append(") {}");
        final String signature = _builder.toString();
        final XtendFunction function = this.function(signature.toString());
        final JvmOperation operation = this._iXtendJvmAssociations.getDirectlyInferredOperation(function);
        final Function1<JvmFormalParameter, LightweightTypeReference> _function = (JvmFormalParameter it) -> {
            return this.toLightweightTypeReference(it.getParameterType());
        };
        List<LightweightTypeReference> _map = ListExtensions.<JvmFormalParameter, LightweightTypeReference>map(operation.getParameters(), _function);
        final ArrayList<LightweightTypeReference> typeReferences = new ArrayList<LightweightTypeReference>(_map);
        final TypeConformanceComputer conformanceComputer = this.getServices().getTypeConformanceComputer();
        LightweightTypeReference computedSuperType = conformanceComputer.getCommonSuperType(typeReferences, this.getOwner());
        String _simpleName = null;
        if (computedSuperType != null) {
            _simpleName = computedSuperType.getSimpleName();
        }
        Assert.assertEquals(superTypeAndParam.getKey(), _simpleName);
        computedSuperType = this.getServices().getTypeConformanceComputer().getCommonSuperType(IterableExtensions.<LightweightTypeReference>toList(Iterables.<LightweightTypeReference>concat(typeReferences, typeReferences)), this.getOwner());
        String _simpleName_1 = null;
        if (computedSuperType != null) {
            _simpleName_1 = computedSuperType.getSimpleName();
        }
        Assert.assertEquals(superTypeAndParam.getKey(), _simpleName_1);
        computedSuperType = this.getServices().getTypeConformanceComputer().getCommonSuperType(ListExtensions.<LightweightTypeReference>reverseView(typeReferences), this.getOwner());
        String _simpleName_2 = null;
        if (computedSuperType != null) {
            _simpleName_2 = computedSuperType.getSimpleName();
        }
        Assert.assertEquals(superTypeAndParam.getKey(), _simpleName_2);
        boolean _isPrimitiveOrVoid = this.isPrimitiveOrVoid(computedSuperType);
        boolean _not_1 = (!_isPrimitiveOrVoid);
        if (_not_1) {
            List<AnyTypeReference> _newImmutableList = CollectionLiterals.<AnyTypeReference>newImmutableList(this.getOwner().newAnyTypeReference(), this.getOwner().newAnyTypeReference());
            computedSuperType = this.getServices().getTypeConformanceComputer().getCommonSuperType(IterableExtensions.<LightweightTypeReference>toList(Iterables.<LightweightTypeReference>concat(typeReferences, _newImmutableList)), this.getOwner());
            String _simpleName_3 = null;
            if (computedSuperType != null) {
                _simpleName_3 = computedSuperType.getSimpleName();
            }
            Assert.assertEquals(superTypeAndParam.getKey(), _simpleName_3);
        }
        if ((computedSuperType != null)) {
            final Procedure1<LightweightTypeReference> _function_1 = (LightweightTypeReference superType) -> {
                final Consumer<LightweightTypeReference> _function_2 = (LightweightTypeReference it) -> {
                    LightweightTypeReference _commonSuperType = conformanceComputer.getCommonSuperType(Collections.<LightweightTypeReference>unmodifiableList(CollectionLiterals.<LightweightTypeReference>newArrayList(it, superType)), superType.getOwner());
                    String _simpleName_4 = null;
                    if (_commonSuperType != null) {
                        _simpleName_4 = _commonSuperType.getSimpleName();
                    }
                    Assert.assertEquals(superTypeAndParam.getKey(), _simpleName_4);
                };
                typeReferences.forEach(_function_2);
            };
            ObjectExtensions.<LightweightTypeReference>operator_doubleArrow(computedSuperType, _function_1);
        }
        if ((computedSuperType != null)) {
            for (final LightweightTypeReference subType : typeReferences) {
                Assert.assertTrue(computedSuperType.isAssignableFrom(subType));
            }
        }
        return computedSuperType;
    } catch (Throwable _e) {
        throw Exceptions.sneakyThrow(_e);
    }
}

Example 69 with LightweightTypeReference

use of org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference in project xtext-xtend by eclipse.

the class DeferredTypeParameterHintCollectorTest method in.

public Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> in(final String typeParameters, final String expectedType, final String actualType) {
    final JvmOperation operation = this.operation(typeParameters, expectedType, actualType);
    ITypeReferenceOwner _owner = this.getOwner();
    final DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(_owner);
    final DefaultReentrantTypeResolver resolver = this.resolverProvider.get();
    resolver.initializeFrom(EcoreUtil.getRootContainer(operation));
    ITypeReferenceOwner _owner_1 = this.getOwner();
    PublicResolvedTypes _publicResolvedTypes = new PublicResolvedTypes(resolver);
    final MockTypeParameterSubstitutor substitutor = new MockTypeParameterSubstitutor(_owner_1, _publicResolvedTypes);
    final LightweightTypeReference hasUnbounds = substitutor.substitute(this.toLightweightTypeReference(IterableExtensions.<JvmFormalParameter>head(operation.getParameters()).getParameterType()));
    final LightweightTypeReference isActual = this.toLightweightTypeReference(IterableExtensions.<JvmFormalParameter>last(operation.getParameters()).getParameterType());
    collector.processPairedReferences(hasUnbounds, isActual);
    return substitutor.getTypeParameterMapping();
}

Example 70 with LightweightTypeReference

use of org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference in project xtext-xtend by eclipse.

the class DeferredTypeParameterHintCollectorTest method hasNoHintsFor.

public void hasNoHintsFor(final Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> mapping, final String typeParamName) {
    final Set<JvmTypeParameter> allKeys = mapping.keySet();
    for (final JvmTypeParameter key : allKeys) {
        String _simpleName = key.getSimpleName();
        boolean _equals = Objects.equal(_simpleName, typeParamName);
        if (_equals) {
            LightweightTypeReference _typeReference = mapping.get(key).getTypeReference();
            final UnboundTypeReference unbound = ((UnboundTypeReference) _typeReference);
            boolean _isEmpty = unbound.getAllHints().isEmpty();
            boolean _not = (!_isEmpty);
            if (_not) {
                StringConcatenation _builder = new StringConcatenation();
                _builder.append("Unexpected mapping for ");
                _builder.append(typeParamName);
                _builder.append(" in ");
                final Function1<JvmTypeParameter, String> _function = (JvmTypeParameter it) -> {
                    return it.getSimpleName();
                };
                Iterable<String> _map = IterableExtensions.<JvmTypeParameter, String>map(mapping.keySet(), _function);
                _builder.append(_map);
                Assert.fail(_builder.toString());
            }
        }
    }
}