Changeset 3133

Show
Ignore:
Timestamp:
12/02/08 10:01:41 (12 months ago)
Author:
sukyoungryu
Message:

[ast refactoring] Merged TupleType? and VoidType?

Location:
trunk
Files:
17 modified

Legend:

Unmodified
Added
Removed

  • trunk/Library/FortressSyntax.fsi

    r3096 r3133  
    126126    RightEncloser : Op 
    127127    ExponentOp : Op 
    128     EncloserPair : Enclosing 
     128    EncloserPair : Op 
    129129    Op : Op 
    130130    CompoundOp : Op 

  • trunk/ProjectFortress/astgen/Fortress.ast

    r3132 r3133  
    13421342                 * e.g.) (String, ZZ32, String..., foo=ZZ32) 
    13431343                 * 
     1344                 * If this tuple type does not have any elements, 
     1345                 * it is a void type. 
     1346                 * void type 
     1347                 * NonArrowType ::= () 
     1348                 * e.g.) () 
     1349                 * 
    13441350                 * <varargs> 
    13451351                 * It has a varargs parameter if the varargs field is set. 
    … …  
    13481354                          Option<Type> varargs = Option.<Type>none(), 
    13491355                          List<KeywordType> keywords = Collections.<KeywordType>emptyList()); 
    1350                 /** 
    1351                  * void type 
    1352                  * NonArrowType ::= () 
    1353                  * e.g.) () 
    1354                  */ 
    1355                 VoidType(); 
    13561356                /** 
    13571357                 * arrow type 

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

    r3132 r3133  
    6060    public static final Type BOTTOM_DOMAIN = BOTTOM; 
    6161 
    62     public static final VoidType VOID = new VoidType(span); 
     62    public static final TupleType VOID = NodeFactory.makeVoidType(span); 
    6363    public static final TraitType FLOAT_LITERAL = makeTraitType(fortressBuiltin, "FloatLiteral"); 
    6464    public static final TraitType INT_LITERAL = makeTraitType(fortressBuiltin, "IntLiteral"); 
    … …  
    298298    public static Type makeDomain(Type argsType, final List<KeywordType> keywords) { 
    299299        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             } 
    307300            @Override public Type forTupleType(TupleType t) { 
    308301                if ( t.getVarargs().isNone() ) 

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

    r3123 r3133  
    477477                        @Override public ConstraintFormula forTraitType(TraitType s) { 
    478478                            return traitSubVararg(s, t, h); 
    479                         } 
    480                         @Override public ConstraintFormula forVoidType(VoidType s) { 
    481                             return voidSubVararg(s, t, h); 
    482479                        } 
    483480                        @Override public ConstraintFormula forTupleType(TupleType s) { 
    … …  
    669666    } 
    670667 
    671     private ConstraintFormula voidSubVararg(VoidType s, TupleType t, SubtypeHistory h) { 
    672         return sub(s, varargDisjunct(t, 0), h); 
    673     } 
    674  
    675668    private ConstraintFormula traitSubVararg(TraitType s, TupleType t, SubtypeHistory h) { 
    676669        return sub(s, varargDisjunct(t, 1), h); 

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

    r3123 r3133  
    194194                return false; 
    195195            } 
    196             @Override public Boolean forVoidType(VoidType t) { return false; } 
    197196            @Override public Boolean for_InferenceVarType(_InferenceVarType t) { return false; } 
    198197            @Override public Boolean forBoundType(BoundType t) { 

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

    r3132 r3133  
    231231                if( arg_type instanceof TupleType ) 
    232232                        arg_size = ((TupleType)arg_type).getElements().size(); 
    233                 else if( arg_type instanceof VoidType ) 
    234                         arg_size = 0; 
    235233                else 
    236234                        arg_size = 1; 

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

    r3123 r3133  
    127127 
    128128    public List<FType> getFTypeListFromList(List<? extends Type> l) { 
    129         if (l == null || l.size() == 1 && (l.get(0) instanceof VoidType)) { 
     129        if (l == null || 
     130            l.size() == 1 && NodeUtil.isVoidType(l.get(0))) { 
    130131            // Flatten out voids. 
    131132            // Should this be mutable? 
    … …  
    327328    } 
    328329 
    329     public FType forVoidType(VoidType v) { return FTypeVoid.ONLY; } 
    330  
    331330    /* (non-Javadoc) 
    332331     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forIntArg(com.sun.fortress.interpreter.nodes.IntArg) 
    … …  
    412411    @Override 
    413412    public FType forTupleType(TupleType tt) { 
    414         if ( tt.getVarargs().isNone() ) { 
     413        if ( NodeUtil.isVoidType(tt) ) 
     414            return FTypeVoid.ONLY; 
     415        else if ( tt.getVarargs().isNone() ) { 
    415416            List<FType> elts = getFTypeListFromList(tt.getElements()); 
    416417            return FTypeTuple.make(elts); 

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

    r3123 r3133  
    3232import com.sun.fortress.nodes.TraitType; 
    3333import com.sun.fortress.nodes.TupleType; 
    34 import com.sun.fortress.nodes.VoidType; 
    3534import com.sun.fortress.nodes_util.NodeUtil; 
    3635import com.sun.fortress.compiler.Types; 
    … …  
    147146        } 
    148147    } 
    149  
    150     /* (non-Javadoc) 
    151      * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forVoidType(com.sun.fortress.nodes.VoidType) 
    152      */ 
    153     @Override 
    154     public void forVoidType(VoidType that) { 
    155         // do nothing 
    156     } 
    157  
    158  
    159  
    160148} 

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

    r3109 r3133  
    3737import com.sun.fortress.nodes.TupleType; 
    3838import com.sun.fortress.nodes.Type; 
    39 import com.sun.fortress.nodes.VoidType; 
    4039import com.sun.fortress.nodes.WhereExtends; 
    4140 
    … …  
    168167 
    169168    /* (non-Javadoc) 
    170      * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forVoidType(com.sun.fortress.nodes.VoidType) 
    171      */ 
    172     @Override 
    173     public void forVoidType(VoidType that) { 
    174         // TODO Auto-generated method stub 
    175         super.forVoidType(that); 
    176     } 
    177  
    178     /* (non-Javadoc) 
    179169     * @see com.sun.fortress.nodes.NodeAbstractVisitor_void#forWhereExtends(com.sun.fortress.nodes.WhereExtends) 
    180170     */ 

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

    r3060 r3133  
    3838import com.sun.fortress.nodes.AnyType; 
    3939import com.sun.fortress.nodes.StaticArg; 
     40import com.sun.fortress.nodes.TupleType; 
    4041import com.sun.fortress.nodes.Type; 
    4142import com.sun.fortress.nodes.VarType; 
    42 import com.sun.fortress.nodes.VoidType; 
    4343import com.sun.fortress.nodes_util.NodeUtil; 
    4444import com.sun.fortress.useful.BASet; 
    … …  
    491491        if (! (val instanceof VarType)) { 
    492492            if (DUMP_UNIFY) System.out.print("builtin "); 
    493             if (val instanceof VoidType) { 
     493            if (val instanceof TupleType && 
     494                NodeUtil.isVoidType((TupleType)val)) { 
    494495                other = FTypeVoid.ONLY; 
    495496            } 
    … …  
    500501            VarType vtval = (VarType)val; 
    501502            other = env.getTypeNull(vtval); 
    502              
    503                  
     503 
     504 
    504505            if (DUMP_UNIFY && other==null) System.out.print("undef second "); 
    505506        } 

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

    r3109 r3133  
    3434import com.sun.fortress.nodes.TupleType; 
    3535import com.sun.fortress.nodes.Type; 
    36 import com.sun.fortress.nodes.VoidType; 
     36import com.sun.fortress.nodes_util.NodeUtil; 
    3737import com.sun.fortress.useful.BoundingMap; 
    3838import com.sun.fortress.useful.Factory1; 
    … …  
    376376        List<Type> elements; 
    377377        Option<Type> vargs; 
    378         if (val instanceof VoidType) { 
    379             elements = Collections.emptyList(); 
    380             vargs = Option.none(); 
    381         } 
    382         else if (val instanceof TupleType) { 
     378        if (val instanceof TupleType) { 
    383379            TupleType _val = (TupleType) val; 
    384             if ( _val.getVarargs().isNone() ) { 
     380            if ( NodeUtil.isVoidType(_val) ) { 
     381                elements = Collections.emptyList(); 
     382                vargs = Option.none(); 
     383            } else if ( _val.getVarargs().isNone() ) { 
    385384                elements = _val.getElements(); 
    386385                vargs = Option.none(); 

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

    r3132 r3133  
    115115 
    116116    public String forVoidLiteralExpr(VoidLiteralExpr e) { 
    117         return "()"; 
    118     } 
    119  
    120     public String forVoidType(VoidType t) { 
    121117        return "()"; 
    122118    } 

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

    r3132 r3133  
    412412        if (left instanceof ArrowType) { 
    413413            return compare((ArrowType) left, (ArrowType) right); 
    414         } else if (left instanceof VoidType) { 
    415             return 0; 
    416414        } else if (left instanceof TupleType) { 
    417             return compare((TupleType) left, (TupleType) right); 
     415            if ( NodeUtil.isVoidType((TupleType)left) ) 
     416                return 0; 
     417            else return compare((TupleType) left, (TupleType) right); 
    418418        } else if (left instanceof TaggedDimType) { 
    419419            return compare((TaggedDimType) left, (TaggedDimType) right); 
    … …  
    437437                                 right.getClass() + ") is not implemented!"); 
    438438    } 
    439  
    440     static int subtypeCompareTo(VoidType left, VoidType right) { 
    441         // All voids are equal 
    442         return 0; 
    443     } 
    444439} 

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

    r3132 r3133  
    10561056    } 
    10571057 
    1058     public static VoidType makeVoidType(Span span) { 
    1059         return new VoidType(span, false); 
     1058    public static TupleType makeVoidType(Span span) { 
     1059        return new TupleType(span, false, Collections.<Type>emptyList(), 
     1060                             Option.<Type>none(), 
     1061                             Collections.<KeywordType>emptyList()); 
    10601062    } 
    10611063 
    … …  
    12651267            public Type forTupleType(TupleType t) { 
    12661268                return new TupleType(t.getSpan(), true, t.getElements(), 
    1267                                      t.getVarargs()); 
    1268             } 
    1269             public Type forVoidType(VoidType t) { 
    1270                 return new VoidType(t.getSpan(), true); 
     1269                                     t.getVarargs(), t.getKeywords()); 
    12711270            } 
    12721271            public Type forTaggedDimType(TaggedDimType t) { 

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

    r3132 r3133  
    166166        else if (def instanceof FnExpr) { return Option.some(((FnExpr)def).getBody()); } 
    167167        else { return Option.none(); } 
     168    } 
     169 
     170    public static boolean isVoidType(Type t) { 
     171        if ( t instanceof TupleType ) { 
     172            TupleType _t = (TupleType)t; 
     173            return ( _t.getElements().isEmpty() && 
     174                     _t.getVarargs().isNone() && 
     175                     _t.getKeywords().isEmpty() ); 
     176        } else 
     177            return false; 
    168178    } 
    169179 

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

    r3123 r3133  
    216216private Type VoidType = 
    217217     openparen w closeparen 
    218      { yyValue = new VoidType(createSpan(yyStart,yyCount)); }; 
     218     { yyValue = NodeFactory.makeVoidType(createSpan(yyStart,yyCount)); }; 
    219219 
    220220/* TypeTail ::= 

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

    r3132 r3133  
    21752175    } 
    21762176 
    2177     @Override public String forVoidTypeOnly(VoidType that) { 
    2178         return "()"; 
    2179     } 
    2180  
    21812177    @Override public String forArrowTypeOnly(ArrowType that, 
    21822178                                             String domain_result,