Generate dynamic type errors according to spec.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 5355 matching lines @@
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       FormatError(script_, token_index_, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
+void Parser::ErrorMsg(const Error& error) {
+  Isolate::Current()->long_jump_base()->Jump(1, error);
+  UNREACHABLE();
+}
+
+
 void Parser::AppendErrorMsg(
       const Error& prev_error, intptr_t token_index, const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(FormatErrorWithAppend(
       prev_error, script_, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
@@ skipping 160 matching lines @@
         const intptr_t type_pos = token_index_;
         const AbstractType& type =
             AbstractType::ZoneHandle(ParseType(ClassFinalizer::kFinalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureReceiver();
         }
         right_operand = new TypeNode(type_pos, type);
         if (type.IsMalformed()) {
+          // Note that a type error is thrown even if the tested value is null.
           return ThrowTypeError(type_pos, type);
         }
       }
       if (Token::IsRelationalOperator(op_kind)
           || Token::IsInstanceofOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
         left_operand = new ComparisonNode(
             op_pos, op_kind, left_operand, right_operand);
         break;  // Equality and relational operators cannot be chained.
       } else {
@@ skipping 820 matching lines @@
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     if (!resolved_type_class.IsNull()) {
       Object& type_class = Object::Handle(resolved_type_class.raw());
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(type_class);
     } else if (finalization >= ClassFinalizer::kFinalize) {
       // The type is malformed.
       ClassFinalizer::FinalizeMalformedType(
+          Error::Handle(),  // No previous error.
           current_class(), parameterized_type, finalization,
           "type '%s' is not loaded",
           String::Handle(parameterized_type.Name()).ToCString());
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
@@ skipping 554 matching lines @@
         String::NewSymbol("list literal element"));
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = token_index_;
       AstNode* element = ParseExpr(is_const);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
         // The expression needs to be type checked at runtime.
         // Eliminate the type check if it can be performed at compile time and
         // if it succeeds.
+        Error& malformed_error = Error::Handle();
         if (!element_type.IsInstantiated() ||
             !element->IsLiteralNode() ||
             !element->AsLiteralNode()->literal().
-                IsAssignableTo(element_type, TypeArguments::Handle())) {
+                IsAssignableTo(element_type,
+                               TypeArguments::Handle(),
+                               &malformed_error)) {
           element = new AssignableNode(element_pos,
                                        element,
                                        element_type,
                                        dst_name);
         }
       }
       list->AddElement(element);
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
       } else if (CurrentToken() != Token::kRBRACK) {
         ErrorMsg("comma or ']' expected");
       }
     }
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
   }
 
   if (is_const) {
     // Allocate and initialize the const list at compile time.
     Array& const_list =
         Array::ZoneHandle(Array::New(list->length(), Heap::kOld));
     const_list.SetTypeArguments(type_arguments);
-
+    Error& malformed_error = Error::Handle();
     for (int i = 0; i < list->length(); i++) {
       AstNode* elem = list->ElementAt(i);
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       if (FLAG_enable_type_checks &&
           !element_type.IsDynamicType() &&
-          !elem->AsLiteralNode()->literal().
-              IsAssignableTo(element_type, TypeArguments::Handle())) {
-        ErrorMsg(elem->AsLiteralNode()->token_index(),
-                 "list literal element at index %d must be "
-                 "a constant of type '%s'",
-                 i,
-                 String::Handle(element_type.Name()).ToCString());
+          !elem->AsLiteralNode()->literal().IsAssignableTo(
+              element_type, TypeArguments::Handle(), &malformed_error)) {
+        // If the failure is due to a malformed type error, display it instead.
+        if (!malformed_error.IsNull()) {
+          ErrorMsg(malformed_error);
+        } else {
+          ErrorMsg(elem->AsLiteralNode()->token_index(),
+                   "list literal element at index %d must be "
+                   "a constant of type '%s'",
+                   i,
+                   String::Handle(element_type.Name()).ToCString());
+        }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     String& list_literal_factory_class_name = String::Handle(
         String::NewSymbol(kListLiteralFactoryClassName));
@@ skipping 117 matching lines @@
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t value_pos = token_index_;
     AstNode* value = ParseExpr(is_const);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
       // The expression needs to be type checked at runtime.
       // Eliminate the type check if it can be performed at compile time and
       // if it succeeds.
+      Error& malformed_error = Error::Handle();
       if (!value_type.IsInstantiated() ||
           !value->IsLiteralNode() ||
-          !value->AsLiteralNode()->literal().
-              IsAssignableTo(value_type, TypeArguments::Handle())) {
+          !value->AsLiteralNode()->literal().IsAssignableTo(
+              value_type, TypeArguments::Handle(), &malformed_error)) {
         value = new AssignableNode(value_pos,
                                    value,
                                    value_type,
                                    dst_name);
       }
     }
     AddKeyValuePair(kv_pairs, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() != Token::kRBRACE) {
       ErrorMsg("comma or '}' expected");
     }
   }
   ASSERT(kv_pairs->length() % 2 == 0);
   ExpectToken(Token::kRBRACE);
 
   if (is_const) {
     // Create the key-value pair array, canonicalize it and then create
     // the immutable map object with it. This all happens at compile time.
     // The resulting immutable map object is returned as a literal.
 
     // First, create the canonicalized key-value pair array.
     Array& key_value_array =
         Array::ZoneHandle(Array::New(kv_pairs->length(), Heap::kOld));
+    Error& malformed_error = Error::Handle();
     for (int i = 0; i < kv_pairs->length(); i++) {
       AstNode* arg = kv_pairs->ElementAt(i);
       // Arguments have been evaluated to a literal value already.
       ASSERT(arg->IsLiteralNode());
       if (FLAG_enable_type_checks &&
           ((i % 2) == 1) &&  // Check values only, not keys.
           !value_type.IsDynamicType() &&
-          !arg->AsLiteralNode()->literal().
-              IsAssignableTo(value_type, TypeArguments::Handle())) {
-        ErrorMsg(arg->AsLiteralNode()->token_index(),
-                 "map literal value at index %d must be "
-                 "a constant of type '%s'",
-                 i >> 1,
-                 String::Handle(value_type.Name()).ToCString());
+          !arg->AsLiteralNode()->literal().IsAssignableTo(
+              value_type, TypeArguments::Handle(), &malformed_error)) {
+        // If the failure is due to a malformed type error, display it instead.
+        if (!malformed_error.IsNull()) {
+          ErrorMsg(malformed_error);
+        } else {
+          ErrorMsg(arg->AsLiteralNode()->token_index(),
+                   "map literal value at index %d must be "
+                   "a constant of type '%s'",
+                   i >> 1,
+                   String::Handle(value_type.Name()).ToCString());
+        }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
         String::Handle(String::NewSymbol(kImmutableMapName));
     const Class& immutable_map_class =
@@ skipping 91 matching lines @@
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = token_index_;
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = token_index_;
 
+  // TODO(regis): Bounds error should not result in a compile time error,
+  // but in a dynamic type error. Requesting kFinalizeWellFormed below is too
+  // strict. See co19 issue 96.
   const AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kFinalizeWellFormed));
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "type parameter '%s' cannot be instantiated",
              String::Handle(type.Name()).ToCString());
   }
   Class& type_class = Class::Handle(type.type_class());
   String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
@@ skipping 57 matching lines @@
     if (!type_class.HasResolvedFactoryClass()) {
       // This error can occur only with bootstrap classes.
       const UnresolvedClass& unresolved =
           UnresolvedClass::Handle(type_class.UnresolvedFactoryClass());
       const String& missing_class_name = String::Handle(unresolved.ident());
       ErrorMsg("unresolved factory class '%s'", missing_class_name.ToCString());
     }
     // Only change the class of the constructor to the factory class if the
     // factory class implements the interface 'type'.
     const Class& factory_class = Class::Handle(type_class.FactoryClass());
+    Error& malformed_error = Error::Handle();
     if (factory_class.IsSubtypeOf(TypeArguments::Handle(),
                                   type_class,
-                                  TypeArguments::Handle())) {
+                                  TypeArguments::Handle(),
+                                  &malformed_error)) {
       // Class finalization verifies that the factory class has identical type
       // parameters as the interface.
       constructor_class_name = factory_class.Name();
     }
     // Always change the result type of the constructor to the factory type.
     constructor_class = factory_class.raw();
     // The finalized type_arguments are still those of the interface type.
     ASSERT(!constructor_class.is_interface());
   }
 
@@ skipping 83 matching lines @@
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
+    // TODO(regis): If the type argument vector is not instantiated, we need to
+    // verify in checked mode at runtime that it is within its declared bounds.
     new_object = new ConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(ArrayNode* values) {
   const String& class_name =
       String::Handle(String::NewSymbol(kStringClassName));
@@ skipping 560 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart