Examples with SyntheticName org.eclipse.ceylon.compiler.java.codegen.Naming.SyntheticName used on opensource projects

Example 16 with SyntheticName

use of org.eclipse.ceylon.compiler.java.codegen.Naming.SyntheticName in project ceylon by eclipse.

the class ExpressionTransformer method transformSpreadTupleArgument.

private List<ExpressionAndType> transformSpreadTupleArgument(SimpleInvocation invocation, CallBuilder callBuilder, List<ExpressionAndType> result, final int argIndex) {
    BoxingStrategy boxingStrategy;
    // Spread tuple Argument
    // invoking f(*args), where declared f(A a, B a) (last param not sequenced)
    final Tree.Expression tupleArgument = invocation.getArgumentExpression(argIndex);
    final int minimumTupleArguments = typeFact().getTupleMinimumLength(tupleArgument.getTypeModel());
    final boolean tupleUnbounded = typeFact().isTupleLengthUnbounded(tupleArgument.getTypeModel());
    final Type callableType = invocation.getPrimary().getTypeModel().getFullType();
    // Only evaluate the tuple expr once
    SyntheticName tupleAlias = naming.alias("tuple");
    JCExpression tupleType;
    JCExpression tupleExpr = transformExpression(tupleArgument, BoxingStrategy.BOXED, null);
    tupleType = makeJavaType(typeFact().getSequentialDeclaration().getType(), JT_RAW);
    if (typeFact().isIterableType(tupleArgument.getTypeModel())) {
        tupleExpr = make().TypeCast(makeJavaType(typeFact().getSequentialDeclaration().getType(), JT_RAW), tupleExpr);
    } else if (typeFact().isJavaIterableType(tupleArgument.getTypeModel())) {
        // need to convert j.l.Iterable to a c.l.Iterable
        Type iteratedType = typeFact().getJavaIteratedType(tupleArgument.getTypeModel());
        tupleExpr = utilInvocation().toIterable(makeJavaType(iteratedType, JT_TYPE_ARGUMENT), makeReifiedTypeArgument(iteratedType), tupleExpr);
        tupleExpr = make().Apply(null, makeSelect(tupleExpr, "sequence"), List.<JCExpression>nil());
    } else if (typeFact().isJavaArrayType(tupleArgument.getTypeModel())) {
        Type iteratedType = typeFact().getJavaArrayElementType(tupleArgument.getTypeModel());
        if (typeFact().isJavaObjectArrayType(tupleArgument.getTypeModel())) {
            tupleExpr = utilInvocation().toIterable(makeJavaType(iteratedType, JT_TYPE_ARGUMENT), makeReifiedTypeArgument(iteratedType), tupleExpr);
        } else {
            // primitive
            tupleExpr = utilInvocation().toIterable(tupleExpr);
        }
        tupleExpr = make().Apply(null, makeSelect(tupleExpr, "sequence"), List.<JCExpression>nil());
    } else {
        throw BugException.unhandledTypeCase(tupleArgument.getTypeModel());
    }
    callBuilder.appendStatement(makeVar(tupleAlias, tupleType, tupleExpr));
    if (callBuilder.getArgumentHandling() == 0) {
        // XXX Hack: Only do this if we're not already doing
        // something funky with arguments e.g. SpreadOp
        callBuilder.argumentHandling(CallBuilder.CB_LET, naming.alias("spreadarg"));
    }
    callBuilder.voidMethod(invocation.getReturnType() == null || Decl.isUnboxedVoid(invocation.getPrimaryDeclaration()) || isWithinSuperInvocation());
    /* Cases:
            *[] -> () => nothing
            *[] -> (Integer=) => nothing
            *[] -> (Integer*) => nothing
            *[Integer] -> (Integer) => extract
            *[Integer] -> (Integer=) => extract
            *[Integer] -> (Integer*) => pass the tuple as-is
            *[Integer*] -> (Integer*) => pass the tuple as-is
            *[Integer+] -> (Integer*) => pass the tuple as-is
            *[Integer] -> (Integer, Integer*) => extract and drop the tuple
            *[Integer,Integer] -> (Integer, Integer) => extract
            *[Integer,Integer] -> (Integer=, Integer=) => extract
            *[Integer,Integer] -> (Integer, Integer*) => extract and pass the tuple rest
            *[Integer,Integer*] -> (Integer, Integer*) => extract and pass the tuple rest
            *[Integer,Integer+] -> (Integer, Integer*) => extract and pass the tuple rest
        */
    int spreadArgIndex = argIndex;
    final int maxParameters = getNumParametersOfCallable(callableType);
    boolean variadic = maxParameters > 0 && invocation.isParameterSequenced(maxParameters - 1);
    // we extract from the tuple not more than we have tuple members, but even less than that if we don't
    // have enough parameters to put them in
    final int argumentsToExtract = Math.min(argIndex + minimumTupleArguments, variadic ? maxParameters - 1 : maxParameters);
    for (; spreadArgIndex < argumentsToExtract; spreadArgIndex++) {
        boxingStrategy = invocation.getParameterBoxingStrategy(spreadArgIndex);
        Type paramType = getParameterTypeOfCallable(callableType, spreadArgIndex);
        JCExpression tupleIndex = boxType(make().Literal((long) spreadArgIndex - argIndex), typeFact().getIntegerType());
        JCExpression tupleElement = make().Apply(null, naming.makeQualIdent(tupleAlias.makeIdent(), "get"), List.<JCExpression>of(tupleIndex));
        tupleElement = applyErasureAndBoxing(tupleElement, typeFact().getAnythingType(), true, boxingStrategy, paramType);
        JCExpression argType = makeJavaType(paramType, boxingStrategy == BoxingStrategy.BOXED ? JT_NO_PRIMITIVES : 0);
        result = result.append(new ExpressionAndType(tupleElement, argType));
    }
    // - OR the tuple is bounded but we did not pass them all
    if (variadic && (tupleUnbounded || argumentsToExtract < (minimumTupleArguments + argIndex))) {
        boxingStrategy = invocation.getParameterBoxingStrategy(spreadArgIndex);
        Type paramType = getParameterTypeOfCallable(callableType, spreadArgIndex);
        JCExpression tupleElement = tupleAlias.makeIdent();
        // argIndex = 0, tuple = [Integer+], params = [Integer, Integer*], spreadArgIndex = 1 => spanFrom(1)
        if (spreadArgIndex - argIndex > 0) {
            JCExpression tupleIndex = boxType(make().Literal((long) spreadArgIndex - argIndex), typeFact().getIntegerType());
            tupleElement = make().Apply(null, naming.makeQualIdent(tupleElement, "spanFrom"), List.<JCExpression>of(tupleIndex));
        }
        tupleElement = applyErasureAndBoxing(tupleElement, typeFact().getAnythingDeclaration().getType(), true, boxingStrategy, paramType);
        JCExpression argType = makeJavaType(paramType, boxingStrategy == BoxingStrategy.BOXED ? JT_NO_PRIMITIVES : 0);
        JCExpression expr;
        if (invocation.isJavaVariadicMethod()) {
            // no need to handle leading arguments since that is handled by transformSpreadArgument
            // if ever we have leading arguments we never end up in this method
            expr = sequenceToJavaArray(invocation, tupleElement, paramType, boxingStrategy, paramType, List.<JCExpression>nil());
        } else {
            expr = tupleElement;
        }
        result = result.append(new ExpressionAndType(expr, argType));
    } else if (variadic && invocation.isIndirect() && argumentsToExtract >= minimumTupleArguments && !tupleUnbounded) {
        result = result.append(new ExpressionAndType(makeEmptyAsSequential(true), makeJavaType(typeFact().getSequenceType(typeFact().getAnythingDeclaration().getType()), JT_RAW)));
    } else if (!variadic && tupleUnbounded && !invocation.isIndirect()) {
        result = result.append(new ExpressionAndType(tupleAlias.makeIdent(), tupleType));
    }
    return result;
}

Example 17 with SyntheticName

use of org.eclipse.ceylon.compiler.java.codegen.Naming.SyntheticName in project ceylon by eclipse.

the class ExpressionTransformer method transformOptimizedIntegerPower.

private JCExpression transformOptimizedIntegerPower(Tree.Term base, Number power_) {
    JCExpression baseExpr = transformExpression(base, BoxingStrategy.UNBOXED, base.getTypeModel());
    long power = power_.longValue();
    if (power == 1) {
        return baseExpr;
    }
    SyntheticName baseAlias = naming.alias("base");
    JCExpression multiplications = baseAlias.makeIdent();
    while (power > 1) {
        power--;
        multiplications = make().Binary(JCTree.Tag.MUL, multiplications, baseAlias.makeIdent());
    }
    return make().LetExpr(makeVar(baseAlias, makeJavaType(base.getTypeModel()), baseExpr), multiplications);
}

Example 18 with SyntheticName

use of org.eclipse.ceylon.compiler.java.codegen.Naming.SyntheticName in project ceylon by eclipse.

the class ClassTransformer method transformAnnotationClassConstructor.

/**
 * Generates a constructor for an annotation class which takes the
 * annotation type as parameter.
 * @param classBuilder
 */
private void transformAnnotationClassConstructor(Tree.AnyClass def, ClassDefinitionBuilder classBuilder) {
    Class klass = def.getDeclarationModel();
    MethodDefinitionBuilder annoCtor = classBuilder.addConstructor(klass.isDeprecated());
    annoCtor.ignoreModelAnnotations();
    // constructors are never final
    annoCtor.modifiers(modifierTransformation().classFlags(klass) & ~FINAL);
    ParameterDefinitionBuilder pdb = ParameterDefinitionBuilder.systemParameter(this, "anno");
    pdb.type(new TransformedType(makeJavaType(klass.getType(), JT_ANNOTATION), null, makeAtNonNull()));
    annoCtor.parameter(pdb);
    // It's up to the caller to invoke value() on the Java annotation for a sequenced
    // annotation
    ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
    for (Tree.Parameter parameter : def.getParameterList().getParameters()) {
        at(parameter);
        Parameter parameterModel = parameter.getParameterModel();
        JCExpression annoAttr = make().Apply(null, naming.makeQuotedQualIdent(naming.makeUnquotedIdent("anno"), parameter.getParameterModel().getName()), List.<JCExpression>nil());
        Type parameterType = parameterModel.getType();
        JCExpression argExpr;
        if (typeFact().isIterableType(parameterType) && !isCeylonString(parameterType)) {
            // Convert from array to Sequential
            Type iteratedType = typeFact().getIteratedType(parameterType);
            boolean nonEmpty = typeFact().isNonemptyIterableType(parameterType);
            if (isCeylonBasicType(iteratedType)) {
                argExpr = utilInvocation().sequentialWrapperBoxed(annoAttr);
            } else if (Decl.isAnnotationClass(iteratedType.getDeclaration())) {
                // Can't use Util.sequentialAnnotation becase we need to 'box'
                // the Java annotations in their Ceylon annotation class
                argExpr = make().Apply(null, naming.makeUnquotedIdent(naming.getAnnotationSequenceMethodName()), List.of(annoAttr));
                ListBuffer<JCStatement> stmts = new ListBuffer<JCStatement>();
                SyntheticName array = naming.synthetic(Unfix.$array$);
                SyntheticName sb = naming.synthetic(Unfix.$sb$);
                SyntheticName index = naming.synthetic(Unfix.$index$);
                SyntheticName element = naming.synthetic(Unfix.$element$);
                stmts.append(makeVar(FINAL, sb, make().TypeArray(make().Type(syms().objectType)), make().NewArray(make().Type(syms().objectType), List.of(naming.makeQualIdent(array.makeIdent(), "length")), null)));
                stmts.append(makeVar(index, make().Type(syms().intType), make().Literal(0)));
                stmts.append(make().ForeachLoop(makeVar(element, makeJavaType(iteratedType, JT_ANNOTATION), null), array.makeIdent(), make().Exec(make().Assign(make().Indexed(sb.makeIdent(), make().Unary(JCTree.Tag.POSTINC, index.makeIdent())), instantiateAnnotationClass(iteratedType, element.makeIdent())))));
                stmts.append(make().Return(make().NewClass(null, null, make().QualIdent(syms().ceylonTupleType.tsym), List.of(makeReifiedTypeArgument(iteratedType), sb.makeIdent(), makeEmpty(), make().Literal(false)), null)));
                classBuilder.method(MethodDefinitionBuilder.systemMethod(this, naming.getAnnotationSequenceMethodName()).ignoreModelAnnotations().modifiers(PRIVATE | STATIC).resultType(new TransformedType(makeJavaType(typeFact().getSequentialType(iteratedType)), null, makeAtNonNull())).parameter(ParameterDefinitionBuilder.systemParameter(this, array.getName()).type(new TransformedType(make().TypeArray(makeJavaType(iteratedType, JT_ANNOTATION))))).body(stmts.toList()));
            } else if (isCeylonMetamodelDeclaration(iteratedType)) {
                argExpr = makeMetamodelInvocation("parseMetamodelReferences", List.<JCExpression>of(makeReifiedTypeArgument(iteratedType), annoAttr), List.<JCExpression>of(makeJavaType(iteratedType, JT_TYPE_ARGUMENT)));
            } else if (Decl.isEnumeratedTypeWithAnonCases(iteratedType)) {
                argExpr = makeMetamodelInvocation("parseEnumerationReferences", List.<JCExpression>of(makeReifiedTypeArgument(iteratedType), annoAttr), List.<JCExpression>of(makeJavaType(iteratedType, JT_TYPE_ARGUMENT)));
            } else {
                argExpr = makeErroneous(parameter, "compiler bug");
            }
            if (nonEmpty) {
                argExpr = make().TypeCast(makeJavaType(parameterType), argExpr);
            }
        } else if (Decl.isAnnotationClass(parameterType.getDeclaration())) {
            argExpr = instantiateAnnotationClass(parameterType, annoAttr);
        } else if (isCeylonMetamodelDeclaration(parameterType)) {
            argExpr = makeMetamodelInvocation("parseMetamodelReference", List.<JCExpression>of(annoAttr), List.<JCExpression>of(makeJavaType(parameterType, JT_TYPE_ARGUMENT)));
        } else if (Decl.isEnumeratedTypeWithAnonCases(parameterType)) {
            argExpr = makeMetamodelInvocation("parseEnumerationReference", List.<JCExpression>of(annoAttr), null);
        } else {
            argExpr = annoAttr;
            argExpr = expressionGen().applyErasureAndBoxing(annoAttr, parameterType.withoutUnderlyingType(), false, BoxingStrategy.UNBOXED, parameterType);
        }
        args.add(argExpr);
    }
    annoCtor.body(at(def).Exec(make().Apply(null, naming.makeThis(), args.toList())));
}

Example 19 with SyntheticName

use of org.eclipse.ceylon.compiler.java.codegen.Naming.SyntheticName in project ceylon by eclipse.

the class ClassTransformer method serializationSet.

private void serializationSet(Class model, ClassDefinitionBuilder classBuilder) {
    MethodDefinitionBuilder mdb = MethodDefinitionBuilder.systemMethod(this, Unfix.$set$.toString());
    mdb.isOverride(true);
    mdb.ignoreModelAnnotations();
    mdb.modifiers(PUBLIC);
    ParameterDefinitionBuilder pdb = ParameterDefinitionBuilder.systemParameter(this, Unfix.reference.toString());
    pdb.modifiers(FINAL);
    pdb.type(new TransformedType(make().Type(syms().ceylonReachableReferenceType), null, makeAtNonNull()));
    mdb.parameter(pdb);
    ParameterDefinitionBuilder pdb2 = ParameterDefinitionBuilder.systemParameter(this, Unfix.instance.toString());
    pdb2.modifiers(FINAL);
    pdb2.type(new TransformedType(make().Type(syms().objectType), null, makeAtNonNull()));
    mdb.parameter(pdb2);
    // mdb.resultType(null, naming.makeQuotedFQIdent("java.util.Collection"));
    /*
         * public void $set$(Object reference, Object instance) {
         *     switch((String)reference) {
         *     case ("attr1")
         *           this.field1 = ...;
         *           break;
         *     // ... other fields of this class
         *     default:
         *           super.set(reference, instance);
         */
    SyntheticName reference = naming.synthetic(Unfix.reference);
    SyntheticName instance = naming.synthetic(Unfix.instance);
    ListBuffer<JCCase> cases = new ListBuffer<JCCase>();
    boolean[] needsLookup = new boolean[] { false };
    for (Declaration member : model.getMembers()) {
        if (hasField(member)) {
            if (member instanceof Function)
                // TODO: This class is not serializable
                continue;
            ListBuffer<JCStatement> caseStmts = new ListBuffer<JCStatement>();
            if (member instanceof Value && ((Value) member).isLate()) {
                caseStmts.add(make().If(make().TypeTest(instance.makeIdent(), make().Type(syms().ceylonUninitializedLateValueType)), make().Break(null), null));
            }
            caseStmts.add(makeDeserializationAssignment((Value) member, needsLookup));
            caseStmts.add(make().Break(null));
            cases.add(make().Case(make().Literal(member.getQualifiedNameString()), caseStmts.toList()));
        }
    }
    ListBuffer<JCStatement> defaultCase = new ListBuffer<JCStatement>();
    if (extendsSerializable(model)) {
        // super.set(reference, instance);
        defaultCase.add(make().Exec(make().Apply(null, naming.makeQualIdent(naming.makeSuper(), Unfix.$set$.toString()), List.<JCExpression>of(reference.makeIdent(), instance.makeIdent()))));
    } else {
        // throw (or pass to something else to throw, based on policy)
        defaultCase.add(make().Throw(make().NewClass(null, null, naming.makeQuotedFQIdent("java.lang.RuntimeException"), List.<JCExpression>of(make().Literal("unknown attribute")), null)));
    }
    cases.add(make().Case(null, defaultCase.toList()));
    ListBuffer<JCStatement> stmts = new ListBuffer<JCStatement>();
    if (needsLookup[0]) {
        // if we needed to use a lookup object to reset final fields,
        // prepend that variable
        stmts.add(makeVar(FINAL, "lookup", naming.makeQualIdent(make().Type(syms().methodHandlesType), "Lookup"), make().Apply(null, naming.makeQuotedFQIdent("java.lang.invoke.MethodHandles.lookup"), List.<JCExpression>nil())));
    }
    JCSwitch swtch = make().Switch(make().Apply(null, naming.makeSelect(make().Apply(null, naming.makeSelect(make().TypeCast(make().Type(syms().ceylonMemberType), reference.makeIdent()), "getAttribute"), List.<JCExpression>nil()), "getQualifiedName"), List.<JCExpression>nil()), cases.toList());
    stmts.add(make().If(make().TypeTest(reference.makeIdent(), make().Type(syms().ceylonMemberType)), swtch, make().Throw(make().NewClass(null, null, make().Type(syms().ceylonAssertionErrorType), List.<JCExpression>of(make().Binary(JCTree.Tag.PLUS, make().Literal("unexpected reachable reference "), reference.makeIdent())), null))));
    mdb.body(stmts.toList());
    classBuilder.method(mdb);
}

Example 20 with SyntheticName

use of org.eclipse.ceylon.compiler.java.codegen.Naming.SyntheticName in project ceylon by eclipse.

the class ClassTransformer method transformMethodBlock.

private List<JCStatement> transformMethodBlock(final Tree.MethodDefinition def) {
    final Function model = def.getDeclarationModel();
    final Tree.Block block = def.getBlock();
    List<JCStatement> body;
    boolean prevNoExpressionlessReturn = statementGen().noExpressionlessReturn;
    Substitution substitution = null;
    JCStatement varDef = null;
    Parameter lastParameter = Decl.getLastParameterFromFirstParameterList(model);
    if (lastParameter != null && Decl.isJavaVariadicIncludingInheritance(lastParameter)) {
        SyntheticName alias = naming.alias(lastParameter.getName());
        substitution = naming.addVariableSubst(lastParameter.getModel(), alias.getName());
        varDef = substituteSequentialForJavaVariadic(alias, lastParameter);
    }
    try {
        statementGen().noExpressionlessReturn = Decl.isMpl(model) || Strategy.useBoxedVoid(model);
        body = statementGen().transformBlock(block);
    } finally {
        statementGen().noExpressionlessReturn = prevNoExpressionlessReturn;
        if (substitution != null)
            substitution.close();
    }
    // We void methods need to have their Callables return null
    // so adjust here.
    HasErrorException error = errors().getFirstErrorBlock(block);
    if ((Decl.isMpl(model) || Strategy.useBoxedVoid(model)) && !block.getDefinitelyReturns() && error == null) {
        if (Decl.isUnboxedVoid(model)) {
            body = body.append(make().Return(makeNull()));
        } else {
            body = body.append(make().Return(makeErroneous(block, "compiler bug: non-void method doesn't definitely return")));
        }
    }
    if (varDef != null)
        body = body.prepend(varDef);
    return body;
}