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

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

565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
    if (paramsList.size()!=refinedParamsList.size()) {
           handleWrongParameterListLength(that, member, refinedMember);
        }
        else {
            for (int i=0; i<paramsList.size(); i++) {
                Parameter rparam = refinedParamsList.get(i);
                Parameter param = paramsList.get(i);
                ProducedType refinedParameterType =
                    refinedMember.getTypedParameter(rparam).getFullType();
                ProducedType parameterType =
                    member.getTypedParameter(param).getFullType();
                Tree.Parameter parameter = pl.getParameters().get(i);
                Node typeNode = parameter;
                if (parameter instanceof Tree.ParameterDeclaration) {
                  Tree.Type type = ((Tree.ParameterDeclaration) parameter)
                      .getTypedDeclaration().getType();
                  if (type!=null) {
                    typeNode = type;
                  }
                }
                if (parameter!=null) {
                if (rparam.getModel().isDynamicallyTyped()) {
                      checkRefiningParameterDynamicallyTyped(member,
                                refinedMember, param, typeNode);
                    }
                else if (param.getModel().isDynamicallyTyped()) {
                      checkRefinedParameterDynamicallyTyped(member,
                                refinedMember, rparam, param, typeNode);
                    }
                else if (refinedParameterType==null || parameterType==null) {
                  handleUnknownParameterType(member, refinedMember,
View Full Code Here
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
        boolean foundSequenced = false;
        boolean foundDefault = false;
        ParameterList pl = that.getModel();
        for (Tree.Parameter p: that.getParameters()) {
            if (p!=null) {
                Parameter pm = p.getParameterModel();
                if (pm.isDefaulted()) {
                    if (foundSequenced) {
                        p.addError("defaulted parameter must occur before variadic parameter");
                    }
                    foundDefault = true;
                    if (!pl.isFirst()) {
                        p.addError("only the first parameter list may have defaulted parameters");
                    }
                }
                else if (pm.isSequenced()) {
                    if (foundSequenced) {
                        p.addError("parameter list may have at most one variadic parameter");
                    }
                    foundSequenced = true;
                    if (!pl.isFirst()) {
                        p.addError("only the first parameter list may have a variadic parameter");
                    }
                    if (foundDefault &&
                            pm.isAtLeastOne()) {
                        p.addError("parameter list with defaulted parameters may not have a nonempty variadic parameter");
                    }
                }
                else {
                    if (foundDefault) {
View Full Code Here
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
            for (final Parameter p: pl.getParameters()) {
                //TODO: meaningful errors when parameters don't line up
                //      currently this is handled elsewhere, but we can
                //      probably do it better right here
                if (tpl==null || tpl.getParameters().size()<=j) {
                    Parameter vp = new Parameter();
                    Value v = new Value();
                    vp.setModel(v);
                    v.setInitializerParameter(vp);
                    vp.setSequenced(p.isSequenced());
                    vp.setAtLeastOne(p.isAtLeastOne());
                    vp.setDefaulted(p.isDefaulted());
                    vp.setName(p.getName());
                    v.setName(p.getName());
                    vp.setDeclaration(m);
                    v.setContainer(m);
                    v.setScope(m);
                    l.getParameters().add(vp);
                    v.setType(new LazyProducedType(that.getUnit()) {
                        @Override
                        public Map<TypeParameter, ProducedType> initTypeArguments() {
                            return rm.getTypedParameter(p).getFullType()
                                    .getTypeArguments();
                        }
                        @Override
                        public TypeDeclaration initDeclaration() {
                            return rm.getTypedParameter(p).getFullType()
                                    .getDeclaration();
                        }
                    });
                }
                else {
                    Tree.Parameter tp = tpl.getParameters().get(j);
                    Parameter rp = tp.getParameterModel();
                    rp.setDefaulted(p.isDefaulted());
                    rp.setDeclaration(m);
                    l.getParameters().add(rp);
                }
                j++;
            }
            m.getParameterLists().add(l);
View Full Code Here
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
        Set<Parameter> foundParameters = new HashSet<Parameter>();
        for (Tree.NamedArgument arg: args.getNamedArguments()) {
            inferTypeArgFromNamedArg(arg, tp, pr, parameters,
                    inferredTypes, foundParameters);
        }
        Parameter sp = getUnspecifiedParameter(null, parameters,
                foundParameters);
        if (sp!=null) {
          Tree.SequencedArgument sa = args.getSequencedArgument();
          inferTypeArgFromSequencedArg(sa, tp, sp, inferredTypes);
        }   
View Full Code Here
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
            type = ta.getDeclarationModel()
                .getTypedReference() //argument can't have type parameters
                .getFullType();
        }
        if (type!=null) {
            Parameter parameter =
                    getMatchingParameter(parameters, arg,
                            foundParameters);
            if (parameter!=null) {
                foundParameters.add(parameter);
                ProducedType pt = pr.getTypedParameter(parameter)
View Full Code Here
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
            ParameterList parameters, ProducedReference pr,
            Tree.PositionalArgumentList pal,
            List<ProducedType> inferredTypes) {
        List<Parameter> params = parameters.getParameters();
        for (int i=0; i<params.size(); i++) {
            Parameter parameter = params.get(i);
            List<Tree.PositionalArgument> args =
                    pal.getPositionalArguments();
            if (args.size()>i) {
                Tree.PositionalArgument a = args.get(i);
                ProducedType at = a.getTypeModel();
                if (a instanceof Tree.SpreadArgument) {
                    at = spreadType(at, unit, true);
                    List<Parameter> subList =
                            params.subList(i, params.size());
                    ProducedType ptt =
                            unit.getParameterTypesAsTupleType(subList, pr);
                    addToUnionOrIntersection(tp, inferredTypes,
                            inferTypeArg(tp, ptt, at, true, false,
                                    new ArrayList<TypeParameter>()));
                }
                else if (a instanceof Tree.Comprehension) {
                    if (parameter.isSequenced()) {
                        inferTypeArgFromComprehension(tp, parameter,
                                ((Tree.Comprehension) a),
                                inferredTypes);
                    }
                }
                else {
                    if (parameter.isSequenced()) {
                        inferTypeArgFromPositionalArgs(tp, parameter,
                                args.subList(i, args.size()),
                                inferredTypes);
                        break;
                    }
View Full Code Here
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
        Tree.SequencedArgument sa = nal.getSequencedArgument();
        if (sa!=null) {
            checkSequencedArg(sa, pl, pr, foundParameters);       
        }
        else {
            Parameter sp = getUnspecifiedParameter(pr, pl, foundParameters);
            if (sp!=null && !unit.isNonemptyIterableType(sp.getType())) {
                foundParameters.add(sp);
            }
        }
           
        for (Parameter p: pl.getParameters()) {
View Full Code Here
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
        }
    }
   
    private void checkSequencedArg(Tree.SequencedArgument sa, ParameterList pl,
            ProducedReference pr, Set<Parameter> foundParameters) {
        Parameter sp = getUnspecifiedParameter(pr, pl, foundParameters);
        if (sp==null) {
            sa.addError("all iterable parameters specified by named argument list: '" +
                    pr.getDeclaration().getName(unit) +
                    "' does not declare any additional parameters of type 'Iterable'");
        }
        else {
            if (!foundParameters.add(sp)) {
                sa.addError("duplicate argument for parameter: '" +
                        sp.getName() + "' of '" + pr.getDeclaration().getName(unit) + "'");
            }
            else if (!dynamic && isTypeUnknown(sp.getType())) {
                sa.addError("parameter type could not be determined: '" +
                        sp.getName() + "' of '" + sp.getDeclaration().getName(unit) + "'");
            }
            checkSequencedArgument(sa, pr, sp);
        }
    }
View Full Code Here
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
        }
    }

    private void checkNamedArg(Tree.NamedArgument a, ParameterList pl,
            ProducedReference pr, Set<Parameter> foundParameters) {
        Parameter p = getMatchingParameter(pl, a, foundParameters);
        if (p==null) {
            if (a.getIdentifier()==null) {
                a.addError("all parameters specified by named argument list: '" +
                        pr.getDeclaration().getName(unit) +
                        "' does not declare any additional parameters");
            }
            else {
                a.addError("no matching parameter for named argument '" +
                        name(a.getIdentifier()) + "' declared by '" +
                        pr.getDeclaration().getName(unit) + "'", 101);
            }
        }
        else {
            if (!foundParameters.add(p)) {
                a.addError("duplicate argument for parameter: '" +
                        p.getName() + "' of '" + pr.getDeclaration().getName(unit) + "'");
            }
            else if (!dynamic && isTypeUnknown(p.getType())) {
                a.addError("parameter type could not be determined: '" +
                        p.getName() + "' of '" + p.getDeclaration().getName(unit) + "'");
            }
            checkNamedArgument(a, pr, p);
            //hack in an identifier node just for the backend:
            //TODO: get rid of this nasty thing
            if (a.getIdentifier()==null) {
                Tree.Identifier node = new Tree.Identifier(null);
                node.setScope(a.getScope());
                node.setUnit(a.getUnit());
                node.setText(p.getName());
                a.setIdentifier(node);
            }
        }
    }
View Full Code Here
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
    private void checkPositionalArguments(ParameterList pl, ProducedReference pr,
            Tree.PositionalArgumentList pal, Tree.InvocationExpression that) {
        List<Tree.PositionalArgument> args = pal.getPositionalArguments();
        List<Parameter> params = pl.getParameters();
        for (int i=0; i<params.size(); i++) {
            Parameter p = params.get(i);
            if (i>=args.size()) {
                if (!p.isDefaulted() && (!p.isSequenced() || p.isAtLeastOne())) {
                    Node n = that instanceof Tree.Annotation && args.isEmpty() ? that : pal;
                    n.addError("missing argument to required parameter '" +
                            p.getName() + "' of '" + pr.getDeclaration().getName(unit) + "'");
                }
            }
            else {
                Tree.PositionalArgument a = args.get(i);
                if (!dynamic && isTypeUnknown(p.getType())) {
                    a.addError("parameter type could not be determined: '" +
                            p.getName() + "' of '" + p.getDeclaration().getName(unit) + "'");
                }
                if (a instanceof Tree.SpreadArgument) {
                    checkSpreadArgument(pr, p, a,
                            (Tree.SpreadArgument) a,
                            params.subList(i, params.size()));
                    break;
                }
                else if (a instanceof Tree.Comprehension) {
                    if (p.isSequenced()) {
                        checkComprehensionPositionalArgument(p, pr,
                                (Tree.Comprehension) a, p.isAtLeastOne());
                    }
                    else {
                        a.addError("not a variadic parameter: parameter '" +
                                p.getName() + "' of '" + pr.getDeclaration().getName() + "'");
                    }
                    break;
                }
                else {
                    if (p.isSequenced()) {
                        checkSequencedPositionalArgument(p, pr,
                                args.subList(i, args.size()));
                        return; //Note: early return!
                    }
                    else {
View Full Code Here
TOP

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

  • com.redhat.ceylon.compiler.java.codegen.AnnotationInvocation
  • com.redhat.ceylon.compiler.java.codegen.AnnotationInvocationVisitor
  • com.redhat.ceylon.compiler.java.codegen.CallableBuilder
  • com.redhat.ceylon.compiler.java.codegen.CallableBuilder$CallVariadicMethodForVariadic
  • com.redhat.ceylon.compiler.java.codegen.CallableBuilder$MethodWithArity
  • com.redhat.ceylon.compiler.java.codegen.CallableBuilder$VariadicMethodWithArity
  • com.redhat.ceylon.compiler.java.codegen.CallableInvocation
  • com.redhat.ceylon.compiler.java.codegen.CeylonTransformer
  • com.redhat.ceylon.compiler.java.codegen.ClassTransformer
  • com.redhat.ceylon.compiler.java.codegen.CodegenUtil
    • 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.