Allow trailing commas in comma-separated syntax elements

Author: HT154

pkl-core/src/test/files/LanguageSnippetTests/input/classes/constraintsTrailingComma.pkl

@@ -0,0 +1,9 @@
+res1: Int(isEven, isNonZero, isBetween(-10, 10), ) = 6
+res2: Int(
+    isEven, isNonZero, isBetween(-10, 10),
+) = 6
+res3: Int(
+    isEven,
+    isNonZero,
+    isBetween(-10, 10),
+) = 6

pkl-core/src/test/files/LanguageSnippetTests/input/lambdas/lambdaTrailingCommas.pkl

@@ -0,0 +1,58 @@
+local lA1 = (a, b, c,) -> true
+local lA2 = (
+  a, b, c,
+) -> true
+local lA3 = (
+  a,
+  b,
+  c,
+) -> true
+
+local lB1 = (a: Int, b: Int, c: Int,) -> true
+local lB2 = (
+  a: Int, b: Int, c: Int,
+) -> true
+local lB3 = (
+  a: Int,
+  b: Int,
+  c: Int,
+) -> true
+
+local lC1: Mixin = new { a, -> x = true }
+local lC2: Mixin = new { a, ->
+  x = true
+}
+local lC3: Mixin = new {
+  a, -> x = true
+}
+local lC4: Mixin = new {
+  a, ->
+  x = true
+}
+
+local lD1: Mixin = new { a: Dynamic, -> x = true }
+local lD2: Mixin = new { a: Dynamic, ->
+  x = true
+}
+local lD3: Mixin = new {
+  a: Dynamic, -> x = true
+}
+local lD4: Mixin = new {
+  a: Dynamic, ->
+  x = true
+}
+
+lA1Call = lA1.apply(1, 2, 3)
+lA2Call = lA2.apply(1, 2, 3)
+lA3Call = lA3.apply(1, 2, 3)
+lB1Call = lB1.apply(1, 2, 3)
+lB2Call = lB2.apply(1, 2, 3)
+lB3Call = lB3.apply(1, 2, 3)
+lC1Call = new Dynamic {} |> lC1
+lC2Call = new Dynamic {} |> lC2
+lC3Call = new Dynamic {} |> lC3
+lC4Call = new Dynamic {} |> lC4
+lD1Call = new Dynamic {} |> lD1
+lD2Call = new Dynamic {} |> lD2
+lD3Call = new Dynamic {} |> lD3
+lD4Call = new Dynamic {} |> lD4

pkl-core/src/test/files/LanguageSnippetTests/input/methods/methodTrailingCommas.pkl

@@ -0,0 +1,157 @@
+function moduleMethodA1(a, b, c, ) = true
+function moduleMethodA2(
+  a, b, c,
+) = true
+function moduleMethodA3(
+  a,
+  b,
+  c,
+) = true
+function moduleMethodB1(a: Int, b: Int, c: Int, ) = true
+function moduleMethodB2(
+  a: Int, b: Int, c: Int,
+) = true
+function moduleMethodB3(
+  a: Int,
+  b: Int,
+  c: Int,
+) = true
+
+class A {
+  function classMethodA1(a, b, c, ) = true
+  function classMethodA2(
+    a, b, c,
+  ) = true
+  function classMethodA3(
+    a,
+    b,
+    c,
+  ) = true
+  function classMethodB1(a: Int, b: Int, c: Int, ) = true
+  function classMethodB2(
+    a: Int, b: Int, c: Int,
+  ) = true
+  function classMethodB3(
+    a: Int,
+    b: Int,
+    c: Int,
+  ) = true
+}
+
+moduleMethodA1Call1 = moduleMethodA1(1, 2, 3, )
+moduleMethodA1Call2 = moduleMethodA1(
+  1, 2, 3,
+)
+moduleMethodA1Call3 = moduleMethodA1(
+  1,
+  2,
+  3,
+)
+moduleMethodA2Call1 = moduleMethodA2(1, 2, 3, )
+moduleMethodA2Call2 = moduleMethodA2(
+  1, 2, 3,
+)
+moduleMethodA2Call3 = moduleMethodA2(
+  1,
+  2,
+  3,
+)
+
+moduleMethodA3Call1 = moduleMethodA3(1, 2, 3, )
+moduleMethodA3Call2 = moduleMethodA3(
+  1, 2, 3,
+)
+moduleMethodA3Call3 = moduleMethodA3(
+  1,
+  2,
+  3,
+)
+
+moduleMethodB1Call1 = moduleMethodB1(1, 2, 3, )
+moduleMethodB1Call2 = moduleMethodB1(
+  1, 2, 3,
+)
+moduleMethodB1Call3 = moduleMethodB1(
+  1,
+  2,
+  3,
+)
+moduleMethodB2Call1 = moduleMethodB2(1, 2, 3, )
+moduleMethodB2Call2 = moduleMethodB2(
+  1, 2, 3,
+)
+moduleMethodB2Call3 = moduleMethodB2(
+  1,
+  2,
+  3,
+)
+
+moduleMethodB3Call1 = moduleMethodB3(1, 2, 3, )
+moduleMethodB3Call2 = moduleMethodB3(
+  1, 2, 3,
+)
+moduleMethodB3Call3 = moduleMethodB3(
+  1,
+  2,
+  3,
+)
+
+local a: A = new {}
+
+classMethodA1Call1 = a.classMethodA1(1, 2, 3, )
+classMethodA1Call2 = a.classMethodA1(
+  1, 2, 3,
+)
+classMethodA1Call3 = a.classMethodA1(
+  1,
+  2,
+  3,
+)
+classMethodA2Call1 = a.classMethodA2(1, 2, 3, )
+classMethodA2Call2 = a.classMethodA2(
+  1, 2, 3,
+)
+classMethodA2Call3 = a.classMethodA2(
+  1,
+  2,
+  3,
+)
+
+classMethodA3Call1 = a.classMethodA3(1, 2, 3, )
+classMethodA3Call2 = a.classMethodA3(
+  1, 2, 3,
+)
+classMethodA3Call3 = a.classMethodA3(
+  1,
+  2,
+  3,
+)
+
+classMethodB1Call1 = a.classMethodB1(1, 2, 3, )
+classMethodB1Call2 = a.classMethodB1(
+  1, 2, 3,
+)
+classMethodB1Call3 = a.classMethodB1(
+  1,
+  2,
+  3,
+)
+classMethodB2Call1 = a.classMethodB2(1, 2, 3, )
+classMethodB2Call2 = a.classMethodB2(
+  1, 2, 3,
+)
+classMethodB2Call3 = a.classMethodB2(
+  1,
+  2,
+  3,
+)
+
+classMethodB3Call1 = a.classMethodB3(1, 2, 3, )
+classMethodB3Call2 = a.classMethodB3(
+  1, 2, 3,
+)
+classMethodB3Call3 = a.classMethodB3(
+  1,
+  2,
+  3,
+)

pkl-core/src/test/files/LanguageSnippetTests/input/types/trailingCommas.pkl

@@ -0,0 +1,22 @@
+class Foo<
+  Key,
+  Value,
+> {
+  test: Mapping<
+      Key,
+      Value,
+    >
+
+  function bar<
+      A,
+      B,
+    >(a: A, b: B,): Value? = "\(a):\(b) - \(test)"
+}
+
+res1: Foo<String, String,>(!test.isEmpty) = new Foo<String, String,> {
+  test {
+    ["hello"] = "world"
+  }
+}
+
+res2 = res1.bar(123, "foo")

pkl-core/src/test/files/LanguageSnippetTests/output/classes/constraintsTrailingComma.pcf

@@ -0,0 +1,3 @@
+res1 = 6
+res2 = 6
+res3 = 6

pkl-core/src/test/files/LanguageSnippetTests/output/lambdas/lambdaTrailingCommas.pcf

@@ -0,0 +1,30 @@
+lA1Call = true
+lA2Call = true
+lA3Call = true
+lB1Call = true
+lB2Call = true
+lB3Call = true
+lC1Call {
+  x = true
+}
+lC2Call {
+  x = true
+}
+lC3Call {
+  x = true
+}
+lC4Call {
+  x = true
+}
+lD1Call {
+  x = true
+}
+lD2Call {
+  x = true
+}
+lD3Call {
+  x = true
+}
+lD4Call {
+  x = true
+}

pkl-core/src/test/files/LanguageSnippetTests/output/methods/methodTrailingCommas.pcf

@@ -0,0 +1,36 @@
+moduleMethodA1Call1 = true
+moduleMethodA1Call2 = true
+moduleMethodA1Call3 = true
+moduleMethodA2Call1 = true
+moduleMethodA2Call2 = true
+moduleMethodA2Call3 = true
+moduleMethodA3Call1 = true
+moduleMethodA3Call2 = true
+moduleMethodA3Call3 = true
+moduleMethodB1Call1 = true
+moduleMethodB1Call2 = true
+moduleMethodB1Call3 = true
+moduleMethodB2Call1 = true
+moduleMethodB2Call2 = true
+moduleMethodB2Call3 = true
+moduleMethodB3Call1 = true
+moduleMethodB3Call2 = true
+moduleMethodB3Call3 = true
+classMethodA1Call1 = true
+classMethodA1Call2 = true
+classMethodA1Call3 = true
+classMethodA2Call1 = true
+classMethodA2Call2 = true
+classMethodA2Call3 = true
+classMethodA3Call1 = true
+classMethodA3Call2 = true
+classMethodA3Call3 = true
+classMethodB1Call1 = true
+classMethodB1Call2 = true
+classMethodB1Call3 = true
+classMethodB2Call1 = true
+classMethodB2Call2 = true
+classMethodB2Call3 = true
+classMethodB3Call1 = true
+classMethodB3Call2 = true
+classMethodB3Call3 = true

pkl-core/src/test/files/LanguageSnippetTests/output/types/trailingCommas.err

@@ -0,0 +1,6 @@
+–– Pkl Error ––
+Only standard library members can have type parameters.
+
+x | Key,
+    ^^^
+at trailingCommas (file:///$snippetsDir/input/types/trailingCommas.pkl)