Examples with TypeReference org.eclipse.xtend.lib.macro.declaration.TypeReference used on opensource projects

Example 26 with TypeReference

use of org.eclipse.xtend.lib.macro.declaration.TypeReference in project xtext-xtend by eclipse.

the class AccessObjectProcessorTest method testWithPackage.

@Test
public void testWithPackage() {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("package my.pack");
    _builder.newLine();
    _builder.append("import org.eclipse.xtend.core.tests.macro.Accessors");
    _builder.newLine();
    _builder.newLine();
    _builder.append("@org.eclipse.xtend.core.tests.macro.AccessObjectAnn");
    _builder.newLine();
    _builder.append("class A {");
    _builder.newLine();
    _builder.append("\t");
    _builder.append("String field");
    _builder.newLine();
    _builder.append("}");
    _builder.newLine();
    final IAcceptor<XtendCompilerTester.CompilationResult> _function = (XtendCompilerTester.CompilationResult it) -> {
        final TransformationContext ctx = it.getTransformationContext();
        final MutableClassDeclaration classA = ctx.findClass("my.pack.A");
        Assert.assertNotNull(classA.findDeclaredMethod("getField"));
        final MutableClassDeclaration classPA = ctx.findClass("my.pack.PA");
        final Function1<TypeReference, Boolean> _function_1 = (TypeReference it_1) -> {
            Type _type = it_1.getType();
            Type _type_1 = ctx.newTypeReference(Serializable.class).getType();
            return Boolean.valueOf(Objects.equal(_type, _type_1));
        };
        Assert.assertNotNull(IterableExtensions.findFirst(classPA.getImplementedInterfaces(), _function_1));
        final MutableClassDeclaration classGA = ctx.findClass("my.pack.GA");
        final Function1<TypeReference, Boolean> _function_2 = (TypeReference it_1) -> {
            Type _type = it_1.getType();
            Type _type_1 = ctx.newTypeReference(Serializable.class).getType();
            return Boolean.valueOf(Objects.equal(_type, _type_1));
        };
        Assert.assertNotNull(IterableExtensions.findFirst(classGA.getImplementedInterfaces(), _function_2));
    };
    this._xtendCompilerTester.compile(_builder, _function);
}

Example 27 with TypeReference

use of org.eclipse.xtend.lib.macro.declaration.TypeReference in project xtext-xtend by eclipse.

the class CheckMutableClassDeclarationProcessor method doTransform.

@Override
public void doTransform(final MutableClassDeclaration annotatedClass, @Extension final TransformationContext context) {
    final Procedure0 _function = () -> {
        annotatedClass.setImplementedInterfaces(null);
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "superIntefaces cannot be null", _function);
    final Procedure0 _function_1 = () -> {
        annotatedClass.setImplementedInterfaces(Collections.<TypeReference>unmodifiableList(CollectionLiterals.<TypeReference>newArrayList((TypeReference) null)));
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "superIntefaces cannot contain null", _function_1);
    annotatedClass.setImplementedInterfaces(CollectionLiterals.<TypeReference>emptyList());
    final Procedure1<String> _function_2 = (String identifier) -> {
        annotatedClass.addTypeParameter(identifier).remove();
    };
    MutableAssert.assertValidJavaIdentifier("name", _function_2);
    final Procedure0 _function_3 = () -> {
        annotatedClass.addTypeParameter("T", ((TypeReference[]) null));
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "upperBounds cannot be null", _function_3);
    final Procedure0 _function_4 = () -> {
        annotatedClass.addTypeParameter("T", new TypeReference[] { null });
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "upperBounds cannot contain null", _function_4);
    final MutableTypeParameterDeclaration typeParameter = annotatedClass.addTypeParameter("T");
    final Procedure1<String> _function_5 = (String identifier) -> {
        typeParameter.setSimpleName(identifier);
    };
    MutableAssert.assertValidJavaIdentifier("name", _function_5);
    final Procedure0 _function_6 = () -> {
        typeParameter.setUpperBounds(null);
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "upperBounds cannot be null", _function_6);
    final Procedure0 _function_7 = () -> {
        typeParameter.setUpperBounds(Collections.<TypeReference>unmodifiableList(CollectionLiterals.<TypeReference>newArrayList((TypeReference) null)));
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "upperBounds cannot contain null", _function_7);
    typeParameter.setUpperBounds(CollectionLiterals.<TypeReference>emptyList());
    final Procedure0 _function_8 = () -> {
        annotatedClass.setSimpleName(null);
    };
    MutableAssert.<UnsupportedOperationException>assertThrowable(UnsupportedOperationException.class, "The type cannot be renamed.", _function_8);
    final Procedure1<String> _function_9 = (String identifier) -> {
        final Procedure1<MutableFieldDeclaration> _function_10 = (MutableFieldDeclaration it) -> {
            it.setType(context.newTypeReference(String.class));
        };
        annotatedClass.addField(identifier, _function_10).remove();
    };
    MutableAssert.assertValidJavaIdentifier("name", _function_9);
    final Procedure0 _function_10 = () -> {
        annotatedClass.addField("foo", null);
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "initializer cannot be null", _function_10);
    final Procedure1<String> _function_11 = (String identifier) -> {
        final Procedure1<MutableMethodDeclaration> _function_12 = (MutableMethodDeclaration it) -> {
        };
        annotatedClass.addMethod(identifier, _function_12).remove();
    };
    MutableAssert.assertValidJavaIdentifier("name", _function_11);
    final Procedure0 _function_12 = () -> {
        annotatedClass.addMethod("foo", null);
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "initializer cannot be null", _function_12);
    final Procedure0 _function_13 = () -> {
        annotatedClass.addConstructor(null);
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "initializer cannot be null", _function_13);
    final Procedure1<MutableMethodDeclaration> _function_14 = (MutableMethodDeclaration it) -> {
    };
    final MutableMethodDeclaration method = annotatedClass.addMethod("foo", _function_14);
    annotatedClass.findDeclaredMethod(null);
    annotatedClass.findDeclaredMethod("foo");
    final Procedure0 _function_15 = () -> {
        annotatedClass.findDeclaredMethod("foo", ((TypeReference[]) null));
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "parameterTypes cannot be null", _function_15);
    final Procedure0 _function_16 = () -> {
        annotatedClass.findDeclaredMethod("foo", new TypeReference[] { null });
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "parameterTypes cannot contain null", _function_16);
    annotatedClass.findDeclaredMethod("foo", ((TypeReference[]) Conversions.unwrapArray(CollectionLiterals.<TypeReference>emptyList(), TypeReference.class)));
    method.remove();
    final Procedure0 _function_17 = () -> {
        annotatedClass.findDeclaredConstructor(((TypeReference[]) null));
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "parameterTypes cannot be null", _function_17);
    final Procedure0 _function_18 = () -> {
        annotatedClass.findDeclaredConstructor(new TypeReference[] { null });
    };
    MutableAssert.<IllegalArgumentException>assertThrowable(IllegalArgumentException.class, "parameterTypes cannot contain null", _function_18);
    annotatedClass.findDeclaredConstructor(((TypeReference[]) Conversions.unwrapArray(CollectionLiterals.<TypeReference>emptyList(), TypeReference.class)));
}

Example 28 with TypeReference

use of org.eclipse.xtend.lib.macro.declaration.TypeReference in project xtext-xtend by eclipse.

the class ImmutableProcessor method doTransform.

@Override
public void doTransform(final List<? extends MutableClassDeclaration> annotatedTargetElements, @Extension final TransformationContext context) {
    for (final MutableClassDeclaration clazz : annotatedTargetElements) {
        {
            final Iterable<? extends MutableFieldDeclaration> fields = clazz.getDeclaredFields();
            final Procedure1<MutableConstructorDeclaration> _function = (MutableConstructorDeclaration it) -> {
                for (final MutableFieldDeclaration f : fields) {
                    {
                        f.markAsInitializedBy(it);
                        it.addParameter(f.getSimpleName(), f.getType());
                    }
                }
                final CompilationStrategy _function_1 = (CompilationStrategy.CompilationContext it_1) -> {
                    StringConcatenation _builder = new StringConcatenation();
                    {
                        for (final MutableFieldDeclaration f_1 : fields) {
                            _builder.append("this.");
                            String _simpleName = f_1.getSimpleName();
                            _builder.append(_simpleName);
                            _builder.append(" = ");
                            String _simpleName_1 = f_1.getSimpleName();
                            _builder.append(_simpleName_1);
                            _builder.append(";");
                            _builder.newLineIfNotEmpty();
                        }
                    }
                    return _builder;
                };
                it.setBody(_function_1);
            };
            clazz.addConstructor(_function);
            for (final MutableFieldDeclaration f : fields) {
                {
                    f.setFinal(true);
                    String _firstUpper = StringExtensions.toFirstUpper(f.getSimpleName());
                    final String getterName = ("get" + _firstUpper);
                    final Procedure1<MutableMethodDeclaration> _function_1 = (MutableMethodDeclaration it) -> {
                        f.markAsRead();
                        it.setReturnType(f.getType());
                        final CompilationStrategy _function_2 = (CompilationStrategy.CompilationContext it_1) -> {
                            StringConcatenation _builder = new StringConcatenation();
                            _builder.append("return ");
                            String _simpleName = f.getSimpleName();
                            _builder.append(_simpleName);
                            _builder.append(";");
                            _builder.newLineIfNotEmpty();
                            return _builder;
                        };
                        it.setBody(_function_2);
                    };
                    this.tryAddMethod(clazz, getterName, _function_1);
                }
            }
            final Procedure1<MutableMethodDeclaration> _function_1 = (MutableMethodDeclaration it) -> {
                it.setReturnType(context.getPrimitiveInt());
                it.addAnnotation(context.newAnnotationReference(Override.class));
                final CompilationStrategy _function_2 = (CompilationStrategy.CompilationContext it_1) -> {
                    StringConcatenation _builder = new StringConcatenation();
                    _builder.append("final int prime = 31;");
                    _builder.newLine();
                    {
                        boolean _extendsSomethingWithProperHashCode = this.getExtendsSomethingWithProperHashCode(clazz);
                        if (_extendsSomethingWithProperHashCode) {
                            _builder.append("int result = super.hashCode();");
                            _builder.newLine();
                        } else {
                            _builder.append("int result = 1;");
                            _builder.newLine();
                        }
                    }
                    {
                        for (final MutableFieldDeclaration f_1 : fields) {
                            {
                                TypeReference _type = f_1.getType();
                                TypeReference _primitiveBoolean = context.getPrimitiveBoolean();
                                boolean _equals = Objects.equal(_type, _primitiveBoolean);
                                if (_equals) {
                                    _builder.append("result = prime * result + (");
                                    String _simpleName = f_1.getSimpleName();
                                    _builder.append(_simpleName);
                                    _builder.append(" ? 1231 : 1237);");
                                    _builder.newLineIfNotEmpty();
                                } else {
                                    TypeReference _primitiveInt = context.getPrimitiveInt();
                                    TypeReference _primitiveChar = context.getPrimitiveChar();
                                    TypeReference _primitiveByte = context.getPrimitiveByte();
                                    TypeReference _primitiveShort = context.getPrimitiveShort();
                                    boolean _contains = Collections.<TypeReference>unmodifiableSet(CollectionLiterals.<TypeReference>newHashSet(_primitiveInt, _primitiveChar, _primitiveByte, _primitiveShort)).contains(f_1.getType());
                                    if (_contains) {
                                        _builder.append("result = prime * result + ");
                                        String _simpleName_1 = f_1.getSimpleName();
                                        _builder.append(_simpleName_1);
                                        _builder.append(";");
                                        _builder.newLineIfNotEmpty();
                                    } else {
                                        TypeReference _primitiveLong = context.getPrimitiveLong();
                                        TypeReference _type_1 = f_1.getType();
                                        boolean _equals_1 = Objects.equal(_primitiveLong, _type_1);
                                        if (_equals_1) {
                                            _builder.append("result = prime * result + (int) (");
                                            String _simpleName_2 = f_1.getSimpleName();
                                            _builder.append(_simpleName_2);
                                            _builder.append(" ^ (");
                                            String _simpleName_3 = f_1.getSimpleName();
                                            _builder.append(_simpleName_3);
                                            _builder.append(" >>> 32));");
                                            _builder.newLineIfNotEmpty();
                                        } else {
                                            TypeReference _primitiveFloat = context.getPrimitiveFloat();
                                            TypeReference _type_2 = f_1.getType();
                                            boolean _equals_2 = Objects.equal(_primitiveFloat, _type_2);
                                            if (_equals_2) {
                                                _builder.append("result = prime * result + Float.floatToIntBits(");
                                                String _simpleName_4 = f_1.getSimpleName();
                                                _builder.append(_simpleName_4);
                                                _builder.append(");");
                                                _builder.newLineIfNotEmpty();
                                            } else {
                                                TypeReference _primitiveDouble = context.getPrimitiveDouble();
                                                TypeReference _type_3 = f_1.getType();
                                                boolean _equals_3 = Objects.equal(_primitiveDouble, _type_3);
                                                if (_equals_3) {
                                                    _builder.append("result = prime * result + (int) (Double.doubleToLongBits(");
                                                    String _simpleName_5 = f_1.getSimpleName();
                                                    _builder.append(_simpleName_5);
                                                    _builder.append(") ^ (Double.doubleToLongBits(");
                                                    String _simpleName_6 = f_1.getSimpleName();
                                                    _builder.append(_simpleName_6);
                                                    _builder.append(") >>> 32));");
                                                    _builder.newLineIfNotEmpty();
                                                } else {
                                                    _builder.append("result = prime * result + ((");
                                                    String _simpleName_7 = f_1.getSimpleName();
                                                    _builder.append(_simpleName_7);
                                                    _builder.append("== null) ? 0 : ");
                                                    String _simpleName_8 = f_1.getSimpleName();
                                                    _builder.append(_simpleName_8);
                                                    _builder.append(".hashCode());");
                                                    _builder.newLineIfNotEmpty();
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _builder.append("return result;");
                    _builder.newLine();
                    return _builder;
                };
                it.setBody(_function_2);
            };
            this.tryAddMethod(clazz, "hashCode", _function_1);
        }
    }
}

Example 29 with TypeReference

use of org.eclipse.xtend.lib.macro.declaration.TypeReference in project xtext-xtend by eclipse.

the class TypeReferenceAssignabilityTest method isAssignableFrom.

@Override
public void isAssignableFrom(final Pair<String, String> lhsAndParams, final String rhs, final boolean expectation) {
    try {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("def ");
        {
            boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(lhsAndParams.getValue());
            boolean _not = (!_isNullOrEmpty);
            if (_not) {
                _builder.append("<");
                String _value = lhsAndParams.getValue();
                _builder.append(_value);
                _builder.append("> ");
            }
        }
        _builder.append("void method(");
        String _fixup = this.fixup(lhsAndParams.getKey());
        _builder.append(_fixup);
        _builder.append(" lhs, ");
        String _fixup_1 = this.fixup(rhs);
        _builder.append(_fixup_1);
        _builder.append(" rhs) {}");
        final String signature = _builder.toString();
        final XtendFunction function = this.function(signature.toString());
        final JvmOperation operation = this._iXtendJvmAssociations.getDirectlyInferredOperation(function);
        EObject _rootContainer = EcoreUtil.getRootContainer(function);
        final XtendFile xtendFile = ((XtendFile) _rootContainer);
        final Procedure1<CompilationUnitImpl> _function = (CompilationUnitImpl it) -> {
            TypeReference _xifexpression = null;
            String _key = lhsAndParams.getKey();
            boolean _tripleNotEquals = (_key != null);
            if (_tripleNotEquals) {
                _xifexpression = it.toTypeReference(IterableExtensions.<JvmFormalParameter>head(operation.getParameters()).getParameterType());
            } else {
                _xifexpression = it.toTypeReference(this.getOwner().newAnyTypeReference());
            }
            final TypeReference lhsType = _xifexpression;
            TypeReference _xifexpression_1 = null;
            if ((rhs != null)) {
                _xifexpression_1 = it.toTypeReference(IterableExtensions.<JvmFormalParameter>last(operation.getParameters()).getParameterType());
            } else {
                _xifexpression_1 = it.toTypeReference(this.getOwner().newAnyTypeReference());
            }
            final TypeReference rhsType = _xifexpression_1;
            String _simpleName = lhsType.getSimpleName();
            String _plus = (_simpleName + " := ");
            String _simpleName_1 = rhsType.getSimpleName();
            String _plus_1 = (_plus + _simpleName_1);
            Assert.assertEquals(_plus_1, Boolean.valueOf(expectation), Boolean.valueOf(this.testIsAssignable(it, lhsType, rhsType)));
            if (expectation) {
                Iterable<? extends TypeReference> _declaredSuperTypes = lhsType.getDeclaredSuperTypes();
                for (final TypeReference superType : _declaredSuperTypes) {
                    if (((superType.isArray() == lhsType.isArray()) || (lhsType.isArray() == rhsType.isArray()))) {
                        Assert.assertEquals(superType.toString(), Boolean.valueOf(expectation), Boolean.valueOf(this.testIsAssignable(it, superType, rhsType)));
                    }
                }
            }
        };
        this.asCompilationUnit(xtendFile, _function);
    } catch (Throwable _e) {
        throw Exceptions.sneakyThrow(_e);
    }
}

Example 30 with TypeReference

use of org.eclipse.xtend.lib.macro.declaration.TypeReference in project xtext-xtend by eclipse.

the class DeclarationsTest method testSetImplementedInterfaces.

@Test
public void testSetImplementedInterfaces() {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("class BaseClass {}");
    _builder.newLine();
    _builder.append("interface Interface {}");
    _builder.newLine();
    final Procedure1<CompilationUnitImpl> _function = (CompilationUnitImpl it) -> {
        final MutableClassDeclaration baseClass = it.getTypeLookup().findClass("BaseClass");
        final MutableInterfaceDeclaration interf = it.getTypeLookup().findInterface("Interface");
        final TypeReference objectType = baseClass.getExtendedClass();
        Assert.assertEquals("Object", objectType.getSimpleName());
        Assert.assertTrue(IterableExtensions.isEmpty(baseClass.getImplementedInterfaces()));
        final TypeReference superType = it.getTypeReferenceProvider().newTypeReference(AccessibleObject.class);
        baseClass.setExtendedClass(superType);
        Assert.assertEquals("AccessibleObject", baseClass.getExtendedClass().getSimpleName());
        Assert.assertTrue(IterableExtensions.isEmpty(baseClass.getImplementedInterfaces()));
        baseClass.setExtendedClass(null);
        Assert.assertEquals("Object", baseClass.getExtendedClass().getSimpleName());
        Assert.assertTrue(IterableExtensions.isEmpty(baseClass.getImplementedInterfaces()));
        TypeReference _newTypeReference = it.getTypeReferenceProvider().newTypeReference(interf);
        baseClass.setImplementedInterfaces(Collections.<TypeReference>unmodifiableList(CollectionLiterals.<TypeReference>newArrayList(_newTypeReference)));
        Assert.assertEquals("Interface", IterableExtensions.head(baseClass.getImplementedInterfaces()).getSimpleName());
        baseClass.setImplementedInterfaces(Collections.<TypeReference>unmodifiableList(CollectionLiterals.<TypeReference>newArrayList()));
        Assert.assertTrue(IterableExtensions.isEmpty(baseClass.getImplementedInterfaces()));
    };
    this.asCompilationUnit(this.validFile(_builder), _function);
}