Incorporating newline-as-statement-terminator heuristics into context-free languages
The basic problem we have to solve is how to separate sequences of statements

(A)
statement1
statement2


from multi-line statements

(B)
state
ment


Dedicated separators such as semicolons are a time-honored way to do this clearly 
but some people dislike them. An alternative is to require some kind of syntax 
for triggering (B) (I think I've seen state \ \nment) which is likely to be 
rejected for similar reasons.

So, one way to do this is to ensure that the set of statements is prefix-free, 
that is no statement of the form (B) can parse as (A) ever. Of course, that is 
rarely possible as you want to allow (improperly parenthesised) statements like

x = 3 - 2 + x


and at the same time blocks like

x = 3
- 2 + x
[returns 1]


Such languages (e.g. Scala) are inherently ambiguous on a syntactic level (without dedicated statement separators). On a semantic level, you may be able to resolve the ambiguity, e.g. you might figure out during name analysis that x is not initialised in reading (B) or during type analysis that the block should return an integer, which reading it as (B) may not do.

Needless to say that many dynamic languages don't even allow for this because all variables may be implicitly initialised or every statement returns something or what not.

In other words, I think this language "feature" is beyond the capabilities of PDAs if you don't want rigid precedences. You need backtracking, look-ahead,
semantic analysis and even guesswork.