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

Examples of com.redhat.ceylon.compiler.typechecker.model.ProducedType$Criteria

4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
            }*/
        }
    }

    private void visitThenOperator(Tree.ThenOp that) {
        ProducedType lhst = leftType(that);
        ProducedType rhst = rightType(that);
        if (!isTypeUnknown(lhst)) {
            checkAssignable(lhst, unit.getType(unit.getBooleanDeclaration()), that.getLeftTerm(),
                    "operand expression must be a boolean value");
        }
        if ( rhst!=null && !isTypeUnknown(rhst)) {
View Full Code Here
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191
4192
4193
            that.setTypeModel(unit.getOptionalType(unit.denotableType(rhst)));
        }
    }

    private void visitInOperator(Tree.InOp that) {
        ProducedType lhst = leftType(that);
        ProducedType rhst = rightType(that);
        if (!isTypeUnknown(rhst) && !isTypeUnknown(lhst)) {
            ProducedType ct = checkSupertype(rhst,unit.getCategoryDeclaration(),
                that.getRightTerm(), "operand expression must be a category");
            if (ct!=null) {
                ProducedType at = ct.getTypeArguments().isEmpty() ?
                        null : ct.getTypeArgumentList().get(0);
              checkAssignable(lhst, at, that.getLeftTerm(),
                  "operand expression must be assignable to category type");
            }
        }
View Full Code Here
4194
4195
4196
4197
4198
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
        that.setTypeModel( unit.getType(unit.getBooleanDeclaration()) );
    }
   
    private void visitUnaryOperator(Tree.UnaryOperatorExpression that,
            TypeDeclaration type) {
        ProducedType t = type(that);
        if (!isTypeUnknown(t)) {
            ProducedType nt = checkSupertype(t, type, that.getTerm(),
                    "operand expression must be of correct type");
            if (nt!=null) {
                ProducedType at = nt.getTypeArguments().isEmpty() ?
                        nt : nt.getTypeArgumentList().get(0);
                that.setTypeModel(at);
            }
        }
    }
View Full Code Here
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
    }
   
    private void visitOfOperator(Tree.OfOp that) {
        Tree.Type rt = that.getType();
        if (rt!=null) {
            ProducedType t = rt.getTypeModel();
            if (!isTypeUnknown(t)) {
                that.setTypeModel(t);
                Tree.Term tt = that.getTerm();
                if (tt!=null) {
                    if (tt!=null) {
                        ProducedType pt = tt.getTypeModel();
                        if (!isTypeUnknown(pt)) {
                            if (!t.covers(pt)) {
                                that.addError("specified type does not cover the cases of the operand expression: '" +
                                        t.getProducedTypeName(unit) + "' does not cover '" +
                                        pt.getProducedTypeName(unit) + "'");
                            }
                        }
                    }
                }
            }
View Full Code Here
4245
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262
4263
4264
4265
4266
4267
    }
   
    private void visitIsOperator(Tree.IsOp that) {
        Tree.Type rt = that.getType();
        if (rt!=null) {
            ProducedType t = rt.getTypeModel();
            if (t!=null) {
                if (that.getTerm()!=null) {
                    ProducedType pt = that.getTerm().getTypeModel();
                    if (pt!=null && pt.isSubtypeOf(t)) {
                        that.addError("expression type is a subtype of the type: '" +
                                pt.getProducedTypeName(unit) + "' is assignable to '" +
                                t.getProducedTypeName(unit) + "'");
                    }
                    else {
                        if (intersectionType(t, pt, unit).isNothing()) {
                            that.addError("tests assignability to bottom type 'Nothing': intersection of '" +
                                    pt.getProducedTypeName(unit) + "' and '" +
                                    t.getProducedTypeName(unit) + "' is empty");
                        }
                    }
                }
            }
View Full Code Here
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
        boolean notDirectlyInvoked = !that.getDirectlyInvoked();
        TypedDeclaration member =
                resolveQualifiedMemberExpression(that, notDirectlyInvoked);
        if (member!=null && notDirectlyInvoked) {
            Tree.TypeArguments tal = that.getTypeArguments();
            ProducedType pt =
                    that.getPrimary().getTypeModel()
                    .resolveAliases(); //TODO: probably not necessary
            List<ProducedType> typeArgs;
            if (explicitTypeArguments(member, tal)) {
                typeArgs = getTypeArguments(tal,
View Full Code Here
4809
4810
4811
4812
4813
4814
4815
4816
4817
4818
4819
4820
4821
4822
4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835
4836
4837
4838
4839
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
    private TypedDeclaration resolveQualifiedMemberExpression(
            Tree.QualifiedMemberExpression that,
            boolean error) {
        Tree.Primary p = that.getPrimary();
        ProducedType pt = p.getTypeModel();
        boolean packageQualified = p instanceof Tree.Package;
        boolean check = packageQualified ||
                //that.getStaticMethodReference() ||
                pt!=null &&
                //account for dynamic blocks
                (!pt.getType().isUnknown() ||
                        that.getMemberOperator() instanceof Tree.SpreadOp);
        boolean nameNonempty = that.getIdentifier()!=null &&
                        !that.getIdentifier().getText().equals("");
        if (nameNonempty && check) {
            TypedDeclaration member;
            String name = name(that.getIdentifier());
            String container;
            boolean ambiguous;
            List<ProducedType> signature = that.getSignature();
            boolean ellipsis = that.getEllipsis();
            if (packageQualified) {
                container = "package '" + unit.getPackage().getNameAsString() + "'";
                Declaration pm = unit.getPackage()
                        .getMember(name, signature, ellipsis);
                if (pm instanceof TypedDeclaration) {
                    member = (TypedDeclaration) pm;
                }
                else {
                    member = null;
                }
                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)) {
View Full Code Here
4922
4923
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941
4942
4943
4944
4945
4946
    }
   
    private void visitQualifiedMemberExpression(Tree.QualifiedMemberExpression that,
            ProducedType receivingType, TypedDeclaration member,
            List<ProducedType> typeArgs, Tree.TypeArguments tal) {
        ProducedType receiverType =
                accountForStaticReferenceReceiverType(that,
                        unwrap(receivingType, that));
        if (acceptsTypeArguments(receiverType, member, typeArgs, tal, that, false)) {
            ProducedTypedReference ptr =
                    receiverType.getTypedMember(member, typeArgs,
                            that.getAssigned());
            /*if (ptr==null) {
                that.addError("member method or attribute does not exist: " +
                        member.getName(unit) + " of type " +
                        receiverType.getDeclaration().getName(unit));
            }
            else {*/
            that.setTarget(ptr);
            ProducedType fullType =
                    ptr.getFullType(wrap(ptr.getType(), receivingType, that));
            if (!dynamic && !isAbstraction(member) &&
                    isTypeUnknown(fullType)) {
                //this occurs with an ambiguous reference
                //to a member of an intersection type
View Full Code Here
5000
5001
5002
5003
5004
5005
5006
5007
5008
5009
5010
5011
5012
5013
5014
5015
5016
   
    private void visitBaseMemberExpression(Tree.StaticMemberOrTypeExpression that,
            TypedDeclaration member, List<ProducedType> typeArgs,
            Tree.TypeArguments tal) {
        if (acceptsTypeArguments(member, typeArgs, tal, that, false)) {
            ProducedType outerType =
                    that.getScope().getDeclaringType(member);
            ProducedTypedReference pr =
                    member.getProducedTypedReference(outerType, typeArgs,
                            that.getAssigned());
            that.setTarget(pr);
            ProducedType fullType = pr.getFullType();
            if (!dynamic && !isAbstraction(member) &&
                    isTypeUnknown(fullType)) {
                that.addError("could not determine type of function or value reference: '" +
                        member.getName(unit) + "'");
            }
View Full Code Here
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
        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,
View Full Code Here
TOP

Related Classes of com.redhat.ceylon.compiler.typechecker.model.ProducedType$Criteria

  • com.redhat.ceylon.ceylondoc.ClassDoc
  • com.redhat.ceylon.ceylondoc.ClassOrPackageDoc
  • com.redhat.ceylon.ceylondoc.Util
  • com.redhat.ceylon.compiler.java.codegen.AbstractTransformer
  • com.redhat.ceylon.compiler.java.codegen.AnnotationInvocation
  • com.redhat.ceylon.compiler.java.codegen.AnnotationModelVisitor
  • com.redhat.ceylon.compiler.java.codegen.AttributeDefinitionBuilder
  • com.redhat.ceylon.compiler.java.codegen.BoxingDeclarationVisitor
  • com.redhat.ceylon.compiler.java.codegen.BoxingVisitor
  • com.redhat.ceylon.compiler.java.codegen.CallableBuilder
    • 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.