Remove inlining restriction of calls to the == operator.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1886 matching lines @@
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          operator_function_name,
                          op_arguments,
                          kResolveGetter,
                          &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           operator_pos, operator_function_name, *op_arguments);
     }
-    super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
+    if (super_operator.name() == Symbols::EqualOperator().raw()) {
+      // Expand super.== call to match correct == semantics into:

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

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:26]

I'll leave it as is for now.

+      // Let t1 = left, t2 = right {
+      //   (t1 === null  || t2 === null) ? t1 === t2
+      //                                 : static_call(super.==, t1, t2)
+      // }
+      // Normal == calls are not expanded at the AST level to produce
+      // more compact code and enable more optimization opportunities.
+      ASSERT(!is_no_such_method);  // == is always found.
+      EnsureExpressionTemp();  // Needed for ConditionalExprNode.
+      LetNode* result = new LetNode(operator_pos);
+      AstNode* left =
+          new LoadLocalNode(operator_pos,
+                            result->AddInitializer(op_arguments->NodeAt(0)));
+      AstNode* right =
+          new LoadLocalNode(operator_pos,
+                            result->AddInitializer(op_arguments->NodeAt(1)));
+      LiteralNode* null_operand =
+          new LiteralNode(operator_pos, Instance::ZoneHandle());
+      ComparisonNode* is_left_null = new ComparisonNode(operator_pos,
+                                                        Token::kEQ_STRICT,
+                                                        left,
+                                                        null_operand);
+      ComparisonNode* is_right_null = new ComparisonNode(operator_pos,
+                                                         Token::kEQ_STRICT,
+                                                         right,
+                                                         null_operand);
+      BinaryOpNode* null_check = new BinaryOpNode(operator_pos,
+                                                  Token::kOR,
+                                                  is_left_null,
+                                                  is_right_null);
+      ArgumentListNode* new_arguments = new ArgumentListNode(operator_pos);
+      new_arguments->Add(left);
+      new_arguments->Add(right);
+      StaticCallNode* call = new StaticCallNode(operator_pos,
+                                                super_operator,
+                                                new_arguments);
+      ComparisonNode* strict_eq = new ComparisonNode(operator_pos,
+                                                     Token::kEQ_STRICT,
+                                                     left,
+                                                     right);
+      result->AddNode(new ConditionalExprNode(operator_pos,
+                                              null_check,
+                                              strict_eq,
+                                              call));
+      super_op = result;
+    } else {
+      super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
+    }
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
 
 AstNode* Parser::CreateImplicitClosureNode(const Function& func,
                                            intptr_t token_pos,
@@ skipping 8585 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart