simplified precise default argument support

Author: soronpo

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

@@ -304,33 +304,14 @@ object desugar {
         vparam => toDefParam(vparam, keepAnnotations = true, keepDefault = false)
       }
 
-    // gets arguments should be considered precise
-    val paramPrecises: List[Boolean] =
-      // indication for the type parameters preciseness
-      val preciseMap : Map[TypeName, Boolean] =
-        meth.leadingTypeParams.map(t => (t.name, t.mods.annotations.exists(isPreciseAnnot))).toMap
-      // mapping type parameters preciseness onto term parameter preciseness
-      meth.termParamss.view.flatten.map(p => p.tpt).map {
-        case Ident(n) => preciseMap.getOrElse(n.asTypeName, false)
-        case _ => false
-      }.toList
-
     def defaultGetters(paramss: List[ParamClause], n: Int): List[DefDef] = paramss match
       case ValDefs(vparam :: vparams) :: paramss1 =>
         def defaultGetter: DefDef =
-          val (rhs, tpt) =
-            // if the parameter is precise, then we add explicit return type for the
-            // definition to keep the precise type after precise typing.
-            if paramPrecises(n) then
-              val rhsTyped = withMode(Mode.Precise){ctx.typer.typedExpr(vparam.rhs)}
-              (TypedSplice(rhsTyped), TypeTree(rhsTyped.tpe))
-            // otherwise, the desugaring is unchanged from the status quo
-            else (vparam.rhs, TypeTree())
           DefDef(
             name = DefaultGetterName(meth.name, n),
             paramss = getterParamss(n),
-            tpt = tpt,
-            rhs = rhs
+            tpt = TypeTree(),
+            rhs = vparam.rhs
           )
           .withMods(Modifiers(
             meth.mods.flags & (AccessFlags | Synthetic) | (vparam.mods.flags & Inline),

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

@@ -1855,19 +1855,18 @@ class Namer { typer: Typer =>
         case _ =>
           approxTp
 
-    var rhsCtx = ctx.fresh.addMode(Mode.InferringReturnType)
-    if sym.isInlineMethod then rhsCtx = rhsCtx.addMode(Mode.InlineableBody)
-    if sym.is(ExtensionMethod) then rhsCtx = rhsCtx.addMode(Mode.InExtensionMethod)
-    val typeParams = paramss.collect { case TypeSymbols(tparams) => tparams }.flatten
-    if (typeParams.nonEmpty) {
-      // we'll be typing an expression from a polymorphic definition's body,
-      // so we must allow constraining its type parameters
-      // compare with typedDefDef, see tests/pos/gadt-inference.scala
-      rhsCtx.setFreshGADTBounds
-      rhsCtx.gadt.addToConstraint(typeParams)
-    }
-
-    def typedAheadRhs(pt: Type) =
+    def typedAheadRhs(pt: Type)(using Context) =
+      var rhsCtx = ctx.fresh.addMode(Mode.InferringReturnType)
+      if sym.isInlineMethod then rhsCtx = rhsCtx.addMode(Mode.InlineableBody)
+      if sym.is(ExtensionMethod) then rhsCtx = rhsCtx.addMode(Mode.InExtensionMethod)
+      val typeParams = paramss.collect { case TypeSymbols(tparams) => tparams }.flatten
+      if (typeParams.nonEmpty) {
+        // we'll be typing an expression from a polymorphic definition's body,
+        // so we must allow constraining its type parameters
+        // compare with typedDefDef, see tests/pos/gadt-inference.scala
+        rhsCtx.setFreshGADTBounds
+        rhsCtx.gadt.addToConstraint(typeParams)
+      }
       PrepareInlineable.dropInlineIfError(sym,
         typedAheadExpr(mdef.rhs, pt)(using rhsCtx))
 
@@ -1877,7 +1876,8 @@ class Namer { typer: Typer =>
       // parameters like in `def mkList[T](value: T = 1): List[T]`.
       val defaultTp = defaultParamType
       val pt = inherited.orElse(expectedDefaultArgType).orElse(fallbackProto).widenExpr
-      val tp = typedAheadRhs(pt).tpe
+      val preciseMode = if (defaultTp.isPrecise) Mode.Precise else Mode.None
+      val tp = withMode(preciseMode){ typedAheadRhs(pt) }.tpe
       if (defaultTp eq pt) && (tp frozen_<:< defaultTp) then
         // When possible, widen to the default getter parameter type to permit a
         // larger choice of overrides (see `default-getter.scala`).