Concision contribution.

We have lots of core classes for which we need not go through
the symbol to get the type:

  ObjectClass.tpe -> ObjectTpe
  AnyClass.tpe    -> AnyTpe

I updated everything to use the concise/direct version,
and eliminated a bunch of noise where places were calling
typeConstructor, erasedTypeRef, and other different-seeming methods
only to always wind up with the same type they would have received
from sym.tpe. There's only one Object type, before or after erasure,
with or without type arguments.

Calls to typeConstructor were especially damaging because (see
previous commit) it had a tendency to cache a different type than
the type one would find via other means. The two types would
compare =:=, but possibly not == and definitely not eq. (I still
don't understand what == is expected to do with types.)

2 files changed, 6 insertions, 6 deletions

diff --git a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
index e6153596f7..f260ee4093 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/CPSAnnotationChecker.scala
@@ -95,7 +95,7 @@ abstract class CPSAnnotationChecker extends CPSUtils {
     override def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds] = {
       if (!cpsEnabled) return bounds
 
-      val anyAtCPS = newCpsParamsMarker(NothingClass.tpe, AnyClass.tpe)
+      val anyAtCPS = newCpsParamsMarker(NothingTpe, AnyTpe)
       if (isFunctionType(tparams.head.owner.tpe_*) || isPartialFunctionType(tparams.head.owner.tpe_*)) {
         vprintln("function bound: " + tparams.head.owner.tpe + "/"+bounds+"/"+targs)
         if (hasCpsParamTypes(targs.last))
@@ -234,7 +234,7 @@ abstract class CPSAnnotationChecker extends CPSUtils {
     }
 
     /** Returns an adapted type for a return expression if the method's result type (pt) is a CPS type.
-     *  Otherwise, it returns the `default` type (`typedReturn` passes `NothingClass.tpe`).
+     *  Otherwise, it returns the `default` type (`typedReturn` passes `NothingTpe`).
      *
      *  A return expression in a method that has a CPS result type is an error unless the return
      *  is in tail position. Therefore, we are making sure that only the types of return expressions
diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala
index 846ce01953..908ffb3713 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala
@@ -189,7 +189,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with
           val targettp = transformCPSType(tree.tpe)
 
           val pos = catches.head.pos
-          val funSym = currentOwner.newValueParameter(cpsNames.catches, pos).setInfo(appliedType(PartialFunctionClass, ThrowableClass.tpe, targettp))
+          val funSym = currentOwner.newValueParameter(cpsNames.catches, pos).setInfo(appliedType(PartialFunctionClass, ThrowableTpe, targettp))
           val funDef = localTyper.typedPos(pos) {
             ValDef(funSym, Match(EmptyTree, catches1))
           }
@@ -197,7 +197,7 @@ abstract class SelectiveCPSTransform extends PluginComponent with
             Apply(Select(expr1, expr1.tpe.member(cpsNames.flatMapCatch)), List(Ident(funSym)))
           }
 
-          val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableClass.tpe)
+          val exSym = currentOwner.newValueParameter(cpsNames.ex, pos).setInfo(ThrowableTpe)
 
           import CODE._
           // generate a case that is supported directly by the back-end
@@ -207,8 +207,8 @@ abstract class SelectiveCPSTransform extends PluginComponent with
                 IF ((REF(funSym) DOT nme.isDefinedAt)(REF(exSym))) THEN (REF(funSym) APPLY (REF(exSym))) ELSE Throw(REF(exSym))
               )
 
-          val catch2 = localTyper.typedCases(List(catchIfDefined), ThrowableClass.tpe, targettp)
-          //typedCases(tree, catches, ThrowableClass.tpe, pt)
+          val catch2 = localTyper.typedCases(List(catchIfDefined), ThrowableTpe, targettp)
+          //typedCases(tree, catches, ThrowableTpe, pt)
 
           patmatTransformer.transform(localTyper.typed(Block(List(funDef), treeCopy.Try(tree, treeCopy.Block(block1, stms, expr2), catch2, finalizer1))))