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

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/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 3130 matching lines @@
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::Handle();
   Instance& init_value = Instance::Handle();
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel().raw();
-      // For static const fields, the initialization expression
-      // will be parsed through the kImplicitStaticFinalGetter method
-      // invocation/compilation.
+      // For static const fields and static final non-const fields, the
+      // initialization expression will be parsed through the
+      // kImplicitStaticFinalGetter method invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
-      // For static const fields with very simple initializer expressions
-      // (e.g. a literal number or string) we optimize away the
-      // kImplicitStaticFinalGetter and initialize the field here.
-      // We also do it for static final non-const fields, but only in production
-      // mode.
+      // For static const fields and static final non-const fields with very
+      // simple initializer expressions (e.g. a literal number or string), we
+      // optimize away the kImplicitStaticFinalGetter and initialize the field
+      // here. However, the class finalizer will check the value type for
+      // assignability once the declared field type can be resolved. If the
+      // value is not assignable (assuming checked mode and disregarding actual
+      // mode), the field value is reset and a kImplicitStaticFinalGetter is
+      // created at finalization time.
 
-      if (field->has_static &&
-          (field->has_const ||
-           (!FLAG_enable_type_checks && field->has_final)) &&
+      if (field->has_static && (field->has_const || field->has_final) &&
           (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
       SkipExpr();
     } else {
       if (field->has_const || (field->has_static && field->has_final)) {
         ErrorMsg(field->name_pos,
                  "%s%s field '%s' must have an initializer expression",
                  field->has_static ? "static " : "",
                  field->has_const ? "const" : "final",
@@ skipping 1070 matching lines @@
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
-  const AbstractType& type =
-      AbstractType::ZoneHandle(ParseConstFinalVarOrType(
-          FLAG_enable_type_checks ? ClassFinalizer::kResolveTypeParameters :
-                                    ClassFinalizer::kIgnore));
+  const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
+      ClassFinalizer::kResolveTypeParameters));
   Field& field = Field::Handle();
   Function& getter = Function::Handle();
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
@@ skipping 17 matching lines @@
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (metadata_pos >= 0) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Object::sentinel().raw());
       bool has_simple_literal = false;
-      if ((is_const || (!FLAG_enable_type_checks && is_final)) &&
-          (LookaheadToken(1) == Token::kSEMICOLON)) {
+      if ((is_const || is_final) && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
-        // Create a static const getter.
-        String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
+        // Create a static final getter.
+        String& getter_name = String::Handle(Field::GetterSymbol(var_name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                is_static,
                                is_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
         top_level->functions.Add(getter);
@@ skipping 6028 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart