Merge branch 'lampepfl:main' into main

Author: gorilskij

.github/workflows/language-reference.yaml

@@ -21,7 +21,6 @@ jobs:
         uses: actions/checkout@v3
         with:
           path: 'dotty'
-          ref: 'language-reference-stable'
           fetch-depth: 0
           ssh-key: ${{ secrets.DOCS_KEY }}
 
@@ -45,7 +44,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

@@ -1127,7 +1127,16 @@ class ClassfileParser(
       val outerName = entry.strippedOuter
       val innerName = entry.originalName
       val owner = classNameToSymbol(outerName)
-      val result = atPhase(typerPhase)(getMember(owner, innerName.toTypeName))
+      val result = owner.denot.infoOrCompleter match
+        case _: StubInfo if hasAnnotation(entry.jflags) =>
+          requiredClass(innerName.toTypeName)
+            // It's okay for the classfiles of Java annotations to be missing
+            // from the classpath. If an annotation is defined as an inner class
+            // we need to avoid forcing the outer class symbol here, and instead
+            // return a new stub symbol for the inner class. This is tested by
+            // `surviveMissingInnerClassAnnot` in AnnotationsTests.scala
+        case _ =>
+          atPhase(typerPhase)(getMember(owner, innerName.toTypeName))
       assert(result ne NoSymbol,
         i"""failure to resolve inner class:
            |externalName = ${entry.externalName},

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -113,6 +113,7 @@ class TreeUnpickler(reader: TastyReader,
   class Completer(reader: TastyReader)(using @constructorOnly _ctx: Context) extends LazyType {
     import reader._
     val owner = ctx.owner
+    val mode = ctx.mode
     val source = ctx.source
     def complete(denot: SymDenotation)(using Context): Unit =
       def fail(ex: Throwable) =
@@ -129,7 +130,7 @@ class TreeUnpickler(reader: TastyReader,
         try
           atPhaseBeforeTransforms {
             new TreeReader(reader).readIndexedDef()(
-              using ctx.withOwner(owner).withSource(source))
+              using ctx.withOwner(owner).withModeBits(mode).withSource(source))
           }
         catch
           case ex: AssertionError => fail(ex)
@@ -1193,6 +1194,10 @@ class TreeUnpickler(reader: TastyReader,
                 res.withAttachment(SuppressedApplyToNone, ())
               else res
 
+      def simplifyLub(tree: Tree): Tree =
+        tree.overwriteType(tree.tpe.simplified)
+        tree
+
       def readLengthTerm(): Tree = {
         val end = readEnd()
         val result =
@@ -1242,23 +1247,25 @@ class TreeUnpickler(reader: TastyReader,
               val tpt = ifBefore(end)(readTpt(), EmptyTree)
               Closure(Nil, meth, tpt)
             case MATCH =>
-              if (nextByte == IMPLICIT) {
-                readByte()
-                InlineMatch(EmptyTree, readCases(end))
-              }
-              else if (nextByte == INLINE) {
-                readByte()
-                InlineMatch(readTerm(), readCases(end))
-              }
-              else Match(readTerm(), readCases(end))
+              simplifyLub(
+                if (nextByte == IMPLICIT) {
+                  readByte()
+                  InlineMatch(EmptyTree, readCases(end))
+                }
+                else if (nextByte == INLINE) {
+                  readByte()
+                  InlineMatch(readTerm(), readCases(end))
+                }
+                else Match(readTerm(), readCases(end)))
             case RETURN =>
               val from = readSymRef()
               val expr = ifBefore(end)(readTerm(), EmptyTree)
               Return(expr, Ident(from.termRef))
             case WHILE =>
               WhileDo(readTerm(), readTerm())
             case TRY =>
-              Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree))
+              simplifyLub(
+                Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree)))
             case SELECTouter =>
               val levels = readNat()
               readTerm().outerSelect(levels, SkolemType(readType()))

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.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

@@ -79,7 +79,7 @@ object Interactive {
   def enclosingTree(trees: List[SourceTree], pos: SourcePosition)(using Context): Tree =
     enclosingTree(pathTo(trees, pos))
 
-  /** The closes enclosing tree with a symbol, or the `EmptyTree`.
+  /** The closest enclosing tree with a symbol, or the `EmptyTree`.
    */
   def enclosingTree(path: List[Tree])(using Context): Tree =
     path.dropWhile(!_.symbol.exists).headOption.getOrElse(tpd.EmptyTree)

compiler/src/dotty/tools/dotc/interactive/Interactive.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

@@ -176,7 +176,8 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID]:
     MatchableWarningID,
     CannotExtendFunctionID,
     LossyWideningConstantConversionID,
-    ImplicitSearchTooLargeID
+    ImplicitSearchTooLargeID,
+    TargetNameOnTopLevelClassID
 
   def errorNumber = ordinal - 2
 

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -2540,3 +2540,24 @@ import transform.SymUtils._
           |
           |${openSearchPairs.reverse.map(showQuery)}%\n%
         """
+
+  class TargetNameOnTopLevelClass(symbol: Symbol)(using Context)
+  extends SyntaxMsg(TargetNameOnTopLevelClassID):
+    def msg = em"${hl("@targetName")} annotation not allowed on top-level $symbol"
+    def explain =
+      val annot = symbol.getAnnotation(defn.TargetNameAnnot).get
+      em"""The @targetName annotation may be applied to a top-level ${hl("val")} or ${hl("def")}, but not
+          |a top-level ${hl("class")}, ${hl("trait")}, or ${hl("object")}.
+          |
+          |This restriction is due to the naming convention of Java classfiles, whose filenames
+          |are based on the name of the class defined within. If @targetName were permitted
+          |here, the name of the classfile would be based on the target name, and the compiler
+          |could not associate that classfile with the Scala-visible defined name of the class.
+          |
+          |If your use case requires @targetName, consider wrapping $symbol in an ${hl("object")}
+          |(and possibly exporting it), as in the following example:
+          |
+          |${hl("object Wrapper:")}
+          |  $annot $symbol { ... }
+          |
+          |${hl("export")} Wrapper.${symbol.name}  ${hl("// optional")}"""

compiler/src/dotty/tools/dotc/reporting/messages.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? */