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

runtime/vm/code_generator_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 406 matching lines @@
       if (num_opt_params == 0) {
         __ cmpq(RAX, Immediate(Smi::RawValue(num_fixed_params)));
         __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
       } else {
         __ subq(RAX, Immediate(Smi::RawValue(num_fixed_params)));
         __ cmpq(RAX, Immediate(Smi::RawValue(num_opt_params)));
         __ j(BELOW_EQUAL, &argc_in_range, Assembler::kNearJump);
       }
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(AstNode::kNoId,
-                            function.token_index(),
+                            0,
                             kClosureArgumentMismatchRuntimeEntry);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
     ASSERT(first_param_index == -1);
     // Copy positional arguments.
     // Check that no fewer than num_fixed_params positional arguments are passed
@@ skipping 104 matching lines @@
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that RDI now points to the null terminator in the array descriptor.
     Label all_arguments_processed;
     __ cmpq(Address(RDI, 0), raw_null);
     __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
 
     __ Bind(&wrong_num_arguments);
     if (function.IsClosureFunction()) {
       GenerateCallRuntime(AstNode::kNoId,
-                          function.token_index(),
+                          0,
                           kClosureArgumentMismatchRuntimeEntry);
     } else {
       // Invoke noSuchMethod function.
       const int kNumArgsChecked = 1;
       ICData& ic_data = ICData::ZoneHandle();
       ic_data = ICData::New(parsed_function().function(),
                             String::Handle(function.name()),
                             AstNode::kNoId,
                             kNumArgsChecked);
       __ LoadObject(RBX, ic_data);
       // RBP : points to previous frame pointer.
       // RBP + 8 : points to return address.
       // RBP + 16 : address of last argument (arg n-1).
       // RSP + 16 + 8*(n-1) : address of first argument (arg 0).
       // RBX : ic-data.
       // R10 : arguments descriptor array.
       __ call(&StubCode::CallNoSuchMethodFunctionLabel());
     }
 
     if (FLAG_trace_functions) {
       __ pushq(RAX);  // Preserve result.
-      __ PushObject(function);
+      __ PushObject(Function::ZoneHandle(function.raw()));
       GenerateCallRuntime(AstNode::kNoId,
                           0,
                           kTraceFunctionExitRuntimeEntry);
       __ popq(RAX);  // Remove argument.
       __ popq(RAX);  // Restore result.
     }
     __ LeaveFrame();
     __ ret();
 
     __ Bind(&all_arguments_processed);
@@ skipping 27 matching lines @@
     }
     __ movq(Address(RBP, index * kWordSize), RAX);
   }
 
   // Generate stack overflow check.
   __ movq(TMP, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(TMP, 0));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow);
   GenerateCallRuntime(AstNode::kNoId,
-                      function.token_index(),
+                      0,
                       kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 void CodeGenerator::GenerateReturnEpilog(ReturnNode* node) {
   // Unchain the context(s) up to context level 0.
   int context_level = state()->context_level();
   ASSERT(context_level >= 0);
   while (context_level-- > 0) {
@@ skipping 31 matching lines @@
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   AddCurrentDescriptor(PcDescriptors::kReturn,
                        node->id(),
                        node->token_index());
 
-
 #ifdef DEBUG
   __ Bind(&wrong_stack);
   __ Stop("Exit stack size does not match the entry stack size.");
 #endif  // DEBUG.
 }
 
 
 void CodeGenerator::VisitReturnNode(ReturnNode* node) {
   ASSERT(!IsResultNeeded(node));
   ASSERT(node->value() != NULL);
@@ skipping 105 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.
   __ pushq(CTX);
   GenerateCallRuntime(node->id(),
       node->token_index(), kCloneContextRuntimeEntry);
   __ popq(RAX);
   __ popq(CTX);  // result: cloned context. Set as current context.
 }
 
 
 void CodeGenerator::VisitSequenceNode(SequenceNode* node_sequence) {
   CodeGeneratorState codegen_state(this);
@@ skipping 481 matching lines @@
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // Destroys RCX.
 // 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;
         __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
         __ CompareObject(RCX, *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.
   __ pushq(RAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (!type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushq(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 RAX 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<int64_t>(Smi::New(token_index)));
+    __ pushq(location);  // Push the source location.
+    __ pushq(RAX);  // 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()) {
           __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
           __ movq(RCX, FieldAddress(RCX, Class::signature_function_offset()));
           __ cmpq(RCX, raw_null);
           __ j(NOT_EQUAL, &done);
         }
       }
     }
   }
   __ 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<int64_t>(Smi::New(token_index)));
   __ pushq(location);  // Push the source location.
   __ pushq(RAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   if (!dst_type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushq(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());
   __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
   __ CompareObject(RCX, 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<int64_t>(Smi::New(token_index)));
   __ pushq(location);  // Push the source location.
   __ pushq(RAX);  // 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.
-  __ addq(RSP, 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 418 matching lines @@
   // Could not concatenate at compile time, generate a call to
   // interpolation function.
   ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
   interpol_arg->Add(node->values());
   node->values()->Visit(this);
   __ LoadObject(RBX, interpol_func);
   __ LoadObject(R10, ArgumentsDescriptor(interpol_arg->length(),
                                          interpol_arg->names()));
   GenerateCall(node->token_index(),
                &StubCode::CallStaticFunctionLabel(),
-               PcDescriptors::kOther);
+               PcDescriptors::kFuncCall);
   __ addq(RSP, Immediate(interpol_arg->length() * kWordSize));
   // Result is in RAX.
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
 }
 
 
 void CodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
@@ skipping 66 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<int64_t>(
           Smi::New(node->type_arguments().Length())));
       __ cmpq(FieldAddress(RAX, 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());
       __ pushq(RAX);  // Push instantiator type arguments.
       GenerateCallRuntime(node->id(),
                           node->token_index(),
                           kInstantiateTypeArgumentsRuntimeEntry);
       __ popq(RAX);  // Pop instantiator type arguments.
       __ popq(RAX);  // Pop uninstantiated type arguments.
       __ popq(RAX);  // Pop instantiated type arguments.
       __ Bind(&type_arguments_instantiated);
       __ pushq(RAX);  // 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);
-  __ popq(RAX);  // Exception object is now in RAX.
+  // Exception object is on TOS.
   if (node->stacktrace() != NULL) {
-    __ PushObject(result);  // Make room for the result of the runtime call.
-    __ pushq(RAX);  // 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.
-    __ pushq(RAX);  // 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_X64