implement NamedTupleBuilder for better inference

Author: bishabosha

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

@@ -1596,9 +1596,10 @@ object desugar {
       if ctx.mode.is(Mode.Type) then
         AppliedTypeTree(ref(defn.NamedTupleTypeRef), namesTuple :: tup :: Nil)
       else
-        TypeApply(
-          Apply(Select(ref(defn.NamedTupleModule), nme.withNames), tup),
-          namesTuple :: Nil)
+        val Builder_apply = Select(Select(ref(defn.NamedTupleModule), nme.NamedTupleBuilder), nme.apply)
+        val build = Select(ref(defn.NamedTupleModule), nme.build)
+        val builder = TypeApply(Builder_apply, namesTuple :: Nil)
+        Apply(Apply(build, builder :: Nil), tup :: Nil)
 
   /** When desugaring a list pattern arguments `elems` adapt them and the
    *  expected type `pt` to each other. This means:

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

@@ -552,6 +552,7 @@ object StdNames {
     val mirror : N              = "mirror"
     val moduleClass : N         = "moduleClass"
     val name: N                 = "name"
+    val NamedTupleBuilder: N    = "NamedTupleBuilder"
     val nameDollar: N           = "$name"
     val ne: N                   = "ne"
     val newFreeTerm: N          = "newFreeTerm"

library/src/scala/NamedTuple.scala

@@ -19,7 +19,17 @@ object NamedTuple:
 
   def unapply[N <: Tuple, V <: Tuple](x: NamedTuple[N, V]): Some[V] = Some(x)
 
+  object NamedTupleBuilder:
+    opaque type Builder[N <: Tuple] = Unit
+
+    @annotation.compileTimeOnly("NamedTupleBuilder.apply should be used as the argument to NamedTuple.build")
+    def apply[N <: Tuple]: Builder[N] = ???
+
+  extension [N <: Tuple](inline builder: NamedTupleBuilder.Builder[N])
+    inline def build[V <: Tuple](inline x: V): NamedTuple[N, V] = x
+
   extension [V <: Tuple](x: V)
+    @deprecated("Use NamedTupleBuilder.apply instead")
     inline def withNames[N <: Tuple]: NamedTuple[N, V] = x
 
   export NamedTupleDecomposition.{Names, DropNames}