Generate dynamic type errors according to spec.

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 1251 matching lines @@
                                        intptr_t token_index,
                                        const AbstractType& type,
                                        bool negate_result) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   // All instances are of a subtype of the Object type.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
-  if (type.IsInstantiated() && object_type.IsSubtypeOf(type)) {
+  Error& malformed_error = Error::Handle();
+  if (type.IsInstantiated() &&
+      object_type.IsSubtypeOf(type, &malformed_error)) {
     __ PushObject(negate_result ? bool_false : bool_true);
     return;
   }
 
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done;
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
@@ skipping 48 matching lines @@
       }
       __ Bind(&runtime_call);
       // Fall through to runtime call.
     } else {
       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.
+      Error& malformed_error = Error::Handle();
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 type_class,
-                                TypeArguments::Handle())) {
+                                TypeArguments::Handle(),
+                                &malformed_error)) {
         __ PushObject(negate_result ? bool_false : bool_true);
       } else {
         __ PushObject(negate_result ? bool_true : bool_false);
       }
       __ jmp(&done, Assembler::kNearJump);
 
       // Compare if the classes are equal.
       __ Bind(&compare_classes);
       const Class* compare_class = NULL;
       if (type.IsStringInterface()) {
@@ skipping 10 matching lines @@
         __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
         __ CompareObject(ECX, *compare_class);
         __ j(NOT_EQUAL, &runtime_call, Assembler::kNearJump);
         __ PushObject(negate_result ? bool_false : bool_true);
         __ jmp(&done, Assembler::kNearJump);
         __ Bind(&runtime_call);
       }
     }
   }
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
+  const Immediate location =
+      Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
+  __ pushl(location);  // Push the source location.
   __ pushl(EAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (!type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushl(raw_null);  // Null instantiator.
   }
   GenerateCallRuntime(node_id, token_index, kInstanceofRuntimeEntry);
   // Pop the two parameters supplied to the runtime entry. The result of the
   // instanceof runtime call will be left as the result of the operation.
-  __ addl(ESP, Immediate(3 * kWordSize));
+  __ addl(ESP, Immediate(4 * kWordSize));
   if (negate_result) {
     Label negate_done;
     __ popl(EDX);
     __ LoadObject(EAX, bool_true);
     __ cmpl(EDX, EAX);
     __ j(NOT_EQUAL, &negate_done, Assembler::kNearJump);
     __ LoadObject(EAX, bool_false);
     __ Bind(&negate_done);
     __ pushl(EAX);
   }
@@ skipping 21 matching lines @@
 // - object in EAX for successful assignable check (or throws TypeError).
 void CodeGenerator::GenerateAssertAssignable(intptr_t node_id,
                                              intptr_t token_index,
                                              const AbstractType& dst_type,
                                              const String& dst_name) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(token_index >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
-  // Generate throw new TypeError() if the type is malformed.
-  if (dst_type.IsMalformed()) {
-    const Error& error = Error::Handle(dst_type.malformed_error());
-    const String& error_message = String::ZoneHandle(
-        String::NewSymbol(error.ToErrorCString()));
-    __ PushObject(Object::ZoneHandle());  // Make room for the result.
-    const Immediate location =
-        Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
-    __ pushl(location);  // Push the source location.
-    __ pushl(EAX);  // Push the source object.
-    __ PushObject(error_message);
-    GenerateCallRuntime(node_id, token_index, kMalformedTypeErrorRuntimeEntry);
-    // We should never return here.
-    __ int3();
-    return;
-  }
-
   // Any expression is assignable to the Dynamic type and to the Object type.
   // Skip the test.
   if (dst_type.IsDynamicType() || dst_type.IsObjectType()) {
     return;
   }
 
   // It is a compile-time error to explicitly return a value (including null)
   // from a void function. However, functions that do not explicitly return a
   // value, implicitly return null. This includes void functions. Therefore, we
   // skip the type test here and trust the parser to only return null in void
   // function.
   if (dst_type.IsVoidType()) {
     return;
   }
 
-  // A NULL object is always assignable and is returned as result.
+  // A null object is always assignable and is returned as result.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, runtime_call;
   __ cmpl(EAX, raw_null);
   __ j(EQUAL, &done, Assembler::kNearJump);
 
+  // Generate throw new TypeError() if the type is malformed.
+  if (dst_type.IsMalformed()) {
+    const Error& error = Error::Handle(dst_type.malformed_error());
+    const String& error_message = String::ZoneHandle(
+        String::NewSymbol(error.ToErrorCString()));
+    __ PushObject(Object::ZoneHandle());  // Make room for the result.
+    const Immediate location =
+        Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
+    __ pushl(location);  // Push the source location.
+    __ pushl(EAX);  // Push the source object.
+    __ PushObject(dst_name);  // Push the name of the destination.
+    __ PushObject(error_message);
+    GenerateCallRuntime(node_id, token_index, kMalformedTypeErrorRuntimeEntry);
+    // We should never return here.
+    __ int3();
+    return;
+  }
+
   // 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 dst_class_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 with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (dst_class_has_type_arguments) {
       const AbstractTypeArguments& dst_type_arguments =
@@ skipping 17 matching lines @@
         }
         // Fall through to runtime class.
       }
     } else {  // dst_type has NO 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.
+      Error& malformed_error = Error::Handle();
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 dst_type_class,
-                                TypeArguments::Handle())) {
+                                TypeArguments::Handle(),
+                                &malformed_error)) {
         // Successful assignable type check: return object in EAX.
         __ jmp(&done, Assembler::kNearJump);
       } else {
         // Failed assignable type check: call runtime to throw TypeError.
         __ jmp(&runtime_call, Assembler::kNearJump);
       }
       // Compare if the classes are equal.
       __ Bind(&compare_classes);
       // If dst_type is an interface, we can skip the class equality check,
       // because instances cannot be of an interface type.
       if (!dst_type_class.is_interface()) {
         __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
         TestClassAndJump(dst_type_class, &done);
       } else {
         // However, for specific core library interfaces, we can check for
         // specific core library classes.
+        Error& malformed_error = Error::Handle();
         if (dst_type.IsBoolInterface()) {
           __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
           const Class& bool_class = Class::ZoneHandle(
               Isolate::Current()->object_store()->bool_class());
           TestClassAndJump(bool_class, &done);
         } else if (dst_type.IsSubtypeOf(
-              Type::Handle(Type::NumberInterface()))) {
+              Type::Handle(Type::NumberInterface()), &malformed_error)) {
           __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
           if (dst_type.IsIntInterface() || dst_type.IsNumberInterface()) {
             // We already checked for Smi above.
             const Class& mint_class = Class::ZoneHandle(
                 Isolate::Current()->object_store()->mint_class());
             TestClassAndJump(mint_class, &done);
             const Class& bigint_class = Class::ZoneHandle(
                 Isolate::Current()->object_store()->bigint_class());
             TestClassAndJump(bigint_class, &done);
           }
@@ skipping 1133 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