Optimize away most implicit const getter functions

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2511 matching lines @@
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (members->FieldNameExists(*field->name)) {
     ErrorMsg(field->name_pos,
              "'%s' field/method already defined\n", field->name->ToCString());
   }
   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 have_simple_literal = false;

[regis, 2012/07/31 23:19:54]

has_simple_literal?

[hausner, 2012/07/31 23:34:03]

Done.

     if (has_initializer) {
       ConsumeToken();
+      init_value = Object::sentinel();
       // For static final fields, the initialization expression
       // will be parsed through the kConstImplicitGetter method
       // invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
+      // For static fields with very simple initializer expressions
+      // (e.g. a literal number or string) we optimize away the
+      // kConstImplicitGetter and initialize the field here.
+
+      if (field->has_static && (field->has_final || field->has_const) &&
+          (LookaheadToken(1) == Token::kSEMICOLON)) {
+        have_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",
                  field->name->ToCString());
       }
     }
 
     // Create the field object.
     // TODO(hausner): For now, all static final fields are constant. Remove
     // this when lazy init of static variables is implemented.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
                              field->has_const || field->has_final,
                              field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
 
     // For static final fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
-      class_field.set_value(Instance::Handle(Object::sentinel()));
-      String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
-      getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                             field->has_static, field->has_final, false,
-                             /* is_abstract */ false,
-                             field->name_pos);
-      getter.set_result_type(*field->type);
-      members->AddFunction(getter);
+      class_field.set_value(init_value);
+      if (!have_simple_literal) {
+        String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+        getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
+                               field->has_static, field->has_final,
+                               /* is_abstract */ false,
+                               /* is_external */ false,
+                               field->name_pos);
+        getter.set_result_type(*field->type);
+        members->AddFunction(getter);
+      }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static, field->has_final, false,
                              /* is_abstract */ false,
                              field->name_pos);
       ParamList params;
@@ skipping 927 matching lines @@
                var_name.ToCString());
     }
 
     field = Field::New(var_name, is_static, is_final, is_const, name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
+      Instance& field_value = Instance::Handle(Object::sentinel());
+      bool have_simple_literal = false;
+      if ((is_final || is_const) && (LookaheadToken(1) == Token::kSEMICOLON)) {
+        have_simple_literal = IsSimpleLiteral(type, &field_value);
+      }
       SkipExpr();
-      field.set_value(Instance::Handle(Object::sentinel()));
-      // Create a static const getter.
-      String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
-      getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                             is_static, is_final, false, false, name_pos);
-      getter.set_result_type(type);
-      top_level->functions.Add(getter);
+      field.set_value(field_value);
+      if (!have_simple_literal) {
+        // Create a static const getter.
+        String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
+        getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
+                               is_static, is_final, false, false, name_pos);
+        getter.set_result_type(type);
+        top_level->functions.Add(getter);
+      }
+
     } else if (is_final || is_const) {
       ErrorMsg(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
@@ skipping 921 matching lines @@
       ConsumeToken();
     } while (nesting_level > 0);
     if (nesting_level < 0) {
       return false;
     }
   }
   return true;
 }
 
 
+bool Parser::IsSimpleLiteral(const AbstractType& type, Instance* value) {
+  bool no_check = type.IsDynamicType();
+  if ((CurrentToken() == Token::kINTEGER) &&
+      (no_check || type.IsIntInterface() || type.IsNumberInterface())) {
+    *value = CurrentIntegerLiteral();
+    return true;
+  } else if ((CurrentToken() == Token::kDOUBLE) &&
+      (no_check || type.IsDoubleInterface() || type.IsNumberInterface())) {
+    *value = CurrentDoubleLiteral();
+    return true;
+  } else if ((CurrentToken() == Token::kSTRING) &&
+      (no_check || type.IsStringInterface())) {
+    *value = CurrentLiteral()->raw();

[regis, 2012/07/31 23:19:54]

Not specific to this change list, but it feels strange that CurrentLiteral()
does not return a raw pointer as CurrentIntegerLiteral() and
CurrentDoubleLiteral() both do, and also that it is not called
CurrentStringLiteral().

[hausner, 2012/07/31 23:34:03]

True. CurrentLiteral used to return a pointer to a handle that already existed
in the token stream, so we could avoid allocating an unnecessary handle. Somehow
this code changed. I think Siva has already looked at this and concluded that
returning a raw pointer is less ideal but I don't remember why.

+    return true;
+  } else if ((CurrentToken() == Token::kTRUE) &&
+      (no_check || type.IsBoolInterface())) {
+    *value = Bool::True();
+    return true;
+  } else if ((CurrentToken() == Token::kFALSE) &&
+      (no_check || type.IsBoolInterface())) {
+    *value = Bool::False();
+    return true;
+  } else if (CurrentToken() == Token::kNULL) {
+    *value = Instance::null();
+    return true;
+  }
+  return false;
+}
+
+
 // Returns true if the current token is kIDENT or a pseudo-keyword.
 bool Parser::IsIdentifier() {
   return Token::IsIdentifier(CurrentToken());
 }
 
 
 // Returns true if the next tokens can be parsed as a type with optional
 // type parameters. Current token position is not restored.
 bool Parser::TryParseOptionalType() {
   if (CurrentToken() == Token::kIDENT) {
@@ skipping 4308 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart