Fix #15701: Implement js.dynamicImport for dynamic module loading.

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

@@ -340,27 +340,35 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  Its position is the union of all functions in `fns`.
    */
   def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(using Context): Block = {
-    val owner = fns.head.owner
+    AnonClass(fns.head.owner, parents, fns.map(_.span).reduceLeft(_ union _)) { cls =>
+      def forwarder(fn: TermSymbol, name: TermName) = {
+        val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
+        for overridden <- fwdMeth.allOverriddenSymbols do
+          if overridden.is(Extension) then fwdMeth.setFlag(Extension)
+          if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
+        DefDef(fwdMeth, ref(fn).appliedToArgss(_))
+      }
+      fns.lazyZip(methNames).map(forwarder)
+    }
+  }
+
+  /** An anonymous class
+   *
+   *      new parents { body }
+   *
+   * with the specified owner and position.
+   */
+  def AnonClass(owner: Symbol, parents: List[Type], coord: Coord)(body: ClassSymbol => List[Tree])(using Context): Block =
     val parents1 =
       if (parents.head.classSymbol.is(Trait)) {
         val head = parents.head.parents.head
         if (head.isRef(defn.AnyClass)) defn.AnyRefType :: parents else head :: parents
       }
       else parents
-    val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1,
-        coord = fns.map(_.span).reduceLeft(_ union _))
+    val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1, coord = coord)
     val constr = newConstructor(cls, Synthetic, Nil, Nil).entered
-    def forwarder(fn: TermSymbol, name: TermName) = {
-      val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
-      for overridden <- fwdMeth.allOverriddenSymbols do
-        if overridden.is(Extension) then fwdMeth.setFlag(Extension)
-        if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
-      DefDef(fwdMeth, ref(fn).appliedToArgss(_))
-    }
-    val forwarders = fns.lazyZip(methNames).map(forwarder)
-    val cdef = ClassDef(cls, DefDef(constr), forwarders)
+    val cdef = ClassDef(cls, DefDef(constr), body(cls))
     Block(cdef :: Nil, New(cls.typeRef, Nil))
-  }
 
   def Import(expr: Tree, selectors: List[untpd.ImportSelector])(using Context): Import =
     ta.assignType(untpd.Import(expr, selectors), newImportSymbol(ctx.owner, expr))

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -195,23 +195,26 @@ object Inlines:
       report.error("inline unapply methods with given parameters before the scrutinee are not supported", fun)
 
     val sym = unapp.symbol
-    val cls = newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), coord = sym.coord)
-    val constr = newConstructor(cls, Synthetic, Nil, Nil, coord = sym.coord).entered
-
-    val targs = fun match
-      case TypeApply(_, targs) => targs
-      case _ => Nil
-    val unapplyInfo = sym.info match
-      case info: PolyType => info.instantiate(targs.map(_.tpe))
-      case info => info
-
-    val unappplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
-    val unapply = DefDef(unappplySym, argss =>
-      inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unappplySym))
-    )
-    val cdef = ClassDef(cls, DefDef(constr), List(unapply))
-    val newUnapply = Block(cdef :: Nil, New(cls.typeRef, Nil))
-    val newFun = newUnapply.select(unappplySym).withSpan(unapp.span)
+
+    var unapplySym1: Symbol = NoSymbol // created from within AnonClass() and used afterwards
+
+    val newUnapply = AnonClass(ctx.owner, List(defn.ObjectType), sym.coord) { cls =>
+      val targs = fun match
+        case TypeApply(_, targs) => targs
+        case _ => Nil
+      val unapplyInfo = sym.info match
+        case info: PolyType => info.instantiate(targs.map(_.tpe))
+        case info => info
+
+      val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
+      val unapply = DefDef(unapplySym.asTerm, argss =>
+        inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unapplySym))
+      )
+      unapplySym1 = unapplySym
+      List(unapply)
+    }
+
+    val newFun = newUnapply.select(unapplySym1).withSpan(unapp.span)
     cpy.UnApply(unapp)(newFun, trailingImplicits, patterns)
   end inlinedUnapply
 
@@ -463,4 +466,4 @@ object Inlines:
           // the opaque type itself. An example is in pos/opaque-inline1.scala.
     end expand
   end InlineCall
-end Inlines
+end Inlines

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

@@ -124,55 +124,54 @@ class ExpandSAMs extends MiniPhase:
     val parents = List(
       defn.AbstractPartialFunctionClass.typeRef.appliedTo(anonTpe.firstParamTypes.head, anonTpe.resultType),
       defn.SerializableType)
-    val pfSym = newNormalizedClassSymbol(anonSym.owner, tpnme.ANON_CLASS, Synthetic | Final, parents, coord = tree.span)
-
-    def overrideSym(sym: Symbol) = sym.copy(
-      owner = pfSym,
-      flags = Synthetic | Method | Final | Override,
-      info = tpe.memberInfo(sym),
-      coord = tree.span).asTerm.entered
-    val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
-    val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)
-
-    def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree)(using Context) = {
-      val selector = tree.selector
-      val selectorTpe = selector.tpe.widen
-      val defaultSym = newSymbol(pfParam.owner, nme.WILDCARD, SyntheticCase, selectorTpe)
-      val defaultCase =
-        CaseDef(
-          Bind(defaultSym, Underscore(selectorTpe)),
-          EmptyTree,
-          defaultValue)
-      val unchecked = selector.annotated(New(ref(defn.UncheckedAnnot.typeRef)))
-      cpy.Match(tree)(unchecked, cases :+ defaultCase)
-        .subst(param.symbol :: Nil, pfParam :: Nil)
-          // Needed because  a partial function can be written as:
-          // param => param match { case "foo" if foo(param) => param }
-          // And we need to update all references to 'param'
-    }
 
-    def isDefinedAtRhs(paramRefss: List[List[Tree]])(using Context) = {
-      val tru = Literal(Constant(true))
-      def translateCase(cdef: CaseDef) =
-        cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
-      val paramRef = paramRefss.head.head
-      val defaultValue = Literal(Constant(false))
-      translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
-    }
+    AnonClass(anonSym.owner, parents, tree.span) { pfSym =>
+      def overrideSym(sym: Symbol) = sym.copy(
+        owner = pfSym,
+        flags = Synthetic | Method | Final | Override,
+        info = tpe.memberInfo(sym),
+        coord = tree.span).asTerm.entered
+      val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
+      val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)
+
+      def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree)(using Context) = {
+        val selector = tree.selector
+        val selectorTpe = selector.tpe.widen
+        val defaultSym = newSymbol(pfParam.owner, nme.WILDCARD, SyntheticCase, selectorTpe)
+        val defaultCase =
+          CaseDef(
+            Bind(defaultSym, Underscore(selectorTpe)),
+            EmptyTree,
+            defaultValue)
+        val unchecked = selector.annotated(New(ref(defn.UncheckedAnnot.typeRef)))
+        cpy.Match(tree)(unchecked, cases :+ defaultCase)
+          .subst(param.symbol :: Nil, pfParam :: Nil)
+            // Needed because  a partial function can be written as:
+            // param => param match { case "foo" if foo(param) => param }
+            // And we need to update all references to 'param'
+      }
 
-    def applyOrElseRhs(paramRefss: List[List[Tree]])(using Context) = {
-      val List(paramRef, defaultRef) = paramRefss(1)
-      def translateCase(cdef: CaseDef) =
-        cdef.changeOwner(anonSym, applyOrElseFn)
-      val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
-      translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
-    }
+      def isDefinedAtRhs(paramRefss: List[List[Tree]])(using Context) = {
+        val tru = Literal(Constant(true))
+        def translateCase(cdef: CaseDef) =
+          cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
+        val paramRef = paramRefss.head.head
+        val defaultValue = Literal(Constant(false))
+        translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
+      }
 
-    val constr = newConstructor(pfSym, Synthetic, Nil, Nil).entered
-    val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)(using ctx.withOwner(isDefinedAtFn))))
-    val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)(using ctx.withOwner(applyOrElseFn))))
-    val pfDef = ClassDef(pfSym, DefDef(constr), List(isDefinedAtDef, applyOrElseDef))
-    cpy.Block(tree)(pfDef :: Nil, New(pfSym.typeRef, Nil))
+      def applyOrElseRhs(paramRefss: List[List[Tree]])(using Context) = {
+        val List(paramRef, defaultRef) = paramRefss(1)
+        def translateCase(cdef: CaseDef) =
+          cdef.changeOwner(anonSym, applyOrElseFn)
+        val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
+        translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
+      }
+
+      val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)(using ctx.withOwner(isDefinedAtFn))))
+      val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)(using ctx.withOwner(applyOrElseFn))))
+      List(isDefinedAtDef, applyOrElseDef)
+    }
   }
 
   private def checkRefinements(tpe: Type, tree: Tree)(using Context): Type = tpe.dealias match {
@@ -184,4 +183,3 @@ class ExpandSAMs extends MiniPhase:
       tpe
   }
 end ExpandSAMs
-

compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala

@@ -292,25 +292,18 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
 
           assert(currentOwner.isTerm, s"unexpected owner: $currentOwner at ${tree.sourcePos}")
 
-          val cls = newNormalizedClassSymbol(currentOwner, tpnme.ANON_CLASS, Synthetic | Final,
-              List(jsdefn.DynamicImportThunkType), coord = span)
-          val constr = newConstructor(cls, Synthetic, Nil, Nil).entered
-
-          val applySym = newSymbol(cls, nme.apply, Method, MethodType(Nil, Nil, defn.AnyType), coord = span).entered
-          val newBody = transform(body).changeOwnerAfter(currentOwner, applySym, thisPhase)
-          val applyDefDef = DefDef(applySym, newBody)
-
-          // class $anon extends DynamicImportThunk
-          val cdef = ClassDef(cls, DefDef(constr), List(applyDefDef)).withSpan(span)
+          // new DynamicImportThunk { def apply(): Any = body }
+          val dynamicImportThunkAnonClass = AnonClass(currentOwner, List(jsdefn.DynamicImportThunkType), span) { cls =>
+            val applySym = newSymbol(cls, nme.apply, Method, MethodType(Nil, Nil, defn.AnyType), coord = span).entered
+            val newBody = transform(body).changeOwnerAfter(currentOwner, applySym, thisPhase)
+            val applyDefDef = DefDef(applySym, newBody)
+            List(applyDefDef)
+          }
 
-          /* runtime.DynamicImport[A]({
-           *   class $anon ...
-           *   new $anon
-           * })
-           */
+          // runtime.DynamicImport[A](new ...)
           ref(jsdefn.Runtime_dynamicImport)
             .appliedToTypeTree(tpeArg)
-            .appliedTo(Block(cdef :: Nil, New(cls.typeRef, Nil)))
+            .appliedTo(dynamicImportThunkAnonClass)
 
         // Compile-time errors and warnings for js.Dynamic.literal
         case Apply(Apply(fun, nameArgs), args)