Add support for malformed types and postpone some related errors from compile

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 1293 matching lines @@
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX.
 // Returns:
 // - true or false on stack.
 void CodeGenerator::GenerateInstanceOf(intptr_t node_id,
                                        intptr_t token_index,
                                        const AbstractType& type,
                                        bool negate_result) {
-  ASSERT(type.IsFinalized());
+  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)) {
     __ PushObject(negate_result ? bool_false : bool_true);
     return;
   }
@@ skipping 141 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()));
+
+    const Object& result = Object::ZoneHandle();
+    __ PushObject(result);  // Make room for the result of the runtime call.

[srdjan, 2012/02/29 00:15:54]

__ PushObject(Object::ZoneHandle());

[srdjan, 2012/02/29 00:15:54]

Is this precaution to push a dummy for result? MalformedTypeError is not setting
a result, is it?

[regis, 2012/02/29 02:10:01]

Correct. No result is returned, but we always reserve space for the result
anyway out of precaution.

[regis, 2012/02/29 02:10:01]

Done here and in other places.

+    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
@@ skipping 175 matching lines @@
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ Bind(&runtime_call);
   const Object& result = Object::ZoneHandle();
   __ PushObject(result);  // Make room for the result of the runtime call.
   const Immediate location =
       Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
   __ pushl(location);  // Push the source location.
   __ pushl(EAX);  // Push the source object.
   GenerateCallRuntime(node_id, token_index, kConditionTypeErrorRuntimeEntry);
-  // Pop the parameters supplied to the runtime entry. The result of the
-  // type check runtime call is the checked value.
-  __ addl(ESP, Immediate(3 * kWordSize));
+  // We should never return here.
+  __ int3();
 
   __ Bind(&done);
 }
 
 
 void CodeGenerator::VisitComparisonNode(ComparisonNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   node->left()->Visit(this);
 
@@ skipping 505 matching lines @@
 // Pushes the type arguments of the instantiator on the stack.
 void CodeGenerator::GenerateInstantiatorTypeArguments(intptr_t token_index) {
   const Class& instantiator_class = Class::Handle(
       parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_index));
-    type ^= ClassFinalizer::FinalizeType(instantiator_class, type);
+    type ^= ClassFinalizer::FinalizeType(
+        instantiator_class, type, ClassFinalizer::kFinalizeWellFormed);
     type_arguments = type.arguments();
     __ PushObject(type_arguments);
   } else {
     ASSERT(parsed_function().instantiator() != NULL);
     parsed_function().instantiator()->Visit(this);
     Function& outer_function =
         Function::Handle(parsed_function().function().raw());
     while (outer_function.IsLocalFunction()) {
       outer_function = outer_function.parent_function();
     }
@@ skipping 485 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