Address TODOs and remove obsolete ones.

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 2984 matching lines @@
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseNativeFunctionBlock(&params, func);
     end_token_pos = TokenPos();
     ExpectSemicolon();
   } else if (func.is_external()) {
     // Body of an external method contains a single throw.
     const String& function_name = String::ZoneHandle(I, func.name());
-    // TODO(regis): For an instance function, pass the receiver to
-    // NoSuchMethodError.
     current_block_->statements->Add(
         ThrowNoSuchMethodError(TokenPos(),
                                current_class(),
                                function_name,
-                               NULL,   // No arguments.
+                               NULL,  // Ignore arguments.
                                func.is_static() ?
                                    InvocationMirror::kStatic :
                                    InvocationMirror::kDynamic,
                                InvocationMirror::kMethod,
-                               NULL));  // No existing function.
+                               &func));  // Unpatched external function.
     end_token_pos = TokenPos();
   } else {
     UnexpectedToken();
   }
 
   ASSERT(func.end_token_pos() == func.token_pos() ||
          func.end_token_pos() == end_token_pos);
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
@@ skipping 917 matching lines @@
         orig_type_parameters.IsNull() ? 0 : orig_type_parameters.Length();
     if (new_type_params_count != orig_type_params_count) {
       ErrorMsg(classname_pos,
                "class '%s' must be patched with identical type parameters",
                class_name.ToCString());
     }
     TypeParameter& new_type_param = TypeParameter::Handle(isolate());
     TypeParameter& orig_type_param = TypeParameter::Handle(isolate());
     String& new_name = String::Handle(isolate());
     String& orig_name = String::Handle(isolate());
+    AbstractType& new_bound = AbstractType::Handle(isolate());
+    AbstractType& orig_bound = AbstractType::Handle(isolate());
     for (int i = 0; i < new_type_params_count; i++) {
       new_type_param ^= new_type_parameters.TypeAt(i);
       orig_type_param ^= orig_type_parameters.TypeAt(i);
       new_name = new_type_param.name();
       orig_name = orig_type_param.name();
       if (!new_name.Equals(orig_name)) {
         ErrorMsg(new_type_param.token_pos(),
                  "type parameter '%s' of patch class '%s' does not match "
                  "original type parameter '%s'",
                  new_name.ToCString(),
                  class_name.ToCString(),
                  orig_name.ToCString());
       }
-      // We do not check that the bounds are repeated. We use the original ones.
-      // TODO(regis): Should we check?
+      new_bound = new_type_param.bound();
+      orig_bound = orig_type_param.bound();
+      if (!new_bound.Equals(orig_bound)) {
+        ErrorMsg(new_type_param.token_pos(),
+                 "bound '%s' of type parameter '%s' of patch class '%s' does "
+                 "not match original type parameter bound '%s'",
+                 String::Handle(new_bound.UserVisibleName()).ToCString(),
+                 new_name.ToCString(),
+                 class_name.ToCString(),
+                 String::Handle(orig_bound.UserVisibleName()).ToCString());
+      }
     }
     cls.set_type_parameters(orig_type_parameters);
   }
 
   if (is_abstract) {
     cls.set_is_abstract();
   }
   if (metadata_pos >= 0) {
     library_.AddClassMetadata(cls, toplevel_class, metadata_pos);
   }
@@ skipping 3649 matching lines @@
                         arguments);
 }
 
 
 AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
                                         const Class& cls,
                                         const String& function_name,
                                         ArgumentListNode* function_arguments,
                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type,
-                                        Function* func) {
+                                        const Function* func) {
   ArgumentListNode* arguments = new(isolate()) ArgumentListNode(call_pos);
   // 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(I,
-      Type::New(cls, TypeArguments::Handle(isolate()), call_pos, Heap::kOld));
-  type ^= ClassFinalizer::FinalizeType(
-      current_class(), type, ClassFinalizer::kCanonicalize);
-  arguments->Add(new(isolate()) LiteralNode(call_pos, type));
+  // If the function is external and dynamic, pass the actual receiver,
+  // otherwise, pass a class literal of the unresolved method's owner.
+  if ((func != NULL) && !func->IsNull() &&
+      func->is_external() && !func->is_static()) {
+    arguments->Add(LoadReceiver(func->token_pos()));
+  } else {
+    Type& type = Type::ZoneHandle(I,
+        Type::New(cls, TypeArguments::Handle(isolate()), call_pos, Heap::kOld));
+    type ^= ClassFinalizer::FinalizeType(
+        current_class(), type, ClassFinalizer::kCanonicalize);
+    arguments->Add(new(isolate()) LiteralNode(call_pos, type));
+  }
   // String memberName.
   arguments->Add(new(isolate()) LiteralNode(
       call_pos, String::ZoneHandle(I, Symbols::New(function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
   }
   arguments->Add(new(isolate()) LiteralNode(call_pos, Smi::ZoneHandle(I,
@@ skipping 21 matching lines @@
   // has done the lookup already. If there is a function with the same
   // name but incompatible parameters, inform the NoSuchMethodError what the
   // expected parameters are.
   Function& function = Function::Handle(isolate());
   if (func != NULL) {
     function = func->raw();
   } else {
     function = cls.LookupStaticFunction(function_name);
   }
   Array& array = Array::ZoneHandle(I);
-  if (!function.IsNull()) {
+  // An unpatched external function is treated as an unresolved function.
+  if (!function.IsNull() && !function.is_external()) {
     // The constructor for NoSuchMethodError takes a list of existing
     // parameter names to produce a descriptive error message explaining
     // the parameter mismatch. The problem is that the array of names
     // does not describe which parameters are optional positional or
     // named, which can lead to confusing error messages.
     // Since the NoSuchMethodError class only uses the list to produce
     // a string describing the expected parameters, we construct a more
     // descriptive string here and pass it as the only element of the
     // "existingArgumentNames" array of the NoSuchMethodError constructor.
     // TODO(13471): Separate the implementations of NoSuchMethodError
@@ skipping 2476 matching lines @@
             String::Handle(isolate(), type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
         ErrorMsg(Error::Handle(isolate(), type.error()));
       }
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
                                     arguments,
                                     InvocationMirror::kConstructor,
                                     InvocationMirror::kMethod,
-                                    &constructor);
+                                    NULL);  // No existing function.
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
       Type& redirect_type = Type::Handle(isolate(),
                                          constructor.RedirectionType());
       if (!redirect_type.IsMalformedOrMalbounded() &&
           !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.
         Error& error = Error::Handle(isolate());
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
@@ skipping 838 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart