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 2424 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);

[Ivan Posva, 2012/06/28 16:35:09]

I am wondering if we will need a
  static const object* Cast(const Object& obj)
eventually.

[regis, 2012/06/28 18:44:51]

Isn't it exactly what we have? That is, before I changed it to static const
object& Cast(const Object& obj), as suggested by Siva.

Are you asking if we will need the non-const version, maybe?
static object& Cast(const Object& obj)
I think that could be dangerous.

However, a Cast in the Raw#object implementation would be useful, because we
often need to cast a raw pointer via a handle before returning it:
static Raw#object* Cast(RawObject* obj)

I'll do it in a following cl, if appropriate.

     if (other.IsTypeParameter()) {
       const TypeParameter* other_type_param =
           reinterpret_cast<const TypeParameter*>(&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());
       if (type_param_bound.IsMoreSpecificThan(other, malformed_error)) {
@@ skipping 848 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);
+    const TypeParameter* type_param = TypeParameter::Cast(type);
     if ((type_param->index() != i)) {

[siva, 2012/06/28 17:02:51]

For example this would be
const TypeParameter& type_param = TypeParameter::Cast(type);
if (type_param.index()) != i) {
   ...
}

[regis, 2012/06/28 18:44:51]

Done.

       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()));
       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());
@@ skipping 3040 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