Inline type check where type argument that we check against is instantiated.

runtime/vm/code_generator_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 1493 matching lines @@
     Label* is_not_instance_lbl) {
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::ZoneHandle(type.type_class());
   ASSERT(type_class.HasTypeArguments());
   // A Smi object cannot be the instance of a parameterized class.
   // A class equality check is only applicable with a dst type of a
   // non-parameterized class or with a raw dst type of a parameterized class.
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(ZERO, is_not_instance_lbl);
   const AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(type.arguments());
+      AbstractTypeArguments::ZoneHandle(type.arguments());
   const bool is_raw_type = type_arguments.IsNull() ||
       type_arguments.IsRaw(type_arguments.Length());
   if (is_raw_type) {
     // Dynamic type argument, check only classes.
     __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
     if (type.IsListInterface()) {
       // TODO(srdjan) also accept List<Object>.
       __ CompareObject(ECX, *CoreClass("ObjectArray"));
       __ j(EQUAL, is_instance_lbl);
       __ CompareObject(ECX, *CoreClass("GrowableObjectArray"));
       __ j(EQUAL, is_instance_lbl);
     }
     GenerateClassTestCache(node_id, token_index, type_class,
                            is_instance_lbl, is_not_instance_lbl);
+    return;
   }
-  // TODO(srdjan): do type test on type arguments.
+  // Inline checks for one type-argument only.

[regis, 2012/04/26 00:36:17]

one type argument

[srdjan, 2012/04/26 18:08:37]

Done.

+  if (type_arguments.Length() != 1) {
+    return;
+  }
+  const AbstractType& type_at_0 =

[regis, 2012/04/26 00:36:17]

type_argument instead of type_at_0?

[srdjan, 2012/04/26 18:08:37]

As discussed: type_argument sounds too close to type_arguments, renaming to
tp_argument.

+      AbstractType::ZoneHandle(type_arguments.TypeAt(0));
+  if (!type_at_0.IsType() || !type_at_0.HasResolvedTypeClass()) {

[regis, 2012/04/26 00:36:17]

We already checked for type.IsMalformed() in the caller. What case are you
handling here?

[srdjan, 2012/04/26 18:08:37]

Changing to assert.

+    return;
+  }
+  // Check if type argument is dynamic or Object.
+  const Type& object_type =
+      Type::Handle(Isolate::Current()->object_store()->object_type());
+  Error& malformed_error = Error::Handle();
+  if (object_type.IsSubtypeOf(type_at_0, &malformed_error)) {
+    // Instance class test only necessary.
+    GenerateClassTestCache(node_id, token_index, type_class,

[regis, 2012/04/26 00:36:17]

I do not understand this shortcut.
Wouldn't this inlined code wrongly link to is_not_instance_lbl when testing an
instance of type A[Object] against B[Object]?
This would be wrong with this declaration:
class A extends B<Object>
Oh, wait, your GenerateClassTestCache is not a class equality test but a
subclass test. How about renaming it to GenerateSubclassTestCache?

However, this is not correct with interfaces, I think.
Consider class A<T> implements I<Object>

[srdjan, 2012/04/26 18:08:37]

Made simpler comment to GenerateClassTestCache. That should explain the question
about interface. Rename as you suggested (offline):
GenerateSubtypeTestCacheLookup

+                           is_instance_lbl, is_not_instance_lbl);
+    return;
+  }
+
+  // First step is to check instance class.
+  Label check_type_argument, fall_through;
+  GenerateClassTestCache(node_id, token_index, type_class,

[regis, 2012/04/26 00:36:17]

The same argument applies here. Consider
class A<T> implements I<bool>

[srdjan, 2012/04/26 18:08:37]

Discussed and answered offline, I guess.

+                         &check_type_argument, is_not_instance_lbl);
+  // Class test not conclusive (fall-through).
+  __ jmp(&fall_through);
+  __ Bind(&check_type_argument);
+  // Get type argument of instance.
+  const Class& type_at_0_class = Class::ZoneHandle(type_at_0.type_class());
+  __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
+  __ movl(EDI, FieldAddress(ECX,
+      type_at_0_class.type_arguments_instance_field_offset_offset()));
+  // EDI: intptr_t offset of type arguments in instance.
+  __ cmpl(EDI, Immediate(Class::kNoTypeArguments));
+  __ j(EQUAL, is_instance_lbl);

[regis, 2012/04/26 00:36:17]

I do not understand this either. Consider
class A implements I<bool>
new A() is I<String> will say true, which is wrong.

[srdjan, 2012/04/26 18:08:37]

You are right. Nifty example, and there is no test for that, yet.  Adding test
in a different CL. Offline discussion concluded that we cannot do inlined tests
at all. Need to chat about it more.

+  __ movl(EDI, FieldAddress(EAX, EDI, TIMES_1, 0));
+  // EDI: type arguments of the instance.
+  // Is type argument dynamic?
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  __ cmpl(EDI, raw_null);
+  __ j(EQUAL, is_instance_lbl);
+  // Type arguments may be canonicalized: are they equal?
+  __ CompareObject(EDI, type_arguments);
+  __ j(EQUAL, is_instance_lbl);

[regis, 2012/04/26 00:36:17]

Consider
class A<T> implements I<bool>
new A() is I<String> will say true, which is wrong.

+
+  // We can handle only type of class TypeArguments.
+  __ movl(EDX, FieldAddress(EDI, Object::class_offset()));
+  __ CompareObject(EDX,
+      Object::ZoneHandle(Object::type_arguments_class()));
+  __ j(NOT_EQUAL, &fall_through);
+  // EDI: instance of class 'TypeArguments'.
+  __ movl(EDX, FieldAddress(EDI, TypeArguments::length_offset()));
+  // Handling only tests with one type argument.
+  Immediate smi_one_imm =
+      Immediate(reinterpret_cast<int32_t>(Smi::New(1)));
+  __ cmpl(EDX, smi_one_imm);
+  __ j(NOT_EQUAL, &fall_through);
+  __ movl(ECX, FieldAddress(EDI, TypeArguments::type_at_offset(0)));
+  __ CompareObject(ECX, type_at_0);
+  __ j(EQUAL, is_instance_lbl);
+  // If the type is not parameterized do the subclass check.
+  if (!type_at_0_class.HasTypeArguments()) {
+    __ LoadObject(EDX, type_at_0_class);
+    __ movl(ECX, FieldAddress(ECX, Type::type_class_offset()));
+    __ cmpl(ECX, EDX);
+    __ j(EQUAL, is_instance_lbl);
+    // A non-parameterized class is in EDX, compare with class in ECX
+    // EAX, EDX are preserved in stub.
+    __ call(&StubCode::IsRawSubTypeLabel());
+    // Result in EBX: 1 is raw subtype.
+    __ cmpl(EBX, Immediate(1));
+    __ j(EQUAL, is_instance_lbl);
+  }
   // Fall through if type test is not conclusive
+  __ Bind(&fall_through);
 }
 
 
 // EAX: instance to test.
 // Clobbers: EBX, ECX, EDX.
 void CodeGenerator::GenerateInstantiatedTypeNoArgumentsTest(
     intptr_t node_id,
     intptr_t token_index,
     const AbstractType& type,
     Label* is_instance_lbl,
@@ skipping 1377 matching lines @@
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32