merge upstream changes

Author: adamgfraser

community-build/community-projects/intent

@@ -31,7 +31,7 @@ def exec(projectDir: Path, binary: String, arguments: String*): Int =
   exitCode
 
 
-sealed trait CommunityProject
+sealed trait CommunityProject:
   private var published = false
 
   val project: String
@@ -77,17 +77,23 @@ sealed trait CommunityProject
       published = true
 end CommunityProject
 
-final case class MillCommunityProject(project: String, baseCommand: String,
-  dependencies: List[CommunityProject] = Nil) extends CommunityProject
+final case class MillCommunityProject(
+    project: String,
+    baseCommand: String,
+    dependencies: List[CommunityProject] = Nil) extends CommunityProject:
   override val binaryName: String = "./mill"
   override val updateCommand = s"$baseCommand.compileClasspath"
   override val testCommand = s"$baseCommand.test"
   override val publishCommand = s"$baseCommand.publishLocal"
   override val runCommandsArgs = List("-i", "-D", s"dottyVersion=$compilerVersion")
 
-final case class SbtCommunityProject(project: String, sbtTestCommand: String,
-  sbtUpdateCommand: String, extraSbtArgs: List[String] = Nil,
-  dependencies: List[CommunityProject] = Nil, sbtPublishCommand: String = null) extends CommunityProject
+final case class SbtCommunityProject(
+    project: String,
+    sbtTestCommand: String,
+    sbtUpdateCommand: String,
+    extraSbtArgs: List[String] = Nil,
+    dependencies: List[CommunityProject] = Nil,
+    sbtPublishCommand: String = null) extends CommunityProject:
   override val binaryName: String = "sbt"
   private val baseCommand = s";clean ;set updateOptions in Global ~= (_.withLatestSnapshots(false)) ;++$compilerVersion! "
   override val testCommand = s"$baseCommand$sbtTestCommand"
@@ -103,7 +109,7 @@ final case class SbtCommunityProject(project: String, sbtTestCommand: String,
       "-sbt-version", "1.3.6",
       s"--addPluginSbtFile=$sbtPluginFilePath")
 
-object projects
+object projects:
   lazy val utest = MillCommunityProject(
     project = "utest",
     baseCommand = s"utest.jvm[$compilerVersion]",
@@ -271,7 +277,7 @@ object projects
 end projects
 
 @Category(Array(classOf[TestCategory]))
-class CommunityBuildTest {
+class CommunityBuildTest:
   given CommunityBuildTest = this
 
   /** Build the given project with the published local compiler and sbt plugin.
@@ -342,7 +348,7 @@ class CommunityBuildTest {
   @Test def effpi = projects.effpi.run()
   @Test def sconfig = projects.sconfig.run()
   @Test def zio = projects.zio.run()
-}
+end CommunityBuildTest
 
 class TestCategory
 class UpdateCategory

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

@@ -43,7 +43,7 @@ class CompilationUnit protected (val source: SourceFile) {
 
   var suspended: Boolean = false
 
-  def suspend()(given ctx: Context): Nothing =
+  def suspend()(using ctx: Context): Nothing =
     if !suspended then
       if (ctx.settings.XprintSuspension.value)
         ctx.echo(i"suspended: $this")
@@ -57,7 +57,7 @@ class CompilationUnit protected (val source: SourceFile) {
    *  that can be tracked for being not null to the list of spans of assignments
    *  to these variables.
    */
-  def assignmentSpans(given Context): Map[Int, List[Span]] =
+  def assignmentSpans(using Context): Map[Int, List[Span]] =
     if myAssignmentSpans == null then myAssignmentSpans = Nullables.assignmentSpans
     myAssignmentSpans
 }

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -488,7 +488,7 @@ object desugar {
       if (isEnum) {
         val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
         if (enumCases.isEmpty)
-          ctx.error("Enumerations must contain at least one case", namePos)
+          ctx.error(EnumerationsShouldNotBeEmpty(cdef), namePos)
         val enumCompanionRef = TermRefTree()
         val enumImport =
           Import(enumCompanionRef, enumCases.flatMap(caseIds).map(ImportSelector(_)))
@@ -883,12 +883,12 @@ object desugar {
     def flagSourcePos(flag: FlagSet) = mods.mods.find(_.flags == flag).fold(mdef.sourcePos)(_.sourcePos)
 
     if (mods.is(Abstract))
-      ctx.error(em"${hl("abstract")} modifier cannot be used for objects", flagSourcePos(Abstract))
+      ctx.error(AbstractCannotBeUsedForObjects(mdef), flagSourcePos(Abstract))
     if (mods.is(Sealed))
-      ctx.error(em"${hl("sealed")} modifier is redundant for objects", flagSourcePos(Sealed))
+      ctx.error(ModifierRedundantForObjects(mdef, "sealed"), flagSourcePos(Sealed))
     // Maybe this should be an error; see https://github.com/scala/bug/issues/11094.
     if (mods.is(Final) && !mods.is(Synthetic))
-      ctx.warning(em"${hl("final")} modifier is redundant for objects", flagSourcePos(Final))
+      ctx.warning(ModifierRedundantForObjects(mdef, "final"), flagSourcePos(Final))
 
     if (mods.is(Package))
       packageModuleDef(mdef)
@@ -929,7 +929,7 @@ object desugar {
    */
 
   def makeExtensionDef(mdef: Tree, tparams: List[TypeDef], leadingParams: List[ValDef],
-                       givenParamss: List[List[ValDef]])(given ctx: Context): Tree = {
+                       givenParamss: List[List[ValDef]])(using ctx: Context): Tree = {
     val allowed = "allowed here, since collective parameters are given"
     mdef match {
       case mdef: DefDef =>
@@ -986,7 +986,7 @@ object desugar {
   }
 
   /** Invent a name for an anonympus given or extension of type or template `impl`. */
-  def inventGivenOrExtensionName(impl: Tree)(given ctx: Context): SimpleName =
+  def inventGivenOrExtensionName(impl: Tree)(using ctx: Context): SimpleName =
     val str = impl match
       case impl: Template =>
         if impl.parents.isEmpty then
@@ -1253,7 +1253,7 @@ object desugar {
     else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
   }
 
-  private def isTopLevelDef(stat: Tree)(given Context): Boolean = stat match
+  private def isTopLevelDef(stat: Tree)(using Context): Boolean = stat match
     case _: ValDef | _: PatDef | _: DefDef | _: Export => true
     case stat: ModuleDef =>
       stat.mods.isOneOf(GivenOrImplicit)

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

@@ -26,7 +26,7 @@ import ast.Trees._
  */
 object MainProxies {
 
-  def mainProxies(stats: List[tpd.Tree])(given Context): List[untpd.Tree] = {
+  def mainProxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
     import tpd._
     def mainMethods(stats: List[Tree]): List[Symbol] = stats.flatMap {
       case stat: DefDef if stat.symbol.hasAnnotation(defn.MainAnnot) =>
@@ -40,7 +40,7 @@ object MainProxies {
   }
 
   import untpd._
-  def mainProxy(mainFun: Symbol)(given ctx: Context): List[TypeDef] = {
+  def mainProxy(mainFun: Symbol)(using ctx: Context): List[TypeDef] = {
     val mainAnnotSpan = mainFun.getAnnotation(defn.MainAnnot).get.tree.span
     def pos = mainFun.sourcePos
     val argsRef = Ident(nme.args)

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

@@ -869,10 +869,10 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  A not-null assertion for reference `x` has the form `x.$asInstanceOf$[x.type & T]`.
    */
   object AssertNotNull with
-    def apply(tree: tpd.Tree, tpnn: Type)(given Context): tpd.Tree =
+    def apply(tree: tpd.Tree, tpnn: Type)(using Context): tpd.Tree =
       tree.select(defn.Any_typeCast).appliedToType(AndType(tree.tpe, tpnn))
 
-    def unapply(tree: tpd.TypeApply)(given Context): Option[tpd.Tree] = tree match
+    def unapply(tree: tpd.TypeApply)(using Context): Option[tpd.Tree] = tree match
       case TypeApply(Select(qual: RefTree, nme.asInstanceOfPM), arg :: Nil) =>
         arg.tpe match
           case AndType(ref, _) if qual.tpe eq ref => Some(qual)

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

@@ -878,7 +878,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Apply(tree, args)
 
     /** An applied node that accepts only varargs as arguments */
-    def appliedToVarargs(args: List[Tree], tpt: Tree)(given Context): Tree =
+    def appliedToVarargs(args: List[Tree], tpt: Tree)(using Context): Tree =
       appliedTo(repeated(args, tpt))
 
     /** The current tree applied to given argument lists:
@@ -1378,7 +1378,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** Convert a list of trees to a vararg-compatible tree.
    *  Used to make arguments for methods that accept varargs.
    */
-  def repeated(trees: List[Tree], tpt: Tree)(given ctx: Context): Tree =
+  def repeated(trees: List[Tree], tpt: Tree)(using ctx: Context): Tree =
     ctx.typeAssigner.arrayToRepeated(JavaSeqLiteral(trees, tpt))
 
   /** Create a tree representing a list containing all
@@ -1390,7 +1390,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  @param tpe    the type of the elements of the resulting list.
    *
    */
-  def mkList(trees: List[Tree], tpe: Tree)(given Context): Tree =
+  def mkList(trees: List[Tree], tpe: Tree)(using Context): Tree =
     ref(defn.ListModule).select(nme.apply)
       .appliedToTypeTree(tpe)
       .appliedToVarargs(trees, tpe)

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

@@ -246,7 +246,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
      *  describe the core of a construct whereas the existing set are the modifiers
      *  given in the source.
      */
-    def withAddedFlags(flags: FlagSet, span: Span)(given ctx: Context): Modifiers =
+    def withAddedFlags(flags: FlagSet, span: Span)(using ctx: Context): Modifiers =
       if this.flags.isAllOf(flags) then this
       else if compatible(this.flags, flags) then this | flags
       else

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

@@ -160,9 +160,6 @@ object Config {
   /** Assume -indent by default */
   final val defaultIndent = true
 
-  /** Assume indentation is significant after a class, object, ... signature */
-  final val silentTemplateIndent = true
-
   /** If set, prints a trace of all symbol completions */
   final val showCompletions = false
 

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -10,7 +10,7 @@ import util.Spans.Span
 
 object Annotations {
 
-  def annotClass(tree: Tree)(given Context) =
+  def annotClass(tree: Tree)(using Context) =
     if (tree.symbol.isConstructor) tree.symbol.owner
     else tree.tpe.typeSymbol
 
@@ -118,25 +118,25 @@ object Annotations {
       apply(New(atp, args))
 
     /** Create an annotation where the tree is computed lazily. */
-    def deferred(sym: Symbol)(treeFn: (given Context) => Tree)(implicit ctx: Context): Annotation =
+    def deferred(sym: Symbol)(treeFn: Context ?=> Tree)(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         override def symbol(implicit ctx: Context): Symbol = sym
-        def complete(implicit ctx: Context) = treeFn(given ctx)
+        def complete(implicit ctx: Context) = treeFn(using ctx)
       }
 
     /** Create an annotation where the symbol and the tree are computed lazily. */
-    def deferredSymAndTree(symf: (given Context) => Symbol)(treeFn: (given Context) => Tree)(implicit ctx: Context): Annotation =
+    def deferredSymAndTree(symf: Context ?=> Symbol)(treeFn: Context ?=> Tree)(implicit ctx: Context): Annotation =
       new LazyAnnotation {
         private var mySym: Symbol = _
 
         override def symbol(implicit ctx: Context): Symbol = {
           if (mySym == null || mySym.defRunId != ctx.runId) {
-            mySym = symf(given ctx)
+            mySym = symf(using ctx)
             assert(mySym != null)
           }
           mySym
         }
-        def complete(implicit ctx: Context) = treeFn(given ctx)
+        def complete(implicit ctx: Context) = treeFn(using ctx)
       }
 
     def deferred(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
@@ -153,8 +153,8 @@ object Annotations {
     object Child {
 
       /** A deferred annotation to the result of a given child computation */
-      def later(delayedSym: (given Context) => Symbol, span: Span)(implicit ctx: Context): Annotation = {
-        def makeChildLater(given ctx: Context) = {
+      def later(delayedSym: Context ?=> Symbol, span: Span)(implicit ctx: Context): Annotation = {
+        def makeChildLater(using ctx: Context) = {
           val sym = delayedSym
           New(defn.ChildAnnot.typeRef.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil)
             .withSpan(span)

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

@@ -51,7 +51,7 @@ object Contexts {
   private val initialStore = store8
 
   /** The current context */
-  def curCtx(given ctx: Context): Context = ctx
+  def curCtx(using ctx: Context): Context = ctx
 
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
@@ -319,7 +319,7 @@ object Contexts {
     /** Run `op` as if it was run in a fresh explore typer state, but possibly
      *  optimized to re-use the current typer state.
      */
-    final def test[T](op: (given Context) => T): T = typerState.test(op)(this)
+    final def test[T](op: Context ?=> T): T = typerState.test(op)(this)
 
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =
@@ -599,7 +599,7 @@ object Contexts {
     def setDebug: this.type = setSetting(base.settings.Ydebug, true)
   }
 
-  given ops: extension (c: Context) with
+  extension ops on (c: Context) with
     def addNotNullInfo(info: NotNullInfo) =
       c.withNotNullInfos(c.notNullInfos.extendWith(info))
 

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

@@ -188,9 +188,9 @@ object Decorators {
 
   implicit class reportDeco[T](x: T) extends AnyVal {
     def reporting(
-        op: (given WrappedResult[T]) => String,
+        op: WrappedResult[T] ?=> String,
         printer: config.Printers.Printer = config.Printers.default): T = {
-      printer.println(op(given WrappedResult(x)))
+      printer.println(op(using WrappedResult(x)))
       x
     }
   }