Use VM type cast and save 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 84 matching lines @@
     type ^= objs.At(i);
     a.SetTypeAt(i, type);
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
 
 static ThrowNode* GenerateRethrow(intptr_t token_pos, const Object& obj) {
-  UnhandledException& excp = UnhandledException::Handle();
-  excp ^= obj.raw();
+  const UnhandledException& excp = UnhandledException::Cast(obj);
   const Instance& exception = Instance::ZoneHandle(excp.exception());
   const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
 LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
   return new LocalVariable(token_pos,
@@ skipping 5953 matching lines @@
 // TODO(srdjan): Implement other optimizations.
 AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
                                       Token::Kind binary_op,
                                       AstNode* lhs,
                                       AstNode* rhs) {
   LiteralNode* lhs_literal = lhs->AsLiteralNode();
   LiteralNode* rhs_literal = rhs->AsLiteralNode();
   if ((lhs_literal != NULL) && (rhs_literal != NULL)) {
     if (lhs_literal->literal().IsDouble() &&
         rhs_literal->literal().IsDouble()) {
-      Double& dbl_obj = Double::ZoneHandle();
-      dbl_obj ^= lhs_literal->literal().raw();
-      double left_double = dbl_obj.value();
-      dbl_obj ^= rhs_literal->literal().raw();
-      double right_double = dbl_obj.value();
+      double left_double = Double::Cast(lhs_literal->literal()).value();
+      double right_double = Double::Cast(rhs_literal->literal()).value();
       if (binary_op == Token::kDIV) {
-        dbl_obj = Double::NewCanonical((left_double / right_double));
+        const Double& dbl_obj = Double::ZoneHandle(
+            Double::NewCanonical((left_double / right_double)));
         return new LiteralNode(op_pos, dbl_obj);
       }
     }
   }
   if ((binary_op == Token::kAND) || (binary_op == Token::kOR)) {
     EnsureExpressionTemp();
   }
   return new BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
@@ skipping 764 matching lines @@
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Local lookup in library prefix scope.
       resolved_type_class = lib_prefix.LookupLocalClass(unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     if (!resolved_type_class.IsNull()) {
-      Object& type_class = Object::Handle(resolved_type_class.raw());
       // Replace unresolved class with resolved type class.
-      parameterized_type.set_type_class(type_class);
+      parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kFinalize) {
       // The type is malformed.
       ClassFinalizer::FinalizeMalformedType(
           Error::Handle(),  // No previous error.
           current_class(), parameterized_type, finalization,
           "type '%s' is not loaded",
           String::Handle(parameterized_type.Name()).ToCString());
     }
   }
   // Resolve type arguments, if any.
@@ skipping 104 matching lines @@
           Function::Handle(Resolver::ResolveStatic(cls,
                                                    getter_name,
                                                    kNumArguments,
                                                    kNoArgumentNames,
                                                    Resolver::kIsQualified));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
       Object& const_value = Object::Handle(
           DartEntry::InvokeStatic(func, arguments, kNoArgumentNames));
       if (const_value.IsError()) {
-        Error& error = Error::Handle();
-        error ^= const_value.raw();
-        if (const_value.IsUnhandledException()) {
+        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 final field '%s'",
                          String::Handle(field.name()).ToCString());
         } else {
           Isolate::Current()->long_jump_base()->Jump(1, error);
         }
       }
@@ skipping 44 matching lines @@
     ASSERT(arg->IsLiteralNode());
     arg_values.Add(&arg->AsLiteralNode()->literal());
   }
   const Array& opt_arg_names = arguments->names();
   const Object& result = Object::Handle(
       DartEntry::InvokeStatic(constructor, arg_values, opt_arg_names));
   if (result.IsError()) {
       if (result.IsUnhandledException()) {
         return result.raw();
       } else {
-        Error& error = Error::Handle();
-        error ^= result.raw();
-        Isolate::Current()->long_jump_base()->Jump(1, error);
+        Isolate::Current()->long_jump_base()->Jump(1, Error::Cast(result));
         UNREACHABLE();
         return Object::null();
       }
   } else {
     if (constructor.IsFactory()) {
       // The factory method returns the allocated object.
       instance ^= result.raw();
     }
     if (!instance.IsNull()) {
       instance ^= instance.Canonicalize();
@@ skipping 113 matching lines @@
                                             const QualIdent& qual_ident,
                                             bool resolve_locally) {
   TRACE_PARSER("ResolveIdentInLibraryScope");
   Object& obj = Object::Handle();
   if (resolve_locally) {
     obj = lib.LookupLocalObject(*qual_ident.ident);
   } else {
     obj = lib.LookupObject(*qual_ident.ident);
   }
   if (obj.IsClass()) {
-    Class& cls = Class::Handle();
-    cls ^= obj.raw();
+    const Class& cls = Class::Cast(obj);
     return new PrimaryNode(qual_ident.ident_pos, Class::ZoneHandle(cls.raw()));
   }
   if (obj.IsField()) {
-    Field& field = Field::Handle();
-    field ^= obj.raw();
+    const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, qual_ident.ident_pos);
   }
-  Function& func = Function::Handle();
   if (obj.IsFunction()) {
-    func ^= obj.raw();
+    const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     return new PrimaryNode(qual_ident.ident_pos,
                            Function::ZoneHandle(func.raw()));
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
 
   // Check if there is a global getter or setter for qual_ident.
   // We create a getter node even if a getter doesn't exist since
   // qual_ident could be followed by an assignment which will convert it
   // to a setter node. If there is no assignment we will get an error
   // when we try to invoke the getter.
   String& accessor_name = String::Handle(Field::GetterName(*qual_ident.ident));
   if (resolve_locally) {
     obj = lib.LookupLocalObject(accessor_name);
   } else {
     obj = lib.LookupObject(accessor_name);
   }
   if (obj.IsNull()) {
     accessor_name = Field::SetterName(*qual_ident.ident);
     if (resolve_locally) {
       obj = lib.LookupLocalObject(accessor_name);
     } else {
       obj = lib.LookupObject(accessor_name);
     }
   }
   if (!obj.IsNull()) {
     ASSERT(obj.IsFunction());
-    func ^= obj.raw();
+    const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
     return new StaticGetterNode(qual_ident.ident_pos,
                                 Class::ZoneHandle(func.owner()),
                                 *qual_ident.ident);
   }
   if (qual_ident.lib_prefix != NULL) {
     return NULL;
   }
   // Lexically unresolved primary identifiers are referenced by their name.
@@ skipping 506 matching lines @@
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       return GenerateRethrow(literal_pos, constructor_result);
     } else {
-      Instance& const_instance = Instance::ZoneHandle();
-      const_instance ^= constructor_result.raw();
-      return new LiteralNode(literal_pos, const_instance);
+      const Instance& const_instance = Instance::Cast(constructor_result);
+      return new LiteralNode(literal_pos,
+                             Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     String& map_literal_factory_class_name = String::Handle(
         String::NewSymbol(kMapLiteralFactoryClassName));
     const Class& map_literal_factory_class =
         Class::Handle(LookupCoreClass(map_literal_factory_class_name));
     ASSERT(!map_literal_factory_class.IsNull());
     const String& map_literal_factory_name =
         String::Handle(String::NewSymbol(kMapLiteralFactoryName));
@@ skipping 255 matching lines @@
       return ThrowTypeError(type_pos, type);
     }
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(constructor_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
       new_object = GenerateRethrow(new_pos, constructor_result);
     } else {
-      Instance& const_instance = Instance::ZoneHandle();
-      const_instance ^= constructor_result.raw();
-      new_object = new LiteralNode(new_pos, const_instance);
+      const Instance& const_instance = Instance::Cast(constructor_result);
+      new_object = new LiteralNode(new_pos,
+                                   Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
@@ skipping 31 matching lines @@
   GrowableArray<const Object*> interpolate_arg;
   interpolate_arg.Add(&value_arr);
   const Array& kNoArgumentNames = Array::Handle();
 
   // Call interpolation function.
   String& concatenated = String::ZoneHandle();
   concatenated ^= DartEntry::InvokeStatic(func,
                                           interpolate_arg,
                                           kNoArgumentNames);
   if (concatenated.IsUnhandledException()) {
-    // TODO(regis): Report
     ErrorMsg("Exception thrown in Parser::Interpolate");
   }
   concatenated = String::NewSymbol(concatenated);
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
@@ skipping 254 matching lines @@
     ReturnNode* ret = new ReturnNode(expr->token_pos(), expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new LocalScope(NULL, 0, 0);
     SequenceNode* seq = new SequenceNode(expr->token_pos(), empty_scope);
     seq->Add(ret);
 
     Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       // Propagate the compilation error.
-      Error& error = Error::Handle();
-      error ^= result.raw();
-      Isolate::Current()->long_jump_base()->Jump(1, error);
+      Isolate::Current()->long_jump_base()->Jump(1, Error::Cast(result));
       UNREACHABLE();
     }
     ASSERT(result.IsInstance());
     Instance& value = Instance::ZoneHandle();
     value ^= result.raw();
-    if (value.IsNull()) {
+    if (!value.IsNull()) {
       value ^= value.Canonicalize();
     }
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
@@ skipping 238 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart