`[]` parsed incorrectly leading to unrelated error message

[bugarela]

Using [] like this:

module test {
  pure val foo = {
    pure val bar = 1
    [bar].concat(2)
  }
}

causes a completely unrelated error about cyclic definitions:

test.qnt:3:5 - error: [QNT099] Found cyclic declarations. Use fold and foldl instead of recursion
3:     pure val bar = 1
       ^^^^^^^^^^^^^^^^
4:     [bar].concat(2)
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: parsing failed

because this is (wrongfully) parsed as:

module test {
  pure val foo = pure val bar = field(nth(1, bar), "concat") { 2 }
}

[bugarela]

Workaround: use List(bar) instead of [bar]

[bugarela]

I stumbled upon a similar issue while writing typescript and the autoformatter immediately made me understand I wrote something different then what I expected. I wrote

const a = foo(x)
[a, bar]

(forgetting the return keyword in the last line). As soon as I saved the file, it got formatted into

const a = foo(x)[a, bar]

which made me realize something was wrong.

[bugarela]

A similar issue was reported by @angbrav involving tuple constructors and operator calls. In this example, one tuple construction ((bar, 1)) is parsed as the parameters in a operator call, and later, one operator call (head()) is parsed as a field access + empty tuple construction. So they "cancel each other out" and form a valid module.

module test {
  pure def foo(x) =
    pure val bar = x
    (bar, 1)

  pure def foo2(x) =
    pure val baz = x.head()
    x
}

is parsed as

module test {
  pure def foo(x) =
    pure val bar = x(bar, 1)
    pure def foo2(x) =
      pure val baz = x.head { Tup() }
    x
}

[bugarela]

Wrapping the first top-level def in curly braces fixes the problem:

module test {
  pure def foo(x) = {
    pure val bar = x
    (bar, 1)
  }

  pure def foo2(x) =
    pure val baz = x.head()
    x
}

[ivan-gavran]

I just stumbled upon a similar issue as @angbrav . I cannot create a minimal example (because I do not udnerstand what exactly is happening) so let me describe how/when the problem occurs.

• a function that returns a tuple
• if it just returns a tuple, all is good
• it if has one helper val, all is good
• if it has two helpers vals, a parsing error is reported that an existing function does not exist.
• as soon as I wrap all in curly braces, all is good again.

Is it an instance of the same error? To the best of my understanding, any number of helper vals before a single expression should be legal syntax

[bugarela]

@ivan-gavran I'd guess not the number of vals, but the content of them. Does any of them end with a char sequence like (.*)? If yes, then it is probably the same thing I described in here