Change compile-time errors into dynamic errors in instance creation expression

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 1976 matching lines @@
     getter_function =
     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);
-    ASSERT(!getter_function.IsNull());
+    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
+      // StaticGetterNode is transformed into a StaticSetterNode referring to
+      // the existing static setter.
+      // However, if the field reference appears in a right hand side
+      // expression, no such transformation occurs and we land here with a
+      // StaticGetterNode missing a getter function, so we 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(getter_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::CoreImplLibrary()).LookupClass(cls_name));
+      ASSERT(!cls.IsNull());
+      getter_function = Resolver::ResolveStatic(cls,
+                                                func_name,
+                                                arguments->length(),
+                                                Array::ZoneHandle(),
+                                                Resolver::kIsQualified);
+      ASSERT(!getter_function.IsNull());
+    }
   }
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               getter_function,
                                               Array::ZoneHandle(),  // No names.
                                               arguments);
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
@@ skipping 635 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