revert Desugar

Author: soronpo

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

@@ -2,33 +2,20 @@ package dotty.tools
 package dotc
 package ast
 
-import core.*
-import util.Spans.*
-import Types.*
-import Contexts.*
-import Constants.*
-import Names.*
-import NameOps.*
-import Flags.*
-import Symbols.*
-import StdNames.*
-import Trees.*
-import ContextOps.*
-import Decorators.*
-import transform.SymUtils.*
-import NameKinds.{DefaultGetterName, EvidenceParamName, UniqueName, WildcardParamName}
-import typer.{Checking, Namer}
-import util.{Chars, Property, SourceFile, SourcePosition}
-import config.Feature.{enabled, migrateTo3, sourceVersion}
-import config.SourceVersion.*
-
+import core._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
+import Symbols._, StdNames._, Trees._, ContextOps._
+import Decorators._, transform.SymUtils._
+import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName, WildcardParamName}
+import typer.{Namer, Checking}
+import util.{Property, SourceFile, SourcePosition, Chars}
+import config.Feature.{sourceVersion, migrateTo3, enabled}
+import config.SourceVersion._
 import collection.mutable.ListBuffer
-import reporting.*
-
+import reporting._
 import annotation.constructorOnly
 import printing.Formatting.hl
 import config.Printers
-import dotty.tools.dotc.core.SymDenotations.NoDenotation
 
 import scala.annotation.internal.sharable
 
@@ -306,51 +293,14 @@ object desugar {
         vparam => toDefParam(vparam, keepAnnotations = true, keepDefault = false)
       }
 
-    def ignoreErrorsAndRun[R](op: => R): R =
-      val savedState = ctx.typerState.snapshot()
-      val savedReporter = ctx.reporter
-      ctx.typerState.setReporter(Reporter.NoReporter)
-      val ret = op
-      ctx.typerState.setReporter(savedReporter)
-      ctx.typerState.resetTo(savedState)
-      ret
-
-    // gets arguments should be considered precise
-    val paramPrecises: List[Boolean] =
-      // indication for the type parameters preciseness
-      val preciseMap : Map[TypeName, Boolean] = ignoreErrorsAndRun {
-        meth.leadingTypeParams.map(t =>
-          (t.name, t.mods.annotations.exists {a =>
-            try
-              val typedAnnot = ctx.typer.typedExpr(a)
-              if (typedAnnot.denot == NoDenotation) false
-              else typedAnnot.symbol.owner == defn.PreciseAnnot
-            catch case e: Throwable => false
-          })
-        ).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)}
-              (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),