- Fix the external_test.dart as it was relying on outdated

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 2833 matching lines @@
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ErrorMsg("constructors may not return a value");
   } else if (IsLiteral("native")) {
     ErrorMsg("native constructors not supported");
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Some constructors have no function body.
     ConsumeToken();
+    if (func.is_external()) {
+      // Body of an external method contains a single throw.
+      const String& function_name = String::ZoneHandle(func.name());
+      current_block_->statements->Add(
+          ThrowNoSuchMethodError(TokenPos(),
+                                 cls,
+                                 function_name,
+                                 NULL,   // No arguments.
+                                 InvocationMirror::kStatic,
+                                 InvocationMirror::kMethod,
+                                 NULL));  // No existing function.
+    }
   } else {
     UnexpectedToken();
   }
 
   SequenceNode* ctor_block = CloseBlock();
   if (ctor_block->length() > 0) {
     // Generate guard around the constructor body code.
     LocalVariable* phase_param = LookupPhaseParameter();
     AstNode* phase_value =
         new LoadLocalNode(Scanner::kNoSourcePos, phase_param);
@@ skipping 149 matching lines @@
       }
     }
     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());
     current_block_->statements->Add(
         ThrowNoSuchMethodError(TokenPos(),
-                               current_class(),
+                               Class::Handle(func.Owner()),
                                function_name,
                                NULL,  // Ignore arguments.
                                func.is_static() ?
                                    InvocationMirror::kStatic :
                                    InvocationMirror::kDynamic,
                                InvocationMirror::kMethod,
                                &func));  // Unpatched external function.
     end_token_pos = TokenPos();
   } else {
     UnexpectedToken();
@@ skipping 226 matching lines @@
   Type& redirection_type = Type::Handle(isolate());
   String& redirection_identifier = String::Handle(isolate());
   bool is_redirecting = false;
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     // Default parameter values are disallowed in redirecting factories.
     if (method->params.has_explicit_default_values) {
       ErrorMsg("redirecting factory '%s' may not specify default values "
                "for optional parameters",
                method->name->ToCString());
     }
+    if (method->has_external) {
+      ErrorMsg(TokenPos(),
+               "external factory constructor '%s' may not have redirection",
+               method->name->ToCString());
+    }
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     is_redirecting = true;
     const AbstractType& type = AbstractType::Handle(isolate(),
         ParseType(ClassFinalizer::kResolveTypeParameters));
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(isolate()),  // No previous error.
           script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
           String::Handle(isolate(), type.UserVisibleName()).ToCString());
     } else {
       // We handle malformed and malbounded redirection type at run time.
       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");
     }
+    if (method->has_external) {
+      ErrorMsg(TokenPos(),
+               "external constructor '%s' may not have initializers",
+               method->name->ToCString());
+    }
     if ((LookaheadToken(1) == Token::kTHIS) &&
         ((LookaheadToken(2) == Token::kLPAREN) ||
          LookaheadToken(4) == Token::kLPAREN)) {
       // Redirected constructor: either this(...) or this.xxx(...).
       is_redirecting = true;
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
         ErrorMsg(formal_param_pos, "Redirecting constructor "
                  "may not use field initializer parameters");
@@ skipping 11 matching lines @@
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
       SkipInitializers();
     }
   }
 
   // Only constructors can redirect to another method.
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
+  if (method->IsConstructor() &&
+      method->has_external &&
+      method->params.has_field_initializer) {
+    ErrorMsg(method->name_pos,
+             "external constructor '%s' may not have field initializers",
+             method->name->ToCString());
+  }
+
   intptr_t method_end_pos = TokenPos();
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
-      ErrorMsg(method->name_pos,
+      ErrorMsg(TokenPos(),
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->has_external) {
-      ErrorMsg(method->name_pos,
-               "external method '%s' may not have a function body",
+      ErrorMsg(TokenPos(),
+               "external %s '%s' may not have a function body",
+               method->IsFactoryOrConstructor() ? "constructor" : "method",
                method->name->ToCString());
     } else if (method->IsConstructor() && method->has_const) {
-      ErrorMsg(method->name_pos,
+      ErrorMsg(TokenPos(),
                "const constructor '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->IsFactory() && method->has_const) {
-      ErrorMsg(method->name_pos,
+      ErrorMsg(TokenPos(),
                "const factory '%s' may not have a function body",
                method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
       method_end_pos = TokenPos();
@@ skipping 7679 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart