test.toit

    import ..tests.syntax-companion
    import .syntax-companion show show-foo2
    import io

    import ..tests.syntax-companion show global-x global-y
    import .syntax-companion show global-x global-y
    import io show Buffer

    import ..tests.syntax-companion show
      global-x
      global-y
    import .syntax-companion
      show
        global-x
        global-y
    import
      io
      show
      Buffer
      InMixin

    import ..tests.syntax-companion show *
    import .syntax-companion show *
    import bytes show *

    import ..tests.syntax-companion as imp1
    import .syntax-companion as imp2
    import bytes as imp3

    import core as core

    export global-x
    export global-x global-y
    export *

    import .syntax-companion as as-prefix

    import-foo:
    show-foo:

    // Normal comment
    /* Normal multiline // with normal
    /* nested multiline */
    foo bar
    ```
    Markdown comment (doesn't need to be colored).
    ```
    Links: http://www.example.com
    */

    separator := null  // To show the separations.

    /// Doc-style comment
    separator2 := null  // To show the separations.
    /// Doc-style with // normal comment
    separator3 := null  // To show the separations.
    /**
    doc-style
    /* with nested comment */
    ```
    Markdown comment
    ```
    [References]

    /**
    Nested multi doc.
    */
    Markdown `code`.

    Links: http://www.example.com
    */
    separator4 := null  // To show the separations.

    global := some-fun 499 "str" true
    global2 /any := some-fun 499 "str" true
    global3 /Type := some-fun 499 "str" true

    globalb /*comment*/ := some-fun 499 "str" true
    global2b /any/*comment*/ := some-fun 499 "str" true
    global3b /Type/*comment*/ := some-fun 499 "str" true

    globalc /*comment*/ ::= some-fun 499 "str" true
    global2c /any/*comment*/ ::= some-fun 499 "str" true
    global3c /**/ /Type/*comment*/ ::= some-fun 499 "str" true

    global-fun:
      while true: some-fun "2" /*comment*/ null true

    global-fun2:
      while true: some-fun "2" /*comment*/ null true

    global-fun2b: while true: some-fun "2" /*comment*/ null true

    global-fun3 x:
      while true: some-fun "2" /*comment*/ null true

    global-fun4 x/any y/Type:
      while true: some-fun "2" /*comment*/ null true

    global-fun5 x/any y/ Type?:
      while true: some-fun "2" /*comment*/ null true

    global-fun6 x / any y/Type?: while true: some-fun "2" /*comment*/ null true

    global-fun7 -> none:
      while true: some-fun "2" /*comment*/ null true

    global-fun8 x/io.Buffer -> none:
      while true: some-fun "2" /*comment*/ null true

    global-fun9 -> none
        x / io.Buffer?
        y/any:
      while true: some-fun "2" /*comment*/ null true

    global-fun9b -> none
        x /io.Buffer? /*comment*/
        y /any:
      while true: some-fun "2" /*comment*/ null true

    some-fun x: return null
    some-fun x y: return null
    some-fun x y z: return null

    foo: return null

    default-values x=499 y="some_str" z=(while true: 499) g=x.bar h=foo[499] i=foo.call:

    default-values2 x=499
        y="some_str"
        z=(while true: 499)
        g=x.bar
        h=foo[499]
        i=foo.call:

    default-values3 --x=499 --y="some_str" --z=(while true: 499) --g=x.bar --h=foo[499] --i=foo.call:
      default-values4 --i=33

    default-values4
        --x=499
        --y="some_str"
        --z=(while true: 499)
        --g=x.bar
        --h=foo[499]
        --i=foo.call:

    global-setter= x:
      499
    global-setter2= x -> none:
      42

    fun
        --some
        --args
        on
        multiple
        lines
    :
      print "with colon at same level as 'fun'"

    class X-Of:

    abstract class Type:
      foo := 499
      constructor:

      operator == other:
        return true
      operator + other:
        return 499
      operator >> shift-amount:
        return 42
      operator << shift-amount:
        return 0
      operator >>> shift-amount:
        return 42

      operator < other: return true
      operator > other: return true
      operator <= other: return true
      operator >= other: return true
      operator - other: return 0
      operator * other: return 0
      operator / other: return 3
      operator % other: return 22
      operator ^ other: return 0
      operator & other: return 0
      operator | other: return 4
      operator [] i:
      operator []= i val:
      operator [..] --from --to:

      method x/Type? -> none:
        print x
      other --flag --named:
        other --no-flag --named=33

      abstract gee x y
      static foobar x y: return 1 + 2
      abstract/**/ foo x y
      static /*comment*/bar y: return 0x499

      instance-setter= x: 42
      instance-setter2= y -> none: 499

    class Type3 extends Type:
      foo x y: return x + y
      gee x y:

    class Type2:
      method2:
        (Type3).method null
        print 3

    interface I1:
      m1

    interface I2 extends I1 implements I3:
      m2
      m3

    interface I3:
      m3

    class ClassConstructor:
      field := null
      constructor:
      constructor x/string:
      constructor .field y/int:
      constructor.named:
      constructor.named .field y/int:
      constructor.named arg/int:

    constant1 ::= 1234_5678
    constant1b ::= 1_2_3_4_5_6_7_8
    constant1c ::= -1234_5678
    constant2 ::= -123_456.789_123
    constant2b ::= -1_2_3_4_5_6.7_8_9_1_2_3
    constant2c ::= -.123_456
    constant2d ::= .123_456
    constant2e ::= .1_2_3_4_5_6
    constant2f ::= 123_456.0
    constant3 ::= 0xFFFF_FFFF + 0X1234_22
    constant3b ::= 0xF_F_F_F_F_F_F_F + 0X1_2_3_4_2_2
    constant4 ::= 0b0101_0101 + 0B1101_1010 + constant3b
    constant4b ::= 0b0_1_0_1_0_1_0_1 + 0B1101_1010 + constant4
    constant5 ::= 1.5e17 + -.7e+3 + 1e-10
    constant5b ::= 1_0.5_3e1_7 + -.7_3e+3_2 + 0_1e-1_0
    constant6 ::= 0xa.bP-3 + -0X7107p44 + 0x.abcp-77
    constant6b ::= 0xa_b_c.b_cP-3_3 + -0X7_1_0_7p4_4 + 0x.a_b_cp-7_7

    SOME-CONSTANT ::= 499
    CONSTANT499 ::= 42

    import-fun: return 42
    export-fun: return 42
    class-fun: return 499
    interface-fun: return 9
    monitor-fun: return 4
    is-something-fun:
      is-local := 42

    g-str / string? ::= null
    g-iii / int?  ::= null
    g-boo / bool? ::= null
    g-flo / float? ::= null
    g-str2 / string ::= "str"
    g-iii2 / int  ::= 499
    g-boo2 / bool ::= true
    g-flo2 / float ::= 3.14

    fun1 str/string? iii/int? boo/bool? flo/float?:
    fun2 str/string iii/int boo/bool flo/float:

    class Cll:
      fun1 str/string? iii/int? boo/bool? flo/float?:
      fun2 str/string iii/int boo/bool flo/float:
      fun3 x / Cll:

      field := ?
      constructor:
        field = 499

      static SOME-STATIC-CONSTANT ::= 42
      static STATIC-CONSTANT499 ::= 3

    fun:
      unreachable

    fun2 unreachable:

    run [block]: block.call

    labeled-continue:
      run:
        continue.run

    class A:
    class A1:
    class AbC0:

    fun-with-bracket-in-default default=SOME-LIST[0][1][2]:

    fun-with-default-block default=A [block]:

    SOME-LIST ::= [1, 2]
    fun-with-default-bracket arg1 default=SOME-LIST[arg1]:

    class Slice:
      operator [..] --from=0 --to=0:

    main:
      5 is any
      "str" is not float
      "str" as string
      5.9 as float
      5 as int
      true is bool
      print false as bool
      local := 2
      local >>= 499
      local >>>= 2

      for ;;: break
      for x := 0;;: break
      for x := 0;;x++: break
      1 + 2
      1 - 2
      0 * 3
      5 / 2
      3 % 1
      5 << 1
      5 >> 2
      8 >>> 3
      5 < 3
      9 > 3
      5 <= 3
      8 >= 5
      3 | 5
      3 & 2
      3 ^ 3
      ~5
      y := 0
      y += 0
      y -= 0
      y *= 0
      y /= 3
      y %= 9
      y <<= 3
      y >>= 5
      y >>>= 3
      y |= 9
      y &= 2
      y ^= 9
      y = ~y

      c := '\''
      c = '\\'
      c = '\x12'
      c = '\u1f3A'
      str := "\""
      mstr := """x"""
      istr := """$("""
      """)"""
      """c"""
      // Empty triple-quoted string.
      """"""
      // Some examples with quotes at the start or end of a triple-quoted string.
      """""""
      """"""""
      """c"""
      """"c""""
      """""c"""""
      """$c"""
      """"$c""""
      """""$c"""""
      """$c """
      """"$c """"
      """""$c """""
      some-fun """"" $c """"" ""

      local2 := ?
      local3 := true ? false : null

      local4 /int := 499
      local5 /string? := ""
      local6/**/ /int := 499
      local7/**/ /string? := ""
      local8 /core.List? ::= []

      while true:
        if local4 == 0: continue
        break

      cc := CONSTANT499 + SOME-CONSTANT
      cc2 := Cll.SOME-STATIC-CONSTANT + Cll.STATIC-CONSTANT499

      a0 / A := A
      a0_ / A? := null
      a1 / A1 := A1
      a1_ / A1? := null
      a2 / AbC0 := AbC0
      a2_ / AbC0? := null

      bytes := #[1, 2, 3]

      (Slice)[1..2]
      (Slice)[..2]
      (Slice)[1..]
      (Slice)[..]

      "string with\\ \" escapes"

      assert-x := 499
      assert-x--
      as-something := assert-x + 42
      null-foo := as-something + assert-x
      assert-x += null-foo

      x-of := X-Of