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 792 matching lines @@
 }
 
 
 void CodeGenerator::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
 void CodeGenerator::VisitCloneContextNode(CloneContextNode *node) {
-  const Context& result = Context::ZoneHandle();
-  __ PushObject(result);
+  __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushl(CTX);
   GenerateCallRuntime(node->id(),
       node->token_index(), kCloneContextRuntimeEntry);
   __ popl(EAX);
   __ popl(CTX);  // result: cloned context. Set as current context.
 }
 
 
 void CodeGenerator::VisitSequenceNode(SequenceNode* node_sequence) {
   CodeGeneratorState codegen_state(this);
@@ skipping 479 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 87 matching lines @@
         Label runtime_call;
         __ 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);
       }
     }
   }
-  const Object& result = Object::ZoneHandle();
-  __ PushObject(result);  // Make room for the result of the runtime call.
+  __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ 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.
@@ skipping 32 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
@@ skipping 101 matching lines @@
         } else if (dst_type.IsFunctionInterface()) {
           __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
           __ movl(ECX, FieldAddress(ECX, Class::signature_function_offset()));
           __ cmpl(ECX, raw_null);
           __ j(NOT_EQUAL, &done, Assembler::kNearJump);
         }
       }
     }
   }
   __ Bind(&runtime_call);
-  const Object& result = Object::ZoneHandle();
-  __ PushObject(result);  // Make room for the result of the 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 source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   if (!dst_type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushl(raw_null);  // Null instantiator.
   }
@@ skipping 45 matching lines @@
   // This check should pass if the receiver's class implements the interface
   // 'bool'. Check only class 'Bool' since it is the only legal implementation
   // of the interface 'bool'.
   const Class& bool_class =
       Class::ZoneHandle(Isolate::Current()->object_store()->bool_class());
   __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
   __ CompareObject(ECX, bool_class);
   __ 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 62 matching lines @@
       Immediate arguments_length = Immediate(reinterpret_cast<int32_t>(
           Smi::New(node->type_arguments().Length())));
       __ cmpl(FieldAddress(EAX, TypeArguments::length_offset()),
           arguments_length);
       __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     }
     __ Bind(&type_arguments_uninstantiated);
     if (node->constructor().IsFactory()) {
       // A runtime call to instantiate the type arguments is required before
       // calling the factory.
-      const Object& result = Object::ZoneHandle();
-      __ PushObject(result);  // Make room for the result of the runtime call.
+      __ PushObject(Object::ZoneHandle());  // Make room for the result.
       __ PushObject(node->type_arguments());
       __ pushl(EAX);  // Push instantiator type arguments.
       GenerateCallRuntime(node->id(),
                           node->token_index(),
                           kInstantiateTypeArgumentsRuntimeEntry);
       __ popl(EAX);  // Pop instantiator type arguments.
       __ popl(EAX);  // Pop uninstantiated type arguments.
       __ popl(EAX);  // Pop instantiated type arguments.
       __ Bind(&type_arguments_instantiated);
       __ pushl(EAX);  // Instantiated type arguments.
@@ skipping 313 matching lines @@
   }
 
   // Generate code for the finally block if one exists.
   if (node->finally_block() != NULL) {
     node->finally_block()->Visit(this);
   }
 }
 
 
 void CodeGenerator::VisitThrowNode(ThrowNode* node) {
-  const Object& result = Object::ZoneHandle();
   node->exception()->Visit(this);
-  __ popl(EAX);  // Exception object is now in EAX.
+  // Exception object is on TOS.
   if (node->stacktrace() != NULL) {
-    __ PushObject(result);  // Make room for the result of the runtime call.
-    __ pushl(EAX);  // Push the exception object.
     node->stacktrace()->Visit(this);
     GenerateCallRuntime(node->id(), node->token_index(), kReThrowRuntimeEntry);
   } else {
-    __ PushObject(result);  // Make room for the result of the runtime call.
-    __ pushl(EAX);  // Push the exception object.
     GenerateCallRuntime(node->id(), node->token_index(), kThrowRuntimeEntry);
   }
   // We should never return here.
   __ int3();
 }
 
 
 void CodeGenerator::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   int try_index = state()->try_index();
   if (try_index >= 0) {
@@ skipping 57 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