Merge pull request #321 from AVSystem/dimplicit

Minimalistic dependency injection with parallel initialization

Author: ghik

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        scala: [2.13.4, 2.12.13]
+        scala: [2.13.4, 2.12.12]
         java: [adopt@1.11]
     runs-on: ${{ matrix.os }}
     steps:
@@ -127,12 +127,12 @@ jobs:
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.12.13)
+      - name: Download target directories (2.12.12)
         uses: actions/download-artifact@v2
         with:
-          name: target-${{ matrix.os }}-2.12.13-${{ matrix.java }}
+          name: target-${{ matrix.os }}-2.12.12-${{ matrix.java }}
 
-      - name: Inflate target directories (2.12.13)
+      - name: Inflate target directories (2.12.12)
         run: |
           tar xf targets.tar
           rm targets.tar

.idea/codeStyles/Project.xml

@@ -53,7 +53,7 @@ inThisBuild(Seq(
     Developer("ghik", "Roman Janusz", "r.janusz@avsystem.com", url("https://github.com/ghik")),
   ),
 
-  crossScalaVersions := Seq("2.13.4", "2.12.13"),
+  crossScalaVersions := Seq("2.13.4", "2.12.12"),
   scalaVersion := crossScalaVersions.value.head,
   compileOrder := CompileOrder.Mixed,
 

build.sbt

@@ -55,7 +55,8 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new CheckBincompat(global),
     new Any2StringAdd(global),
     new ThrowableObjects(global),
-    new DiscardedMonixTask(global)
+    new DiscardedMonixTask(global),
+    new BadSingletonComponent(global)
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap

commons-analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala

@@ -0,0 +1,48 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.annotation.tailrec
+import scala.tools.nsc.Global
+
+class BadSingletonComponent(g: Global) extends AnalyzerRule(g, "badSingletonComponent") {
+
+  import global._
+
+  lazy val componentsTpe: Type = classType("com.avsystem.commons.di.Components")
+  lazy val cachedSym: Symbol = componentsTpe.member(TermName("cached"))
+
+  object UnwrapApply {
+    @tailrec def unapply(tree: Tree): Some[Tree] = tree match {
+      case Apply(fun, _) => unapply(fun)
+      case TypeApply(fun, _) => unapply(fun)
+      case t => Some(t)
+    }
+  }
+
+  object Unwrap {
+    @tailrec def unapply(t: Tree): Some[Tree] = t match {
+      case Block(Nil, expr) => unapply(expr)
+      case Typed(expr, _) => unapply(expr)
+      case Annotated(_, expr) => unapply(expr)
+      case UnwrapApply(Select(prefix, _)) if prefix.tpe =:= t.tpe => unapply(prefix)
+      case _ => Some(t)
+    }
+  }
+
+  def analyze(unit: CompilationUnit): Unit =
+    if (componentsTpe != NoType) {
+      object traverser extends Traverser {
+        override def traverse(tree: Tree): Unit = tree match {
+          case mdef@DefDef(_, _, Nil, Nil, _, Unwrap(app@Apply(_, List(arg, _))))
+            if app.symbol == cachedSym && mdef.symbol.owner.isClass && ThisType(mdef.symbol.owner) <:< componentsTpe =>
+            traverse(arg)
+          case t if t.symbol == cachedSym =>
+            report(t.pos, "singleton(...) macro can only be used as a body of a parameterless method in a Components trait implementation")
+          case _ =>
+            super.traverse(tree)
+        }
+      }
+
+      traverser.traverse(unit.body)
+    }
+}

commons-analyzer/src/main/scala/com/avsystem/commons/analyzer/BadSingletonComponent.scala

@@ -11,6 +11,7 @@ import scala.tools.nsc.{Global, Settings}
 trait AnalyzerTest { this: Assertions =>
   val settings = new Settings
   settings.usejavacp.value = true
+  settings.Yrangepos.value = true
   settings.pluginOptions.value ++= List("AVSystemAnalyzer:+_")
 
   val compiler: Global = new Global(settings) { global =>

commons-analyzer/src/test/scala/com/avsystem/commons/analyzer/AnalyzerTest.scala

@@ -0,0 +1,29 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class BadSingletonComponentTest extends AnyFunSuite with AnalyzerTest {
+  test("general") {
+    assertErrors(5,
+      """
+        |import com.avsystem.commons.di._
+        |
+        |object test extends Components {
+        |  singleton(123)
+        |  val notDef = singleton(123)
+        |  def hasParams(param: Int) = singleton(param)
+        |  def hasTypeParams[T]: Component[T] = singleton(???)
+        |  def outerMethod: Component[Int] = {
+        |    def innerMethod = singleton(123)
+        |    innerMethod
+        |  }
+        |
+        |  def good: Component[Int] = singleton(123)
+        |  def alsoGood: Component[Int] = { singleton(123) }
+        |  def goodAsWell: Component[Int] = singleton(123).dependsOn(good)
+        |}
+      """.stripMargin
+    )
+  }
+}

commons-analyzer/src/test/scala/com/avsystem/commons/analyzer/BadSingletonComponentTest.scala

@@ -55,7 +55,7 @@ abstract class BlockingUtils {
     runAndAwait(task, FiniteDuration(timeout, unit))
 
   def runAndAwait[T](task: Task[T], timeout: Duration): T =
-    Await.result(task.runToFuture, timeout)
+    task.runSyncUnsafe(timeout)
 
   // overloading instead of using default value so that it's usable from Java
   def toIterator[T](observable: Observable[T]): CloseableIterator[T] =

commons-core/jvm/src/main/scala/com/avsystem/commons/concurrent/BlockingUtils.scala

@@ -240,8 +240,14 @@ object SharedExtensionsUtils extends SharedExtensions {
     def stripCommonIndent: String =
       if (str.isEmpty) str
       else {
-        val commonIndentLength = str.linesIterator.map(_.indexWhere(_ != ' ')).min
-        str.linesIterator.map(_.substring(commonIndentLength)).mkString("\n")
+        val commonIndentLength = str.linesIterator
+          .map(l => l.indexWhere(_ != ' '))
+          .map(i => if (i < 0) Int.MaxValue else i)
+          .min
+
+        str.linesIterator
+          .map(l => l.substring(math.min(commonIndentLength, l.length)))
+          .mkString("\n")
       }
   }