Use proper internal name for implicit static final 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 748 matching lines @@
       node_sequence = parser.ParseFunc(func, default_parameter_values);
       break;
     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::kConstImplicitGetter:
-      node_sequence = parser.ParseStaticConstGetter(func);
+    case RawFunction::kImplicitStaticFinalGetter:
+      node_sequence = parser.ParseStaticFinalGetter(func);
       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 90 matching lines @@
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr);
     meta_values.Add(val);
   }
   return Array::MakeArray(meta_values);
 }
 
 
-// TODO(regis): Since a const variable is implicitly final,
-// rename ParseStaticConstGetter to ParseStaticFinalGetter and
-// rename kConstImplicitGetter to kImplicitFinalGetter.
-SequenceNode* Parser::ParseStaticConstGetter(const Function& func) {
-  TRACE_PARSER("ParseStaticConstGetter");
+SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
+  TRACE_PARSER("ParseStaticFinalGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   intptr_t ident_pos = TokenPos();
@@ skipping 679 matching lines @@
       Resolver::ResolveDynamicAnyArgs(super_class, name));
   if (!super_func.IsNull() &&
       !super_func.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
     const String& getter_name = String::ZoneHandle(Field::GetterName(name));
     super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
     ASSERT(super_func.IsNull() ||
-           (super_func.kind() != RawFunction::kConstImplicitGetter));
+           (super_func.kind() != RawFunction::kImplicitStaticFinalGetter));
   }
   if (super_func.IsNull()) {
     super_func =
         Resolver::ResolveDynamicAnyArgs(super_class, Symbols::NoSuchMethod());
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   return super_func.raw();
@@ skipping 1536 matching lines @@
   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 kConstImplicitGetter method
+      // 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
-      // kConstImplicitGetter and initialize the field here.
+      // kImplicitStaticFinalGetter and initialize the field here.
       // We also do it for static final non-const fields, but only in production
       // mode.
 
       if (field->has_static &&
           (field->has_const ||
            (!FLAG_enable_type_checks && field->has_final)) &&
           (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
       SkipExpr();
@@ skipping 14 matching lines @@
                              field->has_const,
                              current_class(),
                              field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
     if (field->metadata_pos >= 0) {
       library_.AddFieldMetadata(class_field, field->metadata_pos);
     }
 
-    // For static const fields, set value to "uninitialized" and
-    // create a kConstImplicitGetter getter method.
+    // For static final fields (this includes static const fields), set value to
+    // "uninitialized" and create a kFinalImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
         String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
         getter = Function::New(getter_name,
-                               RawFunction::kConstImplicitGetter,
+                               RawFunction::kImplicitStaticFinalGetter,
                                field->has_static,
                                field->has_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         members->AddFunction(getter);
       }
     }
@@ skipping 1097 matching lines @@
       if ((is_const || (!FLAG_enable_type_checks && 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));
         getter = Function::New(getter_name,
-                               RawFunction::kConstImplicitGetter,
+                               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);
       }
     } else if (is_final) {
@@ skipping 3315 matching lines @@
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      Object::empty_array(),
                                      Resolver::kIsQualified);
       if (!func.IsNull()) {
-        ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
+        ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
         EnsureSavedCurrentContext();
         closure = new StaticGetterNode(call_pos,
                                        NULL,
                                        false,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
         return new ClosureCallNode(call_pos, closure, arguments);
       }
     } else {
       EnsureSavedCurrentContext();
@@ skipping 61 matching lines @@
   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));
   // Never load field directly if there is a getter (deterministic AST).
   if (getter.IsNull()) {
     return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
   } else {
-    ASSERT(getter.kind() == RawFunction::kConstImplicitGetter);
+    ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
     return new StaticGetterNode(ident_pos,
                                 NULL,  // Receiver.
                                 false,  // is_super_getter.
                                 field_owner,
                                 field_name);
   }
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
@@ skipping 64 matching lines @@
         if (func.IsNull()) {
           // No field or explicit getter function, throw a NoSuchMethodError.
           return ThrowNoSuchMethodError(ident_pos,
                                         cls,
                                         field_name,
                                         InvocationMirror::kStatic,
                                         InvocationMirror::kGetter);
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
-        ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
+        ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
         access = new StaticGetterNode(call_pos,
                                       NULL,
                                       false,
                                       Class::ZoneHandle(cls.raw()),
                                       field_name);
       }
     } else {
       access = GenerateStaticFieldLookup(field, TokenPos());
     }
   }
@@ skipping 542 matching lines @@
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
       const int kNumArguments = 0;  // no arguments.
       const Function& func =
           Function::Handle(Resolver::ResolveStatic(field_owner,
                                                    getter_name,
                                                    kNumArguments,
                                                    Object::empty_array(),
                                                    Resolver::kIsQualified));
       ASSERT(!func.IsNull());
-      ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
+      ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
       Object& const_value = Object::Handle(
           DartEntry::InvokeFunction(func, Object::empty_array()));
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           // An exception may not occur in every parse attempt, i.e., the
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
           current_function().set_is_optimizable(false);
           field.set_value(Object::null_instance());
@@ skipping 13 matching lines @@
       field.set_value(instance);
       return NULL;   // Constant
     } else {
       return new StaticGetterNode(TokenPos(),
                                   NULL,
                                   false,
                                   field_owner,
                                   field_name);
     }
   }
-  if (getter.IsNull() || (getter.kind() == RawFunction::kConstImplicitGetter)) {
+  if (getter.IsNull() ||
+      (getter.kind() == RawFunction::kImplicitStaticFinalGetter)) {
     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,
@@ skipping 1785 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart