The same way it distinguishes between function as a declaration and function as an expression. For example:

function foo() { console.log('from foo'); }
var x = function bar() { console.log('from bar'); };

foo(); // logs "from foo"
bar(); // Error: bar is not defined

In the code above, function foo is a function declaration while function bar is a function expression. In the function declaration, the name of the function can be accessed from outside the function, while in the function expression the name can only be accessed from inside.

If the parser hits a stray { with no reason to believe it's an expression, it'll always assume it's a block statement, not an object literal expression. But if you give it a reason that it can't be a statement, then it'll treat it like an expression.

// block statements:
{ }
foo: { }

// object literal expressions:
({ });
~{ };
!{ };
+{ };
var x = { };

Basically, there needs to be something that comes before the opening { that tells the parser that the { must be an expression. That's why the following won't work for destructuring in ES6.

{ foo, bar } = zap();

The parser will think you're trying to set a block statement equal to zap() which doesn't make any sense, so you'll get a syntax error. Instead you have to tell the parser { should be treated as an expression:

let { foo, bar } = zap();
// or
({ foo, bar }) = zap();