case 1
in 1
end

case 1
in 1
  :one
else
  nil
end

if true
  # 0
  case # 1
    # 2
    a # 3
    # 4
  in # 5
    # 6
    b # 7
    # 8
    :b # 9
    # 10
  else # 11
    # 12
    :c # 13
    # 14
  end # 15
  # 16
end

## Standalone matches (assignments)

1 => a
1 in a

# 0
[
  a, # 1
] in # 2
  # 3
  b # 4
# 5

## Array patterns

xs => []
xs in [a, b, c]
xs => a, b, c
xs in a, b, *cs, d
xs => Foo[a, b, c]
xs => Foo(d, e, *f)
xs => [a, *]
xs => *, a
xs => [*]
xs => a,b;
xs => [a,]
xs => *a

# Wrap by brackets automatically to avoid syntax error after stripping semicolons.
xs => a,;
xs => a,*;
case xs
in 0,;
  nil
end

xs => # 0
  # 1
  Foo:: # 2
    # 3
    Bar[ # 4
      # 5
      a, # 6
      # 7
      b, # 8
      # 9
      *cs, # 10
      # 11
      d # 12
      # 13
    ] # 14
# 15

xs => a, # a
  b, # b
  c # c
# d

xs => [
  a,
  b,
  *cs # no comma
]

xs => [
  a, # a
  b,
  *cs,
  d # no comma
]

## Find patterns

xs in [*, x, *]
xs => *a, x, _y, z, *b

xs => # 0
  # 1
  *a, # 2
  # 3
  b, # 4
  # 5
  c, # 6
  # 7
  *d # 8
# 9

## Hash patterns

hash in {}
hash => { a:, b: { c: } }
hash in a:, b: { c: }
hash => { a: 1, b: [c, *], d: }
hash in { a:, **b }
hash => { a:, ** }
hash in { ** }
hash => **all

hash => # 0
  # 1
  { # 2
    # 3
    a: # 4
      # 5
      :b, # 6
    # 7
  } # 8
# 9

hash => # 0
  # 1
  a:, # 2
  # 3
  **b # 4
# 5

## Pinned expressions / variables

v => ^(1 + 2)
v in ^(nil)
v => { a: ^(!true), b: [*, ^(Foo.bar)] }

v => # 0
  # 1
  ^( # 2
    # 3
    a * (b + c)) # 4
# 5

v => ^a
v => [a, ^b, *c]
v in ^a, ^@b, ^@@c, ^$d

## Captures

xs in [Integer => a, String]
xs => Integer => b, *rest
hash => {
  a:,
  b: Foo::Bar => # 0
    # 1
    baz, # 2
  # 3
  c: [d],
}

## Alternation patterns

v => a | b
v => a | b | c | d | e

# Prism's bug? This is a valid syntax but the patterns before the parentheses are ignored.
v => a | (b | c) | d

v => [a, :b] | c, d | [*, e, *] | {f: Integer | Nil, g:, **} | ^(h.i(j)) | ^@k | [String] => l

v => # 0
  # 1
  a | # 2
  # 3
  [b | c] | # 4
  # 5
  { d: } # 6
# 7

## Mixed with case-in

case foo.bar
in 1, 2, a, *rest
  1
in [*, :a, a, *] | [:b, b, *]
  2
in {
  a: {
    x: Integer => y,
    b: {
      c: [^d, e],
    },
  },
}
  3
in ^(aa.bb(1).cc[2]&.dd) | nil | true | false
  4
else
  case bar.baz
  in *a
    5
  else
    6
  end
end

case v
in [] | {}
  nil
in [:a] if a
  aa
in {
  a: Integer,
  b: String => s
}
  bb
in {
  a: Integer,
  b: { c: c, d: d, ** }
} if foo(v).bar?
  cc
end