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

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

1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
    private void inferParameterTypes(ProducedReference pr,
            Parameter param, Tree.Expression e, boolean variadic) {
        if (e!=null) {
            Tree.Term term = unwrapExpressionUntilTerm(e.getTerm());
            ProducedTypedReference tpr = pr.getTypedParameter(param);
            if (term instanceof Tree.FunctionArgument) {
                if (param.getModel() instanceof Functional) {
                    //NOTE: this branch is basically redundant
                    //      and could be removed
                    inferParameterTypesFromCallableParameter(pr,
                            param, (Tree.FunctionArgument) term);
                }
                else {
                    ProducedType paramType = tpr.getFullType();
                    if (variadic) {
                        paramType = unit.getIteratedType(paramType);
                    }
                    if (unit.isCallableType(paramType)) {
                        inferParameterTypesFromCallableType(paramType,
View Full Code Here
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
        TypeArguments typeArguments = smte.getTypeArguments();
        Declaration dec = smte.getDeclaration();
        if (typeArguments instanceof Tree.InferredTypeArguments &&
                dec instanceof Generic &&
                !((Generic) dec).getTypeParameters().isEmpty()) {
            ProducedTypedReference param = smte.getTargetParameter();
            ProducedType paramType = smte.getParameterType();
            if (paramType==null && param!=null) {
                paramType = param.getFullType();
            }
            ProducedReference arg = getProducedReference(smte);
            if (!smte.getStaticMethodReferencePrimary() &&
                    dec instanceof Functional &&
                    param!=null) {
                Functional fun = (Functional) dec;
                List<ParameterList> apls = fun.getParameterLists();
                Declaration pdec = param.getDeclaration();
                if (pdec instanceof Functional) {
                    Functional pfun = (Functional) pdec;
                    List<ParameterList> ppls = pfun.getParameterLists();
                    if (apls.isEmpty() || ppls.isEmpty()) {
                        return null; //TODO: to give a nicer error
                    }
                    else {
                        List<ProducedType> inferredTypes =
                                new ArrayList<ProducedType>();
                        List<Parameter> apl = apls.get(0).getParameters();
                        List<Parameter> ppl = ppls.get(0).getParameters();
                        for (TypeParameter tp: fun.getTypeParameters()) {
                            List<ProducedType> list =
                                    new ArrayList<ProducedType>();
                            for (int i=0; i<apl.size() && i<ppl.size(); i++) {
                                Parameter ap = apl.get(i);
                                Parameter pp = ppl.get(i);
                                ProducedType type =
                                        param.getTypedParameter(pp).getFullType();
                                ProducedType template =
                                        arg.getTypedParameter(ap).getFullType();
                                ProducedType it =
                                        inferTypeArg(tp, template, type,
                                                true, false,
View Full Code Here
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941
4942
4943
4944
4945
4946
4947
            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
                that.addError("could not determine type of method or attribute reference: '" +
View Full Code Here
5002
5003
5004
5005
5006
5007
5008
5009
5010
5011
5012
5013
5014
5015
5016
            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
6995
6996
6997
6998
6999
7000
7001
7002
7003
7004
7005
7006
7007
7008
7009
7010
7011
7012
7013
7014
7015
7016
7017
7018
7019
7020
7021
7022
7023
                        getTypeParameters(method), outerType);
                    if (tal != null) {
                        tal.setTypeModels(ta);
                    }
                    if (acceptsTypeArguments(outerType, method, ta, tal, that, false)) {
                        ProducedTypedReference pr = outerType==null ?
                                method.getProducedTypedReference(null, ta) :
                                    outerType.getTypedMember(method, ta);
                                that.setTarget(pr);
                                that.setTypeModel(unit.getFunctionMetatype(pr));
                    }
                }
                else {
                    that.addError("missing type arguments to: '" + method.getName(unit) + "'");
                }
            }
        }
        else if (result instanceof Value) {
            Value value = (Value) result;
            if (that.getTypeArgumentList() != null) {
                that.addError("does not accept type arguments: '" + result.getName(unit) + "'");
            }
            else {
                ProducedTypedReference pr = value.getProducedTypedReference(outerType,
                        Collections.<ProducedType>emptyList());
                that.setTarget(pr);
                that.setTypeModel(unit.getValueMetatype(pr));
            }
        }
View Full Code Here
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
        @Override
        protected void resultType(MethodDefinitionBuilder overloadBuilder) {
            if (!isAnything(getModel().getType())
                    || !Decl.isUnboxedVoid(getModel())
                    || Strategy.useBoxedVoid((Method)getModel())) {
                ProducedTypedReference typedRef = (ProducedTypedReference) typedMember;
                overloadBuilder.resultTypeNonWidening(typedMember.getQualifyingType(), typedRef, typedMember.getType(), 0);
            } else {
                super.resultType(overloadBuilder);
            }
        }
View Full Code Here
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
            }
            return paramType;
        }

        private ProducedType paramType(Parameter parameter) {
            final ProducedTypedReference typedParameter = typedMember.getTypedParameter(parameter);
            ProducedType paramType;
            // if the supertype method itself got erased to Object, we can't do better than this
            if (gen().willEraseToObject(parameter.getType()) && !gen().willEraseToBestBounds(parameter)) {
                paramType = typeFact().getObjectDeclaration().getType();
            } else {
                paramType = typedParameter.getType();
            }
            return paramType;
        }
View Full Code Here
394
395
396
397
398
399
400
401
402
403
404
405
406
407
            mods |= FINAL;
        }
        TypedDeclaration nonWideningDecl = null;
        ProducedType nonWideningType;
        if (Decl.isValue(mov)) {
            ProducedTypedReference typedRef = gen.getTypedReference(mov);
            ProducedTypedReference nonWideningTypedRef = gen.nonWideningTypeDecl(typedRef);
            nonWideningType = gen.nonWideningType(typedRef, nonWideningTypedRef);
            nonWideningDecl = nonWideningTypedRef.getDeclaration();
        }else{
            nonWideningType = param.getType();
            nonWideningDecl = param.getModel();
        }
       
View Full Code Here
479
480
481
482
483
484
485
486
487
488
489
490
491
                    resultType = gen.typeFact().getCallableType(resultType);
                }
                return resultType(gen.makeJavaType(resultType, CodegenUtil.isUnBoxed(method) ? 0 : AbstractTransformer.JT_NO_PRIMITIVES), method);
            }
        }
        ProducedTypedReference typedRef = gen.getTypedReference(method);
        ProducedTypedReference nonWideningTypedRef = gen.nonWideningTypeDecl(typedRef);
        ProducedType nonWideningType = gen.nonWideningType(typedRef, nonWideningTypedRef);
        if(method.isActual()
                && CodegenUtil.hasTypeErased(method))
            flags |= AbstractTransformer.JT_RAW;
        return resultType(makeResultType(nonWideningTypedRef.getDeclaration(), nonWideningType, flags), method);
    }
View Full Code Here
490
491
492
493
494
495
496
497
498
499
        return resultType(makeResultType(nonWideningTypedRef.getDeclaration(), nonWideningType, flags), method);
    }
   
    public MethodDefinitionBuilder resultTypeNonWidening(ProducedType currentType, ProducedTypedReference typedRef,
            ProducedType returnType, int flags){
        ProducedTypedReference nonWideningTypedRef = gen.nonWideningTypeDecl(typedRef, currentType);
        returnType = gen.nonWideningType(typedRef, nonWideningTypedRef);
        return resultType(makeResultType(nonWideningTypedRef.getDeclaration(), returnType, flags), typedRef.getDeclaration());

    }
View Full Code Here
TOP

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

  • com.redhat.ceylon.compiler.java.codegen.AbstractTransformer
  • com.redhat.ceylon.compiler.java.codegen.AttributeDefinitionBuilder
  • com.redhat.ceylon.compiler.java.codegen.ClassTransformer
  • com.redhat.ceylon.compiler.java.codegen.ClassTransformer$DefaultedArgumentMethodTyped
  • com.redhat.ceylon.compiler.java.codegen.ExpressionTransformer
  • com.redhat.ceylon.compiler.java.codegen.MethodDefinitionBuilder
  • com.redhat.ceylon.compiler.java.codegen.NamedArgumentInvocation
  • com.redhat.ceylon.compiler.java.runtime.metamodel.FreeFunction
  • com.redhat.ceylon.compiler.typechecker.analyzer.ExpressionVisitor
    • 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.