Eliminate more implicit getters

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 743 matching lines @@
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
+  CompilerStats::num_functions_compiled++;
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Script& script = Script::Handle(isolate, func.script());
   Parser parser(script, parsed_function, func.token_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::ZoneHandle(isolate, Array::null());
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
@@ skipping 11 matching lines @@
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
     case RawFunction::kImplicitStaticFinalGetter:
       node_sequence = parser.ParseStaticFinalGetter(func);
+      CompilerStats::num_implicit_final_getters++;
       break;
     case RawFunction::kStaticInitializer:
       node_sequence = parser.ParseStaticInitializer(func);
+      CompilerStats::num_static_initializer_funcs++;
       break;
     case RawFunction::kMethodExtractor:
       node_sequence = parser.ParseMethodExtractor(func);
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       node_sequence =
           parser.ParseNoSuchMethodDispatcher(func, default_parameter_values);
       break;
     case RawFunction::kInvokeFieldDispatcher:
       node_sequence =
@@ skipping 2590 matching lines @@
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::ZoneHandle();
   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 and static final non-const fields, the
-      // initialization expression will be parsed through the
-      // kImplicitStaticFinalGetter method invocation/compilation.
+      // For static 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 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
+      // For static 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 || field->has_final) &&
-          (LookaheadToken(1) == Token::kSEMICOLON)) {
+      if (field->has_static && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
       SkipExpr();
     } else {
       // Static const and static final fields must have an initializer.
       // Static const fields are implicitly final.
       if (field->has_static && field->has_final) {
         ErrorMsg(field->name_pos,
                  "static %s field '%s' must have an initializer expression",
                  field->has_const ? "const" : "final",
@@ skipping 525 matching lines @@
   } else {
     CheckToken(Token::kLBRACE);
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   }
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
+  CompilerStats::num_classes_compiled++;
   set_current_class(cls);
   is_top_level_ = true;
   String& class_name = String::Handle(cls.Name());
   const intptr_t class_pos = TokenPos();
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kLBRACE) {
     ConsumeToken();
   }
   ExpectToken(Token::kLBRACE);
   while (CurrentToken() != Token::kRBRACE) {
@@ skipping 594 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 || is_final) && (LookaheadToken(1) == Token::kSEMICOLON)) {
+      if (LookaheadToken(1) == Token::kSEMICOLON) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
         // Create a static final getter.
         String& getter_name = String::Handle(Field::GetterSymbol(var_name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                is_static,
@@ skipping 6180 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart