Build Logs

zio/izumi-reflect • 3.8.0-RC2:2025-11-28

Errors

Warnings

Total Lines

2076

1##################################

2Clonning https://github.com/zio/izumi-reflect.git into /build/repo using revision v3.0.7

3##################################

4Note: switching to '64bd5615772092e6550f560c7b990e57237e30ce'.

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.

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:

13 git switch -c <new-branch-name>

15Or undo this operation with:

17 git switch -

19Turn off this advice by setting config variable advice.detachedHead to false

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"

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"

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.411s.

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:663: 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:663

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-shadedJVM/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-thirdparty-boopickle-shadedNative/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-root-native/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 Nov 28, 2025, 12:44:39 PM

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/LTTOrdering.scala]

178[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LTTSyntax.scala]

179[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LightTypeTagRef.scala]

180[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/internal/fundamentals/platform/assertions/IzAssert.scala]

181[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/internal/fundamentals/platform/console/TrivialLogger.scala]

182[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala-3/izumi/reflect/dottyreflection/ReflectionUtil.scala]

183[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/internal/fundamentals/collections/package.scala]

184[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LTTRenderables.scala]

185[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala-3/izumi/reflect/Tags.scala]

186[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala-3/izumi/reflect/TagMacro.scala]

187[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LightTypeTag.scala]

188[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/main/scala/izumi/reflect/macrortti/LightTypeTagInheritance.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:149:84

211[warn] 149 | 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:149

219[warn] 149 | 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/TagTest.scala]

223[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagProgressionTest.scala]

224[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedTagTest.scala]

225[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedLightTypeTagProgressionTest.scala]

226[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/DottyRegressionTests.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/TagAssertions.scala]

229[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/SharedLightTypeTagTest.scala]

230[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala/izumi/reflect/test/TestModel.scala]

231[info] [patched file /build/repo/izumi-reflect/izumi-reflect/src/test/scala-3/izumi/reflect/test/LightTypeTagTest.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:149:84

237[warn] 149 | 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:149

245[warn] 149 | 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": 15778, "warnings": 0, "errors": 0, "sourceVersion": "3.5-migration"},

262 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

263 "test-compile": {"status": "ok", "tookMs": 19854, "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": 47, "warnings": 0, "errors": 0, "sourceVersion": "3.5-migration"},

272 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

273 "test-compile": {"status": "ok", "tookMs": 101, "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: 61 s (0:01:01.0), completed Nov 28, 2025, 12:45:41 PM

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 0bae198] 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-RC2

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-RC2

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-RC2

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-RC2

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-RC2"

339"++3.8.0-RC2 -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-RC2 """{"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:663

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-RC2

363OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflect-root-js/crossScalaVersions

364OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflect-thirdparty-boopickle-shadedNative/crossScalaVersions

365OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflect-thirdparty-boopickle-shadedJVM/crossScalaVersions

366OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflectNative/crossScalaVersions

367OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflect-root-native/crossScalaVersions

368OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflectJVM/crossScalaVersions

369OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflectJS/crossScalaVersions

370OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 in izumi-reflect-thirdparty-boopickle-shadedJS/crossScalaVersions

371OpenCB::Changing crossVersion 3.3.6 -> 3.8.0-RC2 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-RC2 on 9 projects.

379[info] Switching Scala version on:

380[info] izumi-reflect-root-jvm (3.8.0-RC2, 2.13.14, 2.12.20, 2.11.12)

381[info] izumi-reflect-thirdparty-boopickle-shadedJVM (3.8.0-RC2, 2.13.14, 2.12.20, 2.11.12)

382[info] izumi-reflect-thirdparty-boopickle-shadedJS (3.8.0-RC2, 2.13.14, 2.12.20)

383[info] izumi-reflectJVM (3.8.0-RC2, 2.13.14, 2.12.20, 2.11.12)

384[info] izumi-reflectJS (3.8.0-RC2, 2.13.14, 2.12.20)

385[info] izumi-reflect-root-js (3.8.0-RC2, 2.13.14, 2.12.20, 2.11.12)

386[info] izumi-reflect-root-native (3.8.0-RC2, 2.13.14, 2.12.20, 2.11.12)

387[info] izumi-reflectNative (3.8.0-RC2, 2.13.14, 2.12.20)

388[info] izumi-reflect-thirdparty-boopickle-shadedNative (3.8.0-RC2, 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 Nov 28, 2025, 12:45:56 PM

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-RC2/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-RC2/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-RC2/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:149:84

440[warn] 149 | 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:149

448[warn] 149 | 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 (14 milliseconds)

457[info] LTTRenderablesTest:

458[info] LTT renderables

459[info] - should render simple lambdas using placeholders when using scalaStyledName (55 milliseconds)

460[info] - should render complex lambdas using long form when using scalaStyledName (9 milliseconds)

461[info] TagProgressionTest:

462[info] [progression] Tag (all versions)

463[info] - should progression test: can't substitute type parameters inside defs/vals in structural types (84 milliseconds)

464[info] + (java.lang.Object {def x(): izumi.reflect.test.SharedTagProgressionTest._$_$T}) =?= (java.lang.Object {def x(): scala.Int})

465[info] + (java.lang.Object {def x(): izumi.reflect.test.SharedTagProgressionTest._$_$T}) =?= (java.lang.Object {def x(): scala.Int})

466[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 (1 millisecond)

467[info] - should progression test: cannot resolve a higher-kinded type in a higher-kinded tag in an anonymous deeply-nested type lambda (9 milliseconds)

468[info] - should progression test: projections into singletons are not handled properly (on Scala 2) (8 milliseconds)

469[info] + "bar" =?= "bar"

470[info] + "bar" =?= "bar"

471[info] + "bar" =?= "bar"

472[info] + "bar" =?= "bar"

473[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2

474[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2

475[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2

476[info] + izumi.reflect.test.SharedTagProgressionTest._$A::singleton2 =?= izumi.reflect.test.SharedTagProgressionTest._$A::singleton2

477[info] - should Progression test: Scala 2 fails to Handle Tags outside of a predefined set (Somehow raw Tag.auto.T works on Scala 2, but not when defined as an alias) (6 milliseconds)

478[info] - should progression test: fails to combine higher-kinded intersection types without losing ignored type arguments (11 milliseconds)

479[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]}]

480[info] - should progression test: Dotty fails to regression test: resolve correct closestClass for Scala vararg AnyVal (https://github.com/zio/izumi-reflect/issues/224) (3 milliseconds)

481[info] - should progression test: fails to preserve lower bound when combining higher-kinded type members (5 milliseconds)

482[info] + scala.Unit <?< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]

483[info] - should progression test: fails on Scala 3 don't lose tautological intersection components other than Any/AnyRef (15 milliseconds)

484[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]

485[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]}

486[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]}

487[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]}

488[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]}

489[info] - should progression test: intersection tautologies are not removed automatically when constructing combined intersection type (6 milliseconds)

490[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]

491[info] - should progression test: null is treated like Nothing, not like a separate type (0 milliseconds)

492[info] - should progression test: parameter resolution breaks inside covariant wildcard type bounds on Scala 2.13 (76 milliseconds)

493[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]>]

494[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]>]

495[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]>]

496[info] - should progression test: combine intersection path-dependent intersection types with inner tags doesn't work on Scala 2 (3 milliseconds)

497[info] + {scala.Int & scala.Unit} =?= {scala.Int & scala.Unit}

498[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}

499[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}

500[info] [progression] Tag (Dotty)

501[info] - should progression test: fails to don't lose tautological union components other than Nothing (9 milliseconds)

502[info] + {izumi.reflect.test.TestModel::Trait1 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= izumi.reflect.test.TestModel::Trait1

503[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]}

504[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]}

505[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]}

506[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]}

507[info] - should progression test: union tautologies are not removed automatically when constructing combined union type (2 milliseconds)

508[info] + {izumi.reflect.test.TestModel::Trait1 | izumi.reflect.test.TestModel::Trait3[=izumi.reflect.test.InheritedModel::Dep]} =?= izumi.reflect.test.TestModel::Trait1

509LightTypeTagInheritance: ⚙️ Inheritance check: {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}

510⚡️bases:

511 - java.lang.String ->

512 * java.io.Serializable

513 * java.lang.CharSequence

514 * java.lang.constant.Constable

515 * java.lang.constant.ConstantDesc

516 * java.lang.Comparable[=java.lang.String]

517 - scala.Boolean ->

518 * scala.AnyVal

519 - scala.Int ->

520 * scala.AnyVal

521⚡️inheritance:

522 - java.lang.String ->

523 * java.io.Serializable

524 * java.lang.CharSequence

525 * java.lang.Comparable

526 * java.lang.constant.Constable

527 * java.lang.constant.ConstantDesc

528 - scala.Boolean ->

529 * scala.AnyVal

530 - scala.Int ->

531 * scala.AnyVal

532LightTypeTagInheritance: ⚙️ Inheritance check: λ %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]

533⚡️bases:

534 - λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0] ->

535 * λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H2,+scala.Unit]

536 - λ %1:0,%1:1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1:0,+1:1] ->

537 * λ %1:0,%1:1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1:1,+1:0,+scala.Unit]

538 - izumi.reflect.test.TestModel::H2 ->

539 * izumi.reflect.test.TestModel::H1

540 - scala.Unit ->

541 * scala.AnyVal

542⚡️inheritance:

543 - izumi.reflect.test.SharedLightTypeTagTest._$KK2 ->

544 * izumi.reflect.test.SharedLightTypeTagTest._$KK1

545 - izumi.reflect.test.TestModel::H2 ->

546 * izumi.reflect.test.TestModel::H1

547 - scala.Unit ->

548 * scala.AnyVal

549LightTypeTagInheritance: ✴️ isChild: `λ %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]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@2cc4e9f5,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

550> LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@136b8988,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

551LightTypeTagInheritance: ✴️ isChild: `{java.lang.String & scala.Boolean & scala.Int}` <:< `{java.lang.String & scala.Boolean & scala.Int}`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@463475d8,izumi.reflect.macrortti.LightTypeTagInheritance@51d2ecbf)

552LightTypeTagInheritance: ✅ isChild: `{java.lang.String & scala.Boolean & scala.Int}` <:< `{java.lang.String & scala.Boolean & scala.Int}` == true

553> > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H2` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1d642d74,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

554> > LightTypeTagInheritance: Looking up parameterized parents of TestModel::H2 => Set(TestModel::H1)

555> > > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1664e46c,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

556> > > LightTypeTagInheritance: Looking up parameterized parents of TestModel::H1 => Set()

557> > > LightTypeTagInheritance: Looking up unparameterized parents of TestModel::H1 => HashSet()

558> > > LightTypeTagInheritance: ⛔️ isChild: `izumi.reflect.test.TestModel::H1` <:< `0` == false

559> > LightTypeTagInheritance: Looking up unparameterized parents of TestModel::H2 => HashSet(TestModel::H1)

560> > > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1673ee80,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

561> > > LightTypeTagInheritance: Looking up parameterized parents of TestModel::H1 => Set()

562> > > LightTypeTagInheritance: Looking up unparameterized parents of TestModel::H1 => HashSet()

563> > > LightTypeTagInheritance: ⛔️ isChild: `izumi.reflect.test.TestModel::H1` <:< `0` == false

564> > LightTypeTagInheritance: ⛔️ isChild: `izumi.reflect.test.TestModel::H2` <:< `0` == false

565> LightTypeTagInheritance: ⚠️ comparing parameterized references: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]`, paramsOk = false, ctorsOk = false, sameArity = false, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@136b8988,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

566> LightTypeTagInheritance: Looking up parameterized parents of _$KK2[+TestModel::H2,+0] => Set()

567> LightTypeTagInheritance: ℹ️ checking applied lambda parents of self=`izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0]`: parents=List(izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H2,+scala.Unit], izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H2,+scala.Unit]) <:< that=`izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]`

568> > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H2,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@65a89bc5,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

569> > > LightTypeTagInheritance: ✴️ isChild: `0` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@545e5498,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

570> > > LightTypeTagInheritance: ✅ isChild: `0` <:< `0` == true

571> > > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H2` <:< `izumi.reflect.test.TestModel::H1`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5d50a77d,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

572> > > LightTypeTagInheritance: Looking up parameterized parents of TestModel::H2 => Set(TestModel::H1)

573> > > > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H1` <:< `izumi.reflect.test.TestModel::H1`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5cdaddb2,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

574> > > > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.TestModel::H1` <:< `izumi.reflect.test.TestModel::H1` == true

575> > > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.TestModel::H2` <:< `izumi.reflect.test.TestModel::H1` == true

576> > > LightTypeTagInheritance: ✴️ isChild: `scala.Unit` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@7d8d135f,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

577> > > LightTypeTagInheritance: ✅ isChild: `scala.Unit` <:< `scala.Unit` == true

578> > LightTypeTagInheritance: ⚠️ comparing parameterized references: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H2,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]`, paramsOk = true, ctorsOk = true, sameArity = true, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@65a89bc5,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

579> > > LightTypeTagInheritance: ✴️ isChild: `0` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5b5172e2,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

580> > > LightTypeTagInheritance: ✅ isChild: `0` <:< `0` == true

581> > > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H2` <:< `izumi.reflect.test.TestModel::H1`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@3625dba,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

582> > > LightTypeTagInheritance: Looking up parameterized parents of TestModel::H2 => Set(TestModel::H1)

583> > > > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::H1` <:< `izumi.reflect.test.TestModel::H1`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@9df2729,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

584> > > > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.TestModel::H1` <:< `izumi.reflect.test.TestModel::H1` == true

585> > > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.TestModel::H2` <:< `izumi.reflect.test.TestModel::H1` == true

586> > > LightTypeTagInheritance: ✴️ isChild: `scala.Unit` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1cddcaa6,izumi.reflect.macrortti.LightTypeTagInheritance@73ae772f)

587> > > LightTypeTagInheritance: ✅ isChild: `scala.Unit` <:< `scala.Unit` == true

588> > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H2,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]` == true

589> LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+izumi.reflect.test.TestModel::H2,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+izumi.reflect.test.TestModel::H1,+scala.Unit]` == true

590LightTypeTagInheritance: ⚙️ Inheritance check: {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}

591⚡️bases:

592 - java.lang.String ->

593 * java.io.Serializable

594 * java.lang.CharSequence

595 * java.lang.constant.Constable

596 * java.lang.constant.ConstantDesc

597 * java.lang.Comparable[=java.lang.String]

598 - scala.Boolean ->

599 * scala.AnyVal

600 - scala.Int ->

601 * scala.AnyVal

602 - scala.Unit ->

603 * scala.AnyVal

604⚡️inheritance:

605 - java.lang.String ->

606 * java.io.Serializable

607 * java.lang.CharSequence

608 * java.lang.Comparable

609 * java.lang.constant.Constable

610 * java.lang.constant.ConstantDesc

611 - scala.Boolean ->

612 * scala.AnyVal

613 - scala.Int ->

614 * scala.AnyVal

615 - scala.Unit ->

616 * scala.AnyVal

617LightTypeTagInheritance: ✴️ isChild: `{java.lang.String & scala.Boolean & scala.Int}` <:< `{java.lang.String & scala.Boolean & scala.Int & scala.Unit}`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@46c1645b,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

618> LightTypeTagInheritance: ✴️ isChild: `java.lang.String` <:< `java.lang.String`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@57167346,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

619> LightTypeTagInheritance: ✅ isChild: `java.lang.String` <:< `java.lang.String` == true

620> LightTypeTagInheritance: ✴️ isChild: `java.lang.String` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5bd0746c,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

621> LightTypeTagInheritance: Looking up parameterized parents of String => HashSet(Comparable[=String], CharSequence, Serializable, Constable, ConstantDesc)

622> > LightTypeTagInheritance: ✴️ isChild: `java.lang.Comparable[=java.lang.String]` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@4b372fe5,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

623> > LightTypeTagInheritance: Looking up parameterized parents of Comparable[=String] => Set()

624> > LightTypeTagInheritance: Looking up unparameterized parents of Comparable => HashSet()

625> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.Comparable[=java.lang.String]` <:< `scala.Boolean` == false

626> > LightTypeTagInheritance: ✴️ isChild: `java.lang.CharSequence` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@102bfefa,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

627> > LightTypeTagInheritance: Looking up parameterized parents of CharSequence => Set()

628> > LightTypeTagInheritance: Looking up unparameterized parents of CharSequence => HashSet()

629> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.CharSequence` <:< `scala.Boolean` == false

630> > LightTypeTagInheritance: ✴️ isChild: `java.io.Serializable` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@74c323fa,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

631> > LightTypeTagInheritance: Looking up parameterized parents of Serializable => Set()

632> > LightTypeTagInheritance: Looking up unparameterized parents of Serializable => HashSet()

633> > LightTypeTagInheritance: ⛔️ isChild: `java.io.Serializable` <:< `scala.Boolean` == false

634> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.Constable` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@2c685a1a,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

635> > LightTypeTagInheritance: Looking up parameterized parents of Constable => Set()

636> > LightTypeTagInheritance: Looking up unparameterized parents of Constable => HashSet()

637> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.Constable` <:< `scala.Boolean` == false

638> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5e521075,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

639> > LightTypeTagInheritance: Looking up parameterized parents of ConstantDesc => Set()

640> > LightTypeTagInheritance: Looking up unparameterized parents of ConstantDesc => HashSet()

641> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Boolean` == false

642> LightTypeTagInheritance: Looking up unparameterized parents of String => HashSet(CharSequence, Serializable, Constable, Comparable, ConstantDesc)

643> > LightTypeTagInheritance: ✴️ isChild: `java.lang.CharSequence` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1141e96b,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

644> > LightTypeTagInheritance: Looking up parameterized parents of CharSequence => Set()

645> > LightTypeTagInheritance: Looking up unparameterized parents of CharSequence => HashSet()

646> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.CharSequence` <:< `scala.Boolean` == false

647> > LightTypeTagInheritance: ✴️ isChild: `java.io.Serializable` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@7c70d44a,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

648> > LightTypeTagInheritance: Looking up parameterized parents of Serializable => Set()

649LightTypeTagInheritance: ✅ isChild: `λ %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]` == true

650> > LightTypeTagInheritance: Looking up unparameterized parents of Serializable => HashSet()

651> > LightTypeTagInheritance: ⛔️ isChild: `java.io.Serializable` <:< `scala.Boolean` == false

652> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.Constable` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@12a6e954,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

653> > LightTypeTagInheritance: Looking up parameterized parents of Constable => Set()

654> > LightTypeTagInheritance: Looking up unparameterized parents of Constable => HashSet()

655> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.Constable` <:< `scala.Boolean` == false

656> > LightTypeTagInheritance: ✴️ isChild: `java.lang.Comparable` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5cb982cd,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

657> > LightTypeTagInheritance: Looking up parameterized parents of Comparable => Set()

658> > LightTypeTagInheritance: Looking up unparameterized parents of Comparable => HashSet()

659> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.Comparable` <:< `scala.Boolean` == false

660> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@422d2280,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

661> > LightTypeTagInheritance: Looking up parameterized parents of ConstantDesc => Set()

662> > LightTypeTagInheritance: Looking up unparameterized parents of ConstantDesc => HashSet()

663> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Boolean` == false

664> LightTypeTagInheritance: ⛔️ isChild: `java.lang.String` <:< `scala.Boolean` == false

665> LightTypeTagInheritance: ✴️ isChild: `scala.Boolean` <:< `scala.Boolean`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@38057c0b,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

666> LightTypeTagInheritance: ✅ isChild: `scala.Boolean` <:< `scala.Boolean` == true

667> LightTypeTagInheritance: ✴️ isChild: `java.lang.String` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1dccce16,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

668> LightTypeTagInheritance: Looking up parameterized parents of String => HashSet(Comparable[=String], CharSequence, Serializable, Constable, ConstantDesc)

669> > LightTypeTagInheritance: ✴️ isChild: `java.lang.Comparable[=java.lang.String]` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@d739888,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

670> > LightTypeTagInheritance: Looking up parameterized parents of Comparable[=String] => Set()

671> > LightTypeTagInheritance: Looking up unparameterized parents of Comparable => HashSet()

672> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.Comparable[=java.lang.String]` <:< `scala.Int` == false

673> > LightTypeTagInheritance: ✴️ isChild: `java.lang.CharSequence` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@26619284,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

674> > LightTypeTagInheritance: Looking up parameterized parents of CharSequence => Set()

675> > LightTypeTagInheritance: Looking up unparameterized parents of CharSequence => HashSet()

676> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.CharSequence` <:< `scala.Int` == false

677> > LightTypeTagInheritance: ✴️ isChild: `java.io.Serializable` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@35174767,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

678> > LightTypeTagInheritance: Looking up parameterized parents of Serializable => Set()

679> > LightTypeTagInheritance: Looking up unparameterized parents of Serializable => HashSet()

680> > LightTypeTagInheritance: ⛔️ isChild: `java.io.Serializable` <:< `scala.Int` == false

681> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.Constable` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@4e5083ad,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

682> > LightTypeTagInheritance: Looking up parameterized parents of Constable => Set()

683> > LightTypeTagInheritance: Looking up unparameterized parents of Constable => HashSet()

684> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.Constable` <:< `scala.Int` == false

685> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5ff6f537,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

686> > LightTypeTagInheritance: Looking up parameterized parents of ConstantDesc => Set()

687> > LightTypeTagInheritance: Looking up unparameterized parents of ConstantDesc => HashSet()

688> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Int` == false

689> LightTypeTagInheritance: Looking up unparameterized parents of String => HashSet(CharSequence, Serializable, Constable, Comparable, ConstantDesc)

690> > LightTypeTagInheritance: ✴️ isChild: `java.lang.CharSequence` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@75a9a9ff,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

691> > LightTypeTagInheritance: Looking up parameterized parents of CharSequence => Set()

692> > LightTypeTagInheritance: Looking up unparameterized parents of CharSequence => HashSet()

693> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.CharSequence` <:< `scala.Int` == false

694> > LightTypeTagInheritance: ✴️ isChild: `java.io.Serializable` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@7a0af452,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

695> > LightTypeTagInheritance: Looking up parameterized parents of Serializable => Set()

696> > LightTypeTagInheritance: Looking up unparameterized parents of Serializable => HashSet()

697> > LightTypeTagInheritance: ⛔️ isChild: `java.io.Serializable` <:< `scala.Int` == false

698LightTypeTagInheritance: ⚙️ Inheritance check: λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] <?< λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]

699⚡️bases:

700 - λ %1:0,%1:1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1:0,+1:1] ->

701 * λ %1:0,%1:1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1:1,+1:0,+scala.Unit]

702 - λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] ->

703 * λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]

704 - scala.Unit ->

705 * scala.AnyVal

706⚡️inheritance:

707 - izumi.reflect.test.SharedLightTypeTagTest._$KK2 ->

708 * izumi.reflect.test.SharedLightTypeTagTest._$KK1

709 - scala.Unit ->

710 * scala.AnyVal

711LightTypeTagInheritance: ✴️ isChild: `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5f39831b,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

712> LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@3e1b3928,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

713> > LightTypeTagInheritance: ✴️ isChild: `1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@c4d4618,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

714> > LightTypeTagInheritance: Looking up parameterized parents of 1 => Set()

715> > LightTypeTagInheritance: Looking up unparameterized parents of 1 => HashSet()

716> > LightTypeTagInheritance: ⛔️ isChild: `1` <:< `0` == false

717> LightTypeTagInheritance: ⚠️ comparing parameterized references: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`, paramsOk = false, ctorsOk = false, sameArity = false, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@3e1b3928,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

718> LightTypeTagInheritance: Looking up parameterized parents of _$KK2[+1,+0] => Set()

719> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.Constable` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@300d4d55,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

720> > LightTypeTagInheritance: Looking up parameterized parents of Constable => Set()

721> > LightTypeTagInheritance: Looking up unparameterized parents of Constable => HashSet()

722> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.Constable` <:< `scala.Int` == false

723> > LightTypeTagInheritance: ✴️ isChild: `java.lang.Comparable` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@583a492e,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

724> > LightTypeTagInheritance: Looking up parameterized parents of Comparable => Set()

725> > LightTypeTagInheritance: Looking up unparameterized parents of Comparable => HashSet()

726> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.Comparable` <:< `scala.Int` == false

727> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@60e4e587,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

728> > LightTypeTagInheritance: Looking up parameterized parents of ConstantDesc => Set()

729> > LightTypeTagInheritance: Looking up unparameterized parents of ConstantDesc => HashSet()

730> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Int` == false

731> LightTypeTagInheritance: ⛔️ isChild: `java.lang.String` <:< `scala.Int` == false

732> LightTypeTagInheritance: ✴️ isChild: `scala.Boolean` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@4de135ad,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

733> LightTypeTagInheritance: Looking up parameterized parents of Boolean => Set(AnyVal)

734> > LightTypeTagInheritance: ✴️ isChild: `scala.AnyVal` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@175cbea1,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

735> > LightTypeTagInheritance: Looking up parameterized parents of AnyVal => Set()

736> > LightTypeTagInheritance: Looking up unparameterized parents of AnyVal => HashSet()

737> > LightTypeTagInheritance: ⛔️ isChild: `scala.AnyVal` <:< `scala.Int` == false

738> LightTypeTagInheritance: Looking up unparameterized parents of Boolean => HashSet(AnyVal)

739> > LightTypeTagInheritance: ✴️ isChild: `scala.AnyVal` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1d25e65d,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

740> > LightTypeTagInheritance: Looking up parameterized parents of AnyVal => Set()

741> > LightTypeTagInheritance: Looking up unparameterized parents of AnyVal => HashSet()

742> > LightTypeTagInheritance: ⛔️ isChild: `scala.AnyVal` <:< `scala.Int` == false

743> LightTypeTagInheritance: ⛔️ isChild: `scala.Boolean` <:< `scala.Int` == false

744> LightTypeTagInheritance: ✴️ isChild: `scala.Int` <:< `scala.Int`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5a2ae0a3,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

745> LightTypeTagInheritance: ✅ isChild: `scala.Int` <:< `scala.Int` == true

746> LightTypeTagInheritance: ✴️ isChild: `java.lang.String` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1e22fa16,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

747> LightTypeTagInheritance: ℹ️ checking applied lambda parents of self=`izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]`: parents=List(izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1,+0,+scala.Unit], izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit], izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit], izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1,+0,+scala.Unit]) <:< that=`izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`

748> > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1,+0,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1fff2dd1,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

749> > > LightTypeTagInheritance: ✴️ isChild: `1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@16206361,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

750> > > LightTypeTagInheritance: Looking up parameterized parents of 1 => Set()

751> > > LightTypeTagInheritance: Looking up unparameterized parents of 1 => HashSet()

752> > > LightTypeTagInheritance: ⛔️ isChild: `1` <:< `0` == false

753> > LightTypeTagInheritance: ⚠️ comparing parameterized references: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1,+0,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`, paramsOk = false, ctorsOk = true, sameArity = true, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1fff2dd1,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

754> > > LightTypeTagInheritance: ✴️ isChild: `1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@7195caf4,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

755> > > LightTypeTagInheritance: Looking up parameterized parents of 1 => Set()

756> > > LightTypeTagInheritance: Looking up unparameterized parents of 1 => HashSet()

757> > > LightTypeTagInheritance: ⛔️ isChild: `1` <:< `0` == false

758> > LightTypeTagInheritance: ⛔️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1,+0,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]` == false

759> > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@170e3f58,izumi.reflect.macrortti.LightTypeTagInheritance@48083bd4)

760> > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]` == true

761> LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]` == true

762LightTypeTagInheritance: ✅ isChild: `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]` == true

763> LightTypeTagInheritance: Looking up parameterized parents of String => HashSet(Comparable[=String], CharSequence, Serializable, Constable, ConstantDesc)

764> > LightTypeTagInheritance: ✴️ isChild: `java.lang.Comparable[=java.lang.String]` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@6cf9e6c5,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

765> > LightTypeTagInheritance: Looking up parameterized parents of Comparable[=String] => Set()

766> > LightTypeTagInheritance: Looking up unparameterized parents of Comparable => HashSet()

767> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.Comparable[=java.lang.String]` <:< `scala.Unit` == false

768> > LightTypeTagInheritance: ✴️ isChild: `java.lang.CharSequence` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5e5cf209,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

769> > LightTypeTagInheritance: Looking up parameterized parents of CharSequence => Set()

770> > LightTypeTagInheritance: Looking up unparameterized parents of CharSequence => HashSet()

771> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.CharSequence` <:< `scala.Unit` == false

772> > LightTypeTagInheritance: ✴️ isChild: `java.io.Serializable` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@537e3e99,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

773> > LightTypeTagInheritance: Looking up parameterized parents of Serializable => Set()

774> > LightTypeTagInheritance: Looking up unparameterized parents of Serializable => HashSet()

775> > LightTypeTagInheritance: ⛔️ isChild: `java.io.Serializable` <:< `scala.Unit` == false

776> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.Constable` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5a859caa,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

777> > LightTypeTagInheritance: Looking up parameterized parents of Constable => Set()

778> > LightTypeTagInheritance: Looking up unparameterized parents of Constable => HashSet()

779> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.Constable` <:< `scala.Unit` == false

780> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@79e986f1,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

781> > LightTypeTagInheritance: Looking up parameterized parents of ConstantDesc => Set()

782> > LightTypeTagInheritance: Looking up unparameterized parents of ConstantDesc => HashSet()

783> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Unit` == false

784> LightTypeTagInheritance: Looking up unparameterized parents of String => HashSet(CharSequence, Serializable, Constable, Comparable, ConstantDesc)

785> > LightTypeTagInheritance: ✴️ isChild: `java.lang.CharSequence` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@401cff7f,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

786> > LightTypeTagInheritance: Looking up parameterized parents of CharSequence => Set()

787> > LightTypeTagInheritance: Looking up unparameterized parents of CharSequence => HashSet()

788> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.CharSequence` <:< `scala.Unit` == false

789> > LightTypeTagInheritance: ✴️ isChild: `java.io.Serializable` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@62b48b13,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

790> > LightTypeTagInheritance: Looking up parameterized parents of Serializable => Set()

791LightTypeTagInheritance: ⚙️ Inheritance check: λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] <?< λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]

792⚡️bases:

793 - λ %1:0,%1:1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1:0,+1:1] ->

794 * λ %1:0,%1:1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+1:1,+1:0,+scala.Unit]

795 - λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] ->

796 * λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]

797 - scala.Unit ->

798 * scala.AnyVal

799⚡️inheritance:

800 - izumi.reflect.test.SharedLightTypeTagTest._$KK2 ->

801 * izumi.reflect.test.SharedLightTypeTagTest._$KK1

802 - scala.Unit ->

803 * scala.AnyVal

804LightTypeTagInheritance: ✴️ isChild: `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@717919cd,izumi.reflect.macrortti.LightTypeTagInheritance@645747e8)

805> LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@3b4ae3fc,izumi.reflect.macrortti.LightTypeTagInheritance@645747e8)

806> > LightTypeTagInheritance: ✴️ isChild: `1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@5d58ff32,izumi.reflect.macrortti.LightTypeTagInheritance@645747e8)

807> > LightTypeTagInheritance: Looking up parameterized parents of 1 => Set()

808> > LightTypeTagInheritance: Looking up unparameterized parents of 1 => HashSet()

809> > LightTypeTagInheritance: ⛔️ isChild: `1` <:< `0` == false

810> LightTypeTagInheritance: ⚠️ comparing parameterized references: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]`, paramsOk = false, ctorsOk = true, sameArity = true, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@3b4ae3fc,izumi.reflect.macrortti.LightTypeTagInheritance@645747e8)

811> > LightTypeTagInheritance: ✴️ isChild: `1` <:< `0`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@64563225,izumi.reflect.macrortti.LightTypeTagInheritance@645747e8)

812> > LightTypeTagInheritance: Looking up parameterized parents of 1 => Set()

813> > LightTypeTagInheritance: Looking up unparameterized parents of 1 => HashSet()

814> > LightTypeTagInheritance: ⛔️ isChild: `1` <:< `0` == false

815> LightTypeTagInheritance: ⛔️ isChild: `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]` == false

816LightTypeTagInheritance: ⛔️ isChild: `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0]` <:< `λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]` == false

817> > LightTypeTagInheritance: Looking up unparameterized parents of Serializable => HashSet()

818> > LightTypeTagInheritance: ⛔️ isChild: `java.io.Serializable` <:< `scala.Unit` == false

819> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.Constable` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@14222b23,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

820> > LightTypeTagInheritance: Looking up parameterized parents of Constable => Set()

821> > LightTypeTagInheritance: Looking up unparameterized parents of Constable => HashSet()

822> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.Constable` <:< `scala.Unit` == false

823> > LightTypeTagInheritance: ✴️ isChild: `java.lang.Comparable` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@21c9e958,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

824> > LightTypeTagInheritance: Looking up parameterized parents of Comparable => Set()

825> > LightTypeTagInheritance: Looking up unparameterized parents of Comparable => HashSet()

826> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.Comparable` <:< `scala.Unit` == false

827> > LightTypeTagInheritance: ✴️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@6891d19,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

828> > LightTypeTagInheritance: Looking up parameterized parents of ConstantDesc => Set()

829> > LightTypeTagInheritance: Looking up unparameterized parents of ConstantDesc => HashSet()

830> > LightTypeTagInheritance: ⛔️ isChild: `java.lang.constant.ConstantDesc` <:< `scala.Unit` == false

831> LightTypeTagInheritance: ⛔️ isChild: `java.lang.String` <:< `scala.Unit` == false

832> LightTypeTagInheritance: ✴️ isChild: `scala.Boolean` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@40a3e2c8,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

833> LightTypeTagInheritance: Looking up parameterized parents of Boolean => Set(AnyVal)

834> > LightTypeTagInheritance: ✴️ isChild: `scala.AnyVal` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@455db2cc,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

835> > LightTypeTagInheritance: Looking up parameterized parents of AnyVal => Set()

836> > LightTypeTagInheritance: Looking up unparameterized parents of AnyVal => HashSet()

837> > LightTypeTagInheritance: ⛔️ isChild: `scala.AnyVal` <:< `scala.Unit` == false

838> LightTypeTagInheritance: Looking up unparameterized parents of Boolean => HashSet(AnyVal)

839> > LightTypeTagInheritance: ✴️ isChild: `scala.AnyVal` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@2b301016,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

840> > LightTypeTagInheritance: Looking up parameterized parents of AnyVal => Set()

841> > LightTypeTagInheritance: Looking up unparameterized parents of AnyVal => HashSet()

842> > LightTypeTagInheritance: ⛔️ isChild: `scala.AnyVal` <:< `scala.Unit` == false

843> LightTypeTagInheritance: ⛔️ isChild: `scala.Boolean` <:< `scala.Unit` == false

844> LightTypeTagInheritance: ✴️ isChild: `scala.Int` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@651fb1bc,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

845> LightTypeTagInheritance: Looking up parameterized parents of Int => Set(AnyVal)

846> > LightTypeTagInheritance: ✴️ isChild: `scala.AnyVal` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@3a75ba75,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

847> > LightTypeTagInheritance: Looking up parameterized parents of AnyVal => Set()

848> > LightTypeTagInheritance: Looking up unparameterized parents of AnyVal => HashSet()

849> > LightTypeTagInheritance: ⛔️ isChild: `scala.AnyVal` <:< `scala.Unit` == false

850> LightTypeTagInheritance: Looking up unparameterized parents of Int => HashSet(AnyVal)

851> > LightTypeTagInheritance: ✴️ isChild: `scala.AnyVal` <:< `scala.Unit`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1216a425,izumi.reflect.macrortti.LightTypeTagInheritance@3936af9f)

852> > LightTypeTagInheritance: Looking up parameterized parents of AnyVal => Set()

853> > LightTypeTagInheritance: Looking up unparameterized parents of AnyVal => HashSet()

854> > LightTypeTagInheritance: ⛔️ isChild: `scala.AnyVal` <:< `scala.Unit` == false

855> LightTypeTagInheritance: ⛔️ isChild: `scala.Int` <:< `scala.Unit` == false

856LightTypeTagInheritance: ⛔️ isChild: `{java.lang.String & scala.Boolean & scala.Int}` <:< `{java.lang.String & scala.Boolean & scala.Int & scala.Unit}` == false

857LightTypeTagInheritance: ⚙️ Inheritance check: {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]

858⚡️bases:

859 - λ %1:0 → izumi.reflect.test.TestModel::W4[=1:0] ->

860 * λ %1:0 → izumi.reflect.test.TestModel::W3[=1:0]

861 - λ %1:0 → izumi.reflect.test.TestModel::W5[=1:0] ->

862 * izumi.reflect.test.TestModel::W1

863 * izumi.reflect.test.TestModel::W2

864 - λ %0,%1 → izumi.reflect.test.TestModel::W4[=1] ->

865 * λ %0,%1 → izumi.reflect.test.TestModel::W3[=1]

866 - λ %0,%1 → izumi.reflect.test.TestModel::W5[=0] ->

867 * izumi.reflect.test.TestModel::W1

868 * izumi.reflect.test.TestModel::W2

869 - scala.Boolean ->

870 * scala.AnyVal

871 - scala.Int ->

872 * scala.AnyVal

873 - izumi.reflect.test.TestModel::W4[=scala.Boolean] ->

874 * izumi.reflect.test.TestModel::W3[=scala.Boolean]

875 - izumi.reflect.test.TestModel::W4[=scala.Int] ->

876 * izumi.reflect.test.TestModel::W3[=scala.Int]

877 - izumi.reflect.test.TestModel::W5[=scala.Int] ->

878 * izumi.reflect.test.TestModel::W1

879 * izumi.reflect.test.TestModel::W2

880⚡️inheritance:

881 - izumi.reflect.test.TestModel::W4 ->

882 * izumi.reflect.test.TestModel::W3

883 - izumi.reflect.test.TestModel::W5 ->

884 * izumi.reflect.test.TestModel::W1

885 * izumi.reflect.test.TestModel::W2

886 - scala.Boolean ->

887 * scala.AnyVal

888 - scala.Int ->

889 * scala.AnyVal

890LightTypeTagInheritance: ✴️ isChild: `{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]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@69a59e4f,izumi.reflect.macrortti.LightTypeTagInheritance@303e2434)

891> LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::W1` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@47cfbc54,izumi.reflect.macrortti.LightTypeTagInheritance@303e2434)

892> LightTypeTagInheritance: Looking up parameterized parents of TestModel::W1 => Set()

893> LightTypeTagInheritance: ⛔️ isChild: `izumi.reflect.test.TestModel::W1` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]` == false

894> LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::W4[=scala.Boolean]` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@59104338,izumi.reflect.macrortti.LightTypeTagInheritance@303e2434)

895> LightTypeTagInheritance: ⚠️ comparing parameterized references: `izumi.reflect.test.TestModel::W4[=scala.Boolean]` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]`, paramsOk = true, ctorsOk = false, sameArity = true, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@59104338,izumi.reflect.macrortti.LightTypeTagInheritance@303e2434)

896> LightTypeTagInheritance: Looking up parameterized parents of TestModel::W4[=Boolean] => Set(TestModel::W3[=Boolean])

897> > LightTypeTagInheritance: ✴️ isChild: `izumi.reflect.test.TestModel::W3[=scala.Boolean]` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]`, context = Ctx(izumi.reflect.internal.fundamentals.platform.console.TrivialLoggerImpl@1c02f9b3,izumi.reflect.macrortti.LightTypeTagInheritance@303e2434)

898> > LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.TestModel::W3[=scala.Boolean]` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]` == true

899> LightTypeTagInheritance: ✅ isChild: `izumi.reflect.test.TestModel::W4[=scala.Boolean]` <:< `izumi.reflect.test.TestModel::W3[=scala.Boolean]` == true

900LightTypeTagInheritance: ✅ isChild: `{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]` == true

901[info] IzCollectionsTest:

902[info] Collection utils

903[info] - should allow to convert mappings to multimaps (22 milliseconds)

904[info] BasicDottyTest:

905[info] - super-basic test 1 (133 milliseconds)

906[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz =?= izumi.reflect.test.CurrentDottySupportExtentTest._$Baz

907[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz =!= izumi.reflect.test.CurrentDottySupportExtentTest._$Bar[+λ %0,%1 → izumi.reflect.test.CurrentDottySupportExtentTest::X[+0,-1]]

908[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz <?< izumi.reflect.test.CurrentDottySupportExtentTest._$Baz

909[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz <!< izumi.reflect.test.CurrentDottySupportExtentTest._$Bar[+λ %0,%1 → izumi.reflect.test.CurrentDottySupportExtentTest::X[+0,-1]]

910[info] + izumi.reflect.test.CurrentDottySupportExtentTest::B <?< izumi.reflect.test.CurrentDottySupportExtentTest::A

911[info] + izumi.reflect.test.CurrentDottySupportExtentTest._$Baz =?= izumi.reflect.test.CurrentDottySupportExtentTest._$Baz

912[info] + izumi.reflect.test.CurrentDottySupportExtentTest::Listoid[+scala.Int] <?< izumi.reflect.test.CurrentDottySupportExtentTest::Listoid[+scala.Int]

913[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+scala.Int]

914[info] + izumi.reflect.test.CurrentDottySupportExtentTest::SubInvariantoid[=scala.Int] <?< izumi.reflect.test.CurrentDottySupportExtentTest::Traitoid

915[info] + scala.Tuple2[+izumi.reflect.test.CurrentDottySupportExtentTest._$Baz,+izumi.reflect.test.CurrentDottySupportExtentTest._$Baz] <?< scala.Tuple2[+scala.Any,+scala.Any]

916[info] + scala.Tuple2[+scala.Double,+scala.Double] <?< scala.Tuple2[+scala.AnyVal,+scala.AnyVal]

917[info] + scala.collection.immutable.List[+izumi.reflect.test.CurrentDottySupportExtentTest::B] <?< scala.collection.immutable.Seq[+izumi.reflect.test.CurrentDottySupportExtentTest::A]

918[info] + scala.collection.immutable.List[+izumi.reflect.test.CurrentDottySupportExtentTest::B] <?< scala.collection.immutable.Seq[+izumi.reflect.test.CurrentDottySupportExtentTest::A]

919[info] TagCombineTest:

920[info] Tag macro

921[info] - should reconstruct lambda tags (12 milliseconds)

922[info] LightTypeTagProgressionTest:

923[info] [progression] lightweight type tags (all versions)

924[info] - should progression test: can't support subtyping of type prefixes (2 milliseconds)

925[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$a::A <?< izumi.reflect.test.TestModel::C::A

926[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$a::A =!= izumi.reflect.test.TestModel::C::A

927[info] + izumi.reflect.test.TestModel::C::A <!< izumi.reflect.test.SharedLightTypeTagProgressionTest._$a::A

928[info] - should progression test: can't support subtyping of concrete type projections (5 milliseconds)

929[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T =?= izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T

930[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$B::T =!= izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T

931[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$B::T <?< izumi.reflect.test.SharedLightTypeTagProgressionTest._$A::T

932[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) (37 milliseconds)

933[info] + λ %0 → scala.collection.immutable.Set[=0] <!< λ %0 → scala.collection.immutable.Set[=0]

934[info] + λ %0 → scala.collection.immutable.Set[=0] <?< λ %0 → scala.collection.immutable.Set[=0]

935[info] - should progression test: indirect structural checks do not work (2 milliseconds)

936[info] + (java.lang.Object {type A = A}) =!= java.lang.Object

937[info] + izumi.reflect.test.TestModel::C <?< (java.lang.Object {type A = A})

938[info] - should progression test: combined intersection lambda tags still contain some junk bases (coming from the unsound same-arity assumption in LightTypeTag#combine) (25 milliseconds)

939[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]}

940[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]}

941[info] - should progression test: combined lambda tags still contain some junk bases (coming from the unsound same-arity assumption in LightTypeTag#combine) (8 milliseconds)

942[info] + scala.util.Right[+java.lang.Throwable,+scala.Unit] =?= scala.util.Right[+java.lang.Throwable,+scala.Unit]

943[info] - should progression test: Dotty fails to `support methods with type parameters in structural refinements` (9 milliseconds)

944[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean}) <!< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Int})

945[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Int}) <!< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})

946[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Int}) =!= (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})

947[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean}) <?< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.AnyVal})

948[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.AnyVal}) <!< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})

949[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.AnyVal}) =!= (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean})

950[info] + (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): scala.Boolean}) <?< (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): 0})

951[info] - should fails to treat tautological refinements as equal to the underlying type (1 millisecond)

952[info] + izumi.reflect.test.SharedLightTypeTagProgressionTest._$X =?= (izumi.reflect.test.SharedLightTypeTagProgressionTest._$X {def x(0): 0})

953[info] - should fails to support methods with multiple parameter lists in refinements (12 milliseconds)

954[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Boolean): scala.Int})

955[info] + (java.lang.Object {def x(scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

956[info] + (java.lang.Object {def x(scala.Boolean): scala.Int}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

957[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Int): scala.Int})

958[info] + (java.lang.Object {def x(scala.Int): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

959[info] + (java.lang.Object {def x(scala.Int): scala.Int}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

960[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

961[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <?< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Any})

962[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Any}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

963[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Any}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

964[info] + (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int}) <?< (java.lang.Object {def x(scala.Int, scala.Nothing): scala.Int})

965[info] + (java.lang.Object {def x(scala.Int, scala.Nothing): scala.Int}) <!< (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

966[info] + (java.lang.Object {def x(scala.Int, scala.Nothing): scala.Int}) =!= (java.lang.Object {def x(scala.Int, scala.Boolean): scala.Int})

967[info] - should progression test: fails to `Any/Object relation is consistent with Scala` (2 milliseconds)

968[info] + java.lang.Object <?< scala.Any

969[info] + scala.Any <!< java.lang.Object

970[info] + scala.Any =!= java.lang.Object

971[info] - should progression test: can't distinguish between equal-bounded type and alias inside refinements on dotty (1 millisecond)

972[info] + (java.lang.Object {type X = Any}) =!= (java.lang.Object {type X = Any})

973[info] - should progression test: Null type is a subtype of Nothing, but shouldn't be (1 millisecond)

974[info] + scala.Null <!< scala.Nothing

975[info] [progression] lightweight type tag (Dotty)

976[info] - should fails to support variance for type parameters of opaque types (1 millisecond)

977[info] + izumi.reflect.test.LightTypeTagProgressionTest._$x::T[=scala.Int] <?< izumi.reflect.test.LightTypeTagProgressionTest._$x::T[=scala.AnyVal]

978[info] Scala213Plus_LightTypeTagTest:

979[info] lightweight type tags (2.13+)

980[info] - should literal types behave in sane manner https://github.com/zio/izumi-reflect/issues/284 (17 milliseconds)

981[info] + "a" =?= "a"

982[info] + "a" <?< "a"

983[info] + "a" <?< "a"

984[info] + "a" =?= "a"

985[info] + "a" <?< "a"

986[info] + "a" <?< "a"

987[info] + "a" =?= "a"

988[info] + "a" <?< "a"

989[info] + "a" <?< "a"

990[info] + "a" debug== "a"

991[info] + "a" debug== "a"

992[info] + "a" debug== "a"

993[info] + "a" <?< java.lang.String

994[info] + java.lang.String <!< "a"

995[info] + java.lang.String =!= "a"

996[info] + "a" <?< java.lang.String

997[info] + java.lang.String <!< "a"

998[info] + java.lang.String =!= "a"

999[info] + "a" <?< java.lang.String

1000[info] + java.lang.String <!< "a"

1001[info] + java.lang.String =!= "a"

1002[info] + "a" <?< java.lang.String

1003[info] + java.lang.String <!< "a"

1004[info] + java.lang.String =!= "a"

1005[info] - should support string constant types (Scala 2.13+ syntax) (7 milliseconds)

1006[info] + "abc" =!= java.lang.String

1007[info] + "abc" =!= "cba"

1008[info] + "abc" =?= "abc"

1009[info] + "abc" <?< "abc"

1010[info] + "abc" <?< "abc"

1011[info] + "abc" <?< java.lang.String

1012[info] + java.lang.String <!< "abc"

1013[info] + java.lang.String =!= "abc"

1014[info] TagTest:

1015[info] Tag (all versions)

1016[info] - should Work for any concrete type (3 milliseconds)

1017[info] - should Support identity lambda type equality (1 millisecond)

1018[info] - should regression test for https://github.com/zio/izumi-reflect/issues/98 (22 milliseconds)

1019[info] - should Work for any abstract type with available Tag when obscured by empty refinement (0 milliseconds)

1020[info] - should handle function local type aliases (13 milliseconds)

1021[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 (8 milliseconds)

1022[info] - should Tag.auto.T kind inference macro works for known cases (4 milliseconds)

1023[info] - should Shouldn't work for any abstract type without available TypeTag or Tag or TagK (0 milliseconds)

1024[info] - should handle Id type lambda (0 milliseconds)

1025[info] - should handle Id1 type lambda (1 millisecond)

1026[info] - should handle singleton types (1 millisecond)

1027[info] + izumi.reflect.test.ClockLive <?< izumi.reflect.test.Clock

1028[info] - should handle nested intersection aliases (49 milliseconds)

1029[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}

1030[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}

1031[info] + {java.lang.String & scala.Boolean & scala.Int} =?= {java.lang.String & scala.Boolean & scala.Int}

1032[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}

1033[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}

1034[info] + {java.lang.String & scala.Boolean & scala.Int} <?< java.lang.CharSequence

1035[info] + {java.lang.String & scala.Boolean & scala.Int} <?< java.lang.CharSequence

1036[info] - should handle nested refined intersection aliases (18 milliseconds)

1037[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}

1038[info] + {java.lang.String & scala.Boolean & scala.Int} <?< {java.lang.String & scala.Boolean & scala.Int}

1039[info] + {java.lang.String & scala.Boolean & scala.Int} =?= {java.lang.String & scala.Boolean & scala.Int}

1040[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}

1041[info] + {java.lang.String & scala.Boolean & scala.Int} <!< {java.lang.String & scala.Boolean & scala.Int & scala.Unit}

1042[info] + {java.lang.String & scala.Boolean & scala.Int} <?< java.lang.CharSequence

1043[info] - should simple combined Tag (2 milliseconds)

1044[info] + izumi.reflect.test.TestModel::ApplePaymentProvider[=λ %0 → 0] <?< izumi.reflect.test.TestModel::H1

1045[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) (9 milliseconds)

1046[info] + izumi.reflect.test.SharedTagTest._$A::X =?= izumi.reflect.test.SharedTagTest._$A::X

1047[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X

1048[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X

1049[info] + "bar" =?= "bar"

1050[info] + "bar" <?< "bar"

1051[info] + "bar" <?< "bar"

1052[info] + "bar" =?= "bar"

1053[info] + "bar" <?< "bar"

1054[info] + "bar" <?< "bar"

1055[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 =?= izumi.reflect.test.SharedTagTest._$A::singleton2

1056[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2

1057[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2

1058[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 =?= izumi.reflect.test.SharedTagTest._$A::singleton2

1059[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2

1060[info] + izumi.reflect.test.SharedTagTest._$A::singleton2 <?< izumi.reflect.test.SharedTagTest._$A::singleton2

1061[info] + izumi.reflect.test.SharedTagTest._$A::X =?= izumi.reflect.test.SharedTagTest._$A::X

1062[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X

1063[info] + izumi.reflect.test.SharedTagTest._$A::X <?< izumi.reflect.test.SharedTagTest._$A::X

1064[info] + "bar" =?= "bar"

1065[info] + "bar" <?< "bar"

1066[info] + "bar" <?< "bar"

1067[info] + "bar" =?= "bar"

1068[info] + "bar" <?< "bar"

1069[info] + "bar" <?< "bar"

1070[info] + "bar" =?= "bar"

1071[info] + "bar" <?< "bar"

1072[info] + "bar" <?< "bar"

1073[info] - should Does NOT synthesize Tags for abstract types, but recursively summons Tag[this.Abstract] (5 milliseconds)

1074[info] + scala.Int =?= scala.Int

1075[info] + scala.Int <?< scala.Int

1076[info] + scala.Int <?< scala.Int

1077[info] + scala.Option[+scala.Int] =?= scala.Option[+scala.Int]

1078[info] + scala.Option[+scala.Int] <?< scala.Option[+scala.Int]

1079[info] + scala.Option[+scala.Int] <?< scala.Option[+scala.Int]

1080[info] - should DOES synthesize Tags for abstract types (object X; X.T), does not summon Tag[X.T] (7 milliseconds)

1081[info] + izumi.reflect.test.SomeObject::Abstract =!= scala.Int

1082[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] =!= scala.Option[+scala.Int]

1083[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] =?= scala.Option[+izumi.reflect.test.SomeObject::Abstract]

1084[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] <?< scala.Option[+izumi.reflect.test.SomeObject::Abstract]

1085[info] + scala.Option[+izumi.reflect.test.SomeObject::Abstract] <?< scala.Option[+izumi.reflect.test.SomeObject::Abstract]

1086[info] - should DOES synthesize Tags for abstract types (trait X; X#T), does not summon Tag[X#T] (2 milliseconds)

1087[info] + izumi.reflect.test.SomeTrait::Abstract =!= scala.Int

1088[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] =!= scala.Option[+scala.Int]

1089[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] =?= scala.Option[+izumi.reflect.test.SomeTrait::Abstract]

1090[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] <?< scala.Option[+izumi.reflect.test.SomeTrait::Abstract]

1091[info] + scala.Option[+izumi.reflect.test.SomeTrait::Abstract] <?< scala.Option[+izumi.reflect.test.SomeTrait::Abstract]

1092[info] - should DOES synthesize Tags for abstract types (val x; x.T), does not summon Tag[x.T] (2 milliseconds)

1093[info] + izumi.reflect.test.SharedTagTest._$x::Abstract =!= scala.Int

1094[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] =!= scala.Option[+scala.Int]

1095[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] =?= scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract]

1096[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] <?< scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract]

1097[info] + scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract] <?< scala.Option[+izumi.reflect.test.SharedTagTest._$x::Abstract]

1098[info] - should Work for an abstract type with available TagK when obscured by empty refinement (2 milliseconds)

1099[info] - should Work for an abstract type with available TagK when TagK is requested through an explicit implicit (1 millisecond)

1100[info] - should Work for an abstract type with available TagKK (3 milliseconds)

1101[info] - should Work for any configuration of parameters (7 milliseconds)

1102[info] - should handle Swap type lambda (0 milliseconds)

1103[info] - should Assemble from higher than TagKK tags (0 milliseconds)

1104[info] - should regression test: https://github.com/zio/izumi-reflect/issues/293 assemble tag for Builder[B, Collection[B]] (2 milliseconds)

1105[info] + scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]] =?= scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]]

1106[info] + scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]] <?< scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]]

1107[info] + scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]] <?< scala.collection.mutable.Builder[-scala.Int,+java.util.Collection[=scala.Int]]

1108[info] - should combine intersection types (7 milliseconds)

1109[info] + {java.lang.String & scala.Int} =?= {java.lang.String & scala.Int}

1110[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}

1111[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}

1112[info] + {java.lang.String & scala.Int} =?= {java.lang.String & scala.Int}

1113[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}

1114[info] + {java.lang.String & scala.Int} <?< {java.lang.String & scala.Int}

1115[info] + java.lang.String =?= java.lang.String

1116[info] + java.lang.String <?< java.lang.String

1117[info] + java.lang.String <?< java.lang.String

1118[info] + java.lang.String =?= java.lang.String

1119[info] + java.lang.String <?< java.lang.String

1120[info] + java.lang.String <?< java.lang.String

1121[info] - should summon HKT Tag for a Java type (0 milliseconds)

1122[info] - should regression test: https://github.com/zio/izumi-reflect/issues/76 derive tag for a parametric trait inside object (5 milliseconds)

1123[info] + izumi.reflect.test.X76::T[=scala.Int] =?= izumi.reflect.test.X76::T[=scala.Int]

1124[info] + izumi.reflect.test.X76::T[=scala.Int] <?< izumi.reflect.test.X76::T[=scala.Int]

1125[info] + izumi.reflect.test.X76::T[=scala.Int] <?< izumi.reflect.test.X76::T[=scala.Int]

1126[info] - should this.type tags should be generated, but are identical with their class / object tag (5 milliseconds)

1127[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix debug== izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1128[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix debug== izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1129[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1130[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1131[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1132[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1133[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1134[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1135[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1136[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1137[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1138[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1139[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix <!< izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1140[info] + izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix =!= izumi.reflect.test.TestModel::ThisPrefixTest::ThisPrefix

1141[info] - should this.type should have correct prefix (1 millisecond)

1142[info] - should regression test: https://github.com/zio/izumi-reflect/issues/83, convert trifunctor tag to bifunctor tag (2 milliseconds)

1143[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]]

1144[info] - should resolve TagK from TagKK (5 milliseconds)

1145[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] =?= λ %0 → scala.util.Either[+java.lang.Throwable,+0]

1146[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] <?< λ %0 → scala.util.Either[+java.lang.Throwable,+0]

1147[info] + λ %0 → scala.util.Either[+java.lang.Throwable,+0] <?< λ %1 → scala.util.Either[+java.lang.Throwable,+1]

1148[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] <?< λ %0 → scala.util.Either[+scala.Any,+0]

1149[info] + λ %0 → scala.util.Either[+scala.Any,+0] <!< λ %1 → scala.util.Either[+java.lang.Throwable,+1]

1150[info] + λ %0 → scala.util.Either[+scala.Any,+0] =!= λ %1 → scala.util.Either[+java.lang.Throwable,+1]

1151[info] + λ %0 → scala.util.Either[+scala.Nothing,+0] <?< λ %1 → scala.util.Either[+java.lang.Throwable,+1]

1152[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] <!< λ %0 → scala.util.Either[+scala.Nothing,+0]

1153[info] + λ %1 → scala.util.Either[+java.lang.Throwable,+1] =!= λ %0 → scala.util.Either[+scala.Nothing,+0]

1154[info] - should can materialize TagK for type lambdas that close on a generic parameter with available Tag (1 millisecond)

1155[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)

1156[info] - should type parameter covariance works after combine (1 millisecond)

1157[info] - should combine Const Lambda to TagK (1 millisecond)

1158[info] - should combined TagK 3 & 2 parameter coherence (0 milliseconds)

1159[info] - should resolve TagKK from an odd higher-kinded Tag with swapped & ignored parameters (3 milliseconds)

1160[info] - should can resolve Tags of TagK's themselves correctly (7 milliseconds)

1161[info] + izumi.reflect.Tag[=λ %0 → scala.collection.immutable.List[+0]] <?< izumi.reflect.Tag[=λ %0 → scala.collection.immutable.List[+0]]

1162[info] + izumi.reflect.Tag[=λ %0,%1 → scala.util.Either[+0,+1]] =?= izumi.reflect.Tag[=λ %0,%1 → scala.util.Either[+0,+1]]

1163[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]]

1164[info] + izumi.reflect.Tag[=λ %0,%1 → izumi.reflect.test.OptionT[=0,=1]] =?= izumi.reflect.Tag[=λ %0,%1 → izumi.reflect.test.OptionT[=0,=1]]

1165[info] - should regression test: ignore function-local anonymous classes (https://github.com/zio/zio/issues/4285) (1 millisecond)

1166[info] - should equal path-dependent tags for singleton types are expected to be equal (1 millisecond)

1167[info] - should return expected class tag (3 milliseconds)

1168[info] - should Work with term type prefixes (11 milliseconds)

1169[info] + izumi.reflect.test.SharedTagTest._$zy::T =?= izumi.reflect.test.SharedTagTest._$zy::T

1170[info] + izumi.reflect.test.SharedTagTest._$zy::T <?< izumi.reflect.test.SharedTagTest._$zy::T

1171[info] + izumi.reflect.test.SharedTagTest._$zy::T <?< izumi.reflect.test.SharedTagTest._$zy::T

1172[info] + izumi.reflect.test.SharedTagTest._$zy::T <!< izumi.reflect.test.SharedTagTest._$zx::T

1173[info] + izumi.reflect.test.SharedTagTest._$zx::T <!< izumi.reflect.test.SharedTagTest._$zy::T

1174[info] + izumi.reflect.test.SharedTagTest._$zx::T =!= izumi.reflect.test.SharedTagTest._$zy::T

1175[info] + izumi.reflect.test.SharedTagTest._$zy::x =?= izumi.reflect.test.SharedTagTest._$zy::x

1176[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< izumi.reflect.test.SharedTagTest._$zy::x

1177[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< izumi.reflect.test.SharedTagTest._$zy::x

1178[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< java.lang.String

1179[info] + izumi.reflect.test.SharedTagTest._$zy::x <?< java.io.Serializable

1180[info] + izumi.reflect.test.SharedTagTest._$zy::x <!< izumi.reflect.test.SharedTagTest._$zx::x

1181[info] + izumi.reflect.test.SharedTagTest._$zx::x <!< izumi.reflect.test.SharedTagTest._$zy::x

1182[info] + izumi.reflect.test.SharedTagTest._$zx::x =!= izumi.reflect.test.SharedTagTest._$zy::x

1183[info] + izumi.reflect.test.SharedTagTest._$zy::y =?= izumi.reflect.test.SharedTagTest._$zy::y

1184[info] + izumi.reflect.test.SharedTagTest._$zy::y <?< izumi.reflect.test.SharedTagTest._$zy::y

1185[info] + izumi.reflect.test.SharedTagTest._$zy::y <?< izumi.reflect.test.SharedTagTest._$zy::y

1186[info] + izumi.reflect.test.SharedTagTest._$zy::y <?< java.lang.Object

1187[info] + izumi.reflect.test.SharedTagTest._$zy::y <!< izumi.reflect.test.SharedTagTest._$zx::y

1188[info] + izumi.reflect.test.SharedTagTest._$zx::y <!< izumi.reflect.test.SharedTagTest._$zy::y

1189[info] + izumi.reflect.test.SharedTagTest._$zx::y =!= izumi.reflect.test.SharedTagTest._$zy::y

1190[info] + izumi.reflect.test.SharedTagTest._$zy::y <!< izumi.reflect.test.SharedTagTest._$zx::x

1191[info] + izumi.reflect.test.SharedTagTest._$zx::x <!< izumi.reflect.test.SharedTagTest._$zy::y

1192[info] + izumi.reflect.test.SharedTagTest._$zx::x =!= izumi.reflect.test.SharedTagTest._$zy::y

1193[info] - should correctly resolve abstract types inside traits when summoned inside trait (6 milliseconds)

1194[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] =!= izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$b::T]

1195[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] =?= izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T]

1196[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] <?< izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T]

1197[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] <?< izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T]

1198[info] + izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$a::T] =!= izumi.reflect.test.SharedTagTest::DockerContainer[=izumi.reflect.test.SharedTagTest._$b::T]

1199[info] - should combine higher-kinded type lambdas without losing ignored type arguments (1 millisecond)

1200[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]]

1201[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]]

1202[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]]

1203[info] - should resolve a higher-kinded type inside a named type lambda with ignored type arguments (1 millisecond)

1204[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]]

1205[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]]

1206[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]]

1207[info] - should resolve TagKK from an odd higher-kinded Tag with swapped & ignored parameters (low-level) (4 milliseconds)

1208[info] + λ %2,%3 → scala.util.Either[+java.lang.Throwable,+3] =?= λ %0,%1 → scala.util.Either[+java.lang.Throwable,+1]

1209[info] + λ %2,%3 → scala.util.Either[+java.lang.Throwable,+3] <?< λ %0,%1 → scala.util.Either[+java.lang.Throwable,+1]

1210[info] + λ %0,%1 → scala.util.Either[+java.lang.Throwable,+1] <?< λ %2,%3 → scala.util.Either[+java.lang.Throwable,+3]

1211[info] - should correctly resolve a higher-kinded nested type inside a named swap type lambda (3 milliseconds)

1212[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]]

1213[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]]

1214[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]]

1215[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]]

1216[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]]

1217[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]]

1218[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]]

1219[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]]

1220[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]]

1221[info] - should support subtyping of parents parameterized with type lambdas in combined tags (2 milliseconds)

1222[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]]

1223[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]]

1224[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]]

1225[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]]

1226[info] - should support subtyping of parents parameterized with type lambdas in combined tags with multiple parameters (3 milliseconds)

1227[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]

1228[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]]

1229[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]]

1230[info] - should combine inside type lambdas with repeated usages of a type lambda type parameter (1 millisecond)

1231[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]]

1232[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]]

1233[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]]

1234[info] - should combine inside type lambdas with repeated usages of an outer type (2 milliseconds)

1235[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]]

1236[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]]

1237[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]]

1238[info] - should combine inside type lambdas with repeated usages of an outer distinct type with the same type symbol (7 milliseconds)

1239[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]]]

1240[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]]]

1241[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]]]

1242[info] - should combine inside type lambdas where the type constructor of the type lambda result is a type lambda type parameter (2 milliseconds)

1243[info] + izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → 1[=scala.Int]] =?= izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → 1[=scala.Int]]

1244[info] + izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → 1[=scala.Int]] <?< izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → 1[=scala.Int]]

1245[info] + izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → 1[=scala.Int]] <?< izumi.reflect.test.InheritedModel::BlockingIO3T[=λ %0,%1,%2 → 1[=scala.Int]]

1246[info] - should regression test: https://github.com/zio/izumi-reflect/issues/82, convert trifunctor hkt to bifunctor when combining tags (1 millisecond)

1247[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]]

1248[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]]

1249[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]]

1250[info] - should combine higher-kinded types without losing ignored type arguments (1 millisecond)

1251[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]]

1252[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]]

1253[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]]

1254[info] - should resolve a higher-kinded type inside an anonymous type lambda with ignored & higher-kinded type arguments (1 millisecond)

1255[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]]

1256[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]]

1257[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]]

1258[info] - should correctly resolve a higher-kinded nested type inside an anonymous swap type lambda (2 milliseconds)

1259[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]]

1260[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]]

1261[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]]

1262[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]]

1263[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]]

1264[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]]

1265[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]]

1266[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]]

1267[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]]

1268[info] - should handles abstract types instead of parameters (5 milliseconds)

1269[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]]

1270[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]]

1271[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]]

1272[info] - should Generates lambda parents for lambda bases (6 milliseconds)

1273[info] - should subtyping for Invariant Java HKT (1 millisecond)

1274[info] + λ %0 → java.util.Collection[=0] <?< λ %0 → java.lang.Iterable[=0]

1275[info] + λ %0 → java.lang.Iterable[=0] <!< λ %0 → java.util.Collection[=0]

1276[info] + λ %0 → java.lang.Iterable[=0] =!= λ %0 → java.util.Collection[=0]

1277[info] - should subtyping for Invariant Scala HKT (4 milliseconds)

1278[info] + λ %0 → scala.collection.mutable.Set[=0] <?< λ %0 → scala.collection.Set[=0]

1279[info] + λ %0 → scala.collection.Set[=0] <!< λ %0 → scala.collection.mutable.Set[=0]

1280[info] + λ %0 → scala.collection.Set[=0] =!= λ %0 → scala.collection.mutable.Set[=0]

1281[info] - should Work for structural concrete types (5 milliseconds)

1282[info] + (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean}) =?= (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean})

1283[info] + (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean}) <?< (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean})

1284[info] + (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean}) <?< (java.lang.Object {def a(): scala.Int, def g(): scala.Boolean})

1285[info] + (scala.Int {def a(): scala.Int}) =?= (scala.Int {def a(): scala.Int})

1286[info] + (scala.Int {def a(): scala.Int}) <?< (scala.Int {def a(): scala.Int})

1287[info] + (scala.Int {def a(): scala.Int}) <?< (scala.Int {def a(): scala.Int})

1288[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"]}

1289[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"]}

1290[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"]}

1291[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"]}

1292[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"]}

1293[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"]}

1294[info] - should Work for any abstract type with available Tag while preserving additional type refinement (9 milliseconds)

1295[info] + (java.lang.String {type X = Int, type Y = String}) =?= (java.lang.String {type X = Int, type Y = String})

1296[info] + (java.lang.String {type X = Int, type Y = String}) <?< (java.lang.String {type X = Int, type Y = String})

1297[info] + (java.lang.String {type X = Int, type Y = String}) <?< (java.lang.String {type X = Int, type Y = String})

1298[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = String, type Y = Boolean})

1299[info] + (java.lang.String {type X = String, type Y = Boolean}) <!< (java.lang.String {type X = Int, type Y = String})

1300[info] + (java.lang.String {type X = String, type Y = Boolean}) =!= (java.lang.String {type X = Int, type Y = String})

1301[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = String, type Y = Boolean})

1302[info] + (java.lang.String {type X = String, type Y = Boolean}) <!< (java.lang.String {type X = Int, type Y = String})

1303[info] + (java.lang.String {type X = String, type Y = Boolean}) =!= (java.lang.String {type X = Int, type Y = String})

1304[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = Int, type Y = Boolean})

1305[info] + (java.lang.String {type X = Int, type Y = Boolean}) <!< (java.lang.String {type X = Int, type Y = String})

1306[info] + (java.lang.String {type X = Int, type Y = Boolean}) =!= (java.lang.String {type X = Int, type Y = String})

1307[info] + (java.lang.String {type X = Int, type Y = String}) <!< (java.lang.String {type X = Boolean, type Y = String})

1308[info] + (java.lang.String {type X = Boolean, type Y = String}) <!< (java.lang.String {type X = Int, type Y = String})

1309[info] + (java.lang.String {type X = Boolean, type Y = String}) =!= (java.lang.String {type X = Int, type Y = String})

1310[info] - should Work for any abstract type with available Tag while preserving additional method refinement (7 milliseconds)

1311[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})

1312[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})

1313[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})

1314[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})

1315[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})

1316[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})

1317[info] + (java.lang.String {def x(): scala.Int, def y(): java.lang.String}) <!< (java.lang.String {def x(): scala.Int, def y(): scala.Boolean})

1318[info] + (java.lang.String {def x(): scala.Int, def y(): scala.Boolean}) <!< (java.lang.String {def x(): scala.Int, def y(): java.lang.String})

1319[info] + (java.lang.String {def x(): scala.Int, def y(): scala.Boolean}) =!= (java.lang.String {def x(): scala.Int, def y(): java.lang.String})

1320[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})

1321[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})

1322[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})

1323[info] - should can resolve parameters in structural types (0 milliseconds)

1324[info] + (java.lang.Object {type T = Int}) =?= (java.lang.Object {type T = Int})

1325[info] + (java.lang.Object {type T = Int}) =!= (java.lang.Object {type T = String})

1326[info] - should combine higher-kinded type members (9 milliseconds)

1327[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]

1328[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]

1329[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]

1330[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]

1331[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]

1332[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]

1333[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]

1334[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]

1335[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]

1336[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< scala.AnyVal

1337[info] + scala.AnyVal <!< izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]

1338[info] + scala.AnyVal =!= izumi.reflect.test.TestModel::HigherKindedTypeMember::T[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]

1339[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

1340[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]

1341[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]

1342[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]

1343[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]

1344[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]

1345[info] + izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int] <?< scala.AnyVal

1346[info] + scala.AnyVal <!< izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]

1347[info] + scala.AnyVal =!= izumi.reflect.test.TestModel::HigherKindedTypeMember::G[=λ %0 → izumi.reflect.test.TestModel::ZIO[-scala.Any,+java.lang.Throwable,+0],=scala.Int]

1348[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 (9 milliseconds)

1349[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]]

1350[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]]

1351[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]]

1352[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]]

1353[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]]

1354[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]]

1355[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]]

1356[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]]

1357[info] - should support injecting runtime tags in place of type projections from type parameters / match types on type parameters (11 milliseconds)

1358[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] =?= izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]

1359[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] <?< izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]

1360[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] <?< izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]

1361[info] + izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl] debug== izumi.reflect.test.DiscoveryModel::DiscoveryNodeProvider[=izumi.reflect.test.DiscoveryModel::NodeIdImpl]

1362[info] - should regression test for: Scala 2, https://github.com/zio/izumi-reflect/issues/189, parameterized type alias with intersection produces incorrect output (5 milliseconds)

1363[info] - should combining with wildcards is supported (10 milliseconds)

1364[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>]

1365[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>]

1366[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>]

1367[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>]

1368[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>]

1369[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>]

1370[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>]

1371[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>]

1372[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>]

1373[info] - should other type members' bounds are not malformed when resolving parameters in structural types (1 millisecond)

1374[info] + (java.lang.Object {type G = G|<Int..AnyVal>, type T = Int}) =?= (java.lang.Object {type G = G|<Int..AnyVal>, type T = Int})

1375[info] + (java.lang.Object {type G = G|<Int..AnyVal>, type T = Int}) =!= (java.lang.Object {type G = G|<Int..AnyVal>, type T = String})

1376[info] - should form a correct type lambda for an equal-bounded abstract type (5 milliseconds)

1377[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] =?= izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]

1378[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]

1379[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] <?< izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]

1380[info] + izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String] =!= scala.Any

1381[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]]

1382[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]]

1383[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]]

1384[info] + scala.collection.immutable.Set[=izumi.reflect.test.TestModel::RoleDep::RoleDep[=scala.Int,=java.lang.String]] =!= scala.Any

1385[info] - should eradicate intersection tautologies with Any/Object (Tag) (3 milliseconds)

1386[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1387[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1388[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1389[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1390[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1391[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1392[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1393[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1394[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1395[info] - should tautological intersections with Any/Object are discarded from internal structure (Tag) (3 milliseconds)

1396[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1397[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1398[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1399[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1400[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1401[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1402[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1403[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1404[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1405[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1406[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1407[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1408[info] - should regression test for https://github.com/zio/izumi-reflect/issues/474 (0 milliseconds)

1409[info] - should resolve parameters inside type bounds & wildcards (17 milliseconds)

1410[info] + scala.collection.immutable.Set[=?: <scala.Nothing..scala.Int>] =?= scala.collection.immutable.Set[=?: <scala.Nothing..scala.Int>]

1411[info] + scala.collection.immutable.Set[=?: <scala.Int..scala.Any>] =?= scala.collection.immutable.Set[=?: <scala.Int..scala.Any>]

1412[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]>]

1413[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]>]

1414[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]>]

1415[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]

1416[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]

1417[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]

1418[info] Tag (Dotty)

1419[info] - should Support union subtyping (Scala 3 specific, union types) (2 milliseconds)

1420[info] + izumi.reflect.test.TagTest._$Dog <?< izumi.reflect.test.TagTest._$Animal

1421[info] + {izumi.reflect.test.TagTest._$Dog | java.lang.String} <?< {izumi.reflect.test.TagTest._$Animal | java.lang.String}

1422[info] + {izumi.reflect.test.TagTest._$Animal | java.lang.String} <!< {izumi.reflect.test.TagTest._$Dog | java.lang.String}

1423[info] - should Support HKTag for unapplied type lambdas with type bounds (Scala 3 specific, union types) (1 millisecond)

1424[info] + izumi.reflect.test.TagTest._$XAble[=izumi.reflect.test.TagTest._$Y] =?= izumi.reflect.test.TagTest._$XAble[=izumi.reflect.test.TagTest._$Y]

1425[info] - should Can create custom type tags to support bounded generics, e.g. <: Dep in TagK (Scala 3 HKTag Syntax) (0 milliseconds)

1426[info] - should combine union types (Scala 3 specific, union types) (2 milliseconds)

1427[info] + {java.lang.String | scala.Int} =?= {java.lang.String | scala.Int}

1428[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}

1429[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}

1430[info] + {java.lang.String | scala.Int} =?= {java.lang.String | scala.Int}

1431[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}

1432[info] + {java.lang.String | scala.Int} <?< {java.lang.String | scala.Int}

1433[info] + java.lang.String =?= java.lang.String

1434[info] + java.lang.String <?< java.lang.String

1435[info] + java.lang.String <?< java.lang.String

1436[info] + java.lang.String =?= java.lang.String

1437[info] + java.lang.String <?< java.lang.String

1438[info] + java.lang.String <?< java.lang.String

1439[info] - should type tags with bounds are successfully requested by TagMacro (1 millisecond)

1440[info] + izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep] =?= izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep]

1441[info] + izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep] <?< izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep]

1442[info] + izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep] <?< izumi.reflect.test.TagTest::Trait3[=izumi.reflect.test.InheritedModel::Dep]

1443[info] - should remove tautological unions with Nothing (LTT) (1 millisecond)

1444[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1445[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1446[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1447[info] - should remove tautological unions with Nothing (Tag) (1 millisecond)

1448[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1449[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1450[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1451[info] - should combine intersection path-dependent intersection types with inner tags works on Scala 3 (2 milliseconds)

1452[info] + {scala.Int & scala.Unit} =?= {scala.Int & scala.Unit}

1453[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}

1454[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}

1455[info] + {scala.Int & scala.Unit} =?= {scala.Int & scala.Unit}

1456[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}

1457[info] + {scala.Int & scala.Unit} <?< {scala.Int & scala.Unit}

1458[info] LightTypeTagTest:

1459[info] lightweight type tags (all versions)

1460[info] - should support distinction between subtypes (153 milliseconds)

1461[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> <?< java.lang.String

1462[info] + java.lang.String <!< izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>

1463[info] + java.lang.String =!= izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>

1464[info] + izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>> <?< java.lang.String

1465[info] + java.lang.String <!< izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>

1466[info] + java.lang.String =!= izumi.reflect.test.TestModel::SubSubStr|<scala.Nothing..izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>>

1467[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>

1468[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>>

1469[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>>

1470[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>

1471[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>>

1472[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>>

1473[info] + java.lang.String =?= java.lang.String

1474[info] + java.lang.String <?< java.lang.String

1475[info] + java.lang.String <?< java.lang.String

1476[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> <!< izumi.reflect.test.TestModel::SubStrB|<scala.Nothing..java.lang.String>

1477[info] + izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String> =?= izumi.reflect.test.TestModel::SubStrA|<scala.Nothing..java.lang.String>

1478[info] + java.lang.String =?= java.lang.String

1479[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]

1480[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]

1481[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]

1482[info] - should eradicate intersection tautologies with Any/Object (18 milliseconds)

1483[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1484[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1485[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1486[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1487[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1488[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1489[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1490[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1491[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1492[info] - should do not eradicate intersections with Nothing (10 milliseconds)

1493[info] + {scala.Nothing & scala.Option[+java.lang.String]} =!= scala.Option[+java.lang.String]

1494[info] + {scala.Nothing & scala.Option[+java.lang.String]} =?= {scala.Nothing & scala.Option[+java.lang.String]}

1495[info] + {scala.Nothing & scala.Option[+java.lang.String]} <?< {scala.Nothing & scala.Option[+java.lang.String]}

1496[info] + {scala.Nothing & scala.Option[+java.lang.String]} <?< {scala.Nothing & scala.Option[+java.lang.String]}

1497[info] - should eradicate self-intersection (X with X) (2 milliseconds)

1498[info] + java.lang.String =?= java.lang.String

1499[info] + java.lang.String <?< java.lang.String

1500[info] + java.lang.String <?< java.lang.String

1501[info] - should support subtype checks (83 milliseconds)

1502[info] + scala.Int <?< scala.AnyVal

1503[info] + scala.Int <?< scala.Int

1504[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+scala.Int]

1505[info] + scala.collection.immutable.List[+izumi.reflect.test.TestModel::I2] <?< scala.collection.immutable.List[+izumi.reflect.test.TestModel::I1]

1506[info] + scala.util.Either[+scala.Nothing,+scala.Int] <?< scala.util.Either[+java.lang.Throwable,+scala.Int]

1507[info] + izumi.reflect.test.TestModel::F2[+izumi.reflect.test.TestModel::I2] <?< izumi.reflect.test.TestModel::F1[+izumi.reflect.test.TestModel::I1]

1508[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]]

1509[info] + izumi.reflect.test.TestModel::FM2[+izumi.reflect.test.TestModel::I2] <?< izumi.reflect.test.TestModel::FM1[+izumi.reflect.test.TestModel::I1,+scala.Unit]

1510[info] + scala.Option[+scala.Nothing] <?< scala.Option[+scala.Int]

1511[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]]

1512[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]]

1513[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]]

1514[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]]

1515[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]]

1516[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]]

1517[info] - should support unsound subtype checks (35 milliseconds)

1518[info] + izumi.reflect.test.TestModel::FM2[+izumi.reflect.test.TestModel::I2] <!< λ %0,%1 → izumi.reflect.test.TestModel::FM1[+0,+1]

1519[info] + scala.collection.immutable.List[+scala.Int] <!< λ %0 → scala.collection.immutable.List[+0]

1520[info] + scala.collection.immutable.Set[=scala.Int] <!< λ %0 → scala.collection.immutable.Set[=0]

1521[info] - should support swapped parents (41 milliseconds)

1522[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]

1523[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]

1524[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]

1525[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]

1526[info] + izumi.reflect.test.SharedLightTypeTagTest._$KK2[+scala.Int,+java.lang.String] <?< izumi.reflect.test.SharedLightTypeTagTest._$KK1[+java.lang.String,+scala.Int,+scala.Unit]

1527[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]

1528[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]

1529[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]

1530[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]

1531[info] + λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] <?< λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK1[+0,+1,+scala.Unit]

1532[info] + λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+1,+0] <!< λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$KK2[+0,+1]

1533[info] - should support subtyping of parents parameterized with type lambdas (2 milliseconds)

1534[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]]

1535[info] - should support subtyping of parents parameterized with type lambdas in combined tags (6 milliseconds)

1536[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]]

1537[info] - should support subtyping of parents parameterized with type lambdas in combined tags with multiple parameters (6 milliseconds)

1538[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]

1539[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]]

1540[info] - should support PDTs (4 milliseconds)

1541[info] + scala.Int =?= scala.Int

1542[info] + izumi.reflect.test.SharedLightTypeTagTest._$a0::A =!= scala.Int

1543[info] + izumi.reflect.test.SharedLightTypeTagTest._$a1::A =!= scala.Int

1544[info] + izumi.reflect.test.SharedLightTypeTagTest._$a1::A =!= java.lang.String

1545[info] + izumi.reflect.test.SharedLightTypeTagTest._$a1::A <?< izumi.reflect.test.SharedLightTypeTagTest._$a1::A

1546[info] + java.lang.String =?= java.lang.String

1547[info] - should intersections are associative (5 milliseconds)

1548[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]}

1549[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]}

1550[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]}

1551[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]}

1552[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]}

1553[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]}

1554[info] - should runtime-combined intersections are associative (7 milliseconds)

1555[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]}

1556[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]}

1557[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]}

1558[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]}

1559[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]}

1560[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]}

1561[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]}

1562[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]}

1563[info] - should support type alias and refinement subtype checks (12 milliseconds)

1564[info] + izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})> <?< (java.lang.Object {type X = X})

1565[info] + (java.lang.Object {type X = X}) <!< izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>

1566[info] + (java.lang.Object {type X = X}) =!= izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>

1567[info] + izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})> <?< (java.lang.Object {type X = X})

1568[info] + (java.lang.Object {type X = X}) <!< izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>

1569[info] + (java.lang.Object {type X = X}) =!= izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})>

1570[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1571[info] + (java.lang.Object {type X = Any}) <?< (java.lang.Object {type X = X})

1572[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1573[info] + (java.lang.Object {type X = X}) =!= (java.lang.Object {type X = Any})

1574[info] + (java.lang.Object {type X = Any}) <?< (java.lang.Object {type X = X})

1575[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1576[info] + (java.lang.Object {type X = X}) =!= (java.lang.Object {type X = Any})

1577[info] + (java.lang.Object {type X = X}) =?= (java.lang.Object {type X = X})

1578[info] + (java.lang.Object {type X = X}) <?< (java.lang.Object {type X = X})

1579[info] + (java.lang.Object {type X = X}) <?< (java.lang.Object {type X = X})

1580[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = X|<Nothing..AnyVal>})

1581[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1582[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1583[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1584[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Any})

1585[info] + izumi.reflect.test.TestModel::XS|<scala.Nothing..(java.lang.Object {type X = X})> <!< (java.lang.Object {type X = Any})

1586[info] + (java.lang.Object {type X = Int}) <?< (java.lang.Object {type X = X})

1587[info] + (java.lang.Object {type X = X}) <!< (java.lang.Object {type X = Int})

1588[info] + (java.lang.Object {type X = X}) =!= (java.lang.Object {type X = Int})

1589[info] + (java.lang.Object {type X = Int}) <?< (java.lang.Object {type X = X|<Nothing..AnyVal>})

1590[info] + (java.lang.Object {type X = X|<Nothing..AnyVal>}) <!< (java.lang.Object {type X = Int})

1591[info] + (java.lang.Object {type X = X|<Nothing..AnyVal>}) =!= (java.lang.Object {type X = Int})

1592[info] + (java.lang.Object {type X = Int}) <!< (java.lang.Object {type X = Any})

1593[info] + (java.lang.Object {type X = Any}) <!< (java.lang.Object {type X = Int})

1594[info] + (java.lang.Object {type X = Any}) =!= (java.lang.Object {type X = Int})

1595[info] + (java.lang.Object {type X = Int}) <!< (java.lang.Object {type X = Any})

1596[info] + (java.lang.Object {type X = Any}) <!< (java.lang.Object {type X = Int})

1597[info] + (java.lang.Object {type X = Any}) =!= (java.lang.Object {type X = Int})

1598[info] - should support refinement higher-kinded subtype checks (7 milliseconds)

1599[info] + (java.lang.Object {type F = λ %0 → 0}) <?< (java.lang.Object {type F = F|<Nothing..λ %0 → Any>})

1600[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) <!< (java.lang.Object {type F = λ %0 → 0})

1601[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) =!= (java.lang.Object {type F = λ %0 → 0})

1602[info] + (java.lang.Object {type F = λ %0 → 0}) <!< (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>})

1603[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) <!< (java.lang.Object {type F = λ %0 → 0})

1604[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) =!= (java.lang.Object {type F = λ %0 → 0})

1605[info] + izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})> <?< (java.lang.Object {type F = λ %0 → 0})

1606[info] + (java.lang.Object {type F = λ %0 → 0}) <!< izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>

1607[info] + (java.lang.Object {type F = λ %0 → 0}) =!= izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>

1608[info] + izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})> <?< (java.lang.Object {type F = F|<Nothing..λ %0 → Any>})

1609[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) <!< izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>

1610[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → Any>}) =!= izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>

1611[info] + izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})> <!< (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>})

1612[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) <!< izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>

1613[info] + (java.lang.Object {type F = F|<Nothing..λ %0 → AnyVal>}) =!= izumi.reflect.test.TestModel::FXS|<scala.Nothing..(java.lang.Object {type F = λ %0 → 0})>

1614[info] - should support literal types (3 milliseconds)

1615[info] + "str2" =?= "str2"

1616[info] + "str1" =!= "str2"

1617[info] + "str" <?< java.lang.String

1618[info] + java.lang.String <!< "str"

1619[info] + java.lang.String =!= "str"

1620[info] + "str" <!< scala.Int

1621[info] - should resolve comparisons of object and trait with the same name (3 milliseconds)

1622[info] + izumi.reflect.test.TestModel::YieldOpCounts <!< izumi.reflect.test.TestModel::RoleChild[=λ %0,%1 → scala.util.Either[+0,+1]]

1623[info] + izumi.reflect.test.TestModel::YieldOpCounts <?< izumi.reflect.test.TestModel::YieldOpCounts

1624[info] + izumi.reflect.test.TestModel::YieldOpCounts =!= izumi.reflect.test.TestModel::YieldOpCounts

1625[info] + izumi.reflect.test.TestModel::YieldOpCounts <!< izumi.reflect.test.TestModel::YieldOpCounts

1626[info] - should resolve prefixes of annotated types (0 milliseconds)

1627[info] + izumi.reflect.test.TestModel::TPrefix::T =?= izumi.reflect.test.TestModel::TPrefix::T

1628[info] - should `withoutArgs` comparison works (16 milliseconds)

1629[info] + scala.collection.immutable.Set =?= scala.collection.immutable.Set

1630[info] + scala.collection.mutable.LinkedHashSet <?< scala.collection.Set

1631[info] + scala.collection.immutable.ListSet <?< scala.collection.Set

1632[info] + scala.collection.immutable.ListSet <?< scala.collection.immutable.Set

1633[info] + scala.collection.BitSet <?< scala.collection.Set

1634[info] - should `typeArgs` works (5 milliseconds)

1635[info] + scala.Int =?= scala.Int

1636[info] + scala.Int <?< scala.AnyVal

1637[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]]

1638[info] - should support subtyping of a simple combined type (1 millisecond)

1639[info] + izumi.reflect.test.TestModel::ApplePaymentProvider[=λ %0 → 0] <?< izumi.reflect.test.TestModel::H1

1640[info] - should issue #762: properly strip away annotated types / empty refinements / type aliases (3 milliseconds)

1641[info] + java.lang.String =?= java.lang.String

1642[info] + java.lang.String =?= java.lang.String

1643[info] + java.lang.String =?= java.lang.String

1644[info] + java.lang.String debug== java.lang.String

1645[info] + java.lang.String debug== java.lang.String

1646[info] + java.lang.String debug== java.lang.String

1647[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1648[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1649[info] - should calculate identical hashCode in parsed and constructed instances (0 milliseconds)

1650[info] + java.lang.String =?= java.lang.String

1651[info] + java.lang.String =?= java.lang.String

1652[info] - should support non-positional typetag combination (2 milliseconds)

1653[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]

1654[info] - should support additional mixin traits after first trait with a HKT parameter (8 milliseconds)

1655[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< izumi.reflect.test.TestModel::J1[=λ %0 → scala.Option[+0]]

1656[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< izumi.reflect.test.TestModel::J3

1657[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< izumi.reflect.test.TestModel::J2

1658[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< {izumi.reflect.test.TestModel::J2 & izumi.reflect.test.TestModel::J1[=λ %0 → scala.Option[+0]]}

1659[info] + izumi.reflect.test.TestModel::J[=λ %0 → scala.Option[+0]] <?< {izumi.reflect.test.TestModel::J2 & izumi.reflect.test.TestModel::J3}

1660[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]]}

1661[info] - should support LTagK* family summoners (4 milliseconds)

1662[info] + λ %0 → scala.collection.immutable.List[+0] =?= λ %0 → scala.collection.immutable.List[+0]

1663[info] + λ %0,%1 → scala.util.Either[+0,+1] =?= λ %0,%1 → scala.util.Either[+0,+1]

1664[info] - should support higher-kinded intersection type equality (1 millisecond)

1665[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]}

1666[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]}

1667[info] - should support contravariance (0 milliseconds)

1668[info] + scala.Function1[-scala.Any,+scala.Int] <?< scala.Function1[-scala.Int,+scala.Int]

1669[info] + scala.Function1[-scala.Int,+scala.Int] <!< scala.Function1[-scala.Any,+scala.Int]

1670[info] + scala.Function1[-scala.Int,+scala.Int] =!= scala.Function1[-scala.Any,+scala.Int]

1671[info] - should support typetag combination (8 milliseconds)

1672[info] + (λ %0 → izumi.reflect.test.TestModel::T1[=0])•(λ %0 → 0) => izumi.reflect.test.TestModel::T1[=λ %0 → 0] =?= izumi.reflect.test.TestModel::T1[=λ %0 → 0]

1673[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]]

1674[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]

1675[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]]

1676[info] + (λ %0 → scala.collection.immutable.List[+0])•(scala.Int) => scala.collection.immutable.List[+scala.Int] =?= scala.collection.immutable.List[+scala.Int]

1677[info] + (λ %0,%1 → scala.util.Either[+0,+1])•(scala.Unit) => λ %1 → scala.util.Either[+scala.Unit,+1] =?= λ %0 → scala.util.Either[+scala.Unit,+0]

1678[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]]

1679[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}

1680[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]]

1681[info] - should tautological intersections with Any/Object are discarded from internal structure (9 milliseconds)

1682[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1683[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1684[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1685[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1686[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1687[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1688[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1689[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1690[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1691[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1692[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1693[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1694[info] - should wildcards are supported (27 milliseconds)

1695[info] + scala.collection.immutable.Set[=?] =!= scala.collection.immutable.Set[=scala.Any]

1696[info] + scala.collection.immutable.Set[=scala.Int] <?< scala.collection.immutable.Set[=?]

1697[info] + scala.collection.immutable.Set[=?] <!< scala.collection.immutable.Set[=scala.Int]

1698[info] + scala.collection.immutable.Set[=scala.Any] <?< scala.collection.immutable.Set[=?]

1699[info] + scala.collection.immutable.Set[=?] <!< scala.collection.immutable.Set[=scala.Any]

1700[info] + scala.collection.immutable.List[+?] =!= scala.collection.immutable.List[+scala.Any]

1701[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+?]

1702[info] + scala.collection.immutable.List[+?] <!< scala.collection.immutable.List[+scala.Int]

1703[info] + scala.collection.immutable.List[+scala.Any] <?< scala.collection.immutable.List[+?]

1704[info] + scala.collection.immutable.List[+?] <?< scala.collection.immutable.List[+scala.Any]

1705[info] + scala.Function1[-scala.Int,+scala.Int] =!= scala.Function1[-?,+scala.Int]

1706[info] + scala.Function1[-scala.Int,+scala.Int] <?< scala.Function1[-?,+scala.Int]

1707[info] + scala.Function1[-?,+scala.Int] <?< scala.Function1[-scala.Int,+scala.Int]

1708[info] - should wildcards with bounds are supported (1 millisecond)

1709[info] + scala.Option[+izumi.reflect.test.TestModel::W1] =!= scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]

1710[info] + scala.Option[+izumi.reflect.test.TestModel::H2] =!= scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]

1711[info] + scala.Option[+scala.Any] =!= scala.Option[+?: <izumi.reflect.test.TestModel::H4..scala.Any>]

1712[info] - should generate tags for wildcards with type boundaries (13 milliseconds)

1713[info] + scala.Option[+izumi.reflect.test.TestModel::W1] =!= scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]

1714[info] + scala.Option[+izumi.reflect.test.TestModel::W1] <?< scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]

1715[info] + scala.Option[+izumi.reflect.test.TestModel::W2] <?< scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W1>]

1716[info] + scala.Option[+izumi.reflect.test.TestModel::W2] <!< scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::I1>]

1717[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W2>] <?< scala.Option[+izumi.reflect.test.TestModel::W1]

1718[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::W2>] <?< scala.Option[+izumi.reflect.test.TestModel::W2]

1719[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::I1>] <!< scala.Option[+izumi.reflect.test.TestModel::W2]

1720[info] + scala.Option[+izumi.reflect.test.TestModel::H3] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]

1721[info] + scala.Option[+izumi.reflect.test.TestModel::H1] <!< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]

1722[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>] <!< scala.Option[+izumi.reflect.test.TestModel::H3]

1723[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..scala.Any>] <!< scala.Option[+izumi.reflect.test.TestModel::H3]

1724[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::H2>] <!< scala.Option[+izumi.reflect.test.TestModel::H3]

1725[info] + scala.Option[+?: <scala.Nothing..izumi.reflect.test.TestModel::H2>] <?< scala.Option[+izumi.reflect.test.TestModel::H1]

1726[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..scala.Any>] <!< scala.Option[+izumi.reflect.test.TestModel::H1]

1727[info] + scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>] <?< scala.Option[+izumi.reflect.test.TestModel::H1]

1728[info] + scala.Option[+izumi.reflect.test.TestModel::H4] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]

1729[info] + scala.Option[+izumi.reflect.test.TestModel::H2] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]

1730[info] + scala.Option[+izumi.reflect.test.TestModel::H5] <?< scala.Option[+?: <izumi.reflect.test.TestModel::H4..izumi.reflect.test.TestModel::H2>]

1731[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] (1 millisecond)

1732[info] + izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → scala.Option[+0]] <!< izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → 0]

1733[info] + izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → 0] <!< izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → scala.Option[+0]]

1734[info] + izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → 0] =!= izumi.reflect.test.TestModel::IntegrationCheck[+λ %0 → scala.Option[+0]]

1735[info] - should normalize stable PDTs (https://github.com/zio/zio/issues/3390) (6 milliseconds)

1736[info] + izumi.reflect.test.TestModel::PDTNormA::Service =?= izumi.reflect.test.TestModel::PDTNormA::Service

1737[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service

1738[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service

1739[info] + izumi.reflect.test.TestModel::PDTNormA::Service debug== izumi.reflect.test.TestModel::PDTNormA::Service

1740[info] + izumi.reflect.test.TestModel::PDTNormA::Service =?= izumi.reflect.test.TestModel::PDTNormA::Service

1741[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service

1742[info] + izumi.reflect.test.TestModel::PDTNormA::Service <?< izumi.reflect.test.TestModel::PDTNormA::Service

1743[info] + izumi.reflect.test.TestModel::PDTNormA::Service debug== izumi.reflect.test.TestModel::PDTNormA::Service

1744[info] + izumi.reflect.test.TestModel::PDTNormA =?= izumi.reflect.test.TestModel::PDTNormA

1745[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA

1746[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA

1747[info] + izumi.reflect.test.TestModel::PDTNormA debug== izumi.reflect.test.TestModel::PDTNormA

1748[info] + izumi.reflect.test.TestModel::PDTNormA =?= izumi.reflect.test.TestModel::PDTNormA

1749[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA

1750[info] + izumi.reflect.test.TestModel::PDTNormA <?< izumi.reflect.test.TestModel::PDTNormA

1751[info] + izumi.reflect.test.TestModel::PDTNormA debug== izumi.reflect.test.TestModel::PDTNormA

1752[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal =?= izumi.reflect.test.SharedLightTypeTagTest._$literal

1753[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal <?< izumi.reflect.test.SharedLightTypeTagTest._$literal

1754[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal <?< izumi.reflect.test.SharedLightTypeTagTest._$literal

1755[info] + izumi.reflect.test.SharedLightTypeTagTest._$literal debug== izumi.reflect.test.SharedLightTypeTagTest._$literal

1756[info] - should distinguish nested path dependent types (https://github.com/zio/izumi-reflect/issues/363) (0 milliseconds)

1757[info] + izumi.reflect.test.SharedLightTypeTagTest._$A::Nested::Member =!= izumi.reflect.test.SharedLightTypeTagTest._$B::Nested::Member

1758[info] - should dealias nested singletons, regression test for singleton dealias regression introduced in 3.0.0 (https://github.com/zio/izumi-reflect/pull/504) (1 millisecond)

1759[info] + izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO =?= izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO

1760[info] + izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO <?< izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO

1761[info] + izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO <?< izumi.reflect.test.SharedLightTypeTagTest._$_$lifecycle::Lifecycle::FromZIO

1762[info] - should dealias deeply singleton val aliases (1 millisecond)

1763[info] + izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member =?= izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member

1764[info] + izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member <?< izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member

1765[info] + izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member <?< izumi.reflect.test.SharedLightTypeTagTest._$diffA::Nested::Member

1766[info] - should properly dealias and assign prefixes to existential types and wildcards (15 milliseconds)

1767[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+?]

1768[info] + scala.collection.immutable.List[+scala.Int] <?< scala.collection.immutable.List[+?]

1769[info] + scala.collection.immutable.List[+?] <?< scala.collection.immutable.List[+?]

1770[info] + scala.collection.immutable.List[+?] <?< scala.collection.immutable.List[+?]

1771[info] + scala.collection.immutable.List[+?] debug== scala.collection.immutable.List[+?]

1772[info] - should no redundant $ in object names (2 milliseconds)

1773[info] - should support basic None.type subtype check (1 millisecond)

1774[info] + scala.None <?< scala.Option[+scala.Int]

1775[info] - should supports complex type lambdas (2 milliseconds)

1776[info] + λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]] =?= λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]]

1777[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]]]

1778[info] + λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]] <?< λ %0,%1 → izumi.reflect.test.TestModel::FM2[+scala.Tuple2[+1,+0]]

1779[info] - should applied tags should not contain junk bases (6 milliseconds)

1780[info] - should intersection lambda tags should not contain junk bases (3 milliseconds)

1781[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]}

1782[info] - should lambda tags should not contain junk bases (4 milliseconds)

1783[info] - should No degenerate lambdas (regression test https://github.com/zio/izumi-reflect/issues/345) (2 milliseconds)

1784[info] - should check subtyping when higher-kinds are involved on Scala 3 (3 milliseconds)

1785[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]]

1786[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]]

1787[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]]

1788[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]]

1789[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]]

1790[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]]

1791[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]]

1792[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]]

1793[info] - should support higher-kinded intersection type subtyping (3 milliseconds)

1794[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} <?< izumi.reflect.test.TestModel::W3[=scala.Int]

1795[info] + {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=scala.Int]} <?< izumi.reflect.test.TestModel::W1

1796[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]}

1797[info] + λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} <?< λ %0 → izumi.reflect.test.TestModel::W3[=0]

1798[info] + λ %0 → {izumi.reflect.test.TestModel::W1 & izumi.reflect.test.TestModel::W3[=0]} <?< izumi.reflect.test.TestModel::W1

1799[info] + λ %0 → izumi.reflect.test.TestModel::W4[=0] <?< λ %0 → izumi.reflect.test.TestModel::W3[=0]

1800[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]}

1801[info] - should support higher-kinded intersection type combination (13 milliseconds)

1802[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]}

1803[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]}

1804[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]}

1805[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]}

1806[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]}

1807[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]

1808[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]}

1809[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]

1810[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]}

1811[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]

1812[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]

1813[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]

1814[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

1815[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

1816[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]}

1817[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]

1818[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]

1819[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]

1820[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]}

1821[info] - should support structural & refinement type subtype checks (3 milliseconds)

1822[info] + (java.lang.Object {def a(): scala.Int}) =?= (java.lang.Object {def a(): scala.Int})

1823[info] + (java.lang.Object {def a(): scala.Int}) <?< (java.lang.Object {def a(): scala.Int})

1824[info] + (java.lang.Object {def a(): scala.Int}) <?< (java.lang.Object {def a(): scala.Int})

1825[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =?= (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1826[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1827[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1828[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< izumi.reflect.test.TestModel::C

1829[info] + izumi.reflect.test.TestModel::C <!< (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1830[info] + izumi.reflect.test.TestModel::C =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1831[info] + (izumi.reflect.test.TestModel::C {type A = Int}) <?< izumi.reflect.test.TestModel::C

1832[info] + izumi.reflect.test.TestModel::C <!< (izumi.reflect.test.TestModel::C {type A = Int})

1833[info] + izumi.reflect.test.TestModel::C =!= (izumi.reflect.test.TestModel::C {type A = Int})

1834[info] + (izumi.reflect.test.TestModel::C {type A = A|<Nothing..Int>}) <?< izumi.reflect.test.TestModel::C

1835[info] + izumi.reflect.test.TestModel::C <!< (izumi.reflect.test.TestModel::C {type A = A|<Nothing..Int>})

1836[info] + izumi.reflect.test.TestModel::C =!= (izumi.reflect.test.TestModel::C {type A = A|<Nothing..Int>})

1837[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int}) <?< (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1838[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <!< (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int})

1839[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int})

1840[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) <?< (java.lang.Object {def a(): scala.Int})

1841[info] + (java.lang.Object {def a(): scala.Int}) <!< (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1842[info] + (java.lang.Object {def a(): scala.Int}) =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1843[info] - should support structural & refinement type equality (2 milliseconds)

1844[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"]}

1845[info] + (java.lang.Object {def a(): scala.Int}) =?= (java.lang.Object {def a(): scala.Int})

1846[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =?= (izumi.reflect.test.TestModel::C {def a(): scala.Int})

1847[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= (java.lang.Object {def a(): scala.Int})

1848[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= izumi.reflect.test.TestModel::C

1849[info] + (izumi.reflect.test.TestModel::C {def a(): scala.Int}) =!= (izumi.reflect.test.TestModel::C {def a(): scala.Int, def b(): scala.Int})

1850[info] + scala.Int =?= scala.Int

1851[info] - should strong summons test (0 milliseconds)

1852[info] - should distinguishes between val and type structural refinements (1 millisecond)

1853[info] + (java.lang.Object {type T = Either[+Int,+String]}) <!< (java.lang.Object {def T(): scala.util.Either[+scala.Int,+java.lang.String]})

1854[info] + (java.lang.Object {def T(): scala.util.Either[+scala.Int,+java.lang.String]}) <!< (java.lang.Object {type T = Either[+Int,+String]})

1855[info] + (java.lang.Object {def T(): scala.util.Either[+scala.Int,+java.lang.String]}) =!= (java.lang.Object {type T = Either[+Int,+String]})

1856[info] - should does not contain intersections in plain structural refinements (1 millisecond)

1857[info] - should support equal-bounded types as paradoxical (before 2.3.0 and since 2.3.6 NOT equal to their underlying) (2 milliseconds)

1858[info] + java.lang.String <?< izumi.reflect.test.SharedLightTypeTagTest._$x::X|<java.lang.String..java.lang.String>

1859[info] + izumi.reflect.test.SharedLightTypeTagTest._$x::X|<java.lang.String..java.lang.String> <?< java.lang.String

1860[info] + izumi.reflect.test.SharedLightTypeTagTest._$x::X|<java.lang.String..java.lang.String> =!= java.lang.String

1861[info] - should support structural subtype checks (16 milliseconds)

1862[info] + (java.lang.Object {type T = List[+Int]}) <!< (java.lang.Object {type T = λ %0 → List[+0]})

1863[info] + (java.lang.Object {type T = λ %0 → List[+0]}) <!< (java.lang.Object {type T = List[+Int]})

1864[info] + (java.lang.Object {type T = λ %0 → List[+0]}) =!= (java.lang.Object {type T = List[+Int]})

1865[info] + (java.lang.Object {type T = List[+Int]}) <?< (java.lang.Object {type T = T|<Nothing..List[+Any]>})

1866[info] + (java.lang.Object {type T = T|<Nothing..List[+Any]>}) <!< (java.lang.Object {type T = List[+Int]})

1867[info] + (java.lang.Object {type T = T|<Nothing..List[+Any]>}) =!= (java.lang.Object {type T = List[+Int]})

1868[info] + (java.lang.Object {type T = Int}) <?< (java.lang.Object {type T = T|<Nothing..AnyVal>})

1869[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) <!< (java.lang.Object {type T = Int})

1870[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) =!= (java.lang.Object {type T = Int})

1871[info] + (java.lang.Object {type T = Int}) <?< (java.lang.Object {type T = T})

1872[info] + (java.lang.Object {type T = T}) <!< (java.lang.Object {type T = Int})

1873[info] + (java.lang.Object {type T = T}) =!= (java.lang.Object {type T = Int})

1874[info] + (java.lang.Object {type T = String}) <?< (java.lang.Object {type T = T|<Nothing..CharSequence>})

1875[info] + (java.lang.Object {type T = T|<Nothing..CharSequence>}) <!< (java.lang.Object {type T = String})

1876[info] + (java.lang.Object {type T = T|<Nothing..CharSequence>}) =!= (java.lang.Object {type T = String})

1877[info] + (java.lang.Object {def T(): scala.Int}) <?< (java.lang.Object {def T(): scala.AnyVal})

1878[info] + (java.lang.Object {def T(): scala.AnyVal}) <!< (java.lang.Object {def T(): scala.Int})

1879[info] + (java.lang.Object {def T(): scala.AnyVal}) =!= (java.lang.Object {def T(): scala.Int})

1880[info] + (java.lang.Object {type T = Int}) <?< (java.lang.Object {type T = T|<Nothing..AnyVal>})

1881[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) <!< (java.lang.Object {type T = Int})

1882[info] + (java.lang.Object {type T = T|<Nothing..AnyVal>}) =!= (java.lang.Object {type T = Int})

1883[info] + (java.lang.Object {type T = Int}) <!< (java.lang.Object {type T = T|<Nothing..CharSequence>})

1884[info] + (java.lang.Object {def T(): scala.Int}) <!< (java.lang.Object {type T = T})

1885[info] + (java.lang.Object {type T = T}) <!< (java.lang.Object {def T(): scala.Int})

1886[info] + (java.lang.Object {type T = T}) =!= (java.lang.Object {def T(): scala.Int})

1887[info] - should what about non-empty refinements with intersections (0 milliseconds)

1888[info] - should support contravariance in refinement method comparisons (0 milliseconds)

1889[info] + (java.lang.Object {def compare(scala.AnyVal): scala.Int}) <?< (java.lang.Object {def compare(scala.Int): scala.Int})

1890[info] + (java.lang.Object {def compare(scala.Int): scala.Int}) <!< (java.lang.Object {def compare(scala.AnyVal): scala.Int})

1891[info] + (java.lang.Object {def compare(scala.Int): scala.Int}) =!= (java.lang.Object {def compare(scala.AnyVal): scala.Int})

1892[info] - should support human-readable representation (12 milliseconds)

1893[info] - should covariance of a concrete inheritor to a parent with a higher-kinded type parameter (7 milliseconds)

1894[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=0] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]

1895[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int]

1896[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=?]

1897[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int] <!< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Any]

1898[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]

1899[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]

1900[info] - should covariance of a concrete inheritor to a parent with a complex-shaped higher-kinded type parameter (3 milliseconds)

1901[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=0,=scala.Unit] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]

1902[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int]

1903[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=?]

1904[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <!< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Any]

1905[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]

1906[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0]]

1907[info] - should covariance of a concrete inheritor to a parent with a swap type lambda (6 milliseconds)

1908[info] + λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=0] <?< λ %0 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0,=scala.Int]

1909[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Unit,=scala.Int]

1910[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=?,=?]

1911[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[=scala.Int,=scala.Unit] <!< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Any,=scala.Any]

1912[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+λ %0,%1 → izumi.reflect.test.SharedLightTypeTagTest._$Container[=0,=1]]

1913[info] - should covariance of a concrete inheritor to a parent with a proper type parameter (0 milliseconds)

1914[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer <?< izumi.reflect.test.SharedLightTypeTagTest._$Container

1915[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyConcreteService <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[+izumi.reflect.test.SharedLightTypeTagTest._$Container]

1916[info] - should covariance of a parameterized inheritor to a parent with an indirect proper type parameter (1 millisecond)

1917[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer <?< izumi.reflect.test.SharedLightTypeTagTest._$Container

1918[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container]

1919[info] - should covariance of a parameterized inheritor to a parent with an indirect parameterized type parameter (1 millisecond)

1920[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[+scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[+scala.AnyVal]

1921[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container[+scala.AnyVal]]

1922[info] - should covariance of a parameterized inheritor to a parent with an indirect parameterized type parameter with different arity (1 millisecond)

1923[info] + izumi.reflect.test.SharedLightTypeTagTest._$AContainer[+scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.AnyVal]

1924[info] + izumi.reflect.test.SharedLightTypeTagTest._$MyParameterizedService[=scala.Int] <?< izumi.reflect.test.SharedLightTypeTagTest._$Service[=scala.Int,+izumi.reflect.test.SharedLightTypeTagTest._$Container[=scala.Int,+scala.AnyVal]]

1925[info] - should covariance of a self-parameterized inheritor to a parent with an indirect parameterized type parameter with different arity (1 millisecond)

1926[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]]

1927[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]]

1928[info] - should regression test for https://github.com/zio/izumi-reflect/issues/511 (1 millisecond)

1929[info] - should null type is supported (1 millisecond)

1930[info] + scala.Null <?< izumi.reflect.test.TestModel::I1

1931[info] + izumi.reflect.test.TestModel::I1 <!< scala.Null

1932[info] + izumi.reflect.test.TestModel::I1 =!= scala.Null

1933[info] + scala.Nothing <?< scala.Null

1934[info] - should fulldb should contain inheritance db of direct type argument (0 milliseconds)

1935[info] - should unapplied inheritance db should contain inheritance db of direct type argument (0 milliseconds)

1936[info] - should both dbs should contain db of direct self-nested type argument (0 milliseconds)

1937[info] - should fulldb should contain inheritance db of inherited type argument (1 millisecond)

1938[info] - should unapplied inheritance db should contain inheritance db of inherited type argument (0 milliseconds)

1939[info] - should both dbs should NOT contain inheritance db of direct parent type (1 millisecond)

1940[info] - should HKT List dbs should not contain superfluous base types (1 millisecond)

1941[info] - should subtype check succeeds when child type has absorbed a covariant type parameter of the supertype (4 milliseconds)

1942[info] + scala.collection.immutable.Set[=scala.Int] <?< scala.collection.Iterable[+scala.AnyVal]

1943[info] + izumi.reflect.test.TestModel::F3 <?< izumi.reflect.test.TestModel::F2[+scala.Int]

1944[info] + izumi.reflect.test.TestModel::F2[+scala.Int] <!< izumi.reflect.test.TestModel::F3

1945[info] + izumi.reflect.test.TestModel::F2[+scala.Int] =!= izumi.reflect.test.TestModel::F3

1946[info] + izumi.reflect.test.TestModel::F3 <?< izumi.reflect.test.TestModel::F2[+scala.Any]

1947[info] + izumi.reflect.test.TestModel::F2[+scala.Any] <!< izumi.reflect.test.TestModel::F3

1948[info] + izumi.reflect.test.TestModel::F2[+scala.Any] =!= izumi.reflect.test.TestModel::F3

1949[info] + izumi.reflect.test.TestModel::F3 <?< izumi.reflect.test.TestModel::F2[+scala.AnyVal]

1950[info] + izumi.reflect.test.TestModel::F2[+scala.AnyVal] <!< izumi.reflect.test.TestModel::F3

1951[info] + izumi.reflect.test.TestModel::F2[+scala.AnyVal] =!= izumi.reflect.test.TestModel::F3

1952[info] - should regression test 3.0.4: subtype check succeeds versus a parent parameterized with Identity type lambda (1 millisecond)

1953[info] + izumi.reflect.test.TestModel::TargetRole <?< izumi.reflect.test.TestModel::AbstractRole[=λ %0 → 0]

1954[info] + izumi.reflect.test.TestModel::AbstractRole[=λ %0 → 0] <!< izumi.reflect.test.TestModel::TargetRole

1955[info] + izumi.reflect.test.TestModel::AbstractRole[=λ %0 → 0] =!= izumi.reflect.test.TestModel::TargetRole

1956[info] lightweight type tags (Dotty)

1957[info] - should tautological intersections with Matchable are discarded from internal structure (Scala 3 specific, Matchable) (0 milliseconds)

1958[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1959[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1960[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1961[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1962[info] - should tautological intersections with Matchable are discarded from internal structure (Scala 3 specific, Matchable) (Tag) (0 milliseconds)

1963[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1964[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1965[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1966[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1967[info] - should tautological unions with Any/AnyRef/Matchable/Object are discarded from internal structure (Scala 3 specific, Matchable) (1 millisecond)

1968[info] + scala.Any =?= scala.Any

1969[info] + scala.Any <?< scala.Any

1970[info] + scala.Any <?< scala.Any

1971[info] + scala.Any debug== scala.Any

1972[info] + scala.Matchable =?= scala.Matchable

1973[info] + scala.Matchable <?< scala.Matchable

1974[info] + scala.Matchable <?< scala.Matchable

1975[info] + scala.Matchable debug== scala.Matchable

1976[info] + java.lang.Object =?= java.lang.Object

1977[info] + java.lang.Object <?< java.lang.Object

1978[info] + java.lang.Object <?< java.lang.Object

1979[info] + java.lang.Object debug== java.lang.Object

1980[info] + java.lang.Object =?= java.lang.Object

1981[info] + java.lang.Object <?< java.lang.Object

1982[info] + java.lang.Object <?< java.lang.Object

1983[info] + java.lang.Object debug== java.lang.Object

1984[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

1985[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1986[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

1987[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

1988[info] - should tautological unions with Any/AnyRef/Matchable/Object are discarded from internal structure (Scala 3 specific, Matchable) (Tag) (1 millisecond)

1989[info] + scala.Any =?= scala.Any

1990[info] + scala.Any <?< scala.Any

1991[info] + scala.Any <?< scala.Any

1992[info] + scala.Any debug== scala.Any

1993[info] + scala.Matchable =?= scala.Matchable

1994[info] + scala.Matchable <?< scala.Matchable

1995[info] + scala.Matchable <?< scala.Matchable

1996[info] + scala.Matchable debug== scala.Matchable

1997[info] + java.lang.Object =?= java.lang.Object

1998[info] + java.lang.Object <?< java.lang.Object

1999[info] + java.lang.Object <?< java.lang.Object

2000[info] + java.lang.Object debug== java.lang.Object

2001[info] + java.lang.Object =?= java.lang.Object

2002[info] + java.lang.Object <?< java.lang.Object

2003[info] + java.lang.Object <?< java.lang.Object

2004[info] + java.lang.Object debug== java.lang.Object

2005[info] + scala.Option[+java.lang.String] =?= scala.Option[+java.lang.String]

2006[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

2007[info] + scala.Option[+java.lang.String] <?< scala.Option[+java.lang.String]

2008[info] + scala.Option[+java.lang.String] debug== scala.Option[+java.lang.String]

2009[info] - should support top-level abstract types (Scala 3 specific, top level type aliases) (0 milliseconds)

2010[info] + izumi.reflect.test.LightTypeTagTest$package::LightTypeTagTestT|<scala.Nothing..java.lang.String> <?< java.lang.String

2011[info] + java.lang.String <!< izumi.reflect.test.LightTypeTagTest$package::LightTypeTagTestT|<scala.Nothing..java.lang.String>

2012[info] + java.lang.String =!= izumi.reflect.test.LightTypeTagTest$package::LightTypeTagTestT|<scala.Nothing..java.lang.String>

2013[info] - should support opaque types (16 milliseconds)

2014[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< scala.collection.immutable.List[+scala.Int]

2015[info] + scala.collection.immutable.List[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque

2016[info] + scala.collection.immutable.List[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque

2017[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< scala.collection.immutable.Seq[+scala.Int]

2018[info] + scala.collection.immutable.Seq[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque

2019[info] + scala.collection.immutable.Seq[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque

2020[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]>

2021[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

2022[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

2023[info] + izumi.reflect.test.LightTypeTagTest._$x::Opaque <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>

2024[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <!< izumi.reflect.test.LightTypeTagTest._$x::Opaque

2025[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> =!= izumi.reflect.test.LightTypeTagTest._$x::Opaque

2026[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <?< scala.collection.immutable.List[+scala.Int]

2027[info] + scala.collection.immutable.List[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>

2028[info] + scala.collection.immutable.List[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>

2029[info] + izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]> <?< scala.collection.immutable.Seq[+scala.Int]

2030[info] + scala.collection.immutable.Seq[+scala.Int] <!< izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>

2031[info] + scala.collection.immutable.Seq[+scala.Int] =!= izumi.reflect.test.LightTypeTagTest._$x::OpaqueSub|<scala.Nothing..scala.collection.immutable.List[+scala.Int]>

2032[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]

2033[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]>

2034[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]>

2035[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]>

2036[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]>

2037[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]>

2038[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]>

2039[info] - should basic support for polymorphic function types (1 millisecond)

2040[info] + (scala.PolyFunction {def apply(0): 0}) =?= (scala.PolyFunction {def apply(0): 0})

2041[info] + (scala.PolyFunction {def apply(0): 0}) <?< (scala.PolyFunction {def apply(0): 0})

2042[info] + (scala.PolyFunction {def apply(0): 0}) <?< (scala.PolyFunction {def apply(0): 0})

2043Starting build for ProjectRef(file:/build/repo/,izumi-reflect-thirdparty-boopickle-shadedJVM) (izumi-reflect-thirdparty-boopickle-shaded)... [1/2]

2044Compile scalacOptions: -encoding, UTF-8, -unchecked, -language:higherKinds, -Ykind-projector, -no-indent, -language:implicitConversions, -Wconf:msg=can be rewritten automatically under:s, -source:3.8

2045

2046************************

2047Build summary:

2048[{

2049 "module": "izumi-reflect",

2050 "compile": {"status": "ok", "tookMs": 19260, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2051 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2052 "test-compile": {"status": "ok", "tookMs": 13257, "warnings": 1, "errors": 0, "sourceVersion": "3.8"},

2053 "test": {"status": "ok", "tookMs": 1426, "passed": 207, "failed": 0, "ignored": 0, "skipped": 0, "total": 207, "byFramework": [{"framework": "unknown", "stats": {"passed": 207, "failed": 0, "ignored": 0, "skipped": 0, "total": 207}}]},

2054 "publish": {"status": "skipped", "tookMs": 0},

2055 "metadata": {

2056 "crossScalaVersions": ["3.3.6", "2.13.14", "2.12.20", "2.11.12"]

2057}

2058},{

2059 "module": "izumi-reflect-thirdparty-boopickle-shaded",

2060 "compile": {"status": "ok", "tookMs": 67, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2061 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2062 "test-compile": {"status": "ok", "tookMs": 107, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2063 "test": {"status": "ok", "tookMs": 95, "passed": 0, "failed": 0, "ignored": 0, "skipped": 0, "total": 0, "byFramework": []},

2064 "publish": {"status": "skipped", "tookMs": 0},

2065 "metadata": {

2066 "crossScalaVersions": ["3.3.6", "2.13.14", "2.12.20", "2.11.12"]

2067}

2068}]

2069************************

2070[success] Total time: 45 s, completed Nov 28, 2025, 12:46:42 PM

2071[0JChecking patch project/plugins.sbt...

2072Checking patch project/build.properties...

2073Checking patch build.sbt...

2074Applied patch project/plugins.sbt cleanly.

2075Applied patch project/build.properties cleanly.

2076Applied patch build.sbt cleanly.