Introduce a VM type cast to avoid repeating a type test and spare a handle.

runtime/vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2052 matching lines @@
       return field.raw();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  LibraryPrefix& lib_prefix = LibraryPrefix::Handle(isolate,
-                                                    LibraryPrefix::null());
   const Library& lib = Library::Handle(isolate, library());
-  Object& obj = Object::Handle(isolate, lib.LookupLocalObject(name));
-  if (!obj.IsNull()) {
-    if (obj.IsLibraryPrefix()) {
-      lib_prefix ^= obj.raw();
-    }
+  const Object& obj = Object::Handle(isolate, lib.LookupLocalObject(name));
+  if (!obj.IsNull() && obj.IsLibraryPrefix()) {
+    const LibraryPrefix& lib_prefix = LibraryPrefix::Cast(obj);
+    return lib_prefix.raw();
   }
-  return lib_prefix.raw();
+  return LibraryPrefix::null();
 }
 
 
 const char* Class::ToCString() const {
   const char* format = is_interface()
       ? "%s Interface: %s" : "%s Class: %s";
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
@@ skipping 342 matching lines @@
   // is a subtype of V, or vice versa. We only return true if K == V, i.e. if
   // they have the same index (both are finalized, so their indices are
   // comparable).
   // The same rule applies When checking the upper bound of a still
   // uninstantiated type at compile time. Returning false will defer the test
   // to run time. But there are cases where it can be decided at compile time.
   // For example, with class A<K, V extends K>, new A<T, T> called from within
   // a class B<T> will never require a run time bounds check, even it T is
   // uninstantiated at compile time.
   if (IsTypeParameter()) {
-    // TODO(regis): Introduce and use TypeParameter::Cast().
-    const TypeParameter* type_param =
-        reinterpret_cast<const TypeParameter*>(this);
+    const TypeParameter& type_param = TypeParameter::Cast(*this);
     if (other.IsTypeParameter()) {
-      const TypeParameter* other_type_param =
-          reinterpret_cast<const TypeParameter*>(&other);
-      return type_param->index() == other_type_param->index();
+      const TypeParameter& other_type_param = TypeParameter::Cast(other);
+      return type_param.index() == other_type_param.index();
     } else if (FLAG_enable_type_checks) {
       // In checked mode, if the upper bound of this type is more specific than
       // the other type, then this type is more specific than the other type.
       const AbstractType& type_param_bound =
-          AbstractType::Handle(type_param->bound());
+          AbstractType::Handle(type_param.bound());
       if (type_param_bound.IsMoreSpecificThan(other, malformed_error)) {
         return true;
       }
     }
     return false;
   }
   if (other.IsTypeParameter()) {
     return false;
   }
   const Class& cls = Class::Handle(type_class());
@@ skipping 370 matching lines @@
 }
 
 
 bool TypeParameter::Equals(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
-  TypeParameter& other_type_param = TypeParameter::Handle();
-  other_type_param ^= other.raw();
+  const TypeParameter& other_type_param = TypeParameter::Cast(other);
   if (IsFinalized() != other_type_param.IsFinalized()) {
     return false;
   }
   if (parameterized_class() != other_type_param.parameterized_class()) {
     return false;
   }
   if (index() != other_type_param.index()) {
     return false;
   }
   const String& name = String::Handle(Name());
   const String& other_type_param_name = String::Handle(other_type_param.Name());
   return name.Equals(other_type_param_name);
 }
 
 
 bool TypeParameter::IsIdentical(const AbstractType& other,
                                 bool check_type_parameter_bound) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
-  TypeParameter& other_type_param = TypeParameter::Handle();
-  other_type_param ^= other.raw();
+  const TypeParameter& other_type_param = TypeParameter::Cast(other);
   // IsIdentical may be called on type parameters belonging to different
   // classes, e.g. to an interface and to its default factory class.
   // Therefore, both type parameters may have different parameterized classes
   // and different indices. Compare the type parameter names only, and their
   // bounds if requested.
   String& name = String::Handle(Name());
   String& other_name = String::Handle(other_type_param.Name());
   if (!name.Equals(other_name)) {
     return false;
   }
@@ skipping 211 matching lines @@
   if (arguments.IsNull() || other_arguments.IsNull()) {
     return false;
   }
   intptr_t num_types = arguments.Length();
   if (num_types != other_arguments.Length()) {
     return false;
   }
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
-    type ^= arguments.TypeAt(i);
+    type = arguments.TypeAt(i);
     ASSERT(!type.IsNull());
-    other_type ^= other_arguments.TypeAt(i);
+    other_type = other_arguments.TypeAt(i);
     if (!type.IsIdentical(other_type, check_type_parameter_bounds)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
@@ skipping 48 matching lines @@
     const Class& cls,
     const AbstractTypeArguments& bounds_instantiator,
     Error* malformed_error) const {
   ASSERT(FLAG_enable_type_checks);
   // This function may be called at compile time on (partially) uninstantiated
   // type arguments and may return true, in which case a run time bounds check
   // can be avoided.
   ASSERT(Length() >= cls.NumTypeArguments());
   const intptr_t num_type_params = cls.NumTypeParameters();
   const intptr_t offset = cls.NumTypeArguments() - num_type_params;
-  AbstractType& type = AbstractType::Handle();
-  TypeParameter& type_param = TypeParameter::Handle();
+  AbstractType& this_type_arg = AbstractType::Handle();
+  AbstractType& cls_type_arg = AbstractType::Handle();
   AbstractType& bound = AbstractType::Handle();
-  const TypeArguments& type_params =
+  const TypeArguments& cls_type_params =
       TypeArguments::Handle(cls.type_parameters());
-  ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
-         (type_params.Length() == num_type_params));
+  ASSERT((cls_type_params.IsNull() && (num_type_params == 0)) ||
+         (cls_type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
-    type_param ^= type_params.TypeAt(i);
-    bound = type_param.bound();
+    cls_type_arg = cls_type_params.TypeAt(i);
+    const TypeParameter& cls_type_param = TypeParameter::Cast(cls_type_arg);
+    bound = cls_type_param.bound();
     if (!bound.IsDynamicType()) {
-      type = TypeAt(offset + i);
+      this_type_arg = TypeAt(offset + i);
       Error& malformed_bound_error = Error::Handle();
       if (bound.IsMalformed()) {
         malformed_bound_error = bound.malformed_error();
       } else if (!bound.IsInstantiated()) {
         bound = bound.InstantiateFrom(bounds_instantiator);
       }
       if (!malformed_bound_error.IsNull() ||
-          !type.IsSubtypeOf(bound, malformed_error)) {
+          !this_type_arg.IsSubtypeOf(bound, malformed_error)) {
         // Ignore this bound error if another malformed error was already
         // reported for this type test.
         if (malformed_error->IsNull()) {
-          const String& type_argument_name = String::Handle(type.Name());
+          const String& type_arg_name = String::Handle(this_type_arg.Name());
           const String& class_name = String::Handle(cls.Name());
           const String& bound_name = String::Handle(bound.Name());
           const Script& script = Script::Handle(cls.script());
           // Since the bound was canonicalized, its token index was lost,
           // therefore, use the token index of the corresponding type parameter.
-          const TypeArguments& type_parameters =
-              TypeArguments::Handle(cls.type_parameters());
-          type = type_parameters.TypeAt(i);
           *malformed_error ^= FormatError(malformed_bound_error,
-                                          script, type.token_pos(),
+                                          script, cls_type_param.token_pos(),
                                           "type argument '%s' does not "
                                           "extend bound '%s' of '%s'\n",
-                                          type_argument_name.ToCString(),
+                                          type_arg_name.ToCString(),
                                           bound_name.ToCString(),
                                           class_name.ToCString());
         }
         return false;
       }
     }
   }
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull() &&
       !IsWithinBoundsOf(super_class, bounds_instantiator, malformed_error)) {
@@ skipping 83 matching lines @@
 
 bool TypeArguments::IsUninstantiatedIdentity() const {
   ASSERT(!IsInstantiated());
   AbstractType& type = AbstractType::Handle();
   intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsTypeParameter()) {
       return false;
     }
-    // TODO(regis): Introduce and use TypeParameter::Cast().
-    TypeParameter* type_param = reinterpret_cast<TypeParameter*>(&type);
-    if ((type_param->index() != i)) {
+    const TypeParameter& type_param = TypeParameter::Cast(type);
+    if ((type_param.index() != i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(!IsInstantiated());
@@ skipping 3880 matching lines @@
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsVoidType());
   ASSERT(!other.IsMalformed());
   if (IsNull()) {
     Class& other_class = Class::Handle();
     if (other.IsTypeParameter()) {
       if (other_instantiator.IsNull()) {
         return true;  // Other type is uninstantiated, i.e. Dynamic.
       }
-      // TODO(regis): Introduce and use TypeParameter::Cast().
-      const TypeParameter* other_type_param =
-          reinterpret_cast<const TypeParameter*>(&other);
+      const TypeParameter& other_type_param = TypeParameter::Cast(other);
       const AbstractType& instantiated_other = AbstractType::Handle(
-          other_instantiator.TypeAt(other_type_param->index()));
+          other_instantiator.TypeAt(other_type_param.index()));
       ASSERT(instantiated_other.IsInstantiated());
       other_class = instantiated_other.type_class();
     } else {
       other_class = other.type_class();
     }
     return other_class.IsObjectClass() || other_class.IsDynamicClass();
   }
   const Class& cls = Class::Handle(clazz());
   // We must not encounter Object::sentinel() or Object::transition_sentinel(),
   // both instances of class NullClass, but not instance Object::null().
@@ skipping 20 matching lines @@
   Class& other_class = Class::Handle();
   AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator), however, we can save the
   // allocation of a new AbstractType by inlining the code.
   if (other.IsTypeParameter()) {
     if (other_instantiator.IsNull()) {
       // An uninstantiated type parameter is equivalent to Dynamic.
       return true;
     }
-    const TypeParameter* other_type_param =
-        reinterpret_cast<const TypeParameter*>(&other);
+    const TypeParameter& other_type_param = TypeParameter::Cast(other);
     AbstractType& instantiated_other = AbstractType::Handle(
-        other_instantiator.TypeAt(other_type_param->index()));
+        other_instantiator.TypeAt(other_type_param.index()));
     if (instantiated_other.IsDynamicType() ||
         instantiated_other.IsTypeParameter()) {
       return true;
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
     if (!other_type_arguments.IsNull() &&
@@ skipping 2994 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart