Change compile-time errors into dynamic errors in instance creation expression

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 1495 matching lines @@
     if (super_function.IsNull()) {
       ErrorMsg(field_pos, "field or getter '%s' not found in superclass",
                field_name.ToCString());
     }
     return CreateImplicitClosureNode(super_function,
                                      field_pos,
                                      implicit_argument);
   }
 
   return new StaticGetterNode(
-                 field_pos, implicit_argument, true, super_class, field_name);
+      field_pos, implicit_argument, true, super_class, field_name);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           LocalVariable* receiver) {
   const intptr_t supercall_pos = TokenPos();
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
@@ skipping 2112 matching lines @@
     do {
       ConsumeToken();
       type = ParseType(finalization);
       // Only keep the error for the first malformed type argument.
       if (malformed_error->IsNull() && type.IsMalformed()) {
         *malformed_error = type.malformed_error();
       }
       // Map a malformed type argument to Dynamic, so that malformed types with
       // a resolved type class are handled properly in production mode.
       if (type.IsMalformed()) {
+        ASSERT(finalization != ClassFinalizer::kCanonicalizeWellFormed);
+        if (finalization == ClassFinalizer::kCanonicalizeForCreation) {
+          ErrorMsg(*malformed_error);
+        }
         type = Type::DynamicType();
       }
       types.Add(type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
@@ skipping 3010 matching lines @@
   // Malformed type error.
   const Error& error = Error::Handle(type.malformed_error());
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New(error.ToErrorCString()))));
   const String& cls_name = String::Handle(Symbols::TypeError());
   const String& func_name = String::Handle(Symbols::ThrowNew());
   return MakeStaticCall(cls_name, func_name, arguments);
 }
 
 
+AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos, const String& name) {
+  ArgumentListNode* arguments = new ArgumentListNode(call_pos);
+  // Location argument.
+  arguments->Add(new LiteralNode(
+      call_pos, Integer::ZoneHandle(Integer::New(call_pos))));
+  // Function name argument.
+  arguments->Add(new LiteralNode(
+      call_pos, String::ZoneHandle(Symbols::New(name))));
+  const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
+  const String& func_name = String::Handle(Symbols::ThrowNew());
+  return MakeStaticCall(cls_name, func_name, arguments);
+}
+
+
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   if (IsLiteral("as")) {  // Not a reserved word.
     token_kind_ = Token::kAS;
   }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
@@ skipping 248 matching lines @@
     *expr = right_node;
     return left_node;
   }
   return *expr;
 }
 
 
 // Ensure that the expression temp is allocated for nodes that may need it.
 AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
   AstNode* result = original->MakeAssignmentNode(rhs);
+  if ((result == NULL) && original->IsStaticGetterNode()) {
+    const String& setter_name = String::ZoneHandle(
+        Field::SetterSymbol(original->AsStaticGetterNode()->field_name()));
+    result = ThrowNoSuchMethodError(original->token_pos(), setter_name);
+  }
   if ((result != NULL) &&
       (result->IsStoreIndexedNode() ||
        result->IsInstanceSetterNode() ||
        result->IsStaticSetterNode() ||
        result->IsStoreStaticFieldNode() ||
        result->IsStoreLocalNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
@@ skipping 255 matching lines @@
                                        false,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
         return new ClosureCallNode(call_pos, closure, arguments);
       }
     } else {
       EnsureExpressionTemp();
       closure = GenerateStaticFieldLookup(field, call_pos);
       return new ClosureCallNode(call_pos, closure, arguments);
     }
-    // Could not resolve static method: throw an exception if the arguments
-    // do not match or compile time error otherwise.
-    const Function& test_func = Function::Handle(
-        Resolver::ResolveStaticByName(cls, func_name, Resolver::kIsQualified));
-    if (test_func.IsNull()) {
-      ErrorMsg(ident_pos, "unresolved static method '%s'",
-          func_name.ToCString());
-    } else {
-      ArgumentListNode* arguments = new ArgumentListNode(ident_pos);
-      arguments->Add(new LiteralNode(
-          TokenPos(), Integer::ZoneHandle(Integer::New(ident_pos))));
-      const String& cls_name =
-          String::Handle(Symbols::StaticResolutionException());
-      const String& func_name = String::Handle(Symbols::ThrowNew());
-      return MakeStaticCall(cls_name, func_name, arguments);
-    }
+    // Could not resolve static method: throw a NoSuchMethodError.
+    return ThrowNoSuchMethodError(ident_pos, func_name);
   }
   CheckFunctionIsCallable(call_pos, func);
   return new StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
   TRACE_PARSER("ParseInstanceCall");
   const intptr_t call_pos = TokenPos();
   if (CurrentToken() != Token::kLPAREN) {
@@ skipping 51 matching lines @@
       const String& setter_name =
           String::ZoneHandle(Field::SetterName(field_name));
       const int kNumArguments = 1;  // value.
       const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      setter_name,
                                      kNumArguments,
                                      kNoArgumentNames,
                                      Resolver::kIsQualified);
       if (func.IsNull()) {
-        // No field or explicit setter function, this is an error.
-        ErrorMsg(ident_pos, "unknown static field '%s'",
-                 field_name.ToCString());
+        // No field or explicit setter function, throw a NoSuchMethodError.
+        return ThrowNoSuchMethodError(ident_pos, field_name);
       }
 
       // Explicit setter function for the field found, field does not exist.
       // Create a getter node first in case it is needed. If getter node
       // is used as part of, e.g., "+=", and the explicit getter does not
       // exist, and error will be reported by the code generator.
       access = new StaticGetterNode(call_pos,
                                     NULL,
                                     false,
                                     Class::ZoneHandle(cls.raw()),
@@ skipping 19 matching lines @@
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      kNoArgumentNames,
                                      Resolver::kIsQualified);
       if (func.IsNull()) {
         // We might be referring to an implicit closure, check to see if
         // there is a function of the same name.
         func = cls.LookupStaticFunction(field_name);
         if (func.IsNull()) {
-          // No field or explicit getter function, this is an error.
-          ErrorMsg(ident_pos,
-                   "unknown static field '%s'", field_name.ToCString());
+          // No field or explicit getter function, throw a NoSuchMethodError.
+          return ThrowNoSuchMethodError(ident_pos, field_name);
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         access = new StaticGetterNode(call_pos,
                                       NULL,
                                       false,
                                       Class::ZoneHandle(cls.raw()),
                                       field_name);
       }
     } else {
       access = GenerateStaticFieldLookup(field, TokenPos());
     }
   }
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
     return node;
   }
   PrimaryNode* primary = node->AsPrimaryNode();
   if (primary->primary().IsString()) {
-    // In a static method, an unresolved identifier is an error.
+    // In a static method, evaluation of an unresolved identifier causes a
+    // NoSuchMethodError to be thrown.
     // In an instance method, we convert this into a getter call
     // for a field (which may be defined in a subclass.)
     String& name = String::CheckedZoneHandle(primary->primary().raw());
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
-      ErrorMsg(primary->token_pos(),
-               "identifier '%s' is not declared in this scope",
-               name.ToCString());
+      return ThrowNoSuchMethodError(primary->token_pos(), name);
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
 
 AstNode* Parser::LoadClosure(PrimaryNode* primary) {
@@ skipping 104 matching lines @@
                        "cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
         } else if (primary->primary().IsString()) {
           // Primary is an unresolved name.
           String& name = String::CheckedZoneHandle(primary->primary().raw());
           if (current_function().is_static()) {
-            ErrorMsg(primary->token_pos(),
-                     "identifier '%s' is not declared in this scope",
-                     name.ToCString());
+            selector = ThrowNoSuchMethodError(primary->token_pos(), name);
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_pos());
             selector = ParseInstanceCall(receiver, name);
           }
         } else if (primary->primary().IsClass()) {
           ErrorMsg(left->token_pos(),
                    "must use 'new' or 'const' to construct new instance");
         } else {
           UNREACHABLE();  // Internal parser error.
@@ skipping 819 matching lines @@
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
-      // method, this is an error. In an instance method, we convert
+      // method, evaluation of an unresolved identifier causes a
+      // NoSuchMethodError to be thrown. In an instance method, we convert
       // the unresolved name to an instance field access, since a
       // subclass might define a field with this name.
       if (current_function().is_static()) {
-        ErrorMsg(ident_pos, "identifier '%s' is not declared in this scope",
-                 ident.ToCString());
+        resolved = ThrowNoSuchMethodError(ident_pos, ident);
       } else {
         // Treat as call to unresolved instance field.
         resolved = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
     } else if (primary->primary().IsFunction()) {
       if (allow_closure_names) {
         resolved = LoadClosure(primary);
       } else {
         ErrorMsg(ident_pos, "illegal reference to method '%s'",
                  ident.ToCString());
@@ skipping 488 matching lines @@
   TRACE_PARSER("ParseNewOperator");
   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));
+      ParseType(ClassFinalizer::kCanonicalizeForCreation));
   // 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() ?
@@ skipping 10 matching lines @@
     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.
+  // Parsing is complete, so we can return a throw in case of a malformed type
+  // or report a compile-time error if the constructor is const.
   if (type.IsMalformed()) {
+    if (is_const) {
+      const Error& error = Error::Handle(type.malformed_error());
+      ErrorMsg(error);
+    }
     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
@@ skipping 10 matching lines @@
   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()) {
-      // Replace the type with a malformed type and compile a throw.
+      // Replace the type with a malformed type and compile a throw or report
+      // a compile-time error if the constructor is const.
       type = ClassFinalizer::NewFinalizedMalformedType(
           current_class(),
-          type_pos,
+          call_pos,
           "interface '%s' has no constructor named '%s'",
           type_class_name.ToCString(),
           external_constructor_name.ToCString());
-      return ThrowTypeError(type_pos, type);
+      if (is_const) {
+        const Error& error = Error::Handle(type.malformed_error());
+        ErrorMsg(error);
+      }
+      return ThrowNoSuchMethodError(call_pos, external_constructor_name);
     }
-    // TODO(regis): Throw a NoSuchMethodError instead of a TypeError.
     String& error_message = String::Handle();
     if (!constructor.AreValidArguments(arguments_length,
                                        arguments->names(),
                                        &error_message)) {
-      // 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);
+      if (is_const) {
+        ErrorMsg(call_pos,
+                 "invalid arguments passed to constructor '%s' "
+                 "for interface '%s': %s",
+                 external_constructor_name.ToCString(),
+                 type_class_name.ToCString(),
+                 error_message.ToCString());
+      }
+      return ThrowNoSuchMethodError(call_pos, external_constructor_name);
     }
     // 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 =
@@ skipping 21 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);
-      // Replace the type with a malformed type and compile a throw.
+      // Replace the type with a malformed type and compile a throw or report a
+      // compile-time error if the constructor is const.
       type = ClassFinalizer::NewFinalizedMalformedType(
           current_class(),
-          type_pos,
+          call_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);
+      if (is_const) {
+        const Error& error = Error::Handle(type.malformed_error());
+        ErrorMsg(error);
+      }
+      return ThrowNoSuchMethodError(call_pos, external_constructor_name);
     } else if (constructor.IsRedirectingFactory()) {
       type = constructor.RedirectionType();
       if (type.IsMalformed()) {
+        if (is_const) {
+          const Error& error = Error::Handle(type.malformed_error());
+          ErrorMsg(error);
+        }
         return ThrowTypeError(type.token_pos(), type);
       }
       constructor = constructor.RedirectionTarget();
       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.IsFactory()) {
@@ skipping 10 matching lines @@
     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.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
-    // 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);
+    if (is_const) {
+      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());
+    }
+    return ThrowNoSuchMethodError(call_pos, external_constructor_name);
   }
 
   // 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 24 matching lines @@
     // of the super type when finalizing the temporary type.
     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);
     }
   }
+  // Return a throw in case of a malformed type or report a compile-time error
+  // if the constructor is const.
   if (type.IsMalformed()) {
-    // Return the throw of a dynamic type error if the type is malformed.
+    if (is_const) {
+      const Error& error = Error::Handle(type.malformed_error());
+      ErrorMsg(error);
+    }
     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