Examples with JCTree org.eclipse.ceylon.langtools.tools.javac.tree.JCTree used on opensource projects

Example 6 with JCTree

use of org.eclipse.ceylon.langtools.tools.javac.tree.JCTree in project ceylon by eclipse.

the class ExpressionTransformer method makeOptimizedInIntegerOrCharacterMeasure.

protected JCTree makeOptimizedInIntegerOrCharacterMeasure(Tree.InOp op, org.eclipse.ceylon.langtools.tools.javac.code.Type ceylonType, org.eclipse.ceylon.langtools.tools.javac.code.Type javaType) {
    Tree.SegmentOp rangeOp = (Tree.SegmentOp) op.getRightTerm();
    SyntheticName xName = naming.temp("x");
    SyntheticName yName = naming.temp("y");
    SyntheticName zName = naming.temp("z");
    SyntheticName wName = naming.temp("w");
    JCExpression x = transformExpression(op.getLeftTerm(), BoxingStrategy.UNBOXED, typeFact().getObjectType());
    JCExpression y = transformExpression(rangeOp.getLeftTerm(), BoxingStrategy.UNBOXED, rangeOp.getLeftTerm().getTypeModel());
    JCExpression z = transformExpression(rangeOp.getRightTerm(), BoxingStrategy.UNBOXED, rangeOp.getRightTerm().getTypeModel());
    JCExpression w = make().Apply(null, naming.makeSelect(make().QualIdent(ceylonType.tsym), "offset"), List.<JCExpression>of(xName.makeIdent(), yName.makeIdent()));
    return make().LetExpr(List.<JCStatement>of(makeVar(xName, make().Type(javaType), x), makeVar(yName, make().Type(javaType), y), makeVar(zName, make().Type(syms().longType), z), makeVar(wName, make().Type(syms().longType), w)), make().Binary(JCTree.Tag.AND, make().Binary(JCTree.Tag.GT, zName.makeIdent(), make().Literal(0L)), make().Binary(JCTree.Tag.AND, make().Binary(JCTree.Tag.LE, make().Literal(0L), wName.makeIdent()), make().Binary(JCTree.Tag.LT, wName.makeIdent(), zName.makeIdent()))));
}

Example 7 with JCTree

use of org.eclipse.ceylon.langtools.tools.javac.tree.JCTree in project ceylon by eclipse.

the class ExpressionTransformer method transform.

public JCTree transform(Tree.TypeLiteral expr) {
    at(expr);
    if (!expr.getWantsDeclaration()) {
        if (expr.getDeclaration() instanceof Constructor) {
            JCExpression classLiteral = makeTypeLiteralCall(expr.getType().getTypeModel().getQualifyingType(), false, expr.getTypeModel());
            TypeDeclaration classModelDeclaration = (TypeDeclaration) typeFact().getLanguageModuleModelDeclaration(expr.getType().getTypeModel().getQualifyingType().getDeclaration().isMember() ? "MemberClass" : "Class");
            JCTypeCast typeCast = make().TypeCast(makeJavaType(classModelDeclaration.appliedType(null, List.of(expr.getType().getTypeModel().getQualifyingType(), typeFact().getNothingType()))), classLiteral);
            Type callableType = expr.getTypeModel().getFullType();
            JCExpression reifiedArgumentsExpr = makeReifiedTypeArgument(typeFact().getCallableTuple(callableType));
            return make().Apply(null, naming.makeQualIdent(typeCast, "getConstructor"), List.<JCExpression>of(reifiedArgumentsExpr, make().Literal(expr.getDeclaration().getName())));
        } else {
            if (coerced) {
                Type t = expr.getType().getTypeModel();
                if (!typeFact().isJavaObjectArrayType(t) || t.getTypeArgumentList().get(0).isClassOrInterface()) {
                    return makeSelect(makeJavaType(t, JT_NO_PRIMITIVES | JT_RAW), "class");
                }
            }
            return makeTypeLiteralCall(expr.getType().getTypeModel(), true, expr.getTypeModel());
        }
    } else if (expr.getDeclaration() instanceof TypeParameter) {
        // we must get it from its container
        TypeParameter declaration = (TypeParameter) expr.getDeclaration();
        Node node = expr;
        return makeTypeParameterDeclaration(node, declaration);
    } else if (expr.getDeclaration() instanceof Constructor || expr instanceof Tree.NewLiteral) {
        Constructor ctor;
        if (expr.getDeclaration() instanceof Constructor) {
            ctor = (Constructor) expr.getDeclaration();
        } else {
            ctor = ((Class) expr.getDeclaration()).getDefaultConstructor();
        }
        JCExpression metamodelCall = makeTypeDeclarationLiteral(ModelUtil.getConstructedClass(ctor));
        metamodelCall = make().TypeCast(makeJavaType(typeFact().getClassDeclarationType(), JT_RAW), metamodelCall);
        metamodelCall = make().Apply(null, naming.makeQualIdent(metamodelCall, "getConstructorDeclaration"), List.<JCExpression>of(make().Literal(ctor.getName() == null ? "" : ctor.getName())));
        if (ModelUtil.isEnumeratedConstructor(ctor)) {
            metamodelCall = make().TypeCast(makeJavaType(typeFact().getValueConstructorDeclarationType(), JT_RAW), metamodelCall);
        } else /*else if (Decl.isDefaultConstructor(ctor)){
                metamodelCall = make().TypeCast(
                        makeJavaType(typeFact().getDefaultConstructorDeclarationType(), JT_RAW), metamodelCall);
            } */
        {
            metamodelCall = make().TypeCast(makeJavaType(typeFact().getCallableConstructorDeclarationType(), JT_RAW), metamodelCall);
        }
        return metamodelCall;
    } else if (expr.getDeclaration() instanceof ClassOrInterface || expr.getDeclaration() instanceof TypeAlias) {
        // use the generated class to get to the declaration literal
        JCExpression metamodelCall = makeTypeDeclarationLiteral((TypeDeclaration) expr.getDeclaration());
        Type exprType = expr.getTypeModel().resolveAliases();
        // now cast if required
        if (!exprType.isExactly(((TypeDeclaration) typeFact().getLanguageModuleDeclarationDeclaration("NestableDeclaration")).getType())) {
            JCExpression type = makeJavaType(exprType, JT_NO_PRIMITIVES);
            return make().TypeCast(type, metamodelCall);
        }
        return metamodelCall;
    } else {
        return makeErroneous(expr, "compiler bug: " + expr.getDeclaration() + " is an unsupported declaration type");
    }
}

Example 8 with JCTree

use of org.eclipse.ceylon.langtools.tools.javac.tree.JCTree in project ceylon by eclipse.

the class ExpressionTransformer method applyJavaCoercions.

private JCExpression applyJavaCoercions(JCExpression ret, Type exprType, Type expectedType) {
    if (expectedType == null)
        return ret;
    Type nonSimpleExprType = exprType;
    exprType = simplifyType(exprType);
    expectedType = simplifyType(expectedType);
    if (isCeylonString(exprType) && isJavaCharSequence(expectedType)) {
        // FIXME: only do this if boxed, or rather, do not box in the first place
        if (isOptional(nonSimpleExprType)) {
            Naming.SyntheticName varName = naming.temp();
            JCExpression test = make().Binary(JCTree.Tag.NE, varName.makeIdent(), makeNull());
            JCExpression convert = make().Apply(null, makeQualIdent(varName.makeIdent(), "toString"), List.<JCTree.JCExpression>nil());
            JCExpression cond = make().Conditional(test, convert, makeNull());
            JCExpression typeExpr = makeJavaType(typeFact().getObjectType());
            return makeLetExpr(varName, null, typeExpr, ret, cond);
        } else {
            return make().Apply(null, makeQualIdent(ret, "toString"), List.<JCTree.JCExpression>nil());
        }
    }
    // TODO: obsolete code?
    if (isJavaCharSequence(exprType) && expectedType.isExactly(typeFact().getStringDeclaration().getType())) {
        return make().Apply(null, makeQualIdent(ret, "toString"), List.<JCTree.JCExpression>nil());
    }
    // end of obsolete code
    if (isCeylonArray(exprType) && isJavaArray(expectedType)) {
        JCExpression result;
        if (isOptional(nonSimpleExprType)) {
            Naming.SyntheticName varName = naming.temp();
            JCExpression test = make().Binary(JCTree.Tag.NE, varName.makeIdent(), makeNull());
            JCExpression convert = make().Apply(null, makeQualIdent(varName.makeIdent(), "toArray"), List.<JCTree.JCExpression>nil());
            JCExpression cond = make().Conditional(test, convert, makeNull());
            JCExpression typeExpr = makeJavaType(typeFact().getObjectType());
            result = makeLetExpr(varName, null, typeExpr, ret, cond);
        } else {
            result = make().Apply(null, makeQualIdent(ret, "toArray"), List.<JCTree.JCExpression>nil());
        }
        JCExpression targetType = makeJavaType(expectedType, JT_NO_PRIMITIVES);
        return make().TypeCast(targetType, result);
    }
    if (isCeylonClassOrInterfaceModel(exprType) && isJavaClass(expectedType) && !(ret instanceof JCTree.JCFieldAccess && ret.toString().endsWith(".class"))) {
        // FIXME: perhaps cast as RAW?
        JCTree arg = ret;
        // into Util.classErasure(.org.eclipse.ceylon.compiler.java.test.interop.LambdasJava.class)
        while (arg instanceof JCTree.JCTypeCast) arg = ((JCTree.JCTypeCast) arg).getExpression();
        if (arg instanceof JCTree.JCMethodInvocation) {
            JCExpression methodSelect = ((JCTree.JCMethodInvocation) arg).getMethodSelect();
            if (methodSelect instanceof JCTree.JCFieldAccess) {
                JCTree.JCFieldAccess methodField = (JCTree.JCFieldAccess) methodSelect;
                if (methodField.getIdentifier().toString().equals("typeLiteral") && methodField.getExpression() instanceof JCTree.JCFieldAccess && ((JCTree.JCFieldAccess) methodField.getExpression()).toString().equals(".ceylon.language.meta.typeLiteral_")) {
                    JCExpression classLiteral = extractClassLiteralFromTypeDescriptor(((JCTree.JCMethodInvocation) arg).getArguments().get(0));
                    if (classLiteral != null)
                        // FIXME: pass type arg explicitly?
                        return utilInvocation().classErasure(classLiteral);
                }
            }
        }
        // make sure erasure doesn't get in the way of calling this method
        if (willEraseToObject(exprType))
            ret = make().TypeCast(makeJavaType(typeFact().getClassOrInterfaceModelType(typeFact().getObjectType())), ret);
        // FIXME: pass type arg explicitly?
        return utilInvocation().javaClassForModel(ret);
    }
    return ret;
}

Example 9 with JCTree

use of org.eclipse.ceylon.langtools.tools.javac.tree.JCTree in project ceylon by eclipse.

the class ExpressionTransformer method transform.

public JCTree transform(Tree.ObjectExpression expr) {
    at(expr);
    List<JCTree> klass = classGen().transformObjectExpression(expr);
    at(expr);
    JCExpression newCall = make().NewClass(null, null, makeUnquotedIdent(Naming.escapeClassName(expr.getAnonymousClass().getName()) + "_"), List.<JCTree.JCExpression>nil(), null);
    return make().LetExpr((List) klass, newCall);
}

Example 10 with JCTree

use of org.eclipse.ceylon.langtools.tools.javac.tree.JCTree in project ceylon by eclipse.

the class ExpressionTransformer method transformExpression.

JCExpression transformExpression(final Tree.Term expr, BoxingStrategy boxingStrategy, Type expectedType, int flags) {
    if (expr == null) {
        return null;
    }
    at(expr);
    if (inStatement && boxingStrategy != BoxingStrategy.INDIFFERENT) {
        // We're not directly inside the ExpressionStatement anymore
        inStatement = false;
    }
    // Cope with things like ((expr))
    // FIXME: shouldn't that be in the visitor?
    Tree.Term term = expr;
    while (term instanceof Tree.Expression) {
        term = ((Tree.Expression) term).getTerm();
    }
    JCExpression result;
    if (term instanceof Tree.IfExpression) {
        flags |= EXPR_IS_NOT_BASE_MEMBER;
    }
    CeylonVisitor v = gen().visitor;
    final ListBuffer<JCTree> prevDefs = v.defs;
    final boolean prevInInitializer = v.inInitializer;
    final ClassDefinitionBuilder prevClassBuilder = v.classBuilder;
    final Type prevExpectedType = this.expectedType;
    final boolean prevCoerced = this.coerced;
    try {
        v.defs = new ListBuffer<JCTree>();
        v.inInitializer = false;
        v.classBuilder = gen().current();
        this.expectedType = expectedType;
        this.coerced = (flags & EXPR_IS_COERCED) != 0;
        term.visit(v);
        if (v.hasResult()) {
            result = v.getSingleResult();
            if (result == null) {
                throw new BugException(term, "visitor yielded multiple results");
            }
        } else {
            throw new BugException(term, "visitor didn't yield any result");
        }
    } catch (BugException e) {
        result = e.makeErroneous(this, expr);
    } finally {
        v.classBuilder = prevClassBuilder;
        v.inInitializer = prevInInitializer;
        v.defs = prevDefs;
        this.coerced = prevCoerced;
        this.expectedType = prevExpectedType;
    }
    if ((flags & EXPR_TARGET_ACCEPTS_NULL) == 0 && expectedType != null && hasUncheckedNulls(expr) && expectedType.isSubtypeOf(typeFact().getObjectType()) && !knownNullSafe(term)) {
        result = utilInvocation().checkNull(result);
        flags |= EXPR_HAS_NULL_CHECK_FENCE;
    }
    result = applyErasureAndBoxing(result, expr, boxingStrategy, expectedType, flags);
    return result;
}