Fix code to conform to new creator apply scheme

Author: odersky

compiler/src/dotty/tools/backend/jvm/BytecodeWriters.scala

@@ -81,7 +81,7 @@ trait BytecodeWriters {
   trait AsmpBytecodeWriter extends BytecodeWriter {
     import scala.tools.asm
 
-    private val baseDir = Directory(None.get).createDirectory() // FIXME missing directoy
+    private val baseDir = new Directory(None.get).createDirectory() // FIXME missing directoy
 
     private def emitAsmp(jclassBytes: Array[Byte], asmpFile: dotty.tools.io.File): Unit = {
       val pw = asmpFile.printWriter()

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

@@ -1013,13 +1013,15 @@ object Trees {
 
     @sharable val EmptyTree: Thicket = genericEmptyTree
     @sharable val EmptyValDef: ValDef = genericEmptyValDef
-    @sharable val ContextualEmptyTree: Thicket = EmptyTree() // an empty tree marking a contextual closure
+    @sharable val ContextualEmptyTree: Thicket = new EmptyTree() // an empty tree marking a contextual closure
 
     // ----- Auxiliary creation methods ------------------
 
     def Thicket(): Thicket = EmptyTree
-    def Thicket(x1: Tree, x2: Tree)(implicit src: SourceFile): Thicket = Thicket(x1 :: x2 :: Nil)
-    def Thicket(x1: Tree, x2: Tree, x3: Tree)(implicit src: SourceFile): Thicket = Thicket(x1 :: x2 :: x3 :: Nil)
+    def Thicket(x1: Tree, x2: Tree)(implicit src: SourceFile): Thicket = new Thicket(x1 :: x2 :: Nil)
+    def Thicket(x1: Tree, x2: Tree, x3: Tree)(implicit src: SourceFile): Thicket = new Thicket(x1 :: x2 :: x3 :: Nil)
+    def Thicket(xs: List[Tree])(implicit src: SourceFile) = new Thicket(xs)
+
     def flatTree(xs: List[Tree])(implicit src: SourceFile): Tree = flatten(xs) match {
       case x :: Nil => x
       case ys => Thicket(ys)

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

@@ -787,10 +787,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     def shallowFold[T](z: T)(op: (T, tpd.Tree) => T)(using Context): T =
-      ShallowFolder(op).apply(z, tree)
+      new ShallowFolder(op).apply(z, tree)
 
     def deepFold[T](z: T)(op: (T, tpd.Tree) => T)(using Context): T =
-      DeepFolder(op).apply(z, tree)
+      new DeepFolder(op).apply(z, tree)
 
     def find[T](pred: (tpd.Tree) => Boolean)(using Context): Option[tpd.Tree] =
       shallowFold[Option[tpd.Tree]](None)((accum, tree) => if (pred(tree)) Some(tree) else accum)

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

@@ -1610,7 +1610,7 @@ object SymDenotations {
 
     private def baseTypeCache(using Context): BaseTypeMap = {
       if !currentHasSameBaseTypesAs(myBaseTypeCachePeriod) then
-        myBaseTypeCache = BaseTypeMap()
+        myBaseTypeCache = new BaseTypeMap()
         myBaseTypeCachePeriod = ctx.period
       myBaseTypeCache
     }

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

@@ -492,6 +492,8 @@ object Symbols {
   def currentClass(using Context): ClassSymbol = ctx.owner.enclosingClass.asClass
 
   type MutableSymbolMap[T] = EqHashMap[Symbol, T]
+  def MutableSymbolMap[T](): EqHashMap[Symbol, T] = EqHashMap[Symbol, T]()
+  def MutableSymbolMap[T](initialCapacity: Int): EqHashMap[Symbol, T] = EqHashMap[Symbol, T](initialCapacity)
 
 // ---- Factory methods for symbol creation ----------------------
 //

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

@@ -55,7 +55,7 @@ class Namer { typer: Typer =>
   val ExpandedTree    : Property.Key[untpd.Tree]          = new Property.Key
   val ExportForwarders: Property.Key[List[tpd.MemberDef]] = new Property.Key
   val SymOfTree       : Property.Key[Symbol]              = new Property.Key
-  val Deriver         : Property.Key[typer.Deriver]       = new Property.Key
+  val AttachedDeriver : Property.Key[typer.Deriver]       = new Property.Key
 
   /** A partial map from unexpanded member and pattern defs and to their expansions.
    *  Populated during enterSyms, emptied during typer.
@@ -1205,7 +1205,7 @@ class Namer { typer: Typer =>
         }
         val deriver = new Deriver(derivingClass, derivePos)(using localCtx)
         deriver.enterDerived(impl.derived)
-        original.putAttachment(Deriver, deriver)
+        original.putAttachment(AttachedDeriver, deriver)
       }
 
       denot.info = tempInfo.finalized(parentTypes)

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

@@ -2176,8 +2176,8 @@ class Typer extends Namer
       if (ctx.mode.is(Mode.Interactive) && ctx.settings.YretainTrees.value)
         cls.rootTreeOrProvider = cdef1
 
-      for (deriver <- cdef.removeAttachment(Deriver))
-        cdef1.putAttachment(Deriver, deriver)
+      for (deriver <- cdef.removeAttachment(AttachedDeriver))
+        cdef1.putAttachment(AttachedDeriver, deriver)
 
       cdef1
     }
@@ -2687,7 +2687,7 @@ class Typer extends Namer
         val enumContext = enumContexts(stat.symbol.linkedClass)
         if enumContext != null then
           checkEnumCaseRefsLegal(stat, enumContext)
-        stat.removeAttachment(Deriver) match {
+        stat.removeAttachment(AttachedDeriver) match {
           case Some(deriver) => deriver.finalize(stat)
           case None => stat
         }

scala3doc/src/dotty/dokka/site/templates.scala

@@ -70,7 +70,7 @@ case class TemplateFile(
       case other => other
 
     // Library requires mutable maps..
-    val mutableProperties = JHashMap(ctx.properties.transform((_, v) => asJavaElement(v)).asJava)
+    val mutableProperties = new JHashMap(ctx.properties.transform((_, v) => asJavaElement(v)).asJava)
     val rendered = Template.parse(this.rawCode).render(mutableProperties)
     // We want to render markdown only if next template is html
     val code = if (isHtml || layoutTemplate.exists(!_.isHtml)) rendered else

scala3doc/src/dotty/dokka/tasty/SymOps.scala

@@ -131,7 +131,7 @@ class SymOps[Q <: Quotes](val q: Q):
         // We want package object to point to package
         val className = sym.className.filter(_ != "package$")
 
-        DRI(
+        new DRI(
           className.fold(sym.packageName)(cn => s"${sym.packageName}.${cn}"),
           sym.anchor.getOrElse(""), // TODO do we need any of this fields?
           null,

scala3doc/src/dotty/renderers/html.scala

@@ -46,7 +46,7 @@ object HTML:
       .replace("'", "'")
 
   case class Attr(name: String):
-    def :=(value: String): AppliedAttr = AppliedAttr(s"""$name="$value"""")
+    def :=(value: String): AppliedAttr = new AppliedAttr(s"""$name="$value"""")
 
   opaque type AppliedTag = StringBuilder
 
@@ -97,5 +97,5 @@ object HTML:
   val testId = Attr("data-test-id")
   val alt = Attr("alt")
 
-  def raw(content: String): AppliedTag = AppliedTag(content)
+  def raw(content: String): AppliedTag = new AppliedTag(content)
   def raw(content: StringBuilder): AppliedTag = content

tests/new/test.scala

@@ -1,9 +1,9 @@
 
-trait SemiGroup[T] {
-  extension (x: T) def combine(y: T): T
-}
-trait Monoid[T] extends SemiGroup[T] {
-  def unit: T
-}
-def sum[T: Monoid](xs: List[T]): T =
-  xs.foldLeft(implicitly[Monoid[T]].unit)((x, y) => x.combine(y))
+object Test:
+  case class Record(elems: (String, Any)*)
+
+  object Record:
+
+    inline def apply[R <: Record](elems: (String, Any)*) : R = Record(elems: _*)
+
+    def fromUntypedTuple(elems: (String, Any)*): Record = new Record(elems: _*)

tests/run-macros/refined-selectable-macro/Macro_2.scala

@@ -20,6 +20,6 @@ object Macro2 {
       '{ new Record($elems:_*).asInstanceOf[R] }
     }
 
-    def fromUntypedTuple(elems: (String, Any)*): Record = Record(elems: _*)
+    def fromUntypedTuple(elems: (String, Any)*): Record = new Record(elems: _*) // TODO: figure out why `new` is needed
   }
 }