Remove unnecessary parameter for typing Super

The `inConstrCall` parameter passed to `tpd.Super` and `assignType`
should be true for super-calls to parent class constructors and false
otherwise, this is used to correctly type the Super node:

    else if (inConstrCall || ctx.erasedTypes) cls.info.firstParent.typeConstructor

But calls to super-constructor are only generated by Mixin which runs
after Erasure, so we can don't `inConstrCall` to take the correct branch.

There were two places before erasure where we didn't just pass
`inConstrCall = false` and they were both wrong:
- In Typer, we had:
      case pt: SelectionProto if pt.name == nme.CONSTRUCTOR => true
  But Typer never generates super-calls to constructors (such calls are
  just regular constructor calls in the extends clause until Mixin)
- In TreeUnpickler, we had:
      ctx.mode.is(Mode.InSuperCall)
  Which doesn't really make sense (it checks whether the super-call is
  happening inside the extends clause or a secondary constructor)

Author: smarter

compiler/src/dotty/tools/backend/sjs/JUnitBootstrappers.scala

@@ -181,7 +181,7 @@ class JUnitBootstrappers extends MiniPhase {
     val sym = ctx.newDefaultConstructor(owner).entered
     DefDef(sym, {
       Block(
-        Super(This(owner), nme.EMPTY.toTypeName, inConstrCall = true).select(defn.ObjectClass.primaryConstructor).appliedToNone :: Nil,
+        Super(This(owner), tpnme.EMPTY).select(defn.ObjectClass.primaryConstructor).appliedToNone :: Nil,
         unitLiteral
       )
     })

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

@@ -35,11 +35,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def This(cls: ClassSymbol)(implicit ctx: Context): This =
     untpd.This(untpd.Ident(cls.name)).withType(cls.thisType)
 
-  def Super(qual: Tree, mix: untpd.Ident, inConstrCall: Boolean, mixinClass: Symbol)(implicit ctx: Context): Super =
-    ta.assignType(untpd.Super(qual, mix), qual, inConstrCall, mixinClass)
+  def Super(qual: Tree, mix: untpd.Ident, mixinClass: Symbol)(implicit ctx: Context): Super =
+    ta.assignType(untpd.Super(qual, mix), qual, mixinClass)
 
-  def Super(qual: Tree, mixName: TypeName, inConstrCall: Boolean, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super =
-    Super(qual, if (mixName.isEmpty) untpd.EmptyTypeIdent else untpd.Ident(mixName), inConstrCall, mixinClass)
+  def Super(qual: Tree, mixName: TypeName, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super =
+    Super(qual, if (mixName.isEmpty) untpd.EmptyTypeIdent else untpd.Ident(mixName), mixinClass)
 
   def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
     assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply[_]] || fn.isInstanceOf[Inlined])

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

@@ -1098,7 +1098,7 @@ class TreeUnpickler(reader: TastyReader,
             case SUPER =>
               val qual = readTerm()
               val (mixId, mixTpe) = ifBefore(end)(readQualId(), (untpd.EmptyTypeIdent, NoType))
-              tpd.Super(qual, mixId, ctx.mode.is(Mode.InSuperCall), mixTpe.typeSymbol)
+              tpd.Super(qual, mixId, mixTpe.typeSymbol)
             case APPLY =>
               val fn = readTerm()
               tpd.Apply(fn, until(end)(readTerm()))

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -1192,7 +1192,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         setSym()
         val qual = readTreeRef()
         val mix = readTypeNameRef()
-        Super(qual, mix, inConstrCall = false) // todo: revise
+        Super(qual, mix)
 
       case THIStree =>
         setSym()

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -477,7 +477,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Super_id(self: Super)(using ctx: Context): Option[Id] = optional(self.mix)
 
   def Super_apply(qual: Term, mix: Option[Id])(using ctx: Context): Super =
-    withDefaultPos(tpd.Super(qual, mix.getOrElse(untpd.EmptyTypeIdent), false, NoSymbol))
+    withDefaultPos(tpd.Super(qual, mix.getOrElse(untpd.EmptyTypeIdent), NoSymbol))
 
   def Super_copy(original: Tree)(qual: Term, mix: Option[Id])(using ctx: Context): Super =
     tpd.cpy.Super(original)(qual, mix.getOrElse(untpd.EmptyTypeIdent))

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

@@ -30,9 +30,9 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
 
   def superRef(target: Symbol, span: Span = cls.span): Tree = {
     val sup = if (target.isConstructor && !target.owner.is(Trait))
-      Super(This(cls), tpnme.EMPTY, true)
+      Super(This(cls), tpnme.EMPTY)
     else
-      Super(This(cls), target.owner.name.asTypeName, false, target.owner)
+      Super(This(cls), target.owner.name.asTypeName, target.owner)
     //println(i"super ref $target on $sup")
     ast.untpd.Select(sup.withSpan(span), target.name)
       .withType(NamedType(sup.tpe, target))

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

@@ -64,7 +64,7 @@ class ParamForwarding extends MiniPhase with IdentityDenotTransformer:
             info = sym.info.ensureMethodic
           ).installAfter(thisPhase)
         val superAcc =
-          Super(This(currentClass), tpnme.EMPTY, inConstrCall = false)
+          Super(This(currentClass), tpnme.EMPTY)
             .withSpan(mdef.span)
             .select(alias)
             .ensureApplied

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

@@ -369,7 +369,7 @@ trait TypeAssigner {
         else errorType("not a legal qualifying class for this", tree.sourcePos))
   }
 
-  def assignType(tree: untpd.Super, qual: Tree, inConstrCall: Boolean, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super = {
+  def assignType(tree: untpd.Super, qual: Tree, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super = {
     val mix = tree.mix
     qual.tpe match {
       case err: ErrorType => untpd.cpy.Super(tree)(qual, mix).withType(err)
@@ -386,7 +386,7 @@ trait TypeAssigner {
         val owntype =
           if (mixinClass.exists) mixinClass.appliedRef
           else if (!mix.isEmpty) findMixinSuper(cls.info)
-          else if (inConstrCall || ctx.erasedTypes) cls.info.firstParent.typeConstructor
+          else if (ctx.erasedTypes) cls.info.firstParent.typeConstructor
           else {
             val ps = cls.classInfo.parents
             if (ps.isEmpty) defn.AnyType else ps.reduceLeft((x: Type, y: Type) => x & y)

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

@@ -539,18 +539,14 @@ class Typer extends Namer
 
   def typedSuper(tree: untpd.Super, pt: Type)(implicit ctx: Context): Tree = {
     val qual1 = typed(tree.qual)
-    val inConstrCall = pt match {
-      case pt: SelectionProto if pt.name == nme.CONSTRUCTOR => true
-      case _ => false
-    }
     val enclosingInlineable = ctx.owner.ownersIterator.findSymbol(_.isInlineMethod)
     if (enclosingInlineable.exists && !PrepareInlineable.isLocal(qual1.symbol, enclosingInlineable))
       ctx.error(SuperCallsNotAllowedInlineable(enclosingInlineable), tree.sourcePos)
     pt match {
       case pt: SelectionProto if pt.name.isTypeName =>
         qual1 // don't do super references for types; they are meaningless anyway
       case _ =>
-        assignType(cpy.Super(tree)(qual1, tree.mix), qual1, inConstrCall)
+        assignType(cpy.Super(tree)(qual1, tree.mix), qual1)
     }
   }