Dart VM: Simplify code generation for equality operators.

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 1905 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);
     }
-    if (super_operator.name() == Symbols::EqualOperator().raw()) {
-      // Expand super.== call to match correct == semantics into:
-      // 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);
-    }
+    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 884 matching lines @@
         // instantiate types.
         CaptureInstantiator();
       }
     }
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
+    if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
+      const Class& owner = Class::Handle(func.Owner());
+      if (!owner.IsObjectClass()) {
+        AddEqualityNullCheck();
+      }
+    }
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
+    if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
+      const Class& owner = Class::Handle(func.Owner());
+      if (!owner.IsObjectClass()) {
+        AddEqualityNullCheck();
+      }
+    }
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
     end_token_pos = TokenPos();
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);

[hausner, 2013/09/25 16:36:11]

This is a nit, but your scheme does not work for native implementations of ==. I
am fine with that. Native implementations just have to do the null check
themselves. 

[Florian Schneider, 2013/09/26 11:34:21]

Good point. Right now, native methods contain just the NativeCall node. To be
consistent, I'll add the check to the AST  of the native method body, so that
the native implementations are never called with null arguments.

     end_token_pos = TokenPos();
     ExpectSemicolon();
   } else if (func.is_external()) {
     // Body of an external method contains a single throw.
     const String& function_name = String::ZoneHandle(func.name());
     // TODO(regis): For an instance function, pass the receiver to
     // NoSuchMethodError.
     current_block_->statements->Add(
         ThrowNoSuchMethodError(TokenPos(),
                                current_class(),
@@ skipping 12 matching lines @@
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   return CloseBlock();
 }
 
 
+void Parser::AddEqualityNullCheck() {
+  const intptr_t token_pos = Scanner::kDummyTokenIndex;
+  AstNode* argument =
+      new LoadLocalNode(token_pos,
+                        current_block_->scope->parent()->VariableAt(1));
+  LiteralNode* null_operand =
+      new LiteralNode(token_pos, Instance::ZoneHandle());
+  ComparisonNode* check_arg = new ComparisonNode(token_pos,
+                                                 Token::kEQ_STRICT,
+                                                 argument,
+                                                 null_operand);
+  ComparisonNode* result = new ComparisonNode(token_pos,
+                                              Token::kEQ_STRICT,
+                                              LoadReceiver(token_pos),
+                                              null_operand);
+  SequenceNode* arg_is_null = new SequenceNode(token_pos, NULL);
+  arg_is_null->Add(new ReturnNode(token_pos, result));
+  IfNode* if_arg_null = new IfNode(token_pos,
+                                   check_arg,
+                                   arg_is_null,
+                                   NULL);
+  current_block_->statements->Add(if_arg_null);
+}
+
+
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
   }
 }
 
 
 // Skips tokens up to matching closing parenthesis.
 void Parser::SkipToMatchingParenthesis() {
   ASSERT(CurrentToken() == Token::kLPAREN);
@@ skipping 7584 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart