Drop TypeParamAccessor

... and all code related to it.

Author: odersky

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

@@ -5,7 +5,7 @@ package ast
 import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
-import Decorators._
+import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import language.higherKinds
 import typer.FrontEnd
@@ -70,7 +70,7 @@ object desugar {
         def apply(tp: Type) = tp match {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
             val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next()
-            var local = defctx.denotNamed(tp.name).suchThat(_ is ParamOrAccessor).symbol
+            var local = defctx.denotNamed(tp.name).suchThat(_.isParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealias
             else {
               def msg =

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

@@ -304,7 +304,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         true
       case pre: ThisType =>
         pre.cls.isStaticOwner ||
-          tp.symbol.is(ParamOrAccessor) && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
+          tp.symbol.isParamOrAccessor && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
           // was ctx.owner.enclosingClass.derivesFrom(pre.cls) which was not tight enough
           // and was spuriously triggered in case inner class would inherit from outer one
           // eg anonymous TypeMap inside TypeMap.andThen

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

@@ -249,9 +249,7 @@ object Flags {
   /** A field generated for a primary constructor parameter (no matter if it's a 'val' or not),
    *  or an accessor of such a field.
    */
-  final val ParamAccessor = commonFlag(14, "<paramaccessor>")
-  final val TermParamAccessor = ParamAccessor.toTermFlags
-  final val TypeParamAccessor = ParamAccessor.toTypeFlags  // @!!!
+  final val ParamAccessor = termFlag(14, "<paramaccessor>")
 
     /** A value or class implementing a module */
   final val Module = commonFlag(15, "module")
@@ -451,7 +449,7 @@ object Flags {
 
   /** Flags guaranteed to be set upon symbol creation */
   final val FromStartFlags =
-    Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor |
+    Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor.toCommonFlags |
     Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessorOrBaseTypeArg |
     Fresh | Erroneous | ImplicitCommon | Permanent | Synthetic |
@@ -557,8 +555,8 @@ object Flags {
   /** An inline parameter */
   final val InlineParam = allOf(Inline, Param)
 
-  /** A parameter or parameter accessor */
-  final val ParamOrAccessor = Param | ParamAccessor
+  /** A term parameter or parameter accessor */
+  final val TermParamOrAccessor = Param | ParamAccessor
 
   /** A lazy or deferred value */
   final val LazyOrDeferred = Lazy | Deferred
@@ -569,9 +567,6 @@ object Flags {
   /** A synthetic or private definition */
   final val SyntheticOrPrivate = Synthetic | Private
 
-  /** A type parameter or type parameter accessor */
-  final val TypeParamOrAccessor = TypeParam | TypeParamAccessor
-
   /** A deferred member or a parameter accessor (these don't have right hand sides) */
   final val DeferredOrParamAccessor = Deferred | ParamAccessor
 

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

@@ -1171,7 +1171,7 @@ object Types {
     /** The full parent types, including all type arguments */
     def parents(implicit ctx: Context): List[Type] = this match {
       case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isClass =>
-        tycon.parents.map(_.subst(tycon.typeSymbol.typeParams, args)) // !@@@ cache?
+        tycon.parents.map(_.subst(tycon.typeSymbol.typeParams, args)) // @!!! cache?
       case tp: TypeRef =>
         if (tp.info.isInstanceOf[TempClassInfo]) {
           tp.reloadDenot()

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

@@ -367,7 +367,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
     private def normalizeFlags(tag: Int, givenFlags: FlagSet, name: Name, isAbsType: Boolean, rhsIsEmpty: Boolean)(implicit ctx: Context): FlagSet = {
       val lacksDefinition =
         rhsIsEmpty &&
-          name.isTermName && !name.isConstructorName && !givenFlags.is(ParamOrAccessor) ||
+          name.isTermName && !name.isConstructorName && !givenFlags.is(TermParamOrAccessor) ||
         isAbsType
       var flags = givenFlags
       if (lacksDefinition && tag != PARAM) flags |= Deferred

compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala

@@ -64,7 +64,7 @@ class HoistSuperArgs extends MiniPhaseTransform with IdentityDenotTransformer {
       val constr = cdef.symbol
       lazy val origParams = // The parameters that can be accessed in the supercall
         if (constr == cls.primaryConstructor)
-          cls.info.decls.filter(d => d.is(TypeParam) || d.is(TermParamAccessor))
+          cls.info.decls.filter(d => d.is(TypeParam) || d.is(ParamAccessor))
         else
           (cdef.tparams ::: cdef.vparamss.flatten).map(_.symbol)
 
@@ -127,7 +127,7 @@ class HoistSuperArgs extends MiniPhaseTransform with IdentityDenotTransformer {
                 def apply(tp: Type) = tp match {
                   case tp: NamedType
                   if (tp.symbol.owner == cls || tp.symbol.owner == constr) &&
-                     tp.symbol.is(ParamOrAccessor) =>
+                     tp.symbol.isParamOrAccessor =>
                     val mappedSym = origToParam(tp.symbol)
                     if (tp.symbol.isType) mappedSym.typeRef else mappedSym.termRef
                   case _ =>

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -60,6 +60,10 @@ class SymUtils(val self: Symbol) extends AnyVal {
 
   def isSuperAccessor(implicit ctx: Context) = self.name.is(SuperAccessorName)
 
+  /** A type or term parameter or a term parameter accessor */
+  def isParamOrAccessor(implicit ctx: Context) =
+    self.is(Param) || self.is(ParamAccessor)
+
   /** If this is a constructor, its owner: otherwise this. */
   final def skipConstructor(implicit ctx: Context): Symbol =
     if (self.isConstructor) self.owner else self
@@ -87,8 +91,8 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def accessorNamed(name: TermName)(implicit ctx: Context): Symbol =
     self.owner.info.decl(name).suchThat(_ is Accessor).symbol
 
-  def termParamAccessors(implicit ctx: Context): List[Symbol] =
-    self.info.decls.filter(_ is TermParamAccessor).toList
+  def paramAccessors(implicit ctx: Context): List[Symbol] =
+    self.info.decls.filter(_ is ParamAccessor).toList
 
   def caseAccessors(implicit ctx:Context) =
     self.info.decls.filter(_ is CaseAccessor).toList

compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala

@@ -56,10 +56,8 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
   def syntheticMethods(clazz: ClassSymbol)(implicit ctx: Context): List[Tree] = {
     val clazzType = clazz.appliedRef
     lazy val accessors =
-      if (isDerivedValueClass(clazz))
-        clazz.termParamAccessors
-      else
-        clazz.caseAccessors
+      if (isDerivedValueClass(clazz)) clazz.paramAccessors
+      else clazz.caseAccessors
 
     val symbolsToSynthesize: List[Symbol] =
       if (clazz.is(Case)) caseSymbols

compiler/src/dotty/tools/dotc/transform/ValueClasses.scala

@@ -31,7 +31,7 @@ object ValueClasses {
   /** The member of a derived value class that unboxes it. */
   def valueClassUnbox(d: ClassDenotation)(implicit ctx: Context): Symbol =
     // (info.decl(nme.unbox)).orElse(...)      uncomment once we accept unbox methods
-    d.classInfo.decls.find(_.is(TermParamAccessor))
+    d.classInfo.decls.find(_.is(ParamAccessor))
 
   /** For a value class `d`, this returns the synthetic cast from the underlying type to
    *  ErasedValueType defined in the companion module. This method is added to the module

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

@@ -64,8 +64,8 @@ trait TypeAssigner {
 
     def close(tp: Type) = RecType.closeOver(rt => tp.substThis(cls, rt.recThis))
 
-    val refinableDecls = info.decls.filter(
-      sym => !(sym.is(TypeParamAccessor | Private) || sym.isConstructor))
+    def isRefinable(sym: Symbol) = !sym.is(Private) && !sym.isConstructor
+    val refinableDecls = info.decls.filter(isRefinable)
     val raw = (parentType /: refinableDecls)(addRefinement)
     HKTypeLambda.fromParams(cls.typeParams, raw) match {
       case tl: HKTypeLambda => tl.derivedLambdaType(resType = close(tl.resType))
@@ -208,8 +208,6 @@ trait TypeAssigner {
             else errorType(ex"$what cannot be accessed as a member of $pre$where.$whyNot", pos)
           }
         }
-        else if (d.symbol is TypeParamAccessor)
-          ensureAccessible(d.info.bounds.hi, superAccess, pos)
         else
           ctx.makePackageObjPrefixExplicit(tpe withDenot d)
       case _ =>

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

@@ -1413,7 +1413,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         .withType(dummy.nonMemberTermRef)
       checkVariance(impl1)
       if (!cls.is(AbstractOrTrait) && !ctx.isAfterTyper)
-        checkRealizableBounds(cls, cdef.namePos) // !@@@ adapt
+        checkRealizableBounds(cls, cdef.namePos)
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
       if (ctx.phase.isTyper && cdef1.tpe.derivesFrom(defn.DynamicClass) && !ctx.dynamicsEnabled) {
         val isRequired = parents1.exists(_.tpe.isRef(defn.DynamicClass))