Create read only handles for empty_array and sentinel objects

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 830 matching lines @@
     //   field.value = transition_sentinel;
     //   field.value = expr;
     // }
     // return field.value;  // Type check is executed here in checked mode.
 
     // Generate code checking for circular dependency in field initialization.
     AstNode* compare_circular = new ComparisonNode(
         TokenPos(),
         Token::kEQ_STRICT,
         new LoadStaticFieldNode(TokenPos(), field),
-        new LiteralNode(TokenPos(),
-                        Instance::ZoneHandle(Object::transition_sentinel())));
+        new LiteralNode(TokenPos(), Object::transition_sentinel()));
     // Set field to null prior to throwing exception, so that subsequent
     // accesses to the field do not throw again, since initializers should only
     // be executed once.
     SequenceNode* report_circular = new SequenceNode(TokenPos(), NULL);
     report_circular->Add(
         new StoreStaticFieldNode(
             TokenPos(),
             field,
             new LiteralNode(TokenPos(), Instance::ZoneHandle())));
     // TODO(regis): Exception to throw is not specified by spec.
     const String& circular_error = String::ZoneHandle(
         Symbols::New("circular dependency in field initialization"));
     report_circular->Add(
         new ThrowNode(TokenPos(),
                       new LiteralNode(TokenPos(), circular_error),
                       NULL));
     AstNode* circular_check =
         new IfNode(TokenPos(), compare_circular, report_circular, NULL);
     current_block_->statements->Add(circular_check);
 
     // Generate code checking for uninitialized field.
     AstNode* compare_uninitialized = new ComparisonNode(
         TokenPos(),
         Token::kEQ_STRICT,
         new LoadStaticFieldNode(TokenPos(), field),
-        new LiteralNode(TokenPos(),
-                        Instance::ZoneHandle(Object::sentinel())));
+        new LiteralNode(TokenPos(), Object::sentinel()));
     SequenceNode* initialize_field = new SequenceNode(TokenPos(), NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
             TokenPos(),
             field,
             new LiteralNode(
-                TokenPos(),
-                Instance::ZoneHandle(Object::transition_sentinel()))));
+                TokenPos(), Object::transition_sentinel())));
     // TODO(hausner): If evaluation of the field value throws an exception,
     // we leave the field value as 'transition_sentinel', which is wrong.
     // A second reference to the field later throws a circular dependency
     // exception. The field should instead be set to null after an exception.
     initialize_field->Add(new StoreStaticFieldNode(TokenPos(), field, expr));
     AstNode* uninitialized_check =
         new IfNode(TokenPos(), compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
@@ skipping 1812 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();
+      init_value = Object::sentinel().raw();
       // For static const 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) &&
@@ skipping 367 matching lines @@
     cls ^= obj.raw();
     if (is_patch) {
       String& patch = String::Handle(Symbols::New("patch "));
       patch = String::Concat(patch, class_name);
       patch = Symbols::New(patch);
       cls = Class::New(patch, script_, classname_pos);
       cls.set_library(library_);
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
-      if (cls.functions() != Object::empty_array()) {
+      if (cls.functions() != Object::empty_array().raw()) {
         ErrorMsg(classname_pos, "class '%s' is already defined",
                  class_name.ToCString());
       }
       // Pre-registered classes need their scripts connected at this time.
       cls.set_script(script_);
     }
   }
   ASSERT(!cls.IsNull());
-  ASSERT(cls.functions() == Object::empty_array());
+  ASSERT(cls.functions() == Object::empty_array().raw());
   set_current_class(cls);
   ParseTypeParameters(cls);
   Type& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kTryResolve));
     if (type.IsTypeParameter()) {
       ErrorMsg(type_pos,
@@ skipping 556 matching lines @@
     }
 
     field = Field::New(var_name, is_static, is_final, is_const,
                        current_class(), 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());
+      Instance& field_value = Instance::Handle(Object::sentinel().raw());
       bool has_simple_literal = false;
       if (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,
@@ skipping 3496 matching lines @@
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
   // The field is initialized.
   if (field.is_const()) {
-    ASSERT(field.value() != Object::sentinel());
-    ASSERT(field.value() != Object::transition_sentinel());
+    ASSERT(field.value() != Object::sentinel().raw());
+    ASSERT(field.value() != Object::transition_sentinel().raw());
     return new LiteralNode(ident_pos, Instance::ZoneHandle(field.value()));
   }
   // Access the field directly.
   return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
                                         intptr_t ident_pos,
@@ skipping 592 matching lines @@
   return current_class().NumTypeParameters() > 0;
 }
 
 
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
 AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
-  if (value.raw() == Object::transition_sentinel()) {
+  if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                String::Handle(field.name()).ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
       return new StaticGetterNode(TokenPos(),
                                   NULL,
                                   false,
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
-  } else if (value.raw() == Object::sentinel()) {
+  } else if (value.raw() == Object::sentinel().raw()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
-      field.set_value(Instance::Handle(Object::transition_sentinel()));
+      field.set_value(Object::transition_sentinel());
       const String& field_name = String::Handle(field.name());
       const String& getter_name =
           String::Handle(Field::GetterName(field_name));
       const Class& cls = Class::Handle(field.owner());
       const int kNumArguments = 0;  // no arguments.
       const Array& kNoArgumentNames = Array::Handle();
       const Function& func =
           Function::Handle(Resolver::ResolveStatic(cls,
                                                    getter_name,
                                                    kNumArguments,
                                                    kNoArgumentNames,
                                                    Resolver::kIsQualified));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
-      const Array& args = Array::Handle(Object::empty_array());
-      Object& const_value = Object::Handle(DartEntry::InvokeStatic(func, args));
+      Object& const_value = Object::Handle(
+          DartEntry::InvokeStatic(func, Object::empty_array()));
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           field.set_value(Instance::Handle());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
           AppendErrorMsg(error, TokenPos(),
                          "error initializing const field '%s'",
                          String::Handle(field.name()).ToCString());
         } else {
@@ skipping 1828 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart