Package com.redhat.ceylon.compiler.typechecker.model

Examples of com.redhat.ceylon.compiler.typechecker.model.TypeDeclaration

3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
   
    private void visitIdentityOperator(Tree.BinaryOperatorExpression that) {
        ProducedType lhst = leftType(that);
        ProducedType rhst = rightType(that);
        if (!isTypeUnknown(rhst) && !isTypeUnknown(lhst)) {
            TypeDeclaration id = unit.getIdentifiableDeclaration();
            checkAssignable(lhst, id.getType(), that.getLeftTerm(),
                    "operand expression must be of type 'Identifiable'");
            checkAssignable(rhst, id.getType(), that.getRightTerm(),
                    "operand expression must be of type 'Identifiable'");
            if (intersectionType(lhst, rhst, unit).isNothing()) {
                that.addError("values of disjoint types are never identical: '" +
                        lhst.getProducedTypeName(unit) +
                        "' has empty intersection with '" +
View Full Code Here
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
   
    private void visitEqualityOperator(Tree.BinaryOperatorExpression that) {
        ProducedType lhst = leftType(that);
        ProducedType rhst = rightType(that);
        if (!isTypeUnknown(rhst) && !isTypeUnknown(lhst)) {
            TypeDeclaration od = unit.getObjectDeclaration();
            checkAssignable(lhst, od.getType(), that.getLeftTerm(),
                    "operand expression must be of type Object");
            checkAssignable(rhst, od.getType(), that.getRightTerm(),
                    "operand expression must be of type Object");
        }
        that.setTypeModel(unit.getType(unit.getBooleanDeclaration()));
    }
View Full Code Here
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
            TypeDeclaration type) {
        ProducedType lhst = leftType(that);
        ProducedType rhst = rightType(that);
        if (!isTypeUnknown(rhst) && !isTypeUnknown(lhst)) {
            //hardcoded implicit type conversion Integer->Float
            TypeDeclaration fd = unit.getFloatDeclaration();
            TypeDeclaration id = unit.getIntegerDeclaration();
            if (rhst.getDeclaration().inherits(fd) &&
                lhst.getDeclaration().inherits(id)) {
                lhst = fd.getType();
            }
            else if (rhst.getDeclaration().inherits(id) &&
View Full Code Here
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
            TypeDeclaration type) {
        ProducedType lhst = leftType(that);
        ProducedType rhst = rightType(that);
        if (!isTypeUnknown(rhst) && !isTypeUnknown(lhst)) {
            //hardcoded implicit type conversion Integer->Float
            TypeDeclaration fd = unit.getFloatDeclaration();
            TypeDeclaration id = unit.getIntegerDeclaration();
            if (rhst.getDeclaration().inherits(id) &&
                lhst.getDeclaration().inherits(fd)) {
                rhst = fd.getType();
            }
            ProducedType nt = checkSupertype(lhst, type, that.getLeftTerm(),
View Full Code Here
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
    }
   
    @Override
    public void visit(Tree.BaseType that) {
        super.visit(that);
        TypeDeclaration type = that.getDeclarationModel();
        if (type!=null) {
            if (!type.isVisible(that.getScope())) {
                that.addError("type is not visible: " +
                        baseDescription(that), 400);
            }
            else if (type.isPackageVisibility() &&
                    !declaredInPackage(type, unit)) {
                that.addError("package private type is not visible: " +
                    baseDescription(that));
            }
            //don't need to consider "protected" because
View Full Code Here
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
    }

    @Override
    public void visit(Tree.QualifiedType that) {
        super.visit(that);
        TypeDeclaration type = that.getDeclarationModel();
        if (type!=null) {
            if (!type.isVisible(that.getScope())) {
                that.addError("member type is not visible: " +
                        qualifiedDescription(that), 400);
            }
            else if (type.isPackageVisibility() &&
                    !declaredInPackage(type, unit)) {
                that.addError("package private member type is not visible: " +
                        qualifiedDescription(that));
            }
            //this is actually slightly too restrictive
            //since a qualified type may in fact be an
            //inherited member type, but in that case
            //you can just get rid of the qualifier, so
            //in fact this restriction is OK
            else if (type.isProtectedVisibility() &&
                    !declaredInPackage(type, unit)) {
                that.addError("protected member type is not visible: " +
                        qualifiedDescription(that));
            }
            //Note: we should remove this check if we ever
View Full Code Here
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866
4867
4868
                }
                ambiguous = false;
            }
            else {
                pt = pt.resolveAliases(); //needed for aliases like "alias Id<T> => T"
                TypeDeclaration d = getDeclaration(that, pt);
                container = "type '" + d.getName(unit) + "'";
                ClassOrInterface ci =
                        getContainingClassOrInterface(that.getScope());
                if (ci!=null && d.inherits(ci) && !(d instanceof NothingType)) {
                    Declaration direct =
                            ci.getDirectMember(name, signature, ellipsis);
                    if (direct instanceof TypedDeclaration) {
                        member = (TypedDeclaration) direct;
                    }
                    else {
                        member = getTypedMember(d, name, signature, ellipsis, unit);
                    }
                }
                else {
                    member = getTypedMember(d, name, signature, ellipsis, unit);
                }
                ambiguous = member==null &&
                        d.isMemberAmbiguous(name, unit, signature, ellipsis);
            }
            if (member==null) {
                if (error) {
                    if (ambiguous) {
                        that.addError("method or attribute is ambiguous: '" +
View Full Code Here
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036
5037
5038
5039
5040
5041
    }

    @Override public void visit(Tree.BaseTypeExpression that) {
        super.visit(that);
        boolean notDirectlyInvoked = !that.getDirectlyInvoked();
        TypeDeclaration type =
                resolveBaseTypeExpression(that, notDirectlyInvoked);
        if (type!=null && notDirectlyInvoked) {
            Tree.TypeArguments tal = that.getTypeArguments();
            List<ProducedType> typeArgs;
            if (explicitTypeArguments(type, tal)) {
                typeArgs = getTypeArguments(tal,
                        type.getTypeParameters(), null);
            }
            else {
                typeArgs = inferFunctionRefTypeArgs(that);
            }
            if (typeArgs!=null) {
View Full Code Here
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
    private TypeDeclaration resolveBaseTypeExpression(
            Tree.BaseTypeExpression that,
            boolean error) {
        String name = name(that.getIdentifier());
        TypeDeclaration type = getTypeDeclaration(that.getScope(),
                name, that.getSignature(), that.getEllipsis(),
                that.getUnit());
        if (type==null) {
            if (!dynamic && error) {
                that.addError("type does not exist: '" + name + "'", 102);
View Full Code Here
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
    }
   
    @Override public void visit(Tree.QualifiedTypeExpression that) {
        super.visit(that);
        boolean notDirectlyInvoked = !that.getDirectlyInvoked();
        TypeDeclaration type =
                resolveQualifiedTypeExpression(that, notDirectlyInvoked);
        if (type!=null && notDirectlyInvoked) {
            Tree.TypeArguments tal = that.getTypeArguments();
            ProducedType pt =
                    that.getPrimary().getTypeModel()
                    .resolveAliases(); //TODO: probably not necessary
            List<ProducedType> typeArgs;
            if (explicitTypeArguments(type, tal)) {
                typeArgs = getTypeArguments(tal,
                        type.getTypeParameters(), pt);
            }
            else {
                typeArgs = inferFunctionRefTypeArgs(that);
            }
            if (typeArgs!=null) {
View Full Code Here
TOP

Related Classes of com.redhat.ceylon.compiler.typechecker.model.TypeDeclaration

  • com.redhat.ceylon.ceylondoc.CeylonDocTool
  • com.redhat.ceylon.ceylondoc.ClassDoc
  • com.redhat.ceylon.ceylondoc.ClassOrPackageDoc
  • com.redhat.ceylon.ceylondoc.LinkRenderer
  • com.redhat.ceylon.ceylondoc.Util
  • com.redhat.ceylon.compiler.java.codegen.AbstractTransformer
  • com.redhat.ceylon.compiler.java.codegen.AnnotationModelVisitor
  • com.redhat.ceylon.compiler.java.codegen.BoxingVisitor
  • com.redhat.ceylon.compiler.java.codegen.CallableBuilder$CallMethodWithForwardedBody
  • com.redhat.ceylon.compiler.java.codegen.CeylonVisitor
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.