18b7b69 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

18b7b69 — Peter John 2026-11-04T13:47:55+05:30

format: one argument per line for multi-line calls and field lists

Files changed (3) hide show

plum-core/tests/formatter_test.rs +31 -0
plum-examples/games/functional/game_state_view.plum +92 -28
plum-tooling/tree-sitter-plum/queries/plum/format.scm +52 -0

plum-core/tests/formatter_test.rs CHANGED Viewed

@@ -463,3 +463,34 @@ fn format_fn_return_type() {
         "fun adder(n: Int) -> fn(Int) -> Int =\n  |x| x + n\n\nfun k() -> fn(Int) -> fn(Int) -> Int =\n  |x| |y| x\n",
     );
 }
+/// A constructor call wrapped across lines gets one argument per line and its
+/// `)` on its own line; one written on a single line stays on it.
+#[test]
+fn format_multiline_ctor_args_one_per_line() {
+    let input = "fun f() -> Pt =\n  Pt(\n    x: 1, y: 2,\n    z: 3).g()\n\nfun h() -> Pt =\n  Pt(x: 1, y: 2)\n";
+    let expected = "fun f() -> Pt =\n  Pt(\n    x: 1,\n    y: 2,\n    z: 3\n  ).g()\n\nfun h() -> Pt =\n  Pt(x: 1, y: 2)\n";
+    assert_eq!(formatSource(input).unwrap(), expected);
+    assertFormatsUnchanged(expected);
+}
+/// Same for ordinary call arguments (previously collapsed onto one line).
+#[test]
+fn format_multiline_call_args_one_per_line() {
+    let input = "fun f() -> Int =\n  g(\n    1, 2)\n";
+    let expected = "fun f() -> Int =\n  g(\n    1,\n    2\n  )\n";
+    assert_eq!(formatSource(input).unwrap(), expected);
+}
+/// A record's field list written across lines stays one field per line
+/// (previously collapsed onto one line); a one-line list stays on one line.
+#[test]
+fn format_multiline_record_fields_one_per_line() {
+    assertFormatsUnchanged("record Rec(\n  a: Int,\n  b: Int\n)\n\nrecord Sec(a: Int, b: Int)\n");
+}
+/// `mut` fields and `export fun` keep their space.
+#[test]
+fn format_mut_and_export_keywords() {
+    assertFormatsUnchanged("record World(mut s: Int, t: Int)\n\nexport fun f() -> Int =\n  1\n");
+}

plum-examples/games/functional/game_state_view.plum CHANGED Viewed

@@ -73,8 +73,17 @@ fun nothing() -> SceneNode =
 fun cell(sheet: Int, x: Float, y: Float, size: Float, col: Int, row: Int) -> SceneNode =
   Sprite(
-    tex: sheet, x: x, y: y, w: size, h: size, srcX: Float(col) * Rules.Cell, srcY: Float(row) * Rules.Cell,
+    tex: sheet,
+    x: x,
+    y: y,
+    w: size,
+    h: size,
-    srcW: Rules.Cell, srcH: Rules.Cell, tint: Color.White)
+    srcX: Float(col) * Rules.Cell,
+    srcY: Float(row) * Rules.Cell,
+    srcW: Rules.Cell,
+    srcH: Rules.Cell,
+    tint: Color.White
+  )
 fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
   Math.hypot(ax - bx, ay - by) < ra + rb
@@ -122,9 +131,12 @@ fun flashPose(t: Float) -> AnimPose =
 # The game-over title: grows to 1.3x, then pulses between 1.17x and 1.3x.
 fun titleAnim() -> Anim =
+  Seq(
-  Seq(steps: List(
+    steps: List(
-    ScaleTo(sx: 1.3, sy: 1.3, secs: 0.3),
+      ScaleTo(sx: 1.3, sy: 1.3, secs: 0.3),
-    Forever(anim: Seq(steps: List(ScaleTo(sx: 0.9, sy: 0.9, secs: 0.5), ScaleTo(sx: 1.0 / 0.9, sy: 1.0 / 0.9, secs: 0.5))))))
+      Forever(anim: Seq(steps: List(ScaleTo(sx: 0.9, sy: 0.9, secs: 0.5), ScaleTo(sx: 1.0 / 0.9, sy: 1.0 / 0.9, secs: 0.5))))
+    )
+  )
 fun titlePose(t: Float) -> AnimPose =
   Anim.at(titleAnim(), t)
@@ -150,9 +162,13 @@ record Ship(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt: Flo
     vx := if x != x0 then 0.0 else vx0
     vy := if y != y0 then 0.0 else vy0
     Ship(
+      x: x,
+      y: y,
-      x: x, y: y, vx: vx, vy: vy,
+      vx: vx,
+      vy: vy,
       rotation: if vx * vx + vy * vy > 400.0 then Math.atan2(vx, 0.0 - vy) else self.rotation,
-      hurt: {self.hurt - dt}.max(0.0))
+      hurt: {self.hurt - dt}.max(0.0)
+    )
   fun touches(self, at: Motion, radius: Float) -> Bool =
     overlaps(self.x, self.y, Rules.ShipRadius, at.x, at.y, radius)
@@ -167,7 +183,9 @@ record Ship(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt: Flo
         transform: Compose(first: Translate(dx: self.x, dy: self.y), then: Rotate(radians: self.rotation)),
         children: List(
           CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12)),
-          cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(clock, 4, 14.0), 0)))
+          cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(clock, 4, 14.0), 0)
+        )
+      )
 # A glowing orb drifting about. `phase` offsets its animation from the other orbs.
 record Orb(id: Int, at: Motion, phase: Float, clock: Float) =
@@ -188,12 +206,16 @@ record Orb(id: Int, at: Motion, phase: Float, clock: Float) =
       transform: Identity,
       children: List(
         CircleShape(cx: 0.0, cy: 0.0, r: 26.0, color: Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5)),
-        CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))))
+        CircleShape(cx: 0.0, cy: 0.0, r: 17.0, color: Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
+      )
+    )
     Group(
       transform: Translate(dx: self.at.x, dy: self.at.y),
       children: List(
         Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
-        cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock + self.phase, 4, 8.0), 1)))
+        cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock + self.phase, 4, 8.0), 1)
+      )
+    )
 # A spinning mine drifting about.
 record Mine(id: Int, at: Motion, rotation: Float, spin: Float, clock: Float) =
@@ -211,7 +233,8 @@ record Mine(id: Int, at: Motion, rotation: Float, spin: Float, clock: Float) =
   fun render(self, sheet: Int) -> SceneNode =
     Group(
       transform: Compose(first: Translate(dx: self.at.x, dy: self.at.y), then: Rotate(radians: self.rotation)),
-      children: List(cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock, 4, 4.0), 2)))
+      children: List(cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(self.clock, 4, 4.0), 2))
+    )
 # A twinkling background star; it never moves.
 record Star(i: Int) =
@@ -252,14 +275,31 @@ record State(
   sw: Float,
   sh: Float,
   sheet: Int,
-  target: Int) =
+  target: Int
+) =
   # A fresh run: the orbs and the mines spread over the arena away from the ship.
   fun start(seed: Int, best: Int, sheet: Int, target: Int, sw: Float, sh: Float) -> State =
     State(
+      ship: Ship.start(),
+      orbs: Nil,
+      mines: Nil,
+      stars: Star.field(0),
-      ship: Ship.start(), orbs: Nil, mines: Nil, stars: Star.field(0), rng: Random.seeded(seed), score: 0, best: best,
+      rng: Random.seeded(seed),
+      score: 0,
+      best: best,
-      lives: Rules.StartLives, over: false, clock: 0.0, overClock: 0.0, hurtAt: -1.0, overAt: -1.0, ui: Ui.init(),
+      lives: Rules.StartLives,
+      over: false,
+      clock: 0.0,
+      overClock: 0.0,
+      hurtAt: -1.0,
+      overAt: -1.0,
+      ui: Ui.init(),
+      sw: sw,
+      sh: sh,
+      sheet: sheet,
+      target: target
-      sw: sw, sh: sh, sheet: sheet, target: target).fillOrbs(0).growMines()
+    ).fillOrbs(0).growMines()
   # --- update ---
@@ -294,8 +334,11 @@ record State(
   fun respawnOrb(self, o: Orb) -> State =
     sp := spawn(self.rng, self.ship.x, self.ship.y, 120.0, 40.0)
     State(
+      ..self,
-      ..self, orbs: self.orbs.map(|x| if x.id == o.id then x.moved(sp.at) else x), rng: sp.rng,
+      orbs: self.orbs.map(|x| if x.id == o.id then x.moved(sp.at) else x),
+      rng: sp.rng,
-      score: self.score + Rules.OrbPoints)
+      score: self.score + Rules.OrbPoints
+    )
   # Orbs `i` and up to OrbCount, each at a random spot away from the ship.
   fun fillOrbs(self, i: Int) -> State =
@@ -304,8 +347,10 @@ record State(
   fun addOrb(self, i: Int) -> State =
     sp := spawn(self.rng, self.ship.x, self.ship.y, 120.0, 40.0)
     State(
+      ..self,
-      ..self, orbs: self.orbs.append(List(Orb(id: Id.Orb + i, at: sp.at, phase: Float(i) * 0.1, clock: 0.0))),
+      orbs: self.orbs.append(List(Orb(id: Id.Orb + i, at: sp.at, phase: Float(i) * 0.1, clock: 0.0))),
-      rng: sp.rng)
+      rng: sp.rng
+    )
   # Mines are added (at the end) until there are as many as the score asks for.
   fun growMines(self) -> State =
@@ -316,7 +361,8 @@ record State(
     State(
       ..self,
       mines: self.mines.append(List(Mine(id: Id.Mine + self.mines.length(), at: sp.at, rotation: 0.0, spin: 2.0, clock: 0.0))),
-      rng: sp.rng)
+      rng: sp.rng
+    )
   fun touchesMine(self) -> Bool =
     self.mines.fold(false, |hit, k| hit || self.ship.touches(k.at, Rules.MineRadius))
@@ -330,8 +376,14 @@ record State(
     done := lives <= 0
     ship := self.ship
     State(
+      ..self,
+      lives: lives,
-      ..self, lives: lives, ship: Ship(..ship, hurt: Rules.HurtTime), hurtAt: self.clock, over: done,
+      ship: Ship(..ship, hurt: Rules.HurtTime),
+      hurtAt: self.clock,
+      over: done,
+      overAt: if done then self.clock else self.overAt,
-      overAt: if done then self.clock else self.overAt, best: if done then self.best.max(self.score) else self.best)
+      best: if done then self.best.max(self.score) else self.best
+    )
   # After game over the orbs and mines stop: they only animate.
   fun settle(self) -> State =
@@ -375,7 +427,9 @@ record State(
         Group(transform: Identity, children: self.orbs.map(|o| o.render(self.sheet))),
         self.renderShip(),
         self.renderHud(),
-        self.renderOverlay()))
+        self.renderOverlay()
+      )
+    )
   # The ship is gone once the game is over (an empty group keeps the slots).
   fun renderShip(self) -> SceneNode =
@@ -393,13 +447,16 @@ record State(
       transform: Identity,
       children: Cons(
         head: Text(text: "Score {self.score}", x: 16.0, y: 12.0, size: 28.0, color: Color.White),
-        tail: Cons(head: Text(text: "Best {self.best.max(self.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow), tail: self.lifeIcons(0))))
+        tail: Cons(head: Text(text: "Best {self.best.max(self.score)}", x: 16.0, y: 44.0, size: 20.0, color: Color.Yellow), tail: self.lifeIcons(0))
+      )
+    )
   fun renderTitle(self) -> SceneNode =
     p := titlePose(self.clock - self.overAt)
     Group(
       transform: Compose(first: Translate(dx: 400.0 + p.dx, dy: 268.0 + p.dy), then: Scale(sx: p.scaleX, sy: p.scaleY)),
-      children: List(Text(text: "Game over", x: -100.0, y: -24.0, size: 48.0, color: Color.Red)))
+      children: List(Text(text: "Game over", x: -100.0, y: -24.0, size: 48.0, color: Color.Red))
+    )
   # The game-over panel is empty while playing, so nothing in it can be hit.
   fun renderOverlay(self) -> SceneNode =
@@ -414,7 +471,9 @@ record State(
         RectShape(x: 0.0, y: 230.0, w: Rules.ArenaW, h: 170.0, color: Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
         self.renderTitle(),
         Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
-        button))
+        button
+      )
+    )
     Filter(effect: Alpha(alpha: {self.overClock * 2.0}.min(1.0)), child: panel, target: self.target)
   # True when (x, y) in screen pixels is on the restart button of the picture `render` builds.
@@ -444,8 +503,13 @@ fun startMusic(io: Io, w: World) =
 export fun init(io: Io) -> World =
   s := State.start(io.randomSeed(), 0, io.textureLoad("sprites.png"), io.textureCreate(1600, 1200), Rules.ArenaW, Rules.ArenaH)
   w := World(
+    state: s,
+    wasDown: false,
-    state: s, wasDown: false, pickupSound: io.soundLoad("pickup.wav"), hitSound: io.soundLoad("hit.wav"),
+    pickupSound: io.soundLoad("pickup.wav"),
+    hitSound: io.soundLoad("hit.wav"),
-    overSound: io.soundLoad("gameover.wav"), musicSound: io.soundLoad("music.wav"))
+    overSound: io.soundLoad("gameover.wav"),
+    musicSound: io.soundLoad("music.wav")
+  )
   startMusic(io, w)
   w

plum-tooling/tree-sitter-plum/queries/plum/format.scm CHANGED Viewed

@@ -401,3 +401,55 @@
 (trait
   (comment) @allow_blank_line_before)
+; ============================================================
+; Constructor arguments — a `Type(..)` call written across lines puts each
+; argument on its own indented line and the `)` on its own line; one written
+; on a single line stays on it. (Softlines break only when the argument list
+; already spans lines in the source.)
+; ============================================================
+(class_argument_list
+  "(" @append_empty_softline @append_indent_start)
+(class_argument_list
+  ")" @prepend_empty_softline @prepend_indent_end)
+(class_argument_list
+  "," @append_spaced_softline)
+; Function-call arguments follow the same rule: `List(\n  a,\n  b\n)`.
+(fn_argument_list
+  "(" @append_empty_softline @append_indent_start)
+(fn_argument_list
+  ")" @prepend_empty_softline @prepend_indent_end)
+(fn_argument_list
+  "," @append_spaced_softline)
+; `struct`/`record` field lists have no node of their own (the `(`, fields and
+; `)` sit directly under the type, whose body always spans lines), so a scope
+; from `(` to `)` decides: fields written across lines go one per line.
+(struct
+  "(" @append_begin_scope @append_empty_scoped_softline @append_indent_start
+  ")" @prepend_end_scope @prepend_empty_scoped_softline @prepend_indent_end
+  (#scope_id! "ctor_fields"))
+(record
+  "(" @append_begin_scope @append_empty_scoped_softline @append_indent_start
+  ")" @prepend_end_scope @prepend_empty_scoped_softline @prepend_indent_end
+  (#scope_id! "ctor_fields"))
+(struct
+  "," @append_spaced_scoped_softline
+  (#scope_id! "ctor_fields"))
+(record
+  "," @append_spaced_scoped_softline
+  (#scope_id! "ctor_fields"))
+; `mut x: T` fields and `export fun`.
+"mut" @append_space
+(fn "export" @append_space)