Report external without patch as an error.

tests/compiler/dart2js/patch_test.dart

 // 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.
 
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/util/util.dart";
 import "mock_compiler.dart";
 import "parser_helper.dart";
@@ skipping 22 matching lines @@
 
 void expectHasNoBody(compiler, Element element) {
     var node = element.parseNode(compiler);
     Expect.isNotNull(node, "Element isn't parseable, when a body was expected");
     Expect.isFalse(node.hasBody());
 }
 
 Element ensure(compiler,
                String name,
                Element lookup(name),
-               {bool isPatched: false,
-                bool isPatch: false,
-                bool isMethod: true,
-                bool isGetter: false,
-                bool isFound: true}) {
+               {bool expectIsPatched: false,
+                bool expectIsPatch: false,
+                bool checkHasBody: false,
+                bool expectIsGetter: false,
+                bool expectIsFound: true}) {
   var element = lookup(buildSourceString(name));
-  if (!isFound) {
+  if (!expectIsFound) {
     Expect.isNull(element);
     return element;
   }
   Expect.isNotNull(element);
-  if (isGetter) {
+  if (expectIsGetter) {
     Expect.isTrue(element is AbstractFieldElement);
     Expect.isNotNull(element.getter);
     element = element.getter;
   }
-  Expect.equals(isPatched, element.isPatched);
-  if (isPatched) {
+  Expect.equals(expectIsPatched, element.isPatched);
+  if (expectIsPatched) {
     Expect.isNull(element.origin);
     Expect.isNotNull(element.patch);
 
     Expect.equals(element, element.declaration);
     Expect.equals(element.patch, element.implementation);
 
-    if (isMethod) {
+    if (checkHasBody) {
       expectHasNoBody(compiler, element);
       expectHasBody(compiler, element.patch);
     }
   } else {
     Expect.isTrue(element.isImplementation);
   }
-  Expect.equals(isPatch, element.isPatch);
-  if (isPatch) {
+  Expect.equals(expectIsPatch, element.isPatch);
+  if (expectIsPatch) {
     Expect.isNotNull(element.origin);
     Expect.isNull(element.patch);
 
     Expect.equals(element.origin, element.declaration);
     Expect.equals(element, element.implementation);
 
-    if (isMethod) {
+    if (checkHasBody) {
       expectHasBody(compiler, element);
       expectHasNoBody(compiler, element.origin);
     }
   } else {
     Expect.isTrue(element.isDeclaration);
   }
   if (!(element.isPatched || element.isPatch)) {
     Expect.isNull(element.origin);
     Expect.isNull(element.patch);
 
     Expect.equals(element, element.declaration);
     Expect.equals(element, element.implementation);
 
-    if (isMethod) {
+    if (checkHasBody) {
       expectHasBody(compiler, element);
     }
   }
   Expect.isFalse(element.isPatched && element.isPatch);
   return element;
 }
 
 testPatchFunction() {
   var compiler = applyPatch(
       "external test();",
       "patch test() { return 'string'; } ");
-  ensure(compiler, "test", compiler.coreLibrary.find, isPatched: true);
-  ensure(compiler, "test", compiler.coreLibrary.patch.find, isPatch: true);
+  ensure(compiler, "test", compiler.coreLibrary.find,
+         expectIsPatched: true, checkHasBody: true);
+  ensure(compiler, "test", compiler.coreLibrary.patch.find,
+         expectIsPatch: true, checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchMember() {
   var compiler = applyPatch(
       """
       class Class {
         external String toString();
       }
       """,
       """
       patch class Class {
         patch String toString() => 'string';
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         isMethod: false, isPatched: true);
+                         expectIsPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-         isMethod: false, isPatch: true);
+         expectIsPatch: true);
 
   ensure(compiler, "toString", container.lookupLocalMember,
-         isPatched: true);
+         expectIsPatched: true, checkHasBody: true);
   ensure(compiler, "toString", container.patch.lookupLocalMember,
-         isPatch: true);
+         expectIsPatch: true, checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchGetter() {
   var compiler = applyPatch(
       """
       class Class {
         external int get field;
       }
       """,
       """
       patch class Class {
         patch int get field => 5;
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         isPatched: true, isMethod: false);
+                         expectIsPatched: true);
   container.parseNode(compiler);
   ensure(compiler,
          "field",
          container.lookupLocalMember,
-         isGetter: true,
-         isPatched: true);
+         expectIsGetter: true,
+         expectIsPatched: true,
+         checkHasBody: true);
   ensure(compiler,
          "field",
          container.patch.lookupLocalMember,
-         isGetter: true,
-         isPatch: true);
+         expectIsGetter: true,
+         expectIsPatch: true,
+         checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testRegularMember() {
   var compiler = applyPatch(
       """
       class Class {
         void regular() {}
       }
       """,
       """
       patch class Class {
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         isMethod: false, isPatched: true);
+                         expectIsPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-         isMethod: false, isPatch: true);
+         expectIsPatch: true);
 
-  ensure(compiler, "regular", container.lookupLocalMember);
-  ensure(compiler, "regular", container.patch.lookupLocalMember);
+  ensure(compiler, "regular", container.lookupLocalMember,
+         checkHasBody: true);
+  ensure(compiler, "regular", container.patch.lookupLocalMember,
+         checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testGhostMember() {
   var compiler = applyPatch(
       """
       class Class {
       }
       """,
       """
       patch class Class {
         void ghost() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         isMethod: false, isPatched: true);
+                         expectIsPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-         isMethod: false, isPatch: true);
+         expectIsPatch: true);
 
-  ensure(compiler, "ghost", container.lookupLocalMember, isFound: false);
-  ensure(compiler, "ghost", container.patch.lookupLocalMember);
+  ensure(compiler, "ghost", container.lookupLocalMember,
+         expectIsFound: false);
+  ensure(compiler, "ghost", container.patch.lookupLocalMember,
+         checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testInjectFunction() {
   var compiler = applyPatch(
       "",
       "int _function() => 5;");
   ensure(compiler,
          "_function",
          compiler.coreLibrary.find,
-         isFound: false);
+         expectIsFound: false);
   ensure(compiler,
          "_function",
-         compiler.coreLibrary.patch.find);
+         compiler.coreLibrary.patch.find,
+         checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchSignatureCheck() {
   var compiler = applyPatch(
       """
@@ skipping 14 matching lines @@
         patch void method2() {}
         patch void method3(String s2) {}
         patch void method4([String str, int i]) {}
         patch void method5() {}
         patch void method6([String str]) {}
         patch void method7([String s2]) {}
         patch void method8({String s2}) {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         isMethod: false, isPatched: true);
+                         expectIsPatched: true);
   container.ensureResolved(compiler);
   container.parseNode(compiler);
 
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method1", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method1:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method2", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method2:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method3", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method3:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method4", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method4:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method5", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method5:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method6", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method6:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method7", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method7:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method8", container.lookupLocalMember,
-          isPatched: true));
+          expectIsPatched: true, checkHasBody: true));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isFalse(compiler.errors.isEmpty);
   print('method8:${compiler.errors}');
 }
 
+testExternalWithoutImplementationTopLevel() {
+  var compiler = applyPatch(
+      """
+      external void foo();
+      """,
+      """
+      // patch void foo() {}
+      """);
+  compiler.resolver.resolveMethodElement(
+      ensure(compiler, "foo", compiler.coreLibrary.find));
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  print('testExternalWithoutImplementationTopLevel:${compiler.errors}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind ==
+          MessageKind.EXTERNAL_WITHOUT_IMPLEMENTATION);
+  Expect.equals('External method without an implementation.',
+                compiler.errors[0].message.toString());
+}
+
+testExternalWithoutImplementationMember() {
+  var compiler = applyPatch(
+      """
+      class Class {
+        external void foo();
+      }
+      """,
+      """
+      patch class Class {
+        // patch void foo() {}
+      }
+      """);
+  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                         expectIsPatched: true);
+  container.parseNode(compiler);
+
+  compiler.warnings.clear();
+  compiler.errors.clear();
+  compiler.resolver.resolveMethodElement(
+      ensure(compiler, "foo", container.lookupLocalMember));
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  print('testExternalWithoutImplementationMember:${compiler.errors}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind ==
+          MessageKind.EXTERNAL_WITHOUT_IMPLEMENTATION);
+  Expect.equals('External method without an implementation.',
+                compiler.errors[0].message.toString());
+}
+
 main() {
   testPatchFunction();
   testPatchMember();
   testPatchGetter();
   testRegularMember();
   testGhostMember();
   testInjectFunction();
   testPatchSignatureCheck();
+
+  testExternalWithoutImplementationTopLevel();
+  testExternalWithoutImplementationMember();
 }