More fixes for super[]

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 1377 matching lines @@
 
 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);
-
-    if (Token::IsAssignmentOperator(CurrentToken()) &&
-        (CurrentToken() != Token::kASSIGN)) {
-      // Compound assignment. Ensure side effects in index expression
-      // only execute once. If the index is not a local variable or an
-      // literal, evaluate and save in a temporary local.
-      if (!IsSimpleLocalOrLiteralNode(index_expr)) {
-        LocalVariable* temp =
-            CreateTempConstVariable(operator_pos, "lix");
-        AstNode* save = new StoreLocalNode(operator_pos, temp, index_expr);
-        current_block_->statements->Add(save);
-        index_expr = new LoadLocalNode(operator_pos, temp);
-      }
-    }
-
-    // Resolve the [] operator function in the superclass.
-    const String& index_operator_name =
-        String::ZoneHandle(Symbols::IndexToken());
-    const bool kResolveGetter = false;
-    bool is_no_such_method = false;
-    const Function& index_operator = Function::ZoneHandle(
-        GetSuperFunction(operator_pos,
-                         index_operator_name,
-                         kResolveGetter,
-                         &is_no_such_method));
-
-    ArgumentListNode* index_op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
-    index_op_arguments->Add(receiver);
-    index_op_arguments->Add(index_expr);
-
-    if (is_no_such_method) {
-      index_op_arguments = BuildNoSuchMethodArguments(index_operator_name,
-                                                      *index_op_arguments);
-    }
-    super_op = new StaticCallNode(
-        operator_pos, index_operator, index_op_arguments);
-
-    if (Token::IsAssignmentOperator(CurrentToken())) {
-      Token::Kind assignment_op = CurrentToken();
-      ConsumeToken();
-      AstNode* value = ParseExpr(kAllowConst, kConsumeCascades);
-
-      value = ExpandAssignableOp(operator_pos, assignment_op, super_op, value);
-
-      // Resolve the []= operator function in the superclass.
-      const String& assign_index_operator_name =
-          String::ZoneHandle(Symbols::AssignIndexToken());
-      const bool kResolveGetter = false;
-      bool is_no_such_method = false;
-      const Function& assign_index_operator = Function::ZoneHandle(
-          GetSuperFunction(operator_pos,
-                           assign_index_operator_name,
-                           kResolveGetter,
-                           &is_no_such_method));
-
-      ArgumentListNode* operator_args = new ArgumentListNode(operator_pos);
-      operator_args->Add(LoadReceiver(operator_pos));
-      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);
-    }
+    const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
+    ASSERT(!super_class.IsNull());
+    super_op =
+        new LoadIndexedNode(operator_pos, receiver, index_expr, super_class);
   } 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;
     }
@@ skipping 5453 matching lines @@
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* left_node = node->AsLoadIndexedNode();
     LoadIndexedNode* right_node = left_node;
     intptr_t token_pos = node->token_pos();
     node = NULL;  // Do not use it.
     if (!IsSimpleLocalOrLiteralNode(left_node->array())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_pos, "lia");
       StoreLocalNode* save =
           new StoreLocalNode(token_pos, temp, left_node->array());
-      left_node =
-          new LoadIndexedNode(token_pos, save, left_node->index_expr());
+      left_node = new LoadIndexedNode(token_pos,
+                                      save,
+                                      left_node->index_expr(),
+                                      left_node->super_class());
       right_node = new LoadIndexedNode(token_pos,
                                        new LoadLocalNode(token_pos, temp),
-                                       right_node->index_expr());
+                                       right_node->index_expr(),
+                                       right_node->super_class());
     }
     if (!IsSimpleLocalOrLiteralNode(left_node->index_expr())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_pos, "lix");
       StoreLocalNode* save =
           new StoreLocalNode(token_pos, temp, left_node->index_expr());
       left_node = new LoadIndexedNode(token_pos,
                                       left_node->array(),
-                                      save);
+                                      save,
+                                      left_node->super_class());
       right_node = new LoadIndexedNode(token_pos,
                                        right_node->array(),
-                                       new LoadLocalNode(token_pos, temp));
+                                       new LoadLocalNode(token_pos, temp),
+                                       right_node->super_class());
     }
     *expr = right_node;
     return left_node;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* left_node = node->AsInstanceGetterNode();
     InstanceGetterNode* right_node = left_node;
     intptr_t token_pos = node->token_pos();
     node = NULL;  // Do not use it.
     if (!IsSimpleLocalOrLiteralNode(left_node->receiver())) {
@@ skipping 540 matching lines @@
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
           array = LoadClosure(primary);
         } else if (primary->primary().IsClass()) {
           ErrorMsg(bracket_pos, "cannot apply index operator to class");
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
-      selector = new LoadIndexedNode(bracket_pos, array, index);
+      selector =  new LoadIndexedNode(bracket_pos,
+                                      array,
+                                      index,
+                                      Class::ZoneHandle());
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         const intptr_t primary_pos = primary->token_pos();
         if (primary->primary().IsFunction()) {
           Function& func = Function::CheckedHandle(primary->primary().raw());
           String& func_name = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(func.Owner());
@@ skipping 1975 matching lines @@
     }
   } else if (CurrentToken() == Token::kLT ||
              CurrentToken() == Token::kLBRACK ||
              CurrentToken() == Token::kINDEX ||
              CurrentToken() == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
   } else if (CurrentToken() == Token::kSUPER) {
     if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     }
+    if (current_class().SuperClass() == Class::null()) {
+      ErrorMsg("class '%s' does not have a superclass",
+               String::Handle(current_class().Name()).ToCString());
+    }
     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) ||
@@ skipping 317 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart