Skip to content

Commit 027fd27

Browse files
neko-kaineko-kai
authored
Update izumi to 1.3.0-M1 (#608)
Update Scala 3 to 3.8.3 Update Scala.js to 1.21.0
1 parent da38f7c commit 027fd27

10 files changed

Lines changed: 479 additions & 318 deletions

File tree

‎build.sbt‎

Lines changed: 94 additions & 54 deletions
Large diffs are not rendered by default.

‎deps.lock.json‎

Lines changed: 260 additions & 164 deletions
Large diffs are not rendered by default.

‎idealingua-v1/idealingua-v1-core/.jvm/src/test/scala/izumi/idealingua/il/parser/BasicParserTest.scala‎

Lines changed: 81 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -11,64 +11,64 @@ class BasicParserTest extends AnyWordSpec with ParserTestTools {
1111

1212
"IL parser" should {
1313
"parse annos" in {
14-
assertParses(defConst.defAnno(_), """@TestAnno()""".stripMargin)
14+
assertParses(defConst.defAnno(using _), """@TestAnno()""".stripMargin)
1515

16-
assertParses(defConst.defAnno(_), """@TestAnno(a=1)""".stripMargin)
16+
assertParses(defConst.defAnno(using _), """@TestAnno(a=1)""".stripMargin)
1717

18-
assertParses(defConst.defAnno(_), """@TestAnno(a=1, b="xxx",c=true,d=false,e=[1,2,"x",],f={a=1,b="str"} ,)""".stripMargin)
19-
assertParses(defConst.defAnno(_), """@TestAnno(e=[1,2,"x",],f = ( lst[str]([1,2,3]) ) )""".stripMargin)
20-
assertParses(defConst.defAnno(_), """@AnotherAnno(a=1, b="str", c=[1,2,3], d={x=true, y=1}, e=lst[str]([1,2,3]))""".stripMargin)
18+
assertParses(defConst.defAnno(using _), """@TestAnno(a=1, b="xxx",c=true,d=false,e=[1,2,"x",],f={a=1,b="str"} ,)""".stripMargin)
19+
assertParses(defConst.defAnno(using _), """@TestAnno(e=[1,2,"x",],f = ( lst[str]([1,2,3]) ) )""".stripMargin)
20+
assertParses(defConst.defAnno(using _), """@AnotherAnno(a=1, b="str", c=[1,2,3], d={x=true, y=1}, e=lst[str]([1,2,3]))""".stripMargin)
2121

22-
assertParses(defConst.defAnno(_), """@TestAnno(a=1, /*comment*/ b="xxx")""".stripMargin)
22+
assertParses(defConst.defAnno(using _), """@TestAnno(a=1, /*comment*/ b="xxx")""".stripMargin)
2323
}
2424

2525
"parse imports" in {
2626
import defDomain._
27-
assertParses(importBlock(_), "import a.b.c")
28-
assertParses(importBlock(_), "import a.b.c")
29-
assertParses(importBlock(_), "import a.b.{c, d}")
30-
assertParses(importBlock(_), "import a.b.{c, d,}")
31-
assertParses(importBlock(_), "import a.b.{c, d ,}")
32-
assertParses(importBlock(_), "import a")
27+
assertParses(importBlock(using _), "import a.b.c")
28+
assertParses(importBlock(using _), "import a.b.c")
29+
assertParses(importBlock(using _), "import a.b.{c, d}")
30+
assertParses(importBlock(using _), "import a.b.{c, d,}")
31+
assertParses(importBlock(using _), "import a.b.{c, d ,}")
32+
assertParses(importBlock(using _), "import a")
3333
}
3434

3535
"parse domain declaration" in {
3636
import defDomain._
37-
assertParses(domainBlock(_), "domain x.y.z")
37+
assertParses(domainBlock(using _), "domain x.y.z")
3838
}
3939

4040
"parse foreign type interpolations" in {
4141
import ids._
42-
assertParses(typeInterp(_), """t"java.util.Map"""")
43-
assertParses(typeInterp(_), """t"java.util.Map<${A}, ${B}>"""")
42+
assertParses(typeInterp(using _), """t"java.util.Map"""")
43+
assertParses(typeInterp(using _), """t"java.util.Map<${A}, ${B}>"""")
4444
}
4545

4646
"parse aliases" in {
47-
assertParses(defStructure.aliasBlock(_), "alias x = y")
47+
assertParses(defStructure.aliasBlock(using _), "alias x = y")
4848
}
4949

5050
"parse enclosed enums" in {
51-
assertParses(defStructure.enumBlock(_), "enum MyEnum {X Y Zz}")
52-
assertParses(defStructure.enumBlock(_), "enum MyEnum { X Y Z }")
53-
assertParses(defStructure.enumBlock(_), "enum MyEnum { X Y Z }")
51+
assertParses(defStructure.enumBlock(using _), "enum MyEnum {X Y Zz}")
52+
assertParses(defStructure.enumBlock(using _), "enum MyEnum { X Y Z }")
53+
assertParses(defStructure.enumBlock(using _), "enum MyEnum { X Y Z }")
5454
assertParses(
55-
defStructure.enumBlock(_),
55+
defStructure.enumBlock(using _),
5656
"""enum MyEnum {
5757
| + BaseEnum
5858
| - REMOVED_BASE_ELEMENT
5959
| NEW_ELEMENT
6060
|}""".stripMargin,
6161
)
6262
assertParses(
63-
defStructure.enumBlock(_),
63+
defStructure.enumBlock(using _),
6464
"""enum MyEnum {
6565
|X
6666
| Y
6767
|Z
6868
|}""".stripMargin,
6969
)
7070
assertParses(
71-
defStructure.enumBlock(_),
71+
defStructure.enumBlock(using _),
7272
"""enum MyEnum {
7373
| ELEMENT1
7474
| // comment
@@ -77,7 +77,7 @@ class BasicParserTest extends AnyWordSpec with ParserTestTools {
7777
)
7878

7979
assertParses(
80-
defStructure.enumBlock(_),
80+
defStructure.enumBlock(using _),
8181
"""enum MyEnum {
8282
| ELEMENT1
8383
| // comment
@@ -86,35 +86,35 @@ class BasicParserTest extends AnyWordSpec with ParserTestTools {
8686
|}""".stripMargin,
8787
)
8888
assertParses(
89-
defStructure.enumBlock(_),
89+
defStructure.enumBlock(using _),
9090
"""enum MyEnum {
9191
| ELEMENT1 // comment 3
9292
| // comment
9393
| /* comment 2*/
9494
| ELEMENT2
9595
|}""".stripMargin,
9696
)
97-
assertParses(defStructure.enumBlock(_), "enum MyEnum {X,Y,Z}")
98-
assertParses(defStructure.enumBlock(_), "enum MyEnum {X|Y|Z}")
99-
assertParses(defStructure.enumBlock(_), "enum MyEnum { X|Y|Z }")
100-
assertParses(defStructure.enumBlock(_), "enum MyEnum {X | Y | Z}")
101-
assertParses(defStructure.enumBlock(_), "enum MyEnum { X | Y | Z }")
102-
assertParses(defStructure.enumBlock(_), "enum MyEnum { X , Y , Z }")
103-
assertParses(defStructure.enumBlock(_), "enum MyEnum { X , Y , Z , F }")
97+
assertParses(defStructure.enumBlock(using _), "enum MyEnum {X,Y,Z}")
98+
assertParses(defStructure.enumBlock(using _), "enum MyEnum {X|Y|Z}")
99+
assertParses(defStructure.enumBlock(using _), "enum MyEnum { X|Y|Z }")
100+
assertParses(defStructure.enumBlock(using _), "enum MyEnum {X | Y | Z}")
101+
assertParses(defStructure.enumBlock(using _), "enum MyEnum { X | Y | Z }")
102+
assertParses(defStructure.enumBlock(using _), "enum MyEnum { X , Y , Z }")
103+
assertParses(defStructure.enumBlock(using _), "enum MyEnum { X , Y , Z , F }")
104104

105105
}
106106

107107
"parse free-form enums" in {
108-
assertParses(defStructure.enumBlock(_), "enum MyEnum = X | Y | Z")
109-
assertParses(defStructure.enumBlock(_), "enum MyEnum = X | /**/ Y | Z")
108+
assertParses(defStructure.enumBlock(using _), "enum MyEnum = X | Y | Z")
109+
assertParses(defStructure.enumBlock(using _), "enum MyEnum = X | /**/ Y | Z")
110110
assertParses(
111-
defStructure.enumBlock(_),
111+
defStructure.enumBlock(using _),
112112
"""enum MyEnum = X
113113
||Y
114114
|| Z""".stripMargin,
115115
)
116116
assertParses(
117-
defStructure.enumBlock(_),
117+
defStructure.enumBlock(using _),
118118
"""enum MyEnum =
119119
|| X
120120
| | Y
@@ -124,15 +124,15 @@ class BasicParserTest extends AnyWordSpec with ParserTestTools {
124124
}
125125

126126
"parse empty blocks" in {
127-
assertParses(defStructure.mixinBlock(_), "mixin Mixin {}")
128-
assertParses(defStructure.idBlock(_), "id Id {}")
129-
assertParses(defService.serviceBlock(_), "service Service {}")
130-
assertParses(defStructure.dtoBlock(_), "data Data {}")
127+
assertParses(defStructure.mixinBlock(using _), "mixin Mixin {}")
128+
assertParses(defStructure.idBlock(using _), "id Id {}")
129+
assertParses(defService.serviceBlock(using _), "service Service {}")
130+
assertParses(defStructure.dtoBlock(using _), "data Data {}")
131131
}
132132

133133
"parse dto blocks" in {
134134
assertParses(
135-
defStructure.dtoBlock(_),
135+
defStructure.dtoBlock(using _),
136136
"""data Data {
137137
|& Add
138138
|&&& Add
@@ -149,69 +149,69 @@ class BasicParserTest extends AnyWordSpec with ParserTestTools {
149149

150150
"parse complex comments" in {
151151
assertParses(
152-
sep.any(_),
152+
sep.any(using _),
153153
"""// test
154154
|/*test*/
155155
| /* test/**/*/
156156
""".stripMargin,
157157
)
158-
assertParses(comments.ShortComment(_), "// test\n")
159-
assertParses(comments.ShortComment(_), "//\n")
160-
assertParses(sep.any(_), "//\n")
161-
assertParses(sep.any(_), "// test\n")
158+
assertParses(comments.ShortComment(using _), "// test\n")
159+
assertParses(comments.ShortComment(using _), "//\n")
160+
assertParses(sep.any(using _), "//\n")
161+
assertParses(sep.any(using _), "// test\n")
162162
}
163163

164164
"parse complex comments -2" in {
165-
assertParses(defStructure.sepEnum(_), " ")
166-
assertParses(defStructure.sepEnum(_), "//comment\n")
167-
assertParses(defStructure.sepEnum(_), " //comment\n")
168-
assertParses(defStructure.sepEnum(_), " //comment\n ")
169-
assertParses(defStructure.sepEnum(_), " //comment0\n //comment1\n ")
170-
assertParses(defStructure.sepEnum(_), " //comment0\n //comment1\n")
165+
assertParses(defStructure.sepEnum(using _), " ")
166+
assertParses(defStructure.sepEnum(using _), "//comment\n")
167+
assertParses(defStructure.sepEnum(using _), " //comment\n")
168+
assertParses(defStructure.sepEnum(using _), " //comment\n ")
169+
assertParses(defStructure.sepEnum(using _), " //comment0\n //comment1\n ")
170+
assertParses(defStructure.sepEnum(using _), " //comment0\n //comment1\n")
171171
}
172172

173173
"parse service defintions" in {
174-
assertParses(defStructure.inlineStruct(_), "(a: A, b: B, + C)")
175-
assertParses(defStructure.inlineStruct(_), "(a: str)")
176-
assertParses(defStructure.inlineStruct(_), "(+ A)")
177-
assertParses(defStructure.adtOut(_), "( A \n | \n B )")
178-
assertParses(defStructure.adtOut(_), "(A|B)")
179-
assertParses(defStructure.adtOut(_), "(A | B)")
180-
assertParses(defStructure.inlineStruct(_), "(\n firstName: str \n , \n secondName: str\n)")
174+
assertParses(defStructure.inlineStruct(using _), "(a: A, b: B, + C)")
175+
assertParses(defStructure.inlineStruct(using _), "(a: str)")
176+
assertParses(defStructure.inlineStruct(using _), "(+ A)")
177+
assertParses(defStructure.adtOut(using _), "( A \n | \n B )")
178+
assertParses(defStructure.adtOut(using _), "(A|B)")
179+
assertParses(defStructure.adtOut(using _), "(A | B)")
180+
assertParses(defStructure.inlineStruct(using _), "(\n firstName: str \n , \n secondName: str\n)")
181181
}
182182

183183
"parse identifiers" in {
184-
assertParses(ids.domainId(_), "x.y.z")
185-
assertParses(ids.identifier(_), "x.y#z")
184+
assertParses(ids.domainId(using _), "x.y.z")
185+
assertParses(ids.identifier(using _), "x.y#z")
186186
}
187187

188188
"parse fields" in {
189-
assertParses(defStructure.field(_), "a: str")
190-
assertParses(defStructure.field(_), "a: domain#Type")
191-
assertParses(defStructure.field(_), "a: map[str, str]")
192-
assertParses(defStructure.field(_), "a: map[str, set[domain#Type]]")
189+
assertParses(defStructure.field(using _), "a: str")
190+
assertParses(defStructure.field(using _), "a: domain#Type")
191+
assertParses(defStructure.field(using _), "a: map[str, str]")
192+
assertParses(defStructure.field(using _), "a: map[str, set[domain#Type]]")
193193
}
194194

195195
"parse adt members" in {
196-
assertParses(defStructure.adtMember(_), "X")
197-
assertParses(defStructure.adtMember(_), "X as T")
196+
assertParses(defStructure.adtMember(using _), "X")
197+
assertParses(defStructure.adtMember(using _), "X as T")
198198

199-
assertParses(defStructure.adtMember(_), "a.b.c#X")
200-
assertParses(defStructure.adtMember(_), "a.b.c#X as T")
199+
assertParses(defStructure.adtMember(using _), "a.b.c#X")
200+
assertParses(defStructure.adtMember(using _), "a.b.c#X as T")
201201
}
202202

203203
"parse adt blocks" in {
204-
assertParses(defStructure.adtBlock(_), "adt MyAdt { X as XXX | Y }")
205-
assertParses(defStructure.adtBlock(_), "adt MyAdt { X | Y | a.b.c#D as B }")
206-
assertParses(defStructure.adtBlock(_), "adt MyAdt = X | Y | Z")
207-
assertParses(defStructure.adtBlock(_), "adt MyAdt { X }")
208-
assertParses(defStructure.adtBlock(_), "adt MyAdt {a.b.c#D}")
209-
assertParses(defStructure.adtBlock(_), "adt MyAdt { a.b.c#D }")
210-
assertParses(defStructure.adtBlock(_), "adt MyAdt { a.b.c#D Z Z }")
211-
assertParses(defStructure.adtBlock(_), "adt MyAdt { X Y a.b.c#D Z }")
212-
assertParses(defStructure.adtBlock(_), "adt MyAdt { X Y a.b.c#D }")
204+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { X as XXX | Y }")
205+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { X | Y | a.b.c#D as B }")
206+
assertParses(defStructure.adtBlock(using _), "adt MyAdt = X | Y | Z")
207+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { X }")
208+
assertParses(defStructure.adtBlock(using _), "adt MyAdt {a.b.c#D}")
209+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { a.b.c#D }")
210+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { a.b.c#D Z Z }")
211+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { X Y a.b.c#D Z }")
212+
assertParses(defStructure.adtBlock(using _), "adt MyAdt { X Y a.b.c#D }")
213213
assertParses(
214-
defStructure.adtBlock(_),
214+
defStructure.adtBlock(using _),
215215
"""adt MyAdt {
216216
| X
217217
|Y
@@ -223,15 +223,15 @@ class BasicParserTest extends AnyWordSpec with ParserTestTools {
223223
"parse service definition" in {
224224
def defm[$: P]: P[RawMethod.RPCMethod] = defSignature.method(kw.defm)
225225

226-
assertParses(defm(_), "def greetAlgebraicOut(firstName: str, secondName: str) => ( SuccessData | ErrorData )")
226+
assertParses(defm(using _), "def greetAlgebraicOut(firstName: str, secondName: str) => ( SuccessData | ErrorData )")
227227
assertParseableCompletely(
228-
defService.methods(_),
228+
defService.methods(using _),
229229
"""def greetAlgebraicOut(firstName: str, secondName: str) => ( SuccessData | ErrorData )
230230
|def greetAlgebraicOut(firstName: str, secondName: str) => ( SuccessData | ErrorData )""".stripMargin,
231231
)
232232

233233
assertParseableCompletely(
234-
defService.serviceBlock(_),
234+
defService.serviceBlock(using _),
235235
"""service FileService {
236236
| def greetAlgebraicOut(firstName: str, secondName: str) => ( SuccessData | ErrorData )
237237
|}""".stripMargin,

‎idealingua-v1/idealingua-v1-core/.jvm/src/test/scala/izumi/idealingua/il/parser/ParserTestTools.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ trait ParserTestTools {
2222
}
2323

2424
def assertParseableCompletely[T](p: P[?] => P[T], str: String): T = {
25-
assertParseable(ended(_, p), str)
25+
assertParseable(pp => ended(pp, p), str)
2626
}
2727

2828
def assertParseable[T](p: P[?] => P[T], str: String): T = {
@@ -44,7 +44,7 @@ trait ParserTestTools {
4444
}
4545

4646
def assertDomainParses(str: String): Unit = {
47-
val parsed = assertParseable(ctx.defParsers.fullDomainDef(_), str)
47+
val parsed = assertParseable(ctx.defParsers.fullDomainDef(using _), str)
4848
assert(parsed.model.definitions.nonEmpty)
4949
()
5050
}

‎idealingua-v1/idealingua-v1-core/.jvm/src/test/scala/izumi/idealingua/il/parser/structure/CommentsAndDocstringsTest.scala‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -9,42 +9,42 @@ class CommentsAndDocstringsTest extends AnyWordSpec with ParserTestTools {
99

1010
"parse docstrings" in {
1111
assertParses(
12-
comments.DocComment(_),
12+
comments.DocComment(using _),
1313
"""/** docstring
1414
| */""".stripMargin,
1515
)
1616

1717
assertParses(
18-
comments.DocComment(_),
18+
comments.DocComment(using _),
1919
"""/** docstring
2020
| * docstring
2121
| */""".stripMargin,
2222
)
2323

2424
assertParses(
25-
comments.DocComment(_),
25+
comments.DocComment(using _),
2626
"""/** docstring
2727
|* docstring
2828
|*/""".stripMargin,
2929
)
3030

3131
assertParses(
32-
comments.DocComment(_),
32+
comments.DocComment(using _),
3333
"""/**
3434
|* docstring
3535
|*/""".stripMargin,
3636
)
3737

3838
assertParses(
39-
comments.DocComment(_),
39+
comments.DocComment(using _),
4040
"""/**
4141
|* docstring
4242
|*
4343
|*/""".stripMargin,
4444
)
4545

4646
assertParsesInto(
47-
comments.DocComment(_),
47+
comments.DocComment(using _),
4848
"""/** docstring
4949
| * with *stars*
5050
| */""".stripMargin,

‎idealingua-v1/idealingua-v1-core/src/main/scala/izumi/idealingua/il/parser/IDLParser.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,11 @@ class IDLParser(context: IDLParserContext) {
2828
import context._
2929

3030
def parseDomain(input: String): Parsed[ParsedDomain] = {
31-
parse(input, defParsers.fullDomainDef(_))
31+
parse(input, defParsers.fullDomainDef(using _))
3232
}
3333

3434
def parseModel(input: String): Parsed[ParsedModel] = {
35-
parse(input, defParsers.modelDef(_))
35+
parse(input, defParsers.modelDef(using _))
3636
}
3737

3838
}

‎idealingua-v1/idealingua-v1-runtime-rpc-http4s/src/main/scala/izumi/idealingua/runtime/rpc/http4s/HttpServer.scala‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ import io.circe.syntax.EncoderOps
99
import io.circe.{Json, Printer}
1010
import izumi.functional.bio.Exit.{Error, Interruption, Success, Termination}
1111
import izumi.functional.bio.{Clock1, Entropy1, Exit, F, IO2, Primitives2, Temporal2, UnsafeRun2}
12+
import izumi.fundamentals.collections.nonempty.NEList
1213
import izumi.fundamentals.platform.functional.Identity
1314
import izumi.fundamentals.platform.language.Quirks
1415
import izumi.fundamentals.platform.language.Quirks.Discarder
@@ -201,11 +202,11 @@ class HttpServer[F[+_, +_]: IO2: Temporal2: Primitives2: UnsafeRun2, AuthCtx](
201202
logger.warn(s"HTTP Request unexpectedly failed while handling $method:\n$error\n$trace") *>
202203
InternalServerError()
203204

204-
case Termination(_, (cause: IRTHttpFailureException) :: _, trace) =>
205+
case Termination(_, NEList((cause: IRTHttpFailureException), _*), trace) =>
205206
logger.error(s"HTTP Request rejected - $method, $request:\n$cause\n$trace") *>
206207
F.pure(Response(status = cause.status))
207208

208-
case Termination(_, (cause: RejectedExecutionException) :: _, trace) =>
209+
case Termination(_, NEList((cause: RejectedExecutionException), _*), trace) =>
209210
logger.warn(s"HTTP Request rejected - Not enough capacity to handle $method:\n$cause\n$trace") *>
210211
TooManyRequests()
211212

0 commit comments

Comments
 (0)