Changeset 3114

Show
Ignore:
Timestamp:
11/26/08 20:01:54 (12 months ago)
Author:
sukyoungryu
Message:

[ast refactoring] Eliminated Domain.

Location:
trunk/ProjectFortress
Files:
19 modified

Legend:

Unmodified
Added
Removed

  • trunk/ProjectFortress/astgen/Fortress.ast

    r3113 r3114  
    13561356                 * e.g.) (ZZ32, String) 
    13571357                 * 
    1358                  * <varargs> 
    1359                  * It has a varargs parameter if the varargs field is set. 
    1360                  */ 
    1361                 TupleType(List<Type> elements, 
    1362                           Option<Type> varargs = Option.<Type>none()); 
    1363                 /** 
    13641358                 * domain of an arrow type 
    13651359                 * ArgType ::= 
    … …  
    13691363                 * e.g.) ZZ32 
    13701364                 * e.g.) (String, ZZ32, String..., foo=ZZ32) 
    1371                  */ 
    1372                 Domain(List<Type> args, 
    1373                        Option<Type> varargs = Option.<Type>none(), 
    1374                        List<KeywordType> keywords = Collections.<KeywordType>emptyList()); 
     1365                 * 
     1366                 * <varargs> 
     1367                 * It has a varargs parameter if the varargs field is set. 
     1368                 */ 
     1369                TupleType(List<Type> elements, 
     1370                          Option<Type> varargs = Option.<Type>none(), 
     1371                          List<KeywordType> keywords = Collections.<KeywordType>emptyList()); 
    13751372                /** 
    13761373                 * void type 
    … …  
    13821379                 * arrow type 
    13831380                 */ 
    1384                 abstract AbstractArrowType(Domain domain, Type range, 
     1381                abstract AbstractArrowType(Type domain, Type range, 
    13851382                                           Effect effect = FortressUtil.emptyEffect()); 
    13861383                    /** 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/Types.java

    r3109 r3114  
    5858    public static final TraitType OBJECT = makeTraitType(fortressBuiltin, "Object"); 
    5959 
    60     public static final Domain BOTTOM_DOMAIN = NodeFactory.makeDomain(BOTTOM); 
     60    public static final Type BOTTOM_DOMAIN = BOTTOM; 
    6161 
    6262    public static final VoidType VOID = new VoidType(span); 
    … …  
    241241     * representing a singleton argument. 
    242242     */ 
    243     public static Type stripKeywords(Domain d) { 
    244         if (d.getVarargs().isSome()) { 
    245             return new TupleType(NodeFactory.makeSpan(d.getArgs(), d.getVarargs().unwrap()), d.getArgs(), d.getVarargs()); 
    246         } 
    247         else { 
    248             List<Type> args = d.getArgs(); 
    249             switch (args.size()) { 
    250                 case 0: return VOID; 
    251                 case 1: return args.get(0); 
    252                 default: return new TupleType(NodeFactory.makeSpan("impossible", args), args); 
    253             } 
    254         } 
     243    public static Type stripKeywords(Type d) { 
     244        if ( d instanceof TupleType ) { 
     245            TupleType _d = (TupleType)d; 
     246            if (_d.getVarargs().isSome()) { 
     247                return new TupleType(NodeFactory.makeSpan(_d.getElements(), _d.getVarargs().unwrap()), _d.getElements(), _d.getVarargs()); 
     248            } 
     249            else { 
     250                List<Type> args = _d.getElements(); 
     251                switch (args.size()) { 
     252                    case 0: return VOID; 
     253                    case 1: return args.get(0); 
     254                    default: return new TupleType(NodeFactory.makeSpan("impossible", args), args); 
     255                } 
     256            } 
     257        } else 
     258            return d; 
    255259    } 
    256260 
    … …  
    259263     * map is identical to that of the KeywordType list. 
    260264     */ 
    261     public static Map<Id, Type> extractKeywords(Domain d) { 
    262         // Don't waste time allocating a map if it will be empty (the usual case) 
    263         if (d.getKeywords().isEmpty()) { return Collections.<Id, Type>emptyMap(); } 
    264         else { 
    265             Map<Id, Type> result = new LinkedHashMap<Id, Type>(8); 
    266             for (KeywordType k : d.getKeywords()) { 
    267                 result.put(k.getName(), k.getType()); 
    268             } 
    269             return result; 
    270         } 
     265    public static Map<Id, Type> extractKeywords(Type d) { 
     266        if ( d instanceof TupleType ) { 
     267            TupleType _d = (TupleType)d; 
     268            // Don't waste time allocating a map if it will be empty (the usual case) 
     269            if (_d.getKeywords().isEmpty()) { return Collections.<Id, Type>emptyMap(); } 
     270            else { 
     271                Map<Id, Type> result = new LinkedHashMap<Id, Type>(8); 
     272                for (KeywordType k : _d.getKeywords()) { 
     273                    result.put(k.getName(), k.getType()); 
     274                } 
     275                return result; 
     276            } 
     277        } else 
     278            return Collections.<Id, Type>emptyMap(); 
    271279    } 
    272280 
    … …  
    275283     * and a keywords map representing the keyword arguments. 
    276284     */ 
    277     public static Domain makeDomain(Type argsType, Map<Id, Type> keywords) { 
     285    public static Type makeDomain(Type argsType, Map<Id, Type> keywords) { 
    278286        List<KeywordType> keywordList = new ArrayList<KeywordType>(keywords.size()); 
    279287        for (Map.Entry<Id, Type> entry : keywords.entrySet()) { 
    … …  
    288296     * not assume that {@code argsType} was produced by the parser. 
    289297     */ 
    290     public static Domain makeDomain(Type argsType, final List<KeywordType> keywords) { 
    291         return argsType.accept(new NodeAbstractVisitor<Domain>() { 
    292             @Override public Domain forVoidType(VoidType t) { 
    293                 return new Domain(NodeFactory.makeSpan("Types_bogus_span_for_empty_list", keywords), Collections.<Type>emptyList(), keywords); 
    294             } 
    295             @Override public Domain forTupleType(TupleType t) { 
     298    public static Type makeDomain(Type argsType, final List<KeywordType> keywords) { 
     299        return argsType.accept(new NodeAbstractVisitor<Type>() { 
     300            @Override public Type forVoidType(VoidType t) { 
     301                if ( keywords.isEmpty() ) 
     302                    return t; 
     303                else 
     304                    return new TupleType(NodeFactory.makeSpan("Types_bogus_span_for_empty_list", keywords), 
     305                                         Collections.<Type>emptyList(), keywords); 
     306            } 
     307            @Override public Type forTupleType(TupleType t) { 
    296308                if ( t.getVarargs().isNone() ) 
    297                     return new Domain(NodeFactory.makeSpan(t, keywords), t.getElements(), keywords); 
     309                    return new TupleType(NodeFactory.makeSpan(t, keywords), t.getElements(), keywords); 
    298310                else 
    299                     return new Domain(NodeFactory.makeSpan(t, keywords), t.getElements(), t.getVarargs(), 
    300                                       keywords); 
    301             } 
    302             @Override public Domain forType(Type t) { 
    303                 return new Domain(NodeFactory.makeSpan(t, keywords), Collections.singletonList(t), keywords); 
     311                    return new TupleType(NodeFactory.makeSpan(t, keywords), t.getElements(), t.getVarargs(), 
     312                                         keywords); 
     313            } 
     314            @Override public Type forType(Type t) { 
     315                if ( keywords.isEmpty() ) 
     316                    return t; 
     317                else 
     318                    return new TupleType(NodeFactory.makeSpan(t, keywords), Collections.singletonList(t), keywords); 
    304319            } 
    305320        }); 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/disambiguator/TypeDisambiguator.java

    r3098 r3114  
    3232import com.sun.fortress.nodes.ObjectDecl; 
    3333import com.sun.fortress.nodes.AnyType; 
     34import com.sun.fortress.nodes.TupleType; 
    3435import com.sun.fortress.nodes.ArrowType; 
    3536import com.sun.fortress.nodes.BoolArg; 
    … …  
    3940import com.sun.fortress.nodes.DimParam; 
    4041import com.sun.fortress.nodes.DimRef; 
    41 import com.sun.fortress.nodes.Domain; 
    4242import com.sun.fortress.nodes.Effect; 
    4343import com.sun.fortress.nodes.Expr; 
    … …  
    189189 
    190190    @Override public Node forArrowType(final ArrowType that) { 
    191         // make sure this.forDomain is *not* called 
    192         Domain domainResult = (Domain) super.forDomain(that.getDomain()); 
     191        Type domain = that.getDomain(); 
     192        Type domainResult; 
     193        if ( domain instanceof TupleType ) 
     194            domainResult = (Type) super.forTupleType( (TupleType)domain ); 
     195        else 
     196            domainResult = (Type) domain.accept(this); 
    193197        Type rangeResult = (Type) that.getRange().accept(this); 
    194198        Effect effectResult = (Effect) that.getEffect().accept(this); 
    195199        return forArrowTypeOnly(that, domainResult, rangeResult, effectResult); 
    196     } 
    197  
    198     @Override public Node forDomain(final Domain that) { 
    199         // valid occurrences of Domain are recognized before this recursive 
    200         // call takes place 
    201         error("Tuple types are not allowed to have varargs or keyword types.", that); 
    202         return that; 
    203200    } 
    204201 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/SubtypeChecker.java

    r3109 r3114  
    836836    } 
    837837 
    838     private Boolean subdomain(Domain s, Domain t, SubtypeHistory history) { 
     838    private Boolean subdomain(Type s, Type t, SubtypeHistory history) { 
    839839        if (subtype(stripKeywords(s), stripKeywords(t), history)) { 
    840840            Map<Id, Type> sMap = extractKeywords(s); 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java

    r3109 r3114  
    254254 
    255255                @Override public Type forTupleTypeOnly(TupleType t, List<Type> normalElements, 
    256                                                        Option<Type> normalVarargs) { 
     256                                                       Option<Type> normalVarargs, 
     257                                                       List<KeywordType> keywords) { 
    257258                    if ( normalVarargs.isNone() ) { 
    258259                        Type result = handleAbstractTuple(normalElements, MAKE_TUPLE); 
    … …  
    283284                } 
    284285 
     286                @Override public Type forTupleType(TupleType that) { 
     287                    if ( that.getKeywords().isEmpty() ) { 
     288                        List<Type> args_result = recurOnListOfType(that.getElements()); 
     289                        Option<Type> varargs_result = recurOnOptionOfType(that.getVarargs()); 
     290                        List<KeywordType> keywords_result = recurOnListOfKeywordType(that.getKeywords()); 
     291                        return forTupleTypeOnly(that, args_result, varargs_result, keywords_result); 
     292                    } else { 
     293                        // recur on a single args type rather than each element individually 
     294                        Type args = stripKeywords(that); 
     295                        Type argsNorm = (Type) args.accept(this); 
     296                        List<KeywordType> ks = that.getKeywords(); 
     297                        List<KeywordType> ksNorm = recurOnListOfKeywordType(ks); 
     298                        if (args == argsNorm && ks == ksNorm) { return that; } 
     299                        else { return makeDomain(argsNorm, ksNorm); } 
     300                    } 
     301                } 
     302 
    285303            private Type handleAbstractTuple(Iterable<Type> normalElements, 
    286304                                             final Lambda<Iterable<Type>, Type> factory) { 
    … …  
    299317            } 
    300318 
    301             @Override public Type forArrowTypeOnly(ArrowType t, Domain normalDomain, Type normalRange, 
     319            @Override public Type forArrowTypeOnly(ArrowType t, Type normalDomain, Type normalRange, 
    302320                                                   final Effect normalEffect) { 
    303321                Type domainArg = stripKeywords(normalDomain); 
    … …  
    305323                Iterable<Type> domainTs = compose(domainArg, domainKeys.values()); 
    306324                // map a list of the length of domainTs back to a Domain: 
    307                 Lambda<Iterable<Type>, Domain> domainFactory = new Lambda<Iterable<Type>, Domain>() { 
    308                     public Domain value(Iterable<Type> ts) { 
     325                Lambda<Iterable<Type>, Type> domainFactory = new Lambda<Iterable<Type>, Type>() { 
     326                    public Type value(Iterable<Type> ts) { 
    309327                        List<KeywordType> ks = new ArrayList<KeywordType>(domainKeys.size()); 
    310328                        for (Pair<Id, Type> p : zip(domainKeys.keySet(), skipFirst(ts))) { 
    … …  
    314332                    } 
    315333                }; 
    316                 Iterable<Domain> domains = map(cross(map(domainTs, DISJUNCTS)), domainFactory); 
     334                Iterable<Type> domains = map(cross(map(domainTs, DISJUNCTS)), domainFactory); 
    317335                Iterable<Type> ranges = liftConjuncts(normalRange, history); 
    318                 Iterable<Type> overloads = cross(domains, ranges, new Lambda2<Domain, Type, Type>() { 
    319                     public Type value(Domain d, Type r) { 
     336                Iterable<Type> overloads = cross(domains, ranges, new Lambda2<Type, Type, Type>() { 
     337                    public Type value(Type d, Type r) { 
    320338                        return new ArrowType(NodeFactory.makeSetSpan(d,r), d, r, normalEffect); 
    321339                    } 
    … …  
    324342                Type result = makeIntersection(overloads); 
    325343                return t.equals(result) ? t : result; 
    326             } 
    327  
    328             @Override public Domain forDomain(Domain d) { 
    329                 // recur on a single args type rather than each element individually 
    330                 Type args = stripKeywords(d); 
    331                 Type argsNorm = (Type) args.accept(this); 
    332                 List<KeywordType> ks = d.getKeywords(); 
    333                 List<KeywordType> ksNorm = recurOnListOfKeywordType(ks); 
    334                 if (args == argsNorm && ks == ksNorm) { return d; } 
    335                 else { return makeDomain(argsNorm, ksNorm); } 
    336344            } 
    337345 
    … …  
    10901098 
    10911099    /** Subtyping for Domains. */ 
    1092     private ConstraintFormula sub(Domain s, Domain t, SubtypeHistory h) { 
     1100    private ConstraintFormula sub(TupleType s, TupleType t, SubtypeHistory h) { 
    10931101        Map<Id, Type> sMap = extractKeywords(s); 
    10941102        Map<Id, Type> tMap = extractKeywords(t); 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeAnalyzerJUTest.java

    r3112 r3114  
    111111        assertEquals(type("(C->A)&(D->A)"), norm(t, "(C|D)->A")); 
    112112        assertEquals(type("C->A"), norm(t, "(B&C)->A")); 
    113         assertEquals(type("(C&D)->A"), norm(t, "(C&D)->A")); 
     113        assertEquals(type("C&D->A"), norm(t, "C&D->A")); 
    114114        assertEquals(type("&{C->C,C->D,D->C,D->D}"), norm(t, "(C|D)->(C&D)")); 
    115115        assertEquals(type("&{A->(C|E),A->(C|F),A->(D|E),A->(D|F)}"), norm(t, "A->(C&D)|(E&F)")); 
    … …  
    117117        assertEquals(type("Any"), norm(t, "Bottom->C throws E io")); 
    118118        assertEquals(type("&{(A,C...)->E,(A,D...)->E}"), norm(t, "(A, (C|D)...)->E")); 
    119         assertEquals(type("((A,C...)&(A,D...))->E"), norm(t, "(A, (C&D)...)->E")); 
     119        assertEquals(type("(A,C...)&(A,D...)->E"), norm(t, "(A, (C&D)...)->E")); 
    120120        assertEquals(type("(C&D, foo=E&F, bar=G)->A"), norm(t, "(C&D, foo=E&F, bar=G)->A")); 
    121121        assertEquals(type("&{(C,foo=E,bar=G)->A,(C,foo=F,bar=G)->A,(D,foo=E,bar=G)->A,(D,foo=F,bar=G)->A}"), 
    … …  
    520520            int effectStart = findAtTop(s, " throws ", " io "); 
    521521            if (effectStart == -1) { effectStart = s.length(); } 
    522             Domain d = parseDomain(s.substring(0, opIndex)); 
     522            Type d = parseDomain(s.substring(0, opIndex)); 
    523523            Type r = parseType(s.substring(opIndex+2, effectStart)); 
    524524            Effect e = parseEffect(s.substring(effectStart)); 
    … …  
    577577    } 
    578578 
    579     private static Domain parseDomain(String s) { 
     579    private static Type parseDomain(String s) { 
    580580        s = s.trim(); 
    581581        // check whether this is entirely enclosed in parens 
    … …  
    599599                } 
    600600            } 
    601             return new Domain(span, args, varargs, keys); 
     601            return new TupleType(span, args, varargs, keys); 
    602602        } 
    603603        else { 
    604             return new Domain(span, Collections.singletonList(parseType(s))); 
     604            return parseType(s); 
    605605        } 
    606606    } 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeAnalyzerUtil.java

    r3109 r3114  
    163163            } 
    164164            @Override public Boolean forArrowType(ArrowType t) { 
    165                 Domain d = t.getDomain(); 
     165                Type d = t.getDomain(); 
    166166                Effect e = t.getEffect(); 
    167                 return recurOnList(d.getArgs()) || 
    168                     (d.getVarargs().isSome() && d.getVarargs().unwrap().accept(this)) || 
    169                     recurOnKeywords(d.getKeywords()) || 
    170                     t.getRange().accept(this) || 
    171                     recurOnList(t.getEffect().getThrowsClause().unwrap(Collections.<BaseType>emptyList())); 
     167                if ( d instanceof TupleType ) { 
     168                    TupleType _d = (TupleType)d; 
     169                    return recurOnList(_d.getElements()) || 
     170                        (_d.getVarargs().isSome() && _d.getVarargs().unwrap().accept(this)) || 
     171                        recurOnKeywords(_d.getKeywords()) || 
     172                        t.getRange().accept(this) || 
     173                        recurOnList(t.getEffect().getThrowsClause().unwrap(Collections.<BaseType>emptyList())); 
     174                } else 
     175                    return d.accept(this) || 
     176                        t.getRange().accept(this) || 
     177                        recurOnList(t.getEffect().getThrowsClause().unwrap(Collections.<BaseType>emptyList())); 
    172178            } 
    173179            @Override public Boolean forTupleType(TupleType t) { 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeCheckerTestCase.java

    r3096 r3114  
    6666            Type left = parseType(s.substring(0, arrowIndex)); 
    6767            Type right = parseType(s.substring(arrowIndex+2)); 
    68             return new ArrowType(span, NodeFactory.makeDomain(left), right); 
     68            return new ArrowType(span, left, right); 
    6969        } 
    7070        if (s.startsWith("(")) { 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeEnv.java

    r3107 r3114  
    4747import com.sun.fortress.nodes.DimParam; 
    4848import com.sun.fortress.nodes.DimRef; 
    49 import com.sun.fortress.nodes.Domain; 
    5049import com.sun.fortress.nodes.Enclosing; 
    5150import com.sun.fortress.nodes.FnDecl; 
    … …  
    155154     * Get a domain from a list of params. 
    156155     */ 
    157     protected static Domain domainFromParams(List<Param> params) { 
     156    protected static Type domainFromParams(List<Param> params) { 
    158157        List<Type> paramTypes = new ArrayList<Type>(); 
    159158        List<KeywordType> keywordTypes = new ArrayList<KeywordType>(); 
    … …  
    182181        } 
    183182 
    184         return new Domain(NodeFactory.makeSpan("TypeEnv_bogus_span_for_empty_list", params), paramTypes, varargsType, keywordTypes); 
     183        return NodeFactory.makeDomain(NodeFactory.makeSpan("TypeEnv_bogus_span_for_empty_list", params), paramTypes, varargsType, keywordTypes); 
    185184    } 
    186185 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/EvalType.java

    r3109 r3114  
    401401    @Override 
    402402    public FType forArrowType(ArrowType at) { 
    403         Domain domain = at.getDomain(); 
    404         if (!domain.getKeywords().isEmpty()) { 
     403        Type domain = at.getDomain(); 
     404        if ( domain instanceof TupleType && 
     405             ! ((TupleType)domain).getKeywords().isEmpty()) { 
    405406            return NI.nyi("Can't interpret a type with keywords"); 
    406407        } 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/MakeInferenceSpecific.java

    r3109 r3114  
    2424import com.sun.fortress.nodes.AbstractNode; 
    2525import com.sun.fortress.nodes.ArrayType; 
     26import com.sun.fortress.nodes.Type; 
    2627import com.sun.fortress.nodes.ArrowType; 
    2728import com.sun.fortress.nodes.VarType; 
    … …  
    3233import com.sun.fortress.nodes.TupleType; 
    3334import com.sun.fortress.nodes.VoidType; 
    34 import com.sun.fortress.nodes.Domain; 
    3535import com.sun.fortress.nodes_util.NodeUtil; 
    3636import com.sun.fortress.compiler.Types; 
    … …  
    118118    public void forArrowType(ArrowType that) { 
    119119        that.getRange().accept(this); 
    120         Domain domain = that.getDomain(); 
     120        Type domain = that.getDomain(); 
    121121        // TODO: handle keywords 
    122         if (!domain.getKeywords().isEmpty()) { 
     122        if ( domain instanceof TupleType && 
     123             ! ((TupleType)domain).getKeywords().isEmpty()) { 
    123124            NI.nyi("Can't yet handle keywords in arrow domains"); 
    124125        } 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FTypeArrow.java

    r2618 r3114  
    2626import com.sun.fortress.interpreter.evaluator.Environment; 
    2727import com.sun.fortress.nodes.ArrowType; 
    28 import com.sun.fortress.nodes.Domain; 
     28import com.sun.fortress.nodes.TupleType; 
    2929import com.sun.fortress.nodes.Type; 
    3030import com.sun.fortress.useful.BoundingMap; 
    … …  
    168168            range.unify(env, tp_set, abm, arr.getRange()); 
    169169            BoundingMap<String, FType, TypeLatticeOps> dual = abm.dual(); 
    170             Domain valdom = arr.getDomain(); 
    171             if (!valdom.getKeywords().isEmpty()) { 
     170            Type valdom = arr.getDomain(); 
     171            if ( valdom instanceof TupleType && 
     172                 ! ((TupleType)valdom).getKeywords().isEmpty()) { 
    172173                return false; 
    173174                // TODO: handle domains containing keywords 

  • trunk/ProjectFortress/src/com/sun/fortress/nodes_util/ErrorMsgMaker.java

    r3109 r3114  
    8080    } 
    8181 
    82     public String forDomain(Domain node) { 
     82    public String forTupleType(TupleType node) { 
    8383        StringBuilder result = new StringBuilder(); 
    8484        result.append("("); 
    8585        boolean first = true; 
    86         for (Type t : node.getArgs()) { 
     86        for (Type t : node.getElements()) { 
    8787            if (first) { first = false; } 
    8888            else { result.append(", "); } 
    … …  
    356356    } 
    357357 
    358     public String forTupleType(TupleType node) { 
    359         if ( node.getVarargs().isNone() ) 
    360             return Useful.listInDelimiters("(", mapSelf(node.getElements()), ")"); 
    361         else 
    362             return 
    363                 "(" + 
    364                 Useful.listInDelimiters("", mapSelf(node.getElements()), "") + 
    365                 node.getVarargs().unwrap().accept(this) + "..." + 
    366                 ")"; 
    367     } 
    368  
    369358    public String forTypeArg(TypeArg node) { 
    370359        return String.valueOf(node.getType().accept(this)); 

  • trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeComparator.java

    r3109 r3114  
    287287    } 
    288288 
    289     static int compare(Domain left, Domain right) { 
    290         int x = typeListComparer.compare(left.getArgs(), right.getArgs()); 
     289    static int compare(TupleType left, TupleType right) { 
     290        int x = typeListComparer.compare(left.getElements(), right.getElements()); 
    291291        if (x != 0) return x; 
    292292        x = compareOptionalType(left.getVarargs(), right.getVarargs()); 
    … …  
    379379    static int compare(StaticParam left, StaticParam right) { 
    380380        return NodeUtil.getName(left).compareTo(NodeUtil.getName(right)); 
    381     } 
    382  
    383     static int compare(TupleType left, TupleType right) { 
    384         if ( left.getVarargs().isSome() && right.getVarargs().isSome() ) { 
    385             int x = typeListComparer.compare(left.getElements(), right.getElements()); 
    386             if (x != 0) return x; 
    387             return compare(left.getVarargs().unwrap(), right.getVarargs().unwrap()); 
    388         } else 
    389             return typeListComparer.compare(left.getElements(), right.getElements()); 
    390381    } 
    391382 

  • trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeFactory.java

    r3109 r3114  
    284284    } 
    285285 
    286 //    public static ArrowType makeArrowType(ArrowType t, Domain domain, Type range, Effect effect) { 
    287 //    return new ArrowType(t.getSpan(), t.isParenthesized(), domain, range, effect); 
    288 //    } 
    289  
    290286    public static TraitType makeTraitType(TraitType t, 
    291287            List<StaticArg> args) { 
    … …  
    436432 
    437433    public static ArrowType makeArrowType(Span span, Type domain, Type range) { 
    438         return new ArrowType(span, makeDomain(domain), range, makeEffect(range.getSpan().getEnd())); 
     434        return new ArrowType(span, domain, range, makeEffect(range.getSpan().getEnd())); 
    439435    } 
    440436 
    … …  
    468464//    } 
    469465 
    470     /** If args is a tuple or void, extract a list; otherwise, make a singleton */ 
    471     public static Domain makeDomain(Type args) { 
    472         List<Type> argsList; 
    473         if (args instanceof VoidType) { 
    474             argsList = Collections.emptyList(); 
    475         } 
    476         else if (args instanceof TupleType) { 
    477             argsList = ((TupleType) args).getElements(); 
    478         } 
    479         else { 
    480             argsList = Collections.singletonList(args); 
    481         } 
    482         return new Domain(args.getSpan(), argsList); 
     466    public static Type makeDomain(Span span, List<Type> elements, 
     467                                    Option<Type> varargs, 
     468                                    List<KeywordType> keywords) { 
     469        if ( varargs.isNone() && keywords.isEmpty() ) { 
     470            int size = elements.size(); 
     471            if ( size == 0 ) 
     472                return makeVoidType(span); 
     473            else if ( size == 1 ) 
     474                return elements.get(0); 
     475            else 
     476                return new TupleType(span, elements); 
     477        } else 
     478            return new TupleType(span, elements, varargs, keywords); 
    483479    } 
    484480 

  • trunk/ProjectFortress/src/com/sun/fortress/parser/Function.rats

    r3095 r3114  
    5858                       "Abstract function declaration should have an arrow type."); 
    5959       } 
    60        Domain d = ((ArrowType) a2).getDomain(); 
    61        for (Type argT : d.getArgs()) { 
    62            Id name = new Id(argT.getSpan(), "_"); 
    63            params.add(NodeFactory.makeParam(argT.getSpan(), mods, name, argT)); 
     60       Type d = ((ArrowType) a2).getDomain(); 
     61       if ( d instanceof TupleType ) { 
     62           TupleType _d = (TupleType)d; 
     63           for (Type argT : _d.getElements()) { 
     64               Id name = new Id(argT.getSpan(), "_"); 
     65               params.add(NodeFactory.makeParam(argT.getSpan(), mods, name, argT)); 
     66           } 
     67           if (_d.getVarargs().isSome()) { 
     68               Type argT = _d.getVarargs().unwrap(); 
     69               Id name = new Id(argT.getSpan(), "_"); 
     70               params.add(NodeFactory.makeVarargsParam(argT.getSpan(), mods, name, argT)); 
     71           } 
     72           assert(_d.getKeywords().isEmpty()): "Keyword parameters present" 
     73               + " in a FnSig: " + _d; 
     74 
     75       } else { 
     76           Id name = new Id(d.getSpan(), "_"); 
     77           params.add(NodeFactory.makeParam(d.getSpan(), mods, name, d)); 
    6478       } 
    65        if (d.getVarargs().isSome()) { 
    66            Type argT = d.getVarargs().unwrap(); 
    67            Id name = new Id(argT.getSpan(), "_"); 
    68            params.add(NodeFactory.makeVarargsParam(argT.getSpan(), mods, name, argT)); 
    69        } 
    70        assert(d.getKeywords().isEmpty()): "Keyword parameters present" 
    71                                                      + " in a FnSig: " + d; 
     79 
    7280       /* 
    7381       We could do this, if we had a suitable value for bottomExpr: 

  • trunk/ProjectFortress/src/com/sun/fortress/parser/Type.rats

    r3113 r3114  
    162162   | ( w (Type w , w)* Type w ... w ) 
    163163 */ 
    164 Domain Domain = 
     164Type Domain = 
    165165     openparen w a1s:(Type w comma w)* a2:(Type w void:ellipses w comma w)? 
    166166     a3:KeywordType a4s:(w comma w KeywordType)* w closeparen 
    … …  
    170170       List<KeywordType> ts3 = a4s.list(); 
    171171       ts3.add(0, a3); 
    172        yyValue = new Domain(span, ts1, ts2, ts3); 
     172       yyValue = NodeFactory.makeDomain(span, ts1, ts2, ts3); 
    173173     } 
    174174   / openparen w a1s:(Type w comma w)* a2:Type w ellipses w closeparen 
    … …  
    176176       Span span = createSpan(yyStart,yyCount); 
    177177       Option<Type> ts2 = Option.some(a2); 
    178        yyValue = new Domain(span, ts1, ts2); 
     178       yyValue = NodeFactory.makeDomain(span, ts1, ts2, 
     179                                        Collections.<KeywordType>emptyList()); 
    179180     }; 
    180181 

  • trunk/ProjectFortress/src/com/sun/fortress/parser_util/precedence_resolver/TypeResolver.java

    r3113 r3114  
    243243        if (isTypeOp(op)) { 
    244244            return new ArrowType(spanTwo(first, last), true, 
    245                                  typeToDomain(first), 
     245                                 first, 
    246246                                 typeToType(last), frame.getEffect()); 
    247247        } else { // !(isTypeOp(op)) 
    … …  
    611611    } 
    612612 
    613     private static Domain typeToDomain(Type type) { 
    614         if (type instanceof Domain) { return (Domain) type; } 
    615         else { // type instanceof Type 
    616             List<Type> args; 
    617             if (type instanceof VoidType) { 
    618                 args = Collections.emptyList(); 
    619             } 
    620             else if (type instanceof TupleType) { 
    621                 TupleType tup = (TupleType) type; 
    622                 args = new ArrayList<Type>(tup.getElements().size()); 
    623                 for (Type t : tup.getElements()) { 
    624                     args.add(typeToType(t)); 
    625                 } 
    626             } 
    627             else { 
    628                 args = Collections.singletonList(typeToType(type)); 
    629             } 
    630             return new Domain(type.getSpan(), args); 
    631         } 
    632     } 
    633  
    634613    public static DimExpr typeToDim(Type type) throws TypeConvertFailure { 
    635614        try { 

  • trunk/ProjectFortress/src/com/sun/fortress/tools/FortressAstToConcrete.java

    r3112 r3114  
    21792179    } 
    21802180 
    2181     @Override public String forTupleTypeOnly(TupleType that, 
    2182                                              List<String> elements_result, 
    2183                                              Option<String> varargs_result) { 
    2184         StringBuilder s = new StringBuilder(); 
    2185  
    2186         s.append( "(" ); 
    2187         s.append( join(elements_result, ", ") ); 
    2188         if ( varargs_result.isSome() ) { 
    2189             s.append( "(* " ); 
    2190             s.append( ", " ); 
    2191             s.append( varargs_result.unwrap() ); 
    2192             s.append( "...)" ); 
    2193             s.append( " *)" ); 
    2194         } 
    2195         s.append( ")" ); 
    2196  
    2197         return s.toString(); 
    2198     } 
    2199  
    22002181    @Override public String forVoidTypeOnly(VoidType that) { 
    22012182        return "()"; 
    … …  
    22792260    } 
    22802261 
    2281     @Override public String forDomainOnly(Domain that, 
    2282                                           List<String> args_result, 
    2283                                           Option<String> varargs_result, 
    2284                                           List<String> keywords_result) { 
     2262    @Override public String forTupleTypeOnly(TupleType that, 
     2263                                             List<String> args_result, 
     2264                                             Option<String> varargs_result, 
     2265                                             List<String> keywords_result) { 
    22852266        StringBuilder s = new StringBuilder(); 
    22862267