Implement super operator calls

runtime/vm/parser.cc

 // Copyright (c) 2011, 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 1010 matching lines @@
   if (super_function.IsNull()) {
     ErrorMsg(supercall_pos,
              "function '%s' not found in super class",
              function_name.ToCString());
   }
   CheckFunctionIsCallable(supercall_pos, super_function);
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
+AstNode* Parser::ParseSuperOperator() {
+  AstNode* super_op = NULL;
+  const intptr_t operator_pos = token_index_;
+  const Class& super_class = Class::Handle(current_class().SuperClass());
+  if (super_class.IsNull()) {
+    ErrorMsg(operator_pos, "class '%s' does not have a superclass",
+             String::Handle(current_class().Name()).ToCString());
+  }
+
+  if (CurrentToken() == Token::kLBRACK) {
+    Unimplemented("Not yet implemented: super[expr]");
+  } else if (Token::CanBeOverloaded(CurrentToken())) {
+    Token::Kind op = CurrentToken();
+    ConsumeToken();
+
+    // Resolve the operator function in the superclass.
+    const String& operator_function_name =
+        String::ZoneHandle(String::NewSymbol(Token::Str(op)));
+    const Function& super_operator = Function::ZoneHandle(
+        ResolveDynamicFunction(super_class, operator_function_name));
+    if (super_operator.IsNull()) {
+      ErrorMsg(operator_pos, "operator '%s' not found in super class",
+               Token::Str(op));
+    }
+
+    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);
+    super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
+  }
+  return super_op;
+}
+
+
 AstNode* Parser::CreateImplicitClosureNode(const Function& func,
                                            intptr_t token_pos,
                                            AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(func.ImplicitClosureFunction());
   ASSERT(!implicit_closure_function.IsNull());
   ASSERT(implicit_closure_function.is_static());  // TODO(regis): For now.
   AstNode* node;
   if (receiver == NULL) {
     ASSERT(func.is_static());
@@ skipping 5577 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) {
-      Unimplemented("Don't know yet how to interpret super[expr]");
+    } else if (Token::CanBeOverloaded(CurrentToken())) {
+      primary = ParseSuperOperator();
     } else {
-      ErrorMsg("Expected '.' or '[' after super");
+      ErrorMsg("Illegal super call");
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
 // Evaluate expression in expr and return the value. The expression must
 // be a compile time constant.
@@ skipping 247 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart