Check only stable qual for import prefix

Author: som-snytt

compiler/src/dotty/tools/dotc/transform/CheckUnused.scala

@@ -73,7 +73,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha
         val target = res.dealias.typeSymbol
         resolveUsage(target, target.name, res.importPrefix.skipPackageObject) // case _: T =>
       case _ =>
-    else if tree.qualifier.span.isSynthetic || name.exists(_ != tree.symbol.name) then
+    else if tree.qualifier.span.isSynthetic && tree.qualifier.tpe.isStable || name.exists(_ != tree.symbol.name) then
       if !ignoreTree(tree) then
         resolveUsage(tree.symbol, name, tree.qualifier.tpe)
     else

tests/warn/i22629/BoilerplateResultMappers.scala

@@ -0,0 +1,71 @@
+package neotypes
+package mappers
+
+import model.exceptions.KeyMapperException
+
+@annotation.implicitNotFound("${A} is not a valid type for keys")
+trait KeyMapper[A] { self =>
+
+  /** Encodes a value as a key.
+    *
+    * @param a
+    *   The value to encode.
+    * @tparam A
+    *   The type of the value to encode.
+    * @return
+    *   The key corresponding to that value.
+    */
+  def encodeKey(a: A): String
+
+  /** Decodes a key as a value.
+    *
+    * @param key
+    *   The key to decode.
+    * @tparam A
+    *   The type of the value to decode.
+    * @return
+    *   The value corresponding to that key or an error.
+    */
+  def decodeKey(key: String): Either[KeyMapperException, A]
+
+  /** Creates a new [[KeyMapper]] by providing transformation functions to and from A.
+    *
+    * @param f
+    *   The function to apply before the encoding.
+    * @param g
+    *   The function to apply after the decoding.
+    * @tparam B
+    *   The type of the new [[KeyMapper]]
+    * @return
+    *   A new [[KeyMapper]] for values of type B.
+    */
+  final def imap[B](f: B => A)(g: A => Either[KeyMapperException, B]): KeyMapper[B] = new KeyMapper[B] {
+    override def encodeKey(b: B): String =
+      self.encodeKey(f(b))
+
+    override def decodeKey(key: String): Either[KeyMapperException, B] =
+      self.decodeKey(key).flatMap(g)
+  }
+}
+
+object KeyMapper {
+
+  /** Summons an implicit [[KeyMapper]] already in scope by result type.
+    *
+    * @param mapper
+    *   A [[KeyMapper]] in scope of the desired type.
+    * @tparam A
+    *   The result type of the mapper.
+    * @return
+    *   A [[KeyMapper]] for the given type currently in implicit scope.
+    */
+  def apply[A](implicit mapper: KeyMapper[A]): KeyMapper[A] = mapper
+
+  implicit final val string: KeyMapper[String] = new KeyMapper[String] {
+    override def encodeKey(key: String): String =
+      key
+
+    override def decodeKey(key: String): Either[KeyMapperException, String] =
+      Right(key)
+  }
+}

tests/warn/i22629/KeyMapper.scala

@@ -0,0 +1,221 @@
+package neotypes
+package mappers
+
+import model.query.QueryParam
+
+import org.neo4j.driver.types.{IsoDuration => NeoDuration, Point => NeoPoint}
+
+import java.time.{
+  Duration => JDuration,
+  LocalDate => JDate,
+  LocalDateTime => JDateTime,
+  LocalTime => JTime,
+  Period => JPeriod,
+  OffsetTime => JZTime,
+  ZonedDateTime => JZDateTime
+}
+import java.util.UUID
+import scala.collection.immutable.ArraySeq
+import scala.jdk.CollectionConverters._
+
+@annotation.implicitNotFound("Could not find the ParameterMapper for ${A}")
+sealed trait ParameterMapper[A] { self =>
+
+  /** Casts a Scala value of type A into a valid Neo4j parameter.
+    *
+    * @param scalaValue
+    *   The value to cast.
+    * @tparam A
+    *   The type of the scalaValue.
+    * @return
+    *   The same value casted as a valid Neo4j parameter.
+    */
+  def toQueryParam(scalaValue: A): QueryParam
+
+  /** Creates a new [[ParameterMapper]] by applying a function to a Scala value of type B before casting it using this
+    * mapper.
+    *
+    * @param f
+    *   The function to apply before the cast.
+    * @tparam B
+    *   The input type of the supplied function.
+    * @return
+    *   A new [[ParameterMapper]] for values of type B.
+    */
+  final def contramap[B](f: B => A): ParameterMapper[B] = new ParameterMapper[B] {
+    override def toQueryParam(scalaValue: B): QueryParam =
+      self.toQueryParam(f(scalaValue))
+  }
+}
+
+object ParameterMapper {
+
+  /** Summons an implicit [[ParameterMapper]] already in scope by result type.
+    *
+    * @param mapper
+    *   A [[ParameterMapper]] in scope of the desired type.
+    * @tparam A
+    *   The input type of the mapper.
+    * @return
+    *   A [[ParameterMapper]] for the given type currently in implicit scope.
+    */
+  def apply[A](implicit mapper: ParameterMapper[A]): ParameterMapper[A] = mapper
+
+  /** Constructs a [[ParameterMapper]] that always returns a constant value.
+    *
+    * @param v
+    *   The value to always return.
+    * @tparam A
+    *   The type of the input value.
+    * @return
+    *   A [[ParameterMapper]] that always returns the supplied value.
+    */
+  def const[A](v: AnyRef): ParameterMapper[A] = new ParameterMapper[A] {
+    override def toQueryParam(scalaValue: A): QueryParam = // warn unused explicit parameter
+      QueryParam.tag[AnyRef](v)
+  }
+
+  /** Constructs a [[ParameterMapper]] from a cast function.
+    *
+    * @param f
+    *   The cast function.
+    * @tparam A
+    *   The input type of the cast function.
+    * @return
+    *   a [[ParameterMapper]] that will cast its inputs using the provided function.
+    */
+  private[neotypes] def fromCast[A](f: A => AnyRef): ParameterMapper[A] = new ParameterMapper[A] {
+    override def toQueryParam(scalaValue: A): QueryParam =
+      QueryParam.tag[AnyRef](f(scalaValue))
+  }
+
+  /** Constructs a [[ParameterMapper]] that works like an identity function.
+    *
+    * Many values do not require any mapping to be used as parameters. For those cases, this private helper is useful to
+    * reduce boilerplate.
+    *
+    * @tparam A
+    *   The type of the input value (must be a subtype of [[AnyRef]]).
+    * @return
+    *   A [[ParameterMapper]] that always returns its input unchanged.
+    */
+  private[neotypes] def identity[A <: AnyRef] = new ParameterMapper[A] {
+    override def toQueryParam(scalaValue: A): QueryParam =
+      QueryParam.tag[A](scalaValue)
+  }
+
+  /** A QueryParam is already encoded so all we need to do is return the same value. This instance is useful to pass
+    * heterogeneous Lists and Maps.
+    */
+  implicit final val PassthroughParameterMapper: ParameterMapper[QueryParam] =
+    new ParameterMapper[QueryParam] {
+      override def toQueryParam(param: QueryParam): QueryParam =
+        param
+    }
+
+  implicit final val BooleanParameterMapper: ParameterMapper[Boolean] =
+    ParameterMapper.fromCast(Boolean.box)
+
+  implicit final val ByteArrayParameterMapper: ParameterMapper[Array[Byte]] =
+    ParameterMapper.identity
+
+  implicit final val ByteArraySeqParameterMapper: ParameterMapper[ArraySeq[Byte]] =
+    ByteArrayParameterMapper.contramap(arr => arr.unsafeArray.asInstanceOf[Array[Byte]])
+
+  implicit final val DoubleParameterMapper: ParameterMapper[Double] =
+    ParameterMapper.fromCast(Double.box)
+
+  implicit final val FloatParameterMapper: ParameterMapper[Float] =
+    ParameterMapper.fromCast(Float.box)
+
+  implicit final val IntParameterMapper: ParameterMapper[Int] =
+    ParameterMapper.fromCast(Int.box)
+
+  implicit final val LongParameterMapper: ParameterMapper[Long] =
+    ParameterMapper.fromCast(Long.box)
+
+  implicit final val StringParameterMapper: ParameterMapper[String] =
+    ParameterMapper.identity
+
+  implicit final val UUIDParameterMapper: ParameterMapper[UUID] =
+    ParameterMapper[String].contramap(_.toString)
+
+  implicit final val NeoDurationParameterMapper: ParameterMapper[NeoDuration] =
+    ParameterMapper.identity
+
+  implicit final val NeoPointParameterMapper: ParameterMapper[NeoPoint] =
+    ParameterMapper.identity
+
+  implicit final val JDurationParameterMapper: ParameterMapper[JDuration] =
+    ParameterMapper.identity
+
+  implicit final val JPeriodParameterMapper: ParameterMapper[JPeriod] =
+    ParameterMapper.identity
+
+  implicit final val JDateParameterMapper: ParameterMapper[JDate] =
+    ParameterMapper.identity
+
+  implicit final val JTimeParameterMapper: ParameterMapper[JTime] =
+    ParameterMapper.identity
+
+  implicit final val JDateTimeParameterMapper: ParameterMapper[JDateTime] =
+    ParameterMapper.identity
+
+  implicit final val JZTimeParameterMapper: ParameterMapper[JZTime] =
+    ParameterMapper.identity
+
+  implicit final val JZDateTimeParameterMapper: ParameterMapper[JZDateTime] =
+    ParameterMapper.identity
+
+  private final def iterableParameterMapperImpl[T](mapper: ParameterMapper[T]): ParameterMapper[Iterable[T]] =
+    ParameterMapper.fromCast { col =>
+      col.iterator.map(mapper.toQueryParam).asJava
+    }
+
+  implicit final def iterableParameterMapper[T, C](implicit
+    ev: C <:< Iterable[T],
+    mapper: ParameterMapper[T]
+  ): ParameterMapper[C] =
+    iterableParameterMapperImpl(mapper).contramap(ev)
+
+  implicit final def collectionParameterMapper[T, C[_]](implicit
+    ev: C[T] <:< Iterable[T],
+    mapper: ParameterMapper[T]
+  ): ParameterMapper[C[T]] =
+    iterableParameterMapperImpl(mapper).contramap(ev)
+
+  private final def iterableMapParameterMapperImpl[K, V](
+    keyMapper: KeyMapper[K],
+    valueMapper: ParameterMapper[V]
+  ): ParameterMapper[Iterable[(K, V)]] =
+    ParameterMapper.fromCast { col =>
+      col
+        .iterator
+        .map { case (key, v) =>
+          keyMapper.encodeKey(key) -> valueMapper.toQueryParam(v)
+        }
+        .toMap
+        .asJava
+    }
+
+  implicit final def mapParameterMapper[K, V, M[_, _]](implicit
+    ev: M[K, V] <:< Iterable[(K, V)],
+    keyMapper: KeyMapper[K],
+    valueMapper: ParameterMapper[V]
+  ): ParameterMapper[M[K, V]] =
+    iterableMapParameterMapperImpl(keyMapper, valueMapper).contramap(ev)
+
+  implicit final def optionAnyRefParameterMapper[T](implicit mapper: ParameterMapper[T]): ParameterMapper[Option[T]] =
+    new ParameterMapper[Option[T]] {
+      override def toQueryParam(optional: Option[T]): QueryParam =
+        optional.fold(ifEmpty = QueryParam.NullValue)(mapper.toQueryParam)
+    }
+
+  implicit final def tupleParameterMapper[A, B](implicit
+    aMapper: ParameterMapper[A],
+    bMapper: ParameterMapper[B]
+  ): ParameterMapper[(A, B)] =
+    ParameterMapper[List[QueryParam]].contramap { case (a, b) =>
+      aMapper.toQueryParam(a) :: bMapper.toQueryParam(b) :: Nil
+    }
+}