More cleanup to avoid creation of redundant handles

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 246 matching lines @@
 Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
     : script_(Script::Handle(script.raw())),
       tokens_iterator_(TokenStream::Handle(script.tokens()), token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
       innermost_function_(Function::Handle()),
+      literal_token_(LiteralToken::Handle()),
       current_class_(Class::Handle()),
       library_(Library::Handle(library.raw())),
       try_blocks_list_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t token_position)
     : script_(Script::Handle(script.raw())),
       tokens_iterator_(TokenStream::Handle(script.tokens()), token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
       innermost_function_(Function::Handle(parsed_function->function().raw())),
+      literal_token_(LiteralToken::Handle()),
       current_class_(Class::Handle(parsed_function->function().Owner())),
       library_(Library::Handle(Class::Handle(
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
@@ skipping 72 matching lines @@
 
 
 String* Parser::CurrentLiteral() const {
   String& result = String::ZoneHandle();
   result = tokens_iterator_.CurrentLiteral();
   return &result;
 }
 
 
 RawDouble* Parser::CurrentDoubleLiteral() const {
-  LiteralToken& token = LiteralToken::Handle();
-  token ^= tokens_iterator_.CurrentToken();
-  ASSERT(token.kind() == Token::kDOUBLE);
-  return reinterpret_cast<RawDouble*>(token.value());
+  literal_token_ ^= tokens_iterator_.CurrentToken();
+  ASSERT(literal_token_.kind() == Token::kDOUBLE);
+  return Double::RawCast(literal_token_.value());
 }
 
 
 RawInteger* Parser::CurrentIntegerLiteral() const {
-  LiteralToken& token = LiteralToken::Handle();
-  token ^= tokens_iterator_.CurrentToken();
-  ASSERT(token.kind() == Token::kINTEGER);
-  return reinterpret_cast<RawInteger*>(token.value());
+  literal_token_ ^= tokens_iterator_.CurrentToken();
+  ASSERT(literal_token_.kind() == Token::kINTEGER);
+  return Integer::RawCast(literal_token_.value());
 }
 
 
 // A QualIdent is an optionally qualified identifier.
 struct QualIdent {
   QualIdent() {
     Clear();
   }
   void Clear() {
     lib_prefix = NULL;
@@ skipping 4026 matching lines @@
     ParseLibraryImportExport();
     metadata_pos = TokenPos();
     SkipMetadata();
   }
   // Core lib has not been explicitly imported, so we implicitly
   // import it here.
   if (!library_.ImportsCorelib()) {
     Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& core_ns = Namespace::Handle(
-        Namespace::New(core_lib, Array::Handle(), Array::Handle()));
+        Namespace::New(core_lib, Array::null_object(), Array::null_object()));
     library_.AddImport(core_ns);
   }
   while (CurrentToken() == Token::kPART) {
     ParseLibraryPart();
     metadata_pos = TokenPos();
     SkipMetadata();
   }
   SetPosition(metadata_pos);
 }
 
@@ skipping 35 matching lines @@
       Class::New(Symbols::TopLevel(), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source() || is_patch_source()) {
     ParseLibraryDefinition();
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
   while (true) {
-    set_current_class(Class::Handle());  // No current class.
+    set_current_class(Class::null_object());  // No current class.
     SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDeclaration(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       set_current_class(toplevel_class);
       ParseTypedef(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDeclaration(pending_classes);
@@ skipping 3580 matching lines @@
       ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
       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(Instance::Handle());
+          field.set_value(Instance::null_object());
           // 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 {
           Isolate::Current()->long_jump_base()->Jump(1, error);
         }
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
@@ skipping 563 matching lines @@
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Type::New(type_class, type_arguments, type_name.ident_pos));
   // In production mode, malformed type arguments are mapped to dynamic.
   // In checked mode, a type with malformed type arguments is malformed.
   if (FLAG_enable_type_checks && !malformed_error.IsNull()) {
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
-    parameterized_type.set_arguments(AbstractTypeArguments::Handle());
+    parameterized_type.set_arguments(
+        AbstractTypeArguments::null_object());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
     ResolveTypeFromClass(current_class(), finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
   return type.raw();
 }
@@ skipping 1269 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart