Require that injected members are private.

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 'dart:async';
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/diagnostics/messages.dart' show
     MessageKind;
@@ skipping 130 matching lines @@
                 "Unexpected errors: ${compiler.errors}");
 }
 
 Future testPatchFunctionMetadata() async {
   var compiler = await applyPatch(
       """
       const a = 0;
       @a external test();
       """,
       """
-      const b = 1;
-      @patch @b test() {}
+      const _b = 1;
+      @patch @_b test() {}
       """);
   Element origin = ensure(compiler, "test", compiler.coreLibrary.find,
          expectIsPatched: true, checkHasBody: true);
   Element patch = 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}");
@@ skipping 238 matching lines @@
          checkHasBody: true, expectIsRegular: true);
   ensure(compiler, "regular", container.patch.lookupLocalMember,
          checkHasBody: true, expectIsRegular: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
-Future testGhostMember() async {
+Future testInjectedMember() async {
   var compiler = await applyPatch(
       """
       class Class {
       }
       """,
       """
       @patch class Class {
-        void ghost() {}
+        void _injected() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
   container.parseNode(compiler.parsing);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
-  ensure(compiler, "ghost", container.lookupLocalMember,
+  ensure(compiler, "_injected", container.lookupLocalMember,
          expectIsFound: false);
-  ensure(compiler, "ghost", container.patch.lookupLocalMember,
+  ensure(compiler, "_injected", container.patch.lookupLocalMember,
          checkHasBody: true, expectIsRegular: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
-Future testInjectFunction() async {
+Future testInjectedPublicMember() async {
+  var compiler = await applyPatch(
+      """
+      class Class {
+      }
+      """,
+      """
+      @patch class Class {
+        void injected() {}
+      }
+      """);
+  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                         expectIsPatched: true);
+  container.parseNode(compiler.parsing);
+  ensure(compiler, "Class", compiler.coreLibrary.patch.find,
+         expectIsPatch: true);
+
+  ensure(compiler, "injected", container.lookupLocalMember,
+         expectIsFound: false);
+  ensure(compiler, "injected", container.patch.lookupLocalMember,
+         checkHasBody: true, expectIsRegular: true);
+
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  Expect.equals(1, compiler.errors.length,
+                "Unexpected errors: ${compiler.errors}");
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.INJECTED_PUBLIC_MEMBER);
+}
+
+Future testInjectedFunction() async {
   var compiler = await applyPatch(
       "",
       "int _function() => 5;");
   ensure(compiler,
          "_function",
          compiler.coreLibrary.find,
          expectIsFound: false);
   ensure(compiler,
          "_function",
          compiler.coreLibrary.patch.find,
          checkHasBody: true, expectIsRegular: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
+Future testInjectedPublicFunction() async {
+  var compiler = await applyPatch(
+      "",
+      "int function() => 5;");
+  ensure(compiler,
+         "function",
+         compiler.coreLibrary.find,
+         expectIsFound: false);
+  ensure(compiler,
+         "function",
+         compiler.coreLibrary.patch.find,
+         checkHasBody: true, expectIsRegular: true);
+
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  Expect.equals(1, compiler.errors.length,
+                "Unexpected errors: ${compiler.errors}");
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.INJECTED_PUBLIC_MEMBER);
+}
+
 Future testPatchSignatureCheck() async {
   var compiler = await applyPatch(
       """
       class Class {
         external String method1();
         external void method2(String str);
         external void method3(String s1);
         external void method4([String str]);
         external void method5({String str});
         external void method6({String str});
@@ skipping 526 matching lines @@
 
 main() {
   asyncTest(() async {
     await testPatchConstructor();
     await testPatchRedirectingConstructor();
     await testPatchFunction();
     await testPatchFunctionMetadata();
     await testPatchMember();
     await testPatchGetter();
     await testRegularMember();
-    await testGhostMember();
-    await testInjectFunction();
+    await testInjectedMember();
+    await testInjectedPublicMember();
+    await testInjectedFunction();
+    await testInjectedPublicFunction();
     await testPatchSignatureCheck();
 
     await testPatchVersioned();
 
     await testExternalWithoutImplementationTopLevel();
     await testExternalWithoutImplementationMember();
 
     await testIsSubclass();
 
     await testPatchNonExistingTopLevel();
@@ skipping 10 matching lines @@
     await testPatchNonFunction();
 
     await testPatchAndSelector();
 
     await testEffectiveTarget();
 
     await testAnalyzeAllInjectedMembers();
     await testTypecheckPatchedMembers();
   });
 }