Remove inlining restriction of calls to the == operator.

Remove inlining restriction of calls to the == operator.

This CL is the first step in enabling full inlining of == calls.
Previously, calls to any function with the name "==" were not considered
for inlining because super-calls were not handled correctly. Instead
  of implementing == semantics for super calls in the back-end, the parser
now expands super calls to == into 

let t1 = left, t2 = right {
  (t1 === null  || t2 === null) ? t1 === t2
                                : static_call(super.==, t1, t2)
}

This change removes a bit of platform-specific assembly. Normal instance calls
to == are still translated as before. Expanding those at the AST level would
incur a too high cost in terms of (unoptimized) code size, and also would be
an obstruction for optimizations of equality. The plan is to expand those
only at optimization time if there is an inlineable instance call to ==.

R=kmillikin@google.com

Committed: https://code.google.com/p/dart/source/detail?r=27248

[Kevin Millikin (Google), 2013-09-06 12:41:09]

LGTM, with a suggestion to try out.

https://codereview.chromium.org/23627009/diff/1/runtime/vm/parser.cc
File runtime/vm/parser.cc (right):

https://codereview.chromium.org/23627009/diff/1/runtime/vm/parser.cc#newcode1908
runtime/vm/parser.cc:1908: // Expand super.== call to match correct == semantics
into:
Is it better to expand this as:
let t1 = left, t2 = right {
  (t1 === null)
      ? (t2 === null)  // or (t1 === t2)
      : (t2 !== null) && static_call(...)
}

The AST seems to be the same size and the optimizing compiler should optimizer
your version, but mine might be more direct for unoptimized code.

[Florian Schneider, 2013-09-06 13:56:18]

Committed patchset #1 manually as r27248 (presubmit successful).

[Florian Schneider, 2013-09-06 13:56:26]

https://codereview.chromium.org/23627009/diff/1/runtime/vm/parser.cc
File runtime/vm/parser.cc (right):

https://codereview.chromium.org/23627009/diff/1/runtime/vm/parser.cc#newcode1908
runtime/vm/parser.cc:1908: // Expand super.== call to match correct == semantics
into:
On 2013/09/06 12:41:09, kmillikin wrote:
> Is it better to expand this as:
> let t1 = left, t2 = right {
>   (t1 === null)
>       ? (t2 === null)  // or (t1 === t2)
>       : (t2 !== null) && static_call(...)
> }
> 
> The AST seems to be the same size and the optimizing compiler should optimizer
> your version, but mine might be more direct for unoptimized code.

I'll leave it as is for now.