Make AST generation deterministic: always call a static getter if it exists, regardless if the stat…

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 8039 matching lines @@
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   if (current_function().is_static() &&
       !current_function().IsInFactoryScope()) {
     return false;
   }
   return current_class().NumTypeParameters() > 0;
 }
 
 
-// If the field is already initialized, return no ast (NULL).
-// Otherwise, if the field is constant, initialize the field and return no ast.
-// If the field is not initialized and not const, return the ast for the getter.
+
+// If the field is constant, initialize the field if necessary and return
+// no ast (NULL).
+// Otherwise return NULL if no implicit getter exists (either never created
+// because trivial, or not needed or field not readable).
 AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
+  const Class& field_owner = Class::ZoneHandle(field.owner());
+  const String& field_name = String::ZoneHandle(field.name());
+  const String& getter_name = String::Handle(Field::GetterName(field_name));
+  const Function& getter =
+      Function::Handle(field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
-               String::Handle(field.name()).ToCString());
+               field_name.ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
       return new StaticGetterNode(TokenPos(),
                                   NULL,
                                   false,
-                                  Class::ZoneHandle(field.owner()),
-                                  String::ZoneHandle(field.name()));
+                                  field_owner,
+                                  field_name);
     }
   } else if (value.raw() == Object::sentinel().raw()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
-      const String& field_name = String::Handle(field.name());
-      const String& getter_name =
-          String::Handle(Field::GetterName(field_name));
-      const Class& cls = Class::Handle(field.owner());
       const int kNumArguments = 0;  // no arguments.
       const Function& func =
-          Function::Handle(Resolver::ResolveStatic(cls,
+          Function::Handle(Resolver::ResolveStatic(field_owner,
                                                    getter_name,
                                                    kNumArguments,
                                                    Object::empty_array(),
                                                    Resolver::kIsQualified));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
       Object& const_value = Object::Handle(
           DartEntry::InvokeFunction(func, Object::empty_array()));
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
@@ skipping 12 matching lines @@
           isolate()->long_jump_base()->Jump(1, error);
         }
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle();
       instance ^= const_value.raw();
       if (!instance.IsNull()) {
         instance ^= instance.Canonicalize();
       }
       field.set_value(instance);
+      return NULL;   // Constant
     } else {
       return new StaticGetterNode(TokenPos(),
                                   NULL,
                                   false,
-                                  Class::ZoneHandle(field.owner()),
-                                  String::ZoneHandle(field.name()));
+                                  field_owner,
+                                  field_name);
     }
   }
-  return NULL;
+  if (getter.IsNull() || (getter.kind() == RawFunction::kConstImplicitGetter)) {
+    return NULL;
+  }
+  ASSERT(getter.kind() == RawFunction::kImplicitGetter);
+  return new StaticGetterNode(TokenPos(), NULL, false, field_owner, field_name);
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   const int kNumExtraArgs = 2;  // implicit rcvr and construction phase args.
   const int num_arguments = arguments->length() + kNumExtraArgs;
@@ skipping 1838 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart