diff --git a/pkg/vm/lib/transformations/type_flow/native_code.dart b/pkg/vm/lib/transformations/type_flow/native_code.dart
index 4ddf112..2c38d28 100644
--- a/pkg/vm/lib/transformations/type_flow/native_code.dart
+++ b/pkg/vm/lib/transformations/type_flow/native_code.dart
@@ -11,7 +11,6 @@
 
 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart' show CoreTypes;
-import 'package:kernel/external_name.dart' show getExternalName;
 import 'package:kernel/library_index.dart' show LibraryIndex;
 
 import 'calls.dart';
@@ -217,8 +216,6 @@
 
 /// Provides insights into the behavior of native code.
 class NativeCodeOracle {
-  final Map<String, List<Map<String, dynamic>>> _nativeMethods =
-      <String, List<Map<String, dynamic>>>{};
   final LibraryIndex _libraryIndex;
   final Set<Member> _membersReferencedFromNativeCode = new Set<Member>();
   final PragmaAnnotationParser _matcher;
@@ -238,11 +235,8 @@
   /// using [entryPointsListener]. Returns result type of the native method.
   Type handleNativeProcedure(
       Member member, EntryPointsListener entryPointsListener) {
-    final String nativeName = getExternalName(member);
     Type returnType = null;
 
-    final nativeActions = _nativeMethods[nativeName];
-
     for (var annotation in member.annotations) {
       ParsedPragma pragma = _matcher.parsePragma(annotation);
       if (pragma == null) continue;
@@ -282,178 +276,25 @@
     }
 
     if (returnType != null) {
-      assertx(nativeActions == null || nativeActions.length == 0);
-      return returnType;
-    }
-
-    if (nativeActions != null) {
-      for (var action in nativeActions) {
-        if (action['action'] == 'return') {
-          final c = _libraryIndex.getClass(action['library'], action['class']);
-
-          final concreteClass = entryPointsListener.addAllocatedClass(c);
-
-          final nullable = action['nullable'];
-          if (nullable == false) {
-            returnType = concreteClass;
-          } else if ((nullable == true) || (nullable == null)) {
-            returnType = new Type.nullable(concreteClass);
-          } else {
-            throw 'Bad entry point: unexpected nullable: "$nullable" in $action';
-          }
-        } else {
-          _addRoot(action, entryPointsListener);
-        }
-      }
-    }
-
-    if (returnType != null) {
       return returnType;
     } else {
       return new Type.fromStatic(member.function.returnType);
     }
   }
 
-  void _addRoot(
-      Map<String, String> rootDesc, EntryPointsListener entryPointsListener) {
-    final String library = rootDesc['library'];
-    final String class_ = rootDesc['class'];
-    final String name = rootDesc['name'];
-    final String action = rootDesc['action'];
-
-    final libraryIndex = _libraryIndex;
-
-    if ((action == 'create-instance') || ((action == null) && (name == null))) {
-      if (name != null) {
-        throw 'Bad entry point: unexpected "name" element in $rootDesc';
-      }
-
-      final Class cls = libraryIndex.getClass(library, class_);
-      if (cls.isAbstract) {
-        throw 'Bad entry point: abstract class listed in $rootDesc';
-      }
-
-      entryPointsListener.addAllocatedClass(cls);
-    } else if ((action == 'call') ||
-        (action == 'get') ||
-        (action == 'set') ||
-        ((action == null) && (name != null))) {
-      if (name == null) {
-        throw 'Bad entry point: expected "name" element in $rootDesc';
-      }
-
-      final String prefix = {
-            'get': LibraryIndex.getterPrefix,
-            'set': LibraryIndex.setterPrefix
-          }[action] ??
-          '';
-
-      Member member;
-
-      if (class_ != null) {
-        final classDotPrefix = class_ + '.';
-        if ((name == class_) || name.startsWith(classDotPrefix)) {
-          // constructor
-          if (action != 'call' && action != null) {
-            throw 'Bad entry point: action "$action" is not applicable to'
-                ' constructor in $rootDesc';
-          }
-
-          final constructorName =
-              (name == class_) ? '' : name.substring(classDotPrefix.length);
-
-          member = libraryIndex.getMember(library, class_, constructorName);
-        } else {
-          member = libraryIndex.tryGetMember(library, class_, prefix + name);
-          if (member == null) {
-            member = libraryIndex.getMember(library, class_, name);
-          }
-        }
-      } else {
-        member = libraryIndex.tryGetTopLevelMember(
-            library, /* unused */ null, prefix + name);
-        if (member == null) {
-          member = libraryIndex.getTopLevelMember(library, name);
-        }
-      }
-
-      assertx(member != null);
-
-      CallKind callKind;
-
-      if (action == null) {
-        if ((member is Field) || ((member is Procedure) && member.isGetter)) {
-          callKind = CallKind.PropertyGet;
-        } else if ((member is Procedure) && member.isSetter) {
-          callKind = CallKind.PropertySet;
-        } else {
-          callKind = CallKind.Method;
-        }
-      } else {
-        callKind = const {
-          'get': CallKind.PropertyGet,
-          'set': CallKind.PropertySet,
-          'call': CallKind.Method
-        }[action];
-      }
-
-      assertx(callKind != null);
-
-      final Selector selector = member.isInstanceMember
-          ? new InterfaceSelector(member, callKind: callKind)
-          : new DirectSelector(member, callKind: callKind);
-
-      entryPointsListener.addRawCall(selector);
-
-      if ((action == null) && (member is Field) && !member.isFinal) {
-        Selector selector = member.isInstanceMember
-            ? new InterfaceSelector(member, callKind: CallKind.PropertySet)
-            : new DirectSelector(member, callKind: CallKind.PropertySet);
-
-        entryPointsListener.addRawCall(selector);
-      }
-
-      _membersReferencedFromNativeCode.add(member);
-    } else {
-      throw 'Bad entry point: unrecognized action "$action" in $rootDesc';
-    }
-  }
-
-  /// Reads JSON describing entry points and native methods from [jsonString].
-  /// Adds all global entry points using [entryPointsListener].
-  ///
-  /// The format of the JSON descriptor is described in
-  /// 'runtime/vm/compiler/aot/entry_points_json.md'.
-  void processEntryPointsJSON(
-      String jsonString, EntryPointsListener entryPointsListener) {
-    final jsonObject = json.decode(jsonString);
-
-    final roots = jsonObject['roots'];
-    if (roots != null) {
-      for (var root in roots) {
-        _addRoot(new Map<String, String>.from(root), entryPointsListener);
-      }
-    }
-
-    final nativeMethods = jsonObject['native-methods'];
-    if (nativeMethods != null) {
-      nativeMethods.forEach((name, actions) {
-        _nativeMethods[name] = new List<Map<String, dynamic>>.from(
-            actions.map((action) => new Map<String, dynamic>.from(action)));
-      });
-    }
-  }
-
   /// Reads JSON files [jsonFiles] describing entry points and native methods.
-  /// Adds all global entry points using [entryPointsListener].
-  ///
-  /// The format of the JSON descriptor is described in
-  /// 'runtime/vm/compiler/aot/entry_points_json.md'.
+  /// Currently just checks that JSON file is empty as it is deprecated.
   void processEntryPointsJSONFiles(
       List<String> jsonFiles, EntryPointsListener entryPointsListener) {
     for (var file in jsonFiles) {
-      processEntryPointsJSON(
-          new File(file).readAsStringSync(), entryPointsListener);
+      String jsonString = new File(file).readAsStringSync();
+      final jsonObject = json.decode(jsonString);
+
+      final roots = jsonObject['roots'];
+      if (roots != null && roots.isNotEmpty) {
+        throw "Error: Found non-empty entry points JSON file $file."
+            " Use the @pragma('vm:entry-point') annotation instead.";
+      }
     }
   }
 }
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index 849de1d..fcfd575 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -35,10 +35,6 @@
 Component transformComponent(Target target, CoreTypes coreTypes,
     Component component, List<String> entryPoints,
     [PragmaAnnotationParser matcher]) {
-  if ((entryPoints == null) || entryPoints.isEmpty) {
-    throw 'Error: unable to perform global type flow analysis without entry points.';
-  }
-
   void ignoreAmbiguousSupertypes(Class cls, Supertype a, Supertype b) {}
   final hierarchy = new ClassHierarchy(component,
       onAmbiguousSupertypes: ignoreAmbiguousSupertypes);
diff --git a/pkg/vm/test/transformations/type_flow/transformer_test.dart b/pkg/vm/test/transformations/type_flow/transformer_test.dart
index 887c97a..3f8da8d 100644
--- a/pkg/vm/test/transformations/type_flow/transformer_test.dart
+++ b/pkg/vm/test/transformations/type_flow/transformer_test.dart
@@ -24,12 +24,7 @@
 
   final coreTypes = new CoreTypes(component);
 
-  final entryPoints = [
-    pkgVmDir + '/lib/transformations/type_flow/entry_points.json',
-    pkgVmDir + '/lib/transformations/type_flow/entry_points_extra.json',
-  ];
-
-  component = transformComponent(target, coreTypes, component, entryPoints,
+  component = transformComponent(target, coreTypes, component, [],
       new ExpressionPragmaAnnotationParser(coreTypes));
 
   final actual = kernelLibraryToString(component.mainMethod.enclosingLibrary);
diff --git a/runtime/vm/compiler/aot/entry_points_json.md b/runtime/vm/compiler/aot/entry_points_json.md
deleted file mode 100644
index 4ab2356..0000000
--- a/runtime/vm/compiler/aot/entry_points_json.md
+++ /dev/null
@@ -1,110 +0,0 @@
-
-# Entry points file format
-
-Dart VM precompiler (AOT compiler) performs whole-program optimizations such as
-tree shaking in order to decrease size of the resulting compiled apps and
-improve their performance. Such optimizations assume that compiler can see
-the whole Dart program, and is able to discover and analyze all Dart functions
-and members which can be potentially executed at run time. While the Dart code
-is fully available for precompiler, native code of the embedder and native
-methods are out of reach of the compiler. Such native code can call back to
-Dart via native Dart API.
-
-In order to aid precompiler, programmer can explicitly list entry
-points (roots) - Dart classes and members which are accessed from native code.
-Note that listing entry points is not optional: as long as program defines
-native methods which call into Dart, the entry points are required for the
-correctness of compilation.
-
-This memo describes _new_ format of entry points file, which is intended to
-replace old comma-separated lists of entry points. At the time of writing,
-new format is not fully adopted yet. 
-
-The native entry points are described in a JSON text file. The descriptor has the form
-
-```json
-{
- "roots": [
-    <root1>,
-    ...
-    <rootN>
-  ],
-
-  “native-methods”: {
-    “<native1_name>” : [
-      <native1_root1>,
-      ...
-      <native1_rootM1>,
-    ],
-
-    ...
-
-    “<nativeK_name>” : [
-      <nativeK_root1>,
-      ...
-      <nativeK_rootMK>,
-    ]
-  }
-```
-
-## "roots" element
-
-The “roots” element describes entry points which can be accessed by arbitrary native code.
-Each root has the following elements:
-
-```json
-{
- "library": "<library URI>",
- "class": "<class name>",
- "name": "<member name>",
- "action": "<action>"
-}
-```
-
-| Element | Meaning                                   | Can be omitted                     |
-| ------- | ----------------------------------------- | ---------------------------------- |
-| library | Library URI of the entry point.           | No.                                |
-| class   | Dart class name.                          | Omitted for top-level functions.   |
-| name    | Dart function name or member name.        | Omitted for class-related actions. |
-| action  | Specifies kind of the entry point access. | Depends on the entry point.        |
-
-
-The following actions are supported:
-* _"create-instance"_ - native code creates an instance of given Dart class.
-* _"call"_ - native code calls given Dart function or member.
-* _"get"_ - native code calls given getter or retrieves value of a given field.
-* _“set”_ - native code calls given setter or sets value to a given field.
-
-If action element is omitted, the following actions are assumed by default:
-* For classes - “create-instance”.
-* For fields - both “get” and “set” (only “get” if a field is final).
-* For others - “call”.
-
-If needed, the description of an entry point can be extended by supporting
-more elements or actions.
-
-## “native-methods” element
-
-The “native-methods” section contains description of entry points accessed from
-specific native methods. It can be used to declare behavior of a native method
-more accurately.
-Each element in “native-methods” section is identified by the native name - the
-name specified after the native clause in the Dart method or function declaration.
-
-Native method descriptor may contain arbitrary number of entry points.
-In addition to the declaration of entry points described above, native methods
-may contain the root with the action “return”, which describes the specific
-concrete type of a Dart instance returned from the native method:
-
-```json
-{
- "action": "return",
- "library": "<library URI>",
- "class": "<class name>",
- "nullable": "false|true"
-}
-```
-
-“nullable” attribute may be omitted defaulting to “true”.
-If “nullable” is “true” (or omitted), then native method can return an instance
-of the given class or null.