Cleanups and drop redundant code

Author: odersky

compiler/src/dotty/tools/dotc/inlines/Inliner.scala

@@ -58,12 +58,12 @@ object Inliner:
       case Ident(_) =>
         isPureRef(tree) || tree.symbol.isAllOf(InlineParam)
       case Select(qual, _) =>
-        if (tree.symbol.is(Erased)) true
+        if tree.symbol.isErased then true
         else isPureRef(tree) && apply(qual)
       case New(_) | Closure(_, _, _) =>
         true
       case TypeApply(fn, _) =>
-        if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_of) true else apply(fn)
+        if fn.symbol.isErased || fn.symbol == defn.QuotedTypeModule_of then true else apply(fn)
       case Apply(fn, args) =>
         val isCaseClassApply = {
           val cls = tree.tpe.classSymbol

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -214,9 +214,8 @@ object Parsers {
     def isIdent(name: Name) = in.isIdent(name)
     def isPureArrow(name: Name): Boolean = isIdent(name) && Feature.pureFunsEnabled
     def isPureArrow: Boolean = isPureArrow(nme.PUREARROW) || isPureArrow(nme.PURECTXARROW)
-    def isErased = isIdent(nme.erased) && in.erasedEnabled
-    // Are we seeing an `erased` soft keyword that will not be an identifier?
-    def isErasedKw = isErased && in.isSoftModifierInParamModifierPosition
+    def isErased =
+      isIdent(nme.erased) && in.erasedEnabled && in.isSoftModifierInParamModifierPosition
     def isSimpleLiteral =
       simpleLiteralTokens.contains(in.token)
       || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token)
@@ -1725,8 +1724,8 @@ object Parsers {
         else
           val paramStart = in.offset
           def addErased() =
-            erasedArgs.addOne(isErasedKw)
-            if isErasedKw then in.skipToken()
+            erasedArgs.addOne(isErased)
+            if isErased then in.skipToken()
           addErased()
           val args =
             in.currentRegion.withCommasExpected:
@@ -2622,7 +2621,7 @@ object Parsers {
      */
     def binding(mods: Modifiers): Tree =
       atSpan(in.offset) {
-        val mods1 = if isErasedKw then addModifier(mods) else mods
+        val mods1 = if isErased then addModifier(mods) else mods
         makeParameter(bindingName(), typedOpt(), mods1)
       }
 
@@ -2825,7 +2824,7 @@ object Parsers {
       else in.currentRegion.withCommasExpected {
         var isFormalParams = false
         def exprOrBinding() =
-          if isErasedKw then isFormalParams = true
+          if isErased then isFormalParams = true
           if isFormalParams then binding(Modifiers())
           else
             val t = maybeNamed(exprInParens)()
@@ -3570,7 +3569,7 @@ object Parsers {
       def param(): ValDef = {
         val start = in.offset
         var mods = impliedMods.withAnnotations(annotations())
-        if isErasedKw then
+        if isErased then
           mods = addModifier(mods)
         if paramOwner.isClass then
           mods = addFlag(modifiers(start = mods), ParamAccessor)

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -1236,8 +1236,6 @@ object Scanners {
     def isSoftModifierInParamModifierPosition: Boolean =
       isSoftModifier && !lookahead.isColon
 
-    def isErased: Boolean = isIdent(nme.erased) && erasedEnabled
-
     def canStartStatTokens =
       if migrateTo3 then canStartStatTokens2 else canStartStatTokens3
 

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

@@ -105,12 +105,6 @@ class Erasure extends Phase with DenotTransformer {
         if oldSymbol.isRetainedInlineMethod then
           newFlags = newFlags &~ Flags.Inline
           newAnnotations = newAnnotations.filterConserve(!_.isInstanceOf[BodyAnnotation])
-        oldSymbol match
-          case cls: ClassSymbol if cls.is(Flags.Erased) =>
-            newFlags = newFlags | Flags.Trait | Flags.JavaInterface
-            newAnnotations = Nil
-            newInfo = erasedClassInfo(cls)
-          case _ =>
         // TODO: define derivedSymDenotation?
         if ref.is(Flags.PackageClass)
            || !ref.isClass  // non-package classes are always copied since their base types change
@@ -550,8 +544,11 @@ object Erasure {
       case _ => tree.symbol.isEffectivelyErased
     }
 
-    /** Check that Java statics and packages can only be used in selections.
-      */
+    /** Check that
+     *    - erased values are not referred to from normal code
+     *    - inline method applications were inlined
+     *    - Java statics and packages can only be used in selections.
+     */
     private def checkNotErased(tree: Tree)(using Context): tree.type =
       if !ctx.mode.is(Mode.Type) then
         if isErased(tree) then
@@ -582,6 +579,9 @@ object Erasure {
       tree
     end checkNotErased
 
+    /** Check that initializers of erased vals and arguments to erased parameters
+     *  are pure expressions.
+     */
     def checkPureErased(tree: untpd.Tree, isArgument: Boolean, isImplicit: Boolean = false)(using Context): Unit =
       val tree1 = tree.asInstanceOf[tpd.Tree]
       inContext(preErasureCtx):
@@ -1049,22 +1049,20 @@ object Erasure {
       EmptyTree
 
     override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree =
-      if cls.is(Flags.Erased) then erasedDef(cls)
-      else
-        val typedTree@TypeDef(name, impl @ Template(constr, _, self, _)) = super.typedClassDef(cdef, cls): @unchecked
-        // In the case where a trait extends a class, we need to strip any non trait class from the signature
-        // and accept the first one (see tests/run/mixins.scala)
-        val newTraits = impl.parents.tail.filterConserve: tree =>
-          def isTraitConstructor = tree match
-            case Trees.Block(_, expr) => // Specific management for trait constructors (see tests/pos/i9213.scala)
-              expr.symbol.isConstructor && expr.symbol.owner.is(Flags.Trait)
-            case _ => tree.symbol.isConstructor && tree.symbol.owner.is(Flags.Trait)
-          tree.symbol.is(Flags.Trait) || isTraitConstructor
-
-        val newParents =
-          if impl.parents.tail eq newTraits then impl.parents
-          else impl.parents.head :: newTraits
-        cpy.TypeDef(typedTree)(rhs = cpy.Template(impl)(parents = newParents))
+      val typedTree@TypeDef(name, impl @ Template(constr, _, self, _)) = super.typedClassDef(cdef, cls): @unchecked
+      // In the case where a trait extends a class, we need to strip any non trait class from the signature
+      // and accept the first one (see tests/run/mixins.scala)
+      val newTraits = impl.parents.tail.filterConserve: tree =>
+        def isTraitConstructor = tree match
+          case Trees.Block(_, expr) => // Specific management for trait constructors (see tests/pos/i9213.scala)
+            expr.symbol.isConstructor && expr.symbol.owner.is(Flags.Trait)
+          case _ => tree.symbol.isConstructor && tree.symbol.owner.is(Flags.Trait)
+        tree.symbol.is(Flags.Trait) || isTraitConstructor
+
+      val newParents =
+        if impl.parents.tail eq newTraits then impl.parents
+        else impl.parents.head :: newTraits
+      cpy.TypeDef(typedTree)(rhs = cpy.Template(impl)(parents = newParents))
 
     override def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree =
       typed(tree.arg, pt)

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

@@ -264,7 +264,6 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       for
         getter <- mixin.info.decls.toList
         if getter.isGetter
-           && !getter.isEffectivelyErased
            && !wasOneOf(getter, Deferred)
            && !getter.isConstExprFinalVal
       yield

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

@@ -475,15 +475,13 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
         case tree: ValDef =>
           annotateExperimentalCompanion(tree.symbol)
           registerIfHasMacroAnnotations(tree)
-          //checkErasedDef(tree)
           Checking.checkPolyFunctionType(tree.tpt)
           val tree1 = cpy.ValDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt))
           if tree1.removeAttachment(desugar.UntupledParam).isDefined then
             checkStableSelection(tree.rhs)
           processValOrDefDef(super.transform(tree1))
         case tree: DefDef =>
           registerIfHasMacroAnnotations(tree)
-          //checkErasedDef(tree)
           Checking.checkPolyFunctionType(tree.tpt)
           annotateContextResults(tree)
           val tree1 = cpy.DefDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt))
@@ -624,21 +622,6 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       if sym.derivesFrom(defn.MacroAnnotationClass) && !sym.isStatic then
         report.error("classes that extend MacroAnnotation must not be inner/local classes", sym.srcPos)
 
-    private def checkErasedDef(tree: ValOrDefDef)(using Context): Unit =
-      def checkOnlyErasedParams(): Unit = tree match
-        case tree: DefDef =>
-          for params <- tree.paramss; param <- params if !param.symbol.isType && !param.symbol.is(Erased) do
-            report.error("erased definition can only have erased parameters", param.srcPos)
-        case _ =>
-
-      if tree.symbol.is(Erased, butNot = Macro) then
-        checkOnlyErasedParams()
-        val tpe = tree.rhs.tpe
-        if tpe.derivesFrom(defn.NothingClass) then
-          report.error("`erased` definition cannot be implemented with en expression of type Nothing", tree.srcPos)
-        else if tpe.derivesFrom(defn.NullClass) then
-          report.error("`erased` definition cannot be implemented with en expression of type Null", tree.srcPos)
-
     private def annotateExperimentalCompanion(sym: Symbol)(using Context): Unit =
       if sym.is(Module) then
         ExperimentalAnnotation.copy(sym.companionClass).foreach(sym.addAnnotation)

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

@@ -269,7 +269,7 @@ abstract class Recheck extends Phase, SymTransformer:
     def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Type =
       inContext(linkConstructorParams(sym).withOwner(sym)):
         val resType = recheck(tree.tpt)
-        if tree.rhs.isEmpty || sym.isInlineMethod || sym.isEffectivelyErased
+        if tree.rhs.isEmpty || sym.isInlineMethod
         then resType
         else recheck(tree.rhs, resType)
 

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

@@ -155,8 +155,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
 
     val needAccessor =
       name.isTermName                // Types don't need super accessors
-      && !sym.isEffectivelyErased    // Erased and concrete inline methods are not called at runtime
-      && !sym.isInlineMethod         //   so they don't need superaccessors.
+      && !sym.isInlineMethod         // Inline methods are not called at runtime so they don't need superaccessors.
       && (clazz != currentClass || !validCurrentClass || mix.name.isEmpty && clazz.is(Trait))
 
     if (needAccessor) atPhase(thisPhase.next)(superAccessorCall(sel, mix.name))

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

@@ -191,14 +191,14 @@ object LiftCoverage extends LiftImpure {
 
   /** Variant of `noLift` for the arguments of applications.
    *  To produce the right coverage information (especially in case of exceptions), we must lift:
-   *  - all the applications, except the erased ones
+   *  - all the applications
    *  - all the impure arguments
    *
    * There's no need to lift the other arguments.
    */
   private def noLiftArg(arg: tpd.Tree)(using Context): Boolean =
     arg match
-      case a: tpd.Apply => a.symbol.is(Erased) // don't lift erased applications, but lift all others
+      case a: tpd.Apply => true
       case tpd.Block(stats, expr) => stats.forall(noLiftArg) && noLiftArg(expr)
       case tpd.Inlined(_, bindings, expr) => noLiftArg(expr)
       case tpd.Typed(expr, _) => noLiftArg(expr)