Handle super != and ?

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1445 matching lines @@
       operator_args->Add(index_expr);
       operator_args->Add(value);
 
       if (is_no_such_method) {
         operator_args = BuildNoSuchMethodArguments(assign_index_operator_name,
                                                    *operator_args);
       }
       super_op = new StaticCallNode(
           operator_pos, assign_index_operator, operator_args);
     }
-  } else if (Token::CanBeOverloaded(CurrentToken())) {
+  } else if (Token::CanBeOverloaded(CurrentToken()) ||
+             (CurrentToken() == Token::kNE)) {
     Token::Kind op = CurrentToken();
     ConsumeToken();
 
+    bool negate_result = false;
+    if (op == Token::kNE) {
+      op = Token::kEQ;
+      negate_result = true;
+    }
+
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
         String::Handle(Symbols::New(Token::Str(op)));
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          operator_function_name,
                          kResolveGetter,
                          &is_no_such_method));
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kBIT_OR));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     op_arguments->Add(receiver);
     op_arguments->Add(other_operand);
 
     CheckFunctionIsCallable(operator_pos, super_operator);
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(operator_function_name,
                                                 *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,
                                            AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(func.ImplicitClosureFunction());
@@ skipping 7916 matching lines @@
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
-        Token::CanBeOverloaded(CurrentToken())) {
+        Token::CanBeOverloaded(CurrentToken()) ||
+        (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else {
       ErrorMsg("illegal super call");
     }
   } else if (CurrentToken() == Token::kCONDITIONAL) {
     primary = ParseArgumentDefinitionTest();
   } else {
     UnexpectedToken();
   }
   return primary;
@@ skipping 183 matching lines @@
       } else {
         SkipNewOperator();
       }
       break;
     case Token::kLT:
     case Token::kLBRACE:
     case Token::kLBRACK:
     case Token::kINDEX:
       SkipCompoundLiteral();
       break;
+    case Token::kCONDITIONAL:
+      ConsumeToken();
+      if (IsIdentifier()) {
+        ConsumeToken();
+      }
+      break;
     default:
       if (IsIdentifier()) {
         ConsumeToken();  // Handle pseudo-keyword identifiers.
       } else {
         UnexpectedToken();
         UNREACHABLE();
       }
       break;
   }
 }
@@ skipping 96 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart