scalafmtAll

Author: halotukozak

analyzer/src/main/scala/com/avsystem/commons/analyzer/ExplicitGenerics.scala

@@ -9,7 +9,6 @@ class ExplicitGenerics(g: Global) extends AnalyzerRule(g, "explicitGenerics") {
 
   lazy val explicitGenericsAnnotTpe = classType("com.avsystem.commons.annotation.explicitGenerics")
 
-
   private def fail(pos: Position, symbol: Symbol): Unit =
     report(pos, s"$symbol requires that its type arguments are explicit (not inferred)")
 
@@ -30,7 +29,9 @@ class ExplicitGenerics(g: Global) extends AnalyzerRule(g, "explicitGenerics") {
     def analyzeTree(tree: Tree): Unit = analyzer.macroExpandee(tree) match {
       case `tree` | EmptyTree =>
         tree match {
-          case t@TypeApply(pre, args) if requiresExplicitGenerics(pre.symbol) || applyOfAnnotatedCompanion(pre.symbol) =>
+          case t @ TypeApply(pre, args)
+              if requiresExplicitGenerics(pre.symbol) || applyOfAnnotatedCompanion(pre.symbol) =>
+
             val inferredTypeParams = args.forall {
               case tt: TypeTree => tt.original == null || tt.original == EmptyTree
               case _ => false
@@ -40,12 +41,13 @@ class ExplicitGenerics(g: Global) extends AnalyzerRule(g, "explicitGenerics") {
               val targetSym = if (applyOfAnnotatedCompanion(pre.symbol)) pre.symbol.owner.companionClass else pre.symbol
               fail(t.pos, targetSym)
             }
-          case n@New(tpt) if requiresExplicitGenerics(tpt.tpe.typeSymbol) =>
+          case n @ New(tpt) if requiresExplicitGenerics(tpt.tpe.typeSymbol) =>
             val explicitTypeArgsProvided = tpt match {
-              case tt: TypeTree => tt.original match {
-                case AppliedTypeTree(_, args) if args.nonEmpty => true
-                case _ => false
-              }
+              case tt: TypeTree =>
+                tt.original match {
+                  case AppliedTypeTree(_, args) if args.nonEmpty => true
+                  case _ => false
+                }
               case _ => false
             }
             if (!explicitTypeArgsProvided) {

analyzer/src/test/scala/com/avsystem/commons/analyzer/ExplicitGenericsTest.scala

@@ -43,37 +43,38 @@ final class ExplicitGenericsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   test("inferred in constructor should be rejected") {
-    assertErrors(2,
+    assertErrors(
+      2,
       scala"""
              |import com.avsystem.commons.analyzer.TestUtils
              |
              |val x = new TestUtils.GenericClass()
              |val y = new TestUtils.GenericCaseClass(123)
-             |""".stripMargin)
+             |""".stripMargin,
+    )
   }
 
-
   test("inferred in apply when constructor marked should be rejected") {
-    assertErrors(1,
+    assertErrors(
+      1,
       scala"""
              |import com.avsystem.commons.analyzer.TestUtils
              |
              |val x = TestUtils.GenericCaseClass(123)
-             |""".stripMargin)
+             |""".stripMargin,
+    )
   }
 
   test("explicit in constructor should not be rejected") {
-    assertNoErrors(
-      scala"""
+    assertNoErrors(scala"""
              |import com.avsystem.commons.analyzer.TestUtils
              |
              |val x = new TestUtils.GenericClass[Int]()
              |""".stripMargin)
   }
 
   test("not marked should not be rejected") {
-    assertNoErrors(
-      scala"""
+    assertNoErrors(scala"""
              |def method[T](e: T) = e
              |class NotMarkedGenericClass[T]
              |final case class NotMarkedGenericCaseClass[T](arg: T)

analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala

@@ -10,7 +10,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
              |implicit final class GoodImplicitClass(val x: Int) extends AnyVal {
              |  def double: Int = x * 2
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -42,7 +42,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
              |class RegularClass(val x: Int) {
              |  def double: Int = x * 2
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -52,7 +52,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
              |implicit final class ImplicitClassWithImplicitParameter(val x: Int)(implicit dummy: DummyImplicit) {
              |  def double: Int = x * 2
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -69,7 +69,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
              |implicit final class GoodImplicitClass2(val x: Int) extends SomeTrait {
              |  def double: Int = x * 2
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -89,8 +89,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
   }
 
   test("nested implicit class not extending AnyVal should pass") {
-    assertNoErrors(
-      scala"""
+    assertNoErrors(scala"""
              |class Outer {
              |  implicit final class NestedImplicitClass(val x: Int) {
              |    def double: Int = x * 2
@@ -105,7 +104,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
              |implicit final class ValueClass(x: com.avsystem.commons.misc.Timestamp) {
              |  def sth: Long = x.millis
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -116,7 +115,7 @@ final class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
              |implicit final class LazyValueClassOps(lvc: => ValueClass) {
              |  def someOp: Int = lvc.underlying
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -194,7 +193,7 @@ final class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTes
              |class RegularClass(val x: Int) {
              | def double: Int = x * 2
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }
 
@@ -213,7 +212,7 @@ final class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTes
              |   def double: Int = x * 2
              | }
              |}
-             |""".stripMargin,
+             |""".stripMargin
     )
   }