Turn compile time errors related to missing getters and setters into invocation

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 2079 matching lines @@
                            Token::kSET,
                            arguments,
                            Array::ZoneHandle(),
                            2));  // Checked argument count.
   ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
-      String::Handle(Field::GetterName(node->field_name()));
+      String::ZoneHandle(Field::GetterSymbol(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);
-    ASSERT(!getter_function.IsNull());
     ASSERT(node->receiver() != NULL);
-    ValueGraphVisitor receiver_value(owner(), temp_index(), loop_depth());
-    node->receiver()->Visit(&receiver_value);
-    Append(receiver_value);
-    arguments->Add(PushArgument(receiver_value.value()));
+    getter_function = Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
+    if (getter_function.IsNull()) {
+      // Resolve and call noSuchMethod.
+      ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
+      arguments->Add(node->receiver());
+      StaticCallInstr* call = BuildStaticNoSuchMethodCall(node->cls(),
+                                                          node->receiver(),
+                                                          getter_name,
+                                                          arguments);
+      ReturnDefinition(call);
+      return;
+    } else {
+      ValueGraphVisitor receiver_value(owner(), temp_index(), loop_depth());
+      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
       // only by a static setter, but no corresponding static getter, it creates
       // a StaticGetterNode ast node referring to the non-existing static getter
       // for the case this field reference appears in a left hand side
       // expression (the parser has not distinguished between left and right
       // hand side yet at this stage). If the parser establishes later that the
       // field access is part of a left hand side expression, the
@@ skipping 29 matching lines @@
                                               getter_function,
                                               Array::ZoneHandle(),  // No names.
                                               arguments);
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
-      String::Handle(Field::SetterName(node->field_name()));
+      String::ZoneHandle(Field::SetterSymbol(node->field_name()));
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(1);
   // A super setter is an instance setter whose setter function is
   // resolved at compile time (in the caller instance getter's super class).
   // Unlike a static getter, a super getter has a receiver parameter.
   const bool is_super_setter = (node->receiver() != NULL);
-  const Function& setter_function =
+  Function& setter_function =
       Function::ZoneHandle(is_super_setter
           ? Resolver::ResolveDynamicAnyArgs(node->cls(), setter_name)
           : node->cls().LookupStaticFunction(setter_name));
-  ASSERT(!setter_function.IsNull());
+  StaticCallInstr* call;
+  if (setter_function.IsNull()) {
+    if (is_super_setter) {
+      ASSERT(node->receiver() != NULL);
+      // Resolve and call noSuchMethod.
+      ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
+      arguments->Add(node->receiver());
+      arguments->Add(node->value());
+      call = BuildStaticNoSuchMethodCall(node->cls(),
+                                         node->receiver(),
+                                         setter_name,
+                                         arguments);
+    } else {
+      // Throw a NoSuchMethodError.
+      // Location argument.
+      Value* call_pos = Bind(
+          new ConstantInstr(Smi::ZoneHandle(Smi::New(node->token_pos()))));
+      arguments->Add(PushArgument(call_pos));
+      // Function name argument.
+      const String& method_name = String::ZoneHandle(Symbols::New(setter_name));
+      Value* method_name_value = Bind(new ConstantInstr(method_name));
+      arguments->Add(PushArgument(method_name_value));
+      const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
+      const String& func_name = String::Handle(Symbols::ThrowNew());
+      const Class& cls = Class::Handle(
+          Library::Handle(Library::CoreLibrary()).LookupClass(cls_name));
+      ASSERT(!cls.IsNull());
+      setter_function = Resolver::ResolveStatic(cls,
+                                                func_name,
+                                                arguments->length(),
+                                                Array::ZoneHandle(),
+                                                Resolver::kIsQualified);
+      ASSERT(!setter_function.IsNull());
+      call = new StaticCallInstr(node->token_pos(),
+                                 setter_function,
+                                 Array::ZoneHandle(),  // No names.
+                                 arguments);
+    }
+  } else {
+    if (is_super_setter) {
+      // Add receiver of instance getter.
+      ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
+      node->receiver()->Visit(&for_receiver);
+      Append(for_receiver);
+      arguments->Add(PushArgument(for_receiver.value()));
+    }
+    ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
+    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));
 
-  ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new ZoneGrowableArray<PushArgumentInstr*>(1);
-  if (is_super_setter) {
-    // Add receiver of instance getter.
-    ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
-    node->receiver()->Visit(&for_receiver);
-    Append(for_receiver);
-    arguments->Add(PushArgument(for_receiver.value()));
+    call = new StaticCallInstr(node->token_pos(),
+                               setter_function,
+                               Array::ZoneHandle(),  // No names.
+                               arguments);
   }
-  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
-  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));
-
-  StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
-                                              setter_function,
-                                              Array::ZoneHandle(),  // No names.
-                                              arguments);
   if (result_is_needed) {
     Do(call);
     ReturnDefinition(BuildLoadExprTemp());
   } else {
     ReturnDefinition(call);
   }
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
@@ skipping 162 matching lines @@
   Function* super_function = NULL;
   if (node->IsSuperLoad()) {
     // Resolve the load indexed operator in the super class.
     super_function = &Function::ZoneHandle(
           Resolver::ResolveDynamicAnyArgs(node->super_class(),
                                           Symbols::IndexTokenHandle()));
     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->array());
       arguments->Add(node->index_expr());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
                                       Symbols::IndexTokenHandle(),
                                       arguments);
       ReturnDefinition(call);
       return;
     }
   }
@@ skipping 44 matching lines @@
       // 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(), loop_depth());
         node->value()->Visit(&for_value);
         Append(for_value);
         Bind(BuildStoreExprTemp(for_value.value()));
       }
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
+      arguments->Add(node->array());
       arguments->Add(node->index_expr());
       arguments->Add(node->value());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
                                       Symbols::AssignIndexTokenHandle(),
                                       arguments);
       if (result_is_needed) {
         Do(call);
         return BuildLoadExprTemp();
@@ skipping 506 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