Remove NoSuchMethodErrorImplementation class and use NoSuchMethodError from core

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 2297 matching lines @@
     ConsumeToken();
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else if (func.is_external()) {
     // Body of an external method contains a single throw.
     const String& function_name = String::ZoneHandle(func.name());
+    // TODO(regis): For an instance function, pass the receiver to
+    // NoSuchMethodError.
     current_block_->statements->Add(
-        ThrowNoSuchMethodError(TokenPos(), function_name));
+        ThrowNoSuchMethodError(TokenPos(), current_class(), function_name));
   } else {
     UnexpectedToken();
   }
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   return CloseBlock();
 }
 
 
@@ skipping 4261 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) {
+// TODO(regis): Providing the argument values is not always feasible, since
+// evaluating them could throw an error.
+// Should NoSuchMethodError reflect the argument count and names instead of
+// argument values? Or should the spec specify a different evaluation order?
+AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
+                                        const Class& cls,
+                                        const String& function_name) {
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
-  // Location argument.
+  // Object receiver.
+  // TODO(regis): For now, we pass a class literal of the unresolved
+  // method's owner, but this is not specified and will probably change.
+  Type& type = Type::ZoneHandle(
+      Type::New(cls, TypeArguments::Handle(), call_pos, Heap::kOld));
+  type ^= ClassFinalizer::FinalizeType(
+      current_class(), type, ClassFinalizer::kCanonicalize);
+  arguments->Add(new LiteralNode(call_pos, type));
+  // String memberName.
   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))));
+      call_pos, String::ZoneHandle(Symbols::New(function_name))));
+  // List arguments.
+  arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+  // List argumentNames.
+  arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+  // List existingArgumentNames.
+  arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
   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();
@@ skipping 268 matching lines @@
 }
 
 
 // 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->IsTypeNode()) {
     const String& type_name = String::ZoneHandle(
         original->AsTypeNode()->type().ClassName());
     // TODO(tball): determine whether NoSuchMethod should be called instead.
-    result = ThrowNoSuchMethodError(original->token_pos(), type_name);
+    result = ThrowNoSuchMethodError(original->token_pos(),
+                                    current_class(),
+                                    type_name);
   }
   if ((result != NULL) &&
       (result->IsStoreIndexedNode() ||
        result->IsInstanceSetterNode() ||
        result->IsStaticSetterNode() ||
        result->IsStoreStaticFieldNode() ||
        result->IsStoreLocalNode())) {
     EnsureExpressionTemp();
   }
   return result;
@@ skipping 263 matching lines @@
                                        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 a NoSuchMethodError.
-    return ThrowNoSuchMethodError(ident_pos, func_name);
+    return ThrowNoSuchMethodError(ident_pos, cls, func_name);
   }
   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) {
     ErrorMsg(call_pos, "left parenthesis expected");
@@ skipping 51 matching lines @@
           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, throw a NoSuchMethodError.
-        return ThrowNoSuchMethodError(ident_pos, field_name);
+        return ThrowNoSuchMethodError(ident_pos, cls, 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 20 matching lines @@
                                      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, throw a NoSuchMethodError.
-          return ThrowNoSuchMethodError(ident_pos, field_name);
+          return ThrowNoSuchMethodError(ident_pos, cls, 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);
       }
@@ skipping 14 matching lines @@
     if (primary->IsSuper()) {
       return primary;
     }
     // 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()) {
-      return ThrowNoSuchMethodError(primary->token_pos(), name);
+      return ThrowNoSuchMethodError(primary->token_pos(),
+                                    current_class(),
+                                    name);
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
 
 AstNode* Parser::LoadClosure(PrimaryNode* primary) {
@@ skipping 116 matching lines @@
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
         } else if (primary->primary().IsString()) {
           // Primary is an unresolved name.
           if (primary->IsSuper()) {
             ErrorMsg(primary->token_pos(), "illegal use of super");
           }
           String& name = String::CheckedZoneHandle(primary->primary().raw());
           if (current_function().is_static()) {
-            selector = ThrowNoSuchMethodError(primary->token_pos(), name);
+            selector = ThrowNoSuchMethodError(primary->token_pos(),
+                                              current_class(),
+                                              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 884 matching lines @@
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
       // 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()) {
-        resolved = ThrowNoSuchMethodError(ident_pos, ident);
+        resolved = ThrowNoSuchMethodError(ident_pos, current_class(), 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 583 matching lines @@
       BuildConstructorName(type_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(
       type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
       // 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(
-          Error::Handle(),  // No previous error.
-          current_class(),
-          call_pos,
-          ClassFinalizer::kTryResolve,  // No compile-time error.
-          "class '%s' has no constructor or factory named '%s'",
-          String::Handle(type_class.Name()).ToCString(),
-          external_constructor_name.ToCString());
       if (is_const) {
+        type = ClassFinalizer::NewFinalizedMalformedType(
+            Error::Handle(),  // No previous error.
+            current_class(),
+            call_pos,
+            ClassFinalizer::kTryResolve,  // No compile-time error.
+            "class '%s' has no constructor or factory named '%s'",
+            String::Handle(type_class.Name()).ToCString(),
+            external_constructor_name.ToCString());
         const Error& error = Error::Handle(type.malformed_error());
         ErrorMsg(error);
       }
-      return ThrowNoSuchMethodError(call_pos, external_constructor_name);
+      return ThrowNoSuchMethodError(call_pos,
+                                    type_class,
+                                    external_constructor_name);
     } else if (constructor.IsRedirectingFactory()) {
       Type& redirect_type = Type::Handle(constructor.RedirectionType());
       if (!redirect_type.IsMalformed() && !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments);
       }
       if (redirect_type.IsMalformed()) {
         if (is_const) {
           const Error& error = Error::Handle(redirect_type.malformed_error());
@@ skipping 38 matching lines @@
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     if (is_const) {
       ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
                "for class '%s': %s",
                external_constructor_name.ToCString(),
                String::Handle(type_class.Name()).ToCString(),
                error_message.ToCString());
     }
-    return ThrowNoSuchMethodError(call_pos, external_constructor_name);
+    return ThrowNoSuchMethodError(call_pos,
+                                  type_class,
+                                  external_constructor_name);
   }
 
   // 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);
@@ skipping 650 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart