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
     }