Merge branch 'main' into capset-syntax3

Author: bracevac

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -949,7 +949,12 @@ class CheckCaptures extends Recheck, SymTransformer:
         // TODO follow up on this
       try
         matchParams(mdef.paramss, pt)
-        recheckDef(mdef, mdef.symbol)
+        capt.println(i"recheck closure block $mdef: ${mdef.symbol.infoOrCompleter}")
+        if !mdef.symbol.isCompleted then
+          mdef.symbol.ensureCompleted() // this will recheck def
+        else
+          recheckDef(mdef, mdef.symbol)
+
         recheckClosure(expr, pt, forceDependent = true)
       finally
         openClosures = openClosures.tail
@@ -1112,6 +1117,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       finally
         curEnv = saved
 
+    override def recheckTypeDef(tree: TypeDef, sym: Symbol)(using Context): Type =
+      try super.recheckTypeDef(tree, sym)
+      finally completed += sym
+
     /** Recheck classDef by enforcing the following class-specific capture set relations:
      *   1. The capture set of a class includes the capture sets of its parents.
      *   2. The capture set of the self type of a class includes the capture set of the class.
@@ -1156,6 +1165,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         ccState.inNestedLevelUnless(cls.is(Module)):
           super.recheckClassDef(tree, impl, cls)
       finally
+        completed += cls
         curEnv = saved
 
     /** If type is of the form `T @requiresCapability(x)`,

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

@@ -224,7 +224,8 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case ExtensionHasDefaultID // errorNumber: 208
   case FormatInterpolationErrorID // errorNumber: 209
   case ValueClassCannotExtendAliasOfAnyValID // errorNumber: 210
-  case ExpectedCaptureBoundOrEqualsID // errorNumber: 211
+  case MatchIsNotPartialFunctionID // errorNumber: 211
+  case ExpectedCaptureBoundOrEqualsID // errorNumber: 212
 
   def errorNumber = ordinal - 1
 

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

@@ -3472,5 +3472,35 @@ end IllegalUnrollPlacement
 
 class BadFormatInterpolation(errorText: String)(using Context) extends Message(FormatInterpolationErrorID):
   def kind = MessageKind.Interpolation
-  def msg(using Context) = errorText
-  def explain(using Context) = ""
+  protected def msg(using Context) = errorText
+  protected def explain(using Context) = ""
+
+class MatchIsNotPartialFunction(using Context) extends SyntaxMsg(MatchIsNotPartialFunctionID):
+  protected def msg(using Context) =
+    "match expression in result of block will not be used to synthesize partial function"
+  protected def explain(using Context) =
+    i"""A `PartialFunction` can be synthesized from a function literal if its body is just a pattern match.
+       |
+       |For example, `collect` takes a `PartialFunction`.
+       |  (1 to 10).collect(i => i match { case n if n % 2 == 0 => n })
+       |is equivalent to using a "pattern-matching anonymous function" directly:
+       |  (1 to 10).collect { case n if n % 2 == 0 => n }
+       |Compare an operation that requires a `Function1` instead:
+       |  (1 to 10).map { case n if n % 2 == 0 => n case n => n + 1 }
+       |
+       |As a convenience, the "selector expression" of the match can be an arbitrary expression:
+       |  List("1", "two", "3").collect(x => Try(x.toInt) match { case Success(i) => i })
+       |In this example, `isDefinedAt` evaluates the selector expression and any guard expressions
+       |in the pattern match in order to report whether an input is in the domain of the function.
+       |
+       |However, blocks of statements are not supported by this idiom:
+       |  List("1", "two", "3").collect: x =>
+       |    val maybe = Try(x.toInt) // statements preceding the match
+       |    maybe match
+       |    case Success(i) if i % 2 == 0 => i // throws MatchError on cases not covered
+       |
+       |This restriction is enforced to simplify the evaluation semantics of the partial function.
+       |Otherwise, it might not be clear what is computed by `isDefinedAt`.
+       |
+       |Efficient operations will use `applyOrElse` to avoid computing the match twice,
+       |but the `apply` body would be executed "per element" in the example."""

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

@@ -126,10 +126,16 @@ class ExpandSAMs extends MiniPhase:
     // The right hand side from which to construct the partial function. This is always a Match.
     // If the original rhs is already a Match (possibly in braces), return that.
     // Otherwise construct a match `x match case _ => rhs` where `x` is the parameter of the closure.
-    def partialFunRHS(tree: Tree): Match = tree match
+    def partialFunRHS(tree: Tree): Match =
+      inline def checkMatch(): Unit =
+        tree match
+        case Block(_, m: Match) => report.warning(reporting.MatchIsNotPartialFunction(), m.srcPos)
+        case _ =>
+      tree match
       case m: Match => m
       case Block(Nil, expr) => partialFunRHS(expr)
       case _ =>
+        checkMatch()
         Match(ref(param.symbol),
           CaseDef(untpd.Ident(nme.WILDCARD).withType(param.symbol.info), EmptyTree, tree) :: Nil)
 

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

@@ -247,8 +247,10 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
             if sym.is(Param) then
               registerIfUnrolledParam(sym)
               // @unused is getter/setter but we want it on ordinary method params
-              if !sym.owner.is(Method) || sym.owner.isConstructor then
-                sym.keepAnnotationsCarrying(thisPhase, Set(defn.ParamMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
+              // @param should be consulted only for fields
+              val unusing = sym.getAnnotation(defn.UnusedAnnot)
+              sym.keepAnnotationsCarrying(thisPhase, Set(defn.ParamMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
+              unusing.foreach(sym.addAnnotation)
             else if sym.is(ParamAccessor) then
               // @publicInBinary is not a meta-annotation and therefore not kept by `keepAnnotationsCarrying`
               val publicInBinaryAnnotOpt = sym.getAnnotation(defn.PublicInBinaryAnnot)

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

@@ -524,12 +524,14 @@ abstract class Recheck extends Phase, SymTransformer:
               if !skipRecheck(sym) then recheckDef(tree, sym)
               sym.termRef
           case tree: TypeDef =>
-            // TODO: Should we allow for completers as for ValDefs or DefDefs?
-            tree.rhs match
-              case impl: Template =>
-                recheckClassDef(tree, impl, sym.asClass)(using ctx.localContext(tree, sym))
-              case _ =>
-                recheckTypeDef(tree, sym)(using ctx.localContext(tree, sym))
+            if !skipRecheck(sym) then
+              // TODO: Should we allow for completers as for ValDefs or DefDefs?
+              tree.rhs match
+                case impl: Template =>
+                  recheckClassDef(tree, impl, sym.asClass)(using ctx.localContext(tree, sym))
+                case _ =>
+                  recheckTypeDef(tree, sym)(using ctx.localContext(tree, sym))
+            sym.typeRef
           case tree: Labeled => recheckLabeled(tree, pt)
 
       def recheckUnnamed(tree: Tree, pt: Type): Type = tree match

presentation-compiler/src/main/dotty/tools/pc/PcInlineValueProvider.scala

@@ -128,16 +128,13 @@ final class PcInlineValueProvider(
     end for
   end defAndRefs
 
-  private def stripIndentPrefix(rhs: String, refIndent: String, defIndent: String): String =
+  private def stripIndentPrefix(rhs: String, refIndent: String, defIndent: String, hasNextLineAfterEqualsSign: Boolean): String =
     val rhsLines = rhs.split("\n").toList
     rhsLines match
       case h :: Nil => rhs
       case h :: t =>
-        val noPrefixH = h.stripPrefix(refIndent)
-        if noPrefixH.startsWith("{") then
-          noPrefixH ++ t.map(refIndent ++ _.stripPrefix(defIndent)).mkString("\n","\n", "")
-        else
-          (("  " ++ h) :: t).map(refIndent ++ _.stripPrefix(defIndent)).mkString("\n", "\n", "")
+        val header = if !hasNextLineAfterEqualsSign then h else "\n" ++ refIndent ++ "  " ++ h
+        header ++ t.map(refIndent ++ _.stripPrefix(defIndent)).mkString("\n", "\n", "")
       case Nil => rhs
 
   private def definitionRequiresBrackets(tree: Tree)(using Context): Boolean =
@@ -236,7 +233,7 @@ final class PcInlineValueProvider(
       var idx = source.startOfLine(offset)
       val pad = new StringBuilder
       while (idx != offset && idx < source.content().length && source.content()(idx).isWhitespace) {
-        pad.append(if (idx < source.content().length && source.content()(idx) == '\t') '\t' else ' ')
+        pad.append(source.content()(idx))
         idx += 1
       }
       pad.result()
@@ -262,14 +259,17 @@ final class PcInlineValueProvider(
             case _ => false
         }
         .map(_.fullNameBackticked)
+      val hasNextLineAfterEqualsSign =
+        definition.tree.sourcePos.startLine != definition.tree.rhs.sourcePos.startLine
       if conflictingSymbols.isEmpty then
         Right(
           Reference(
             occurrence.pos.toLsp,
             stripIndentPrefix(
               extendWithSurroundingParens(definition.tree.rhs.sourcePos),
               occurrence.tree.startPos.startColumnIndentPadding,
-              definition.tree.startPos.startColumnIndentPadding
+              definition.tree.startPos.startColumnIndentPadding,
+              hasNextLineAfterEqualsSign
             ),
             occurrence.parent.map(p =>
               RangeOffset(p.sourcePos.start, p.sourcePos.end)

presentation-compiler/test/dotty/tools/pc/tests/edit/InlineValueSuite.scala

@@ -430,6 +430,25 @@ class InlineValueSuite extends BaseCodeActionSuite with CommonMtagsEnrichments:
     )
 
   @Test def `i7137a` =
+    checkEdit(
+      """|def foo = {
+         |  val newValue =
+         |    val x = true
+         |    x
+         |  def bar =
+         |    val xx =new<<V>>alue
+         |}
+         |""".stripMargin,
+      """|def foo = {
+         |  def bar =
+         |    val xx =
+         |      val x = true
+         |      x
+         |}
+         |""".stripMargin
+    )
+
+  @Test def `i7137b` =
       checkEdit(
         """|object O {
             |  def foo = {
@@ -454,6 +473,31 @@ class InlineValueSuite extends BaseCodeActionSuite with CommonMtagsEnrichments:
             |""".stripMargin
       )
 
+  @Test def `no-new-line` =
+    checkEdit(
+      """|object O {
+         |  val i: Option[Int] = ???
+         |  def foo = {
+         |    val newValue = i match
+         |      case Some(x) => x
+         |      case None => 0
+         |    def bar =
+         |      val xx = new<<V>>alue
+         |  }
+         |}
+         |""".stripMargin,
+      """|object O {
+         |  val i: Option[Int] = ???
+         |  def foo = {
+         |    def bar =
+         |      val xx = i match
+         |        case Some(x) => x
+         |        case None => 0
+         |  }
+         |}
+         |""".stripMargin
+    )
+
   def checkEdit(
       original: String,
       expected: String,

tests/warn/i21649.scala

@@ -0,0 +1,16 @@
+//> using options -explain
+// do warn if function literal adaptation has match in non-empty block
+
+import scala.util.*
+import PartialFunction.condOpt
+
+val f: PartialFunction[String, Boolean] = _.toUpperCase match { case "TRUE" => true }
+
+val g: PartialFunction[String, Boolean] = x =>
+  val uc = x.toUpperCase
+  uc match // warn
+  case "TRUE" => true
+
+def kollekt = List("1", "two", "3").collect(x => Try(x.toInt) match { case Success(i) => i })
+
+def lesen = List("1", "two", "3").flatMap(x => condOpt(Try(x.toInt)) { case Success(i) => i })

tests/warn/i23033.scala

@@ -0,0 +1,13 @@
+//> using options -Werror -Wunused:all
+
+import scala.annotation.unused
+import scala.concurrent.ExecutionContext
+import scala.util.NotGiven
+
+object Test {
+  given [T](using @unused ev: NotGiven[T <:< Int]): AnyRef with {}
+}
+object Useful:
+  given [T](using @unused ec: ExecutionContext): AnyRef with {}
+object Syntax:
+  given [T] => (@unused ec: ExecutionContext) => AnyRef