auto-let.civet

{testCase} from ./helper.civet

describe "auto-let", ->
  testCase """
    multiple assignment
    ---
    "civet auto-let"
    a = b = c = d
    a = 2
    ---
    let a, b, c
    a = b = c = d
    a = 2
  """

  testCase """
    assignment to variable indexed array
    ---
    "civet auto-let"
    a[x] = 1
    ---
    a[x] = 1
  """

  testCase """
    with a declaration
    ---
    "civet auto-let"
    let b = 2
    a = 1
    b = a
    ---
    let b = 2
    let a = 1
    b = a
  """

  testCase """
    with a let declaration
    ---
    "civet auto-let"
    var b = 2
    a = 1
    b = a
    ---
    var b = 2
    let a = 1
    b = a
  """

  testCase """
    with a binding pattern
    ---
    "civet auto-let"
    let [a, b] = [1, 2]
    a = 3
    ---
    let [a, b] = [1, 2]
    a = 3
  """

  testCase """
    with import named binding
    ---
    "civet auto-let"
    import {a, b} from 'c'
    a = 1
    ---
    import {a, b} from 'c'
    a = 1
  """

  testCase """
    with default import
    ---
    "civet auto-let"
    import a from 'b'
    a = 1
    ---
    import a from 'b'
    a = 1
  """

  testCase """
    with default and named import
    ---
    "civet auto-let"
    import a, {b, c} from 'd'
    a = 1
    b = 2
    ---
    import a, {b, c} from 'd'
    a = 1
    b = 2
  """

  testCase """
    with an array destructuring assignment
    ---
    "civet auto-let"
    [a, b] = [1, 2]
    [c] = [3]
    ---
    let a, b
    [a, b] = [1, 2];
    let [c] = [3]
  """

  testCase """
    with nested array destructuring assignment
    ---
    "civet auto-let"
    [
      a
      b
    ] = [1, 2]
    ---
    let a, b
    [
      a,
      b
    ] = [1, 2]
  """

  testCase """
    with an object destructuring assignment
    ---
    "civet auto-let"
    {a, b} = {a: 1, b: 2}
    {c} = {c: 3}
    ---
    let a, b
    ({a, b} = {a: 1, b: 2});
    let c
    ({c} = {c: 3})
  """

  testCase """
    with nested object destructuring assignment
    ---
    "civet auto-let"
    {
      a
      b
    } = {a: 1, b: 2}
    ---
    let a, b
    ({
      a,
      b
    } = {a: 1, b: 2})
  """

  testCase """
    with destructuring assignment renaming
    ---
    "civet auto-let"
    {a: b, c: d} = {a: 1, c: 2}
    ---
    let b, d
    ({a: b, c: d} = {a: 1, c: 2})
  """

  testCase """
    with destructuring assignment nested renaming
    ---
    "civet auto-let"
    {
      a: {b: c}
      d: e
    } = {a: 1, c: 2}
    ---
    let c, e
    ({
      a: {b: c},
      d: e
    } = {a: 1, c: 2})
  """

  testCase """
    with destructuring assignment object in array in object
    ---
    "civet auto-let"
    {
      a: [b, {c}]
      d: e
    } = {a: 1, c: 2}
    ---
    let b, c, e
    ({
      a: [b, {c}],
      d: e
    } = {a: 1, c: 2})
  """

  testCase """
    for i loop
    ---
    "civet auto-let"
    for i = 0; i < 10; i++
      a = i
    ---
    let i
    for (i = 0; i < 10; i++) {
      let a = i
    }
  """

  testCase """
    for in loop with let dec
    ---
    "civet auto-let"
    for let a in b
      a = c = 1
    ---
    for (let a in b) {
      let c
      a = c = 1
    }
  """

  testCase """
    for loop implied const
    ---
    "civet auto-let"
    for a in b
      a = c = 1
    ---
    for (const a in b) {
      let c
      a = c = 1
    }
  """

  testCase """
    chained assignment
    ---
    "civet auto-let"
    a = b = c = 1
    ---
    let a, b, c
    a = b = c = 1
  """

  testCase """
    chained assignment with a declaration
    ---
    "civet auto-let"
    let a = 1
    a = b = c = 1
    ---
    let a = 1
    let b, c
    a = b = c = 1
  """

  testCase """
    chained assignment with destructuring
    ---
    "civet auto-let"
    {a, b} = c = d
    ---
    let a, b, c
    ({a, b} = c = d)
  """

  testCase """
    chained assignment with destructuring in other order
    ---
    "civet auto-let"
    a = {b, c} = d
    ---
    let a, b, c
    a = ({b, c} = d)
  """

  testCase """
    chained assignment with destructuring and a declaration
    ---
    "civet auto-let"
    let a = 1
    {a, b} = c = d
    ---
    let a = 1;
    let b, c
    ({a, b} = c = d)
  """

  testCase """
    multiple chained destructuring assignments
    ---
    "civet auto-let"
    {a, b} = {c, d} = x
    ---
    let a, b, c, d
    ({a, b} = {c, d} = x)
  """

  testCase """
    nested function
    ---
    "civet auto-let"
    x = 1
    a = ->
      x = 2
      y = 1
      b = ->
        x = 3
        y = 2
        z = 1
    ---
    let x = 1
    let a = function() {
      x = 2
      let y = 1
      let b
      return b = function() {
        x = 3
        y = 2
        let z
        return z = 1
      }
    }
  """

  testCase """
    function with parameters
    ---
    "civet auto-let"
    a = (b, c) ->
      x = 1
      c = 2
    ---
    let a = function(b, c) {
      let x = 1
      return c = 2
    }
  """

  testCase """
    nested blocks
    ---
    "civet auto-let"
    x = 1
    {
      x = 2
      y = 1
      {
        x = 3
        y = 2
        z = 1
      }
      {
        z = 2
      }
    }
    ---
    let x = 1
    {
      x = 2
      let y = 1
      {
        x = 3
        y = 2
        let z = 1
      }
      {
        let z = 2
      }
    }
  """


  // This case is disabled because the 'export var' cannot be detected due to the var token is not in declaration.
  testCase """
    export implicit let dec
    ---
    "civet auto-let"
    a = 1
    export a = 2
    ---
    a = 1
    export var a = 2
  """

  testCase """
    let dec inside block
    ---
    "civet auto-let"
    a = 1
    {
      let a = 2
    }
    ---
    let a = 1
    {
      let a = 2
    }
  """

describe "complicated auto-let", ->
    testCase """
        auto let nest
        ---
        "civet auto-let"
        let v1 = 0
        v2 = 0
        for i of [1]
            v1 = 1
            var v2 = 1
            v3 = 1
            for j of [1]
                v1 = 2
            v2 = 2
        v3 = 2
        ---
        let v1 = 0
        v2 = 0
        for (const i of [1]) {
            v1 = 1
            var v2 = 1
            let v3 = 1
            for (const j of [1]) {
                v1 = 2
            }
            v2 = 2
        }
        let v3 = 2
    """
    testCase """
        auto let with function
        ---
        "civet auto-let"
        b = 1
        function b(a) {
            a = 1
            var b = 2
        }
        a = 2
        let c = (b) => {
            c = 1
        }
        ---
        let b = 1
        function b(a) {
            a = 1
            var b = 2
        }
        let a = 2
        let c = (b) => {
            let c
            return c = 1
        }
    """
    testCase """
        auto let with multiple declaration
        ---
        "civet auto-let"
        c = "str"
        [a, b] = [1, 2]
        [c, d] = [3, 4]
        ---
        let c = "str";
        let a, b
        [a, b] = [1, 2];
        let d
        [c, d] = [3, 4]
    """
    testCase """
    auto let inner assignment expression
    ---
    "civet auto-let"
    [a, b] = function(a) {
        a = 2
        b = 2
        return [a, b]
    }(a)
    ---
    let a, b
    [a, b] = function(a) {
        a = 2
        let b = 2
        return [a, b]
    }(a)
    """

    testCase """
    auto let inner if parens
    ---
    "civet auto-let"
    if a = 1
      a = 2
    else if b = 2 then c = 3
    else if d = 3
      a = 4
    else
      e = 5
    a = 6
    ---
    let a, b, c, d
    if (a = 1) {
      a = 2
    }
    else if (b = 2) c = 3;
    else if (d = 3) {
      a = 4
    }
    else {
      let e = 5
    }
    a = 6
    """

    testCase """
    auto let embedded
    ---
    "civet auto-let"
    a1 = 1
    a2.b = 1
    [a3] = 1
    {a4} = 1
    a5 = b5 = 1
    a6.b = b6 = 1
    b7 = a7.b = 1
    ---
    let a1 = 1
    a2.b = 1;
    let [a3] = 1;
    let a4
    ({a4} = 1)
    let a5, b5
    a5 = b5 = 1
    let b6
    a6.b = b6 = 1
    let b7 = a7.b = 1
    """