Polishings

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -244,7 +244,7 @@ object desugar {
     if (tdef.mods is PrivateLocalParam) {
       val tparam = cpy.TypeDef(tdef)(name = tdef.name.expandedName(ctx.owner))
         .withMods(tdef.mods &~ PrivateLocal | ExpandedName)
-      val alias = cpy.TypeDef(tdef)(name = tdef.name, rhs = refOfDef(tparam))
+      val alias = cpy.TypeDef(tdef)(rhs = refOfDef(tparam))
         .withMods(tdef.mods & VarianceFlags | PrivateLocalParamAccessor | Synthetic)
       Thicket(tparam, alias)
     }

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -361,9 +361,9 @@ trait ConstraintHandling {
         if (comparedTypeLambdas.nonEmpty) {
           val approx = new ApproximatingTypeMap {
             def apply(t: Type): Type = t match {
-              case t @ TypeParamRef(pt: TypeLambda, n) if comparedTypeLambdas contains pt =>
+              case t @ TypeParamRef(tl: TypeLambda, n) if comparedTypeLambdas contains tl =>
                 val effectiveVariance = if (fromBelow) -variance else variance
-                val bounds = pt.paramInfos(n)
+                val bounds = tl.paramInfos(n)
                 if (effectiveVariance > 0) bounds.lo
                 else if (effectiveVariance < 0) bounds.hi
                 else NoType

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -516,8 +516,8 @@ object Symbols {
     // ParamInfo types and methods
     def isTypeParam(implicit ctx: Context) = denot.is(TypeParam)
     def paramName(implicit ctx: Context) = name.asInstanceOf[ThisName]
-    def paramInfo(implicit ctx: Context) = denot.info.bounds
-    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this).bounds
+    def paramInfo(implicit ctx: Context) = denot.info
+    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this)
     def paramInfoOrCompleter(implicit ctx: Context): Type = denot.infoOrCompleter
     def paramVariance(implicit ctx: Context) = denot.variance
     def paramRef(implicit ctx: Context) = denot.typeRef

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -65,12 +65,13 @@ object Types {
    *        |              +- ExprType
    *        |              +- AnnotatedType
    *        |              +- TypeVar
-   *        |              +- HKLambda --------- PolyType
+   *        |              +- HKTypeLambda
    *        |
    *        +- GroundType -+- AndType
    *                       +- OrType
-   *                       +- MethodOrPoly ----- MethodType ---+- ImplicitMethodType
-   *                       |                                   +- JavaMethodType
+   *                       +- MethodOrPoly ---+-- PolyType
+   *                                          +-- MethodType ---+- ImplicitMethodType
+   *                       |                                    +- JavaMethodType
    *                       +- ClassInfo
    *                       |
    *                       +- NoType
@@ -2355,8 +2356,8 @@ object Types {
     def isDependent(implicit ctx: Context): Boolean
     def isParamDependent(implicit ctx: Context): Boolean
 
-    final def isTermLambda = paramNames.head.isTermName
-    final def isTypeLambda = paramNames.head.isTypeName
+    final def isTermLambda = isInstanceOf[TermLambda]
+    final def isTypeLambda = isInstanceOf[TypeLambda]
     final def isHigherKinded = isInstanceOf[TypeProxy]
 
     lazy val paramRefs: List[ParamRef] = paramNames.indices.toList.map(newParamRef)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -227,13 +227,6 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
       def readLengthType(): Type = {
         val end = readEnd()
 
-        def readNamesSkipParams: (List[Name], TreeReader) = {
-          val nameReader = fork
-          nameReader.skipTree() // skip result
-          val paramReader = nameReader.fork
-          (nameReader.readParamNames(end), paramReader)
-        }
-
         def readMethodic[N <: Name, PInfo <: Type, LT <: LambdaType]
             (companion: LambdaTypeCompanion[N, PInfo, LT], nameMap: Name => N): LT = {
           val nameReader = fork

compiler/src/dotty/tools/dotc/printing/Formatting.scala

@@ -31,7 +31,7 @@ object Formatting {
       case arg: Showable =>
         try arg.show
         catch {
-          case NonFatal(ex) if false => s"[cannot display due to $ex, raw string = $toString]"
+          case NonFatal(ex) => s"[cannot display due to $ex, raw string = $toString]"
         }
       case _ => arg.toString
     }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1055,7 +1055,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       typr.println(s"adding refinement $refinement")
       checkRefinementNonCyclic(refinement, refineCls, seen)
       val rsym = refinement.symbol
-      if (rsym.info.isInstanceOf[TypeLambda] && rsym.allOverriddenSymbols.isEmpty)
+      if (rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
         ctx.error(i"polymorphic refinement $rsym without matching type in parent $tpt1 is no longer allowed", refinement.pos)    }
     assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)
   }