Scala 2.12.20, 3.5.0

.github/workflows/release.yml

@@ -23,10 +23,10 @@ jobs:
       fail-fast: false
     runs-on: ubuntu-latest
     env:
-      SONATYPE_PGP_SECRET: ${{ secrets.SONATYPE_PGP_SECRET }}
       SONATYPE_DEPLOY_USER: ${{ secrets.SONATYPE_DEPLOY_USER }}
       SONATYPE_DEPLOY_PASSWORD: ${{ secrets.SONATYPE_DEPLOY_PASSWORD }}
-      SONATYPE_PGP_PASSWORD: ${{ secrets.SONATYPE_PGP_PASSWORD }}
+      SONATYPE_PGP_SECRET: ${{ secrets.SONATYPE_PGP_PRIVATE_KEY }}
+      SONATYPE_PGP_PASSWORD: ${{ secrets.SONATYPE_PGP_PRIVATE_KEY_PASSWORD }}
       LANG: "en_US.UTF-8"
       LC_MESSAGES: "en_US.UTF-8"
       LC_ALL: "en_US.UTF-8"
@@ -38,5 +38,5 @@ jobs:
         with:
           java-version: '8'
           distribution: temurin
-      - run: test -z "$SONATYPE_PGP_SECRET" || echo "$SONATYPE_PGP_SECRET" | base64 --decode | gpg --import --no-tty --batch --yes
+      - run: test -z "$SONATYPE_PGP_PRIVATE_KEY" || echo "$SONATYPE_PGP_PRIVATE_KEY" | base64 --decode | gpg --import --no-tty --batch --yes
       - run: GPG_TTY=$(tty) ./mill -i publishSonatype __.publishArtifacts --shard ${{ matrix.shard }} --divisionCount 6

.github/workflows/run-tests.yml

@@ -22,21 +22,21 @@ jobs:
             command: 'terminal.__.test'
 
           - java-version: 11
-            command: 'sshd[{2.12.19,2.13.14,3.3.3,3.4.2}].__.test'
+            command: 'sshd[{2.12.20,2.13.14,3.3.3,3.4.2,3.5.0}].__.test'
 
           - java-version: 11
-            command: 'amm.repl[2.12.{9,14,19}].__.test'
+            command: 'amm.repl[2.12.{9,14,20}].__.test'
           - java-version: 17
             command: 'amm.repl[2.13.{4,9,14}].__.test'
           - java-version: 21
-            command: 'amm.repl[{3.3.3,3.4.2}].__.test'
+            command: 'amm.repl[{3.3.3,3.4.2,3.5.0}].__.test'
 
           - java-version: 11
-            command: 'amm[2.12.{9,14,19}].__.test'
+            command: 'amm[2.12.{9,14,20}].__.test'
           - java-version: 17
             command: 'amm[2.13.{4,9,14}].__.test'
           - java-version: 21
-            command: 'amm[{3.3.3,3.4.2}].__.test'
+            command: 'amm[{3.3.3,3.4.2,3.5.0}].__.test'
 
     runs-on: ubuntu-latest
     steps:
@@ -53,11 +53,11 @@ jobs:
       matrix:
         include:
           - java-version: 11
-            scala-version: '2.12.{9,14,19}'
+            scala-version: '2.12.{9,14,20}'
           - java-version: 17
             scala-version: '2.13.{4,9,14}'
           - java-version: 21
-            scala-version: '{3.3.3,3.4.2}'
+            scala-version: '{3.3.3,3.4.2,3.5.0}'
 
     runs-on: ubuntu-latest
     steps:

amm/compiler/src/main/scala-3/dotty/ammonite/compiler/AmmCompletion.scala → amm/compiler/src/main/scala-3.0.0-3.3.1/dotty/ammonite/compiler/AmmCompletion.scala

@@ -5,9 +5,8 @@ import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Denotations.SingleDenotation
 import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.Names.{Name, termName}
+import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.Symbols.{Symbol, defn}
-import dotty.tools.dotc.core.TypeError
 import dotty.tools.dotc.interactive.{Completion, Interactive}
 import dotty.tools.dotc.util.SourcePosition
 

amm/compiler/src/main/scala-3.3.2+/dotty/ammonite/compiler/AmmCompletion.scala

@@ -0,0 +1,138 @@
+package dotty.ammonite.compiler
+
+import dotty.tools.dotc.ast.tpd._
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Denotations.SingleDenotation
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.Symbols.{Symbol, defn}
+import dotty.tools.dotc.interactive.{Completion, Interactive}
+import dotty.tools.dotc.util.SourcePosition
+
+object AmmCompletion extends AmmCompletionExtras {
+
+  def completions(
+    pos: SourcePosition,
+    dependencyCompleteOpt: Option[String => (Int, Seq[String])],
+    enableDeep: Boolean
+  )(using Context): (Int, List[Completion]) = {
+    val path = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.span)
+    computeCompletions(
+      pos,
+      path,
+      dependencyCompleteOpt,
+      enableDeep
+    )(using Interactive.contextOfPath(path))
+  }
+
+  def computeCompletions(
+    pos: SourcePosition,
+    path: List[Tree],
+    dependencyCompleteOpt: Option[String => (Int, Seq[String])],
+    enableDeep: Boolean
+  )(using Context): (Int, List[Completion]) = {
+    val mode = Completion.completionMode(path, pos)
+    val prefix = Completion.completionPrefix(path, pos)
+    val completer = new DeepCompleter(mode, prefix, pos)
+
+    val hasBackTick = prefix.headOption.contains('`')
+
+    var extra = List.empty[Completion]
+
+    val completions = path match {
+      case Select(qual, _) :: _                              => completer.selectionCompletions(qual)
+      case Import(Ident(name), _) :: _
+        if name.decode.toString == "$ivy" && dependencyCompleteOpt.nonEmpty =>
+        val complete = dependencyCompleteOpt.get
+        val (pos, completions) = complete(prefix)
+        val input0 = prefix.take(pos)
+        extra = extra ::: completions.distinct.toList
+          .map(s => maybeBackticked(input0 + s, hasBackTick))
+        Map.empty
+      case Import(expr, _) :: _                              =>
+        completer.directMemberCompletions(expr)
+      case (_: untpd.ImportSelector) :: Import(expr, _) :: _ =>
+        completer.directMemberCompletions(expr)
+      case _                                                 =>
+        completer.scopeCompletions ++ {
+          if (enableDeep) completer.deepCompletions
+          else Nil
+        }
+    }
+
+    val describedCompletions = extra ++ Completion.describeCompletions(completions).map(backtick)
+    val offset = Completion.completionOffset(path)
+
+    (pos.span.start - prefix.length, describedCompletions)
+  }
+
+  class DeepCompleter(
+    mode: Completion.Mode,
+    prefix: String,
+    pos: SourcePosition
+  ) extends Completion.Completer(mode, prefix, pos):
+    private def blacklisted(s: Symbol)(using Context) = {
+      val blacklist = Set(
+        "scala.Predef.any2stringadd.+",
+        "scala.Any.##",
+        "java.lang.Object.##",
+        "scala.<byname>",
+        "scala.<empty>",
+        "scala.<repeated>",
+        "scala.<repeated...>",
+        "scala.Predef.StringFormat.formatted",
+        "scala.Predef.Ensuring.ensuring",
+        "scala.Predef.ArrowAssoc.->",
+        "scala.Predef.ArrowAssoc.→",
+        "java.lang.Object.synchronized",
+        "java.lang.Object.ne",
+        "java.lang.Object.eq",
+        "java.lang.Object.wait",
+        "java.lang.Object.notifyAll",
+        "java.lang.Object.notify",
+        "java.lang.Object.clone",
+        "java.lang.Object.finalize"
+      )
+
+      blacklist(s.showFullName) ||
+      s.isOneOf(GivenOrImplicit) ||
+      // Cache objects, which you should probably never need to
+      // access directly, and apart from that have annoyingly long names
+      "cache[a-f0-9]{32}".r.findPrefixMatchOf(s.name.decode.toString).isDefined ||
+      // s.isDeprecated ||
+      s.name.decode.toString == "<init>" ||
+      s.name.decode.toString.contains('$')
+    }
+    def deepCompletions(using Context): Map[Name, Seq[SingleDenotation]] = {
+
+      val blacklistedPackages = Set("shaded")
+
+      def allMembers(s: Symbol) =
+        try s.info.allMembers
+        catch {
+          case _: dotty.tools.dotc.core.TypeError => Nil
+        }
+      def rec(t: Symbol): Seq[Symbol] =
+        if (blacklistedPackages(t.name.toString))
+          Nil
+        else {
+          val children =
+            if (t.is(Package) || t.is(PackageVal) || t.is(PackageClass)) {
+              allMembers(t).map(_.symbol).filter(!blacklisted(_)).filter(_ != t).flatMap(rec)
+            } else Nil
+
+          t +: children.toSeq
+        }
+
+      val syms = for {
+        member <- allMembers(defn.RootClass).map(_.symbol).filter(!blacklisted(_)).toList
+        sym <- rec(member)
+        if sym.name.toString.startsWith(prefix)
+      } yield sym
+
+      syms.map(sym => (sym.fullName, List(sym: SingleDenotation))).toMap
+    }
+
+}
+

amm/compiler/src/main/scala-3.4.2+/dotty/ammonite/compiler/AmmCompletion.scala

@@ -0,0 +1,138 @@
+package dotty.ammonite.compiler
+
+import dotty.tools.dotc.ast.tpd._
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Denotations.SingleDenotation
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.Symbols.{Symbol, defn}
+import dotty.tools.dotc.interactive.{Completion, Interactive}
+import dotty.tools.dotc.util.SourcePosition
+
+object AmmCompletion extends AmmCompletionExtras {
+
+  def completions(
+    pos: SourcePosition,
+    dependencyCompleteOpt: Option[String => (Int, Seq[String])],
+    enableDeep: Boolean
+  )(using Context): (Int, List[Completion]) = {
+    val path = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.span)
+    computeCompletions(
+      pos,
+      path,
+      dependencyCompleteOpt,
+      enableDeep
+    )(using Interactive.contextOfPath(path))
+  }
+
+  def computeCompletions(
+    pos: SourcePosition,
+    path: List[Tree],
+    dependencyCompleteOpt: Option[String => (Int, Seq[String])],
+    enableDeep: Boolean
+  )(using Context): (Int, List[Completion]) = {
+    val mode = Completion.completionMode(path, pos)
+    val prefix = Completion.completionPrefix(path, pos)
+    val completer = new DeepCompleter(mode, prefix, pos)
+
+    val hasBackTick = prefix.headOption.contains('`')
+
+    var extra = List.empty[Completion]
+
+    val completions = path match {
+      case Select(qual, _) :: _                              => completer.selectionCompletions(qual)
+      case Import(Ident(name), _) :: _
+        if name.decode.toString == "$ivy" && dependencyCompleteOpt.nonEmpty =>
+        val complete = dependencyCompleteOpt.get
+        val (pos, completions) = complete(prefix)
+        val input0 = prefix.take(pos)
+        extra = extra ::: completions.distinct.toList
+          .map(s => maybeBackticked(input0 + s, hasBackTick))
+        Map.empty
+      case Import(expr, _) :: _                              =>
+        completer.directMemberCompletions(expr)
+      case (_: untpd.ImportSelector) :: Import(expr, _) :: _ =>
+        completer.directMemberCompletions(expr)
+      case _                                                 =>
+        completer.scopeCompletions ++ {
+          if (enableDeep) completer.deepCompletions
+          else Nil
+        }
+    }
+
+    val describedCompletions = extra ++ Completion.describeCompletions(completions).map(backtick)
+    val offset = Completion.completionOffset(path)
+
+    (pos.span.start - prefix.length, describedCompletions)
+  }
+
+  class DeepCompleter(
+    mode: Completion.Mode,
+    prefix: String,
+    pos: SourcePosition
+  ) extends Completion.Completer(mode, prefix, pos):
+    private def blacklisted(s: Symbol)(using Context) = {
+      val blacklist = Set(
+        "scala.Predef.any2stringadd.+",
+        "scala.Any.##",
+        "java.lang.Object.##",
+        "scala.<byname>",
+        "scala.<empty>",
+        "scala.<repeated>",
+        "scala.<repeated...>",
+        "scala.Predef.StringFormat.formatted",
+        "scala.Predef.Ensuring.ensuring",
+        "scala.Predef.ArrowAssoc.->",
+        "scala.Predef.ArrowAssoc.→",
+        "java.lang.Object.synchronized",
+        "java.lang.Object.ne",
+        "java.lang.Object.eq",
+        "java.lang.Object.wait",
+        "java.lang.Object.notifyAll",
+        "java.lang.Object.notify",
+        "java.lang.Object.clone",
+        "java.lang.Object.finalize"
+      )
+
+      blacklist(s.showFullName) ||
+      s.isOneOf(GivenOrImplicit) ||
+      // Cache objects, which you should probably never need to
+      // access directly, and apart from that have annoyingly long names
+      "cache[a-f0-9]{32}".r.findPrefixMatchOf(s.name.decode.toString).isDefined ||
+      // s.isDeprecated ||
+      s.name.decode.toString == "<init>" ||
+      s.name.decode.toString.contains('$')
+    }
+    def deepCompletions(using Context): Map[Name, Seq[SingleDenotation]] = {
+
+      val blacklistedPackages = Set("shaded")
+
+      def allMembers(s: Symbol) =
+        try s.info.allMembers
+        catch {
+          case _: dotty.tools.dotc.core.TypeError => Nil
+        }
+      def rec(t: Symbol): Seq[Symbol] =
+        if (blacklistedPackages(t.name.toString))
+          Nil
+        else {
+          val children =
+            if (t.is(Package) || t.is(PackageVal) || t.is(PackageClass)) {
+              allMembers(t).map(_.symbol).filter(!blacklisted(_)).filter(_ != t).flatMap(rec)
+            } else Nil
+
+          t +: children.toSeq
+        }
+
+      val syms = for {
+        member <- allMembers(defn.RootClass).map(_.symbol).filter(!blacklisted(_)).toList
+        sym <- rec(member)
+        if sym.name.toString.startsWith(prefix)
+      } yield sym
+
+      syms.map(sym => (sym.fullName, List(sym: SingleDenotation))).toMap
+    }
+
+}
+