Handle super call to unary 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1368 matching lines @@
   if (node->IsLiteralNode()) {
     return true;
   }
   if (node->IsLoadLocalNode() && !node->AsLoadLocalNode()->HasPseudo()) {
     return true;
   }
   return false;
 }
 
 
+AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
+  ASSERT(super->IsSuper());
+  AstNode* super_op = NULL;
+  const intptr_t super_pos = super->token_pos();
+  if ((op == Token::kNEGATE) ||
+      (op == Token::kBIT_NOT)) {
+    // Resolve the operator function in the superclass.
+    const String& operator_function_name =
+        String::ZoneHandle(Symbols::New(Token::Str(op)));
+    const bool kResolveGetter = false;
+    bool is_no_such_method = false;
+    const Function& super_operator = Function::ZoneHandle(
+        GetSuperFunction(super_pos,
+                         operator_function_name,
+                         kResolveGetter,
+                         &is_no_such_method));
+    ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
+    AstNode* receiver = LoadReceiver(super_pos);
+    op_arguments->Add(receiver);
+    CheckFunctionIsCallable(super_pos, super_operator);
+    if (is_no_such_method) {
+      op_arguments = BuildNoSuchMethodArguments(operator_function_name,
+                                                *op_arguments);
+    }
+    super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
+  } else {
+    ErrorMsg(super_pos, "illegal super operator call");
+  }
+  return super_op;
+}
+
+
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const intptr_t operator_pos = TokenPos();
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
     AstNode* receiver = LoadReceiver(operator_pos);
@@ skipping 5251 matching lines @@
   const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
   const String& func_name = String::Handle(Symbols::ThrowNew());
   return MakeStaticCall(cls_name, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
+  if (left_operand->IsPrimaryNode() &&
+      (left_operand->AsPrimaryNode()->IsSuper())) {
+    ErrorMsg(left_operand->token_pos(), "illegal use of 'super'");
+  }
   if (IsLiteral("as")) {  // Not a reserved word.
     token_kind_ = Token::kAS;
   }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
       if (op_kind == Token::kTIGHTADD) {
         op_kind = Token::kADD;
       }
@@ skipping 43 matching lines @@
             op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
 bool Parser::IsAssignableExpr(AstNode* expr) {
-  return expr->IsPrimaryNode()
-      || (expr->IsLoadLocalNode() && !expr->AsLoadLocalNode()->HasPseudo())
+  return (expr->IsLoadLocalNode() && !expr->AsLoadLocalNode()->HasPseudo())
       || expr->IsLoadStaticFieldNode()
       || expr->IsStaticGetterNode()
       || expr->IsInstanceGetterNode()
-      || expr->IsLoadIndexedNode();
+      || expr->IsLoadIndexedNode()
+      || (expr->IsPrimaryNode() && !expr->AsPrimaryNode()->IsSuper());
 }
 
 
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
   AstNode* expressions = ParseExpr(kAllowConst, kConsumeCascades);
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
     SequenceNode* list = new SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
@@ skipping 336 matching lines @@
       unary_op = Token::kNEGATE;
     }
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (unary_op == Token::kTIGHTADD) {
       // kTIGHADD is added only in front of a number literal.
       if (!expr->IsLiteralNode()) {
         ErrorMsg(op_pos, "unexpected operator '+'");
       }
       // Expression is the literal itself.
+    } else if (expr->IsPrimaryNode() && (expr->AsPrimaryNode()->IsSuper())) {
+      expr = BuildUnarySuperOperator(unary_op, expr->AsPrimaryNode());
     } else {
       expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
     }
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (!IsAssignableExpr(expr)) {
       ErrorMsg("expression is not assignable");
     }
@@ skipping 247 matching lines @@
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
     return node;
   }
   PrimaryNode* primary = node->AsPrimaryNode();
   if (primary->primary().IsString()) {
+    if (primary->IsSuper()) {
+      return primary;
+    }
     // In a static method, evaluation of an unresolved identifier causes a
     // NoSuchMethodError to be thrown.
     // In an instance method, we convert this into a getter call
     // for a field (which may be defined in a subclass.)
     String& name = String::CheckedZoneHandle(primary->primary().raw());
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       return ThrowNoSuchMethodError(primary->token_pos(), name);
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
@@ skipping 31 matching lines @@
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         if (left->AsPrimaryNode()->primary().IsFunction()) {
           left = LoadClosure(left->AsPrimaryNode());
         } else {
+          // Super field access handled in ParseSuperFieldAccess(),
+          // super calls handled in ParseSuperCall().
+          ASSERT(!left->AsPrimaryNode()->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const intptr_t ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         // Identifier followed by a opening paren: method call.
         if (left->IsPrimaryNode()
             && left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
@@ skipping 17 matching lines @@
         if (cls.IsNull()) {
           // Instance field access.
           selector = CallGetter(ident_pos, left, *ident);
         } else {
           // Static field access.
           selector =
               ParseStaticFieldAccess(cls, *ident, ident_pos, !is_cascade);
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
+      // Super index operator handled in ParseSuperOperator().
+      ASSERT(!left->IsPrimaryNode() || !left->AsPrimaryNode()->IsSuper());
+
       const intptr_t bracket_pos = TokenPos();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
       AstNode* index = ParseExpr(kAllowConst, kConsumeCascades);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
@@ skipping 25 matching lines @@
             if (current_function().is_static()) {
               ErrorMsg(primary_pos,
                        "cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
         } else if (primary->primary().IsString()) {
           // Primary is an unresolved name.
+          if (primary->IsSuper()) {
+            ErrorMsg(primary->token_pos(), "illegal use of super");
+          }
           String& name = String::CheckedZoneHandle(primary->primary().raw());
           if (current_function().is_static()) {
             selector = ThrowNoSuchMethodError(primary->token_pos(), name);
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_pos());
             selector = ParseInstanceCall(receiver, name);
           }
         } else if (primary->primary().IsClass()) {
           ErrorMsg(left->token_pos(),
@@ skipping 14 matching lines @@
         if (primary->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary);
         } else if (left->AsPrimaryNode()->primary().IsClass()) {
           Class& cls = Class::CheckedHandle(
               left->AsPrimaryNode()->primary().raw());
           String& cls_name = String::Handle(cls.Name());
           ErrorMsg(left->token_pos(),
                    "illegal use of class name '%s'",
                    cls_name.ToCString());
+        } else if (primary->IsSuper()) {
+          // Return "super" to handle unary super operator calls,
+          // or to report illegal use of "super" otherwise.
+          left = primary;
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       // Done parsing selectors.
       return left;
     }
     ASSERT(selector != NULL);
     left = selector;
   }
@@ skipping 1936 matching lines @@
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
         Token::CanBeOverloaded(CurrentToken()) ||
         (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else {
-      ErrorMsg("illegal super call");
+      primary = new PrimaryNode(TokenPos(),
+                                String::ZoneHandle(Symbols::Super()));
     }
   } else if (CurrentToken() == Token::kCONDITIONAL) {
     primary = ParseArgumentDefinitionTest();
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
@@ skipping 302 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart