Cleanup: Remove unused return value in OptimizeTypeArguments.

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/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 384 matching lines @@
   }
   const Function& function = Function::Handle(
       caller_frame->LookupDartFunction());
   OS::Print(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
 
 // Converts InstantiatedTypeArguments to TypeArguments and stores it
 // into the instance. The assembly code can handle only type arguments of
 // class TypeArguments. Because of the overhead, do it only when needed.
-// Return false if the optimization was aborted.
-// Set type_arguments_replaced to true if they have changed.
-static bool OptimizeTypeArguments(const Instance& instance,
-                                  bool* type_arguments_replaced) {
-  *type_arguments_replaced = false;
+// Return true if type arguments have been replaced, false otherwise.
+static bool OptimizeTypeArguments(const Instance& instance) {
+  bool replaced = false;
   const Class& type_class = Class::ZoneHandle(instance.clazz());
   if (!type_class.HasTypeArguments()) {
-    return true;
+    return replaced;

[Vyacheslav Egorov (Google), 2012/11/29 12:57:05]

return false;

   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(instance.GetTypeArguments());
   if (type_arguments.IsNull()) {
-    return true;
+    return replaced;

[Vyacheslav Egorov (Google), 2012/11/29 12:57:05]

return false;

   }
   if (type_arguments.IsInstantiatedTypeArguments()) {

[Vyacheslav Egorov (Google), 2012/11/29 12:57:05]

move variable here.

     do {
       const InstantiatedTypeArguments& instantiated_type_arguments =
           InstantiatedTypeArguments::Cast(type_arguments);
       const AbstractTypeArguments& uninstantiated =
           AbstractTypeArguments::Handle(
               instantiated_type_arguments.uninstantiated_type_arguments());
       const AbstractTypeArguments& instantiator =
           AbstractTypeArguments::Handle(
               instantiated_type_arguments.instantiator_type_arguments());
       type_arguments = uninstantiated.InstantiateFrom(instantiator);
     } while (type_arguments.IsInstantiatedTypeArguments());
     AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
     new_type_arguments = type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
-    *type_arguments_replaced = true;
+    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;
+    replaced = true;
   }

[srdjan, 2012/11/29 21:12:20]

Add } else { return false; } here and remove variable 'replaced' ?

   ASSERT(AbstractTypeArguments::Handle(
       instance.GetTypeArguments()).IsTypeArguments());
-  return true;
+  return replaced;
 }
 
 
 // This updates the type test cache, an array containing 4-value elements
 // (instance class, instance type arguments, instantiator type arguments and
 // test_result). It can be applied to classes with type arguments in which
 // case it contains just the result of the class subtype test, not including
 // the evaluation of type arguments.
 // This operation is currently very slow (lookup of code is not efficient yet).
 // 'instantiator' can be null, in which case inst_targ
@@ skipping 12 matching lines @@
   AbstractTypeArguments& instantiator_type_arguments =
       AbstractTypeArguments::Handle(incoming_instantiator_type_arguments.raw());
   AbstractTypeArguments& instance_type_arguments =
       AbstractTypeArguments::Handle();
   const Class& instance_class = Class::Handle(instance.clazz());
 
   // Canonicalize type arguments.
   bool type_arguments_replaced = false;
   if (instance_class.HasTypeArguments()) {
     // Canonicalize type arguments.
-    if (!OptimizeTypeArguments(instance, &type_arguments_replaced)) {
-      if (FLAG_trace_type_checks) {
-        PrintTypeCheck("WARNING: Cannot canonicalize instance type arguments",
-            instance, type, instantiator_type_arguments, result);
-      }
-      return;
-    }
+    type_arguments_replaced = OptimizeTypeArguments(instance);
     instance_type_arguments = instance.GetTypeArguments();
   }
   if (!instantiator.IsNull()) {
-    bool replaced = false;
-    if (!OptimizeTypeArguments(instantiator, &replaced)) {
-      if (FLAG_trace_type_checks) {
-        PrintTypeCheck("WARNING: Cannot canonicalize instantiator "
-            "type arguments",
-            instance, type, instantiator_type_arguments, result);
-      }
-      return;
-    }
-    if (replaced) {
+    if (OptimizeTypeArguments(instantiator)) {
       type_arguments_replaced = true;
     }
     instantiator_type_arguments = instantiator.GetTypeArguments();
   }
 
   intptr_t last_instance_class_id = -1;
   AbstractTypeArguments& last_instance_type_arguments =
       AbstractTypeArguments::Handle();
   AbstractTypeArguments& last_instantiator_type_arguments =
       AbstractTypeArguments::Handle();
@@ skipping 1390 matching lines @@
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   const Bigint& big_left = Bigint::Handle(left);
   const Bigint& big_right = Bigint::Handle(right);
   return BigintOperations::Compare(big_left, big_right);
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart