Examples with Constructor com.redhat.ceylon.model.typechecker.model.Constructor used on opensource projects

Example 6 with Constructor

use of com.redhat.ceylon.model.typechecker.model.Constructor in project ceylon-compiler by ceylon.

the class MethodOrValueReferenceVisitor method visit.

@Override
public void visit(Tree.ClassDefinition that) {
    if (!that.getDeclarationModel().hasConstructors()) {
        boolean cs = enterCapturingScope();
        super.visit(that);
        exitCapturingScope(cs);
    } else {
        // super special case for unshared members when we have constructors
        if (!declaration.isCaptured() && declaration instanceof FunctionOrValue && declaration.isClassMember()) {
            Map<Constructor, ConstructorPlan> constructorPlans = new HashMap<Constructor, ConstructorPlan>();
            List<Tree.Statement> statements = new ArrayList<>(that.getClassBody().getStatements().size());
            // find every constructor, and build a model of how they delegate
            for (Tree.Statement stmt : that.getClassBody().getStatements()) {
                if (stmt instanceof Tree.Constructor) {
                    Tree.Constructor ctor = (Tree.Constructor) stmt;
                    // build a new plan for it
                    ConstructorPlan plan = new ConstructorPlan();
                    plan.constructor = ctor;
                    constructorPlans.put(ctor.getConstructor(), plan);
                    // find every constructor which delegates to another constructor
                    if (ctor.getDelegatedConstructor() != null && ctor.getDelegatedConstructor().getInvocationExpression() != null) {
                        if (ctor.getDelegatedConstructor().getInvocationExpression().getPrimary() instanceof Tree.ExtendedTypeExpression) {
                            Tree.ExtendedTypeExpression ete = (Tree.ExtendedTypeExpression) ctor.getDelegatedConstructor().getInvocationExpression().getPrimary();
                            // are we delegating to a constructor (not a supertype) of the same class (this class)?
                            if (Decl.isConstructor(ete.getDeclaration()) && Decl.getConstructedClass(ete.getDeclaration()).equals(that.getDeclarationModel())) {
                                // remember the delegation
                                Constructor delegate = Decl.getConstructor(ete.getDeclaration());
                                ConstructorPlan delegatePlan = constructorPlans.get(delegate);
                                plan.delegate = delegatePlan;
                                // mark the delegate as delegated
                                delegatePlan.isDelegate = true;
                                // we have all the statements before us and after our delegate
                                plan.before.addAll(delegatePlan.after);
                            }
                        }
                    }
                    // if we have no delegate, we start with every common statement
                    if (plan.delegate == null)
                        plan.before.addAll(statements);
                    // also add all the constructor's statements
                    if (ctor.getBlock() != null) {
                        plan.before.addAll(ctor.getBlock().getStatements());
                    }
                } else {
                    statements.add(stmt);
                    // make sure all existing constructors get this statement too
                    for (ConstructorPlan constructorPlan : constructorPlans.values()) constructorPlan.after.add(stmt);
                }
            }
            // try every constructor plan and see if it's used in two methods
            for (ConstructorPlan constructorPlan : constructorPlans.values()) {
                visitConstructorPlan(constructorPlan);
                // are we done?
                if (declaration.isCaptured())
                    break;
            }
        }
        // do regular capturing after that (for members), if required
        if (!declaration.isCaptured())
            super.visit(that);
    }
}

Example 7 with Constructor

use of com.redhat.ceylon.model.typechecker.model.Constructor in project ceylon-compiler by ceylon.

the class AbstractTransformer method makeJavaType.

JCExpression makeJavaType(final Type ceylonType, final int flags) {
    Type type = ceylonType;
    if (type == null || type.isUnknown())
        return make().Erroneous();
    if (type.getDeclaration() instanceof Constructor) {
        type = type.getExtendedType();
    }
    // resolve aliases
    if ((flags & JT_CLASS_LITERAL) == 0)
        type = type.resolveAliases();
    if ((flags & __JT_RAW_TP_BOUND) != 0 && type.isTypeParameter()) {
        type = type.getExtendedType();
    }
    if (type.isUnion()) {
        for (Type pt : type.getCaseTypes()) {
            if (pt.getDeclaration().isAnonymous()) {
                // found one, let's try to make it simpler
                Type simplerType = typeFact().denotableType(type);
                if (!simplerType.isNothing() && !simplerType.isUnion()) {
                    type = simplerType;
                } else if (isCeylonBoolean(simplifyType(simplerType))) {
                    type = simplerType;
                }
                break;
            }
        }
    }
    if (type.getDeclaration().isJavaEnum()) {
        type = type.getExtendedType();
    }
    if (type.isTypeConstructor()) {
        return make().QualIdent(syms().ceylonAbstractTypeConstructorType.tsym);
    }
    // ERASURE
    if ((flags & JT_CLASS_LITERAL) == 0 && // literals to the alias class
    willEraseToObject(type)) {
        // - The Ceylon type U|V results in the Java type Object
        if ((flags & JT_SATISFIES) != 0) {
            return null;
        } else {
            return make().Type(syms().objectType);
        }
    } else if (willEraseToAnnotation(type)) {
        return make().Type(syms().annotationType);
    } else if (willEraseToException(type)) {
        if ((flags & JT_CLASS_NEW) != 0 || (flags & JT_EXTENDS) != 0) {
            return makeIdent(syms().ceylonExceptionType);
        } else {
            return make().Type(syms().exceptionType);
        }
    } else if (willEraseToThrowable(type)) {
        if ((flags & JT_CLASS_NEW) != 0 || (flags & JT_EXTENDS) != 0) {
            return makeIdent(syms().throwableType);
        } else {
            return make().Type(syms().throwableType);
        }
    } else if (willEraseToSequence(type)) {
        if ((flags & (JT_CLASS_NEW | JT_EXTENDS | JT_IS)) == 0) {
            Type typeArg = simplifyType(type).getTypeArgumentList().get(0);
            Type seqType = typeFact.getSequenceType(typeArg);
            if (typeFact.isOptionalType(type)) {
                type = typeFact.getOptionalType(seqType);
            } else {
                type = seqType;
            }
        }
    } else if ((flags & (JT_SATISFIES | JT_EXTENDS | JT_NO_PRIMITIVES | JT_CLASS_NEW)) == 0 && ((isCeylonBasicType(type) && !isOptional(type)) || isJavaString(type))) {
        if (isCeylonString(type) || isJavaString(type)) {
            return make().Type(syms().stringType);
        } else if (isCeylonBoolean(type)) {
            return make().TypeIdent(TypeTags.BOOLEAN);
        } else if (isCeylonInteger(type)) {
            if ("short".equals(type.getUnderlyingType())) {
                return make().TypeIdent(TypeTags.SHORT);
            } else if ((flags & JT_SMALL) != 0 || "int".equals(type.getUnderlyingType())) {
                return make().TypeIdent(TypeTags.INT);
            } else {
                return make().TypeIdent(TypeTags.LONG);
            }
        } else if (isCeylonFloat(type)) {
            if ((flags & JT_SMALL) != 0 || "float".equals(type.getUnderlyingType())) {
                return make().TypeIdent(TypeTags.FLOAT);
            } else {
                return make().TypeIdent(TypeTags.DOUBLE);
            }
        } else if (isCeylonCharacter(type)) {
            if ("char".equals(type.getUnderlyingType())) {
                return make().TypeIdent(TypeTags.CHAR);
            } else {
                return make().TypeIdent(TypeTags.INT);
            }
        } else if (isCeylonByte(type)) {
            return make().TypeIdent(TypeTags.BYTE);
        }
    } else if (isCeylonBoolean(type) && !isTypeParameter(type)) {
        //&& (flags & TYPE_ARGUMENT) == 0){
        // special case to get rid of $true and $false types
        type = typeFact.getBooleanType();
    } else if ((flags & JT_VALUE_TYPE) == 0 && isJavaArray(type)) {
        return getJavaArrayElementType(type, flags);
    }
    JCExpression jt = null;
    Type simpleType;
    if ((flags & JT_CLASS_LITERAL) == 0)
        simpleType = simplifyType(type);
    else
        simpleType = type;
    // see if we need to cross methods when looking up container types
    // this is required to properly collect all the type parameters for local interfaces
    // which we pull up to the toplevel and capture all the container type parameters
    boolean needsQualifyingTypeArgumentsFromLocalContainers = Decl.isCeylon(simpleType.getDeclaration()) && simpleType.getDeclaration() instanceof Interface && // this is only valid for interfaces, not for their companion which stay where they are
    (flags & JT_COMPANION) == 0;
    java.util.List<Reference> qualifyingTypes = null;
    Reference qType = simpleType;
    boolean hasTypeParameters = false;
    while (qType != null) {
        hasTypeParameters |= !qType.getTypeArguments().isEmpty();
        if (qualifyingTypes != null)
            qualifyingTypes.add(qType);
        Declaration typeDeclaration = qType.getDeclaration();
        // all the containing type parameters that it captures
        if (// local or anonymous
        (Decl.isLocal(typeDeclaration) || !typeDeclaration.isNamed()) && needsQualifyingTypeArgumentsFromLocalContainers && typeDeclaration instanceof ClassOrInterface) {
            Declaration container = Decl.getDeclarationScope(typeDeclaration.getContainer());
            while (container instanceof Function) {
                qType = ((Function) container).getReference();
                if (qualifyingTypes == null) {
                    qualifyingTypes = new java.util.ArrayList<Reference>();
                    qualifyingTypes.add(simpleType);
                }
                hasTypeParameters = true;
                qualifyingTypes.add(qType);
                container = Decl.getDeclarationScope(container.getContainer());
            }
            if (container instanceof TypeDeclaration) {
                qType = ((TypeDeclaration) container).getType();
            } else {
                qType = null;
            }
        } else if (typeDeclaration.isNamed()) {
            // avoid anonymous types which may pretend that they have a qualifying type
            qType = qType.getQualifyingType();
            if (qType != null && qType.getDeclaration() instanceof ClassOrInterface == false) {
                // sometimes the typechecker throws qualifying intersections at us and
                // we can't make anything of them, since some members may be unrelated to
                // the qualified declaration. This happens with "extends super.Foo()"
                // for example. See https://github.com/ceylon/ceylon-compiler/issues/1478
                qType = ((Type) qType).getSupertype((TypeDeclaration) typeDeclaration.getContainer());
            }
        } else {
            // skip local declaration containers
            qType = null;
        }
        // delayed allocation if we have a qualifying type
        if (qualifyingTypes == null && qType != null) {
            qualifyingTypes = new java.util.ArrayList<Reference>();
            qualifyingTypes.add(simpleType);
        }
    }
    int firstQualifyingTypeWithTypeParameters = qualifyingTypes != null ? qualifyingTypes.size() - 1 : 0;
    // find the first static one, from the right to the left
    if (qualifyingTypes != null) {
        for (Reference pt : qualifyingTypes) {
            Declaration declaration = pt.getDeclaration();
            if (declaration instanceof TypeDeclaration && Decl.isStatic((TypeDeclaration) declaration)) {
                break;
            }
            firstQualifyingTypeWithTypeParameters--;
        }
        if (firstQualifyingTypeWithTypeParameters < 0)
            firstQualifyingTypeWithTypeParameters = 0;
        // put them in outer->inner order
        Collections.reverse(qualifyingTypes);
    }
    if (((flags & JT_RAW) == 0) && hasTypeParameters && !rawSupertype(ceylonType, flags)) {
        // special case for interfaces because we pull them into toplevel types
        if (Decl.isCeylon(simpleType.getDeclaration()) && qualifyingTypes != null && qualifyingTypes.size() > 1 && simpleType.getDeclaration() instanceof Interface && // this is only valid for interfaces, not for their companion which stay where they are
        (flags & JT_COMPANION) == 0) {
            JCExpression baseType;
            TypeDeclaration tdecl = simpleType.getDeclaration();
            // collect all the qualifying type args we'd normally have
            java.util.List<TypeParameter> qualifyingTypeParameters = new java.util.ArrayList<TypeParameter>();
            java.util.Map<TypeParameter, Type> qualifyingTypeArguments = new java.util.HashMap<TypeParameter, Type>();
            collectQualifyingTypeArguments(qualifyingTypeParameters, qualifyingTypeArguments, qualifyingTypes);
            ListBuffer<JCExpression> typeArgs = makeTypeArgs(isCeylonCallable(simpleType), flags, qualifyingTypeArguments, qualifyingTypeParameters, simpleType);
            if (isCeylonCallable(type) && (flags & JT_CLASS_NEW) != 0) {
                baseType = makeIdent(syms().ceylonAbstractCallableType);
            } else {
                baseType = naming.makeDeclarationName(tdecl, DeclNameFlag.QUALIFIED);
            }
            if (typeArgs != null && typeArgs.size() > 0) {
                jt = make().TypeApply(baseType, typeArgs.toList());
            } else {
                jt = baseType;
            }
        } else if ((flags & JT_NON_QUALIFIED) == 0) {
            int index = 0;
            if (qualifyingTypes != null) {
                for (Reference qualifyingType : qualifyingTypes) {
                    jt = makeParameterisedType(qualifyingType.getType(), type, flags, jt, qualifyingTypes, firstQualifyingTypeWithTypeParameters, index);
                    index++;
                }
            } else {
                jt = makeParameterisedType(simpleType, type, flags, jt, qualifyingTypes, firstQualifyingTypeWithTypeParameters, index);
            }
        } else {
            jt = makeParameterisedType(type, type, flags, jt, qualifyingTypes, 0, 0);
        }
    } else {
        TypeDeclaration tdecl = simpleType.getDeclaration();
        // - The Ceylon type T results in the Java type T
        if (isCeylonCallable(type) && (flags & JT_CLASS_NEW) != 0) {
            jt = makeIdent(syms().ceylonAbstractCallableType);
        } else if (tdecl instanceof TypeParameter)
            jt = makeQuotedIdent(tdecl.getName());
        else // don't use underlying type if we want no primitives
        if ((flags & (JT_SATISFIES | JT_NO_PRIMITIVES)) != 0 || simpleType.getUnderlyingType() == null) {
            jt = naming.makeDeclarationName(tdecl, jtFlagsToDeclNameOpts(flags));
        } else
            jt = makeQuotedFQIdent(simpleType.getUnderlyingType());
    }
    return (jt != null) ? jt : makeErroneous(null, "compiler bug: the java type corresponding to " + ceylonType + " could not be computed");
}

Example 8 with Constructor

use of com.redhat.ceylon.model.typechecker.model.Constructor in project ceylon-compiler by ceylon.

the class ClassTransformer method transformClassAlias.

private void transformClassAlias(final Tree.ClassDeclaration def, ClassDefinitionBuilder classBuilder) {
    ClassAlias model = (ClassAlias) def.getDeclarationModel();
    Type aliasedClass = model.getExtendedType();
    TypeDeclaration classOrCtor = def.getClassSpecifier().getType().getDeclarationModel();
    while (classOrCtor instanceof ClassAlias) {
        classOrCtor = ((ClassAlias) classOrCtor).getConstructor();
    }
    classBuilder.annotations(makeAtAlias(aliasedClass, classOrCtor instanceof Constructor ? (Constructor) classOrCtor : null));
    classBuilder.isAlias(true);
    MethodDefinitionBuilder instantiator = transformClassAliasInstantiator(def, model, aliasedClass);
    ClassDefinitionBuilder cbInstantiator = null;
    switch(Strategy.defaultParameterMethodOwner(model)) {
        case STATIC:
            cbInstantiator = classBuilder;
            break;
        case OUTER:
            cbInstantiator = classBuilder.getContainingClassBuilder();
            break;
        case OUTER_COMPANION:
            cbInstantiator = classBuilder.getContainingClassBuilder().getCompanionBuilder(Decl.getClassOrInterfaceContainer(model, true));
            break;
        default:
            throw BugException.unhandledEnumCase(Strategy.defaultParameterMethodOwner(model));
    }
    cbInstantiator.method(instantiator);
}

Example 9 with Constructor

use of com.redhat.ceylon.model.typechecker.model.Constructor in project ceylon-compiler by ceylon.

the class CeylonVisitor method visit.

public void visit(Tree.ExtendedType extendedType) {
    ClassOrInterface forDefinition = classBuilder.getForDefinition();
    Type thisType = forDefinition != null ? forDefinition.getType() : null;
    Type extended = extendedType.getType().getTypeModel();
    if (extended.getDeclaration() instanceof Constructor) {
        extended = extended.getQualifyingType();
    }
    classBuilder.extending(thisType, extended);
    gen.expressionGen().transformSuperInvocation(extendedType, classBuilder);
}

Example 10 with Constructor

use of com.redhat.ceylon.model.typechecker.model.Constructor in project ceylon-compiler by ceylon.

the class CeylonVisitor method visit.

public void visit(Tree.ClassBody that) {
    // Transform executable statements and declarations in the body
    // except constructors. Record how constructors delegate.
    HashMap<Constructor, CtorDelegation> delegates = new HashMap<Constructor, CtorDelegation>();
    java.util.List<Statement> stmts = getBodyStatements(that);
    HashMap<Constructor, CtorDelegation> broken = new HashMap<Constructor, CtorDelegation>();
    for (Tree.Statement stmt : stmts) {
        if (stmt instanceof Tree.Constructor) {
            Tree.Constructor ctor = (Tree.Constructor) stmt;
            Constructor ctorModel = ctor.getConstructor();
            if (gen.errors().hasDeclarationAndMarkBrokenness(ctor) instanceof Drop) {
                broken.put(ctorModel, CtorDelegation.brokenDelegation(ctorModel));
                continue;
            }
            classBuilder.getInitBuilder().constructor(ctor);
            if (ctor.getDelegatedConstructor() != null) {
                // error recovery
                if (ctor.getDelegatedConstructor().getInvocationExpression() != null) {
                    Tree.ExtendedTypeExpression p = (Tree.ExtendedTypeExpression) ctor.getDelegatedConstructor().getInvocationExpression().getPrimary();
                    Declaration delegatedDecl = p.getDeclaration();
                    delegates.put(ctorModel, ctorDelegation(ctorModel, delegatedDecl, broken));
                }
            } else {
                // implicitly delegating to superclass initializer
                Type et = Decl.getConstructedClass(ctorModel).getExtendedType();
                if (et != null) {
                    Declaration delegatedDecl = et.getDeclaration();
                    delegates.put(ctorModel, ctorDelegation(ctorModel, delegatedDecl, broken));
                }
            }
        } else if (stmt instanceof Tree.Enumerated) {
            Tree.Enumerated singleton = (Tree.Enumerated) stmt;
            Constructor ctorModel = singleton.getEnumerated();
            if (gen.errors().hasDeclarationAndMarkBrokenness(singleton) instanceof Drop) {
                broken.put(ctorModel, CtorDelegation.brokenDelegation(ctorModel));
                continue;
            }
            classBuilder.getInitBuilder().singleton(singleton);
            if (singleton.getDelegatedConstructor() != null) {
                Tree.ExtendedTypeExpression p = (Tree.ExtendedTypeExpression) singleton.getDelegatedConstructor().getInvocationExpression().getPrimary();
                Declaration delegatedDecl = p.getDeclaration();
                delegates.put(ctorModel, ctorDelegation(ctorModel, delegatedDecl, broken));
            } else {
                // implicitly delegating to superclass initializer
                Type et = Decl.getConstructedClass(ctorModel).getExtendedType();
                if (et != null) {
                    Declaration delegatedDecl = et.getDeclaration();
                    delegates.put(ctorModel, ctorDelegation(ctorModel, delegatedDecl, broken));
                }
            }
        } else {
            HasErrorException error = gen.errors().getFirstErrorInitializer(stmt);
            if (error != null) {
                append(gen.makeThrowUnresolvedCompilationError(error));
            } else {
                stmt.visit(this);
            }
        }
    }
    // Now transform constructors
    for (Tree.Statement stmt : stmts) {
        if (stmt instanceof Tree.Constructor) {
            Tree.Constructor ctor = (Tree.Constructor) stmt;
            if (gen.errors().hasDeclarationError(ctor) instanceof Drop) {
                continue;
            }
            transformConstructor(ctor, ctor.getParameterList(), ctor.getDelegatedConstructor(), ctor.getBlock(), ctor.getConstructor(), delegates);
        } else if (stmt instanceof Tree.Enumerated) {
            Tree.Enumerated ctor = (Tree.Enumerated) stmt;
            if (gen.errors().hasDeclarationError(ctor) instanceof Drop) {
                continue;
            }
            transformSingletonConstructor(delegates, ctor);
        }
    }
}