add EnumerateSingletons - listing all objects extending a sealed trait

Author: cvogt

project/Build.scala

@@ -12,15 +12,10 @@ object MyBuild extends Build{
  description := "Composable Records and type-indexed Maps for Scala",
  libraryDependencies ++= Seq(
  "org.scalatest" %% "scalatest" % "3.0.0-RC4" % "test",
- "org.scala-lang" % "scala-compiler" % scalaVersion.value % "provided"//,
- ) ++
- CrossVersion.partialVersion(scalaVersion.value).collect{
- case (2, 10) =>
- Seq(
- "org.typelevel" %% "macro-compat" % "1.1.0",
- compilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.full)
- )
- }.toSeq.flatten,
+ "org.typelevel" %% "macro-compat" % "1.1.0",
+ "org.scala-lang" % "scala-compiler" % scalaVersion.value % "provided",
+ compilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.full)
+ ),
  scalacOptions ++= Seq("-feature", "-deprecation", "-unchecked"),
  //scalacOptions ++= Seq("-Xprint:patmat", "-Xshow-phases"),
  testOptions in Test += Tests.Argument(TestFrameworks.ScalaTest, "-oFD"),

readme.txt

@@ -3,11 +3,8 @@ http://cvogt.org/scala-extensions/
 
 Contents:
 
-Type-level constraints (org.cvogt.constraints)
-- CaseClass and SingletonObject type classes
-- Comparisons: <:<, =:=, >:>, !=:=, !<:<, !>:>, e.g. String !=:= And
-- Boolean Algebra: True, False, ==, !, &&, ||, Implies, Xor
-- Subset tests: In, NotIn, e.g. Int NotIn (Any,AnyRef,AnyVal)
+Type-level helpers
+- EnumerateSingletons - listing all objects extending a sealed trait
 
 Collection extensions (org.cvogt.collection)
 - distinctBy - remove duplicates by key
@@ -28,6 +25,12 @@ Debug (org.cvogt.scala.debug)
 Type safety
 - safe"..." alternative to s"..." that requires explicit toString conversions rather than implicit
 
+Type-level constraints (org.cvogt.constraints)
+- CaseClass and SingletonObject type classes
+- Comparisons: <:<, =:=, >:>, !=:=, !<:<, !>:>, e.g. String !=:= And
+- Boolean Algebra: True, False, ==, !, &&, ||, Implies, Xor
+- Subset tests: In, NotIn, e.g. Int NotIn (Any,AnyRef,AnyVal)
+
 Others
 - alternative `->` that works as constructor, extractor, type
 

src/main/scala/EnumerateSingletons.scala

@@ -0,0 +1,71 @@
+package org.cvogt.scala
+import scala.reflect.macros.blackbox.Context
+import scala.language.experimental.macros
+import macrocompat.bundle
+
+object EnumerateSingletons {
+ /** singleton objects transitively extending the given class or trait */
+ def apply[A]: Set[A] = macro EnumerateSingletonsMacros.enumerateSingletonsMacros[A]
+}
+
+@bundle
+class EnumerateSingletonsMacros( val c: Context ) {
+ import c.universe._
+ def enumerateSingletonsMacros[T: c.WeakTypeTag]: Tree = {
+ val T = weakTypeOf[T].typeSymbol.asClass
+ val ( subs, verifiers ) = knownTransitiveSubclassesAndVerifiers( T )
+ val (singletons, classes) = subs.partition( _.isModuleClass )
+ val nonClosed = classes.filterNot(_.isSealed).filterNot(_.isFinal)
+ if(nonClosed.nonEmpty){
+ c.error(
+ c.enclosingPosition,
+ "EnumerateSingleton requires all transitive subclasses to be sealed or final. These are not: " ++ nonClosed.mkString(", ")
+ )
+ }
+ val trees = singletons.map( _.module ).map( m => q"$m" )
+ val tree = q"""{
+ ..$verifiers
+ _root_.scala.collection.immutable.Set[$T](..$trees)
+ }"""
+ tree
+ }
+
+ /** Generates a list of all singleton objects extending the given class directly or transitively. */
+ private def knownTransitiveSubclassesAndVerifiers( sym: ClassSymbol ): ( Set[ClassSymbol], List[Tree] ) = {
+ val direct = knownDirectSubclassesAndVerifier( sym )
+ direct._1.map( knownTransitiveSubclassesAndVerifiers ).fold(
+ direct
+ )(
+ ( l, r ) => ( l._1 ++ r._1, l._2 ++ r._2 )
+ )
+ }
+
+ private def knownDirectSubclassesAndVerifier( T: ClassSymbol ): ( Set[ClassSymbol], List[Tree] ) = {
+ val subs = T.knownDirectSubclasses
+
+ // hack to detect breakage of knownDirectSubclasses as suggested in 
+ // https://gitter.im/scala/scala/archives/2015/05/05 and
+ // https://gist.github.com/retronym/639080041e3fecf58ba9
+ val global = c.universe.asInstanceOf[scala.tools.nsc.Global]
+ def checkSubsPostTyper = if ( subs != T.knownDirectSubclasses )
+ c.error(
+ c.macroApplication.pos,
+ s"""No child classes found for $T. If there clearly are child classes,
+Try moving the call lower in the file, into a separate file, a sibbling package, a separate sbt sub project or else.
+This is caused by https://issues.scala-lang.org/browse/SI-7046 and can only be avoided by manually moving the call.
+It is triggered when a macro call happend in a place, where typechecking of $T hasn't been completed yet.
+Completion is required in order to find subclasses.
+"""
+ )
+
+ val checkSubsPostTyperTypTree =
+ new global.TypeTreeWithDeferredRefCheck()( () => { checkSubsPostTyper; global.TypeTree( global.NoType ) } ).asInstanceOf[TypTree]
+
+ val name = TypeName( c.freshName( "VerifyKnownDirectSubclassesPostTyper" ) )
+
+ (
+ subs.map( _.asClass ).toSet,
+ List( q"type ${name} = $checkSubsPostTyperTypTree" )
+ )
+ }
+}

src/test/scala/EnumerateSingletonsTest.scala

@@ -0,0 +1,19 @@
+package org.cvogt.scala.test
+
+import org.cvogt.scala.EnumerateSingletons
+
+import org.scalatest.FunSuite
+
+sealed trait A
+case object B extends A
+sealed trait C extends A
+case object D extends C
+
+class EnumerateSingletonsTest extends FunSuite {
+ test( "works for hierarchies" ) {
+ val s = EnumerateSingletons[A]
+ assert(
+ s === Set[A]( B, D )
+ )
+ }
+}