Change everyItem, everyMapKey and everyMapValue implementation in Sca…

…la 3 to something which works better in IDE, add compileTimeOnly/inline+compiletime.error for DSL methods intended to use only within DSL

chimney/src/main/scala-2/io/scalaland/chimney/syntax/package.scala

@@ -2,7 +2,7 @@ package io.scalaland.chimney
 
 import io.scalaland.chimney.internal.runtime.{IsCollection, IsEither, IsMap, IsOption}
 
-import scala.annotation.unused
+import scala.annotation.{compileTimeOnly, unused}
 import scala.util.Try
 
 /** Imports only extension methods for summoning and using Transformer, PartialTransformer or Patcher
@@ -181,34 +181,38 @@ package object syntax {
  partial.Result.fromTry(`try`)
  }
 
+ // $COVERAGE-OFF$methods used only within macro-erased expressions
+
  // TODO: docs
  implicit final class TransformationMatchingPathOps[A](@unused private val a: A) extends AnyVal {
 
- def matching[B <: A]: B =
-  sys.error(".matching should be only called within Chimney DSL")
+ @compileTimeOnly(".matching should be only called within Chimney DSL")
+ def matching[B <: A]: B = sys.error("")
 
- def matchingSome[SV, S](implicit @unused ev: IsOption.Of[A, SV, S]): SV =
-  sys.error(".matchingSome should be only called within Chimney DSL")
+ @compileTimeOnly(".matchingSome should be only called within Chimney DSL")
+ def matchingSome[SV, S](implicit @unused ev: IsOption.Of[A, SV, S]): SV = sys.error("")
 
- def matchingLeft[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): LV =
-  sys.error(".matchingLeft should be only called within Chimney DSL")
+ @compileTimeOnly(".matchingLeft should be only called within Chimney DSL")
+ def matchingLeft[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): LV = sys.error("")
 
- def matchingRight[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): RV =
-  sys.error(".matchingRight should be only called within Chimney DSL")
+ @compileTimeOnly(".matchingRight should be only called within Chimney DSL")
+ def matchingRight[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): RV = sys.error("")
  }
 
  implicit final class TransformationCollectionPathOps[C[_], I](@unused private val cc: C[I]) extends AnyVal {
 
- def everyItem(implicit @unused ev: IsCollection.Of[C[I], I]): I =
-  sys.error(".everyItem should be only called within Chimney DSL")
+ @compileTimeOnly(".everyItem should be only called within Chimney DSL")
+ def everyItem(implicit @unused ev: IsCollection.Of[C[I], I]): I = sys.error("")
  }
 
  implicit final class TransformationMapPathOps[M[_, _], K, V](@unused private val cc: M[K, V]) extends AnyVal {
 
- def everyMapKey(implicit @unused ev: IsMap.Of[M[K, V], K, V]): K =
-  sys.error(".everyMapKey should be only called within Chimney DSL")
+ @compileTimeOnly(".everyMapKey should be only called within Chimney DSL")
+ def everyMapKey(implicit @unused ev: IsMap.Of[M[K, V], K, V]): K = sys.error("")
 
- def everyMapValue(implicit @unused ev: IsMap.Of[M[K, V], K, V]): V =
-  sys.error(".everyMapValue should be only called within Chimney DSL")
+ @compileTimeOnly(".everyMapValue should be only called within Chimney DSL")
+ def everyMapValue(implicit @unused ev: IsMap.Of[M[K, V], K, V]): V = sys.error("")
  }
+
+ // $COVERAGE-ON$
 }

chimney/src/main/scala-3/io/scalaland/chimney/internal/compiletime/dsl/utils/DslMacroUtils.scala

@@ -21,7 +21,7 @@
  private object IsOptionOf {
  def unapply(term: Term): Option[(ExistentialType, ExistentialType, ExistentialType)] = term.tpe.asType match {
  case '[runtime.IsOption.Of[o, sv, s]] => Some((ExistentialType[o], ExistentialType[sv], ExistentialType[s]))
  case _ => None
  }
  }
 
@@ -32,7 +32,7 @@
  term.tpe.asType match {
  case '[runtime.IsEither.Of[e, lv, rv, l, r]] =>
  Some((ExistentialType[e], ExistentialType[lv], ExistentialType[rv], ExistentialType[l], ExistentialType[r]))
  case _ => None
  }
  }
 
@@ -40,7 +40,7 @@
  def unapply(term: Term): Option[(ExistentialType, ExistentialType)] =
  term.tpe.asType match {
  case '[runtime.IsCollection.Of[c, a]] => Some((ExistentialType[c], ExistentialType[a]))
  case _ => None
  }
  }
 
@@ -48,7 +48,7 @@
  def unapply(term: Term): Option[(ExistentialType, ExistentialType, ExistentialType)] =
  term.tpe.asType match {
  case '[runtime.IsMap.Of[m, k, v]] => Some((ExistentialType[m], ExistentialType[k], ExistentialType[v]))
  case _ => None
  }
  }
 
@@ -155,7 +155,7 @@
  }
  }
  // matches `.everyItem`
- case Apply(TypeApply(Apply(TypeApply(Ident("everyItem"), _), List(t2)), _), List(IsCollectionOf(_, _))) =>
+ case Apply(Apply(TypeApply(Ident("everyItem"), _), List(t2)), List(IsCollectionOf(_, _))) =>
  unpackSelects(t2).map { init =>
  import init.Underlying as Init
  new ExistentialPath {
@@ -164,7 +164,7 @@
  }
  }
  // matches `.everyMapKey`
- case Apply(TypeApply(Apply(TypeApply(Ident("everyMapKey"), _), List(t2)), _), List(IsMapOf(_, _, _))) =>
+ case Apply(Apply(TypeApply(Ident("everyMapKey"), _), List(t2)), List(IsMapOf(_, _, _))) =>
  unpackSelects(t2).map { init =>
  import init.Underlying as Init
  new ExistentialPath {
@@ -173,7 +173,7 @@
  }
  }
  // matches `.everyMapValue`
- case Apply(TypeApply(Apply(TypeApply(Ident("everyMapValue"), _), List(t2)), _), List(IsMapOf(_, _, _))) =>
+ case Apply(Apply(TypeApply(Ident("everyMapValue"), _), List(t2)), List(IsMapOf(_, _, _))) =>
  unpackSelects(t2).map { init =>
  import init.Underlying as Init
  new ExistentialPath {
@@ -191,7 +191,6 @@
  }
 
  private def invalidSelectorErrorMessage(t: Tree): String =
- println(t.show(using Printer.TreeStructure))
  s"Invalid selector expression: ${t.show(using Printer.TreeAnsiCode)}"
 
  private def arbitraryFunctionNotAllowed(t: Tree): String =

chimney/src/main/scala-3/io/scalaland/chimney/syntax/syntax.scala

@@ -3,7 +3,7 @@ package io.scalaland.chimney.syntax
 import io.scalaland.chimney.{partial, PartialTransformer, Patcher, Transformer}
 import io.scalaland.chimney.internal.runtime.{IsCollection, IsEither, IsMap, IsOption}
 
-import scala.annotation.unused
+import scala.annotation.{compileTimeOnly, unused}
 import scala.util.Try
 
 // Extension methods in dsl.* summon TypeClass.AutoDerived while extension methods in syntax.* summon TypeClass.
@@ -175,27 +175,36 @@ extension [T](`try`: Try[T]) {
  partial.Result.fromTry(`try`)
 }
 
+// $COVERAGE-OFF$methods used only within macro-erased expressions
+
 // TODO docs
 extension [A](@unused a: A) {
 
- def matching[B <: A]: B =
- sys.error(".matching should be only called within Chimney DSL")
+ inline def matching[B <: A]: B = compiletime.error(".matching should be only called within Chimney DSL")
+
+ inline def matchingSome[SV, S](implicit @unused ev: IsOption.Of[A, SV, S]): SV =
+ compiletime.error(".matchingSome should be only called within Chimney DSL")
+
+ inline def matchingLeft[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): LV =
+ compiletime.error(".matchingLeft should be only called within Chimney DSL")
 
- def matchingSome[SV, S](implicit @unused ev: IsOption.Of[A, SV, S]): SV =
- sys.error(".matchingSome should be only called within Chimney DSL")
+ inline def matchingRight[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): RV =
+ compiletime.error(".matchingRight should be only called within Chimney DSL")
+}
 
- def matchingLeft[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): LV =
- sys.error(".matchingLeft should be only called within Chimney DSL")
+extension [C[_], I](@unused cc: C[I]) {
 
- def matchingRight[LV, RV, L, R](implicit @unused ev: IsEither.Of[A, LV, RV, L, R]): RV =
- sys.error(".matchingRight should be only called within Chimney DSL")
+ inline def everyItem(implicit @unused ev: IsCollection.Of[C[I], I]): I =
+ compiletime.error(".everyItem should be only called within Chimney DSL")
+}
 
- def everyItem[I](implicit @unused ev: IsCollection.Of[A, I]): I =
- sys.error(".everyItem should be only called within Chimney DSL")
+extension [M[_, _], K, V](@unused cc: M[K, V]) {
 
- def everyMapKey[K, V](implicit @unused ev: IsMap.Of[A, K, V]): K =
- sys.error(".everyMapKey should be only called within Chimney DSL")
+ inline def everyMapKey(implicit @unused ev: IsMap.Of[M[K, V], K, V]): K =
+ compiletime.error(".everyMapKey should be only called within Chimney DSL")
 
- def everyMapValue[K, V](implicit @unused ev: IsMap.Of[A, K, V]): V =
- sys.error(".everyMapValue should be only called within Chimney DSL")
+ inline def everyMapValue(implicit @unused ev: IsMap.Of[M[K, V], K, V]): V =
+ compiletime.error(".everyMapValue should be only called within Chimney DSL")
 }
+
+// $COVERAGE-ON$

chimney/src/test/scala/io/scalaland/chimney/TotalTransformerProductSpec.scala

@@ -4,6 +4,7 @@ import io.scalaland.chimney.dsl.*
 import io.scalaland.chimney.fixtures.*
 
 import scala.annotation.unused
+import scala.collection.immutable.ListMap
 
 class TotalTransformerProductSpec extends ChimneySpec {
 
@@ -158,17 +159,13 @@ class TotalTransformerProductSpec extends ChimneySpec {
  .withFieldComputed(_.value.age, _.getValue.age * 2)
  .transform ==> NestedProduct(User("John", 20, 140))
 
- val _ = implicitly[io.scalaland.chimney.internal.runtime.IsOption[Option[User]]]
  NestedComplex(
  Some(Person("John", 10, 140)),
  Right(Person("John", 10, 140)),
  List(Person("John", 10, 140)),
- scala.collection.immutable.ListMap(Person("John", 10, 140) -> Person("John", 10, 140))
+ ListMap(Person("John", 10, 140) -> Person("John", 10, 140))
  ).into[NestedComplex[User]]
- .withFieldComputed(
- _.option.matchingSome(io.scalaland.chimney.internal.runtime.IsOption.optionIsOption).age,
- _ => 15
- )
+ .withFieldComputed(_.option.matchingSome.age, _ => 15)
  .withFieldComputed(_.either.matchingLeft.age, _ => 20)
  .withFieldComputed(_.either.matchingRight.age, _ => 30)
  .withFieldComputed(_.collection.everyItem.age, _ => 40)
@@ -178,7 +175,7 @@ class TotalTransformerProductSpec extends ChimneySpec {
  Some(User("John", 15, 140)),
  Right(User("John", 30, 140)),
  List(User("John", 40, 140)),
- scala.collection.immutable.ListMap(User("John", 50, 140) -> User("John", 60, 140))
+ ListMap(User("John", 50, 140) -> User("John", 60, 140))
  )
 
  List[NestedADT[Person]](NestedADT.Foo(Person("John", 10, 140)), NestedADT.Bar(Person("John", 10, 140)))