- In Definitions, replaced primitive _TYPE fiel...

- In Definitions, replaced primitive _TYPE fields by methods

15 files changed, 92 insertions, 101 deletions

diff --git a/sources/scala/tools/scalai/Interpreter.java b/sources/scala/tools/scalai/Interpreter.java
index 9c43c5fa1f..b87114eb90 100644
--- a/sources/scala/tools/scalai/Interpreter.java
+++ b/sources/scala/tools/scalai/Interpreter.java
@@ -146,7 +146,7 @@ public class Interpreter {
         if (!erased) global.currentPhase = global.getFirstPhase();
         Definitions definitions = global.definitions;
         Type argument = definitions.arrayType(definitions.JAVA_STRING_TYPE());
-        Type result = definitions.UNIT_TYPE;
+        Type result = definitions.UNIT_TYPE();
         if (erased) argument = argument.erasure();
         if (erased) result = result.fullErasure();
         Symbol formal = new TermSymbol(0, ARGS_N, null, Modifiers.PARAM);
diff --git a/sources/scalac/ast/TreeGen.java b/sources/scalac/ast/TreeGen.java
index 3f9e33b3cc..13176d351e 100644
--- a/sources/scalac/ast/TreeGen.java
+++ b/sources/scalac/ast/TreeGen.java
@@ -53,15 +53,15 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
         this.make = make;
 	this.infer = new Infer(global, this, make);
         this.toType = new Symbol[] {
-            mkToType(definitions.BYTE_TYPE),
-            mkToType(definitions.CHAR_TYPE),
-            mkToType(definitions.SHORT_TYPE),
-            mkToType(definitions.INT_TYPE),
-            mkToType(definitions.LONG_TYPE),
-            mkToType(definitions.FLOAT_TYPE),
-            mkToType(definitions.DOUBLE_TYPE),
-            mkToType(definitions.BOOLEAN_TYPE),
-            mkToType(definitions.UNIT_TYPE),
+            mkToType(definitions.BYTE_TYPE()),
+            mkToType(definitions.CHAR_TYPE()),
+            mkToType(definitions.SHORT_TYPE()),
+            mkToType(definitions.INT_TYPE()),
+            mkToType(definitions.LONG_TYPE()),
+            mkToType(definitions.FLOAT_TYPE()),
+            mkToType(definitions.DOUBLE_TYPE()),
+            mkToType(definitions.BOOLEAN_TYPE()),
+            mkToType(definitions.UNIT_TYPE()),
             mkToType(definitions.JAVA_STRING_TYPE()),
         };
     }
@@ -1034,7 +1034,7 @@ public class TreeGen implements Kinds, Modifiers, TypeTags {
             makeVisitorMethod(pos, Names.apply, applyVisitor,
                               pattype, restype, clazz, owner),
             makeVisitorMethod(pos, Names.isDefinedAt, isDefinedAtVisitor,
-                              pattype, definitions.BOOLEAN_TYPE, clazz, owner)};
+                              pattype, definitions.BOOLEAN_TYPE(), clazz, owner)};
         Symbol local = TermSymbol.newLocalDummy(clazz);
         Tree classDef = ClassDef(clazz, parentTrees, local, memberTrees);
 	Tree alloc = New(pos, mkPrimaryConstr(pos, clazz))
diff --git a/sources/scalac/backend/Primitives.java b/sources/scalac/backend/Primitives.java
index 4b2b4f4066..54bf41e582 100644
--- a/sources/scalac/backend/Primitives.java
+++ b/sources/scalac/backend/Primitives.java
@@ -251,22 +251,22 @@ public class Primitives {
         this.OARRAY_SET = getUniqueTerm(RUNTIME, OARRAY_SET_N);
         Symbol[] boxes = getTerm(RUNTIME, BOX_N).alternativeSymbols();
         this.BOX_UVALUE = getBoxUnit(boxes);
-        this.BOX_ZVALUE = getBoxValue(boxes, definitions.BOOLEAN_TYPE);
-        this.BOX_BVALUE = getBoxValue(boxes, definitions.BYTE_TYPE);
-        this.BOX_SVALUE = getBoxValue(boxes, definitions.SHORT_TYPE);
-        this.BOX_CVALUE = getBoxValue(boxes, definitions.CHAR_TYPE);
-        this.BOX_IVALUE = getBoxValue(boxes, definitions.INT_TYPE);
-        this.BOX_LVALUE = getBoxValue(boxes, definitions.LONG_TYPE);
-        this.BOX_FVALUE = getBoxValue(boxes, definitions.FLOAT_TYPE);
-        this.BOX_DVALUE = getBoxValue(boxes, definitions.DOUBLE_TYPE);
-        this.BOX_ZARRAY = getBoxArray(boxes, definitions.BOOLEAN_TYPE);
-        this.BOX_BARRAY = getBoxArray(boxes, definitions.BYTE_TYPE);
-        this.BOX_SARRAY = getBoxArray(boxes, definitions.SHORT_TYPE);
-        this.BOX_CARRAY = getBoxArray(boxes, definitions.CHAR_TYPE);
-        this.BOX_IARRAY = getBoxArray(boxes, definitions.INT_TYPE);
-        this.BOX_LARRAY = getBoxArray(boxes, definitions.LONG_TYPE);
-        this.BOX_FARRAY = getBoxArray(boxes, definitions.FLOAT_TYPE);
-        this.BOX_DARRAY = getBoxArray(boxes, definitions.DOUBLE_TYPE);
+        this.BOX_ZVALUE = getBoxValue(boxes, definitions.BOOLEAN_TYPE());
+        this.BOX_BVALUE = getBoxValue(boxes, definitions.BYTE_TYPE());
+        this.BOX_SVALUE = getBoxValue(boxes, definitions.SHORT_TYPE());
+        this.BOX_CVALUE = getBoxValue(boxes, definitions.CHAR_TYPE());
+        this.BOX_IVALUE = getBoxValue(boxes, definitions.INT_TYPE());
+        this.BOX_LVALUE = getBoxValue(boxes, definitions.LONG_TYPE());
+        this.BOX_FVALUE = getBoxValue(boxes, definitions.FLOAT_TYPE());
+        this.BOX_DVALUE = getBoxValue(boxes, definitions.DOUBLE_TYPE());
+        this.BOX_ZARRAY = getBoxArray(boxes, definitions.BOOLEAN_TYPE());
+        this.BOX_BARRAY = getBoxArray(boxes, definitions.BYTE_TYPE());
+        this.BOX_SARRAY = getBoxArray(boxes, definitions.SHORT_TYPE());
+        this.BOX_CARRAY = getBoxArray(boxes, definitions.CHAR_TYPE());
+        this.BOX_IARRAY = getBoxArray(boxes, definitions.INT_TYPE());
+        this.BOX_LARRAY = getBoxArray(boxes, definitions.LONG_TYPE());
+        this.BOX_FARRAY = getBoxArray(boxes, definitions.FLOAT_TYPE());
+        this.BOX_DARRAY = getBoxArray(boxes, definitions.DOUBLE_TYPE());
         this.BOX_OARRAY = getBoxArray(boxes, definitions.JAVA_OBJECT_TYPE());
         this.AS_UVALUE = getUniqueTerm(definitions.UNIT_CLASS, AS_UVALUE_N);
         this.AS_ZVALUE = getUniqueTerm(definitions.BOOLEAN_CLASS, AS_ZVALUE_N);
diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java
index 6d834d3256..cdaa989113 100644
--- a/sources/scalac/symtab/Definitions.java
+++ b/sources/scalac/symtab/Definitions.java
@@ -121,23 +121,23 @@ public class Definitions {
     /** the primitive types
      */
     public final Symbol BYTE_CLASS;
-    public final Type   BYTE_TYPE;
+    public final Type   BYTE_TYPE() {return BYTE_CLASS.type();}
     public final Symbol SHORT_CLASS;
-    public final Type   SHORT_TYPE;
+    public final Type   SHORT_TYPE() {return SHORT_CLASS.type();}
     public final Symbol CHAR_CLASS;
-    public final Type   CHAR_TYPE;
+    public final Type   CHAR_TYPE() {return CHAR_CLASS.type();}
     public final Symbol INT_CLASS;
-    public final Type   INT_TYPE;
+    public final Type   INT_TYPE() {return INT_CLASS.type();}
     public final Symbol LONG_CLASS;
-    public final Type   LONG_TYPE;
+    public final Type   LONG_TYPE() {return LONG_CLASS.type();}
     public final Symbol FLOAT_CLASS;
-    public final Type   FLOAT_TYPE;
+    public final Type   FLOAT_TYPE() {return FLOAT_CLASS.type();}
     public final Symbol DOUBLE_CLASS;
-    public final Type   DOUBLE_TYPE;
+    public final Type   DOUBLE_TYPE() {return DOUBLE_CLASS.type();}
     public final Symbol BOOLEAN_CLASS;
-    public final Type   BOOLEAN_TYPE;
+    public final Type   BOOLEAN_TYPE() {return BOOLEAN_CLASS.type();}
     public final Symbol UNIT_CLASS;
-    public final Type   UNIT_TYPE;
+    public final Type   UNIT_TYPE() {return UNIT_CLASS.type();}
 
     private Symbol BOOLEAN_OR;
     private Symbol BOOLEAN_AND;
@@ -406,23 +406,14 @@ public class Definitions {
 
         // the primitive types
         DOUBLE_CLASS = getClass(Names.scala_Double);
-        DOUBLE_TYPE = DOUBLE_CLASS.typeConstructor();
         FLOAT_CLASS = getClass(Names.scala_Float);
-        FLOAT_TYPE = FLOAT_CLASS.typeConstructor();
         LONG_CLASS = getClass(Names.scala_Long);
-        LONG_TYPE = LONG_CLASS.typeConstructor();
         INT_CLASS = getClass(Names.scala_Int);
-        INT_TYPE = INT_CLASS.typeConstructor();
         CHAR_CLASS = getClass(Names.scala_Char);
-        CHAR_TYPE = CHAR_CLASS.typeConstructor();
         SHORT_CLASS = getClass(Names.scala_Short);
-        SHORT_TYPE = SHORT_CLASS.typeConstructor();
         BYTE_CLASS = getClass(Names.scala_Byte);
-        BYTE_TYPE = BYTE_CLASS.typeConstructor();
         BOOLEAN_CLASS = getClass(Names.scala_Boolean);
-        BOOLEAN_TYPE = BOOLEAN_CLASS.typeConstructor();
         UNIT_CLASS = getClass(Names.scala_Unit);
-        UNIT_TYPE = UNIT_CLASS.typeConstructor();
 
         // the scala.ANYREF class
 	ANYREF_CLASS = new AliasTypeSymbol(
@@ -530,31 +521,31 @@ public class Definitions {
         IS = new TermSymbol(
 	    Position.NOPOS, Names.isInstanceOf, ANY_CLASS, Modifiers.FINAL);
         IS.setInfo(Type.PolyType(new Symbol[]{newTypeParameter(IS, ANY_TYPE())},
-				 BOOLEAN_TYPE));
+				 BOOLEAN_TYPE()));
         ANY_CLASS.members().enter(IS);
 
         EQEQ = new TermSymbol(
 	    Position.NOPOS, Names.EQEQ, ANY_CLASS, Modifiers.FINAL);
         EQEQ.setInfo(Type.MethodType(new Symbol[]{newParameter(EQEQ, ANY_TYPE())},
-				     BOOLEAN_TYPE));
+				     BOOLEAN_TYPE()));
         ANY_CLASS.members().enter(EQEQ);
 
         BANGEQ = new TermSymbol(
 	    Position.NOPOS, Names.BANGEQ, ANY_CLASS, Modifiers.FINAL);
         BANGEQ.setInfo(Type.MethodType(new Symbol[]{newParameter(BANGEQ, ANY_TYPE())},
-				       BOOLEAN_TYPE));
+				       BOOLEAN_TYPE()));
         ANY_CLASS.members().enter(BANGEQ);
 
         EQUALS = new TermSymbol(
 	    Position.NOPOS, Names.equals, ANY_CLASS, 0);
         EQUALS.setInfo(Type.MethodType(new Symbol[]{newParameter(EQUALS, ANY_TYPE())},
-				     BOOLEAN_TYPE));
+				     BOOLEAN_TYPE()));
         ANY_CLASS.members().enter(EQUALS);
 
 	EQ = new TermSymbol(
 	    Position.NOPOS, Names.eq, ANY_CLASS, 0);
         EQ.setInfo(Type.MethodType(new Symbol[]{newParameter(EQ, ANY_TYPE())},
-				   BOOLEAN_TYPE));
+				   BOOLEAN_TYPE()));
         ANY_CLASS.members().enter(EQ);
 
         TOSTRING = new TermSymbol(
@@ -564,7 +555,7 @@ public class Definitions {
 
         HASHCODE = new TermSymbol(
 	    Position.NOPOS, Names.hashCode, ANY_CLASS, 0);
-        HASHCODE.setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, INT_TYPE));
+        HASHCODE.setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, INT_TYPE()));
         ANY_CLASS.members().enter(HASHCODE);
 
         // add a null value to the root scope
diff --git a/sources/scalac/transformer/AddConstructors.java b/sources/scalac/transformer/AddConstructors.java
index 4fdf9f6221..bb71b167df 100644
--- a/sources/scalac/transformer/AddConstructors.java
+++ b/sources/scalac/transformer/AddConstructors.java
@@ -85,7 +85,7 @@ public class AddConstructors extends Transformer {
 
 	    Type constrType = Type.MethodType
 		(paramSyms, forJVM ?
-		 global.definitions.UNIT_TYPE : owner.type());
+		 global.definitions.UNIT_TYPE() : owner.type());
             if (tparamSyms.length != 0)
                 constrType = Type.PolyType(tparamSyms, constrType);
 
diff --git a/sources/scalac/transformer/matching/AlgebraicMatcher.java b/sources/scalac/transformer/matching/AlgebraicMatcher.java
index 191aa17fd3..20c9e2536c 100644
--- a/sources/scalac/transformer/matching/AlgebraicMatcher.java
+++ b/sources/scalac/transformer/matching/AlgebraicMatcher.java
@@ -461,7 +461,7 @@ public class AlgebraicMatcher extends PatternMatcher {
 
 	  Matcher m = new Matcher( _m.owner,
 				   selector,
-				   defs.BOOLEAN_TYPE );
+				   defs.BOOLEAN_TYPE() );
 
 	  Tree pats[] = new Tree[ seqPatNodes.size() ];
 	  Tree body[] = new Tree[ seqPatNodes.size() ];
diff --git a/sources/scalac/transformer/matching/Autom2Scala.java b/sources/scalac/transformer/matching/Autom2Scala.java
index 49b18f2943..13cb939ae3 100644
--- a/sources/scalac/transformer/matching/Autom2Scala.java
+++ b/sources/scalac/transformer/matching/Autom2Scala.java
@@ -99,17 +99,17 @@ public class Autom2Scala  {
                   .setType( cf._seqIterType( elementType ) ) ;
 
             this.stateSym = newParam("q")
-                  .setType( defs.INT_TYPE ) ;
+                  .setType( defs.INT_TYPE() ) ;
 
             this.resultSym = new TermSymbol( pos,
 					     cf.fresh.newName("swRes"),
 					     owner,
 					     0 )
-                  .setType( defs.INT_TYPE ) ;
+                  .setType( defs.INT_TYPE() ) ;
 
             this.funSym
                   .setType( new Type.MethodType( new Symbol[] {
-                        iterSym, stateSym },  defs.INT_TYPE ));
+                        iterSym, stateSym },  defs.INT_TYPE() ));
 
             this.curSym = new TermSymbol( pos,
                                           CURRENT_ELEM,
@@ -121,7 +121,7 @@ public class Autom2Scala  {
 					   HASNEXT,
 					   funSym,
 					   0)
-                  .setType( defs.BOOLEAN_TYPE );
+                  .setType( defs.BOOLEAN_TYPE() );
 
       }
 
@@ -250,7 +250,7 @@ public class Autom2Scala  {
       Tree _cur_match( Tree pat ) {
             Matcher m = new Matcher( funSym,//this.funSym,
                                      currentElem(),
-                                     defs.BOOLEAN_TYPE );
+                                     defs.BOOLEAN_TYPE() );
 
             am.construct( m, new CaseDef[] {
                 cf.gen.CaseDef( pat,
diff --git a/sources/scalac/transformer/matching/CodeFactory.java b/sources/scalac/transformer/matching/CodeFactory.java
index ee501e692f..832d75fc7b 100644
--- a/sources/scalac/transformer/matching/CodeFactory.java
+++ b/sources/scalac/transformer/matching/CodeFactory.java
@@ -48,7 +48,7 @@ class CodeFactory extends PatternTool {
 
     /** returns  `List[ Tuple2[ scala.Int, <elemType> ] ]' */
       Type SeqTraceType( Type elemType ) {
-          return defs.listType(pairType(defs.INT_TYPE, elemType));
+          return defs.listType(pairType(defs.INT_TYPE(), elemType));
       }
 
     /**  returns `Iterator[ elemType ]' */
diff --git a/sources/scalac/transformer/matching/LeftTracerInScala.java b/sources/scalac/transformer/matching/LeftTracerInScala.java
index df9e3b71ee..d85d4b2e37 100644
--- a/sources/scalac/transformer/matching/LeftTracerInScala.java
+++ b/sources/scalac/transformer/matching/LeftTracerInScala.java
@@ -265,7 +265,7 @@ public class LeftTracerInScala extends TracerInScala {
 
         Matcher m = new Matcher( funSym,
                                  currentElem(),
-                                 defs.BOOLEAN_TYPE );
+                                 defs.BOOLEAN_TYPE() );
 
         if( CollectVariableTraverser.containsBinding( pat )) {
             switch( pat ) {
diff --git a/sources/scalac/transformer/matching/PatternMatcher.java b/sources/scalac/transformer/matching/PatternMatcher.java
index 3ece11b531..4572d565ba 100644
--- a/sources/scalac/transformer/matching/PatternMatcher.java
+++ b/sources/scalac/transformer/matching/PatternMatcher.java
@@ -477,7 +477,7 @@ public class PatternMatcher extends PatternTool {
                 switch (t.type()) {
                     case OverloadedType(Symbol[] alts, Type[] alttypes):
                         infer.methodAlternative(t, alts, alttypes,
-                            new Type[]{defs.INT_TYPE}, seqType);
+                            new Type[]{defs.INT_TYPE()}, seqType);
                 }
                 t = gen.mkApply_V(t, new Tree[]{gen.mkIntLit(pat.pos, index)});
 */
@@ -582,7 +582,7 @@ public class PatternMatcher extends PatternTool {
     }
 
     protected boolean isSimpleIntSwitch() {
-    	if (selector.type.widen().isSameAs(defs.INT_TYPE)) {
+    	if (selector.type.widen().isSameAs(defs.INT_TYPE())) {
     		PatternNode patNode = root.and;
     		while (patNode != null) {
    				PatternNode node = patNode;
@@ -922,7 +922,7 @@ public class PatternMatcher extends PatternTool {
 			bodies,
 			(defaultCase == null) ? gen.mkBooleanLit(selector.pos, false)
 			                      : toTree(defaultCase.and),
-                        defs.BOOLEAN_TYPE);
+                        defs.BOOLEAN_TYPE());
     }
 
     protected Tree toTree(PatternNode node, Tree selector) {
diff --git a/sources/scalac/transformer/matching/RightTracerInScala.java b/sources/scalac/transformer/matching/RightTracerInScala.java
index a991ffba84..91d84091af 100644
--- a/sources/scalac/transformer/matching/RightTracerInScala.java
+++ b/sources/scalac/transformer/matching/RightTracerInScala.java
@@ -133,7 +133,7 @@ public class RightTracerInScala extends TracerInScala  {
 	  new Tree [] {
 	  cf.debugPrintRuntime( "ASSIGN" ),
 	  gen.Assign( hv, cf.newSeqCons( elem, hv ))
-	  }, defs.UNIT_TYPE);
+	  }, defs.UNIT_TYPE());
 	*/
     }
 
@@ -151,7 +151,7 @@ public class RightTracerInScala extends TracerInScala  {
 					cf.fresh.newName("q"),
 					funSym,
 					0 )
-	    .setType( defs.INT_TYPE ) ;
+	    .setType( defs.INT_TYPE() ) ;
 
 	this.elemSym = new TermSymbol( pos,
 				       cf.fresh.newName("elem"),
@@ -163,17 +163,17 @@ public class RightTracerInScala extends TracerInScala  {
 					 cf.fresh.newName("trgt"),
 					 funSym,
 					 0)
-	    .setType( defs.INT_TYPE ) ;
+	    .setType( defs.INT_TYPE() ) ;
 
 
 	funSym.setType( new Type.MethodType( new Symbol[] {
-	    iterSym, stateSym },  defs.UNIT_TYPE ));
+	    iterSym, stateSym },  defs.UNIT_TYPE() ));
 
     }
 
     // same as in LeftTracer
     Tree code_fail() {
-	return cf.ThrowMatchError( _m.pos, defs.UNIT_TYPE );
+	return cf.ThrowMatchError( _m.pos, defs.UNIT_TYPE() );
     }
 
     public Tree code_body() {
@@ -311,7 +311,7 @@ public class RightTracerInScala extends TracerInScala  {
 
 	Matcher m = new Matcher( funSym,//this.funSym,
 				 currentElem(),
-				 defs.BOOLEAN_TYPE );
+				 defs.BOOLEAN_TYPE() );
 
 	// there could be variables in regular expressions under Sequence node,
 	// export those later
diff --git a/sources/scalac/typechecker/Analyzer.java b/sources/scalac/typechecker/Analyzer.java
index 2954a56e3d..855c55292b 100644
--- a/sources/scalac/typechecker/Analyzer.java
+++ b/sources/scalac/typechecker/Analyzer.java
@@ -596,13 +596,13 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
     }
 
     private Type value2Type(Object value) {
-	if (value instanceof Character) return definitions.CHAR_TYPE;
-	else if (value instanceof Integer) return definitions.INT_TYPE;
-	else if (value instanceof Long) return definitions.LONG_TYPE;
-	else if (value instanceof Float) return definitions.FLOAT_TYPE;
-	else if (value instanceof Double) return definitions.DOUBLE_TYPE;
+	if (value instanceof Character) return definitions.CHAR_TYPE();
+	else if (value instanceof Integer) return definitions.INT_TYPE();
+	else if (value instanceof Long) return definitions.LONG_TYPE();
+	else if (value instanceof Float) return definitions.FLOAT_TYPE();
+	else if (value instanceof Double) return definitions.DOUBLE_TYPE();
 	else if (value instanceof String) return definitions.JAVA_STRING_TYPE();
-	else if (value instanceof Boolean) return definitions.BOOLEAN_TYPE;
+	else if (value instanceof Boolean) return definitions.BOOLEAN_TYPE();
 	else throw new ApplicationError();
     }
 
@@ -1576,7 +1576,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 	    this.inAlternative = false;       // no vars allowed below Alternative
 	    Tree pat1 = transform(pat, PATTERNmode, pattpe);
 	    Tree guard1 = (guard == Tree.Empty) ? Tree.Empty
-		: transform(guard, EXPRmode, definitions.BOOLEAN_TYPE);
+		: transform(guard, EXPRmode, definitions.BOOLEAN_TYPE());
 	    Tree body1 = transform(body, EXPRmode, pt);
 	    popContext();
 	    return (Tree.CaseDef) copy.CaseDef(tree, pat1, guard1, body1)
@@ -1851,7 +1851,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 			Tree.Template templ1 = copy.Template(templ, parents, body1);
 			templ1.setType(Type.NoType).setSymbol(Symbol.NONE);
 			return copy.PackageDef(tree, pkg, templ1)
-			    .setType(definitions.UNIT_TYPE);
+			    .setType(definitions.UNIT_TYPE());
 		    }
 		}
 		return tree.setType(Type.ErrorType);
@@ -1871,7 +1871,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		checkNoEscape(tree.pos, sym.info());
 		popContext();
 		return copy.ClassDef(tree, sym, tparams1, vparams1, tpe1, templ1)
-		    .setType(definitions.UNIT_TYPE);
+		    .setType(definitions.UNIT_TYPE());
 
 	    case ModuleDef(_, _, Tree tpe, Tree.Template templ):
 		sym.moduleClass().initialize();
@@ -1881,7 +1881,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		    error(tree.pos,
 			sym + " does not implement " + tpe1.type);
 		return copy.ModuleDef(tree, sym, tpe1, templ1)
-		    .setType(definitions.UNIT_TYPE);
+		    .setType(definitions.UNIT_TYPE());
 
 	    case DefDef(_, Name name, Tree.AbsTypeDef[] tparams, Tree.ValDef[][] vparams, Tree tpe, Tree rhs):
 		pushContext(tree, sym, new Scope(context.scope));
@@ -1907,7 +1907,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		checkNonCyclic(tree.pos, tpe1.type);
 		sym.flags &= ~LOCKED;
 		return copy.DefDef(tree, sym, tparams1, vparams1, tpe1, rhs1)
-		    .setType(definitions.UNIT_TYPE);
+		    .setType(definitions.UNIT_TYPE());
 
 	    case ValDef(_, _, Tree tpe, Tree rhs):
 		Tree tpe1 = (tpe == Tree.Empty)
@@ -1925,14 +1925,14 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		checkNonCyclic(tree.pos, tpe1.type);
 		sym.flags &= ~LOCKED;
 		return copy.ValDef(tree, sym, tpe1, rhs1)
-		    .setType(definitions.UNIT_TYPE);
+		    .setType(definitions.UNIT_TYPE());
 
 	    case AbsTypeDef(_, _, Tree rhs, Tree lobound):
 		Tree rhs1 = transform(rhs, TYPEmode);
 		Tree lobound1 = transform(lobound, TYPEmode);
 		checkNonCyclic(tree.pos, sym.type());
 		return copy.AbsTypeDef(tree, sym, rhs1, lobound1)
-		    .setType(definitions.UNIT_TYPE);
+		    .setType(definitions.UNIT_TYPE());
 
 	    case AliasTypeDef(_, _, AbsTypeDef[] tparams, Tree rhs):
 		pushContext(tree, sym.primaryConstructor(), new Scope(context.scope));
@@ -1942,7 +1942,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		popContext();
 		checkNonCyclic(tree.pos, sym.type());
 		return copy.AliasTypeDef(tree, sym, tparams1, rhs1)
-		    .setType(definitions.UNIT_TYPE);
+		    .setType(definitions.UNIT_TYPE());
 
 	    case Import(Tree expr, Name[] selectors):
 		context.imports = new ImportList(tree, context.scope, context.imports);
@@ -1969,7 +1969,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 			    transform(stats1[stats1.length - 1], curmode & ~FUNmode, pt);
 			owntype = checkNoEscape(tree.pos, stats1[stats1.length - 1].type);
 		    } else {
-			owntype = definitions.UNIT_TYPE;
+			owntype = definitions.UNIT_TYPE();
 		    }
 		}
 		popContext();
@@ -2033,7 +2033,7 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 			Type restype = pftargs[1];
 			Tree isDefinedAtVisitor = transformVisitor(
 			    desugarize.isDefinedAtVisitor(tree),
-			    pattype, definitions.BOOLEAN_TYPE);
+			    pattype, definitions.BOOLEAN_TYPE());
 			Tree applyVisitor = transformVisitor(tree, pattype, restype);
 			if (!infer.isFullyDefined(restype))
 			    restype = applyVisitor.type;
@@ -2063,18 +2063,18 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		} else if (varsym != null && (varsym.flags & MUTABLE) != 0) {
 		    Tree rhs1 = transform(rhs, EXPRmode, lhs1.type);
 		    return copy.Assign(tree, lhs1, rhs1)
-			.setType(definitions.UNIT_TYPE);
+			.setType(definitions.UNIT_TYPE());
 		} else {
 		    return error(tree.pos, "assignment to non-variable");
 		}
 
 	    case If(Tree cond, Tree thenp, Tree elsep):
-		Tree cond1 = transform(cond, EXPRmode, definitions.BOOLEAN_TYPE);
+		Tree cond1 = transform(cond, EXPRmode, definitions.BOOLEAN_TYPE());
 		Tree thenp1, elsep1;
 		if (elsep == Tree.Empty) {
-		    thenp1 = transform(thenp, EXPRmode, definitions.UNIT_TYPE);
+		    thenp1 = transform(thenp, EXPRmode, definitions.UNIT_TYPE());
 		    elsep1 = make.Block(tree.pos, Tree.EMPTY_ARRAY)
-			.setType(definitions.UNIT_TYPE);
+			.setType(definitions.UNIT_TYPE());
 		} else {
 		    thenp1 = transform(thenp, EXPRmode, pt);
 		    elsep1 = transform(elsep, EXPRmode, pt);
@@ -2493,12 +2493,12 @@ public class Analyzer extends Transformer implements Modifiers, Kinds {
 		pushContext(tree, context.owner, new Scope(context.scope));
 		Symbol lsym = new TermSymbol(tree.pos, name, context.owner, LABEL);
 		lsym.setInfo(
-		    Type.MethodType(Symbol.EMPTY_ARRAY, definitions.UNIT_TYPE));
+		    Type.MethodType(Symbol.EMPTY_ARRAY, definitions.UNIT_TYPE()));
 		context.scope.enter(lsym);
 		Tree body1 = transform(body, mode, pt);
 		popContext();
 		return copy.LabelDef(tree, lsym, params, body1)
-		    .setSymbol(lsym).setType(definitions.UNIT_TYPE);
+		    .setSymbol(lsym).setType(definitions.UNIT_TYPE());
 
 	    case TypeTerm():
 		return tree;
diff --git a/sources/scalac/typechecker/AnalyzerPhase.java b/sources/scalac/typechecker/AnalyzerPhase.java
index 3db1a0bf1c..155b8a7a06 100644
--- a/sources/scalac/typechecker/AnalyzerPhase.java
+++ b/sources/scalac/typechecker/AnalyzerPhase.java
@@ -46,7 +46,7 @@ public class AnalyzerPhase extends Phase {
             Tree importjavalang = make.Import(
                 Position.NOPOS, javalang, new Name[]{Names.IMPORT_WILDCARD})
                 .setSymbol(definitions.JAVALANG)
-                .setType(definitions.UNIT_TYPE);
+                .setType(definitions.UNIT_TYPE());
             startContext.imports = new ImportList(
                 importjavalang, startContext.scope, startContext.imports);
 
@@ -56,7 +56,7 @@ public class AnalyzerPhase extends Phase {
             Tree importscala = make.Import(
                 Position.NOPOS, scala, new Name[]{Names.IMPORT_WILDCARD})
                 .setSymbol(definitions.SCALA)
-                .setType(definitions.UNIT_TYPE);
+                .setType(definitions.UNIT_TYPE());
             startContext.imports = new ImportList(
                 importscala, new Scope(), startContext.imports);
         }
@@ -75,7 +75,7 @@ public class AnalyzerPhase extends Phase {
             Tree importscalaPredef = make.Import(
                 Position.NOPOS, scalaPredef, new Name[]{Names.IMPORT_WILDCARD})
                 .setSymbol(scalaPredefSym)
-                .setType(definitions.UNIT_TYPE);
+                .setType(definitions.UNIT_TYPE());
             startContext.imports = new ImportList(
                 importscalaPredef, new Scope(), startContext.imports);
         }
@@ -98,7 +98,7 @@ public class AnalyzerPhase extends Phase {
         Tree importConsole = make.Import(
             Position.NOPOS, console, new Name[]{Names.IMPORT_WILDCARD})
             .setSymbol(module)
-            .setType(definitions.UNIT_TYPE);
+            .setType(definitions.UNIT_TYPE());
         consoleContext.imports = new ImportList(
             importConsole, new Scope(), consoleContext.imports);
     }
diff --git a/sources/scalac/typechecker/DeSugarize.java b/sources/scalac/typechecker/DeSugarize.java
index 8640962780..c15e3b6291 100644
--- a/sources/scalac/typechecker/DeSugarize.java
+++ b/sources/scalac/typechecker/DeSugarize.java
@@ -447,7 +447,7 @@ public class DeSugarize implements Kinds, Modifiers {
 		    new ValDef[][]{{
 			(ValDef) make.ValDef(
 			    tree.pos, SYNTHETIC | PARAM, parameterName(0), tpe.duplicate(), Tree.Empty)}},
-		    gen.mkType(tree.pos, global.definitions.UNIT_TYPE),
+		    gen.mkType(tree.pos, global.definitions.UNIT_TYPE()),
 		    ((mods1 & DEFERRED) != 0) ? Tree.Empty
 		        : make.Assign(
 			    tree.pos,
diff --git a/sources/scalac/typechecker/RefCheck.java b/sources/scalac/typechecker/RefCheck.java
index b27def2224..582b6e56f0 100644
--- a/sources/scalac/typechecker/RefCheck.java
+++ b/sources/scalac/typechecker/RefCheck.java
@@ -540,7 +540,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
             Symbol m_eqarg = new TermSymbol(tree.pos, name, m_eq, 0)
                 .setType(sym.type());
             m_eq.setInfo(
-                Type.MethodType(new Symbol[] {m_eqarg}, defs.UNIT_TYPE));
+                Type.MethodType(new Symbol[] {m_eqarg}, defs.UNIT_TYPE()));
             Tree m_eqdef = gen.DefDef(m_eq,
                 gen.Assign(gen.mkRef(tree.pos, mvar), gen.Ident(tree.pos, m_eqarg)));
             sym.owner().members().enterOrOverload(m_eq);
@@ -642,7 +642,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	    new TermSymbol(clazz.pos, Names.that, equalsSym, PARAM)
 	    .setInfo(defs.ANY_TYPE());
 	equalsSym.setInfo(
-	    Type.MethodType(new Symbol[]{equalsParam}, defs.BOOLEAN_TYPE));
+	    Type.MethodType(new Symbol[]{equalsParam}, defs.BOOLEAN_TYPE()));
 	clazz.info().members().enter(equalsSym);
 	Tree[] fields = caseFields(clazz);
 	Type testtp = clazz.type();
@@ -709,7 +709,7 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
         Symbol tagSym = new TermSymbol(
             clazz.pos, Names.tag, clazz,
             clazz.isSubClass(defs.OBJECT_CLASS) ? OVERRIDE : 0)
-            .setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, defs.INT_TYPE));
+            .setInfo(Type.MethodType(Symbol.EMPTY_ARRAY, defs.INT_TYPE()));
         clazz.info().members().enter(tagSym);
         return gen.DefDef(tagSym, gen.mkIntLit(clazz.pos, clazz.tag()));
 	}
@@ -722,9 +722,9 @@ public class RefCheck extends Transformer implements Modifiers, Kinds {
 	Tree[] fields = caseFields(clazz);
 	Symbol getClassMethod = getNullaryMemberMethod(clazz.type(), Names.getClass);
 	Symbol addMethod = getUnaryMemberMethod(
-	    defs.INT_TYPE, Names.ADD, defs.INT_TYPE);
+	    defs.INT_TYPE(), Names.ADD, defs.INT_TYPE());
 	Symbol mulMethod = getUnaryMemberMethod(
-	    defs.INT_TYPE, Names.MUL, defs.INT_TYPE);
+	    defs.INT_TYPE(), Names.MUL, defs.INT_TYPE());
 	Tree body =
 	    gen.Apply(
 		gen.Select(