Build Logs
zio/izumi-reflect • 3.8.0-RC6:2026-01-08
Errors
0
Warnings
79
Total Lines
1682
1##################################
2Clonning https://github.com/zio/izumi-reflect.git into /build/repo using revision v3.0.9
3##################################
4Note: switching to 'd41efc92620075c03dd82c29478870b0f333c365'.
5
6You are in 'detached HEAD' state. You can look around, make experimental
7changes and commit them, and you can discard any commits you make in this
8state without impacting any branches by switching back to a branch.
9
10If you want to create a new branch to retain commits you create, you may
11do so (now or later) by using -c with the switch command. Example:
12
13 git switch -c <new-branch-name>
14
15Or undo this operation with:
16
17 git switch -
18
19Turn off this advice by setting config variable advice.detachedHead to false
20
21Using target Scala version for migration: 3.7.4
22Migrating project for -source:3.5 using Scala 3.7.4
23----
24Preparing build for 3.7.4
25Would try to apply common scalacOption (best-effort, sbt/mill only):
26Append: -rewrite,REQUIRE:-source:3.5-migration
27Remove: -indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e
28----
29Starting build for 3.7.4
30Execute tests: false
31sbt project found:
32Sbt version 1.11.2 is not supported, minimal supported version is 1.11.5
33Enforcing usage of sbt in version 1.11.5
34No prepare script found for project zio/izumi-reflect
35##################################
36Scala version: 3.7.4
37Targets: dev.zio%izumi-reflect dev.zio%izumi-reflect-thirdparty-boopickle-shaded
38Project projectConfig: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"21"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"compile-only","migrationVersions":["3.5"],"sourcePatches":[]}
39##################################
40Using extra scalacOptions: -rewrite,REQUIRE:-source:3.5-migration
41Filtering out scalacOptions: -indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e
42[sbt_options] declare -a sbt_options=()
43[process_args] java_version = '21'
44[copyRt] java9_rt = '/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_21/rt.jar'
45# Executing command line:
46java
47-Xmx8G
48-XX:ReservedCodeCacheSize=256m
49-XX:MaxMetaspaceSize=3G
50-XX:+OmitStackTraceInFastThrow
51-XX:SoftRefLRUPolicyMSPerMB=50
52-Dsun.io.useCanonCaches=false
53-server
54-XX:+UseG1GC
55-XX:MaxInlineLevel=18
56-Dcommunitybuild.scala=3.7.4
57-Dcommunitybuild.project.dependencies.add=
58-Xmx7G
59-Xms4G
60-Xss8M
61-Dsbt.script=/root/.sdkman/candidates/sbt/current/bin/sbt
62-Dscala.ext.dirs=/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_21
63-jar
64/root/.sdkman/candidates/sbt/1.11.5/bin/sbt-launch.jar
65"setCrossScalaVersions 3.7.4"
66"++3.7.4 -v"
67"mapScalacOptions "-rewrite,REQUIRE:-source:3.5-migration,-Wconf:msg=can be rewritten automatically under:s" "-indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e""
68"set every credentials := Nil"
69"excludeLibraryDependency com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}"
70"removeScalacOptionsStartingWith -P:wartremover"
71
72moduleMappings
73"runBuild 3.7.4 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"21"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"compile-only","migrationVersions":["3.5"],"sourcePatches":[]}""" dev.zio%izumi-reflect dev.zio%izumi-reflect-thirdparty-boopickle-shaded"
74
75[info] welcome to sbt 1.11.5 (Eclipse Adoptium Java 21)
76[info] loading project definition from /build/repo/project/project
77[info] compiling 1 Scala source to /build/repo/project/project/target/scala-2.12/sbt-1.0/classes ...
78[info] Non-compiled module 'compiler-bridge_2.12' for Scala 2.12.20. Compiling...
79[info] Compilation completed in 8.128s.
80[info] done compiling
81[info] loading settings for project repo-build from akka.sbt, plugins.sbt...
82[info] loading project definition from /build/repo/project
83[info] compiling 4 Scala sources to /build/repo/project/target/scala-2.12/sbt-1.0/classes ...
84[info] done compiling
85/build/repo/build.sbt:665: warning: method useGpg in object autoImport is deprecated (since 2.0.0): useGpg is true by default; Bouncy Castle mode is deprecated
86 ThisBuild / useGpg := false,
87 ^
88[info] loading settings for project izumi-reflect-root from build.sbt, version.sbt...
89[info] resolving key references (15926 settings) ...
90[info] set current project to izumi-reflect-root (in build file:/build/repo/)
91[warn] there's a key that's not used by any other settings/tasks:
92[warn]
93[warn] * ThisBuild / useGpg
94[warn] +- /build/repo/build.sbt:665
95[warn]
96[warn] note: a setting might still be used by a command; to exclude a key from this `lintUnused` check
97[warn] either append it to `Global / excludeLintKeys` or call .withRank(KeyRanks.Invisible) on the key
98Execute setCrossScalaVersions: 3.7.4
99OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflect-thirdparty-boopickle-shadedNative/crossScalaVersions
100OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflect-root-js/crossScalaVersions
101OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflect-root-native/crossScalaVersions
102OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflectNative/crossScalaVersions
103OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflect-thirdparty-boopickle-shadedJVM/crossScalaVersions
104OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflectJVM/crossScalaVersions
105OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflectJS/crossScalaVersions
106OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflect-thirdparty-boopickle-shadedJS/crossScalaVersions
107OpenCB::Changing crossVersion 3.3.6 -> 3.7.4 in izumi-reflect-root-jvm/crossScalaVersions
108OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate/crossScalaVersions
109OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-root/crossScalaVersions
110OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate-js/crossScalaVersions
111OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate-jvm/crossScalaVersions
112OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate-native/crossScalaVersions
113[info] set current project to izumi-reflect-root (in build file:/build/repo/)
114[info] Setting Scala version to 3.7.4 on 9 projects.
115[info] Switching Scala version on:
116[info] izumi-reflect-root-jvm (3.7.4, 2.13.14, 2.12.20, 2.11.12)
117[info] izumi-reflect-thirdparty-boopickle-shadedJVM (3.7.4, 2.13.14, 2.12.20, 2.11.12)
118[info] izumi-reflect-thirdparty-boopickle-shadedJS (3.7.4, 2.13.14, 2.12.20)
119[info] izumi-reflectJVM (3.7.4, 2.13.14, 2.12.20, 2.11.12)
120[info] izumi-reflectJS (3.7.4, 2.13.14, 2.12.20)
121[info] izumi-reflect-root-js (3.7.4, 2.13.14, 2.12.20, 2.11.12)
122[info] izumi-reflect-root-native (3.7.4, 2.13.14, 2.12.20, 2.11.12)
123[info] izumi-reflectNative (3.7.4, 2.13.14, 2.12.20)
124[info] izumi-reflect-thirdparty-boopickle-shadedNative (3.7.4, 2.13.14, 2.12.20)
125[info] Excluding projects:
126[info] izumi-reflect-aggregate-native (2.12.20)
127[info] izumi-reflect-aggregate (2.12.20)
128[info] izumi-reflect-aggregate-js (2.12.20)
129[info] * izumi-reflect-root (2.12.20)
130[info] izumi-reflect-aggregate-jvm (2.12.20)
131[info] Reapplying settings...
132[info] set current project to izumi-reflect-root (in build file:/build/repo/)
133Execute mapScalacOptions: -rewrite,REQUIRE:-source:3.5-migration,-Wconf:msg=can be rewritten automatically under:s -indent,-no-indent,-new-syntax,,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e
134[info] Reapplying settings...
135[info] set current project to izumi-reflect-root (in build file:/build/repo/)
136[info] Defining Global / credentials, ThisBuild / credentials and 13 others.
137[info] The new values will be used by Global / pgpSelectPassphrase, Global / pgpSigningKey and 70 others.
138[info] Run `last` for details.
139[info] Reapplying settings...
140[info] set current project to izumi-reflect-root (in build file:/build/repo/)
141Execute excludeLibraryDependency: com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}
142[info] Reapplying settings...
143OpenCB::Failed to reapply settings in excludeLibraryDependency: Reference to undefined setting:
144
145 Global / allExcludeDependencies from Global / allExcludeDependencies (CommunityBuildPlugin.scala:331)
146 Did you mean izumi-reflect-thirdparty-boopickle-shadedJVM / allExcludeDependencies ?
147 , retry without global scopes
148[info] Reapplying settings...
149[info] set current project to izumi-reflect-root (in build file:/build/repo/)
150Execute removeScalacOptionsStartingWith: -P:wartremover
151[info] Reapplying settings...
152[info] set current project to izumi-reflect-root (in build file:/build/repo/)
153[success] Total time: 0 s, completed Jan 8, 2026, 2:26:00 AM
154Build config: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"21"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"compile-only","migrationVersions":["3.5"],"sourcePatches":[]}
155Parsed config: Success(ProjectBuildConfig(ProjectsConfig(List(),Map()),CompileOnly,List()))
156Starting build...
157Projects: Set(izumi-reflectJVM, izumi-reflect-thirdparty-boopickle-shadedJVM)
158Starting build for ProjectRef(file:/build/repo/,izumi-reflectJVM) (izumi-reflect)... [0/2]
159OpenCB::Exclude Scala3 specific scalacOption `-rewrite` in Scala 2.12.20 module Global
160OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.5-migration` in Scala 2.12.20 module Global
161OpenCB::Exclude Scala3 specific scalacOption `-rewrite` in Scala 2.12.20 module Scope(Select(BuildRef(file:/build/repo/)), Zero, Zero, Zero)
162OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.5-migration` in Scala 2.12.20 module Scope(Select(BuildRef(file:/build/repo/)), Zero, Zero, Zero)
163OpenCB::Filter out '-feature', matches setting pattern '^-?-feature'
164OpenCB::Filter out '-deprecation', matches setting pattern '^-?-deprecation'
165OpenCB::Filter out '-no-indent', matches setting pattern '^-?-no-indent'
166Compile scalacOptions: -encoding, UTF-8, -unchecked, -language:higherKinds, -Ykind-projector, -language:implicitConversions, -rewrite, -Wconf:msg=can be rewritten automatically under:s, -source:3.5-migration
167[info] compiling 16 Scala sources to /build/repo/izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.jvm/target/scala-3.7.4/classes ...
168[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
169[info] [patched file /build/repo/izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/Pickler.scala]
170[info] [patched file /build/repo/izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala-2.13+/izumi/reflect/thirdparty/internal/boopickle/XCompat.scala]
171[info] [patched file /build/repo/izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/src/main/scala/izumi/reflect/thirdparty/internal/boopickle/CompositePicklers.scala]
172[warn] there were 2 deprecation warnings; re-run with -deprecation for details
173[warn] two warnings found
174[info] done compiling
175[info] compiling 31 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/classes ...
176[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
177[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LightTypeTagInheritance.scala]
178[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LightTypeTagRef.scala]
179[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/internal/fundamentals/platform/assertions/IzAssert.scala]
180[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LTTRenderables.scala]
181[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/internal/fundamentals/collections/package.scala]
182[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala-3/izumi/reflect/Tags.scala]
183[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala-3/izumi/reflect/dottyreflection/ReflectionUtil.scala]
184[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LTTSyntax.scala]
185[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala-3/izumi/reflect/TagMacro.scala]
186[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LightTypeTag.scala]
187[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LTTOrdering.scala]
188[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/internal/fundamentals/platform/console/TrivialLogger.scala]
189[warn] one warning found
190[info] done compiling
191[info] compiling 3 Scala sources to /build/repo/izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.jvm/target/scala-3.7.4/classes ...
192[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
193[warn] there were 2 deprecation warnings; re-run with -deprecation for details
194[warn] two warnings found
195[info] done compiling
196[info] compiling 12 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/classes ...
197[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
198[warn] one warning found
199[info] done compiling
200[info] compiling 6 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/classes ...
201[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
202[warn] two warnings found
203[info] done compiling
204[info] compiling 7 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/classes ...
205[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
206[warn] three warnings found
207[info] done compiling
208[info] compiling 25 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/test-classes ...
209[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
210[warn] -- Warning: /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagProgressionTest.scala:147:84
211[warn] 147 | def mk[F[+_, +_]: TagKK, G[+_, +_]: TagKK] = Tag[IntersectionBlockingIO[F, G]]
212[warn] | ^
213[warn] |TODO: Pathological intersection refinement result in lambda being reconstructed result=`F[E, A] & G[A, E]` in the rhs of type lambda lam=`[R >: scala.Nothing <: scala.Any, E >: scala.Nothing <: scala.Any, A >: scala.Nothing <: scala.Any] =>> F[E, A] & G[A, E]`
214[warn] |Only simple applied types of form F[A] are supported in results of type lambdas. The generated tag will not work correctly.
215[warn] |---------------------------------------------------------------------------
216[warn] |Inline stack trace
217[warn] |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
218[warn] |This location contains code that was inlined from SharedTagProgressionTest.scala:147
219[warn] 147 | def mk[F[+_, +_]: TagKK, G[+_, +_]: TagKK] = Tag[IntersectionBlockingIO[F, G]]
220[warn] | ^
221[warn] ---------------------------------------------------------------------------
222[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/LightTypeTagTest.scala]
223[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/DottyRegressionTests.scala]
224[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagProgressionTest.scala]
225[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/TagTest.scala]
226[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagTest.scala]
227[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/InheritedModel.scala]
228[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedLightTypeTagTest.scala]
229[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedLightTypeTagProgressionTest.scala]
230[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/TagAssertions.scala]
231[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/TestModel.scala]
232[warn] two warnings found
233[info] done compiling
234[info] compiling 10 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/test-classes ...
235[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
236[warn] -- Warning: /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagProgressionTest.scala:147:84
237[warn] 147 | def mk[F[+_, +_]: TagKK, G[+_, +_]: TagKK] = Tag[IntersectionBlockingIO[F, G]]
238[warn] | ^
239[warn] |TODO: Pathological intersection refinement result in lambda being reconstructed result=`F[E, A] & G[A, E]` in the rhs of type lambda lam=`[R >: scala.Nothing <: scala.Any, E >: scala.Nothing <: scala.Any, A >: scala.Nothing <: scala.Any] =>> F[E, A] & G[A, E]`
240[warn] |Only simple applied types of form F[A] are supported in results of type lambdas. The generated tag will not work correctly.
241[warn] |---------------------------------------------------------------------------
242[warn] |Inline stack trace
243[warn] |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
244[warn] |This location contains code that was inlined from SharedTagProgressionTest.scala:147
245[warn] 147 | def mk[F[+_, +_]: TagKK, G[+_, +_]: TagKK] = Tag[IntersectionBlockingIO[F, G]]
246[warn] | ^
247[warn] ---------------------------------------------------------------------------
248[warn] two warnings found
249[info] done compiling
250[info] compiling 25 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.7.4/test-classes ...
251[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
252[warn] three warnings found
253[info] done compiling
254Starting build for ProjectRef(file:/build/repo/,izumi-reflect-thirdparty-boopickle-shadedJVM) (izumi-reflect-thirdparty-boopickle-shaded)... [1/2]
255Compile scalacOptions: -encoding, UTF-8, -unchecked, -language:higherKinds, -Ykind-projector, -language:implicitConversions, -rewrite, -Wconf:msg=can be rewritten automatically under:s, -source:3.5-migration
256
257************************
258Build summary:
259[{
260 "module": "izumi-reflect",
261 "compile": {"status": "ok", "tookMs": 14950, "warnings": 0, "errors": 0, "sourceVersion": "3.5-migration"},
262 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},
263 "test-compile": {"status": "ok", "tookMs": 19317, "warnings": 1, "errors": 0, "sourceVersion": "3.5-migration"},
264 "test": {"status": "skipped", "tookMs": 0, "passed": 0, "failed": 0, "ignored": 0, "skipped": 0, "total": 0, "byFramework": []},
265 "publish": {"status": "skipped", "tookMs": 0},
266 "metadata": {
267 "crossScalaVersions": ["3.3.6", "2.13.14", "2.12.20", "2.11.12"]
268}
269},{
270 "module": "izumi-reflect-thirdparty-boopickle-shaded",
271 "compile": {"status": "ok", "tookMs": 44, "warnings": 0, "errors": 0, "sourceVersion": "3.5-migration"},
272 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},
273 "test-compile": {"status": "ok", "tookMs": 90, "warnings": 0, "errors": 0, "sourceVersion": "3.5-migration"},
274 "test": {"status": "skipped", "tookMs": 0, "passed": 0, "failed": 0, "ignored": 0, "skipped": 0, "total": 0, "byFramework": []},
275 "publish": {"status": "skipped", "tookMs": 0},
276 "metadata": {
277 "crossScalaVersions": ["3.3.6", "2.13.14", "2.12.20", "2.11.12"]
278}
279}]
280************************
281[success] Total time: 49 s, completed Jan 8, 2026, 2:26:49 AM
282[0JChecking patch project/plugins.sbt...
283Checking patch project/build.properties...
284Checking patch build.sbt...
285Applied patch project/plugins.sbt cleanly.
286Applied patch project/build.properties cleanly.
287Applied patch build.sbt cleanly.
288Commit migration rewrites
289Switched to a new branch 'opencb/migrate-source-3.5'
290[opencb/migrate-source-3.5 de51310] Apply Scala compiler rewrites using -source:3.5-migration using Scala 3.7.4
291 25 files changed, 246 insertions(+), 246 deletions(-)
292----
293Preparing build for 3.8.0-RC6
294Scala binary version found: 3.8
295Implicitly using source version 3.8
296Scala binary version found: 3.8
297Implicitly using source version 3.8
298Would try to apply common scalacOption (best-effort, sbt/mill only):
299Append: ,REQUIRE:-source:3.8
300Remove: ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e
301----
302Starting build for 3.8.0-RC6
303Execute tests: true
304sbt project found:
305Sbt version 1.11.2 is not supported, minimal supported version is 1.11.5
306Enforcing usage of sbt in version 1.11.5
307No prepare script found for project zio/izumi-reflect
308##################################
309Scala version: 3.8.0-RC6
310Targets: dev.zio%izumi-reflect dev.zio%izumi-reflect-thirdparty-boopickle-shaded
311Project projectConfig: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"21"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":["3.5"],"sourcePatches":[]}
312##################################
313Using extra scalacOptions: ,REQUIRE:-source:3.8
314Filtering out scalacOptions: ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e
315[sbt_options] declare -a sbt_options=()
316[process_args] java_version = '21'
317[copyRt] java9_rt = '/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_21/rt.jar'
318# Executing command line:
319java
320-Xmx8G
321-XX:ReservedCodeCacheSize=256m
322-XX:MaxMetaspaceSize=3G
323-XX:+OmitStackTraceInFastThrow
324-XX:SoftRefLRUPolicyMSPerMB=50
325-Dsun.io.useCanonCaches=false
326-server
327-XX:+UseG1GC
328-XX:MaxInlineLevel=18
329-Dcommunitybuild.scala=3.8.0-RC6
330-Dcommunitybuild.project.dependencies.add=
331-Xmx7G
332-Xms4G
333-Xss8M
334-Dsbt.script=/root/.sdkman/candidates/sbt/current/bin/sbt
335-Dscala.ext.dirs=/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_21
336-jar
337/root/.sdkman/candidates/sbt/1.11.5/bin/sbt-launch.jar
338"setCrossScalaVersions 3.8.0-RC6"
339"++3.8.0-RC6 -v"
340"mapScalacOptions ",REQUIRE:-source:3.8,-Wconf:msg=can be rewritten automatically under:s" ",-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e""
341"set every credentials := Nil"
342"excludeLibraryDependency com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}"
343"removeScalacOptionsStartingWith -P:wartremover"
344
345moduleMappings
346"runBuild 3.8.0-RC6 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"21"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":["3.5"],"sourcePatches":[]}""" dev.zio%izumi-reflect dev.zio%izumi-reflect-thirdparty-boopickle-shaded"
347
348[info] welcome to sbt 1.11.5 (Eclipse Adoptium Java 21)
349[info] loading project definition from /build/repo/project/project
350[info] loading settings for project repo-build from akka.sbt, plugins.sbt...
351[info] loading project definition from /build/repo/project
352[info] loading settings for project izumi-reflect-root from build.sbt, version.sbt...
353[info] resolving key references (15926 settings) ...
354[info] set current project to izumi-reflect-root (in build file:/build/repo/)
355[warn] there's a key that's not used by any other settings/tasks:
356[warn]
357[warn] * ThisBuild / useGpg
358[warn] +- /build/repo/build.sbt:665
359[warn]
360[warn] note: a setting might still be used by a command; to exclude a key from this `lintUnused` check
361[warn] either append it to `Global / excludeLintKeys` or call .withRank(KeyRanks.Invisible) on the key
362Execute setCrossScalaVersions: 3.8.0-RC6
363OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflect-thirdparty-boopickle-shadedNative/crossScalaVersions
364OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflect-thirdparty-boopickle-shadedJVM/crossScalaVersions
365OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflect-root-js/crossScalaVersions
366OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflectNative/crossScalaVersions
367OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflect-root-native/crossScalaVersions
368OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflectJVM/crossScalaVersions
369OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflectJS/crossScalaVersions
370OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflect-thirdparty-boopickle-shadedJS/crossScalaVersions
371OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC6 in izumi-reflect-root-jvm/crossScalaVersions
372OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate/crossScalaVersions
373OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-root/crossScalaVersions
374OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate-js/crossScalaVersions
375OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate-jvm/crossScalaVersions
376OpenCB::Limitting incorrect crossVersions List() -> List(2.12.20) in izumi-reflect-aggregate-native/crossScalaVersions
377[info] set current project to izumi-reflect-root (in build file:/build/repo/)
378[info] Setting Scala version to 3.8.0-RC6 on 9 projects.
379[info] Switching Scala version on:
380[info] izumi-reflect-root-jvm (3.8.0-RC6, 2.13.14, 2.12.20, 2.11.12)
381[info] izumi-reflect-thirdparty-boopickle-shadedJVM (3.8.0-RC6, 2.13.14, 2.12.20, 2.11.12)
382[info] izumi-reflect-thirdparty-boopickle-shadedJS (3.8.0-RC6, 2.13.14, 2.12.20)
383[info] izumi-reflectJVM (3.8.0-RC6, 2.13.14, 2.12.20, 2.11.12)
384[info] izumi-reflectJS (3.8.0-RC6, 2.13.14, 2.12.20)
385[info] izumi-reflect-root-js (3.8.0-RC6, 2.13.14, 2.12.20, 2.11.12)
386[info] izumi-reflect-root-native (3.8.0-RC6, 2.13.14, 2.12.20, 2.11.12)
387[info] izumi-reflectNative (3.8.0-RC6, 2.13.14, 2.12.20)
388[info] izumi-reflect-thirdparty-boopickle-shadedNative (3.8.0-RC6, 2.13.14, 2.12.20)
389[info] Excluding projects:
390[info] izumi-reflect-aggregate-native (2.12.20)
391[info] izumi-reflect-aggregate (2.12.20)
392[info] izumi-reflect-aggregate-js (2.12.20)
393[info] * izumi-reflect-root (2.12.20)
394[info] izumi-reflect-aggregate-jvm (2.12.20)
395[info] Reapplying settings...
396[info] set current project to izumi-reflect-root (in build file:/build/repo/)
397Execute mapScalacOptions: ,REQUIRE:-source:3.8,-Wconf:msg=can be rewritten automatically under:s ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e
398[info] Reapplying settings...
399[info] set current project to izumi-reflect-root (in build file:/build/repo/)
400[info] Defining Global / credentials, ThisBuild / credentials and 13 others.
401[info] The new values will be used by Global / pgpSelectPassphrase, Global / pgpSigningKey and 70 others.
402[info] Run `last` for details.
403[info] Reapplying settings...
404[info] set current project to izumi-reflect-root (in build file:/build/repo/)
405Execute excludeLibraryDependency: com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}
406[info] Reapplying settings...
407OpenCB::Failed to reapply settings in excludeLibraryDependency: Reference to undefined setting:
408
409 Global / allExcludeDependencies from Global / allExcludeDependencies (CommunityBuildPlugin.scala:331)
410 Did you mean izumi-reflect-thirdparty-boopickle-shadedJVM / allExcludeDependencies ?
411 , retry without global scopes
412[info] Reapplying settings...
413[info] set current project to izumi-reflect-root (in build file:/build/repo/)
414Execute removeScalacOptionsStartingWith: -P:wartremover
415[info] Reapplying settings...
416[info] set current project to izumi-reflect-root (in build file:/build/repo/)
417[success] Total time: 0 s, completed Jan 8, 2026, 2:27:05 AM
418Build config: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"21"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":["3.5"],"sourcePatches":[]}
419Parsed config: Success(ProjectBuildConfig(ProjectsConfig(List(),Map()),Full,List()))
420Starting build...
421Projects: Set(izumi-reflectJVM, izumi-reflect-thirdparty-boopickle-shadedJVM)
422Starting build for ProjectRef(file:/build/repo/,izumi-reflectJVM) (izumi-reflect)... [0/2]
423OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.8` in Scala 2.12.20 module Global
424OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.8` in Scala 2.12.20 module Scope(Select(BuildRef(file:/build/repo/)), Zero, Zero, Zero)
425OpenCB::Filter out '-feature', matches setting pattern '^-?-feature'
426OpenCB::Filter out '-deprecation', matches setting pattern '^-?-deprecation'
427Compile scalacOptions: -encoding, UTF-8, -unchecked, -language:higherKinds, -Ykind-projector, -no-indent, -language:implicitConversions, -Wconf:msg=can be rewritten automatically under:s, -source:3.8
428[info] compiling 16 Scala sources to /build/repo/izumi-reflect/izumi-reflect-thirdparty-boopickle-shaded/.jvm/target/scala-3.8.0-RC6/classes ...
429[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
430[warn] there were 2 deprecation warnings; re-run with -deprecation for details
431[warn] two warnings found
432[info] done compiling
433[info] compiling 31 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.8.0-RC6/classes ...
434[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
435[warn] one warning found
436[info] done compiling
437[info] compiling 25 Scala sources to /build/repo/izumi-reflect/izumi-reflect/.jvm/target/scala-3.8.0-RC6/test-classes ...
438[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
439[warn] -- Warning: /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagProgressionTest.scala:147:84
440[warn] 147 | def mk[F[+_, +_]: TagKK, G[+_, +_]: TagKK] = Tag[IntersectionBlockingIO[F, G]]
441[warn] | ^
442[warn] |TODO: Pathological intersection refinement result in lambda being reconstructed result=`F[E, A] & G[A, E]` in the rhs of type lambda lam=`[R >: scala.Nothing <: scala.Any, E >: scala.Nothing <: scala.Any, A >: scala.Nothing <: scala.Any] =>> F[E, A] & G[A, E]`
443[warn] |Only simple applied types of form F[A] are supported in results of type lambdas. The generated tag will not work correctly.
444[warn] |---------------------------------------------------------------------------
445[warn] |Inline stack trace
446[warn] |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
447[warn] |This location contains code that was inlined from SharedTagProgressionTest.scala:147
448[warn] 147 | def mk[F[+_, +_]: TagKK, G[+_, +_]: TagKK] = Tag[IntersectionBlockingIO[F, G]]
449[warn] | ^
450[warn] ---------------------------------------------------------------------------
451[warn] there was 1 deprecation warning; re-run with -deprecation for details
452[warn] three warnings found
453[info] done compiling
454[info] IzStringTest:
455[info] Extended string
456[info] - should support boolean parsing (20 milliseconds)
457[info] TagProgressionTest:
458[info] [progression] Tag (all versions)
459[info] - should progression test: can't substitute type parameters inside defs/vals in structural types (70 milliseconds)
460[info] + (java.lang.Object {def x(): izumi.reflect.test.SharedTagProgressionTest._$_$T}) =?= (java.lang.Object {def x(): scala.Int})
461[info] + (java.lang.Object {def x(): izumi.reflect.test.SharedTagProgressionTest._$_$T}) =?= (java.lang.Object {def x(): scala.Int})
462[info] - should progression test: cannot resolve a higher-kinded type in a higher-kinded tag in a named deeply-nested type lambda on Scala 2 (3 milliseconds)
463[info] - should progression test: cannot resolve a higher-kinded type in a higher-kinded tag in an anonymous deeply-nested type lambda (5 milliseconds)
464[info] - should progression test: projections into singletons are not handled properly (on Scala 2) (9 milliseconds)
465[info] + "bar" =?= "bar"
466[info] + "bar" =?= "bar"
467[info] + "bar" =?= "bar"
468[info] + "bar" =?= "bar"
469[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2
470[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2
471[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2
472[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2
473[info] - should Progression test: Scala 2 partially fails to Handle Tags outside of a predefined set when using TagX alias (Tag.auto.T works directly) (6 milliseconds)
474[info] - should progression test: fails to combine higher-kinded intersection types without losing ignored type arguments (10 milliseconds)
475[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → {izumi.reflect.test.SharedTagProgressionTest._$_$F[=1,=2] & izumi.reflect.test.SharedTagProgressionTest._$_$G[=2,=1]}] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → {izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+1] & scala.util.Either[+1,+2]}]
476[info] - should progression test: Dotty fails to regression test: resolve correct closestClass for Scala vararg AnyVal (https://github.com/zio/izumi-reflect/issues/224) (5 milliseconds)
477[info] - should progression test: fails to preserve lower bound when combining higher-kinded type members (12 milliseconds)
478[info] + scala.Unit <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
479[info] - should progression test: fails on Scala 3 don't lose tautological intersection components other than Any/AnyRef (16 milliseconds)
480[info] + {izumi.reflect.test.TestModel::Trait1 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]
481[info] + {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
482[info] + {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} <?< {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
483[info] + {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} <?< {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
484[info] + {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} debug== {izumi.reflect.test.TestModel::Trait4 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
485[info] - should progression test: intersection tautologies are not removed automatically when constructing combined intersection type (6 milliseconds)
486[info] + {izumi.reflect.test.TestModel::Trait1 & izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]
487[info] - should progression test: null is treated like Nothing, not like a separate type (1 millisecond)
488[info] - should progression test: parameter resolution breaks inside covariant wildcard type bounds on Scala 2.13 (122 milliseconds)
489[info] + scala.collection.immutable.List[+?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>] =?= scala.collection.immutable.List[+?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>]
490[info] + scala.collection.immutable.List[+?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>] <?< scala.collection.immutable.List[+?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>]
491[info] + scala.collection.immutable.List[+?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>] <?< scala.collection.immutable.List[+?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>]
492[info] - should progression test: combine intersection path-dependent intersection types with inner tags doesn't work on Scala 2 (5 milliseconds)
493[info] + {scala.Int & scala.Unit} =?= {scala.Int & scala.Unit}
494[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}
495[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}
496[info] - should progression test: `combine inside type lambdas where the type constructor of the type lambda result is a type lambda type parameter` doesn't work (1 millisecond)
497[info] [progression] Tag (Dotty)
498[info] - should progression test: fails to don't lose tautological union components other than Nothing (14 milliseconds)
499[info] + {izumi.reflect.test.TestModel::Trait1 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= izumi.reflect.test.TestModel::Trait1
500[info] + {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
501[info] + {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} <?< {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
502[info] + {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} <?< {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
503[info] + {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} debug== {izumi.reflect.test.TestModel::Trait4 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]}
504[info] - should progression test: union tautologies are not removed automatically when constructing combined union type (5 milliseconds)
505[info] + {izumi.reflect.test.TestModel::Trait1 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= izumi.reflect.test.TestModel::Trait1
506[info] TagTest:
507[info] Tag (all versions)
508[info] - should Work for any concrete type (13 milliseconds)
509[info] - should Support identity lambda type equality (0 milliseconds)
510[info] - should regression test for https://github.com/zio/izumi-reflect/issues/98 (30 milliseconds)
511[info] - should Work for any abstract type with available Tag when obscured by empty refinement (1 millisecond)
512[info] - should handle function local type aliases (48 milliseconds)
513[info] - should Can dealias transparent type members with class type parameters inside them when a tag is summoned _inside_ the class, because LightTypeTags are not affected by https://github.com/scala/bug/issues/11139 (13 milliseconds)
514[info] - should Tag.auto.T kind inference macro works for known cases (5 milliseconds)
515[info] - should support HKTag for unapplied type lambdas with type bounds (1 millisecond)
516[info] - should support Tag.auto.T for higher-kinded type lambdas with interdependent inner and outer type bounds (5 milliseconds)
517[info] - should Shouldn't work for any abstract type without available TypeTag or Tag or TagK (1 millisecond)
518[info] - should handle Id type lambda (0 milliseconds)
519[info] - should handle Id1 type lambda (3 milliseconds)
520[info] - should handle singleton types (2 milliseconds)
521[info] + izumi.reflect.test.ClockLive <?< izumi.reflect.test.Clock
522[info] - should handle nested intersection aliases (46 milliseconds)
523[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}
524[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}
525[info] + {java.lang.String & scala.Boolean & scala.Int} =?= {java.lang.String & scala.Boolean & scala.Int}
526[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}
527[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}
528[info] + {java.lang.String & scala.Boolean & scala.Int} <?< java.lang.CharSequence
529[info] + {java.lang.String & scala.Boolean & scala.Int} <?< java.lang.CharSequence
530[info] - should handle nested refined intersection aliases (43 milliseconds)
531[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}
532[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}
533[info] + {java.lang.String & scala.Boolean & scala.Int} =?= {java.lang.String & scala.Boolean & scala.Int}
534[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}
535[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}
536[info] + {java.lang.String & scala.Boolean & scala.Int} <?< java.lang.CharSequence
537[info] - should simple combined Tag (2 milliseconds)
538[info] + izumi.reflect.test.TestModel::ApplePaymentProvider[=λ %0 → 0] <?< izumi.reflect.test.TestModel::H1
539[info] - should consider class member's this-prefix to be the defining template, not the most specific prefix from where the call is happening (deliberate omission of this for better ergonomics in cakes) (31 milliseconds)
540[info] + izumi.reflect.test.SharedTagTest._$A::X =?= izumi.reflect.test.SharedTagTest._$A::X
541[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X
542[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X
543[info] + "bar" =?= "bar"
544[info] + "bar" <?< "bar"
545[info] + "bar" <?< "bar"
546[info] + "bar" =?= "bar"
547[info] + "bar" <?< "bar"
548[info] + "bar" <?< "bar"
549[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 =?= izumi.reflect.test.SharedTagTest._$A::singleton2
550[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2
551[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2
552[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 =?= izumi.reflect.test.SharedTagTest._$A::singleton2
553[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2
554[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2
555[info] + izumi.reflect.test.SharedTagTest._$A::X =?= izumi.reflect.test.SharedTagTest._$A::X
556[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X
557[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X
558[info] + "bar" =?= "bar"
559[info] + "bar" <?< "bar"
560[info] + "bar" <?< "bar"
561[info] + "bar" =?= "bar"
562[info] + "bar" <?< "bar"
563[info] + "bar" <?< "bar"
564[info] + "bar" =?= "bar"
565[info] + "bar" <?< "bar"
566[info] + "bar" <?< "bar"
567[info] - should Does NOT synthesize Tags for abstract types, but recursively summons Tag[this.Abstract] (17 milliseconds)
568[info] + scala.Int =?= scala.Int
569[info] + scala.Int <?< scala.Int
570[info] + scala.Int <?< scala.Int
571[info] + scala.Option[+scala.Int] =?= scala.Option[+scala.Int]
572[info] + scala.Option[+scala.Int] <?< scala.Option[+scala.Int]
573[info] + scala.Option[+scala.Int] <?< scala.Option[+scala.Int]
574[info] - should DOES synthesize Tags for abstract types (object X; X.T), does not summon Tag[X.T] (6 milliseconds)
575[info] + izumi.reflect.test.SomeObject::Abstract =!= scala.Int
576[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] =!= scala.Option[+scala.Int]
577[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] =?= scala.Option[+izumi.reflect.test.SomeObject::Abstract]
578[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] <?< scala.Option[+izumi.reflect.test.SomeObject::Abstract]
579[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] <?< scala.Option[+izumi.reflect.test.SomeObject::Abstract]
580[info] - should DOES synthesize Tags for abstract types (trait X; X#T), does not summon Tag[X#T] (4 milliseconds)
581[info] + izumi.reflect.test.SomeTrait::Abstract =!= scala.Int
582[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] =!= scala.Option[+scala.Int]
583[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] =?= scala.Option[+izumi.reflect.test.SomeTrait::Abstract]
584[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] <?< scala.Option[+izumi.reflect.test.SomeTrait::Abstract]
585[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] <?< scala.Option[+izumi.reflect.test.SomeTrait::Abstract]
586[info] - should DOES synthesize Tags for abstract types (val x; x.T), does not summon Tag[x.T] (4 milliseconds)
587[info] + izumi.reflect.test.SharedTagTest._$x::Abstract =!= scala.Int
588[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] =!= scala.Option[+scala.Int]
589[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] =?= scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract]
590[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] <?< scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract]
591[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] <?< scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract]
592[info] - should Work for an abstract type with available TagK when obscured by empty refinement (2 milliseconds)
593[info] - should Work for an abstract type with available TagK when TagK is requested through an explicit implicit (2 milliseconds)
594[info] - should Work for an abstract type with available TagKK (2 milliseconds)
595[info] - should Work for any configuration of parameters (3 milliseconds)
596[info] - should handle Swap type lambda (1 millisecond)
597[info] - should Assemble from higher than TagKK tags (0 milliseconds)
598[info] - should regression test: https://github.com/zio/izumi-reflect/issues/293 assemble tag for Builder[B, Collection[B]] (7 milliseconds)
599[info] + scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]] =?= scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]]
600[info] + scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]] <?< scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]]
601[info] + scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]] <?< scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]]
602[info] - should combine intersection types (12 milliseconds)
603[info] + {java.lang.String & scala.Int} =?= {java.lang.String & scala.Int}
604[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}
605[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}
606[info] + {java.lang.String & scala.Int} =?= {java.lang.String & scala.Int}
607[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}
608[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}
609[info] + java.lang.String =?= java.lang.String
610[info] + java.lang.String <?< java.lang.String
611[info] + java.lang.String <?< java.lang.String
612[info] + java.lang.String =?= java.lang.String
613[info] + java.lang.String <?< java.lang.String
614[info] + java.lang.String <?< java.lang.String
615[info] - should summon HKT Tag for a Java type (0 milliseconds)
616[info] - should regression test: https://github.com/zio/izumi-reflect/issues/76 derive tag for a parametric trait inside object (2 milliseconds)
617[info] + izumi.reflect.test.X76::T[=scala.Int] =?= izumi.reflect.test.X76::T[=scala.Int]
618[info] + izumi.reflect.test.X76::T[=scala.Int] <?< izumi.reflect.test.X76::T[=scala.Int]
619[info] + izumi.reflect.test.X76::T[=scala.Int] <?< izumi.reflect.test.X76::T[=scala.Int]
620[info] - should this.type tags should be generated, but are identical with their class / object tag (8 milliseconds)
621[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix debug== izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
622[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix debug== izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
623[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
624[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
625[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
626[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
627[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
628[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
629[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
630[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
631[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
632[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
633[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
634[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix
635[info] - should this.type should have correct prefix (0 milliseconds)
636[info] - should regression test: https://github.com/zio/izumi-reflect/issues/83, convert trifunctor tag to bifunctor tag (3 milliseconds)
637[info] + izumi.reflect.test.TestModel::BIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]] =?= izumi.reflect.test.TestModel::BIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]]
638[info] - should resolve TagK from TagKK (18 milliseconds)
639[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] =?= λ %0 → scala.util.Either[+java.lang.Throwable,+0]
640[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] <?< λ %0 → scala.util.Either[+java.lang.Throwable,+0]
641[info] + λ %0 → scala.util.Either[+java.lang.Throwable,+0] <?< λ %1 → scala.util.Either[+java.lang.Throwable,+1]
642[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] <?< λ %0 → scala.util.Either[+scala.Any,+0]
643[info] + λ %0 → scala.util.Either[+scala.Any,+0] <!< λ %1 → scala.util.Either[+java.lang.Throwable,+1]
644[info] + λ %0 → scala.util.Either[+scala.Any,+0] =!= λ %1 → scala.util.Either[+java.lang.Throwable,+1]
645[info] + λ %0 → scala.util.Either[+scala.Nothing,+0] <?< λ %1 → scala.util.Either[+java.lang.Throwable,+1]
646[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] <!< λ %0 → scala.util.Either[+scala.Nothing,+0]
647[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] =!= λ %0 → scala.util.Either[+scala.Nothing,+0]
648[info] - should can materialize TagK for type lambdas that close on a generic parameter with available Tag (0 milliseconds)
649[info] - should can materialize TagK for type lambdas that close on a generic parameter with available Tag when the constructor is a type parameter (0 milliseconds)
650[info] - should type parameter covariance works after combine (5 milliseconds)
651[info] - should combine Const Lambda to TagK (0 milliseconds)
652[info] - should combined TagK 3 & 2 parameter coherence (0 milliseconds)
653[info] - should resolve TagKK from an odd higher-kinded Tag with swapped & ignored parameters (5 milliseconds)
654[info] - should can resolve Tags of TagK's themselves correctly (16 milliseconds)
655[info] + izumi.reflect.Tag[=λ %0 → scala.collection.immutable.List[+0]] <?< izumi.reflect.Tag[=λ %0 → scala.collection.immutable.List[+0]]
656[info] + izumi.reflect.Tag[=λ %0,%1 → scala.util.Either[+0,+1]] =?= izumi.reflect.Tag[=λ %0,%1 → scala.util.Either[+0,+1]]
657[info] + izumi.reflect.Tag[=λ %0,%1,%2 → izumi.reflect.test.SharedTagTest._$X[=0,=1,=2]] =?= izumi.reflect.Tag[=λ %0,%1,%2 → izumi.reflect.test.SharedTagTest._$X[=0,=1,=2]]
658[info] + izumi.reflect.Tag[=λ %0,%1 → izumi.reflect.test.OptionT[=0,=1]] =?= izumi.reflect.Tag[=λ %0,%1 → izumi.reflect.test.OptionT[=0,=1]]
659[info] - should regression test: ignore function-local anonymous classes (https://github.com/zio/zio/issues/4285) (1 millisecond)
660[info] - should equal path-dependent tags for singleton types are expected to be equal (1 millisecond)
661[info] - should return expected class tag (6 milliseconds)
662[info] - should Work with term type prefixes (25 milliseconds)
663[info] + izumi.reflect.test.SharedTagTest._$zy::T =?= izumi.reflect.test.SharedTagTest._$zy::T
664[info] + izumi.reflect.test.SharedTagTest._$zy::T <?< izumi.reflect.test.SharedTagTest._$zy::T
665[info] + izumi.reflect.test.SharedTagTest._$zy::T <?< izumi.reflect.test.SharedTagTest._$zy::T
666[info] + izumi.reflect.test.SharedTagTest._$zy::T <!< izumi.reflect.test.SharedTagTest._$zx::T
667[info] + izumi.reflect.test.SharedTagTest._$zx::T <!< izumi.reflect.test.SharedTagTest._$zy::T
668[info] + izumi.reflect.test.SharedTagTest._$zx::T =!= izumi.reflect.test.SharedTagTest._$zy::T
669[info] + izumi.reflect.test.SharedTagTest._$zy::x =?= izumi.reflect.test.SharedTagTest._$zy::x
670[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< izumi.reflect.test.SharedTagTest._$zy::x
671[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< izumi.reflect.test.SharedTagTest._$zy::x
672[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< java.lang.String
673[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< java.io.Serializable
674[info] + izumi.reflect.test.SharedTagTest._$zy::x <!< izumi.reflect.test.SharedTagTest._$zx::x
675[info] + izumi.reflect.test.SharedTagTest._$zx::x <!< izumi.reflect.test.SharedTagTest._$zy::x
676[info] + izumi.reflect.test.SharedTagTest._$zx::x =!= izumi.reflect.test.SharedTagTest._$zy::x
677[info] + izumi.reflect.test.SharedTagTest._$zy::y =?= izumi.reflect.test.SharedTagTest._$zy::y
678[info] + izumi.reflect.test.SharedTagTest._$zy::y <?< izumi.reflect.test.SharedTagTest._$zy::y
679[info] + izumi.reflect.test.SharedTagTest._$zy::y <?< izumi.reflect.test.SharedTagTest._$zy::y
680[info] + izumi.reflect.test.SharedTagTest._$zy::y <?< java.lang.Object
681[info] + izumi.reflect.test.SharedTagTest._$zy::y <!< izumi.reflect.test.SharedTagTest._$zx::y
682[info] + izumi.reflect.test.SharedTagTest._$zx::y <!< izumi.reflect.test.SharedTagTest._$zy::y
683[info] + izumi.reflect.test.SharedTagTest._$zx::y =!= izumi.reflect.test.SharedTagTest._$zy::y
684[info] + izumi.reflect.test.SharedTagTest._$zy::y <!< izumi.reflect.test.SharedTagTest._$zx::x
685[info] + izumi.reflect.test.SharedTagTest._$zx::x <!< izumi.reflect.test.SharedTagTest._$zy::y
686[info] + izumi.reflect.test.SharedTagTest._$zx::x =!= izumi.reflect.test.SharedTagTest._$zy::y
687[info] - should correctly resolve abstract types inside traits when summoned inside trait (7 milliseconds)
688[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] =!= izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$b::T]
689[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] =?= izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T]
690[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] <?< izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T]
691[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] <?< izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T]
692[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] =!= izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$b::T]
693[info] - should combine higher-kinded type lambdas without losing ignored type arguments (4 milliseconds)
694[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1:0,%1:1,%1:2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1:1,+1:2]] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
695[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1:0,%1:1,%1:2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1:1,+1:2]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
696[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1:0,%1:1,%1:2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1:1,+1:2]]
697[info] - should resolve a higher-kinded type inside a named type lambda with ignored type arguments (2 milliseconds)
698[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
699[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
700[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]]
701[info] - should resolve TagKK from an odd higher-kinded Tag with swapped & ignored parameters (low-level) (7 milliseconds)
702[info] + λ %2,%3 → scala.util.Either[+java.lang.Throwable,+3] =?= λ %0,%1 → scala.util.Either[+java.lang.Throwable,+1]
703[info] + λ %2,%3 → scala.util.Either[+java.lang.Throwable,+3] <?< λ %0,%1 → scala.util.Either[+java.lang.Throwable,+1]
704[info] + λ %0,%1 → scala.util.Either[+java.lang.Throwable,+1] <?< λ %2,%3 → scala.util.Either[+java.lang.Throwable,+3]
705[info] - should correctly resolve a higher-kinded nested type inside a named swap type lambda (5 milliseconds)
706[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] =?= izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
707[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
708[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]]
709[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] =?= izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
710[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
711[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]]
712[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] =?= izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
713[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
714[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]]
715[info] - should support subtyping of parents parameterized with type lambdas in combined tags (7 milliseconds)
716[info] + izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]] <?< izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]]
717[info] + izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]] =?= izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]]
718[info] + izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]] <?< izumi.reflect.test.TestModel::RoleParent[=λ %0 → scala.util.Either[+java.lang.Throwable,+0]]
719[info] + izumi.reflect.test.TestModel::RoleParent[=λ %0 → scala.util.Either[+java.lang.Throwable,+0]] <!< izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]]
720[info] - should support subtyping of parents parameterized with type lambdas in combined tags with multiple parameters (9 milliseconds)
721[info] + izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String] =?= izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String]
722[info] + izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleParent[=λ %0 → scala.util.Either[+java.lang.Throwable,+0]]
723[info] + izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleParent[=λ %0 → scala.util.Either[+java.lang.Throwable,+0]]
724[info] - should combine inside type lambdas with repeated usages of a type lambda type parameter (4 milliseconds)
725[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+3,+3]] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+2]]
726[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+3,+3]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+2]]
727[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+2]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+3,+3]]
728[info] - should combine inside type lambdas with repeated usages of an outer type (1 millisecond)
729[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %2,%3,%4 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.Int,+scala.Int]] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.Int,+scala.Int]]
730[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %2,%3,%4 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.Int,+scala.Int]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.Int,+scala.Int]]
731[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.Int,+scala.Int]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %2,%3,%4 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.Int,+scala.Int]]
732[info] - should combine inside type lambdas with repeated usages of an outer distinct type with the same type symbol (8 milliseconds)
733[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %3,%4,%5 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.util.Either[+scala.Int,+scala.Int],+scala.util.Either[+scala.Int,+java.lang.String]]] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.util.Either[+scala.Int,+scala.Int],+scala.util.Either[+scala.Int,+java.lang.String]]]
734[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %3,%4,%5 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.util.Either[+scala.Int,+scala.Int],+scala.util.Either[+scala.Int,+java.lang.String]]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.util.Either[+scala.Int,+scala.Int],+scala.util.Either[+scala.Int,+java.lang.String]]]
735[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.util.Either[+scala.Int,+scala.Int],+scala.util.Either[+scala.Int,+java.lang.String]]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %3,%4,%5 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+scala.util.Either[+scala.Int,+scala.Int],+scala.util.Either[+scala.Int,+java.lang.String]]]
736[info] - should regression test: https://github.com/zio/izumi-reflect/issues/82, convert trifunctor hkt to bifunctor when combining tags (1 millisecond)
737[info] + izumi.reflect.test.TestModel::BIO3[=λ %2,%3,%4 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+3,+4]] =?= izumi.reflect.test.TestModel::BIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
738[info] + izumi.reflect.test.TestModel::BIO3[=λ %2,%3,%4 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+3,+4]] <?< izumi.reflect.test.TestModel::BIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
739[info] + izumi.reflect.test.TestModel::BIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]] <?< izumi.reflect.test.TestModel::BIO3[=λ %2,%3,%4 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+3,+4]]
740[info] - should combine higher-kinded types without losing ignored type arguments (1 millisecond)
741[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]] =?= izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
742[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]]
743[info] + izumi.reflect.test.InheritedModel::BlockingIO3[=λ %0,%1,%2 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+1,+2]] <?< izumi.reflect.test.InheritedModel::BlockingIO3[=λ %1,%2,%3 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+2,+3]]
744[info] - should resolve a higher-kinded type inside an anonymous type lambda with ignored & higher-kinded type arguments (2 milliseconds)
745[info] + izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %1,%2,%3 → izumi.reflect.test.OptionT[=2,=3]] =?= izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → izumi.reflect.test.OptionT[=1,=2]]
746[info] + izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %1,%2,%3 → izumi.reflect.test.OptionT[=2,=3]] <?< izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → izumi.reflect.test.OptionT[=1,=2]]
747[info] + izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → izumi.reflect.test.OptionT[=1,=2]] <?< izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %1,%2,%3 → izumi.reflect.test.OptionT[=2,=3]]
748[info] - should correctly resolve a higher-kinded nested type inside an anonymous swap type lambda (8 milliseconds)
749[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] =?= izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
750[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
751[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]]
752[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] =?= izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
753[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
754[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]]
755[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] =?= izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
756[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]]
757[info] + izumi.reflect.test.InheritedModel::BIOService[=λ %0,%1 → scala.util.Either[+1,+0]] <?< izumi.reflect.test.InheritedModel::BIOService[=λ %1,%2 → scala.util.Either[+2,+1]]
758[info] - should handles abstract types instead of parameters (10 milliseconds)
759[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=scala.util.Either[+scala.Int,+scala.Byte]] =?= izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=scala.util.Either[+scala.Int,+scala.Byte]]
760[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=scala.util.Either[+scala.Int,+scala.Byte]] <?< izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=scala.util.Either[+scala.Int,+scala.Byte]]
761[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=scala.util.Either[+scala.Int,+scala.Byte]] <?< izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=scala.util.Either[+scala.Int,+scala.Byte]]
762[info] - should Generates lambda parents for lambda bases (4 milliseconds)
763[info] - should subtyping for Invariant Java HKT (2 milliseconds)
764[info] + λ %0 → java.util.Collection[=0] <?< λ %0 → java.lang.Iterable[=0]
765[info] + λ %0 → java.lang.Iterable[=0] <!< λ %0 → java.util.Collection[=0]
766[info] + λ %0 → java.lang.Iterable[=0] =!= λ %0 → java.util.Collection[=0]
767[info] - should subtyping for Invariant Scala HKT (5 milliseconds)
768[info] + λ %0 → scala.collection.mutable.Set[=0] <?< λ %0 → scala.collection.Set[=0]
769[info] + λ %0 → scala.collection.Set[=0] <!< λ %0 → scala.collection.mutable.Set[=0]
770[info] + λ %0 → scala.collection.Set[=0] =!= λ %0 → scala.collection.mutable.Set[=0]
771[info] - should Work for structural concrete types (7 milliseconds)
772[info] + (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean}) =?= (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean})
773[info] + (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean}) <?< (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean})
774[info] + (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean}) <?< (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean})
775[info] + (scala.Int {def a(): scala.Int}) =?= (scala.Int {def a(): scala.Int})
776[info] + (scala.Int {def a(): scala.Int}) <?< (scala.Int {def a(): scala.Int})
777[info] + (scala.Int {def a(): scala.Int}) <?< (scala.Int {def a(): scala.Int})
778[info] + {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]} =?= {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]}
779[info] + {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]} <?< {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]}
780[info] + {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]} <?< {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]}
781[info] + {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]} <!< {(java.lang.Object {type T = {Long & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]}
782[info] + {(java.lang.Object {type T = {Long & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]} <!< {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]}
783[info] + {(java.lang.Object {type T = {Long & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]} =!= {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.SharedTagTest::With[="str"]}
784[info] - should Work for any abstract type with available Tag while preserving additional type refinement (13 milliseconds)
785[info] + (java.lang.String {type X = Int, type Y = String}) =?= (java.lang.String {type X = Int, type Y = String})
786[info] + (java.lang.String {type X = Int, type Y = String}) <?< (java.lang.String {type X = Int, type Y = String})
787[info] + (java.lang.String {type X = Int, type Y = String}) <?< (java.lang.String {type X = Int, type Y = String})
788[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = String, type Y = Boolean})
789[info] + (java.lang.String {type X = String, type Y = Boolean}) <!< (java.lang.String {type X = Int, type Y = String})
790[info] + (java.lang.String {type X = String, type Y = Boolean}) =!= (java.lang.String {type X = Int, type Y = String})
791[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = String, type Y = Boolean})
792[info] + (java.lang.String {type X = String, type Y = Boolean}) <!< (java.lang.String {type X = Int, type Y = String})
793[info] + (java.lang.String {type X = String, type Y = Boolean}) =!= (java.lang.String {type X = Int, type Y = String})
794[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = Int, type Y = Boolean})
795[info] + (java.lang.String {type X = Int, type Y = Boolean}) <!< (java.lang.String {type X = Int, type Y = String})
796[info] + (java.lang.String {type X = Int, type Y = Boolean}) =!= (java.lang.String {type X = Int, type Y = String})
797[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = Boolean, type Y = String})
798[info] + (java.lang.String {type X = Boolean, type Y = String}) <!< (java.lang.String {type X = Int, type Y = String})
799[info] + (java.lang.String {type X = Boolean, type Y = String}) =!= (java.lang.String {type X = Int, type Y = String})
800[info] - should Work for any abstract type with available Tag while preserving additional method refinement (13 milliseconds)
801[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) =?= (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
802[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) <?< (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
803[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) <?< (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
804[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) <!< (java.lang.String {def x(): java.lang.String, def y(): scala.Boolean})
805[info] + (java.lang.String {def x(): java.lang.String, def y(): scala.Boolean}) <!< (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
806[info] + (java.lang.String {def x(): java.lang.String, def y(): scala.Boolean}) =!= (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
807[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) <!< (java.lang.String {def x(): scala.Int, def y(): scala.Boolean})
808[info] + (java.lang.String {def x(): scala.Int, def y(): scala.Boolean}) <!< (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
809[info] + (java.lang.String {def x(): scala.Int, def y(): scala.Boolean}) =!= (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
810[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) <!< (java.lang.String {def x(): scala.Boolean, def y(): java.lang.String})
811[info] + (java.lang.String {def x(): scala.Boolean, def y(): java.lang.String}) <!< (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
812[info] + (java.lang.String {def x(): scala.Boolean, def y(): java.lang.String}) =!= (java.lang.String {def x(): scala.Int, def y(): java.lang.String})
813[info] - should can resolve parameters in structural types (1 millisecond)
814[info] + (java.lang.Object {type T = Int}) =?= (java.lang.Object {type T = Int})
815[info] + (java.lang.Object {type T = Int}) =!= (java.lang.Object {type T = String})
816[info] - should combine higher-kinded type members (12 milliseconds)
817[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] =?= izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
818[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
819[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
820[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %1:0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+1:0],=scala.Int] =?= izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
821[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %1:0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+1:0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
822[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %1:0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+1:0],=scala.Int]
823[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] =?= izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
824[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
825[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
826[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< scala.AnyVal
827[info] + scala.AnyVal <!< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
828[info] + scala.AnyVal =!= izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
829[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %1:0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+1:0],=scala.Int] <?< scala.AnyVal
830[info] + scala.AnyVal <!< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %1:0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+1:0],=scala.Int]
831[info] + scala.AnyVal =!= izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %1:0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+1:0],=scala.Int]
832[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
833[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <!< izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
834[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] =!= izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
835[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< scala.AnyVal
836[info] + scala.AnyVal <!< izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
837[info] + scala.AnyVal =!= izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]
838[info] - should regression test: do not be confused by a type alias of Set of an abstract type referred via this-prefix on Scala 3 (10 milliseconds)
839[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] =?= scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
840[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] <?< scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
841[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] <?< scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
842[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] =?= scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
843[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] <?< scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
844[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] <?< scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
845[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] debug== scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
846[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]] debug== scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=scala.Int]]
847[info] - should support injecting runtime tags in place of type projections from type parameters / match types on type parameters (2 milliseconds)
848[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] =?= izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]
849[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] <?< izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]
850[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] <?< izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]
851[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] debug== izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]
852[info] - should regression test for: Scala 2, https://github.com/zio/izumi-reflect/issues/189, parameterized type alias with intersection produces incorrect output (15 milliseconds)
853[info] - should combining with wildcards is supported (8 milliseconds)
854[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.Set[=0],=?: <scala.Nothing..scala.Int>] =?= izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.Set[=0],=?: <scala.Nothing..scala.Int>]
855[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.Set[=0],=?: <scala.Nothing..scala.Int>] <?< izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.Set[=0],=?: <scala.Nothing..scala.Int>]
856[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.Set[=0],=?: <scala.Nothing..scala.Int>] <?< izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.Set[=0],=?: <scala.Nothing..scala.Int>]
857[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=?: <scala.Nothing..scala.Int>] =?= izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=?: <scala.Nothing..scala.Int>]
858[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=?: <scala.Nothing..scala.Int>] <?< izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=?: <scala.Nothing..scala.Int>]
859[info] + izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=?: <scala.Nothing..scala.Int>] <?< izumi.reflect.test.OptionT[=λ %0 → scala.collection.immutable.List[+0],=?: <scala.Nothing..scala.Int>]
860[info] + izumi.reflect.test.OptionT[=λ %0 → scala.Function1[-0,+scala.Int],=?: <scala.Nothing..scala.Int>] =?= izumi.reflect.test.OptionT[=λ %0 → scala.Function1[-0,+scala.Int],=?: <scala.Nothing..scala.Int>]
861[info] + izumi.reflect.test.OptionT[=λ %0 → scala.Function1[-0,+scala.Int],=?: <scala.Nothing..scala.Int>] <?< izumi.reflect.test.OptionT[=λ %0 → scala.Function1[-0,+scala.Int],=?: <scala.Nothing..scala.Int>]
862[info] + izumi.reflect.test.OptionT[=λ %0 → scala.Function1[-0,+scala.Int],=?: <scala.Nothing..scala.Int>] <?< izumi.reflect.test.OptionT[=λ %0 → scala.Function1[-0,+scala.Int],=?: <scala.Nothing..scala.Int>]
863[info] - should other type members' bounds are not malformed when resolving parameters in structural types (1 millisecond)
864[info] + (java.lang.Object {type G = G|<Int..AnyVal>, type T = Int}) =?= (java.lang.Object {type G = G|<Int..AnyVal>, type T = Int})
865[info] + (java.lang.Object {type G = G|<Int..AnyVal>, type T = Int}) =!= (java.lang.Object {type G = G|<Int..AnyVal>, type T = String})
866[info] - should form a correct type lambda for an equal-bounded abstract type (8 milliseconds)
867[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] =?= izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]
868[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]
869[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]
870[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] =!= scala.Any
871[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]] =?= scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]]
872[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]] <?< scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]]
873[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]] <?< scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]]
874[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]] =!= scala.Any
875[info] - should eradicate intersection tautologies with Any/Object (Tag) (2 milliseconds)
876[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
877[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
878[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
879[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
880[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
881[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
882[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
883[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
884[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
885[info] - should tautological intersections with Any/Object are discarded from internal structure (Tag) (4 milliseconds)
886[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
887[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
888[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
889[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
890[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
891[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
892[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
893[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
894[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
895[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
896[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
897[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
898[info] - should regression test for https://github.com/zio/izumi-reflect/issues/474 (0 milliseconds)
899[info] - should resolve parameters inside type bounds & wildcards (28 milliseconds)
900[info] + scala.collection.immutable.Set[=?: <scala.Nothing..scala.Int>] =?= scala.collection.immutable.Set[=?: <scala.Nothing..scala.Int>]
901[info] + scala.collection.immutable.Set[=?: <scala.Int..scala.Any>] =?= scala.collection.immutable.Set[=?: <scala.Int..scala.Any>]
902[info] + scala.collection.immutable.Set[=?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>] =?= scala.collection.immutable.Set[=?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>]
903[info] + scala.collection.immutable.Set[=?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>] <?< scala.collection.immutable.Set[=?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>]
904[info] + scala.collection.immutable.Set[=?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>] <?< scala.collection.immutable.Set[=?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>]
905[info] + scala.Function1[-?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>,+scala.Int] =?= scala.Function1[-?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>,+scala.Int]
906[info] + scala.Function1[-?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>,+scala.Int] <?< scala.Function1[-?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>,+scala.Int]
907[info] + scala.Function1[-?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>,+scala.Int] <?< scala.Function1[-?: <scala.Nothing..scala.collection.immutable.List[+scala.Long]>,+scala.Int]
908[info] Tag (Dotty)
909[info] - should Support union subtyping (Scala 3 specific, union types) (9 milliseconds)
910[info] + izumi.reflect.test.TagTest._$Dog <?< izumi.reflect.test.TagTest._$Animal
911[info] + {izumi.reflect.test.TagTest._$Dog | java.lang.String} <?< {izumi.reflect.test.TagTest._$Animal | java.lang.String}
912[info] + {izumi.reflect.test.TagTest._$Animal | java.lang.String} <!< {izumi.reflect.test.TagTest._$Dog | java.lang.String}
913[info] - should Can create custom type tags to support bounded generics, e.g. <: Dep in TagK (Scala 3 HKTag Syntax) (1 millisecond)
914[info] - should combine union types (Scala 3 specific, union types) (6 milliseconds)
915[info] + {java.lang.String | scala.Int} =?= {java.lang.String | scala.Int}
916[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}
917[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}
918[info] + {java.lang.String | scala.Int} =?= {java.lang.String | scala.Int}
919[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}
920[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}
921[info] + java.lang.String =?= java.lang.String
922[info] + java.lang.String <?< java.lang.String
923[info] + java.lang.String <?< java.lang.String
924[info] + java.lang.String =?= java.lang.String
925[info] + java.lang.String <?< java.lang.String
926[info] + java.lang.String <?< java.lang.String
927[info] - should type tags with bounds are successfully requested by TagMacro (1 millisecond)
928[info] + izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep] =?= izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep]
929[info] + izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep] <?< izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep]
930[info] + izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep] <?< izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep]
931[info] - should remove tautological unions with Nothing (LTT) (1 millisecond)
932[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
933[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
934[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
935[info] - should remove tautological unions with Nothing (Tag) (1 millisecond)
936[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
937[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
938[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
939[info] - should combine intersection path-dependent intersection types with inner tags works on Scala 3 (2 milliseconds)
940[info] + {scala.Int & scala.Unit} =?= {scala.Int & scala.Unit}
941[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}
942[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}
943[info] + {scala.Int & scala.Unit} =?= {scala.Int & scala.Unit}
944[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}
945[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}
946[info] Scala213Plus_LightTypeTagTest:
947[info] lightweight type tags (2.13+)
948[info] - should literal types behave in sane manner https://github.com/zio/izumi-reflect/issues/284 (66 milliseconds)
949[info] + "a" =?= "a"
950[info] + "a" <?< "a"
951[info] + "a" <?< "a"
952[info] + "a" =?= "a"
953[info] + "a" <?< "a"
954[info] + "a" <?< "a"
955[info] + "a" =?= "a"
956[info] + "a" <?< "a"
957[info] + "a" <?< "a"
958[info] + "a" debug== "a"
959[info] + "a" debug== "a"
960[info] + "a" debug== "a"
961[info] + "a" <?< java.lang.String
962[info] + java.lang.String <!< "a"
963[info] + java.lang.String =!= "a"
964[info] + "a" <?< java.lang.String
965[info] + java.lang.String <!< "a"
966[info] + java.lang.String =!= "a"
967[info] + "a" <?< java.lang.String
968[info] + java.lang.String <!< "a"
969[info] + java.lang.String =!= "a"
970[info] + "a" <?< java.lang.String
971[info] + java.lang.String <!< "a"
972[info] + java.lang.String =!= "a"
973[info] - should support string constant types (Scala 2.13+ syntax) (9 milliseconds)
974[info] + "abc" =!= java.lang.String
975[info] + "abc" =!= "cba"
976[info] + "abc" =?= "abc"
977[info] + "abc" <?< "abc"
978[info] + "abc" <?< "abc"
979[info] + "abc" <?< java.lang.String
980[info] + java.lang.String <!< "abc"
981[info] + java.lang.String =!= "abc"
982[info] LTTRenderablesTest:
983[info] LTT renderables
984[info] - should render simple lambdas using placeholders when using scalaStyledRepr (34 milliseconds)
985[info] - should render complex lambdas using long form when using scalaStyledRepr (9 milliseconds)
986[info] - should types in nested objects should be rendered with dot separator (0 milliseconds)
987[info] BasicDottyTest:
988[info] - super-basic test 1 (100 milliseconds)
989[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz =?= izumi.reflect.test.CurrentDottySupportExtentTest._$Baz
990[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz =!= izumi.reflect.test.CurrentDottySupportExtentTest._$Bar[+λ %0,%1 → izumi.reflect.test.CurrentDottySupportExtentTest::X[+0,-1]]
991[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz <?< izumi.reflect.test.CurrentDottySupportExtentTest._$Baz
992[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz <!< izumi.reflect.test.CurrentDottySupportExtentTest._$Bar[+λ %0,%1 → izumi.reflect.test.CurrentDottySupportExtentTest::X[+0,-1]]
993[info] + izumi.reflect.test.CurrentDottySupportExtentTest::B <?< izumi.reflect.test.CurrentDottySupportExtentTest::A
994[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz =?= izumi.reflect.test.CurrentDottySupportExtentTest._$Baz
995[info] + izumi.reflect.test.CurrentDottySupportExtentTest::Listoid[+scala.Int] <?< izumi.reflect.test.CurrentDottySupportExtentTest::Listoid[+scala.Int]
996[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+scala.Int]
997[info] + izumi.reflect.test.CurrentDottySupportExtentTest::SubInvariantoid[=scala.Int] <?< izumi.reflect.test.CurrentDottySupportExtentTest::Traitoid
998[info] + scala.Tuple2[+izumi.reflect.test.CurrentDottySupportExtentTest._$Baz,+izumi.reflect.test.CurrentDottySupportExtentTest._$Baz] <?< scala.Tuple2[+scala.Any,+scala.Any]
999[info] + scala.Tuple2[+scala.Double,+scala.Double] <?< scala.Tuple2[+scala.AnyVal,+scala.AnyVal]
1000[info] + scala.collection.immutable.List[+izumi.reflect.test.CurrentDottySupportExtentTest::B] <?< scala.collection.immutable.Seq[+izumi.reflect.test.CurrentDottySupportExtentTest::A]
1001[info] + scala.collection.immutable.List[+izumi.reflect.test.CurrentDottySupportExtentTest::B] <?< scala.collection.immutable.Seq[+izumi.reflect.test.CurrentDottySupportExtentTest::A]
1002[info] LightTypeTagProgressionTest:
1003[info] [progression] lightweight type tags (all versions)
1004[info] - should progression test: can't support subtyping of type prefixes (5 milliseconds)
1005[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$a::A <?< izumi.reflect.test.TestModel::C::A
1006[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$a::A =!= izumi.reflect.test.TestModel::C::A
1007[info] + izumi.reflect.test.TestModel::C::A <!< izumi.reflect.test.SharedLightTypeTagProgressionTest._$a::A
1008[info] - should progression test: can't support subtyping of concrete type projections (1 millisecond)
1009[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T =?= izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T
1010[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$B::T =!= izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T
1011[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$B::T <?< izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T
1012[info] - should progression test: bounds-based subtype checks for lambdas do not work properly (LambdaParameter must contain bounds and NameReferences shouldn't for this to work) (8 milliseconds)
1013[info] + λ %0 → scala.collection.immutable.Set[=0] <!< λ %0 → scala.collection.immutable.Set[=0]
1014[info] + λ %0 → scala.collection.immutable.Set[=0] <?< λ %0 → scala.collection.immutable.Set[=0]
1015[info] - should progression test: indirect structural checks do not work (8 milliseconds)
1016[info] + (java.lang.Object {type A = A}) =!= java.lang.Object
1017[info] + izumi.reflect.test.TestModel::C <?< (java.lang.Object {type A = A})
1018[info] - should progression test: combined intersection lambda tags still contain some junk bases (coming from the unsound same-arity assumption in LightTypeTag#combine) (30 milliseconds)
1019[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} debug== {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1020[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} debug== {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1021[info] - should progression test: combined lambda tags still contain some junk bases (coming from the unsound same-arity assumption in LightTypeTag#combine) (5 milliseconds)
1022[info] + scala.util.Right[+java.lang.Throwable,+scala.Unit] =?= scala.util.Right[+java.lang.Throwable,+scala.Unit]
1023[info] - should progression test: Dotty fails to `support methods with type parameters in structural refinements` (11 milliseconds)
1024[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean}) <!< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Int})
1025[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Int}) <!< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})
1026[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Int}) =!= (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})
1027[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean}) <?< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.AnyVal})
1028[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.AnyVal}) <!< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})
1029[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.AnyVal}) =!= (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})
1030[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean}) <?< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): 0})
1031[info] - should fails to treat tautological refinements as equal to the underlying type (1 millisecond)
1032[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$X =?= (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): 0})
1033[info] - should fails to support methods with multiple parameter lists in refinements (20 milliseconds)
1034[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Boolean): scala.Int})
1035[info] + (java.lang.Object {def x(scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1036[info] + (java.lang.Object {def x(scala.Boolean): scala.Int}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1037[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Int): scala.Int})
1038[info] + (java.lang.Object {def x(scala.Int): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1039[info] + (java.lang.Object {def x(scala.Int): scala.Int}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1040[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1041[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <?< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Any})
1042[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Any}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1043[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Any}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1044[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <?< (java.lang.Object {def x(scala.Int, scala.Nothing): scala.Int})
1045[info] + (java.lang.Object {def x(scala.Int, scala.Nothing): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1046[info] + (java.lang.Object {def x(scala.Int, scala.Nothing): scala.Int}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})
1047[info] - should progression test: fails to `Any/Object relation is consistent with Scala` (4 milliseconds)
1048[info] + java.lang.Object <?< scala.Any
1049[info] + scala.Any <!< java.lang.Object
1050[info] + scala.Any =!= java.lang.Object
1051[info] - should progression test: can't distinguish between equal-bounded type and alias inside refinements on dotty (1 millisecond)
1052[info] + (java.lang.Object {type X = Any}) =!= (java.lang.Object {type X = Any})
1053[info] - should progression test: Null type is a subtype of Nothing, but shouldn't be (1 millisecond)
1054[info] + scala.Null <!< scala.Nothing
1055[info] [progression] lightweight type tag (Dotty)
1056[info] - should fails to support variance for type parameters of opaque types (1 millisecond)
1057[info] + izumi.reflect.test.LightTypeTagProgressionTest._$x::T[=scala.Int] <?< izumi.reflect.test.LightTypeTagProgressionTest._$x::T[=scala.AnyVal]
1058[info] IzCollectionsTest:
1059[info] Collection utils
1060[info] - should allow to convert mappings to multimaps (1 millisecond)
1061[info] TagCombineTest:
1062[info] Tag macro
1063[info] - should reconstruct lambda tags (20 milliseconds)
1064[info] LightTypeTagTest:
1065[info] lightweight type tags (all versions)
1066[info] - should support distinction between subtypes (162 milliseconds)
1067[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> <?< java.lang.String
1068[info] + java.lang.String <!< izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>
1069[info] + java.lang.String =!= izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>
1070[info] + izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>> <?< java.lang.String
1071[info] + java.lang.String <!< izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>
1072[info] + java.lang.String =!= izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>
1073[info] + izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>> <?< izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>
1074[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> <!< izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>
1075[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> =!= izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>
1076[info] + izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>> <!< izumi.reflect.test.TestModel::SubStrB|<scala.Nothing..java.lang.String>
1077[info] + izumi.reflect.test.TestModel::SubStrB|<scala.Nothing..java.lang.String> <!< izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>
1078[info] + izumi.reflect.test.TestModel::SubStrB|<scala.Nothing..java.lang.String> =!= izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>
1079[info] + java.lang.String =?= java.lang.String
1080[info] + java.lang.String <?< java.lang.String
1081[info] + java.lang.String <?< java.lang.String
1082[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> <!< izumi.reflect.test.TestModel::SubStrB|<scala.Nothing..java.lang.String>
1083[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> =?= izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>
1084[info] + java.lang.String =?= java.lang.String
1085[info] + izumi.reflect.test.TestModel::\/[=izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>,=scala.Int] =?= izumi.reflect.test.TestModel::\/[=izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>,=scala.Int]
1086[info] + izumi.reflect.test.TestModel::\/[=izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>,=scala.Int] <?< izumi.reflect.test.TestModel::\/[=izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>,=scala.Int]
1087[info] + izumi.reflect.test.TestModel::\/[=izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>,=scala.Int] <?< izumi.reflect.test.TestModel::\/[=izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>,=scala.Int]
1088[info] - should eradicate intersection tautologies with Any/Object (17 milliseconds)
1089[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1090[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1091[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1092[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1093[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1094[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1095[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1096[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1097[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1098[info] - should do not eradicate intersections with Nothing (5 milliseconds)
1099[info] + {scala.Nothing & scala.Option[+java.lang.String]} =!= scala.Option[+java.lang.String]
1100[info] + {scala.Nothing & scala.Option[+java.lang.String]} =?= {scala.Nothing & scala.Option[+java.lang.String]}
1101[info] + {scala.Nothing & scala.Option[+java.lang.String]} <?< {scala.Nothing & scala.Option[+java.lang.String]}
1102[info] + {scala.Nothing & scala.Option[+java.lang.String]} <?< {scala.Nothing & scala.Option[+java.lang.String]}
1103[info] - should eradicate self-intersection (X with X) (2 milliseconds)
1104[info] + java.lang.String =?= java.lang.String
1105[info] + java.lang.String <?< java.lang.String
1106[info] + java.lang.String <?< java.lang.String
1107[info] - should support subtype checks (112 milliseconds)
1108[info] + scala.Int <?< scala.AnyVal
1109[info] + scala.Int <?< scala.Int
1110[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+scala.Int]
1111[info] + scala.collection.immutable.List[+izumi.reflect.test.TestModel::I2] <?< scala.collection.immutable.List[+izumi.reflect.test.TestModel::I1]
1112[info] + scala.util.Either[+scala.Nothing,+scala.Int] <?< scala.util.Either[+java.lang.Throwable,+scala.Int]
1113[info] + izumi.reflect.test.TestModel::F2[+izumi.reflect.test.TestModel::I2] <?< izumi.reflect.test.TestModel::F1[+izumi.reflect.test.TestModel::I1]
1114[info] + izumi.reflect.test.TestModel::FT2[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]] <?< izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]]
1115[info] + izumi.reflect.test.TestModel::FM2[+izumi.reflect.test.TestModel::I2] <?< izumi.reflect.test.TestModel::FM1[+izumi.reflect.test.TestModel::I1,+scala.Unit]
1116[info] + scala.Option[+scala.Nothing] <?< scala.Option[+scala.Int]
1117[info] + izumi.reflect.test.TestModel::P1[=λ %0 → izumi.reflect.test.TestModel::X1[=0],=λ %0 → izumi.reflect.test.TestModel::X2[=0]] <?< izumi.reflect.test.TestModel::P0[=λ %0 → izumi.reflect.test.TestModel::X2[=0],=λ %0 → izumi.reflect.test.TestModel::X1[=0]]
1118[info] + izumi.reflect.test.TestModel::P1[=λ %0 → izumi.reflect.test.TestModel::X1[=0],=λ %0 → izumi.reflect.test.TestModel::X2[=0]] <!< izumi.reflect.test.TestModel::P0[=λ %0 → izumi.reflect.test.TestModel::X1[=0],=λ %0 → izumi.reflect.test.TestModel::X2[=0]]
1119[info] + izumi.reflect.test.TestModel::XP1[=λ %0 → izumi.reflect.test.TestModel::X1[=0]] <?< izumi.reflect.test.TestModel::P0[=λ %0 → izumi.reflect.test.TestModel::X2[=0],=λ %0 → izumi.reflect.test.TestModel::X1[=0]]
1120[info] + izumi.reflect.test.TestModel::XP1[=λ %0 → izumi.reflect.test.TestModel::X2[=0]] <?< izumi.reflect.test.TestModel::P0[=λ %0 → izumi.reflect.test.TestModel::X2[=0],=λ %0 → izumi.reflect.test.TestModel::X2[=0]]
1121[info] + izumi.reflect.test.TestModel::XP1[=λ %0 → izumi.reflect.test.TestModel::X2[=0]] <!< izumi.reflect.test.TestModel::P0[=λ %0 → izumi.reflect.test.TestModel::X2[=0],=λ %0 → izumi.reflect.test.TestModel::X1[=0]]
1122[info] + izumi.reflect.test.TestModel::XP1[=λ %0 → izumi.reflect.test.TestModel::X2[=0]] <!< izumi.reflect.test.TestModel::P0[=λ %0 → izumi.reflect.test.TestModel::X1[=0],=λ %0 → izumi.reflect.test.TestModel::X2[=0]]
1123[info] - should support unsound subtype checks (25 milliseconds)
1124[info] + izumi.reflect.test.TestModel::FM2[+izumi.reflect.test.TestModel::I2] <!< λ %0,%1 → izumi.reflect.test.TestModel::FM1[+0,+1]
1125[info] + scala.collection.immutable.List[+scala.Int] <!< λ %0 → scala.collection.immutable.List[+0]
1126[info] + scala.collection.immutable.Set[=scala.Int] <!< λ %0 → scala.collection.immutable.Set[=0]
1127[info] - should support swapped parents (39 milliseconds)
1128[info] + izumi.reflect.test.SharedLightTypeTagTest._$KT2[+izumi.reflect.test.TestModel::H1,+izumi.reflect.test.TestModel::I1] <?< izumi.reflect.test.SharedLightTypeTagTest._$KT1[+izumi.reflect.test.TestModel::I1,+izumi.reflect.test.TestModel::H1]
1129[info] + izumi.reflect.test.SharedLightTypeTagTest._$KT2[+izumi.reflect.test.TestModel::H1,+izumi.reflect.test.TestModel::I1] <!< izumi.reflect.test.SharedLightTypeTagTest._$KT1[+izumi.reflect.test.TestModel::H1,+izumi.reflect.test.TestModel::I1]
1130[info] + izumi.reflect.test.SharedLightTypeTagTest._$KT2[+izumi.reflect.test.TestModel::H2,+izumi.reflect.test.TestModel::I2] <?< izumi.reflect.test.SharedLightTypeTagTest._$KT1[+izumi.reflect.test.TestModel::I1,+izumi.reflect.test.TestModel::H1]
1131[info] + izumi.reflect.test.SharedLightTypeTagTest._$KT2[+izumi.reflect.test.TestModel::H2,+izumi.reflect.test.TestModel::I2] <!< izumi.reflect.test.SharedLightTypeTagTest._$KT1[+izumi.reflect.test.TestModel::H1,+izumi.reflect.test.TestModel::I1]
1132[info] + izumi.reflect.test.SharedLightTypeTagTest._$KK2[+scala.Int,+java.lang.String] <?< izumi.reflect.test.SharedLightTypeTagTest._$KK1[+java.lang.String,+scala.Int,+scala.Unit]
1133[info] + izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+izumi.reflect.test.TestModel::I2] <?< izumi.reflect.test.SharedLightTypeTagTest._$KK1[+izumi.reflect.test.TestModel::I1,+izumi.reflect.test.TestModel::H1,+scala.Unit]
1134[info] + izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+izumi.reflect.test.TestModel::I2] <!< izumi.reflect.test.SharedLightTypeTagTest._$KK1[+izumi.reflect.test.TestModel::H1,+izumi.reflect.test.TestModel::I1,+scala.Unit]
1135[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0] <!< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+izumi.reflect.test.TestModel::H1,+0,+scala.Unit]
1136[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]
1137[info] + λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] <?< λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]
1138[info] + λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] <!< λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]
1139[info] - should support subtyping of parents parameterized with type lambdas (7 milliseconds)
1140[info] + izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]] <?< izumi.reflect.test.TestModel::RoleParent[=λ %0 → scala.util.Either[+java.lang.Throwable,+0]]
1141[info] - should support subtyping of parents parameterized with type lambdas in combined tags (1 millisecond)
1142[info] + izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]] =?= izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]]
1143[info] - should support subtyping of parents parameterized with type lambdas in combined tags with multiple parameters (7 milliseconds)
1144[info] + izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String] =?= izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String]
1145[info] + izumi.reflect.test.TestModel::RoleChild2[=λ %0,%1 → scala.util.Either[+0,+1],=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleParent[=λ %0 → scala.util.Either[+java.lang.Throwable,+0]]
1146[info] - should support PDTs (6 milliseconds)
1147[info] + scala.Int =?= scala.Int
1148[info] + izumi.reflect.test.SharedLightTypeTagTest._$a0::A =!= scala.Int
1149[info] + izumi.reflect.test.SharedLightTypeTagTest._$a1::A =!= scala.Int
1150[info] + izumi.reflect.test.SharedLightTypeTagTest._$a1::A =!= java.lang.String
1151[info] + izumi.reflect.test.SharedLightTypeTagTest._$a1::A <?< izumi.reflect.test.SharedLightTypeTagTest._$a1::A
1152[info] + java.lang.String =?= java.lang.String
1153[info] - should intersections are associative (7 milliseconds)
1154[info] + {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1155[info] + {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} <?< {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1156[info] + {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} <?< {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1157[info] + λ %0 → {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} =?= λ %0 → {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]}
1158[info] + λ %0 → {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} <?< λ %0 → {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]}
1159[info] + λ %0 → {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} <?< λ %0 → {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]}
1160[info] - should runtime-combined intersections are associative (12 milliseconds)
1161[info] + ({izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} & izumi.reflect.test.TestModel::I1) => {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1162[info] + {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} debug== {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1163[info] + ({izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} & izumi.reflect.test.TestModel::I1) => {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1164[info] + {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} debug== {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1165[info] + (λ %0 → {izumi.reflect.test.TestModel::W1 & 0 & izumi.reflect.test.TestModel::W3[=scala.Int]})•(izumi.reflect.test.TestModel::I1) => {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1166[info] + (λ %0 → {izumi.reflect.test.TestModel::W1 & 0 & izumi.reflect.test.TestModel::W3[=scala.Int]})•(izumi.reflect.test.TestModel::I1) => {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1167[info] + (λ %0 → {izumi.reflect.test.TestModel::W1 & 0 & izumi.reflect.test.TestModel::W3[=scala.Int]})•(izumi.reflect.test.TestModel::I1) => {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1168[info] + (λ %0 → {izumi.reflect.test.TestModel::W1 & 0 & izumi.reflect.test.TestModel::W3[=scala.Int]})•(izumi.reflect.test.TestModel::I1) => {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} =?= {izumi.reflect.test.TestModel::I1 & izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1169[info] - should support type alias and refinement subtype checks (16 milliseconds)
1170[info] + izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})> <?< (java.lang.Object {type X = X})
1171[info] + (java.lang.Object {type X = X}) <!< izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>
1172[info] + (java.lang.Object {type X = X}) =!= izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>
1173[info] + izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})> <?< (java.lang.Object {type X = X})
1174[info] + (java.lang.Object {type X = X}) <!< izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>
1175[info] + (java.lang.Object {type X = X}) =!= izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>
1176[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1177[info] + (java.lang.Object {type X = Any}) <?< (java.lang.Object {type X = X})
1178[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1179[info] + (java.lang.Object {type X = X}) =!= (java.lang.Object {type X = Any})
1180[info] + (java.lang.Object {type X = Any}) <?< (java.lang.Object {type X = X})
1181[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1182[info] + (java.lang.Object {type X = X}) =!= (java.lang.Object {type X = Any})
1183[info] + (java.lang.Object {type X = X}) =?= (java.lang.Object {type X = X})
1184[info] + (java.lang.Object {type X = X}) <?< (java.lang.Object {type X = X})
1185[info] + (java.lang.Object {type X = X}) <?< (java.lang.Object {type X = X})
1186[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = X|<Nothing..AnyVal>})
1187[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1188[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1189[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1190[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})
1191[info] + izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})> <!< (java.lang.Object {type X = Any})
1192[info] + (java.lang.Object {type X = Int}) <?< (java.lang.Object {type X = X})
1193[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Int})
1194[info] + (java.lang.Object {type X = X}) =!= (java.lang.Object {type X = Int})
1195[info] + (java.lang.Object {type X = Int}) <?< (java.lang.Object {type X = X|<Nothing..AnyVal>})
1196[info] + (java.lang.Object {type X = X|<Nothing..AnyVal>}) <!< (java.lang.Object {type X = Int})
1197[info] + (java.lang.Object {type X = X|<Nothing..AnyVal>}) =!= (java.lang.Object {type X = Int})
1198[info] + (java.lang.Object {type X = Int}) <!< (java.lang.Object {type X = Any})
1199[info] + (java.lang.Object {type X = Any}) <!< (java.lang.Object {type X = Int})
1200[info] + (java.lang.Object {type X = Any}) =!= (java.lang.Object {type X = Int})
1201[info] + (java.lang.Object {type X = Int}) <!< (java.lang.Object {type X = Any})
1202[info] + (java.lang.Object {type X = Any}) <!< (java.lang.Object {type X = Int})
1203[info] + (java.lang.Object {type X = Any}) =!= (java.lang.Object {type X = Int})
1204[info] - should support refinement higher-kinded subtype checks (10 milliseconds)
1205[info] + (java.lang.Object {type F = λ %0 → 0}) <?< (java.lang.Object {type F = F|<Nothing..λ %0 → Any>})
1206[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) <!< (java.lang.Object {type F = λ %0 → 0})
1207[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) =!= (java.lang.Object {type F = λ %0 → 0})
1208[info] + (java.lang.Object {type F = λ %0 → 0}) <!< (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>})
1209[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) <!< (java.lang.Object {type F = λ %0 → 0})
1210[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) =!= (java.lang.Object {type F = λ %0 → 0})
1211[info] + izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})> <?< (java.lang.Object {type F = λ %0 → 0})
1212[info] + (java.lang.Object {type F = λ %0 → 0}) <!< izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>
1213[info] + (java.lang.Object {type F = λ %0 → 0}) =!= izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>
1214[info] + izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})> <?< (java.lang.Object {type F = F|<Nothing..λ %0 → Any>})
1215[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) <!< izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>
1216[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) =!= izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>
1217[info] + izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})> <!< (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>})
1218[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) <!< izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>
1219[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) =!= izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>
1220[info] - should support literal types (10 milliseconds)
1221[info] + "str2" =?= "str2"
1222[info] + "str1" =!= "str2"
1223[info] + "str" <?< java.lang.String
1224[info] + java.lang.String <!< "str"
1225[info] + java.lang.String =!= "str"
1226[info] + "str" <!< scala.Int
1227[info] - should resolve comparisons of object and trait with the same name (2 milliseconds)
1228[info] + izumi.reflect.test.TestModel::YieldOpCounts <!< izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]]
1229[info] + izumi.reflect.test.TestModel::YieldOpCounts <?< izumi.reflect.test.TestModel::YieldOpCounts
1230[info] + izumi.reflect.test.TestModel::YieldOpCounts =!= izumi.reflect.test.TestModel::YieldOpCounts
1231[info] + izumi.reflect.test.TestModel::YieldOpCounts <!< izumi.reflect.test.TestModel::YieldOpCounts
1232[info] - should resolve prefixes of annotated types (0 milliseconds)
1233[info] + izumi.reflect.test.TestModel::TPrefix::T =?= izumi.reflect.test.TestModel::TPrefix::T
1234[info] - should `withoutArgs` comparison works (33 milliseconds)
1235[info] + scala.collection.immutable.Set =?= scala.collection.immutable.Set
1236[info] + scala.collection.mutable.LinkedHashSet <?< scala.collection.Set
1237[info] + scala.collection.immutable.ListSet <?< scala.collection.Set
1238[info] + scala.collection.immutable.ListSet <?< scala.collection.immutable.Set
1239[info] + scala.collection.BitSet <?< scala.collection.Set
1240[info] - should `typeArgs` works (12 milliseconds)
1241[info] + scala.Int =?= scala.Int
1242[info] + scala.Int <?< scala.AnyVal
1243[info] + izumi.reflect.test.TestModel::T0[=λ %1:0 → scala.collection.immutable.List[+1:0],=λ %0 → scala.Option[+0]] =?= izumi.reflect.test.TestModel::T0[=λ %0 → scala.collection.immutable.List[+0],=λ %0 → scala.Option[+0]]
1244[info] - should support subtyping of a simple combined type (1 millisecond)
1245[info] + izumi.reflect.test.TestModel::ApplePaymentProvider[=λ %0 → 0] <?< izumi.reflect.test.TestModel::H1
1246[info] - should issue #762: properly strip away annotated types / empty refinements / type aliases (6 milliseconds)
1247[info] + java.lang.String =?= java.lang.String
1248[info] + java.lang.String =?= java.lang.String
1249[info] + java.lang.String =?= java.lang.String
1250[info] + java.lang.String debug== java.lang.String
1251[info] + java.lang.String debug== java.lang.String
1252[info] + java.lang.String debug== java.lang.String
1253[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1254[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1255[info] - should calculate identical hashCode in parsed and constructed instances (0 milliseconds)
1256[info] + java.lang.String =?= java.lang.String
1257[info] + java.lang.String =?= java.lang.String
1258[info] - should support non-positional typetag combination (3 milliseconds)
1259[info] + (λ %0,%1 → scala.util.Either[+0,+1])•(None,Some(scala.Unit)) => λ %0 → scala.util.Either[+0,+scala.Unit] =?= λ %0 → scala.util.Either[+0,+scala.Unit]
1260[info] - should support additional mixin traits after first trait with a HKT parameter (9 milliseconds)
1261[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< izumi.reflect.test.TestModel::J1[=λ %0 → scala.Option[+0]]
1262[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< izumi.reflect.test.TestModel::J3
1263[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< izumi.reflect.test.TestModel::J2
1264[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< {izumi.reflect.test.TestModel::J2 & izumi.reflect.test.TestModel::J1[=λ %0 → scala.Option[+0]]}
1265[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< {izumi.reflect.test.TestModel::J2 & izumi.reflect.test.TestModel::J3}
1266[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< {izumi.reflect.test.TestModel::J2 & izumi.reflect.test.TestModel::J3 & izumi.reflect.test.TestModel::J1[=λ %0 → scala.Option[+0]]}
1267[info] - should support LTagK* family summoners (1 millisecond)
1268[info] + λ %0 → scala.collection.immutable.List[+0] =?= λ %0 → scala.collection.immutable.List[+0]
1269[info] + λ %0,%1 → scala.util.Either[+0,+1] =?= λ %0,%1 → scala.util.Either[+0,+1]
1270[info] - should support higher-kinded intersection type equality (1 millisecond)
1271[info] + λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} =?= λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]}
1272[info] + λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} =!= λ %0 → {izumi.reflect.test.TestModel::W2 & izumi.reflect.test.TestModel::W4[=0]}
1273[info] - should support contravariance (4 milliseconds)
1274[info] + scala.Function1[-scala.Any,+scala.Int] <?< scala.Function1[-scala.Int,+scala.Int]
1275[info] + scala.Function1[-scala.Int,+scala.Int] <!< scala.Function1[-scala.Any,+scala.Int]
1276[info] + scala.Function1[-scala.Int,+scala.Int] =!= scala.Function1[-scala.Any,+scala.Int]
1277[info] - should support typetag combination (8 milliseconds)
1278[info] + (λ %0 → izumi.reflect.test.TestModel::T1[=0])•(λ %0 → 0) => izumi.reflect.test.TestModel::T1[=λ %0 → 0] =?= izumi.reflect.test.TestModel::T1[=λ %0 → 0]
1279[info] + (λ %0 → izumi.reflect.test.TestModel::T1[=0])•(λ %0 → scala.collection.immutable.List[+0]) => izumi.reflect.test.TestModel::T1[=λ %0 → scala.collection.immutable.List[+0]] =?= izumi.reflect.test.TestModel::T1[=λ %0 → scala.collection.immutable.List[+0]]
1280[info] + (λ %0 → izumi.reflect.test.TestModel::T1[=0])•(λ %0 → scala.Unit) => izumi.reflect.test.TestModel::T1[=λ %0 → scala.Unit] =?= izumi.reflect.test.TestModel::T1[=λ %0 → scala.Unit]
1281[info] + (λ %0 → izumi.reflect.test.TestModel::T1[=0])•(λ %0 → scala.collection.immutable.List[+0]) => izumi.reflect.test.TestModel::T1[=λ %0 → scala.collection.immutable.List[+0]] =?= izumi.reflect.test.TestModel::T1[=λ %0 → scala.collection.immutable.List[+0]]
1282[info] + (λ %0 → scala.collection.immutable.List[+0])•(scala.Int) => scala.collection.immutable.List[+scala.Int] =?= scala.collection.immutable.List[+scala.Int]
1283[info] + (λ %0,%1 → scala.util.Either[+0,+1])•(scala.Unit) => λ %1 → scala.util.Either[+scala.Unit,+1] =?= λ %0 → scala.util.Either[+scala.Unit,+0]
1284[info] + (λ %0 → izumi.reflect.test.TestModel::T2[=0])•(λ %0,%1 → izumi.reflect.test.TestModel::T0[=0,=1]) => izumi.reflect.test.TestModel::T2[=λ %0,%1 → izumi.reflect.test.TestModel::T0[=0,=1]] =?= izumi.reflect.test.TestModel::T2[=λ %0,%1 → izumi.reflect.test.TestModel::T0[=0,=1]]
1285[info] + (λ %0 → {(0 {def a(0): 0, type M = 0}) & izumi.reflect.test.TestModel::W1})•(scala.Int) => {(scala.Int {def a(scala.Int): scala.Int, type M = Int}) & izumi.reflect.test.TestModel::W1} =?= {(scala.Int {def a(scala.Int): scala.Int, type M = Int}) & izumi.reflect.test.TestModel::W1}
1286[info] + (λ %0 → izumi.reflect.test.TestModel::T0[=λ %1:0 → 1:0,=0])•(λ %0 → scala.collection.immutable.List[+0]) => izumi.reflect.test.TestModel::T0[=λ %1:0 → 1:0,=λ %0 → scala.collection.immutable.List[+0]] =?= izumi.reflect.test.TestModel::T0[=λ %0 → 0,=λ %0 → scala.collection.immutable.List[+0]]
1287[info] - should tautological intersections with Any/Object are discarded from internal structure (8 milliseconds)
1288[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1289[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1290[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1291[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1292[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1293[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1294[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1295[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1296[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1297[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1298[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1299[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1300[info] - should wildcards are supported (33 milliseconds)
1301[info] + scala.collection.immutable.Set[=?] =!= scala.collection.immutable.Set[=scala.Any]
1302[info] + scala.collection.immutable.Set[=scala.Int] <?< scala.collection.immutable.Set[=?]
1303[info] + scala.collection.immutable.Set[=?] <!< scala.collection.immutable.Set[=scala.Int]
1304[info] + scala.collection.immutable.Set[=scala.Any] <?< scala.collection.immutable.Set[=?]
1305[info] + scala.collection.immutable.Set[=?] <!< scala.collection.immutable.Set[=scala.Any]
1306[info] + scala.collection.immutable.List[+?] =!= scala.collection.immutable.List[+scala.Any]
1307[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+?]
1308[info] + scala.collection.immutable.List[+?] <!< scala.collection.immutable.List[+scala.Int]
1309[info] + scala.collection.immutable.List[+scala.Any] <?< scala.collection.immutable.List[+?]
1310[info] + scala.collection.immutable.List[+?] <?< scala.collection.immutable.List[+scala.Any]
1311[info] + scala.Function1[-scala.Int,+scala.Int] =!= scala.Function1[-?,+scala.Int]
1312[info] + scala.Function1[-scala.Int,+scala.Int] <?< scala.Function1[-?,+scala.Int]
1313[info] + scala.Function1[-?,+scala.Int] <?< scala.Function1[-scala.Int,+scala.Int]
1314[info] - should wildcards with bounds are supported (1 millisecond)
1315[info] + scala.Option[+izumi.reflect.test.TestModel::W1] =!= scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]
1316[info] + scala.Option[+izumi.reflect.test.TestModel::H2] =!= scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]
1317[info] + scala.Option[+scala.Any] =!= scala.Option[+?: <izumi.reflect.test.TestModel::H4..scala.Any>]
1318[info] - should generate tags for wildcards with type boundaries (23 milliseconds)
1319[info] + scala.Option[+izumi.reflect.test.TestModel::W1] =!= scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]
1320[info] + scala.Option[+izumi.reflect.test.TestModel::W1] <?< scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]
1321[info] + scala.Option[+izumi.reflect.test.TestModel::W2] <?< scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]
1322[info] + scala.Option[+izumi.reflect.test.TestModel::W2] <!< scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::I1>]
1323[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W2>] <?< scala.Option[+izumi.reflect.test.TestModel::W1]
1324[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W2>] <?< scala.Option[+izumi.reflect.test.TestModel::W2]
1325[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::I1>] <!< scala.Option[+izumi.reflect.test.TestModel::W2]
1326[info] + scala.Option[+izumi.reflect.test.TestModel::H3] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]
1327[info] + scala.Option[+izumi.reflect.test.TestModel::H1] <!< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]
1328[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>] <!< scala.Option[+izumi.reflect.test.TestModel::H3]
1329[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..scala.Any>] <!< scala.Option[+izumi.reflect.test.TestModel::H3]
1330[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::H2>] <!< scala.Option[+izumi.reflect.test.TestModel::H3]
1331[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::H2>] <?< scala.Option[+izumi.reflect.test.TestModel::H1]
1332[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..scala.Any>] <!< scala.Option[+izumi.reflect.test.TestModel::H1]
1333[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>] <?< scala.Option[+izumi.reflect.test.TestModel::H1]
1334[info] + scala.Option[+izumi.reflect.test.TestModel::H4] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]
1335[info] + scala.Option[+izumi.reflect.test.TestModel::H2] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]
1336[info] + scala.Option[+izumi.reflect.test.TestModel::H5] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]
1337[info] - should https://github.com/zio/izumi-reflect/issues/315 regression test 2.1.0-M1: IntegrationCheck[F] should not be related to IntegrationCheck[Identity] (2 milliseconds)
1338[info] + izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → scala.Option[+0]] <!< izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → 0]
1339[info] + izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → 0] <!< izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → scala.Option[+0]]
1340[info] + izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → 0] =!= izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → scala.Option[+0]]
1341[info] - should normalize stable PDTs (https://github.com/zio/zio/issues/3390) (4 milliseconds)
1342[info] + izumi.reflect.test.TestModel::PDTNormA::Service =?= izumi.reflect.test.TestModel::PDTNormA::Service
1343[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service
1344[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service
1345[info] + izumi.reflect.test.TestModel::PDTNormA::Service debug== izumi.reflect.test.TestModel::PDTNormA::Service
1346[info] + izumi.reflect.test.TestModel::PDTNormA::Service =?= izumi.reflect.test.TestModel::PDTNormA::Service
1347[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service
1348[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service
1349[info] + izumi.reflect.test.TestModel::PDTNormA::Service debug== izumi.reflect.test.TestModel::PDTNormA::Service
1350[info] + izumi.reflect.test.TestModel::PDTNormA =?= izumi.reflect.test.TestModel::PDTNormA
1351[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA
1352[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA
1353[info] + izumi.reflect.test.TestModel::PDTNormA debug== izumi.reflect.test.TestModel::PDTNormA
1354[info] + izumi.reflect.test.TestModel::PDTNormA =?= izumi.reflect.test.TestModel::PDTNormA
1355[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA
1356[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA
1357[info] + izumi.reflect.test.TestModel::PDTNormA debug== izumi.reflect.test.TestModel::PDTNormA
1358[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal =?= izumi.reflect.test.SharedLightTypeTagTest._$literal
1359[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal <?< izumi.reflect.test.SharedLightTypeTagTest._$literal
1360[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal <?< izumi.reflect.test.SharedLightTypeTagTest._$literal
1361[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal debug== izumi.reflect.test.SharedLightTypeTagTest._$literal
1362[info] - should distinguish nested path dependent types (https://github.com/zio/izumi-reflect/issues/363) (0 milliseconds)
1363[info] + izumi.reflect.test.SharedLightTypeTagTest._$A::Nested::Member =!= izumi.reflect.test.SharedLightTypeTagTest._$B::Nested::Member
1364[info] - should dealias nested singletons, regression test for singleton dealias regression introduced in 3.0.0 (https://github.com/zio/izumi-reflect/pull/504) (2 milliseconds)
1365[info] + izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO =?= izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO
1366[info] + izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO <?< izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO
1367[info] + izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO <?< izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO
1368[info] - should dealias deeply singleton val aliases (1 millisecond)
1369[info] + izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member =?= izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member
1370[info] + izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member <?< izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member
1371[info] + izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member <?< izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member
1372[info] - should properly dealias and assign prefixes to existential types and wildcards (22 milliseconds)
1373[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+?]
1374[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+?]
1375[info] + scala.collection.immutable.List[+?] <?< scala.collection.immutable.List[+?]
1376[info] + scala.collection.immutable.List[+?] <?< scala.collection.immutable.List[+?]
1377[info] + scala.collection.immutable.List[+?] debug== scala.collection.immutable.List[+?]
1378[info] - should no redundant $ in object names (7 milliseconds)
1379[info] - should support basic None.type subtype check (2 milliseconds)
1380[info] + scala.None <?< scala.Option[+scala.Int]
1381[info] - should supports complex type lambdas (3 milliseconds)
1382[info] + λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]] =?= λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]]
1383[info] + λ %0 → izumi.reflect.test.TestModel::FM2[+0[=scala.util.Either[+izumi.reflect.test.TestModel::W1,+izumi.reflect.test.TestModel::W2]]] =?= λ %0 → izumi.reflect.test.TestModel::FM2[+0[=scala.util.Either[+izumi.reflect.test.TestModel::W1,+izumi.reflect.test.TestModel::W2]]]
1384[info] + λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]] <?< λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]]
1385[info] - should applied tags should not contain junk bases (7 milliseconds)
1386[info] - should intersection lambda tags should not contain junk bases (4 milliseconds)
1387[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} debug== {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1388[info] - should lambda tags should not contain junk bases (4 milliseconds)
1389[info] - should No degenerate lambdas (regression test https://github.com/zio/izumi-reflect/issues/345) (3 milliseconds)
1390[info] - should check subtyping when higher-kinds are involved on Scala 3 (4 milliseconds)
1391[info] + izumi.reflect.test.TestModel::FT2[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]] <?< izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1392[info] + izumi.reflect.test.TestModel::FT2[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]] <?< izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1393[info] + izumi.reflect.test.TestModel::FT2[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]] =!= izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1394[info] + izumi.reflect.test.TestModel::FT2[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]] <?< izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1395[info] + izumi.reflect.test.TestModel::FT2[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]] =!= izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1396[info] + izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]] <?< izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1397[info] + izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT2[+0]] =!= izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1398[info] + izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]] =?= izumi.reflect.test.TestModel::FT1[+λ %0 → izumi.reflect.test.TestModel::IT1[+0]]
1399[info] - should support higher-kinded intersection type subtyping (4 milliseconds)
1400[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} <?< izumi.reflect.test.TestModel::W3[=scala.Int]
1401[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} <?< izumi.reflect.test.TestModel::W1
1402[info] + {izumi.reflect.test.TestModel::W2 & izumi.reflect.test.TestModel::W4[=scala.Int]} <?< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]}
1403[info] + λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} <?< λ %0 → izumi.reflect.test.TestModel::W3[=0]
1404[info] + λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} <?< izumi.reflect.test.TestModel::W1
1405[info] + λ %0 → izumi.reflect.test.TestModel::W4[=0] <?< λ %0 → izumi.reflect.test.TestModel::W3[=0]
1406[info] + λ %0 → {izumi.reflect.test.TestModel::W2 & izumi.reflect.test.TestModel::W4[=0]} <?< λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]}
1407[info] - should support higher-kinded intersection type combination (21 milliseconds)
1408[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1409[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1410[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1411[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} =?= {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1412[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} =?= {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]}
1413[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} =!= scala.util.Either[+scala.Int,+scala.Boolean]
1414[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} =!= {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Int] & izumi.reflect.test.TestModel::W5[=scala.Boolean]}
1415[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <!< scala.util.Either[+scala.Int,+scala.Boolean]
1416[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <!< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Int] & izumi.reflect.test.TestModel::W5[=scala.Boolean]}
1417[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< izumi.reflect.test.TestModel::W5[=scala.Int]
1418[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< izumi.reflect.test.TestModel::W4[=scala.Boolean]
1419[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< izumi.reflect.test.TestModel::W3[=scala.Boolean]
1420[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< izumi.reflect.test.TestModel::W1
1421[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< izumi.reflect.test.TestModel::W2
1422[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <?< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Boolean]}
1423[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <!< izumi.reflect.test.TestModel::W4[=scala.Int]
1424[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <!< izumi.reflect.test.TestModel::W3[=scala.Int]
1425[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <!< izumi.reflect.test.TestModel::W5[=scala.Boolean]
1426[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W4[=scala.Boolean] & izumi.reflect.test.TestModel::W5[=scala.Int]} <!< {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W5[=scala.Boolean]}
1427[info] - should support structural & refinement type subtype checks (3 milliseconds)
1428[info] + (java.lang.Object {def a(): scala.Int}) =?= (java.lang.Object {def a(): scala.Int})
1429[info] + (java.lang.Object {def a(): scala.Int}) <?< (java.lang.Object {def a(): scala.Int})
1430[info] + (java.lang.Object {def a(): scala.Int}) <?< (java.lang.Object {def a(): scala.Int})
1431[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =?= (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1432[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1433[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1434[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< izumi.reflect.test.TestModel::C
1435[info] + izumi.reflect.test.TestModel::C <!< (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1436[info] + izumi.reflect.test.TestModel::C =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1437[info] + (izumi.reflect.test.TestModel::C {type A = Int}) <?< izumi.reflect.test.TestModel::C
1438[info] + izumi.reflect.test.TestModel::C <!< (izumi.reflect.test.TestModel::C {type A = Int})
1439[info] + izumi.reflect.test.TestModel::C =!= (izumi.reflect.test.TestModel::C {type A = Int})
1440[info] + (izumi.reflect.test.TestModel::C {type A = A|<Nothing..Int>}) <?< izumi.reflect.test.TestModel::C
1441[info] + izumi.reflect.test.TestModel::C <!< (izumi.reflect.test.TestModel::C {type A = A|<Nothing..Int>})
1442[info] + izumi.reflect.test.TestModel::C =!= (izumi.reflect.test.TestModel::C {type A = A|<Nothing..Int>})
1443[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int}) <?< (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1444[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <!< (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int})
1445[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int})
1446[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< (java.lang.Object {def a(): scala.Int})
1447[info] + (java.lang.Object {def a(): scala.Int}) <!< (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1448[info] + (java.lang.Object {def a(): scala.Int}) =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1449[info] - should support structural & refinement type equality (2 milliseconds)
1450[info] + {(java.lang.Object {type T = {Int & "str"}}) & izumi.reflect.test.TestModel::W4[="str"]} =!= {(java.lang.Object {type T = {Long & "str"}}) & izumi.reflect.test.TestModel::W4[="str"]}
1451[info] + (java.lang.Object {def a(): scala.Int}) =?= (java.lang.Object {def a(): scala.Int})
1452[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =?= (izumi.reflect.test.TestModel::C {def a(): scala.Int})
1453[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= (java.lang.Object {def a(): scala.Int})
1454[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= izumi.reflect.test.TestModel::C
1455[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int})
1456[info] + scala.Int =?= scala.Int
1457[info] - should strong summons test (0 milliseconds)
1458[info] - should distinguishes between val and type structural refinements (1 millisecond)
1459[info] + (java.lang.Object {type T = Either[+Int,+String]}) <!< (java.lang.Object {def T(): scala.util.Either[+scala.Int,+java.lang.String]})
1460[info] + (java.lang.Object {def T(): scala.util.Either[+scala.Int,+java.lang.String]}) <!< (java.lang.Object {type T = Either[+Int,+String]})
1461[info] + (java.lang.Object {def T(): scala.util.Either[+scala.Int,+java.lang.String]}) =!= (java.lang.Object {type T = Either[+Int,+String]})
1462[info] - should does not contain intersections in plain structural refinements (0 milliseconds)
1463[info] - should support equal-bounded types as paradoxical (before 2.3.0 and since 2.3.6 NOT equal to their underlying) (1 millisecond)
1464[info] + java.lang.String <?< izumi.reflect.test.SharedLightTypeTagTest._$x::X|<java.lang.String..java.lang.String>
1465[info] + izumi.reflect.test.SharedLightTypeTagTest._$x::X|<java.lang.String..java.lang.String> <?< java.lang.String
1466[info] + izumi.reflect.test.SharedLightTypeTagTest._$x::X|<java.lang.String..java.lang.String> =!= java.lang.String
1467[info] - should support structural subtype checks (13 milliseconds)
1468[info] + (java.lang.Object {type T = List[+Int]}) <!< (java.lang.Object {type T = λ %0 → List[+0]})
1469[info] + (java.lang.Object {type T = λ %0 → List[+0]}) <!< (java.lang.Object {type T = List[+Int]})
1470[info] + (java.lang.Object {type T = λ %0 → List[+0]}) =!= (java.lang.Object {type T = List[+Int]})
1471[info] + (java.lang.Object {type T = List[+Int]}) <?< (java.lang.Object {type T = T|<Nothing..List[+Any]>})
1472[info] + (java.lang.Object {type T = T|<Nothing..List[+Any]>}) <!< (java.lang.Object {type T = List[+Int]})
1473[info] + (java.lang.Object {type T = T|<Nothing..List[+Any]>}) =!= (java.lang.Object {type T = List[+Int]})
1474[info] + (java.lang.Object {type T = Int}) <?< (java.lang.Object {type T = T|<Nothing..AnyVal>})
1475[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) <!< (java.lang.Object {type T = Int})
1476[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) =!= (java.lang.Object {type T = Int})
1477[info] + (java.lang.Object {type T = Int}) <?< (java.lang.Object {type T = T})
1478[info] + (java.lang.Object {type T = T}) <!< (java.lang.Object {type T = Int})
1479[info] + (java.lang.Object {type T = T}) =!= (java.lang.Object {type T = Int})
1480[info] + (java.lang.Object {type T = String}) <?< (java.lang.Object {type T = T|<Nothing..CharSequence>})
1481[info] + (java.lang.Object {type T = T|<Nothing..CharSequence>}) <!< (java.lang.Object {type T = String})
1482[info] + (java.lang.Object {type T = T|<Nothing..CharSequence>}) =!= (java.lang.Object {type T = String})
1483[info] + (java.lang.Object {def T(): scala.Int}) <?< (java.lang.Object {def T(): scala.AnyVal})
1484[info] + (java.lang.Object {def T(): scala.AnyVal}) <!< (java.lang.Object {def T(): scala.Int})
1485[info] + (java.lang.Object {def T(): scala.AnyVal}) =!= (java.lang.Object {def T(): scala.Int})
1486[info] + (java.lang.Object {type T = Int}) <?< (java.lang.Object {type T = T|<Nothing..AnyVal>})
1487[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) <!< (java.lang.Object {type T = Int})
1488[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) =!= (java.lang.Object {type T = Int})
1489[info] + (java.lang.Object {type T = Int}) <!< (java.lang.Object {type T = T|<Nothing..CharSequence>})
1490[info] + (java.lang.Object {def T(): scala.Int}) <!< (java.lang.Object {type T = T})
1491[info] + (java.lang.Object {type T = T}) <!< (java.lang.Object {def T(): scala.Int})
1492[info] + (java.lang.Object {type T = T}) =!= (java.lang.Object {def T(): scala.Int})
1493[info] - should what about non-empty refinements with intersections (1 millisecond)
1494[info] - should support contravariance in refinement method comparisons (0 milliseconds)
1495[info] + (java.lang.Object {def compare(scala.AnyVal): scala.Int}) <?< (java.lang.Object {def compare(scala.Int): scala.Int})
1496[info] + (java.lang.Object {def compare(scala.Int): scala.Int}) <!< (java.lang.Object {def compare(scala.AnyVal): scala.Int})
1497[info] + (java.lang.Object {def compare(scala.Int): scala.Int}) =!= (java.lang.Object {def compare(scala.AnyVal): scala.Int})
1498[info] - should support human-readable representation (5 milliseconds)
1499[info] - should covariance of a concrete inheritor to a parent with a higher-kinded type parameter (4 milliseconds)
1500[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=0] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]
1501[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int]
1502[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=?]
1503[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int] <!< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Any]
1504[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]
1505[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]
1506[info] - should covariance of a concrete inheritor to a parent with a complex-shaped higher-kinded type parameter (3 milliseconds)
1507[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=0,=scala.Unit] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]
1508[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int]
1509[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=?]
1510[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <!< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Any]
1511[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]
1512[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]
1513[info] - should covariance of a concrete inheritor to a parent with a swap type lambda (3 milliseconds)
1514[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=0] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0,=scala.Int]
1515[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Unit,=scala.Int]
1516[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=?,=?]
1517[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <!< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Any,=scala.Any]
1518[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0,=1]]
1519[info] - should covariance of a concrete inheritor to a parent with a proper type parameter (0 milliseconds)
1520[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer <?< izumi.reflect.test.SharedLightTypeTagTest._$Container
1521[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+izumi.reflect.test.SharedLightTypeTagTest._$Container]
1522[info] - should covariance of a parameterized inheritor to a parent with an indirect proper type parameter (1 millisecond)
1523[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer <?< izumi.reflect.test.SharedLightTypeTagTest._$Container
1524[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container]
1525[info] - should covariance of a parameterized inheritor to a parent with an indirect parameterized type parameter (1 millisecond)
1526[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[+scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[+scala.AnyVal]
1527[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container[+scala.AnyVal]]
1528[info] - should covariance of a parameterized inheritor to a parent with an indirect parameterized type parameter with different arity (1 millisecond)
1529[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[+scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.AnyVal]
1530[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.AnyVal]]
1531[info] - should covariance of a self-parameterized inheritor to a parent with an indirect parameterized type parameter with different arity (1 millisecond)
1532[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[+izumi.reflect.test.SharedLightTypeTagTest._$AContainer[+scala.Int]] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.AnyVal]]
1533[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.AnyVal],+izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.Any]]
1534[info] - should regression test for https://github.com/zio/izumi-reflect/issues/511 (1 millisecond)
1535[info] - should null type is supported (1 millisecond)
1536[info] + scala.Null <?< izumi.reflect.test.TestModel::I1
1537[info] + izumi.reflect.test.TestModel::I1 <!< scala.Null
1538[info] + izumi.reflect.test.TestModel::I1 =!= scala.Null
1539[info] + scala.Nothing <?< scala.Null
1540[info] - should fulldb should contain inheritance db of direct type argument (0 milliseconds)
1541[info] - should unapplied inheritance db should contain inheritance db of direct type argument (0 milliseconds)
1542[info] - should both dbs should contain db of direct self-nested type argument (0 milliseconds)
1543[info] - should fulldb should contain inheritance db of inherited type argument (0 milliseconds)
1544[info] - should unapplied inheritance db should contain inheritance db of inherited type argument (0 milliseconds)
1545[info] - should both dbs should NOT contain inheritance db of direct parent type (1 millisecond)
1546[info] - should HKT List dbs should not contain superfluous base types (1 millisecond)
1547[info] - should subtype check succeeds when child type has absorbed a covariant type parameter of the supertype (4 milliseconds)
1548[info] + scala.collection.immutable.Set[=scala.Int] <?< scala.collection.Iterable[+scala.AnyVal]
1549[info] + izumi.reflect.test.TestModel::F3 <?< izumi.reflect.test.TestModel::F2[+scala.Int]
1550[info] + izumi.reflect.test.TestModel::F2[+scala.Int] <!< izumi.reflect.test.TestModel::F3
1551[info] + izumi.reflect.test.TestModel::F2[+scala.Int] =!= izumi.reflect.test.TestModel::F3
1552[info] + izumi.reflect.test.TestModel::F3 <?< izumi.reflect.test.TestModel::F2[+scala.Any]
1553[info] + izumi.reflect.test.TestModel::F2[+scala.Any] <!< izumi.reflect.test.TestModel::F3
1554[info] + izumi.reflect.test.TestModel::F2[+scala.Any] =!= izumi.reflect.test.TestModel::F3
1555[info] + izumi.reflect.test.TestModel::F3 <?< izumi.reflect.test.TestModel::F2[+scala.AnyVal]
1556[info] + izumi.reflect.test.TestModel::F2[+scala.AnyVal] <!< izumi.reflect.test.TestModel::F3
1557[info] + izumi.reflect.test.TestModel::F2[+scala.AnyVal] =!= izumi.reflect.test.TestModel::F3
1558[info] - should regression test 3.0.4: subtype check succeeds versus a parent parameterized with Identity type lambda (1 millisecond)
1559[info] + izumi.reflect.test.TestModel::TargetRole <?< izumi.reflect.test.TestModel::AbstractRole[=λ %0 → 0]
1560[info] + izumi.reflect.test.TestModel::AbstractRole[=λ %0 → 0] <!< izumi.reflect.test.TestModel::TargetRole
1561[info] + izumi.reflect.test.TestModel::AbstractRole[=λ %0 → 0] =!= izumi.reflect.test.TestModel::TargetRole
1562[info] lightweight type tags (Dotty)
1563[info] - should tautological intersections with Matchable are discarded from internal structure (Scala 3 specific, Matchable) (2 milliseconds)
1564[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1565[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1566[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1567[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1568[info] - should tautological intersections with Matchable are discarded from internal structure (Scala 3 specific, Matchable) (Tag) (2 milliseconds)
1569[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1570[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1571[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1572[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1573[info] - should tautological unions with Any/AnyRef/Matchable/Object are discarded from internal structure (Scala 3 specific, Matchable) (2 milliseconds)
1574[info] + scala.Any =?= scala.Any
1575[info] + scala.Any <?< scala.Any
1576[info] + scala.Any <?< scala.Any
1577[info] + scala.Any debug== scala.Any
1578[info] + scala.Matchable =?= scala.Matchable
1579[info] + scala.Matchable <?< scala.Matchable
1580[info] + scala.Matchable <?< scala.Matchable
1581[info] + scala.Matchable debug== scala.Matchable
1582[info] + java.lang.Object =?= java.lang.Object
1583[info] + java.lang.Object <?< java.lang.Object
1584[info] + java.lang.Object <?< java.lang.Object
1585[info] + java.lang.Object debug== java.lang.Object
1586[info] + java.lang.Object =?= java.lang.Object
1587[info] + java.lang.Object <?< java.lang.Object
1588[info] + java.lang.Object <?< java.lang.Object
1589[info] + java.lang.Object debug== java.lang.Object
1590[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1591[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1592[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1593[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1594[info] - should tautological unions with Any/AnyRef/Matchable/Object are discarded from internal structure (Scala 3 specific, Matchable) (Tag) (2 milliseconds)
1595[info] + scala.Any =?= scala.Any
1596[info] + scala.Any <?< scala.Any
1597[info] + scala.Any <?< scala.Any
1598[info] + scala.Any debug== scala.Any
1599[info] + scala.Matchable =?= scala.Matchable
1600[info] + scala.Matchable <?< scala.Matchable
1601[info] + scala.Matchable <?< scala.Matchable
1602[info] + scala.Matchable debug== scala.Matchable
1603[info] + java.lang.Object =?= java.lang.Object
1604[info] + java.lang.Object <?< java.lang.Object
1605[info] + java.lang.Object <?< java.lang.Object
1606[info] + java.lang.Object debug== java.lang.Object
1607[info] + java.lang.Object =?= java.lang.Object
1608[info] + java.lang.Object <?< java.lang.Object
1609[info] + java.lang.Object <?< java.lang.Object
1610[info] + java.lang.Object debug== java.lang.Object
1611[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]
1612[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1613[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]
1614[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]
1615[info] - should support top-level abstract types (Scala 3 specific, top level type aliases) (1 millisecond)
1616[info] + izumi.reflect.test.LightTypeTagTest$package::LightTypeTagTestT|<scala.Nothing..java.lang.String> <?< java.lang.String
1617[info] + java.lang.String <!< izumi.reflect.test.LightTypeTagTest$package::LightTypeTagTestT|<scala.Nothing..java.lang.String>
1618[info] + java.lang.String =!= izumi.reflect.test.LightTypeTagTest$package::LightTypeTagTestT|<scala.Nothing..java.lang.String>
1619[info] - should support opaque types (21 milliseconds)
1620[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< scala.collection.immutable.List[+scala.Int]
1621[info] + scala.collection.immutable.List[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque
1622[info] + scala.collection.immutable.List[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque
1623[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< scala.collection.immutable.Seq[+scala.Int]
1624[info] + scala.collection.immutable.Seq[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque
1625[info] + scala.collection.immutable.Seq[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque
1626[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]>
1627[info] + izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]> <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque
1628[info] + izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]> =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque
1629[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1630[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque
1631[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque
1632[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <?< scala.collection.immutable.List[+scala.Int]
1633[info] + scala.collection.immutable.List[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1634[info] + scala.collection.immutable.List[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1635[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <?< scala.collection.immutable.Seq[+scala.Int]
1636[info] + scala.collection.immutable.Seq[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1637[info] + scala.collection.immutable.Seq[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1638[info] + izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]> <?< scala.collection.immutable.Seq[+scala.Int]
1639[info] + scala.collection.immutable.Seq[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]>
1640[info] + scala.collection.immutable.Seq[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]>
1641[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <?< izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]>
1642[info] + izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]> <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1643[info] + izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]> =!= izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>
1644[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> =!= izumi.reflect.test.LightTypeTagTest._$x::T|<scala.collection.immutable.List[+scala.Int]..scala.collection.immutable.List[+scala.Int]>
1645[info] - should basic support for polymorphic function types (0 milliseconds)
1646[info] + (scala.PolyFunction {def apply(0): 0}) =?= (scala.PolyFunction {def apply(0): 0})
1647[info] + (scala.PolyFunction {def apply(0): 0}) <?< (scala.PolyFunction {def apply(0): 0})
1648[info] + (scala.PolyFunction {def apply(0): 0}) <?< (scala.PolyFunction {def apply(0): 0})
1649Starting build for ProjectRef(file:/build/repo/,izumi-reflect-thirdparty-boopickle-shadedJVM) (izumi-reflect-thirdparty-boopickle-shaded)... [1/2]
1650Compile scalacOptions: -encoding, UTF-8, -unchecked, -language:higherKinds, -Ykind-projector, -no-indent, -language:implicitConversions, -Wconf:msg=can be rewritten automatically under:s, -source:3.8
1651
1652************************
1653Build summary:
1654[{
1655 "module": "izumi-reflect",
1656 "compile": {"status": "ok", "tookMs": 14702, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},
1657 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},
1658 "test-compile": {"status": "ok", "tookMs": 13232, "warnings": 1, "errors": 0, "sourceVersion": "3.8"},
1659 "test": {"status": "ok", "tookMs": 1524, "passed": 209, "failed": 0, "ignored": 0, "skipped": 0, "total": 209, "byFramework": [{"framework": "unknown", "stats": {"passed": 209, "failed": 0, "ignored": 0, "skipped": 0, "total": 209}}]},
1660 "publish": {"status": "skipped", "tookMs": 0},
1661 "metadata": {
1662 "crossScalaVersions": ["3.3.6", "2.13.14", "2.12.20", "2.11.12"]
1663}
1664},{
1665 "module": "izumi-reflect-thirdparty-boopickle-shaded",
1666 "compile": {"status": "ok", "tookMs": 66, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},
1667 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},
1668 "test-compile": {"status": "ok", "tookMs": 99, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},
1669 "test": {"status": "ok", "tookMs": 102, "passed": 0, "failed": 0, "ignored": 0, "skipped": 0, "total": 0, "byFramework": []},
1670 "publish": {"status": "skipped", "tookMs": 0},
1671 "metadata": {
1672 "crossScalaVersions": ["3.3.6", "2.13.14", "2.12.20", "2.11.12"]
1673}
1674}]
1675************************
1676[success] Total time: 33 s, completed Jan 8, 2026, 2:27:38 AM
1677[0JChecking patch project/plugins.sbt...
1678Checking patch project/build.properties...
1679Checking patch build.sbt...
1680Applied patch project/plugins.sbt cleanly.
1681Applied patch project/build.properties cleanly.
1682Applied patch build.sbt cleanly.