Merge branch 'lampepfl:main' into show-context-for-inline-safe-init

Author: Xavientois

.gitmodules

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

community-build/community-projects/cats-effect-3

@@ -791,6 +791,14 @@ object projects:
     dependencies = () => List(cats, disciplineMunit)
   )
 
+  lazy val http4s = SbtCommunityProject(
+    project = "http4s",
+    sbtTestCommand = "tests/test; server/test; client/test; ember-core/test; ember-server/test; ember-client/test; circe/test",
+    sbtPublishCommand = "publishLocal",
+    scalacOptions = SbtCommunityProject.scalacOptions.filter(_ != "-Ysafe-init"),
+    dependencies = () => List(cats, catsEffect3, fs2, disciplineMunit, scalacheckEffect)
+  )
+
 end projects
 
 lazy val forwardCompatMapping = Map[CommunityProject, CommunityProject](
@@ -892,7 +900,9 @@ def allProjects = List(
   projects.jacksonModuleScala,
   projects.specs2,
   projects.coop,
-  projects.coopForwardCompat
+  projects.coopForwardCompat,
+  projects.spire,
+  projects.http4s
 )
 
 lazy val projectMap = allProjects.groupBy(_.project)

community-build/community-projects/http4s

@@ -52,6 +52,7 @@ class CommunityBuildTestB:
   @Test def scodecBits = projects.scodecBits.run()
   @Test def simulacrumScalafixAnnotations = projects.simulacrumScalafixAnnotations.run()
   @Test def spire = projects.spire.run()
+  @Test def http4s = projects.http4s.run()
 end CommunityBuildTestB
 
 @Category(Array(classOf[TestCategory]))

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

@@ -4563,14 +4563,7 @@ class JSCodeGen()(using genCtx: Context) {
         val module = annot.argumentConstantString(0).getOrElse {
           unexpected("could not read the module argument as a string literal")
         }
-        val path = annot.argumentConstantString(1).fold {
-          if (annot.arguments.sizeIs < 2)
-            parsePath(sym.defaultJSName)
-          else
-            Nil
-        } { pathName =>
-          parsePath(pathName)
-        }
+        val path = annot.argumentConstantString(1).fold[List[String]](Nil)(parsePath)
         val importSpec = Import(module, path)
         annot.argumentConstantString(2).fold[js.JSNativeLoadSpec] {
           importSpec

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

@@ -78,6 +78,22 @@ object Completion {
         Mode.None
     }
 
+  /** When dealing with <errors> in varios palces we check to see if they are
+   *  due to incomplete backticks. If so, we ensure we get the full prefix
+   *  including the backtick.
+   *
+   * @param content The source content that we'll check the positions for the prefix
+   * @param start The start position we'll start to look for the prefix at
+   * @param end The end position we'll look for the prefix at
+   * @return Either the full prefix including the ` or an empty string 
+   */
+  private def checkBacktickPrefix(content: Array[Char], start: Int, end: Int): String = 
+    content.lift(start) match
+      case Some(char) if char == '`' =>
+        content.slice(start, end).mkString
+      case _ =>
+        ""
+
   /**
    * Inspect `path` to determine the completion prefix. Only symbols whose name start with the
    * returned prefix should be considered.
@@ -92,15 +108,14 @@ object Completion {
           completionPrefix(selector :: Nil, pos)
         }.getOrElse("")
 
-      // We special case Select here because we want to determine if the name
-      // is an error due to an unclosed backtick.
-      case (select: untpd.Select) :: _ if (select.name == nme.ERROR) =>
-         val content = select.source.content()
-          content.lift(select.nameSpan.start) match
-            case Some(char) if char == '`' =>
-              content.slice(select.nameSpan.start, select.span.end).mkString
-            case _ =>
-              ""
+      // Foo.`se<TAB> will result in Select(Ident(Foo), <error>)
+      case (select: untpd.Select) :: _ if select.name == nme.ERROR =>
+        checkBacktickPrefix(select.source.content(), select.nameSpan.start, select.span.end)
+     
+      // import scala.util.chaining.`s<TAB> will result in a Ident(<error>)
+      case (ident: untpd.Ident) :: _ if ident.name == nme.ERROR =>
+        checkBacktickPrefix(ident.source.content(), ident.span.start, ident.span.end)
+
       case (ref: untpd.RefTree) :: _ =>
         if (ref.name == nme.ERROR) ""
         else ref.name.toString.take(pos.span.point - ref.span.point)

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -594,7 +594,7 @@ object JavaParsers {
           val vparams = formalParams()
           if (!isVoid) rtpt = optArrayBrackets(rtpt)
           optThrows()
-          val bodyOk = !inInterface || mods.isOneOf(Flags.DefaultMethod | Flags.JavaStatic)
+          val bodyOk = !inInterface || mods.isOneOf(Flags.DefaultMethod | Flags.JavaStatic | Flags.Private)
           val body =
             if (bodyOk && in.token == LBRACE)
               methodBody()

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

@@ -14,8 +14,7 @@ import Contexts._
 import Decorators._
 import DenotTransformers._
 import Flags._
-import NameKinds.{DefaultGetterName, ModuleClassName}
-import NameOps._
+import NameKinds.DefaultGetterName
 import StdNames._
 import Symbols._
 import SymUtils._
@@ -560,14 +559,9 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
           case Some(annot) if annot.symbol == jsdefn.JSGlobalAnnot =>
             checkJSGlobalLiteral(annot)
             val pathName = annot.argumentConstantString(0).getOrElse {
-              val symTermName = sym.name.exclude(NameKinds.ModuleClassName).toTermName
-              if (symTermName == nme.apply) {
+              if ((enclosingOwner is OwnerKind.ScalaMod) && !sym.owner.isPackageObject) {
                 report.error(
-                    "Native JS definitions named 'apply' must have an explicit name in @JSGlobal",
-                    annot.tree)
-              } else if (symTermName.isSetterName) {
-                report.error(
-                    "Native JS definitions with a name ending in '_=' must have an explicit name in @JSGlobal",
+                    "Native JS members inside non-native objects must have an explicit name in @JSGlobal",
                     annot.tree)
               }
               sym.defaultJSName
@@ -576,18 +570,6 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
 
           case Some(annot) if annot.symbol == jsdefn.JSImportAnnot =>
             checkJSImportLiteral(annot)
-            if (annot.arguments.sizeIs < 2) {
-              val symTermName = sym.name.exclude(NameKinds.ModuleClassName).toTermName
-              if (symTermName == nme.apply) {
-                report.error(
-                    "Native JS definitions named 'apply' must have an explicit name in @JSImport",
-                    annot.tree)
-              } else if (symTermName.isSetterName) {
-                report.error(
-                    "Native JS definitions with a name ending in '_=' must have an explicit name in @JSImport",
-                    annot.tree)
-              }
-            }
             annot.argumentConstantString(2).foreach { globalPathName =>
               checkGlobalRefPath(globalPathName)
             }
@@ -1125,19 +1107,18 @@ object PrepJSInterop {
    */
   private def checkJSImportLiteral(annot: Annotation)(using Context): Unit = {
     val args = annot.arguments
-    val argCount = args.size
-    assert(argCount >= 1 && argCount <= 3,
-        i"@JSImport annotation $annot does not have between 1 and 3 arguments")
+    assert(args.size == 2 || args.size == 3,
+        i"@JSImport annotation $annot does not have exactly 2 or 3 arguments")
 
     val firstArgIsValid = annot.argumentConstantString(0).isDefined
     if (!firstArgIsValid)
       report.error("The first argument to @JSImport must be a literal string.", args.head)
 
-    val secondArgIsValid = argCount < 2 || annot.argumentConstantString(1).isDefined || args(1).symbol == jsdefn.JSImportNamespaceModule
+    val secondArgIsValid = annot.argumentConstantString(1).isDefined || args(1).symbol == jsdefn.JSImportNamespaceModule
     if (!secondArgIsValid)
       report.error("The second argument to @JSImport must be literal string or the JSImport.Namespace object.", args(1))
 
-    val thirdArgIsValid = argCount < 3 || annot.argumentConstantString(2).isDefined
+    val thirdArgIsValid = args.size < 3 || annot.argumentConstantString(2).isDefined
     if (!thirdArgIsValid)
       report.error("The third argument to @JSImport, when present, must be a literal string.", args(2))
   }

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

@@ -152,6 +152,14 @@ final class JLineTerminal extends java.io.Closeable {
           // using dummy values, resulting parsed input is probably unused
           defaultParsedLine
 
+        // In the situation where we have a partial command that we want to
+        // complete we need to ensure that the :<partial-word> isn't split into
+        // 2 tokens, but rather the entire thing is treated as the "word", in
+        //   order to insure the : is replaced in the completion.
+        case ParseContext.COMPLETE if
+          ParseResult.commands.exists(command => command._1.startsWith(input)) =>
+            parsedLine(input, cursor)
+
         case ParseContext.COMPLETE =>
           // Parse to find completions (typically after a Tab).
           def isCompletable(token: Token) = isIdentifier(token) || isKeyword(token)