Make sure type information is not lost in snapshots created in production mode,

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 1054 matching lines @@
         ReportError(Error::Handle(),  // No previous error.
                     script, field.token_pos(),
                     "field '%s' of class '%s' conflicts with method '%s' "
                     "of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
-    if ((FLAG_enable_type_checks || FLAG_error_on_malformed_type) &&
-        field.is_static() && field.is_const() &&
+    if (field.is_static() && (field.is_const() || field.is_final()) &&
         (field.value() != Object::null()) &&
         (field.value() != Object::sentinel().raw())) {
       // The parser does not preset the value if the type is a type parameter or
       // is parameterized unless the value is null.
       Error& malformed_error = Error::Handle();
       if (type.IsMalformed()) {
         malformed_error = type.malformed_error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(field.value());
       if (!malformed_error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      AbstractTypeArguments::Handle(),
                                      &malformed_error))) {
-        const AbstractType& const_value_type = AbstractType::Handle(
-            const_value.GetType());
-        const String& const_value_type_name = String::Handle(
-            const_value_type.UserVisibleName());
-        const String& type_name = String::Handle(type.UserVisibleName());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(malformed_error, script, field.token_pos(),
-                    "error initializing const field '%s': type '%s' is not a "
-                    "subtype of type '%s'",
-                    name.ToCString(),
-                    const_value_type_name.ToCString(),
-                    type_name.ToCString());
+        if (FLAG_error_on_malformed_type) {
+          const AbstractType& const_value_type = AbstractType::Handle(
+              const_value.GetType());
+          const String& const_value_type_name = String::Handle(
+              const_value_type.UserVisibleName());
+          const String& type_name = String::Handle(type.UserVisibleName());
+          const Script& script = Script::Handle(cls.script());
+          ReportError(malformed_error, script, field.token_pos(),
+                      "error initializing static %s field '%s': "
+                      "type '%s' is not a subtype of type '%s'",
+                      field.is_const() ? "const" : "final",
+                      name.ToCString(),
+                      const_value_type_name.ToCString(),
+                      type_name.ToCString());
+        } else {
+          // Do not report an error yet, even in checked mode, since the field
+          // may not actually be used.
+          // Also, we may be generating a snapshot in production mode that will
+          // later be executed in checked mode, in which case an error needs to
+          // be reported, should the field be accessed.
+          // Therefore, we undo the optimization performed by the parser, i.e.
+          // we create an implicit static final getter and reset the field value
+          // to the sentinel value.
+          const String& getter_name = String::Handle(Field::GetterSymbol(name));
+          const Function& getter = Function::Handle(
+              Function::New(getter_name,
+                            RawFunction::kImplicitStaticFinalGetter,
+                            /* is_static = */ true,
+                            /* is_const = */ field.is_const(),
+                            /* is_abstract = */ false,
+                            /* is_external = */ false,
+                            cls,
+                            field.token_pos()));
+          getter.set_result_type(type);
+          cls.AddFunction(getter);
+          field.set_value(Instance::Handle(Object::sentinel().raw()));
+        }
       }
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   CollectInterfaces(cls, interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
@@ skipping 1104 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart