More fixes for super[]

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 1984 matching lines @@
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     getter_function =
-    Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
+        Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
     ASSERT(!getter_function.IsNull());
     ASSERT(node->receiver() != NULL);
     ValueGraphVisitor receiver_value(owner(), temp_index());
     node->receiver()->Visit(&receiver_value);
     Append(receiver_value);
     arguments->Add(PushArgument(receiver_value.value()));
   } else {
     getter_function = node->cls().LookupStaticFunction(getter_name);
     if (getter_function.IsNull()) {
       // When the parser encounters a reference to a static field materialized
@@ skipping 242 matching lines @@
   ReturnDefinition(BuildStoreStaticField(node, kResultNotNeeded));
 }
 
 
 void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(BuildStoreStaticField(node, kResultNeeded));
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
+  Function* super_function = NULL;
+  if (node->IsSuperLoad()) {
+    // Resolve the load indexed operator in the super class.
+    const String& index_operator_name =
+        String::ZoneHandle(Symbols::IndexToken());
+    super_function = &Function::ZoneHandle(
+          Resolver::ResolveDynamicAnyArgs(node->super_class(),
+                                          index_operator_name));
+    if (super_function->IsNull()) {
+      // Could not resolve super operator. Generate call noSuchMethod() of the
+      // super class instead.
+      ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
+      arguments->Add(node->index_expr());
+      BuildStaticNoSuchMethodCall(node->super_class(),
+                                  node->array(),
+                                  index_operator_name,
+                                  arguments);
+      return;
+    }
+  }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
-  const intptr_t checked_argument_count = 1;
-  const String& name =
-      String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
-  InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
-                                                  name,
-                                                  Token::kINDEX,
-                                                  arguments,
-                                                  Array::ZoneHandle(),
-                                                  checked_argument_count);
-  ReturnDefinition(load);
+  if (super_function != NULL) {
+    // Generate static call to super operator.
+    StaticCallInstr* load = new StaticCallInstr(node->token_pos(),
+                                                *super_function,
+                                                Array::ZoneHandle(),
+                                                arguments);
+    ReturnDefinition(load);
+  } else {
+    // Generate dynamic call to index operator.
+    const intptr_t checked_argument_count = 1;
+    const String& name = String::ZoneHandle(Symbols::IndexToken());
+    InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
+                                                    name,
+                                                    Token::kINDEX,
+                                                    arguments,
+                                                    Array::ZoneHandle(),
+                                                    checked_argument_count);
+    ReturnDefinition(load);
+  }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
+  Function* super_function = NULL;
+  if (node->IsSuperStore()) {
+    // Resolve the store indexed operator in the super class.
+    const String& store_index_op_name =
+        String::ZoneHandle(Symbols::AssignIndexToken());
+    super_function = &Function::ZoneHandle(
+        Resolver::ResolveDynamicAnyArgs(node->super_class(),
+                                        store_index_op_name));
+    if (super_function->IsNull()) {
+      // Could not resolve super operator. Generate call noSuchMethod() of the
+      // super class instead.
+      if (result_is_needed) {
+        // Even though noSuchMethod most likely does not return,
+        // we save the stored value if the result is needed.
+        ValueGraphVisitor for_value(owner(), temp_index());
+        node->value()->Visit(&for_value);
+        Append(for_value);
+        Bind(BuildStoreExprTemp(for_value.value()));
+      }
+      ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
+      arguments->Add(node->index_expr());
+      arguments->Add(node->value());
+      StaticCallInstr* call =
+          BuildStaticNoSuchMethodCall(node->super_class(),
+                                      node->array(),
+                                      store_index_op_name,
+                                      arguments);
+      if (result_is_needed) {
+        Do(call);
+        return BuildLoadExprTemp();
+      } else {
+        return call;
+      }
+    }
+  }
+
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
-  const intptr_t checked_argument_count = 3;
-  const String& name =
-      String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
-  InstanceCallInstr* store = new InstanceCallInstr(node->token_pos(),
-                                                   name,
-                                                   Token::kASSIGN_INDEX,
-                                                   arguments,
-                                                   Array::ZoneHandle(),
-                                                   checked_argument_count);
-  if (result_is_needed) {
-    Do(store);
-    return BuildLoadExprTemp();
+  if (super_function != NULL) {
+    // Generate static call to super operator []=.
+
+    StaticCallInstr* store =
+        new StaticCallInstr(node->token_pos(),
+                            *super_function,
+                            Array::ZoneHandle(),
+                            arguments);
+    if (result_is_needed) {
+      Do(store);
+      return BuildLoadExprTemp();
+    } else {
+      return store;
+    }
   } else {
-    return store;
+    // Generate dynamic call to operator []=.
+    const intptr_t checked_argument_count = 3;
+    const String& name =
+        String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
+    InstanceCallInstr* store =
+        new InstanceCallInstr(node->token_pos(),
+                              name,
+                              Token::kASSIGN_INDEX,
+                              arguments,
+                              Array::ZoneHandle(),
+                              checked_argument_count);
+    if (result_is_needed) {
+      Do(store);
+      return BuildLoadExprTemp();
+    } else {
+      return store;
+    }
   }
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNotNeeded));
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
@@ skipping 233 matching lines @@
 
   // Generate code for the finally block if one exists.
   if ((node->finally_block() != NULL) && is_open()) {
     EffectGraphVisitor for_finally_block(owner(), temp_index());
     node->finally_block()->Visit(&for_finally_block);
     Append(for_finally_block);
   }
 }
 
 
+// Looks up dynamic method noSuchMethod in target_class
+// (including its super class chain) and builds a static call to it.
+StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
+      const Class& target_class,
+      AstNode* receiver,
+      const String& method_name,
+      ArgumentListNode* method_arguments) {
+  const String& no_such_method_name =
+      String::ZoneHandle(Symbols::NoSuchMethod());
+  const Function& no_such_method_func = Function::ZoneHandle(
+      Resolver::ResolveDynamicAnyArgs(target_class, no_such_method_name));
+  // We are guaranteed to find noSuchMethod of class Object.
+  ASSERT(!no_such_method_func.IsNull());
+
+  const intptr_t args_pos = method_arguments->token_pos();
+  ArgumentListNode* arguments = new ArgumentListNode(args_pos);
+  // The first argument is the receiver.
+  arguments->Add(receiver);
+  // The second argument is the original method name.
+  // TODO(regis): This will change once mirrors are supported.
+  arguments->Add(new LiteralNode(args_pos, method_name));
+  // The third argument is an array containing the original method arguments.
+  ArrayNode* args_array =
+      new ArrayNode(args_pos, Type::ZoneHandle(Type::ListInterface()));
+  for (intptr_t i = 0; i < method_arguments->length(); i++) {
+    args_array->AddElement(method_arguments->NodeAt(i));
+  }
+  arguments->Add(args_array);
+
+  ZoneGrowableArray<PushArgumentInstr*>* args =
+      new ZoneGrowableArray<PushArgumentInstr*>(arguments->length());
+  BuildPushArguments(*arguments, args);
+  return new StaticCallInstr(args_pos,
+                             no_such_method_func,
+                             Array::ZoneHandle(),
+                             args);
+}
+
+
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   // TODO(kmillikin) non-local control flow is not handled correctly
   // by the inliner.
   InlineBailout("EffectGraphVisitor::BuildThrowNode (exception)");
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
@@ skipping 98 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart