Improve type checking, remove unused stub (removed also in x64 in preparation of porting the better…

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 413 matching lines @@
   const Class& type_class = Class::ZoneHandle(instance.clazz());
   if (!type_class.HasTypeArguments()) {
     return true;
   }
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(instance.GetTypeArguments());
   if (type_arguments.IsNull()) {
     return true;
   }
   if (type_arguments.IsInstantiatedTypeArguments()) {
+    AbstractTypeArguments& temp_type_arguments =

[regis, 2012/05/07 21:13:04]

Why do you need temp_type_arguments instead of using type_arguments directly?

[srdjan, 2012/05/07 21:23:12]

Good point, eliminating temp_type_arguments.

+        AbstractTypeArguments::Handle(type_arguments.raw());
+    do {
+      InstantiatedTypeArguments& instantiated_type_arguments =
+          InstantiatedTypeArguments::Handle();
+      instantiated_type_arguments ^= temp_type_arguments.raw();
+      const AbstractTypeArguments& uninstantiated =
+          AbstractTypeArguments::Handle(
+              instantiated_type_arguments.uninstantiated_type_arguments());
+      const AbstractTypeArguments& instantiator =
+          AbstractTypeArguments::Handle(
+              instantiated_type_arguments.instantiator_type_arguments());
+      temp_type_arguments = uninstantiated.InstantiateFrom(instantiator);
+    } while (temp_type_arguments.IsInstantiatedTypeArguments());
     TypeArguments& new_type_arguments = TypeArguments::Handle();
-    InstantiatedTypeArguments& instantiated_type_arguments =
-        InstantiatedTypeArguments::Handle();
-    instantiated_type_arguments ^= type_arguments.raw();
-    const AbstractTypeArguments& uninstantiated =
-        AbstractTypeArguments::Handle(
-            instantiated_type_arguments.uninstantiated_type_arguments());
-    const AbstractTypeArguments& instantiator =
-        AbstractTypeArguments::Handle(
-            instantiated_type_arguments.instantiator_type_arguments());
-    AbstractTypeArguments& temp = AbstractTypeArguments::Handle();
-    temp = uninstantiated.InstantiateFrom(instantiator);
-    if (!temp.IsTypeArguments()) {
-      // TODO(srdjan): Figure out why it does not want to convert to
-      // TypeArguments.
-      return false;
-    }
-    new_type_arguments ^= temp.raw();
+    new_type_arguments ^= temp_type_arguments.raw();
     new_type_arguments ^= new_type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
     *type_arguments_replaced = true;
   } else if (!type_arguments.IsCanonical()) {
     AbstractTypeArguments& new_type_arguments =
         AbstractTypeArguments::Handle();
     new_type_arguments ^= type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
     *type_arguments_replaced = true;
   }
@@ skipping 71 matching lines @@
         &last_instance_class,
         &last_instance_type_arguments,
         &last_instantiator_type_arguments,
         &last_result);
     if ((last_instance_class.raw() == instance_class.raw()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
       if (FLAG_trace_type_checks) {
         OS::Print("%d ", i);
-        PrintTypeCheck("WARNING duplicate cache entry", instance, type,
-            instantiator_type_arguments, result);
+        if (type_arguments_replaced) {
+          PrintTypeCheck("Duplicate cache entry (canonical.)", instance, type,
+              instantiator_type_arguments, result);
+        } else {
+          PrintTypeCheck("WARNING Duplicate cache entry", instance, type,
+              instantiator_type_arguments, result);
+        }
       }
       // Can occur if we have canonicalized arguments.
       // TODO(srdjan): Investigate why this assert can fail.
       // ASSERT(type_arguments_replaced);
       return;
     }
   }
   new_cache.AddCheck(instance_class,
                      instance_type_arguments,
                      instantiator_type_arguments,
                      result);
   if (FLAG_trace_type_checks) {
+    AbstractType& test_type = AbstractType::Handle(type.raw());
+    if (!test_type.IsInstantiated()) {
+      test_type = type.InstantiateFrom(instantiator_type_arguments);
+    }
     OS::Print("  Updated test cache 0x%x ix:%d:\n"
         "    [0x%x %s, 0x%x %s]\n"
         "    [0x%x %s, 0x%x %s] %s\n",
         new_cache.raw(),
         len,
         instance_class.raw(),
         instance_class.ToCString(),
         instance_type_arguments.raw(),
         instance_type_arguments.ToCString(),
-        type.type_class(),
-        Class::Handle(type.type_class()).ToCString(),
+        test_type.type_class(),
+        Class::Handle(test_type.type_class()).ToCString(),
         instantiator_type_arguments.raw(),
         instantiator_type_arguments.ToCString(),
         result.ToCString());
   }
 }
 
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: index of the token of the instanceof test (source location).
@@ skipping 964 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart