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

Revision 3246, 26.9 KB (checked in by sukyoungryu, 11 months ago)

[ast refactoring] Replaced the span field, which every AST node contains, with the info field. Commented out two syntactic abstraction tests. Will add them back when we have cycles to clean up the syntactic abstraction code.
Line 
1/*******************************************************************************
2    Copyright 2008 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                error("Undefined API: " + NodeUtil.nameString(originalApi), originalApi);
306                return that;
307            }
308            APIName realApi = realApiOpt.unwrap();
309            Id newN;
310            if (originalApi == realApi) { newN = n; }
311            else { newN = NodeFactory.makeId(realApi, n); }
312
313            if (!_env.hasQualifiedTypeCons(newN)) {
314                error(NodeUtil.nameString(newN) + " is undefined.", newN);
315                return that;
316            }
317            return typeConsHandler.value(newN);
318        }
319
320        else {
321            if (_env.hasTypeParam(n).isSome()) { return variableHandler.value(); }
322            else {
323                Set<Id> typeConses = _env.explicitTypeConsNames(n);
324                if (typeConses.isEmpty()) {
325                    typeConses = _env.onDemandTypeConsNames(n);
326                    _onDemandImports.add(n);
327                }
328                if (typeConses.isEmpty()) {
329                    error(NodeUtil.nameString(n)+" is undefined.", n);
330                    return that;
331                }
332                if (typeConses.size() > 1) {
333                    error("Type name may refer to: " + NodeUtil.namesString(typeConses),
334                            n);
335                    return that;
336                }
337                Id qname = IterUtil.first(typeConses);
338                Type result = typeConsHandler.value(qname);
339
340                return result;
341            }
342        }
343    }
344
345    /**
346     * Prevent recursion on function static args -- delayed until the function references
347     * can be resolved.
348     */
349//    @Override public Node forFnRef(FnRef that) {
350//        return that;
351//    }
352
353
354    private StaticArg updateStaticArg(final StaticArg a, final StaticParam p) {
355        // return a;
356        /* Commented out due to assumptions in the interpreter that this *isn't* implemented: */
357        StaticArg fixed = a.accept(new NodeAbstractVisitor<StaticArg>() {
358
359            @Override public StaticArg forTypeArg(final TypeArg a) {
360                final Type t = a.getTypeArg();
361                if (t instanceof VarType) {
362                    final Span s = NodeUtil.getSpan(a);
363                    final Id name = ((VarType) t).getName();
364                    return p.getKind().accept(new NodeAbstractVisitor<StaticArg>() {
365                            @Override public StaticArg forKindBool(KindBool k) {
366                                return NodeFactory.makeBoolArg(s, NodeFactory.makeBoolRef(s, name));
367                            }
368                            @Override public StaticArg forKindDim(KindDim p) {
369                                return NodeFactory.makeDimArg(s, NodeFactory.makeDimRef(s, name));
370                            }
371                            @Override public StaticArg forKindInt(KindInt p) {
372                                return NodeFactory.makeIntArg(s, NodeFactory.makeIntRef(s, name));
373                            }
374                            @Override public StaticArg forKindNat(KindNat p) {
375                                return NodeFactory.makeIntArg(s, NodeFactory.makeIntRef(s, name));
376                                // TODO: shouldn't there be a NatArg class?
377                            }
378                            @Override public StaticArg forKindType(KindType p) {
379                                return a;
380                            }
381                            @Override public StaticArg forKindUnit(KindUnit p) {
382                                return NodeFactory.makeUnitArg(s, NodeFactory.makeUnitRef(s, false, name));
383                            }
384                            @Override public StaticArg forKindOp(KindOp p) {
385                                mismatch("an identifier");
386                                return a;
387                            }
388                        });
389                }
390                else {
391                    if ( ! NodeUtil.isTypeParam(p) ) { mismatch("a type"); }
392                    return a;
393                }
394            }
395
396            @Override public StaticArg forIntArg(IntArg a) {
397                if (! NodeUtil.isIntParam(p) ) {
398                    mismatch("an int expression");
399                }
400                return a;
401            }
402
403            @Override public StaticArg forBoolArg(BoolArg a) {
404                if (! NodeUtil.isBoolParam(p) ) { mismatch("a bool expression"); }
405                return a;
406            }
407
408            @Override public StaticArg forOpArg(OpArg a) {
409                if (! NodeUtil.isOpParam(p) ) { mismatch("an operator"); }
410                return a;
411            }
412
413            @Override public StaticArg forDimArg(DimArg a) {
414                if (! NodeUtil.isDimParam(p)) { mismatch("a dimension"); }
415                return a;
416            }
417
418            @Override public StaticArg forUnitArg(UnitArg a) {
419                // TODO: convert units to dimensions
420                if (! NodeUtil.isUnitParam(p)) { mismatch("a unit"); }
421                return a;
422            }
423
424            private void mismatch(String given) {
425                String expected = p.getKind().accept(new NodeAbstractVisitor<String>() {
426                        @Override public String forKindBool(KindBool k) {
427                            return "a bool expression";
428                        }
429                        @Override public String forKindDim(KindDim k) {
430                            return "a dimension";
431                        }
432                        @Override public String forKindInt(KindInt k) {
433                            return "an int expression";
434                        }
435                        @Override public String forKindNat(KindNat k) {
436                            return "a nat expression";
437                        }
438                        @Override public String forKindType(KindType k) {
439                            return "a type";
440                        }
441                        @Override public String forKindUnit(KindUnit k) {
442                            return "a unit";
443                        }
444                        @Override public String forKindOp(KindOp k) {
445                            return "an operator";
446                        }
447                    });
448                error("Type parameter mismatch: given " + given + ", expected " + expected, a);
449            }
450
451        });
452        return (StaticArg) fixed.accept(this);
453
454    }
455
456    private Pair<List<Id>, Collection<GrammarIndex>> getExtendedGrammarIndecies(GrammarDecl that) {
457        List<Id> ls = new LinkedList<Id>();
458        Collection<GrammarIndex> gs = new LinkedList<GrammarIndex>();
459        for (Id name: that.getExtendsClause()) {
460            Id nname = handleGrammarName(name);
461            ls.add(nname);
462            Option<GrammarIndex> gi = this._env.grammarIndex(nname);
463            if (gi.isSome()) {
464                gs.add(gi.unwrap());
465            }
466            else {
467                error("Undefined grammar: " + NodeUtil.nameString(nname), name);
468            }
469        }
470        return new Pair<List<Id>, Collection<GrammarIndex>>(ls,gs);
471    }
472
473    @Override public Node forSuperSyntaxDefOnly(SuperSyntaxDef that,
474                                                ASTNodeInfo info,
475                                                Id nonterminal_result, Id grammar_result) {
476        Id disambiguatedGrammar = handleGrammarName(grammar_result);
477        return new SuperSyntaxDef(info,
478                                  that.getModifier(), nonterminal_result, disambiguatedGrammar);
479    }
480
481    @Override
482    public Node forGrammarDeclOnly(GrammarDecl that,
483                                   ASTNodeInfo info, Id name_result,
484            List<Id> extends_result,
485            List<GrammarMemberDecl> members_result,
486            List<TransformerDecl> transformers) {
487
488        Pair<List<Id>, Collection<GrammarIndex>> p = getExtendedGrammarIndecies(that);
489
490        Id name = handleGrammarName(name_result);
491
492        GrammarDecl disambiguatedGrammar = new GrammarDecl(info,
493                                                           name, p.first(), members_result, transformers, that.isNativeDef());
494
495        List<StaticError> newErrs = new ArrayList<StaticError>();
496
497        if (!newErrs.isEmpty()) {
498            this._errors.addAll(newErrs);
499        }
500
501        return disambiguatedGrammar;
502    }
503
504    private Id handleGrammarName(Id name) {
505        if (name.getApiName().isSome()) {
506            APIName originalApi = name.getApiName().unwrap();
507            Option<APIName> realApiOpt = _env.apiName(originalApi);
508            if (realApiOpt.isNone()) {
509                error("Undefined API: " + NodeUtil.nameString(originalApi), originalApi);
510                return name;
511            }
512            APIName realApi = realApiOpt.unwrap();
513            Id newN;
514            if (originalApi == realApi) { newN = name; }
515            else { newN = NodeFactory.makeId(NodeUtil.getSpan(name), realApi, name); }
516
517            if (!_env.hasQualifiedGrammar(newN)) {
518                error("Undefined grammar: " + NodeUtil.nameString(newN), newN);
519                return name;
520            }
521            return newN;
522        }
523        else {
524         String uqname = name.getText();
525            if (_env.hasGrammar(uqname)) {
526                Set<Id> grammars = _env.explicitGrammarNames(uqname);
527                if (grammars.size() > 1) {
528                    error("Grammar name may refer to: " + NodeUtil.namesString(grammars), name);
529                    return name;
530                }
531                Id qname = IterUtil.first(grammars);
532                return qname;
533            }
534            else {
535                Set<Id> grammars = _env.explicitGrammarNames(uqname);
536                if (grammars.isEmpty()) {
537                    grammars = _env.onDemandGrammarNames(uqname);
538                    _onDemandImports.add(name);
539                }
540
541                if (grammars.isEmpty()) {
542                    error("Undefined grammar: " + NodeUtil.nameString(name), name);
543                    return name;
544                }
545                if (grammars.size() > 1) {
546                    error("Grammar name may refer to: " + NodeUtil.namesString(grammars), name);
547                    return name;
548                }
549                Id qname = IterUtil.first(grammars);
550                return qname;
551            }
552        }
553    }
554
555    @Override
556    public Node forNonterminalHeader(NonterminalHeader that) {
557        TypeDisambiguator v = this.extend(that.getStaticParams());
558
559//        System.err.println("T: "+that.getParamType());
560
561        Option<Type> t = v.recurOnOptionOfType(that.getParamType());
562//        System.err.println("t: "+t);
563        return forNonterminalHeaderOnly(that,
564                                        that.getInfo(),
565            (Id) that.getName().accept(v),
566            v.recurOnListOfNonterminalParameter(that.getParams()),
567            v.recurOnListOfStaticParam(that.getStaticParams()),
568            t ,
569            v.recurOnOptionOfWhereClause(that.getWhereClause()));
570    }
571
572    /**
573     * All Args are parsed as TypeArgs
574     */
575    @Override
576        public Node forTypeArgOnly(final TypeArg arg,
577                                   ASTNodeInfo info,
578                                   final Type t) {
579        if(arg.getTypeArg() instanceof VarType){
580            Id _name = ((VarType)arg.getTypeArg()).getName();
581            Option<StaticParam> param=this._env.hasTypeParam(_name);
582            if(param.isSome()){
583                final IdOrOp name = param.unwrap().getName();
584                NodeAbstractVisitor<StaticArg> v =new NodeAbstractVisitor<StaticArg>(){
585                    @Override public StaticArg forKindBool(KindBool k) {
586                        return NodeFactory.makeBoolArg(NodeUtil.getSpan(arg), NodeFactory.makeBoolRef(NodeUtil.getSpan(arg), (Id)name));
587                    }
588                    @Override
589                    public StaticArg forKindDim(KindDim k) {
590                        return NodeFactory.makeDimArg(NodeUtil.getSpan(arg), NodeFactory.makeDimRef(NodeUtil.getSpan(arg), (Id)name));
591                    }
592                    @Override
593                    public StaticArg forKindInt(KindInt k) {
594                        return NodeFactory.makeIntArg(NodeUtil.getSpan(arg), NodeFactory.makeIntRef(NodeUtil.getSpan(arg), (Id)name));
595                    }
596                    @Override
597                    public StaticArg forKindNat(KindNat k) {
598                        return NodeFactory.makeIntArg(NodeUtil.getSpan(arg), NodeFactory.makeIntRef(NodeUtil.getSpan(arg), (Id)name));
599                    }
600                    @Override
601                    public StaticArg forKindType(KindType k) {
602                        return NodeFactory.makeTypeArg(NodeUtil.getSpan(arg),t);
603                    }
604                    @Override
605                    public StaticArg forKindUnit(KindUnit k) {
606                        return NodeFactory.makeUnitArg(NodeUtil.getSpan(arg),
607                                           NodeFactory.makeUnitRef(NodeUtil.getSpan(arg), false, (Id)name));
608                    }
609                    @Override
610                    public StaticArg forKindOp(KindOp that) {
611                        return NodeFactory.makeOpArg(NodeUtil.getSpan(arg), ExprFactory.makeOpRef( (Op)name));
612                    }
613                };
614                return param.unwrap().getKind().accept(v);
615            }
616        }
617        return NodeFactory.makeTypeArg(NodeUtil.getSpan(arg),t);
618    }
619
620}
Note: See TracBrowser for help on using the browser.