Generate a dynamic type error when creating an instance with a bound error.

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 2934 matching lines @@
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       type_parameter = TypeParameter::New(index,
                                           type_parameter_name,
                                           token_index_);
       ConsumeToken();
       bound = Type::DynamicType();
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
-        bound = ParseType(ClassFinalizer::kTryResolve);
+        // A bound may refer to the owner of the type parameter it applies to,
+        // i.e. to the class or interface currently being parsed.
+        // Postpone resolution in order to avoid resolving the class and its
+        // type parameters, as they are not fully parsed yet.
+        bound = ParseType(ClassFinalizer::kDoNotResolve);
       }
       type_parameters_array.Add(type_parameter);
       bounds_array.Add(bound);
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
@@ skipping 2565 matching lines @@
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
   ASSERT(type.IsMalformed());
   ArgumentListNode* arguments = new ArgumentListNode(type_pos);
   // Location argument.
   arguments->Add(new LiteralNode(
       type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
   // Src value argument.
   arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
   // Dst type name argument.
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
-      String::NewSymbol("malformed type"))));
-  // Dst type name argument.
+      String::NewSymbol("malformed"))));
+  // Dst name argument.
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
     String::NewSymbol(""))));
   // Malformed type error.
   const Error& error = Error::Handle(type.malformed_error());
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       String::NewSymbol(error.ToErrorCString()))));
   return MakeStaticCall(kTypeErrorName, kThrowNewName, arguments);
 }
 
 
@@ skipping 1781 matching lines @@
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = token_index_;
   Error& malformed_error = Error::Handle();
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle(
       ParseTypeArguments(&malformed_error,
                          ClassFinalizer::kFinalizeWellFormed));
+  // Map and List interfaces do not declare bounds on their type parameters, so
+  // we should never see a malformed type error here.
+  // Note that a bound error is the only possible malformed type error returned
+  // when requesting kFinalizeWellFormed type finalization.

[srdjan, 2012/03/09 20:48:28]

What if we change the libraries? Can we check somewhere/somehow?

[regis, 2012/03/09 21:08:37]

We would need to add debug code here to resolve Map and List  and verify that
they do not declare bounds. It is not worth it, since if this core interfaces
are modified at some time (quite improbable) and someone specifies a type
argument out of bounds, the parser will hit the assert below in checked mode. 

+  ASSERT(malformed_error.IsNull());
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
@@ skipping 19 matching lines @@
 AstNode* Parser::ParseNewOperator() {
   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));
+  // Malformed bounds never result in a compile time error, therefore, the
+  // parsed type may be malformed although we requested kFinalizeWellFormed.
+  // In that case, we throw a dynamic type error instead of calling the
+  // constructor.
   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 =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
@@ skipping 142 matching lines @@
   }
 
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       ErrorMsg("'const' requires const constructor: '%s'",
           String::Handle(constructor.name()).ToCString());
     }
+    if (type.IsMalformed()) {
+      // Compile the throw of a dynamic type error due to a bound error.
+      return ThrowTypeError(type_pos, type);
+    }
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(constructor_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
       new_object = CreateEvalConstConstructorThrow(new_pos, constructor_result);
     } else {
       Instance& const_instance = Instance::ZoneHandle();
       const_instance ^= constructor_result.raw();
       new_object = new LiteralNode(new_pos, const_instance);
     }
   } 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();
     }
+    if (type.IsMalformed()) {
+      // Compile the throw of a dynamic type error due to a bound error.
+      return ThrowTypeError(type_pos, type);
+    }
     // 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) {
@@ skipping 562 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart