Change many instance creation errors from compile-time errors to dynamic errors

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 2435 matching lines @@
   }
 
   // Parse redirecting factory constructor.
   Type& redirection_type = Type::Handle();
   String& redirection_identifier = String::Handle();
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kTryResolve));
-    if (type.IsTypeParameter()) {
-      // TODO(regis): Spec is not clear. Throw dynamic error or report
-      // compile-time error? Same question for new and const operators.
-      ErrorMsg(type_pos, "factory may not redirect via a type parameter");
+    if (type.IsTypeParameter() || type.IsDynamicType()) {
+      // Replace the type with a malformed type and compile a throw when called.
+      redirection_type = ClassFinalizer::NewFinalizedMalformedType(
+          current_class(),
+          type_pos,
+          "factory '%s' may not redirect to %s'%s'",
+          method->name->ToCString(),
+          type.IsTypeParameter() ? "type parameter " : "",
+          type.IsTypeParameter() ?
+              String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
+    } else {
+      redirection_type ^= type.raw();
     }
-    redirection_type ^= type.raw();
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor or factory.
       ConsumeToken();
       redirection_identifier = ExpectIdentifier("identifier expected")->raw();
     }
   } else if (CurrentToken() == Token::kCOLON) {
     // Parse initializers.
     if (!method->IsConstructor()) {
       ErrorMsg("initializers only allowed on constructors");
     }
@@ skipping 6379 matching lines @@
   const intptr_t new_pos = TokenPos();
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeWellFormed));
-  // Malformed bounds never result in a compile time error, therefore, the
-  // parsed type may be malformed although we requested kCanonicalizeWellFormed.
-  // 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.UserVisibleName()).ToCString());
+  // In case the type is malformed, throw a dynamic type error after finishing
+  // parsing the instance creation expression.
+  if (type.IsTypeParameter() || type.IsDynamicType()) {
+    // Replace the type with a malformed type.
+    type = ClassFinalizer::NewFinalizedMalformedType(
+        current_class(),
+        type_pos,
+        "%s'%s' cannot be instantiated",
+        type.IsTypeParameter() ? "type parameter " : "",
+        type.IsTypeParameter() ?
+            String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
   }
-  if (type.IsDynamicType()) {
-    ErrorMsg(type_pos, "Dynamic cannot be instantiated");
-  }
-  Class& type_class = Class::Handle(type.type_class());
-  const String& type_class_name = String::Handle(type_class.Name());
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::ZoneHandle(type.arguments());
-
-  // The constructor class and its name are those of the parsed type, unless the
-  // parsed type is an interface and a default factory class is specified, in
-  // which case constructor_class and constructor_class_name are modified below.
-  Class& constructor_class = Class::ZoneHandle(type_class.raw());
-  String& constructor_class_name = String::Handle(type_class_name.raw());
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that ParseType(kMustResolve) above will not
   // consume it as part of a misinterpreted qualified identifier, because only a
   // valid library prefix is accepted as qualifier.
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   intptr_t call_pos = TokenPos();
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
+  // Parsing is complete, so we can return a throw in case of a malformed type.
+  if (type.IsMalformed()) {
+    return ThrowTypeError(type_pos, type);
+  }
+
+  // Resolve the type and optional identifier to a constructor or factory.
+  Class& type_class = Class::Handle(type.type_class());
+  const String& type_class_name = String::Handle(type_class.Name());
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::ZoneHandle(type.arguments());
+
+  // The constructor class and its name are those of the parsed type, unless the
+  // parsed type is an interface and a default factory class is specified, in
+  // which case constructor_class and constructor_class_name are modified below.
+  Class& constructor_class = Class::ZoneHandle(type_class.raw());
+  String& constructor_class_name = String::Handle(type_class_name.raw());
+
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
   if (type_class.is_interface()) {
     // We need to make sure that an appropriate constructor is
     // declared in the interface.
     const String& constructor_name =
         BuildConstructorName(type_class_name, named_constructor);
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     Function& constructor = Function::ZoneHandle(
         type_class.LookupConstructor(constructor_name));
     if (constructor.IsNull()) {
-      ErrorMsg(type_pos,
-               "interface '%s' has no constructor named '%s'",
-               type_class_name.ToCString(),
-               external_constructor_name.ToCString());
+      // Replace the type with a malformed type and compile a throw.
+      type = ClassFinalizer::NewFinalizedMalformedType(
+          current_class(),
+          type_pos,
+          "interface '%s' has no constructor named '%s'",
+          type_class_name.ToCString(),
+          external_constructor_name.ToCString());
+      return ThrowTypeError(type_pos, type);
     }
+    // TODO(regis): Throw a NoSuchMethodError instead of a TypeError.
     String& error_message = String::Handle();
     if (!constructor.AreValidArguments(arguments_length,
                                        arguments->names(),
                                        &error_message)) {
-      ErrorMsg(call_pos,
-               "invalid arguments passed to constructor '%s' "
-               "for interface '%s': %s",
-               external_constructor_name.ToCString(),
-               type_class_name.ToCString(),
-               error_message.ToCString());
+      // Replace the type with a malformed type and compile a throw.
+      type = ClassFinalizer::NewFinalizedMalformedType(
+          current_class(),
+          call_pos,
+          "invalid arguments passed to constructor '%s' "
+          "for interface '%s': %s",
+          external_constructor_name.ToCString(),
+          type_class_name.ToCString(),
+          error_message.ToCString());
+      return ThrowTypeError(call_pos, type);
     }
+    // TODO(regis): Remove support for obsolete default factory classes.
     if (!type_class.HasFactoryClass()) {
       ErrorMsg(type_pos,
                "cannot allocate interface '%s' without factory class",
                type_class_name.ToCString());
     }
     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());
@@ skipping 19 matching lines @@
   // Make sure that an appropriate constructor exists.
   const String& constructor_name =
       BuildConstructorName(constructor_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(
       constructor_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = constructor_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : constructor_class_name);
-      ErrorMsg(type_pos,
-               "class '%s' has no constructor or factory named '%s'",
-               String::Handle(constructor_class.Name()).ToCString(),
-               external_constructor_name.ToCString());
+      // Replace the type with a malformed type and compile a throw.
+      type = ClassFinalizer::NewFinalizedMalformedType(
+          current_class(),
+          type_pos,
+          "class '%s' has no constructor or factory named '%s'",
+          String::Handle(constructor_class.Name()).ToCString(),
+          external_constructor_name.ToCString());
+      return ThrowTypeError(type_pos, type);
     } else if (constructor.IsRedirectingFactory()) {
       type = constructor.RedirectionType();
+      if (type.IsMalformed()) {
+        return ThrowTypeError(type.token_pos(), type);
+      }
       constructor = constructor.RedirectionTarget();
-      if (constructor.IsNull()) {
-        // TODO(regis): We normally report a compile-time error if the
-        // constructor is not found. See above. However, we should throw a
-        // dynamic error instead. We do it here. This is the first step.
-        ASSERT(type.IsMalformed());
-      } else {
-        type_class = type.type_class();
-        type_arguments = type.arguments();
-        constructor_class = constructor.Owner();
-        ASSERT(type_class.raw() == constructor_class.raw());
-      }
+      ASSERT(!constructor.IsNull());
+      type_class = type.type_class();
+      type_arguments = type.arguments();
+      constructor_class = constructor.Owner();
+      ASSERT(type_class.raw() == constructor_class.raw());
     }
-    if (!constructor.IsNull() && constructor.IsFactory()) {
+    if (constructor.IsFactory()) {
       // A factory does not have the implicit 'phase' parameter.
       arguments_length -= 1;
     }
   }
 
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
-  if (!constructor.IsNull() &&
-      constructor_class.is_abstract() &&
+  ASSERT(!constructor.IsNull());
+  if (constructor_class.is_abstract() &&
       !constructor.IsFactory()) {
     ArgumentListNode* arguments = new ArgumentListNode(type_pos);
     arguments->Add(new LiteralNode(
         TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
     arguments->Add(new LiteralNode(
         TokenPos(), String::ZoneHandle(constructor_class_name.raw())));
     const String& cls_name =
         String::Handle(Symbols::AbstractClassInstantiationError());
     const String& func_name = String::Handle(Symbols::ThrowNew());
     return MakeStaticCall(cls_name, func_name, arguments);
   }
-
+  // TODO(regis): Throw a NoSuchMethodError instead of a TypeError.
   String& error_message = String::Handle();
-  if (!constructor.IsNull() &&
-      !constructor.AreValidArguments(arguments_length,
+  if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
-    ErrorMsg(call_pos,
-             "invalid arguments passed to constructor '%s' for class '%s': %s",
-             external_constructor_name.ToCString(),
-             String::Handle(constructor_class.Name()).ToCString(),
-             error_message.ToCString());
+    // Replace the type with a malformed type and compile a throw when called.
+    type = ClassFinalizer::NewFinalizedMalformedType(
+      current_class(),
+      call_pos,
+      "invalid arguments passed to constructor '%s' for class '%s': %s",
+      external_constructor_name.ToCString(),
+      String::Handle(constructor_class.Name()).ToCString(),
+      error_message.ToCString());
+    return ThrowTypeError(call_pos, type);
   }
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   // The type argument vector of the parsed type was finalized in ParseType.
   // If the constructor class was changed from the interface class to the
   // factory class, we need to finalize the type argument vector again, because
   // it may be longer due to the factory class extending a class, or/and because
   // the bounds on the factory class may be tighter than on the interface.
   if (!constructor.IsNull() && (constructor_class.raw() != type_class.raw())) {
@@ skipping 25 matching lines @@
     type_arguments = temp_type.arguments();
     // The type parameter bounds of the factory class may be more specific than
     // the type parameter bounds of the interface class. Therefore, although
     // type was not malformed, temp_type may be malformed.
     if (!type.IsMalformed() && temp_type.IsMalformed()) {
       const Error& error = Error::Handle(temp_type.malformed_error());
       type.set_malformed_error(error);
     }
   }
   if (type.IsMalformed()) {
-    // Compile the throw of a dynamic type error due to a bound error or to
-    // a redirection error.
+    // Return the throw of a dynamic type error if the type is malformed.
     return ThrowTypeError(type_pos, type);
   }
   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());
     }
@@ skipping 613 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart