Changeset 3109

Timestamp:

11/26/08 12:46:49 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Merged AbstractTupleType?, TupleType?, and VarargTupleType? to TupleType?.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (2 diffs)
• src/com/sun/fortress/compiler/Types.java (modified) (5 diffs)
• src/com/sun/fortress/compiler/typechecker/SubtypeChecker.java (modified) (5 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java (modified) (5 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzerJUTest.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzerUtil.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/evaluator/EvalType.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/evaluator/MakeInferenceSpecific.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/ScoutVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FTypeTuple.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/ErrorMsgMaker.java (modified) (1 diff)
• src/com/sun/fortress/nodes_util/NodeComparator.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (1 diff)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (1 diff)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -653 +653 @@
              * e.g.) self
              * e.g.) x: String...
+             *
+             * <varargsType>
+             * It is a varargs parameter if the varargsType field is set.
              */
             Param(List<Modifier> mods = Collections.<Modifier>emptyList(),
@@ -1357 +1360 @@
                 /**
                  * tuple-like types
-                 */
-                abstract AbstractTupleType(List<Type> elements);
-                    /**
-                     * tuple type
-                     * TupleType ::= ( Type, TypeList )
-                     * e.g.) (ZZ32, String)
-                     */
-                    TupleType();
-                    /**
-                     * Used internally to represent an infinite union of
-                     * TupleTypes.
-                     */
-                    VarargTupleType(Type varargs);
+                 * TupleType ::= ( Type, TypeList )
+                 * e.g.) (ZZ32, String)
+                 *
+                 * <varargs>
+                 * It has a varargs parameter if the varargs field is set.
+                 */
+                TupleType(List<Type> elements,
+                          Option<Type> varargs = Option.<Type>none());
                 /**
                  * void type

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

@@ -45 +45 @@
 
     private Types() {}
-    
+
     private static Span span = NodeFactory.makeSpan("If you see this, it is a bug.");
 
@@ -53 +53 @@
     //       ImmutableHeapSequence is put into the libraries.
     public static final Id IMMUTABLE_HEAP_SEQ_NAME = makeId(fortressLibrary, "ImmutableArray");
-    
+
     public static final AnyType ANY = new AnyType(span);
     public static final BottomType BOTTOM = new BottomType(span);
@@ -226 +226 @@
      * Bottom.
      */
-    public static Type varargDisjunct(VarargTupleType t, int arity) {
+    public static Type varargDisjunct(TupleType t, int arity) {
         List<Type> base = t.getElements();
         int baseSize = base.size();
         if (baseSize > arity) { return BOTTOM; }
         else {
-            Iterable<Type> rest = IterUtil.copy(t.getVarargs(), arity-baseSize);
+            Iterable<Type> rest = IterUtil.copy(t.getVarargs().unwrap(), arity-baseSize);
             return makeTuple(IterUtil.compose(base, rest));
         }
@@ -238 +238 @@
     /**
      * Produce a type representing a Domain with any keyword types removed.
-     * May return a TupleType, a VoidType, a VarargTupleType, or a type
+     * May return a TupleType, a VoidType, a TupleType with varargs, or a type
      * representing a singleton argument.
      */
     public static Type stripKeywords(Domain d) {
         if (d.getVarargs().isSome()) {
-            return new VarargTupleType(NodeFactory.makeSpan(d.getArgs(), d.getVarargs().unwrap()), d.getArgs(), d.getVarargs().unwrap());
+            return new TupleType(NodeFactory.makeSpan(d.getArgs(), d.getVarargs().unwrap()), d.getArgs(), d.getVarargs());
         }
         else {
@@ -294 +294 @@
             }
             @Override public Domain forTupleType(TupleType t) {
-                return new Domain(NodeFactory.makeSpan(t, keywords), t.getElements(), keywords);
-            }
-            @Override public Domain forVarargTupleType(VarargTupleType t) {
-                return new Domain(NodeFactory.makeSpan(t, keywords), t.getElements(), Option.some(t.getVarargs()),
-                                  keywords);
+                if ( t.getVarargs().isNone() )
+                    return new Domain(NodeFactory.makeSpan(t, keywords), t.getElements(), keywords);
+                else
+                    return new Domain(NodeFactory.makeSpan(t, keywords), t.getElements(), t.getVarargs(),
+                                      keywords);
             }
             @Override public Domain forType(Type t) {

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

@@ -379 +379 @@
     }
     private boolean isTuple(Type t) {
-        return (t instanceof AbstractTupleType);
+        return (t instanceof TupleType);
     }
     private boolean isInst(Type t) {
@@ -397 +397 @@
     }
     private boolean isVarargTupleType(Type t) {
-        return (t instanceof VarargTupleType);
+        return (t instanceof TupleType &&
+                ((TupleType)t).getVarargs().isSome());
     }
 
@@ -598 +599 @@
      *
      *        _InferenceVarType(Object id, int index = -1);
-     *        VarargTupleType(Type varargs);
      *        abstract DimExpr();
      *            ExponentType(Type base, IntExpr power);
@@ -719 +719 @@
             //           p; Delta |- (s, ...) <: (t, ...)
             if (isTuple(s) && isTuple(t)) {
-                if (s instanceof VarargTupleType && t instanceof VarargTupleType) {
-                    VarargTupleType ss = (VarargTupleType)s;
-                    VarargTupleType tt = (VarargTupleType)t;
+                TupleType ss = (TupleType)s;
+                TupleType tt = (TupleType)t;
+                if (ss.getVarargs().isSome() && tt.getVarargs().isSome()) {
                     List<Type> stypes = ss.getElements();
                     List<Type> ttypes = tt.getElements();
                     int padLength = Math.max(stypes.size(), ttypes.size());
-                    List<Type> spadded = pad(stypes, ss.getVarargs(), padLength);
-                    List<Type> tpadded = pad(ttypes, tt.getVarargs(), padLength);
+                    List<Type> spadded = pad(stypes, ss.getVarargs().unwrap(), padLength);
+                    List<Type> tpadded = pad(ttypes, tt.getVarargs().unwrap(), padLength);
                     for (Pair<Type, Type> p : IterUtil.zip(spadded, tpadded)) {
                         if (!subtype(p.first(), p.second(), history)) {
@@ -733 +733 @@
                     }
                     // Check that varargs are subtypes
-                    if (!subtype(ss.getVarargs(), tt.getVarargs())) {
+                    if (!subtype(ss.getVarargs().unwrap(), tt.getVarargs().unwrap())) {
                         return FALSE;
                     }
                     return TRUE;
-                } else if (s instanceof VarargTupleType || t instanceof VarargTupleType) {
-                    // only one is a VarargTupleType
+                } else if (ss.getVarargs().isSome() || tt.getVarargs().isSome()) {
+                    // only one has a varargs parameter
                     return FALSE;
                 } else { // s instanceof TupleType && s instanceof TupleType
-                    TupleType ss = (TupleType)s;
-                    TupleType tt = (TupleType)t;
                     List<Type> types = tt.getElements();
                     if (ss.getElements().size() != types.size()) {

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

@@ -253 +253 @@
             }
 
-            @Override public Type forTupleTypeOnly(TupleType t, List<Type> normalElements) {
-                Type result = handleAbstractTuple(normalElements, MAKE_TUPLE);
-                return t.equals(result) ? t : result;
-            }
-
-            @Override public Type forVarargTupleTypeOnly(VarargTupleType t, List<Type> normalElements,
-                                                         Type normalVarargs) {
-                // the varargs type can be treated like just another tuple element, as far as
-                // normalization is concerned, unless the varargs type is Bottom
-                if (normalVarargs.equals(BOTTOM)) {
-                    return handleAbstractTuple(normalElements, MAKE_TUPLE);
-                }
-                else {
-                    Lambda<Iterable<Type>, Type> factory = new Lambda<Iterable<Type>, Type>() {
-                        public Type value(Iterable<Type> ts) {
-                            if (IterUtil.isEmpty(ts)) { return VOID; }
-                            else {
-                                List<Type> elts = makeList(skipLast(ts));
-                                Type varargs = last(ts);
-                                return new VarargTupleType(NodeFactory.makeSpan(elts, varargs), elts, varargs);
-                            }
-                        }
-                    };
-                    Type result = handleAbstractTuple(compose(normalElements, normalVarargs),
-                                                      factory);
-                    return t.equals(result) ? t : result;
-                }
-            }
+                @Override public Type forTupleTypeOnly(TupleType t, List<Type> normalElements,
+                                                       Option<Type> normalVarargs) {
+                    if ( normalVarargs.isNone() ) {
+                        Type result = handleAbstractTuple(normalElements, MAKE_TUPLE);
+                        return t.equals(result) ? t : result;
+                    } else {
+                        // the varargs type can be treated like just another tuple element, as far as
+                        // normalization is concerned, unless the varargs type is Bottom
+                        if (normalVarargs.unwrap().equals(BOTTOM)) {
+                            return handleAbstractTuple(normalElements, MAKE_TUPLE);
+                        }
+                        else {
+                            Lambda<Iterable<Type>, Type> factory = new Lambda<Iterable<Type>, Type>() {
+                                public Type value(Iterable<Type> ts) {
+                                    if (IterUtil.isEmpty(ts)) { return VOID; }
+                                    else {
+                                        List<Type> elts = makeList(skipLast(ts));
+                                        Type varargs = last(ts);
+                                        return new TupleType(NodeFactory.makeSpan(elts, varargs),
+                                                             elts, Option.<Type>some(varargs));
+                                    }
+                                }
+                            };
+                            Type result = handleAbstractTuple(compose(normalElements, normalVarargs.unwrap()),
+                                                              factory);
+                            return t.equals(result) ? t : result;
+                        }
+                    }
+                }
 
             private Type handleAbstractTuple(Iterable<Type> normalElements,
@@ -455 +456 @@
 
                 @Override public
-                ConstraintFormula forVarargTupleType(final VarargTupleType t) {
+                ConstraintFormula forTupleType(final TupleType t) {
+                    if ( t.getVarargs().isSome() ) {
+
                     return s.accept(new NodeAbstractVisitor<ConstraintFormula>() {
                         @Override public ConstraintFormula forType(Type s) {
@@ -471 +474 @@
                         }
                         @Override public ConstraintFormula forTupleType(TupleType s) {
-                            return tupleSubVararg(s, t, h);
-                        }
-                        @Override public
-                        ConstraintFormula forVarargTupleType(VarargTupleType s) {
-                            return varargSubVararg(s, t, h);
+                            if ( s.getVarargs().isSome() )
+                                return varargSubVararg(s, t, h);
+                            else return tupleSubVararg(s, t, h);
                         }
                     });
+                    } else
+                        return null;
                 }
 
@@ -658 +661 @@
     }
 
-    private ConstraintFormula voidSubVararg(VoidType s, VarargTupleType t, SubtypeHistory h) {
+    private ConstraintFormula voidSubVararg(VoidType s, TupleType t, SubtypeHistory h) {
         return sub(s, varargDisjunct(t, 0), h);
     }
 
-    private ConstraintFormula traitSubVararg(TraitType s, VarargTupleType t, SubtypeHistory h) {
+    private ConstraintFormula traitSubVararg(TraitType s, TupleType t, SubtypeHistory h) {
         return sub(s, varargDisjunct(t, 1), h);
     }
 
-    private ConstraintFormula anySubVararg(AnyType s, VarargTupleType t, SubtypeHistory h) {
+    private ConstraintFormula anySubVararg(AnyType s, TupleType t, SubtypeHistory h) {
         return sub(s, varargDisjunct(t, 1), h);
     }
 
-    private ConstraintFormula tupleSubVararg(TupleType s, VarargTupleType t, SubtypeHistory h) {
+    private ConstraintFormula tupleSubVararg(TupleType s, TupleType t, SubtypeHistory h) {
         return sub(s, varargDisjunct(t, s.getElements().size()), h);
     }
 
-    private ConstraintFormula varargSubVararg(VarargTupleType s, VarargTupleType t,
+    private ConstraintFormula varargSubVararg(TupleType s, TupleType t,
                                               SubtypeHistory h) {
         int n = s.getElements().size();
@@ -680 +683 @@
         ConstraintFormula f = sub(varargDisjunct(s, n), varargDisjunct(t, n), h);
         if (!f.isFalse()) {
-            f = f.and(sub(s.getVarargs(), t.getVarargs(), h), h);
+            f = f.and(sub(s.getVarargs().unwrap(), t.getVarargs().unwrap(), h), h);
         }
         return f;

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

@@ -550 +550 @@
             if (varargs) { s = s.substring(0, s.length()-4) + ")"; }
             List<Type> ts = parseTypeList(s, "(", ")");
-            if (varargs) { return new VarargTupleType(span, ts, ts.remove(ts.size()-1)); }
+            if (varargs) { return new TupleType(span, ts, Option.<Type>some(ts.remove(ts.size()-1))); }
             else if (ts.size() == 0) { return VOID; }
             else if (ts.size() == 1) { return ts.get(0); }

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

@@ -172 +172 @@
             }
             @Override public Boolean forTupleType(TupleType t) {
-                return recurOnList(t.getElements());
-            }
-            @Override public Boolean forVarargTupleType(VarargTupleType t) {
-                return recurOnList(t.getElements()) || t.getVarargs().accept(this);
+                if ( t.getVarargs().isNone() )
+                    return recurOnList(t.getElements());
+                else
+                    return recurOnList(t.getElements()) || t.getVarargs().unwrap().accept(this);
             }
             @Override public Boolean forAnyType(AnyType t) { return false; }

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeChecker.java

@@ -2395 +2395 @@
                     }
                 }
-                AbstractTupleType domain;
+                TupleType domain;
                 if(varargs){
                         Type var = dlist.remove(dlist.size()-1);
-                        domain = new VarargTupleType(that.getSpan(), dlist,var);
+                        domain = new TupleType(that.getSpan(), dlist, Option.<Type>some(var));
                 }
                 else{

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

@@ -410 +410 @@
 
     @Override
-    public FType forVarargTupleType(VarargTupleType tt) {
-        List<FType> elts = getFTypeListFromList(tt.getElements());
-        elts.add(FTypeRest.make(tt.getVarargs().accept(this)));
-        return FTypeTuple.make(elts);
-    }
-
-    @Override
     public FType forTupleType(TupleType tt) {
-        List<FType> elts = getFTypeListFromList(tt.getElements());
-        return FTypeTuple.make(elts);
+        if ( tt.getVarargs().isNone() ) {
+            List<FType> elts = getFTypeListFromList(tt.getElements());
+            return FTypeTuple.make(elts);
+        } else {
+            List<FType> elts = getFTypeListFromList(tt.getElements());
+            elts.add(FTypeRest.make(tt.getVarargs().unwrap().accept(this)));
+            return FTypeTuple.make(elts);
+        }
     }
 

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

@@ -30 +30 @@
 import com.sun.fortress.nodes.NodeAbstractVisitor_void;
 import com.sun.fortress.nodes.TraitType;
-import com.sun.fortress.nodes.VarargTupleType;
 import com.sun.fortress.nodes.TupleType;
 import com.sun.fortress.nodes.VoidType;
@@ -136 +135 @@
 
     /* (non-Javadoc)
-     * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forVarargTupleType(com.sun.fortress.nodes.VarargTupleType)
-     */
-    @Override
-    public void forVarargTupleType(VarargTupleType that) {
-        // TODO: implement
-        NI.nyi("Can't yet handle varargs tuples");
-    }
-
-    /* (non-Javadoc)
      * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forTupleType(com.sun.fortress.nodes.TupleType)
      */
     @Override
     public void forTupleType(TupleType that) {
-        acceptList(that.getElements(), this);
+        if ( that.getVarargs().isSome() ) {
+            // TODO: implement
+            NI.nyi("Can't yet handle varargs tuples");
+        } else {
+            acceptList(that.getElements(), this);
+        }
     }
 

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/ScoutVisitor.java

@@ -35 +35 @@
 import com.sun.fortress.nodes.BaseType;
 import com.sun.fortress.nodes.TraitTypeWhere;
-import com.sun.fortress.nodes.VarargTupleType;
 import com.sun.fortress.nodes.TupleType;
 import com.sun.fortress.nodes.Type;
@@ -151 +150 @@
 
     /* (non-Javadoc)
-     * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forVarargTupleType(com.sun.fortress.nodes.VarargTupleType)
-     */
-    @Override
-    public void forVarargTupleType(VarargTupleType that) {
-        // TODO Auto-generated method stub
-        super.forVarargTupleType(that);
-    }
-
-    /* (non-Javadoc)
      * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forTupleType(com.sun.fortress.nodes.TupleType)
      */

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

@@ -34 +34 @@
 import com.sun.fortress.nodes.TupleType;
 import com.sun.fortress.nodes.Type;
-import com.sun.fortress.nodes.VarargTupleType;
 import com.sun.fortress.nodes.VoidType;
 import com.sun.fortress.useful.BoundingMap;
@@ -382 +381 @@
         }
         else if (val instanceof TupleType) {
-            elements = ((TupleType) val).getElements();
-            vargs = Option.none();
-        }
-        else if (val instanceof VarargTupleType) {
-            VarargTupleType tup = (VarargTupleType) val;
-            elements = tup.getElements();
-            vargs = Option.some(tup.getVarargs());
+            TupleType _val = (TupleType) val;
+            if ( _val.getVarargs().isNone() ) {
+                elements = _val.getElements();
+                vargs = Option.none();
+            } else {
+                elements = _val.getElements();
+                vargs = Option.some(_val.getVarargs().unwrap());
+            }
         }
         else { return false; }

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

@@ -356 +356 @@
     }
 
-    public String forVarargTupleType(VarargTupleType node) {
-        return
-            "(" +
-            Useful.listInDelimiters("", mapSelf(node.getElements()), "") +
-            node.getVarargs().accept(this) + "..." +
-            ")";
-    }
-
     public String forTupleType(TupleType node) {
-        return Useful.listInDelimiters("(", mapSelf(node.getElements()), ")");
+        if ( node.getVarargs().isNone() )
+            return Useful.listInDelimiters("(", mapSelf(node.getElements()), ")");
+        else
+            return
+                "(" +
+                Useful.listInDelimiters("", mapSelf(node.getElements()), "") +
+                node.getVarargs().unwrap().accept(this) + "..." +
+                ")";
     }
 

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

@@ -381 +381 @@
     }
 
-    static int compare(VarargTupleType left, VarargTupleType right) {
-        int x = typeListComparer.compare(left.getElements(), right.getElements());
-        if (x != 0) return x;
-        return compare(left.getVarargs(), right.getVarargs());
-    }
-
     static int compare(TupleType left, TupleType right) {
-        return typeListComparer.compare(left.getElements(), right.getElements());
+        if ( left.getVarargs().isSome() && right.getVarargs().isSome() ) {
+            int x = typeListComparer.compare(left.getElements(), right.getElements());
+            if (x != 0) return x;
+            return compare(left.getVarargs().unwrap(), right.getVarargs().unwrap());
+        } else
+            return typeListComparer.compare(left.getElements(), right.getElements());
     }
 
@@ -424 +423 @@
         } else if (left instanceof VoidType) {
             return 0;
-        } else if (left instanceof VarargTupleType) {
-            return compare((VarargTupleType) left, (VarargTupleType) right);
         } else if (left instanceof TupleType) {
             return compare((TupleType) left, (TupleType) right);

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

@@ -1272 +1272 @@
                         t.getArgs());
             }
-            public Type forVarargTupleType(VarargTupleType t) {
-                return new VarargTupleType(t.getSpan(), true, t.getElements(),
-                        t.getVarargs());
-            }
             public Type forTupleType(TupleType t) {
-                return new TupleType(t.getSpan(), true, t.getElements());
+                return new TupleType(t.getSpan(), true, t.getElements(),
+                                     t.getVarargs());
             }
             public Type forVoidType(VoidType t) {

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

@@ -2173 +2173 @@
 
     @Override public String forTupleTypeOnly(TupleType that,
-                                             List<String> elements_result) {
+                                             List<String> elements_result,
+                                             Option<String> varargs_result) {
         StringBuilder s = new StringBuilder();
 
         s.append( "(" );
         s.append( join(elements_result, ", ") );
+        if ( varargs_result.isSome() ) {
+            s.append( "(* " );
+            s.append( ", " );
+            s.append( varargs_result.unwrap() );
+            s.append( "...)" );
+            s.append( " *)" );
+        }
         s.append( ")" );
 
         return s.toString();
-    }
-
-    @Override public String forVarargTupleTypeOnly(VarargTupleType that,
-                                                   List<String> elements_result,
-                                                   String varargs_result) {
-        StringBuilder s = new StringBuilder();
-
-        s.append( "(" );
-        s.append( join(elements_result, ", ") );
-        s.append( ", " );
-        s.append( varargs_result );
-        s.append( "...)" );
-
-        return "(* " + s.toString() + " *)";
     }