Merge github.com:lampepfl/dotty

Author: olhotak

.github/workflows/language-reference.yaml

@@ -45,7 +45,7 @@ jobs:
       - name: Generate reference documentation and test links
         run: |
           cd dotty
-          ./project/scripts/sbt scaladoc/generateReferenceDocumentation --no-regenerate-expected-links
+          ./project/scripts/sbt "scaladoc/generateReferenceDocumentation --no-regenerate-expected-links"
           ./project/scripts/docsLinksStability ./scaladoc/output/reference ./project/scripts/expected-links/reference-expected-links.txt
           cd ..
 

.github/workflows/scaladoc.yaml

@@ -57,7 +57,7 @@ jobs:
         run: ./project/scripts/sbt scaladoc/generateTestcasesDocumentation
 
       - name: Generate reference documentation
-        run: ./project/scripts/sbt scaladoc/generateReferenceDocumentation --no-regenerate-expected-links
+        run: ./project/scripts/sbt scaladoc/generateReferenceDocumentation
 
       - name: Generate Scala 3 documentation
         run: ./project/scripts/sbt scaladoc/generateScalaDocumentation

.gitmodules

@@ -219,3 +219,6 @@
 [submodule "community-build/community-projects/http4s"]
 	path = community-build/community-projects/http4s
 	url = https://github.com/dotty-staging/http4s.git
+[submodule "community-build/community-projects/parboiled2"]
+	path = community-build/community-projects/parboiled2
+	url = https://github.com/dotty-staging/parboiled2.git

community-build/community-projects/parboiled2

@@ -761,6 +761,14 @@ object projects:
     dependencies = List(cats, catsEffect3, fs2, disciplineMunit, scalacheckEffect)
   )
 
+  lazy val parboiled2 = SbtCommunityProject(
+    project = "parboiled2",
+    sbtTestCommand = "parboiledCoreJVM/test; parboiledJVM/test",
+    sbtPublishCommand = "publishLocal",
+    scalacOptions = SbtCommunityProject.scalacOptions.filter(_ != "-Xcheck-macros"),
+    dependencies = List(utest, scalacheck)
+  )
+
 end projects
 
 def allProjects = List(
@@ -841,7 +849,8 @@ def allProjects = List(
   projects.specs2,
   projects.coop,
   projects.spire,
-  projects.http4s
+  projects.http4s,
+  projects.parboiled2,
 )
 
 lazy val projectMap = allProjects.groupBy(_.project)

community-build/src/scala/dotty/communitybuild/projects.scala

@@ -74,6 +74,7 @@ class CommunityBuildTestC:
   @Test def onnxScala = projects.onnxScala.run()
   @Test def oslib = projects.oslib.run()
   // @Test def oslibWatch = projects.oslibWatch.run()
+  @Test def parboiled2 = projects.parboiled2.run()
   @Test def playJson = projects.playJson.run()
   @Test def pprint = projects.pprint.run()
   @Test def protoquill = projects.protoquill.run()

community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala

@@ -242,8 +242,10 @@ object MainProxies {
         val param = paramName.toString
         val paramType0 = if formal.isRepeatedParam then formal.argTypes.head.dealias else formal.dealias
         val paramType = paramType0.dealias
-
-        val paramTypeStr = formal.dealias.typeSymbol.owner.showFullName + "." + paramType.show
+        val paramTypeOwner = paramType.typeSymbol.owner
+        val paramTypeStr =
+          if paramTypeOwner == defn.EmptyPackageClass then paramType.show
+          else paramTypeOwner.showFullName + "." + paramType.show
         val hasDefault = defaultValueSymbols.contains(idx)
         val isRepeated = formal.isRepeatedParam
         val paramDoc = documentation.argDocs.getOrElse(param, "")

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

@@ -578,12 +578,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
             pre
           case _ =>
             tree1
-            
+
         val countsAsPure =
           if dropOp(tree1).symbol.isInlineVal
           then isIdempotentExpr(tree1)
           else isPureExpr(tree1)
-          
+
         if countsAsPure then Literal(value).withSpan(tree.span)
         else
           val pre = dropOp(tree1)
@@ -864,8 +864,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  that is not a member of an underlying class or trait?
    */
   def isStructuralTermSelectOrApply(tree: Tree)(using Context): Boolean = {
-    def isStructuralTermSelect(tree: Select) = {
-      def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match {
+    def isStructuralTermSelect(tree: Select) =
+      def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match
         case RefinedType(parent, rname, rinfo) =>
           rname == tree.name || hasRefinement(parent)
         case tp: TypeProxy =>
@@ -876,17 +876,21 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           hasRefinement(tp.tp1) || hasRefinement(tp.tp2)
         case _ =>
           false
+      !tree.symbol.exists
+      && tree.isTerm
+      && {
+        val qualType = tree.qualifier.tpe
+        hasRefinement(qualType) && !qualType.derivesFrom(defn.PolyFunctionClass)
       }
-      !tree.symbol.exists && tree.isTerm && hasRefinement(tree.qualifier.tpe)
-    }
-    def loop(tree: Tree): Boolean = tree match {
+    def loop(tree: Tree): Boolean = tree match
+      case TypeApply(fun, _) =>
+        loop(fun)
       case Apply(fun, _) =>
         loop(fun)
       case tree: Select =>
         isStructuralTermSelect(tree)
       case _ =>
         false
-    }
     loop(tree)
   }
 

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

@@ -363,13 +363,13 @@ object TypeErasure {
    *  which leads to more predictable bytecode and (?) faster dynamic dispatch.
    */
   def erasedLub(tp1: Type, tp2: Type)(using Context): Type = {
-    // After erasure, C | {Null, Nothing} is just C, if C is a reference type.
-    // We need to short-circuit this case here because the regular lub logic below
-    // relies on the class hierarchy, which doesn't properly capture `Null`s subtyping
-    // behaviour.
-    if (tp1.isBottomTypeAfterErasure && tp2.derivesFrom(defn.ObjectClass)) return tp2
-    if (tp2.isBottomTypeAfterErasure && tp1.derivesFrom(defn.ObjectClass)) return tp1
-    tp1 match {
+    // We need to short-circuit the following 2 case because the regular lub logic in the else relies on
+    // the class hierarchy, which doesn't properly capture `Nothing`/`Null` subtyping behaviour.
+    if tp1.isRef(defn.NothingClass) || (tp1.isRef(defn.NullClass) && tp2.derivesFrom(defn.ObjectClass)) then
+      tp2 // After erasure, Nothing | T is just T and Null | C is just C, if C is a reference type.
+    else if tp2.isRef(defn.NothingClass) || (tp2.isRef(defn.NullClass) && tp1.derivesFrom(defn.ObjectClass)) then
+      tp1 // After erasure, T | Nothing is just T and C | Null is just C, if C is a reference type.
+    else tp1 match {
       case JavaArrayType(elem1) =>
         import dotty.tools.dotc.transform.TypeUtils._
         tp2 match {

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

@@ -384,9 +384,10 @@ object Completion {
       if qual.tpe.isExactlyNothing || qual.tpe.isNullType then
         Map.empty
       else
-        val membersFromConversion =
-          implicitConversionTargets(qual)(using ctx.fresh.setExploreTyperState()).flatMap(accessibleMembers)
-        membersFromConversion.toSeq.groupByName
+        implicitConversionTargets(qual)(using ctx.fresh.setExploreTyperState())
+          .flatMap(accessibleMembers)
+          .toSeq
+          .groupByName
 
     /** Completions from extension methods */
     private def extensionCompletions(qual: Tree)(using Context): CompletionMap =
@@ -492,15 +493,17 @@ object Completion {
 
     /**
      * Given `qual` of type T, finds all the types S such that there exists an implicit conversion
-     * from T to S.
+     * from T to S. It then applies conversion method for proper type parameter resolution.
      *
      * @param qual The argument to which the implicit conversion should be applied.
-     * @return The set of types that `qual` can be converted to.
+     * @return The set of types after `qual` implicit conversion.
      */
     private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] = {
       val typer = ctx.typer
       val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
-      val targets = conversions.map(_.widen.finalResultType)
+      val convertedTrees = conversions.flatMap(typer.tryApplyingImplicitConversion(_, qual))
+      val targets = convertedTrees.map(_.tpe.finalResultType)
+
       interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")
       targets
     }

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -3888,7 +3888,7 @@ object Parsers {
           stats +++= defOrDcl(in.offset, defAnnotsMods(modifierTokens))
         else
           empty = true
-        statSepOrEnd(stats, empty, "toplevel definition")
+        statSepOrEnd(stats, noPrevStat = empty, "toplevel definition")
       do ()
       stats.toList
     }
@@ -3938,7 +3938,7 @@ object Parsers {
           stats += expr1()
         else
           empty = true
-        statSepOrEnd(stats, empty)
+        statSepOrEnd(stats, noPrevStat = empty)
       do ()
       (self, if stats.isEmpty then List(EmptyTree) else stats.toList)
     }
@@ -3977,7 +3977,7 @@ object Parsers {
           stats ++= checkLegal(defOrDcl(in.offset, Modifiers()))
         var what = "declaration"
         if inFunReturnType then what += " (possible cause: missing `=` in front of current method body)"
-        statSepOrEnd(stats, !dclFound, what)
+        statSepOrEnd(stats, noPrevStat = !dclFound, what)
       do ()
       stats.toList
     }
@@ -4016,7 +4016,7 @@ object Parsers {
           stats +++= localDef(in.offset)
         else
           empty = true
-        statSepOrEnd(stats, empty, altEnd = CASE)
+        statSepOrEnd(stats, noPrevStat = empty, altEnd = CASE)
       do ()
       stats.toList
     }

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -120,8 +120,9 @@ object SymUtils:
     def useCompanionAsSumMirror(using Context): Boolean =
       def companionExtendsSum(using Context): Boolean =
         self.linkedClass.isSubClass(defn.Mirror_SumClass)
-      self.linkedClass.exists
-        && !self.is(Scala2x)
+      !self.is(Scala2x)
+        && self.linkedClass.exists
+        && !self.linkedClass.is(Case)
         && (
           // If the sum type is compiled from source, and `self` is a "generic sum"
           // then its companion object will become a sum mirror in `posttyper`. (This method

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

@@ -9,6 +9,8 @@ import Contexts._
 import Symbols._
 import Names.Name
 
+import dotty.tools.dotc.core.Decorators.*
+
 object TypeUtils {
   /** A decorator that provides methods on types
    *  that are needed in the transformer pipeline.
@@ -84,11 +86,16 @@ object TypeUtils {
     /** The TermRef referring to the companion of the underlying class reference
      *  of this type, while keeping the same prefix.
      */
-    def companionRef(using Context): TermRef = self match {
+    def mirrorCompanionRef(using Context): TermRef = self match {
+      case OrType(tp1, tp2) =>
+        val r1 = tp1.mirrorCompanionRef
+        val r2 = tp2.mirrorCompanionRef
+        assert(r1.symbol == r2.symbol, em"mirrorCompanionRef mismatch for $self: $r1, $r2 did not have the same symbol")
+        r1
       case self @ TypeRef(prefix, _) if self.symbol.isClass =>
         prefix.select(self.symbol.companionModule).asInstanceOf[TermRef]
       case self: TypeProxy =>
-        self.underlying.companionRef
+        self.underlying.mirrorCompanionRef
     }
 
     /** Is this type a methodic type that takes implicit parameters (both old and new) at some point? */

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

@@ -2289,6 +2289,27 @@ trait Applications extends Compatibility {
     catch
       case NonFatal(_) => None
 
+  /** Tries applying conversion method reference to a provided receiver
+   *
+   *  returns converted tree in case of success.
+   *  None is returned if conversion method application fails.
+   */
+  def tryApplyingImplicitConversion(conversionMethodRef: TermRef, receiver: Tree)(using Context): Option[Tree] =
+    val conversionMethodTree = ref(conversionMethodRef, needLoad = false)
+    val newCtx = ctx.fresh.setNewScope.setReporter(new reporting.ThrowingReporter(ctx.reporter))
+
+    try
+      val appliedTree = inContext(newCtx) {
+        typed(untpd.Apply(conversionMethodTree, untpd.TypedSplice(receiver) :: Nil))
+      }
+
+      if appliedTree.tpe.exists && !appliedTree.tpe.isError then
+        Some(appliedTree)
+      else
+        None
+    catch
+      case NonFatal(x) => None
+
   def isApplicableExtensionMethod(methodRef: TermRef, receiverType: Type)(using Context): Boolean =
     methodRef.symbol.is(ExtensionMethod) && !receiverType.isBottomType &&
       tryApplyingExtensionMethod(methodRef, nullLiteral.asInstance(receiverType)).nonEmpty

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

@@ -677,7 +677,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
    *  map them to their opaque proxies.
    */
   def mapOpaquesInValueArg(arg: Tree)(using Context): Tree =
-    val argType = arg.tpe.widen
+    val argType = arg.tpe.widenDealias
     addOpaqueProxies(argType, arg.span, forThisProxy = false)
     if opaqueProxies.nonEmpty then
       val mappedType = mapOpaques.typeMap(argType)

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

@@ -249,7 +249,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   /** A path referencing the companion of class type `clsType` */
   private def companionPath(clsType: Type, span: Span)(using Context) =
-    val ref = pathFor(clsType.companionRef)
+    val ref = pathFor(clsType.mirrorCompanionRef)
     assert(ref.symbol.is(Module) && (clsType.classSymbol.is(ModuleClass) || (ref.symbol.companionClass == clsType.classSymbol)))
     ref.withSpan(span)
 
@@ -275,6 +275,36 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     monoMap(mirroredType.resultType)
 
   private def productMirror(mirroredType: Type, formal: Type, span: Span)(using Context): Tree =
+
+    /** do all parts match the class symbol? */
+    def acceptable(tp: Type, cls: Symbol): Boolean = tp match
+      case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
+      case tp: TypeProxy    => acceptable(tp.underlying, cls)
+      case OrType(tp1, tp2) => acceptable(tp1, cls) && acceptable(tp2, cls)
+      case _                => tp.classSymbol eq cls
+
+    def makeProductMirror(cls: Symbol): Tree =
+      val accessors = cls.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
+      val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
+      val nestedPairs = TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
+      val (monoType, elemsType) = mirroredType match
+        case mirroredType: HKTypeLambda =>
+          (mkMirroredMonoType(mirroredType), mirroredType.derivedLambdaType(resType = nestedPairs))
+        case _ =>
+          (mirroredType, nestedPairs)
+      val elemsLabels = TypeOps.nestedPairs(elemLabels)
+      checkRefinement(formal, tpnme.MirroredElemTypes, elemsType, span)
+      checkRefinement(formal, tpnme.MirroredElemLabels, elemsLabels, span)
+      val mirrorType =
+        mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, formal)
+          .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
+          .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
+      val mirrorRef =
+        if (cls.is(Scala2x) || cls.linkedClass.is(Case)) anonymousMirror(monoType, ExtendsProductMirror, span)
+        else companionPath(mirroredType, span)
+      mirrorRef.cast(mirrorType)
+    end makeProductMirror
+
     mirroredType match
       case AndType(tp1, tp2) =>
         productMirror(tp1, formal, span).orElse(productMirror(tp2, formal, span))
@@ -289,28 +319,10 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           else
             val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name, formal)
             modulePath.cast(mirrorType)
-        else if mirroredType.classSymbol.isGenericProduct then
+        else
           val cls = mirroredType.classSymbol
-          val accessors = cls.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
-          val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
-          val nestedPairs = TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
-          val (monoType, elemsType) = mirroredType match
-            case mirroredType: HKTypeLambda =>
-              (mkMirroredMonoType(mirroredType), mirroredType.derivedLambdaType(resType = nestedPairs))
-            case _ =>
-              (mirroredType, nestedPairs)
-          val elemsLabels = TypeOps.nestedPairs(elemLabels)
-          checkRefinement(formal, tpnme.MirroredElemTypes, elemsType, span)
-          checkRefinement(formal, tpnme.MirroredElemLabels, elemsLabels, span)
-          val mirrorType =
-            mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, formal)
-              .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
-              .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
-          val mirrorRef =
-            if (cls.is(Scala2x)) anonymousMirror(monoType, ExtendsProductMirror, span)
-            else companionPath(mirroredType, span)
-          mirrorRef.cast(mirrorType)
-        else EmptyTree
+          if acceptable(mirroredType, cls) && cls.isGenericProduct then makeProductMirror(cls)
+          else EmptyTree
   end productMirror
 
   private def sumMirror(mirroredType: Type, formal: Type, span: Span)(using Context): Tree =
@@ -319,6 +331,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
     def acceptable(tp: Type): Boolean = tp match
       case tp: TermRef => false
+      case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
       case tp: TypeProxy => acceptable(tp.underlying)
       case OrType(tp1, tp2) => acceptable(tp1) && acceptable(tp2)
       case _            => tp.classSymbol eq cls

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

@@ -530,9 +530,12 @@ object SourceCode {
       case Closure(meth, _) =>
         printTree(meth)
 
-      case _:Unapply | _:Alternatives | _:Bind =>
+      case _:TypedOrTest | _:Unapply | _:Alternatives | _:Bind =>
         printPattern(tree)
 
+      case tree: CaseDef =>
+        printCaseDef(tree)
+
       case _ =>
         throw new MatchError(tree.show(using Printer.TreeStructure))