Use SAM-conversion if possible (#8477)

internal/util-logging/src/main/scala/sbt/util/InterfaceUtil.scala

@@ -33,9 +33,8 @@ object InterfaceUtil {
   }
 
   import java.util.function.{ Function as JavaFunction }
-  def toJavaFunction[A1, R](f: A1 => R): JavaFunction[A1, R] = new JavaFunction[A1, R] {
-    override def apply(t: A1): R = f(t)
-  }
+  def toJavaFunction[A1, R](f: A1 => R): JavaFunction[A1, R] =
+    (t: A1) => f(t)
 
   def t2[A1, A2](x: (A1, A2)): T2[A1, A2] = new ConcreteT2(x._1, x._2)
 

internal/util-logging/src/main/scala/sbt/util/ShowLines.scala

@@ -13,9 +13,7 @@ trait ShowLines[A] {
 }
 object ShowLines {
   def apply[A](f: A => Seq[String]): ShowLines[A] =
-    new ShowLines[A] {
-      def showLines(a: A): Seq[String] = f(a)
-    }
+    (a: A) => f(a)
 
   extension [A: ShowLines](a: A) {
     def lines: Seq[String] = implicitly[ShowLines[A]].showLines(a)

internal/util-logging/src/test/scala/ProblemTest.scala

@@ -192,10 +192,7 @@ object ProblemTest extends Properties {
     }
 
   private def copy(edit: WorkspaceEdit): WorkspaceEdit =
-    new WorkspaceEdit {
-      override def changes() =
-        l2jl(jl2l(edit.changes).map(copy))
-    }
+    () => l2jl(jl2l(edit.changes).map(copy))
 
   private def copy(edit: TextEdit): TextEdit =
     new TextEdit {

lm-core/src/main/scala/sbt/librarymanagement/DependencyFilter.scala

@@ -16,10 +16,8 @@ trait DependencyFilterExtra {
       name: NameFilter = AllPassFilter,
       revision: NameFilter = AllPassFilter
   ): ModuleFilter =
-    new ModuleFilter {
-      def apply(m: ModuleID): Boolean =
-        organization.accept(m.organization) && name.accept(m.name) && revision.accept(m.revision)
-    }
+    (m: ModuleID) =>
+      organization.accept(m.organization) && name.accept(m.name) && revision.accept(m.revision)
 
   def artifactFilter(
       name: NameFilter = AllPassFilter,
@@ -27,18 +25,14 @@ trait DependencyFilterExtra {
       extension: NameFilter = AllPassFilter,
       classifier: NameFilter = AllPassFilter
   ): ArtifactFilter =
-    new ArtifactFilter {
-      def apply(a: Artifact): Boolean =
-        name.accept(a.name) && `type`.accept(a.`type`) && extension.accept(
-          a.extension
-        ) && classifier
-          .accept(a.classifier getOrElse "")
-    }
+    (a: Artifact) =>
+      name.accept(a.name) && `type`.accept(a.`type`) && extension.accept(
+        a.extension
+      ) && classifier
+        .accept(a.classifier getOrElse "")
 
   def configurationFilter(name: NameFilter = AllPassFilter): ConfigurationFilter =
-    new ConfigurationFilter {
-      def apply(c: ConfigRef): Boolean = name.accept(c.name)
-    }
+    (c: ConfigRef) => name.accept(c.name)
 }
 
 object DependencyFilter extends DependencyFilterExtra {
@@ -47,27 +41,20 @@ object DependencyFilter extends DependencyFilterExtra {
       module: ModuleFilter = moduleFilter(),
       artifact: ArtifactFilter = artifactFilter()
   ): DependencyFilter =
-    new DependencyFilter {
-      def apply(c: ConfigRef, m: ModuleID, a: Artifact): Boolean =
-        configuration(c) && module(m) && artifact(a)
-    }
+    (c: ConfigRef, m: ModuleID, a: Artifact) => configuration(c) && module(m) && artifact(a)
   def apply(
       x: DependencyFilter,
       y: DependencyFilter,
       combine: (Boolean, Boolean) => Boolean
   ): DependencyFilter =
-    new DependencyFilter {
-      def apply(c: ConfigRef, m: ModuleID, a: Artifact): Boolean = combine(x(c, m, a), y(c, m, a))
-    }
+    (c: ConfigRef, m: ModuleID, a: Artifact) => combine(x(c, m, a), y(c, m, a))
   def allPass: DependencyFilter = configurationFilter()
-  implicit def fnToModuleFilter(f: ModuleID => Boolean): ModuleFilter = new ModuleFilter {
-    def apply(m: ModuleID) = f(m)
-  }
-  implicit def fnToArtifactFilter(f: Artifact => Boolean): ArtifactFilter = new ArtifactFilter {
-    def apply(m: Artifact) = f(m)
-  }
+  implicit def fnToModuleFilter(f: ModuleID => Boolean): ModuleFilter =
+    (m: ModuleID) => f(m)
+  implicit def fnToArtifactFilter(f: Artifact => Boolean): ArtifactFilter =
+    (m: Artifact) => f(m)
   implicit def fnToConfigurationFilter(f: ConfigRef => Boolean): ConfigurationFilter =
-    new ConfigurationFilter { def apply(c: ConfigRef) = f(c) }
+    (c: ConfigRef) => f(c)
   implicit def subDepFilterToFn[Arg](f: SubDepFilter[Arg, ?]): Arg => Boolean = f.apply(_)
 }
 trait DependencyFilter {
@@ -87,23 +74,20 @@ sealed trait SubDepFilter[Arg, Self <: SubDepFilter[Arg, Self]] extends Dependen
     make((m: Arg) => f(this(m), o(m)))
 }
 trait ModuleFilter extends SubDepFilter[ModuleID, ModuleFilter] {
-  protected final def make(f: ModuleID => Boolean) = new ModuleFilter {
-    def apply(m: ModuleID) = f(m)
-  }
+  protected final def make(f: ModuleID => Boolean) =
+    (m: ModuleID) => f(m)
   final def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean =
     apply(module)
 }
 trait ArtifactFilter extends SubDepFilter[Artifact, ArtifactFilter] {
-  protected final def make(f: Artifact => Boolean) = new ArtifactFilter {
-    def apply(m: Artifact) = f(m)
-  }
+  protected final def make(f: Artifact => Boolean) =
+    (m: Artifact) => f(m)
   final def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean =
     apply(artifact)
 }
 trait ConfigurationFilter extends SubDepFilter[ConfigRef, ConfigurationFilter] {
-  protected final def make(f: ConfigRef => Boolean) = new ConfigurationFilter {
-    def apply(m: ConfigRef) = f(m)
-  }
+  protected final def make(f: ConfigRef => Boolean) =
+    (m: ConfigRef) => f(m)
   final def apply(configuration: ConfigRef, module: ModuleID, artifact: Artifact): Boolean =
     apply(configuration)
 }

tasks-standard/src/main/scala/sbt/std/Streams.scala

@@ -136,9 +136,8 @@ object Streams {
       name: Key => String,
       mkLogger: (Key, PrintWriter) => ManagedLogger,
       mkFactory: File => CacheStoreFactory
-  ): Streams[Key] = new Streams[Key] {
-
-    def apply(a: Key): ManagedStreams[Key] = new ManagedStreams[Key] {
+  ): Streams[Key] = (a: Key) =>
+    new ManagedStreams[Key] {
       private var opened: List[Closeable] = nil
       private var closed = false
 
@@ -216,5 +215,4 @@ object Streams {
         if (closed) sys.error("Streams for '" + name(a) + "' have been closed.")
       }
     }
-  }
 }