Address review comments of previously submitted cl 8329005.

runtime/vm/code_generator_ia32.cc

 // Copyright (c) 2011, 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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 837 matching lines @@
         node->scope()->PreserveOuterScope(current_context_level));
     ASSERT(!function.HasCode());
     ASSERT(function.context_scope() == ContextScope::null());
     function.set_context_scope(context_scope);
   } else {
     ASSERT(function.context_scope() != ContextScope::null());
     if (function.IsImplicitInstanceClosureFunction()) {
       node->receiver()->Visit(this);
     }
   }
-  // The function type of a closure may be parameterized. In that case, pass
+  // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
-  const bool is_cls_parameterized = cls.NumTypeArguments() > 0;
-  if (is_cls_parameterized) {
+  const bool requires_type_arguments = cls.HasTypeArguments();
+  if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     GenerateInstantiatorTypeArguments();
   }
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(function));
   const ExternalLabel label(function.ToCString(), stub.EntryPoint());
   GenerateCall(node->token_index(), &label);
-  if (is_cls_parameterized) {
+  if (requires_type_arguments) {
     __ popl(ECX);  // Pop type arguments.
   }
   if (function.IsImplicitInstanceClosureFunction()) {
     __ popl(ECX);  // Pop receiver.
   }
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
@@ skipping 490 matching lines @@
   __ cmpl(EAX, raw_null);
   __ j(NOT_EQUAL, &non_null, Assembler::kNearJump);
   __ PushObject(negate_result ? bool_true : bool_false);
   __ jmp(&done, Assembler::kNearJump);
 
   __ Bind(&non_null);
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
     const Class& type_class = Class::ZoneHandle(type.type_class());
-    const bool is_type_class_parameterized = type_class.NumTypeArguments() > 0;
+    const bool requires_type_arguments = type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable to a non-parameterized class.
     // TODO(regis): Should we still inline a Smi type check when checking for a
     // parameterized type and return false for a Smi's without calling the
     // runtime?
-    if (!is_type_class_parameterized) {
+    if (!requires_type_arguments) {
       Label compare_classes;
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, &compare_classes, Assembler::kNearJump);
       // Object is Smi.
       const Class& smi_class = Class::Handle(Smi::Class());
       // TODO(regis): We should introduce a SmiType.
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 type_class,
                                 TypeArguments::Handle())) {
         __ PushObject(negate_result ? bool_false : bool_true);
@@ skipping 92 matching lines @@
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, runtime_call;
   __ cmpl(EAX, raw_null);
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   // If dst_type is instantiated and non-parameterized, we can inline code
   // checking whether the assigned instance is a Smi.
   if (dst_type.IsInstantiated()) {
     const Class& dst_type_class = Class::ZoneHandle(dst_type.type_class());
-    const bool is_dst_type_parameterized =
-        dst_type_class.NumTypeArguments() > 0;
+    const bool dst_has_type_arguments = dst_type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable to a non-parameterized class.
-    if (!is_dst_type_parameterized) {
+    if (!dst_has_type_arguments) {
       Label compare_classes;
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, &compare_classes, Assembler::kNearJump);
       // Object is Smi.
       const Class& smi_class = Class::Handle(Smi::Class());
       // TODO(regis): We should introduce a SmiType.
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 dst_type_class,
                                 TypeArguments::Handle())) {
         // Successful assignable type check: return object in EAX.
@@ skipping 672 matching lines @@
 // call) and pushes the type argument vector that will be passed as implicit
 // first parameter to the factory.
 // For a constructor call allocating an object of a parameterized class, pushes
 // the type arguments and the type arguments of the instantiator, without ever
 // generating an additional run time call.
 // Does nothing for a constructor call allocating an object of a non
 // parameterized class.
 // Note that a class without proper type parameters may still be parameterized,
 // e.g. class A extends Array<int>.
 void CodeGenerator::GenerateTypeArguments(ConstructorCallNode* node,
-                                          bool is_cls_parameterized) {
+                                          bool requires_type_arguments) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Instantiate the type arguments if necessary.
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
-    if (node->constructor().IsFactory() || is_cls_parameterized) {
+    if (node->constructor().IsFactory() || requires_type_arguments) {
       // A factory requires the type arguments as first parameter.
       __ PushObject(node->type_arguments());
       if (!node->constructor().IsFactory()) {
         // The allocator additionally requires the instantiator type arguments.
         __ pushl(raw_null);  // Null instantiator.
       }
     }
   } else {
     // The type arguments are uninstantiated.
-    ASSERT(node->constructor().IsFactory() || is_cls_parameterized);
+    ASSERT(node->constructor().IsFactory() || requires_type_arguments);
     GenerateInstantiatorTypeArguments();
     __ popl(EAX);  // Pop instantiator.
     // EAX is the instantiator TypeArguments object (or null).
     // If EAX is null, no need to instantiate the type arguments, use null, and
     // allocate an object of a raw type.
     Label type_arguments_instantiated, type_arguments_uninstantiated;
     __ cmpl(EAX, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
 
     // Instantiate non-null type arguments.
@@ skipping 35 matching lines @@
       __ pushl(EAX);  // Instantiated type arguments.
       __ pushl(raw_null);  // Null instantiator.
       __ Bind(&type_arguments_pushed);
     }
   }
 }
 
 
 void CodeGenerator::VisitConstructorCallNode(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
-  const bool is_cls_parameterized = cls.NumTypeArguments() > 0;
-  GenerateTypeArguments(node, is_cls_parameterized);
+  const bool requires_type_arguments = cls.HasTypeArguments();
+  GenerateTypeArguments(node, requires_type_arguments);
   if (node->constructor().IsFactory()) {
     // The top of stack is an instantiated TypeArguments object (or null).
     int num_args = node->arguments()->length() + 1;  // +1 to include type args.
     node->arguments()->Visit(this);
     // Call the factory.
     __ LoadObject(ECX, node->constructor());
     __ LoadObject(EDX, ArgumentsDescriptor(num_args,
                                            node->arguments()->names()));
     GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
     // Factory constructor returns object in EAX.
     __ addl(ESP, Immediate(num_args * kWordSize));
     if (IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     return;
   }
 
   // If cls is parameterized, the type arguments and the instantiator's
   // type arguments are on the stack.
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   GenerateCall(node->token_index(), &label);
-  if (is_cls_parameterized) {
+  if (requires_type_arguments) {
     __ popl(ECX);  // Pop type arguments.
     __ popl(ECX);  // Pop instantiator type arguments.
   }
 
   if (IsResultNeeded(node)) {
     __ pushl(EAX);  // Set up return value from allocate.
   }
   __ pushl(EAX);  // First argument(this) for constructor call which follows.
 
   // Now setup rest of the arguments for the constructor call.
@@ skipping 317 matching lines @@
   const Class& cls = Class::Handle(parsed_function_.function().owner());
   const Script& script = Script::Handle(cls.script());
   Parser::ReportMsg(script, token_index, "Error", error_msg, format, args);
   Isolate::Current()->long_jump_base()->Jump(1, error_msg);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32