There are some design decisions to be made here.

Currently, a statement beginning with var is either:

• a VarDeclStmt, whose LHS consists of some number of identifiers and whose RHS is allowed to be a method call, among other things
• a LetStmt, whose LHS consists of a tuple of patterns, and whose RHS must be an expression (in particular, not a method call)

The concrete gotcha raised by this issue is that a LetStmt requires it's LHS to be a tuple of patterns, not an arbitrary pattern. The obvious solution is to allow an arbitrary pattern on the LHS of a LetStmt while retaining the distinction between VarDeclStmt and LetStmt. There are some subtleties, though. For example,

var Foo := Bar();

• Bar might be a function method or a method.
• Foo might be the name of a parameterless constructor or not

If Bar is a method, then this must be VarDeclStmt, and the LHS always means "introduce a local variable named Foo, even if Foo is the name of a constructor.

If Bar is a function method and Foo is the name of a parameterless constructor, then this is a syntactically valid LetStmt, but is rejected by the resolver since its pattern doesn't introduce any bound variables.

While we're at it, it seems natural to want pattern matching on the LHS of a VarDeclStmt as well. Then we could do things like this:

method Line() returns (start: Point, end: Point)
{
    start := Point(0, 0);
    end := Point(1, 1);
}

method UseLine()
{
    var Point(x0, y0), Point(x1, y1) := Line();
}

This has its own problems though. For example, I think it would make it impossible to shadow the name of a parameterless constructor.

For now, I think I will see if I can get arbitrary patterns working in LetStmts, and see what troubles I run into.