- Generalized use of AConstant to represent con...

- Generalized use of AConstant to represent constant values

4 files changed, 44 insertions, 125 deletions

diff --git a/sources/scalac/ast/Transformer.java.tmpl b/sources/scalac/ast/Transformer.java.tmpl
index 32f69eb3b5..69aef7dfca 100644
--- a/sources/scalac/ast/Transformer.java.tmpl
+++ b/sources/scalac/ast/Transformer.java.tmpl
@@ -265,8 +265,8 @@ public class GenTransformer {
             Symbol symbol = getSymbolFor(tree);
             return gen.Ident(tree.pos, symbol);
 
-        case Literal(Object value):
-            return gen.mkLit(tree.pos, value);
+        case Literal(AConstant value):
+            return gen.Literal(tree.pos, value);
 
         case TypeTerm():
             return gen.mkType(tree.pos, transform(tree.type()));
diff --git a/sources/scalac/ast/TreeGen.java b/sources/scalac/ast/TreeGen.java
index 2718287946..669f513c78 100644
--- a/sources/scalac/ast/TreeGen.java
+++ b/sources/scalac/ast/TreeGen.java
@@ -10,6 +10,7 @@ package scalac.ast;
 
 import scalac.Global;
 import scalac.ast.Tree.*;
+import scalac.atree.AConstant;
 import scalac.symtab.*;
 import scalac.typechecker.Infer;
 import scalac.util.*;
@@ -94,154 +95,64 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
     //########################################################################
     // Public Methods - Building constants
 
-    /** Builds a literal. */
-    public Tree mkLit(int pos, Object value) {
-        if (value instanceof Boolean) return mkBooleanLit(pos, (Boolean)value);
-        if (value instanceof Byte) return mkByteLit(pos, (Byte)value);
-        if (value instanceof Short) return mkShortLit(pos, (Short)value);
-        if (value instanceof Character) return mkCharLit(pos,(Character)value);
-        if (value instanceof Integer) return mkIntLit(pos, (Integer)value);
-        if (value instanceof Long) return mkLongLit(pos, (Long)value);
-        if (value instanceof Float) return mkFloatLit(pos, (Float)value);
-        if (value instanceof Double) return mkDoubleLit(pos, (Double)value);
-        if (value instanceof String) return mkStringLit(pos, (String)value);
-        throw Debug.abort("unknown literal class " + value.getClass(), value);
-    }
-
     /** Builds a unit literal. */
     public Tree mkUnitLit(int pos) {
-        return Block(pos, Tree.EMPTY_ARRAY);
+        return Literal(pos, AConstant.UNIT);
     }
 
     /** Builds a boolean literal. */
     public Tree mkBooleanLit(int pos, boolean value) {
-        return mkBooleanLit(pos, value ? Boolean.TRUE : Boolean.FALSE);
-    }
-
-    /** Builds a boolean literal. */
-    public Tree mkBooleanLit(int pos, Boolean value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.BOOLEAN_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.BOOLEAN(value));
     }
 
     /** Builds a byte literal. */
     public Tree mkByteLit(int pos, byte value) {
-        return mkByteLit(pos, new Byte(value));
-    }
-
-    /** Builds a byte literal. */
-    public Tree mkByteLit(int pos, Byte value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.BYTE_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.BYTE(value));
     }
 
     /** Builds a short literal. */
     public Tree mkShortLit(int pos, short value) {
-        return mkShortLit(pos, new Short(value));
-    }
-
-    /** Builds a short literal. */
-    public Tree mkShortLit(int pos, Short value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.SHORT_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.SHORT(value));
     }
 
     /** Builds a character literal. */
     public Tree mkCharLit(int pos, char value) {
-        return mkCharLit(pos, new Character(value));
-    }
-
-    /** Builds a character literal. */
-    public Tree mkCharLit(int pos, Character value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.CHAR_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.CHAR(value));
     }
 
     /** Builds an integer literal */
     public Tree mkIntLit(int pos, int value) {
-        return mkIntLit(pos, new Integer(value));
-    }
-
-    /** Builds an integer literal */
-    public Tree mkIntLit(int pos, Integer value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.INT_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.INT(value));
     }
 
     /** Builds a long literal. */
     public Tree mkLongLit(int pos, long value) {
-        return mkLongLit(pos, new Long(value));
-    }
-
-    /** Builds a long literal. */
-    public Tree mkLongLit(int pos, Long value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.LONG_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.LONG(value));
     }
 
     /** Builds a float literal. */
     public Tree mkFloatLit(int pos, float value) {
-        return mkFloatLit(pos, new Float(value));
-    }
-
-    /** Builds a float literal. */
-    public Tree mkFloatLit(int pos, Float value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.FLOAT_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.FLOAT(value));
     }
 
     /** Builds a double literal. */
     public Tree mkDoubleLit(int pos, double value) {
-        return mkDoubleLit(pos, new Double(value));
-    }
-
-    /** Builds a double literal. */
-    public Tree mkDoubleLit(int pos, Double value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.DOUBLE_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.DOUBLE(value));
     }
 
     /** Builds a string literal. */
     public Tree mkStringLit(int pos, String value) {
-        Tree tree = make.Literal(pos, value);
-        global.nextPhase();
-        tree.setType(definitions.STRING_TYPE());
-        global.prevPhase();
-        return tree;
+        return Literal(pos, AConstant.STRING(value));
     }
 
     /** Builds a null literal. */
     public Tree mkNullLit(int pos) {
-        return Ident(pos, definitions.NULL);
+        return Literal(pos, AConstant.NULL);
     }
 
     /** Builds a zero literal. */
     public Tree mkZeroLit(int pos) {
-        return Ident(pos, definitions.ZERO);
+        return Literal(pos, AConstant.ZERO);
     }
 
     /** Builds a default zero value according to given type tag. */
@@ -269,6 +180,15 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
         return mkZeroLit(pos);
     }
 
+    /** Builds a Literal node of given value. */
+    public Literal Literal(int pos, AConstant value) {
+        Literal tree = make.Literal(pos, value);
+        global.nextPhase();
+        tree.setType(definitions.atyper.type(value));
+        global.prevPhase();
+        return tree;
+    }
+
     //########################################################################
     // Public Methods - Building references
 
diff --git a/sources/scalac/ast/parser/Parser.java b/sources/scalac/ast/parser/Parser.java
index d98324c970..12226aa922 100644
--- a/sources/scalac/ast/parser/Parser.java
+++ b/sources/scalac/ast/parser/Parser.java
@@ -32,6 +32,10 @@ public class Parser implements Tokens {
      */
     TreeFactory make;
 
+    /** the tree generator
+     */
+    TreeGen gen;
+
     /** pattern checker and normalizer
      */
     PatternNormalizer pN;
@@ -43,6 +47,7 @@ public class Parser implements Tokens {
     public Parser(Unit unit) {
         s = new Scanner(unit);
         make = unit.global.make;
+        gen = unit.global.treeGen;
         pN = new PatternNormalizer( unit );
         mapTreeComment = unit.global.mapTreeComment;
         loopNestingDepth = 0;
@@ -620,38 +625,38 @@ public class Parser implements Tokens {
         Tree t;
         switch (s.token) {
         case CHARLIT:
-            t = make.Literal(s.pos, new Character((char)s.intVal));
+            t = gen.mkCharLit(s.pos, (char)s.intVal);
             break;
         case INTLIT:
-            t = make.Literal(s.pos, new Integer((int)s.intVal));
+            t = gen.mkIntLit(s.pos, (int)s.intVal);
             break;
         case LONGLIT:
-            t = make.Literal(s.pos, new Long(s.intVal));
+            t = gen.mkLongLit(s.pos, s.intVal);
             break;
         case FLOATLIT:
-            t = make.Literal(s.pos, new Float((float)s.floatVal));
+            t = gen.mkFloatLit(s.pos, (float)s.floatVal);
             break;
         case DOUBLELIT:
-            t = make.Literal(s.pos, new Double(s.floatVal));
+            t = gen.mkDoubleLit(s.pos, s.floatVal);
             break;
         case STRINGLIT:
-            t = make.Literal(s.pos, s.name.toString());
+            t = gen.mkStringLit(s.pos, s.name.toString());
             break;
         case TRUE:
-            t = make.Literal(s.pos, Boolean.TRUE);
+            t = gen.mkBooleanLit(s.pos, true);
             break;
         case FALSE:
-            t = make.Literal(s.pos, Boolean.FALSE);
+            t = gen.mkBooleanLit(s.pos, false);
             break;
         case NULL:
-            t = make.Ident(s.pos, Names.null_);
+            t = gen.mkNullLit(s.pos);
             break;
         case SYMBOLLIT:
 	    int pos = s.pos;
             Tree symt = scalaDot(s.pos, Names.Symbol);
             if (isPattern) symt = convertToTypeId(symt);
 	    TreeList ts = new TreeList();
-	    ts.append(make.Literal(s.pos, s.name.toString()));
+	    ts.append(gen.mkStringLit(s.pos, s.name.toString()));
 	    s.nextToken();
             if (s.token == LPAREN || s.token == LBRACE)
                 ts.append(argumentExprs());
@@ -1171,10 +1176,10 @@ public class Parser implements Tokens {
                         new Tree.CaseDef[]{
                             (CaseDef)make.CaseDef(
                                 rhs.pos, pat.duplicate(), Tree.Empty,
-                                make.Literal(s.pos, Boolean.TRUE)),
+                                gen.mkBooleanLit(s.pos, true)),
                             (CaseDef)make.CaseDef(
                                 rhs.pos, make.Ident(rhs.pos, Names.PATTERN_WILDCARD), Tree.Empty,
-                                make.Literal(s.pos, Boolean.FALSE))})});
+                                gen.mkBooleanLit(s.pos, false))})});
         return make.PatDef(pos, 0, pat, rhs);
     }
 
diff --git a/sources/scalac/ast/printer/TextTreePrinter.java b/sources/scalac/ast/printer/TextTreePrinter.java
index 730c53fe06..cbe607b3b2 100644
--- a/sources/scalac/ast/printer/TextTreePrinter.java
+++ b/sources/scalac/ast/printer/TextTreePrinter.java
@@ -10,6 +10,7 @@
 package scalac.ast.printer;
 
 import scalac.ast.*;
+import scalac.atree.AConstant;
 import scalac.symtab.*;
 import scalac.util.Debug;
 import scalac.Global;
@@ -558,15 +559,8 @@ public class TextTreePrinter implements TreePrinter {
             printType(tree);
             break;
 
-        case Literal(Object obj):
-            String str;
-            if (obj instanceof String)
-                str = "\"" + obj + "\"";
-            else if (obj instanceof Character)
-                str = "\'" + obj + "\'";
-            else
-                str = String.valueOf(obj);
-            print(Text.Literal(str));
+        case Literal(AConstant value):
+            print(Text.Literal(value.toString()));
             printType(tree);
             break;