Changeset 3203

Show
Ignore:
Timestamp:
12/12/08 11:46:23 (12 months ago)
Author:
sukyoungryu
Message:

[ast refactoring] Removed optional fields of the rest of the Type nodes.

Location:
trunk/ProjectFortress
Files:
15 modified

Legend:

Unmodified
Added
Removed

  • trunk/ProjectFortress/astgen/Fortress.ast

    r3202 r3203  
    976976             * type 
    977977             */ 
    978             root abstract Type(ignoreForEquals boolean parenthesized = false); 
     978            root abstract Type(ignoreForEquals boolean parenthesized); 
    979979                /** 
    980980                 * base types: things that can be extended, excluded, thrown, etc. 

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

    r3202 r3203  
    5555    public static final Id IMMUTABLE_HEAP_SEQ_NAME = makeId(fortressLibrary, "ImmutableArray"); 
    5656 
    57     public static final AnyType ANY = new AnyType(span); 
    58     public static final BottomType BOTTOM = new BottomType(span); 
     57    public static final AnyType ANY = new AnyType(span, false); 
     58    public static final BottomType BOTTOM = new BottomType(span, false); 
    5959    public static final TraitType OBJECT = makeTraitType(fortressBuiltin, "Object"); 
    6060 
    … …  
    7373 
    7474 
    75     public static final LabelType LABEL = new LabelType(span); 
     75    public static final LabelType LABEL = new LabelType(span, false); 
    7676 
    7777    public static final TraitType makeVarargsParamType(Type varargsType) { 
    … …  
    127127                default: { 
    128128                    List<Type> l = CollectUtil.makeList(ts); 
    129                     return new UnionType(NodeFactory.makeSpan("impossible", l), l); 
     129                    return NodeFactory.makeUnionType(NodeFactory.makeSpan("impossible", l), 
     130                                                     false, l); 
    130131                } 
    131132            } 
    … …  
    147148                default: { 
    148149                    List<Type> l = CollectUtil.makeList(ts); 
    149                     return new IntersectionType(NodeFactory.makeSpan("impossible", l), l); 
     150                    return NodeFactory.makeIntersectionType(NodeFactory.makeSpan("impossible", l), l); 
    150151                } 
    151152            } 

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

    r3202 r3203  
    209209            public Type value(Id n) { 
    210210                if (n.equals(Types.ANY_NAME)) { 
    211                     return new AnyType(that.getSpan()); 
     211                    return new AnyType(that.getSpan(), false); 
    212212                } 
    213213                else { 
    … …  
    238238                List<StaticArg> args = that.getArgs(); 
    239239                if (n.equals(Types.ANY_NAME) && args.isEmpty()) { 
    240                     return new AnyType(that.getSpan()); 
     240                    return new AnyType(that.getSpan(), false); 
    241241                } 
    242242                else { 
    … …  
    353353                            } 
    354354                            @Override public StaticArg forKindDim(KindDim p) { 
    355                                 return new DimArg(s, new DimRef(s, name)); 
     355                                return new DimArg(s, NodeFactory.makeDimRef(s, name)); 
    356356                            } 
    357357                            @Override public StaticArg forKindInt(KindInt p) { 
    … …  
    567567                    @Override 
    568568                    public StaticArg forKindDim(KindDim k) { 
    569                         return new DimArg(arg.getSpan(), new DimRef(arg.getSpan(), (Id)name)); 
     569                        return new DimArg(arg.getSpan(), NodeFactory.makeDimRef(arg.getSpan(), (Id)name)); 
    570570                    } 
    571571                    @Override 

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

    r3123 r3203  
    7777        } 
    7878        // TODO highly bogus span here -- we need a set-span 
    79         return some(new BindingLookup(var, new IntersectionType(NodeFactory.makeSetSpan("impossible", overloadedTypes), overloadedTypes))); 
     79        return some(new BindingLookup(var, NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", overloadedTypes), overloadedTypes))); 
    8080    } 
    8181 

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

    r3202 r3203  
    162162            } 
    163163        } 
    164         return Option.some(new BindingLookup(var, new IntersectionType(NodeFactory.makeSetSpan("impossible", overloadedTypes), overloadedTypes))); 
     164        return Option.some(new BindingLookup(var, NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", overloadedTypes), overloadedTypes))); 
    165165    } 
    166166 

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

    r3071 r3203  
    9090        // created elsewhere that wrap Characters (currently, other instances just wrap 
    9191        // raw Objects) 
    92         return new _InferenceVarType(NodeFactory.makeSpan("blame InferenceVarTranslator.nextCanonicalVar"), _canonicalNames.next()); 
     92        return NodeFactory.make_InferenceVarType(NodeFactory.makeSpan("blame InferenceVarTranslator.nextCanonicalVar"), 
     93                                                 false, _canonicalNames.next()); 
    9394    } 
    9495 

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

    r3122 r3203  
    8484        } 
    8585        // TODO, need a "set span" 
    86         return Option.some(new BindingLookup(var, new IntersectionType(NodeFactory.makeSetSpan("impossible", overloads), overloads))); 
     86        return Option.some(new BindingLookup(var, NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", overloads), overloads))); 
    8787    } 
    8888 

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

    r3176 r3203  
    548548            default: { 
    549549                List<Type> l = CollectUtil.makeList(elts); 
    550                 return new UnionType(NodeFactory.makeSetSpan("impossible", l),l); 
     550                return NodeFactory.makeUnionType(NodeFactory.makeSetSpan("impossible", l), false, l); 
    551551            } 
    552552        } 
    … …  
    567567            default: { 
    568568                List<Type> l = CollectUtil.makeList(elts); 
    569                 return new IntersectionType(NodeFactory.makeSetSpan("impossible", l),l); 
     569                return NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", l),l); 
    570570            } 
    571571        } 

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

    r3202 r3203  
    526526        opIndex = findAtTop(s, "|"); 
    527527        if (opIndex == 0) { 
    528             return new UnionType(span, parseTypeList(s, "|{", "}")); 
     528            return NodeFactory.makeUnionType(span, false, parseTypeList(s, "|{", "}")); 
    529529        } 
    530530        else if (opIndex > 0) { 
    … …  
    536536        opIndex = findAtTop(s, "&"); 
    537537        if (opIndex == 0) { 
    538             return new IntersectionType(span, parseTypeList(s, "&{", "}")); 
     538            return NodeFactory.makeIntersectionType(span, parseTypeList(s, "&{", "}")); 
    539539        } 
    540540        else if (opIndex > 0) { 
    … …  
    567567 
    568568        if (s.startsWith("#")) { 
    569             return new _InferenceVarType(span, s); 
     569            return NodeFactory.make_InferenceVarType(span, false, s); 
    570570        } 
    571571 

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

    r3202 r3203  
    25372537                        type = (arrow_types.isEmpty()) ? 
    25382538                                        Option.<Type>none() : 
    2539                                                 Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
     2539                                                Option.<Type>some(NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
    25402540                                        constraints = accumulated_constraints; 
    25412541                                        new_node = ExprFactory.makeFnRef(that.getSpan(), 
    … …  
    25652565                                type = Option.<Type>some(arrow_types.get(0)); 
    25662566                        } else { 
    2567                                 type = Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
     2567                                type = Option.<Type>some(NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
    25682568                        } 
    25692569 
    25702570                        type = (arrow_types.isEmpty()) ? 
    25712571                                        Option.<Type>none() : 
    2572                                                 Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
     2572                                                Option.<Type>some(NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
    25732573                                        constraints = accumulated_constraints; 
    25742574                                        new_node = ExprFactory.makeFnRef(that.getSpan(), 
    … …  
    38463846                        type = (arrow_types.isEmpty()) ? 
    38473847                                        Option.<Type>none() : 
    3848                                                 Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
     3848                                                Option.<Type>some(NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
    38493849                                        new_node = ExprFactory.makeOpRef(that.getSpan(), 
    38503850                                                                         that.isParenthesized(), 
    … …  
    38723872                        type = (arrow_types.isEmpty()) ? 
    38733873                                        Option.<Type>none() : 
    3874                                                 Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
     3874                                                Option.<Type>some(NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types)); 
    38753875 
    38763876                                        constraints = accumulated_constraints; 

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

    r3202 r3203  
    195195                        } 
    196196                        public StaticArg forKindDim(KindDim k) { 
    197                             return new DimArg(new Span(), new DimRef(new Span(), (Id)name)); 
     197                            return new DimArg(new Span(), NodeFactory.makeDimRef(new Span(), (Id)name)); 
    198198                        } 
    199199                        public StaticArg forKindInt(KindInt k) { 
    … …  
    455455                mods.addAll(decl.getMods()); 
    456456            } 
    457             type = Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", overloads), overloads)); 
     457            type = Option.<Type>some(NodeFactory.makeIntersectionType(NodeFactory.makeSetSpan("impossible", overloads), overloads)); 
    458458            mutable = false; 
    459459        } 

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

    r3202 r3203  
    421421                                        } 
    422422                                } 
    423                                 return Option.some(Pair.make((Type) new IntersectionType(that.getSpan(),that.isParenthesized(),conjuncts),accumulated_constraint)); 
     423                                return Option.some(Pair.make((Type) NodeFactory.makeIntersectionType(that.getSpan(), 
     424                                                                                                     that.isParenthesized(), 
     425                                                                                                     conjuncts),accumulated_constraint)); 
    424426                        } 
    425427 

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

    r3202 r3203  
    649649    } 
    650650 
     651    public static DimBinaryOp makeDimBinaryOp(DimBinaryOp t, DimExpr s, DimExpr u, Op o) { 
     652        return makeDimBinaryOp(t.getSpan(), t.isParenthesized(), s, u, o); 
     653    } 
     654 
     655    public static DimBinaryOp makeDimBinaryOp(Span span, boolean parenthesized, 
     656                                              DimExpr left, DimExpr right, Op op) { 
     657        return new DimBinaryOp(span, parenthesized, left, right, op); 
     658    } 
     659 
     660    public static DimUnaryOp makeDimUnaryOp(DimUnaryOp t, DimExpr s) { 
     661        return makeDimUnaryOp(t.getSpan(), t.isParenthesized(), s, t.getOp()); 
     662    } 
     663 
     664    public static DimUnaryOp makeDimUnaryOp(Span span, boolean parenthesized, 
     665                                            DimExpr dim, Op op) { 
     666        return new DimUnaryOp(span, parenthesized, dim, op); 
     667    } 
     668 
     669    public static DimExponent makeDimExponent(DimExponent t, Type s) { 
     670        return makeDimExponent(t.getSpan(), t.isParenthesized(), s, 
     671                               t.getPower()); 
     672    } 
     673 
     674    public static DimExponent makeDimExponent(Span span, boolean parenthesized, 
     675                                              Type base, IntExpr power) { 
     676        return new DimExponent(span, parenthesized, base, power); 
     677    } 
     678 
     679    public static DimRef makeDimRef(Span span, String name) { 
     680        return makeDimRef(span, false, makeId(name)); 
     681    } 
     682 
     683    public static DimRef makeDimRef(Span span, Id name) { 
     684        return new DimRef(span, false, name); 
     685    } 
     686 
     687    public static DimRef makeDimRef(Span span, boolean parenthesized, Id name) { 
     688        return new DimRef(span, parenthesized, name); 
     689    } 
     690 
     691    public static DimBase makeDimBase(Span span, boolean parenthesized) { 
     692        return new DimBase(span, parenthesized); 
     693    } 
     694 
     695    public static FixedPointType makeFixedPointType(FixedPointType t, Type s) { 
     696        return makeFixedPointType(t.getSpan(), t.isParenthesized(), t.getName(), s); 
     697    } 
     698 
     699    public static FixedPointType makeFixedPointType(_InferenceVarType name, Type s) { 
     700        return makeFixedPointType(s.getSpan(), s.isParenthesized(), name, s); 
     701    } 
     702 
     703    public static FixedPointType makeFixedPointType(Span span, boolean parenthesized, 
     704                                                    _InferenceVarType name, Type body) { 
     705        return new FixedPointType(span, parenthesized, name, body); 
     706    } 
     707 
     708    public static UnionType makeUnionType(Type t1, Type t2) { 
     709        return new UnionType(FortressUtil.spanTwo(t1, t2), false, 
     710                             Arrays.asList(t1, t2)); 
     711    } 
     712 
     713    public static UnionType makeUnionType(Set<? extends Type> types){ 
     714        return new UnionType(FortressUtil.spanAll(types), false, 
     715                             CollectUtil.makeList(types)); 
     716    } 
     717 
     718    public static UnionType makeUnionType(Span span, boolean parenthesized, 
     719                                          List<Type> elements) { 
     720        return new UnionType(span, parenthesized, elements); 
     721    } 
     722 
     723    public static List<Type> make_InferenceVarTypes(Span s, int size) { 
     724        List<Type> result = new ArrayList<Type>(size); 
     725        for (int i = 0; i < size; i++) { result.add(make_InferenceVarType(s)); } 
     726        return result; 
     727    } 
     728 
     729    public static _InferenceVarType make_InferenceVarType(Span s) { 
     730        return make_InferenceVarType(s, false, new Object()); 
     731    } 
     732 
     733    public static _InferenceVarType make_InferenceVarType(Span span, boolean parenthesized, Object id) { 
     734        return new _InferenceVarType(span, parenthesized, id); 
     735    } 
     736 
     737    public static TaggedUnitType makeTaggedUnitType(TaggedUnitType t, Type s) { 
     738        return makeTaggedUnitType(t.getSpan(), t.isParenthesized(), s, 
     739                                  t.getUnitExpr()); 
     740    } 
     741 
     742    public static TaggedUnitType makeTaggedUnitType(Span span, boolean parenthesized, 
     743                                                    Type elem, Expr unit) { 
     744        return makeTaggedUnitType(span, parenthesized, elem, unit); 
     745    } 
     746 
     747 
     748    public static MatrixType makeMatrixType(Span span, Type element, 
     749                                            ExtentRange dimension) { 
     750        List<ExtentRange> dims = new ArrayList<ExtentRange>(); 
     751        dims.add(dimension); 
     752        dims = Useful.immutableTrimmedList(dims); 
     753        return makeMatrixType(span, false, element, dims); 
     754    } 
     755 
     756    public static MatrixType makeMatrixType(Span span, Type element, 
     757                                            ExtentRange dimension, 
     758                                            List<ExtentRange> dimensions) { 
     759        List<ExtentRange> dims = new ArrayList<ExtentRange>(); 
     760        dims.add(dimension); 
     761        dims.addAll(dimensions); 
     762        dims = Useful.immutableTrimmedList(dims); 
     763        return makeMatrixType(span, false, element, dims); 
     764    } 
     765 
     766    public static MatrixType makeMatrixType(Span span, boolean parenthesized, 
     767                                            Type elem, List<ExtentRange> dim) { 
     768        return new MatrixType(span, parenthesized, elem, dim); 
     769    } 
     770 
     771    public static ArrayType makeArrayType(Span span, Type element, 
     772                                          Option<Indices> ind) { 
     773        Indices indices = ind.unwrap(new Indices(span, Collections.<ExtentRange>emptyList())); 
     774        return makeArrayType(span, false, element, indices); 
     775    } 
     776 
     777    public static ArrayType makeArrayType(Span span, boolean parenthesized, 
     778                                          Type elem, Indices indices) { 
     779        return new ArrayType(span, parenthesized, elem, indices); 
     780    } 
     781 
     782    public static IntersectionType makeIntersectionType(Type t1, Type t2) { 
     783        return makeIntersectionType(FortressUtil.spanTwo(t1, t2), false, 
     784                                    Arrays.asList(t1, t2)); 
     785    } 
     786 
     787    public static IntersectionType makeIntersectionType(Set<? extends Type> types) { 
     788        return makeIntersectionType(FortressUtil.spanAll(types), false, 
     789                                    CollectUtil.makeList(types)); 
     790    } 
     791 
     792    public static IntersectionType makeIntersectionType(Span span, 
     793                                                        List<Type> elems) { 
     794        return new IntersectionType(span, false, elems); 
     795    } 
     796 
     797    public static IntersectionType makeIntersectionType(Span span, boolean parenthesized, 
     798                                                        List<Type> elems) { 
     799        return new IntersectionType(span, parenthesized, elems); 
     800    } 
     801 
    651802    /***************************************************************************/ 
    652803 
    … …  
    688839    } 
    689840 
    690     public static ArrayType makeArrayType(Span span, Type element, 
    691             Option<Indices> ind) { 
    692         Indices indices = ind.unwrap(new Indices(span, Collections.<ExtentRange>emptyList())); 
    693         return new ArrayType(span, element, indices); 
    694     } 
    695  
    696     public static DimExponent makeDimExponent(DimExponent t, Type s) { 
    697         return new DimExponent(t.getSpan(), t.isParenthesized(), s, 
    698                                t.getPower()); 
    699     } 
    700  
    701     public static DimBinaryOp makeDimBinaryOp(DimBinaryOp t, DimExpr s, DimExpr u, Op o) { 
    702         return new DimBinaryOp(t.getSpan(), t.isParenthesized(), s, u, o); 
    703     } 
    704  
    705     public static DimUnaryOp makeDimUnaryOp(DimUnaryOp t, DimExpr s) { 
    706         return new DimUnaryOp(t.getSpan(), t.isParenthesized(), s, t.getOp()); 
    707     } 
    708  
    709841    public static TraitTypeWhere makeTraitTypeWhere(BaseType in_type) { 
    710842        Span sp = in_type.getSpan(); 
    … …  
    720852    } 
    721853 
    722     public static _InferenceVarType make_InferenceVarType(Span s) { 
    723         return new _InferenceVarType(s, new Object()); 
    724     } 
    725  
    726     public static List<Type> make_InferenceVarTypes(Span s, int size) { 
    727         List<Type> result = new ArrayList<Type>(size); 
    728         for (int i = 0; i < size; i++) { result.add(make_InferenceVarType(s)); } 
    729         return result; 
    730     } 
    731  
    732854    public static KeywordType makeKeywordType(KeywordType t, Type s) { 
    733855        return new KeywordType(t.getSpan(), t.getName(), s); 
    734856    } 
    735857 
    736     public static TaggedUnitType makeTaggedUnitType(TaggedUnitType t, Type s) { 
    737         return new TaggedUnitType(t.getSpan(), t.isParenthesized(), s, 
    738                                   t.getUnitExpr()); 
    739     } 
    740  
    741858    public static TypeArg makeTypeArg(TypeArg t, Type s) { 
    742859        return new TypeArg(t.getSpan(), s); 
    … …  
    751868    } 
    752869 
    753     public static DimRef makeDimRef(Span span, String name) { 
    754         return new DimRef(span, makeId(name)); 
    755     } 
    756  
    757870    public static UnitArg makeUnitArg(UnitExpr s) { 
    758871        return new UnitArg(s.getSpan(), s); 
    … …  
    761874    public static UnitRef makeUnitRef(Span span, String name) { 
    762875        return new UnitRef(span, makeId(name)); 
    763     } 
    764  
    765     public static FixedPointType makeFixedPointType(FixedPointType t, Type s) { 
    766         return new FixedPointType(t.getSpan(), t.isParenthesized(), t.getName(), 
    767                 s); 
    768     } 
    769  
    770     public static FixedPointType makeFixedPointType(_InferenceVarType name, Type s) { 
    771         return new FixedPointType(s.getSpan(), s.isParenthesized(), name, s); 
    772     } 
    773  
    774     public static IntersectionType makeIntersectionType(Type t1, Type t2) { 
    775         return new IntersectionType(FortressUtil.spanTwo(t1, t2), Arrays.asList(t1, t2)); 
    776     } 
    777  
    778     public static IntersectionType makeIntersectionType(Set<? extends Type> types){ 
    779         return new IntersectionType(FortressUtil.spanAll(types),CollectUtil.makeList(types)); 
    780     } 
    781  
    782     public static UnionType makeUnionType(Type t1, Type t2) { 
    783         return new UnionType(FortressUtil.spanTwo(t1, t2), Arrays.asList(t1, t2)); 
    784     } 
    785  
    786     public static UnionType makeUnionType(Set<? extends Type> types){ 
    787         return new UnionType(FortressUtil.spanAll(types),CollectUtil.makeList(types)); 
    788876    } 
    789877 
    … …  
    9991087    }; 
    10001088 
    1001     public static MatrixType makeMatrixType(Span span, Type element, 
    1002                                             ExtentRange dimension) { 
    1003         List<ExtentRange> dims = new ArrayList<ExtentRange>(); 
    1004         dims.add(dimension); 
    1005         dims = Useful.immutableTrimmedList(dims); 
    1006         return new MatrixType(span, element, dims); 
    1007     } 
    1008  
    1009     public static MatrixType makeMatrixType(Span span, Type element, 
    1010                                             ExtentRange dimension, 
    1011                                             List<ExtentRange> dimensions) { 
    1012         List<ExtentRange> dims = new ArrayList<ExtentRange>(); 
    1013         dims.add(dimension); 
    1014         dims.addAll(dimensions); 
    1015         dims = Useful.immutableTrimmedList(dims); 
    1016         return new MatrixType(span, element, dims); 
    1017     } 
    1018  
    10191089    public static Op makeEnclosing(Span in_span, String in_open, String in_close) { 
    10201090        return new Op(in_span, PrecedenceMap.ONLY.canon(in_open + " " + in_close), 
    … …  
    12901360        return dim.accept(new NodeAbstractVisitor<DimExpr>() { 
    12911361            public DimExpr forDimBase(DimBase t) { 
    1292                 return new DimBase(t.getSpan(), true); 
     1362                return makeDimBase(t.getSpan(), true); 
    12931363            } 
    12941364            public DimExpr forDimRef(DimRef t) { 
    1295                 return new DimRef(t.getSpan(), true, t.getName()); 
     1365                return makeDimRef(t.getSpan(), true, t.getName()); 
    12961366            } 
    12971367            public DimExpr forDimBinaryOp(DimBinaryOp t) { 
    1298                 return new DimBinaryOp(t.getSpan(), true, t.getLeft(), 
     1368                return makeDimBinaryOp(t.getSpan(), true, t.getLeft(), 
    12991369                                       t.getRight(), t.getOp()); 
    13001370            } 
    13011371            public DimExpr forDimExponent(DimExponent t) { 
    1302                 return new DimExponent(t.getSpan(), true, t.getBase(), 
    1303                         t.getPower()); 
     1372                return makeDimExponent(t.getSpan(), true, t.getBase(), 
     1373                                       t.getPower()); 
    13041374            } 
    13051375            public DimExpr forDimUnaryOp(DimUnaryOp t) { 
    1306                 return new DimUnaryOp(t.getSpan(), true, t.getDimVal(), t.getOp()); 
     1376                return makeDimUnaryOp(t.getSpan(), true, t.getDimVal(), t.getOp()); 
    13071377            } 
    13081378            public DimExpr defaultCase(Node x) { 
    … …  
    13561426            } 
    13571427            public Type forArrayType(ArrayType t) { 
    1358                 return new ArrayType(t.getSpan(), true, t.getElemType(), 
    1359                         t.getIndices()); 
     1428                return makeArrayType(t.getSpan(), true, t.getElemType(), 
     1429                                     t.getIndices()); 
    13601430            } 
    13611431            public Type forVarType(VarType t) { 
    … …  
    13631433            } 
    13641434            public Type forMatrixType(MatrixType t) { 
    1365                 return new MatrixType(t.getSpan(), true, t.getElemType(), 
    1366                         t.getDimensions()); 
     1435                return makeMatrixType(t.getSpan(), true, t.getElemType(), 
     1436                                      t.getDimensions()); 
    13671437            } 
    13681438            public Type forTraitType(TraitType t) { 
    … …  
    13791449            } 
    13801450            public Type forTaggedUnitType(TaggedUnitType t) { 
    1381                 return new TaggedUnitType(t.getSpan(), true, t.getElemType(), 
     1451                return makeTaggedUnitType(t.getSpan(), true, t.getElemType(), 
    13821452                                          t.getUnitExpr()); 
    13831453            } 

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

    r3202 r3203  
    151151   / TypeRef 
    152152   / VoidType 
    153    / one { yyValue = new DimBase(createSpan(yyStart,1)); }; 
     153   / one { yyValue = NodeFactory.makeDimBase(createSpan(yyStart,1), false); }; 
    154154 
    155155/* ParenthesizedType ::= ( w Type w ) */ 
    … …  
    205205   / "Unity" 
    206206     { Span span = createSpan(yyStart,yyCount); 
    207        yyValue = new DimBase(span); 
     207         yyValue = NodeFactory.makeDimBase(span, false); 
    208208     } 
    209209   / a1:Id a2:StaticArgs? 
    … …  
    302302                                      "by an exponentiation."); 
    303303               if (base instanceof DimExpr) { 
    304                    return new DimExponent(createSpan(yyStart,yyCount), 
    305                                           (DimExpr)base, a1); 
     304                   return NodeFactory.makeDimExponent(createSpan(yyStart,yyCount), 
     305                                                      false, (DimExpr)base, a1); 
    306306               } else { // !(base instanceof DimExpr) 
    307                    return new DimExponent(createSpan(yyStart,yyCount), 
    308                                           (Type)base, a1); 
     307                   return NodeFactory.makeDimExponent(createSpan(yyStart,yyCount), 
     308                                                      false, (Type)base, a1); 
    309309               } 
    310310           }}; 
    … …  
    353353           public Type run(Type base) { 
    354354               return NodeFactory.makeTaggedDimType(createSpan(yyStart,yyCount), false, 
    355                                                     (Type)base, new DimRef(a1.getSpan(), a1), 
     355                                                    (Type)base, NodeFactory.makeDimRef(a1.getSpan(), a1), 
    356356                                                    Option.<Expr>none()); 
    357357           }}; 

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

    r3202 r3203  
    7575    private static Type makeProductDim(Span span, TaggedDimType expr0, 
    7676                                       DimExpr expr2) throws TypeConvertFailure { 
    77         DimExpr dim = new DimBinaryOp(span, true, dimToDim(expr0.getDimExpr()), 
    78                                       dimToDim(expr2), product(span)); 
     77        DimExpr dim = NodeFactory.makeDimBinaryOp(span, true, dimToDim(expr0.getDimExpr()), 
     78                                                  dimToDim(expr2), product(span)); 
    7979        return NodeFactory.makeTaggedDimType(span, true, 
    8080                                             typeToType(expr0.getElemType()), dim, 
    … …  
    8585                                        DimExpr expr2) 
    8686        throws TypeConvertFailure { 
    87         DimExpr dim = new DimBinaryOp(span, true, dimToDim(expr0.getDimExpr()), 
     87        DimExpr dim = NodeFactory.makeDimBinaryOp(span, true, dimToDim(expr0.getDimExpr()), 
    8888                                      dimToDim(expr2), quotient(span)); 
    8989        return NodeFactory.makeTaggedDimType(span, true, 
    … …  
    268268                    DimExpr _first = typeToDim(first); 
    269269                    if (isDOT(op)) 
    270                         return new DimBinaryOp(span, true, _first, _second, 
     270                        return NodeFactory.makeDimBinaryOp(span, true, _first, _second, 
    271271                                               product(span)); 
    272272                    else // op.getText().equals("/") || 
    273273                         // op.getText().equals("per") 
    274                         return new DimBinaryOp(span, true, _first, _second, 
     274                        return NodeFactory.makeDimBinaryOp(span, true, _first, _second, 
    275275                                               quotient(span)); 
    276276                    //                    throw new ReadError(op.getSpan(), "DimExpr is expected."); 
    … …  
    457457                        DimExpr e = 
    458458                            typeToDim(((RealType)__opTypes.getFirst()).getType()); 
    459                         return _rest.cons(new RealType(new DimUnaryOp(e.getSpan(), true, 
     459                        return _rest.cons(new RealType(NodeFactory.makeDimUnaryOp(e.getSpan(), true, 
    460460                                                                 e, op))); 
    461461                    } catch (TypeConvertFailure x) { 
    … …  
    529529                            try { 
    530530                                DimExpr _expr0 = typeToDim(expr0); 
    531                                 e = new DimBinaryOp(span, true, 
     531                                e = NodeFactory.makeDimBinaryOp(span, true, 
    532532                                                    _expr0, expr2, 
    533533                                                    quotient(span)); 
    … …  
    574574                    Op op = ((Postfix)(_rest.getFirst())).getOp(); 
    575575                    PureList<PostfixOpExpr> restRest = _rest.getRest(); 
    576                     DimExpr dim = new DimUnaryOp(_first.getSpan(), 
     576                    DimExpr dim = NodeFactory.makeDimUnaryOp(_first.getSpan(), 
    577577                                            _first.isParenthesized(), 
    578578                                            _first, op); 
    … …  
    630630                public DimExpr forDimExponent(DimExponent t) { 
    631631                    try { 
    632                         return new DimExponent(t.getSpan(), 
     632                        return NodeFactory.makeDimExponent(t.getSpan(), 
    633633                                               t.isParenthesized(), 
    634634                                               typeToDim(t.getBase()), 
    … …  
    647647                        ExtentRange dimension = dimensions.get(0); 
    648648                        IntArg power = (IntArg)dimension.getSize().unwrap(); 
    649                         return new DimExponent(t.getSpan(), 
     649                        return NodeFactory.makeDimExponent(t.getSpan(), 
    650650                                               t.isParenthesized(), 
    651651                                               typeToDim(t.getElemType()), 
    … …  
    659659                    try { 
    660660                        if (t.getUnitExpr().isNone()) { 
    661                             return new DimBinaryOp(t.getSpan(), 
     661                            return NodeFactory.makeDimBinaryOp(t.getSpan(), 
    662662                                                   t.isParenthesized(), 
    663663                                                   typeToDim(t.getElemType()), 
    … …  
    691691            public DimExpr forDimExponent(DimExponent d) { 
    692692                try { 
    693                     return new DimExponent(d.getSpan(), 
     693                    return NodeFactory.makeDimExponent(d.getSpan(), 
    694694                                           d.isParenthesized(), 
    695695                                           typeToDim(d.getBase()), 
    … …  
    700700            } 
    701701            public DimExpr forDimBinaryOp(DimBinaryOp d) { 
    702                 return new DimBinaryOp(d.getSpan(), 
     702                return NodeFactory.makeDimBinaryOp(d.getSpan(), 
    703703                                       d.isParenthesized(), 
    704704                                       dimToDim(d.getLeft()), 
    … …  
    707707            } 
    708708            public DimExpr forDimUnaryOp(DimUnaryOp d) { 
    709                 return new DimUnaryOp(d.getSpan(), 
     709                return NodeFactory.makeDimUnaryOp(d.getSpan(), 
    710710                                 d.isParenthesized(), 
    711711                                 dimToDim(d.getDimVal()), 
    … …  
    779779                        DimExpr rleft = _right.getLeft(); 
    780780                        Span span = spanTwo(left, rleft); 
    781                         left = new DimBinaryOp(span, 
     781                        left = NodeFactory.makeDimBinaryOp(span, 
    782782                                               true, left, rleft, 
    783783                                               product(span)); 
    … …  
    786786                    } else 
    787787                        left = canonicalizeDim(left); 
    788                     return new DimBinaryOp(d.getSpan(), 
     788                    return NodeFactory.makeDimBinaryOp(d.getSpan(), 
    789789                                           d.isParenthesized(), 
    790790                                           left, right, product(d.getSpan())); 
    791791                } else { 
    792                     return new DimBinaryOp(d.getSpan(), 
     792                    return NodeFactory.makeDimBinaryOp(d.getSpan(), 
    793793                                           d.isParenthesized(), 
    794794                                           canonicalizeDim(d.getLeft()), 
    … …  
    799799            } 
    800800            public DimExpr forDimExponent(DimExponent d) { 
    801                 return new DimExponent(d.getSpan(), 
     801                return NodeFactory.makeDimExponent(d.getSpan(), 
    802802                                       d.isParenthesized(), 
    803803                                       canonicalizeDim((DimExpr)d.getBase()), 
    … …  
    805805            } 
    806806            public DimExpr forDimUnaryOp(DimUnaryOp d) { 
    807                 return new DimUnaryOp(d.getSpan(), 
     807                return NodeFactory.makeDimUnaryOp(d.getSpan(), 
    808808                                 d.isParenthesized(), 
    809809                                 canonicalizeDim(d.getDimVal()),