root/trunk/ProjectFortress/src/com/sun/fortress/compiler/disambiguator/TypeDisambiguator.java @ 3289

Revision 3289, 27.0 KB (checked in by dr2chase, 11 months ago)

Feeding generated APIs to static analysis, not yet working
Line 
1/*******************************************************************************
2    Copyright 2009 Sun Microsystems, Inc.,
3    4150 Network Circle, Santa Clara, California 95054, U.S.A.
4    All rights reserved.
5
6    U.S. Government Rights - Commercial software.
7    Government users are subject to the Sun Microsystems, Inc. standard
8    license agreement and applicable provisions of the FAR and its supplements.
9
10    Use is subject to license terms.
11
12    This distribution may include materials developed by third parties.
13
14    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
15    trademarks of Sun Microsystems, Inc. in the U.S. and other countries.
16 ******************************************************************************/
17
18package com.sun.fortress.compiler.disambiguator;
19
20import java.util.ArrayList;
21import java.util.Collection;
22import java.util.Collections;
23import java.util.LinkedList;
24import java.util.List;
25import java.util.Set;
26
27import com.sun.fortress.compiler.Types;
28import com.sun.fortress.compiler.index.GrammarIndex;
29import com.sun.fortress.compiler.index.TypeConsIndex;
30import com.sun.fortress.exceptions.StaticError;
31import com.sun.fortress.nodes.Decl;
32import com.sun.fortress.nodes.TypeInfo;
33import com.sun.fortress.nodes.TraitTypeWhere;
34import com.sun.fortress.nodes.TraitTypeHeader;
35import com.sun.fortress.nodes.WhereClause;
36import com.sun.fortress.nodes.BaseType;
37import com.sun.fortress.nodes.Contract;
38import com.sun.fortress.nodes.APIName;
39import com.sun.fortress.nodes.ObjectDecl;
40import com.sun.fortress.nodes.AnyType;
41import com.sun.fortress.nodes.TupleType;
42import com.sun.fortress.nodes.ArrowType;
43import com.sun.fortress.nodes.BoolArg;
44import com.sun.fortress.nodes.BoolRef;
45import com.sun.fortress.nodes.DimArg;
46import com.sun.fortress.nodes.DimRef;
47import com.sun.fortress.nodes.Effect;
48import com.sun.fortress.nodes.Expr;
49import com.sun.fortress.nodes.FnDecl;
50import com.sun.fortress.nodes.FnHeader;
51import com.sun.fortress.nodes.GrammarDecl;
52import com.sun.fortress.nodes.GrammarMemberDecl;
53import com.sun.fortress.nodes.Id;
54import com.sun.fortress.nodes.IdOrOp;
55import com.sun.fortress.nodes.IdOrOpOrAnonymousName;
56import com.sun.fortress.nodes.IntArg;
57import com.sun.fortress.nodes.IntRef;
58import com.sun.fortress.nodes.KindType;
59import com.sun.fortress.nodes.KindInt;
60import com.sun.fortress.nodes.KindNat;
61import com.sun.fortress.nodes.KindBool;
62import com.sun.fortress.nodes.KindDim;
63import com.sun.fortress.nodes.KindUnit;
64import com.sun.fortress.nodes.KindOp;
65import com.sun.fortress.nodes.Node;
66import com.sun.fortress.nodes.NodeAbstractVisitor;
67import com.sun.fortress.nodes.NodeUpdateVisitor;
68import com.sun.fortress.nodes.NonterminalHeader;
69import com.sun.fortress.nodes.ObjectDecl;
70import com.sun.fortress.nodes.Op;
71import com.sun.fortress.nodes.OpArg;
72import com.sun.fortress.nodes.ASTNodeInfo;
73import com.sun.fortress.nodes.StaticArg;
74import com.sun.fortress.nodes.StaticParam;
75import com.sun.fortress.nodes.SuperSyntaxDef;
76import com.sun.fortress.nodes.TraitDecl;
77import com.sun.fortress.nodes.TraitType;
78import com.sun.fortress.nodes.TransformerDecl;
79import com.sun.fortress.nodes.Type;
80import com.sun.fortress.nodes.TypeArg;
81import com.sun.fortress.nodes.UnitArg;
82import com.sun.fortress.nodes.UnitRef;
83import com.sun.fortress.nodes.VarType;
84import com.sun.fortress.nodes_util.ExprFactory;
85import com.sun.fortress.nodes_util.NodeFactory;
86import com.sun.fortress.nodes_util.NodeUtil;
87import com.sun.fortress.nodes_util.Span;
88import com.sun.fortress.useful.HasAt;
89
90import edu.rice.cs.plt.iter.IterUtil;
91import edu.rice.cs.plt.lambda.Lambda;
92import edu.rice.cs.plt.lambda.LambdaUtil;
93import edu.rice.cs.plt.lambda.Thunk;
94import edu.rice.cs.plt.tuple.Option;
95import edu.rice.cs.plt.tuple.Pair;
96
97/**
98 * <p>Eliminates ambiguities in types:
99 * <ul>
100 * <li>VarTypes (and 0-ary TraitTypes, if they exist) referencing type Any are
101 *     replaced by AnyTypes.</li>
102 * <li>Type names referring to APIs are made fully qualified.</li>
103 * <li>VarTypes referring to traits, objects, and aliases become TraitTypes
104 *     (with 0 arguments).</li>
105 * <li>TypeArgs wrapping VarTypes corresponding to other kinds of parameters (like UnitParams)
106       are converted to the corresponding kind of arg (like UnitArg).</li>
107 * <li>TODO: UnitArgs corresponding to DimParams are converted to DimArgs.</li>
108 * <li>TODO: TaggedUnitTypes for types that absorb dimensions become TaggedDimTypes.</li>
109 * </ul>
110 * (TODO: Verify that the parser prefers producing units over dimensions in ambiguous cases.)
111 * </p>
112 * <p>All name references in resolved types that are undefined or used incorrectly are
113 * treated as static errors.  Similarly, incorrect arity or kinds of static arguments
114 * are treated as errors.  Malformed types (currently, just Domains that don't appear
115 * as an arrow's domain) also cause errors.</p>
116 */
117public class TypeDisambiguator extends NodeUpdateVisitor {
118
119    private final TypeNameEnv _env;
120    private final Set<IdOrOpOrAnonymousName> _onDemandImports;
121    private final List<StaticError> _errors;
122
123    public TypeDisambiguator(TypeNameEnv env, Set<IdOrOpOrAnonymousName> onDemandImports,
124            List<StaticError> errors) {
125        _env = env;
126        _onDemandImports = onDemandImports;
127        _errors = errors;
128    }
129
130    private void error(String msg, HasAt loc) {
131        _errors.add(StaticError.make(msg, loc));
132    }
133
134    /**
135     * Return a new TypeDisambiguator
136     * that includes the given type variables in its environment.
137     */
138    private TypeDisambiguator extend(List<StaticParam> typeVars) {
139        TypeNameEnv newEnv = new LocalStaticParamEnv(_env, typeVars);
140        return new TypeDisambiguator(newEnv, _onDemandImports, _errors);
141    }
142
143    /**
144     * When recurring on a TraitDecl, we first need to extend the
145     * environment with all the newly bound static parameters.
146     */
147    @Override public Node forTraitDecl(final TraitDecl that) {
148        TypeDisambiguator v = this.extend(NodeUtil.getStaticParams(that));
149        TraitTypeHeader header = (TraitTypeHeader)forTraitTypeHeaderOnly(that.getHeader(),
150                v.recurOnListOfStaticParam(NodeUtil.getStaticParams(that)),
151                (Id) NodeUtil.getName(that).accept(v),
152                v.recurOnOptionOfWhereClause(NodeUtil.getWhereClause(that)),
153                Option.<List<BaseType>>none(),
154                Option.<Contract>none(),
155                v.recurOnListOfTraitTypeWhere(NodeUtil.getExtendsClause(that)),
156                v.recurOnListOfDecl(NodeUtil.getDecls(that)));
157        return forTraitDeclOnly(that, that.getInfo(), header,
158                v.recurOnListOfBaseType(NodeUtil.getExcludesClause(that)),
159                v.recurOnOptionOfListOfBaseType(NodeUtil.getComprisesClause(that)));
160    }
161
162    /**
163     * When recurring on an ObjectDecl, we first need to extend the
164     * environment with all the newly bound static parameters.
165     */
166    @Override public Node forObjectDecl(final ObjectDecl that) {
167        TypeDisambiguator v = this.extend(NodeUtil.getStaticParams(that));
168        TraitTypeHeader header = (TraitTypeHeader)forTraitTypeHeaderOnly(that.getHeader(),
169                v.recurOnListOfStaticParam(NodeUtil.getStaticParams(that)),
170                (Id) NodeUtil.getName(that).accept(v),
171                v.recurOnOptionOfWhereClause(NodeUtil.getWhereClause(that)),
172                Option.<List<BaseType>>none(),
173                Option.<Contract>none(),
174                v.recurOnListOfTraitTypeWhere(NodeUtil.getExtendsClause(that)),
175                v.recurOnListOfDecl(NodeUtil.getDecls(that)));
176
177        return forObjectDeclOnly(that, that.getInfo(), header,
178                v.recurOnOptionOfListOfParam(NodeUtil.getParams(that)));
179    }
180
181    /**
182     * When recurring on a FnDecl, we first need to extend the
183     * environment with all the newly bound static parameters.
184     */
185    @Override public Node forFnDecl(final FnDecl that) {
186        TypeDisambiguator v = this.extend(NodeUtil.getStaticParams(that));
187
188        FnHeader header = (FnHeader)forFnHeaderOnly(that.getHeader(),
189                v.recurOnListOfStaticParam(NodeUtil.getStaticParams(that)),
190                (IdOrOpOrAnonymousName) NodeUtil.getName(that).accept(v),
191                v.recurOnOptionOfWhereClause(NodeUtil.getWhereClause(that)),
192                v.recurOnOptionOfListOfBaseType(NodeUtil.getThrowsClause(that)),
193                v.recurOnOptionOfContract(NodeUtil.getContract(that)),
194                v.recurOnListOfParam(NodeUtil.getParams(that)),
195                v.recurOnOptionOfType(NodeUtil.getReturnType(that)));
196
197        return forFnDeclOnly(that, that.getInfo(), header,
198                that.getUnambiguousName(),
199                v.recurOnOptionOfExpr(NodeUtil.getBody(that)),
200                that.getImplementsUnambiguousName());
201    }
202
203    @Override public Node forArrowType(final ArrowType that) {
204        Type domain = that.getDomain();
205        Type domainResult;
206        if ( domain instanceof TupleType )
207            domainResult = (Type) super.forTupleType( (TupleType)domain );
208        else
209            domainResult = (Type) domain.accept(this);
210        Type rangeResult = (Type) that.getRange().accept(this);
211        Effect effectResult = (Effect) that.getEffect().accept(this);
212        TypeInfo infoResult = NodeFactory.makeTypeInfo(NodeUtil.getSpan(that),
213                                                       NodeUtil.isParenthesized(that),
214                                                       NodeUtil.getStaticParams(that),
215                                                       NodeUtil.getWhereClause(that));
216        return forArrowTypeOnly(that, infoResult, domainResult, rangeResult, effectResult);
217    }
218
219    @Override public Node forVarType(final VarType that) {
220        Thunk<Type> varHandler = LambdaUtil.<Type>valueLambda(that);
221        Lambda<Id, Type> typeConsHandler =
222            new Lambda<Id, Type>() {
223            public Type value(Id n) {
224                if (n.equals(Types.ANY_NAME)) {
225                    return NodeFactory.makeAnyType(NodeUtil.getSpan(that));
226                }
227                else {
228                    TypeConsIndex typeCons = _env.typeConsIndex(n);
229                    if (!typeCons.staticParameters().isEmpty()) {
230                        error("Type requires static arguments: " + NodeUtil.nameString(n),
231                              that);
232                        return that;
233                    }
234                    return NodeFactory.makeTraitType(NodeUtil.getSpan(that), false, n);
235                }
236            }
237        };
238        return handleTypeName(that, that.getName(), varHandler, typeConsHandler);
239    }
240
241    @Override public Node forTraitType(final TraitType that) {
242        Thunk<Type> varHandler = new Thunk<Type>() {
243            public Type value() {
244                error("Type parameter cannot be parameterized: " +
245                        NodeUtil.nameString(that.getName()), that);
246                return that;
247            }
248        };
249        Lambda<Id, Type> typeConsHandler =
250            new Lambda<Id, Type>() {
251            public Type value(Id n) {
252                List<StaticArg> args = that.getArgs();
253                if (n.equals(Types.ANY_NAME) && args.isEmpty()) {
254                    return NodeFactory.makeAnyType(NodeUtil.getSpan(that));
255                }
256                else {
257                    TypeConsIndex typeCons = _env.typeConsIndex(n);
258                    List<StaticParam> params = typeCons.staticParameters();
259                    if (params.size() != args.size()) {
260                        error("Incorrect number of static arguments for type '" +
261                              NodeUtil.nameString(n) + "': provided " + args.size() +
262                              ", expected " + params.size(), that);
263                        return that;
264                    }
265                    boolean changed = !n.equals(that.getName());
266                    List<StaticArg> newArgs = new ArrayList<StaticArg>(args.size());
267                    for (Pair<StaticParam, StaticArg> pair :
268                             IterUtil.zip(params, args)) {
269                        StaticArg updated = updateStaticArg(pair.second(), pair.first());
270                        if (updated != pair.second()) { changed = true; }
271                        newArgs.add(updated);
272                    }
273                    return changed ?
274                    NodeFactory.makeTraitType(NodeUtil.getSpan(that), n, newArgs) : that;
275                }
276            }
277        };
278        return handleTypeName(that, that.getName(), varHandler, typeConsHandler);
279    }
280
281    /**
282     * Generalization of name handling in {@code forVarType} and
283     * {@code forTraitType}.  Disambiguate the given type name,
284     * determine whether it is a variable or a type constructor, and delegate to the
285     * appropriate handler.
286     * @param that  The type that is being translated (used as a result when errors
287     *              occur).
288     * @param n  The type name to be resolved (provided by {@code that}).
289     * @param variableHandler  Produces the appropriate result where {@code n} represents
290     *                         a type variable.  May assume that {@code n} has no
291     *                         API and was not changed.
292     * @param typeConsHandler  Produce the appropriate result where {@code n} represents
293     *                         a type constructor (trait, object, or type alias) name.
294     *                         An updated, potentially-qualified version of {@code n} is
295     *                         provided.  May assume that the named type constructor
296     *                         exists.
297     */
298    private Type handleTypeName(Type that, Id n,
299                                Thunk<Type> variableHandler,
300                                Lambda<Id, Type> typeConsHandler) {
301        if (n.getApiName().isSome()) {
302            APIName originalApi = n.getApiName().unwrap();
303            Option<APIName> realApiOpt = _env.apiName(originalApi);
304            if (realApiOpt.isNone()) {
305                // retry for debugging purposes
306                realApiOpt = _env.apiName(originalApi);
307                error("Undefined API: " + NodeUtil.nameString(originalApi), originalApi);
308                return that;
309            }
310            APIName realApi = realApiOpt.unwrap();
311            Id newN;
312            if (originalApi == realApi) { newN = n; }
313            else { newN = NodeFactory.makeId(realApi, n); }
314
315            if (!_env.hasQualifiedTypeCons(newN)) {
316                error(NodeUtil.nameString(newN) + " is undefined.", newN);
317                return that;
318            }
319            return typeConsHandler.value(newN);
320        }
321
322        else {
323            if (_env.hasTypeParam(n).isSome()) { return variableHandler.value(); }
324            else {
325                Set<Id> typeConses = _env.explicitTypeConsNames(n);
326                if (typeConses.isEmpty()) {
327                    typeConses = _env.onDemandTypeConsNames(n);
328                    _onDemandImports.add(n);
329                }
330                if (typeConses.isEmpty()) {
331                    error(NodeUtil.nameString(n)+" is undefined.", n);
332                    return that;
333                }
334                if (typeConses.size() > 1) {
335                    error("Type name may refer to: " + NodeUtil.namesString(typeConses),
336                            n);
337                    return that;
338                }
339                Id qname = IterUtil.first(typeConses);
340                Type result = typeConsHandler.value(qname);
341
342                return result;
343            }
344        }
345    }
346
347    /**
348     * Prevent recursion on function static args -- delayed until the function references
349     * can be resolved.
350     */
351//    @Override public Node forFnRef(FnRef that) {
352//        return that;
353//    }
354
355
356    private StaticArg updateStaticArg(final StaticArg a, final StaticParam p) {
357        // return a;
358        /* Commented out due to assumptions in the interpreter that this *isn't* implemented: */
359        StaticArg fixed = a.accept(new NodeAbstractVisitor<StaticArg>() {
360
361            @Override public StaticArg forTypeArg(final TypeArg a) {
362                final Type t = a.getTypeArg();
363                if (t instanceof VarType) {
364                    final Span s = NodeUtil.getSpan(a);
365                    final Id name = ((VarType) t).getName();
366                    return p.getKind().accept(new NodeAbstractVisitor<StaticArg>() {
367                            @Override public StaticArg forKindBool(KindBool k) {
368                                return NodeFactory.makeBoolArg(s, NodeFactory.makeBoolRef(s, name));
369                            }
370                            @Override public StaticArg forKindDim(KindDim p) {
371                                return NodeFactory.makeDimArg(s, NodeFactory.makeDimRef(s, name));
372                            }
373                            @Override public StaticArg forKindInt(KindInt p) {
374                                return NodeFactory.makeIntArg(s, NodeFactory.makeIntRef(s, name));
375                            }
376                            @Override public StaticArg forKindNat(KindNat p) {
377                                return NodeFactory.makeIntArg(s, NodeFactory.makeIntRef(s, name));
378                                // TODO: shouldn't there be a NatArg class?
379                            }
380                            @Override public StaticArg forKindType(KindType p) {
381                                return a;
382                            }
383                            @Override public StaticArg forKindUnit(KindUnit p) {
384                                return NodeFactory.makeUnitArg(s, NodeFactory.makeUnitRef(s, false, name));
385                            }
386                            @Override public StaticArg forKindOp(KindOp p) {
387                                mismatch("an identifier");
388                                return a;
389                            }
390                        });
391                }
392                else {
393                    if ( ! NodeUtil.isTypeParam(p) ) { mismatch("a type"); }
394                    return a;
395                }
396            }
397
398            @Override public StaticArg forIntArg(IntArg a) {
399                if (! NodeUtil.isIntParam(p) ) {
400                    mismatch("an int expression");
401                }
402                return a;
403            }
404
405            @Override public StaticArg forBoolArg(BoolArg a) {
406                if (! NodeUtil.isBoolParam(p) ) { mismatch("a bool expression"); }
407                return a;
408            }
409
410            @Override public StaticArg forOpArg(OpArg a) {
411                if (! NodeUtil.isOpParam(p) ) { mismatch("an operator"); }
412                return a;
413            }
414
415            @Override public StaticArg forDimArg(DimArg a) {
416                if (! NodeUtil.isDimParam(p)) { mismatch("a dimension"); }
417                return a;
418            }
419
420            @Override public StaticArg forUnitArg(UnitArg a) {
421                // TODO: convert units to dimensions
422                if (! NodeUtil.isUnitParam(p)) { mismatch("a unit"); }
423                return a;
424            }
425
426            private void mismatch(String given) {
427                String expected = p.getKind().accept(new NodeAbstractVisitor<String>() {
428                        @Override public String forKindBool(KindBool k) {
429                            return "a bool expression";
430                        }
431                        @Override public String forKindDim(KindDim k) {
432                            return "a dimension";
433                        }
434                        @Override public String forKindInt(KindInt k) {
435                            return "an int expression";
436                        }
437                        @Override public String forKindNat(KindNat k) {
438                            return "a nat expression";
439                        }
440                        @Override public String forKindType(KindType k) {
441                            return "a type";
442                        }
443                        @Override public String forKindUnit(KindUnit k) {
444                            return "a unit";
445                        }
446                        @Override public String forKindOp(KindOp k) {
447                            return "an operator";
448                        }
449                    });
450                error("Type parameter mismatch: given " + given + ", expected " + expected, a);
451            }
452
453        });
454        return (StaticArg) fixed.accept(this);
455
456    }
457
458    private Pair<List<Id>, Collection<GrammarIndex>> getExtendedGrammarIndecies(GrammarDecl that) {
459        List<Id> ls = new LinkedList<Id>();
460        Collection<GrammarIndex> gs = new LinkedList<GrammarIndex>();
461        for (Id name: that.getExtendsClause()) {
462            Id nname = handleGrammarName(name);
463            ls.add(nname);
464            Option<GrammarIndex> gi = this._env.grammarIndex(nname);
465            if (gi.isSome()) {
466                gs.add(gi.unwrap());
467            }
468            else {
469                error("Undefined grammar: " + NodeUtil.nameString(nname), name);
470            }
471        }
472        return new Pair<List<Id>, Collection<GrammarIndex>>(ls,gs);
473    }
474
475    @Override public Node forSuperSyntaxDefOnly(SuperSyntaxDef that,
476                                                ASTNodeInfo info,
477                                                Id nonterminal_result, Id grammar_result) {
478        Id disambiguatedGrammar = handleGrammarName(grammar_result);
479        return new SuperSyntaxDef(info,
480                                  that.getModifier(), nonterminal_result, disambiguatedGrammar);
481    }
482
483    @Override
484    public Node forGrammarDeclOnly(GrammarDecl that,
485                                   ASTNodeInfo info, Id name_result,
486            List<Id> extends_result,
487            List<GrammarMemberDecl> members_result,
488            List<TransformerDecl> transformers) {
489
490        Pair<List<Id>, Collection<GrammarIndex>> p = getExtendedGrammarIndecies(that);
491
492        Id name = handleGrammarName(name_result);
493
494        GrammarDecl disambiguatedGrammar = new GrammarDecl(info,
495                                                           name, p.first(), members_result, transformers, that.isNativeDef());
496
497        List<StaticError> newErrs = new ArrayList<StaticError>();
498
499        if (!newErrs.isEmpty()) {
500            this._errors.addAll(newErrs);
501        }
502
503        return disambiguatedGrammar;
504    }
505
506    private Id handleGrammarName(Id name) {
507        if (name.getApiName().isSome()) {
508            APIName originalApi = name.getApiName().unwrap();
509            Option<APIName> realApiOpt = _env.apiName(originalApi);
510            if (realApiOpt.isNone()) {
511                error("Undefined API: " + NodeUtil.nameString(originalApi), originalApi);
512                return name;
513            }
514            APIName realApi = realApiOpt.unwrap();
515            Id newN;
516            if (originalApi == realApi) { newN = name; }
517            else { newN = NodeFactory.makeId(NodeUtil.getSpan(name), realApi, name); }
518
519            if (!_env.hasQualifiedGrammar(newN)) {
520                error("Undefined grammar: " + NodeUtil.nameString(newN), newN);
521                return name;
522            }
523            return newN;
524        }
525        else {
526         String uqname = name.getText();
527            if (_env.hasGrammar(uqname)) {
528                Set<Id> grammars = _env.explicitGrammarNames(uqname);
529                if (grammars.size() > 1) {
530                    error("Grammar name may refer to: " + NodeUtil.namesString(grammars), name);
531                    return name;
532                }
533                Id qname = IterUtil.first(grammars);
534                return qname;
535            }
536            else {
537                Set<Id> grammars = _env.explicitGrammarNames(uqname);
538                if (grammars.isEmpty()) {
539                    grammars = _env.onDemandGrammarNames(uqname);
540                    _onDemandImports.add(name);
541                }
542
543                if (grammars.isEmpty()) {
544                    error("Undefined grammar: " + NodeUtil.nameString(name), name);
545                    return name;
546                }
547                if (grammars.size() > 1) {
548                    error("Grammar name may refer to: " + NodeUtil.namesString(grammars), name);
549                    return name;
550                }
551                Id qname = IterUtil.first(grammars);
552                return qname;
553            }
554        }
555    }
556
557    @Override
558    public Node forNonterminalHeader(NonterminalHeader that) {
559        TypeDisambiguator v = this.extend(that.getStaticParams());
560
561//        System.err.println("T: "+that.getParamType());
562
563        Option<Type> t = v.recurOnOptionOfType(that.getParamType());
564//        System.err.println("t: "+t);
565        return forNonterminalHeaderOnly(that,
566                                        that.getInfo(),
567            (Id) that.getName().accept(v),
568            v.recurOnListOfNonterminalParameter(that.getParams()),
569            v.recurOnListOfStaticParam(that.getStaticParams()),
570            t ,
571            v.recurOnOptionOfWhereClause(that.getWhereClause()));
572    }
573
574    /**
575     * All Args are parsed as TypeArgs
576     */
577    @Override
578        public Node forTypeArgOnly(final TypeArg arg,
579                                   ASTNodeInfo info,
580                                   final Type t) {
581        if(arg.getTypeArg() instanceof VarType){
582            Id _name = ((VarType)arg.getTypeArg()).getName();
583            Option<StaticParam> param=this._env.hasTypeParam(_name);
584            if(param.isSome()){
585                final IdOrOp name = param.unwrap().getName();
586                NodeAbstractVisitor<StaticArg> v =new NodeAbstractVisitor<StaticArg>(){
587                    @Override public StaticArg forKindBool(KindBool k) {
588                        return NodeFactory.makeBoolArg(NodeUtil.getSpan(arg), NodeFactory.makeBoolRef(NodeUtil.getSpan(arg), (Id)name));
589                    }
590                    @Override
591                    public StaticArg forKindDim(KindDim k) {
592                        return NodeFactory.makeDimArg(NodeUtil.getSpan(arg), NodeFactory.makeDimRef(NodeUtil.getSpan(arg), (Id)name));
593                    }
594                    @Override
595                    public StaticArg forKindInt(KindInt k) {
596                        return NodeFactory.makeIntArg(NodeUtil.getSpan(arg), NodeFactory.makeIntRef(NodeUtil.getSpan(arg), (Id)name));
597                    }
598                    @Override
599                    public StaticArg forKindNat(KindNat k) {
600                        return NodeFactory.makeIntArg(NodeUtil.getSpan(arg), NodeFactory.makeIntRef(NodeUtil.getSpan(arg), (Id)name));
601                    }
602                    @Override
603                    public StaticArg forKindType(KindType k) {
604                        return NodeFactory.makeTypeArg(NodeUtil.getSpan(arg),t);
605                    }
606                    @Override
607                    public StaticArg forKindUnit(KindUnit k) {
608                        return NodeFactory.makeUnitArg(NodeUtil.getSpan(arg),
609                                           NodeFactory.makeUnitRef(NodeUtil.getSpan(arg), false, (Id)name));
610                    }
611                    @Override
612                    public StaticArg forKindOp(KindOp that) {
613                        return NodeFactory.makeOpArg(NodeUtil.getSpan(arg), ExprFactory.makeOpRef( (Op)name));
614                    }
615                };
616                return param.unwrap().getKind().accept(v);
617            }
618        }
619        return NodeFactory.makeTypeArg(NodeUtil.getSpan(arg),t);
620    }
621
622}
Note: See TracBrowser for help on using the browser.