remove "infer from overrides" option which is now obsolete

lib/strong_mode.dart

 // Copyright (c) 2015, 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.
 
 /// Types needed to implement "strong" checking in the Dart analyzer. This is
 /// intended to be used by `analyzer_cli` and `analysis_server` packages.
 library dev_compiler.strong_mode;
 
 import 'package:analyzer/src/generated/engine.dart'
     show
@@ skipping 27 matching lines @@
 
   StrongChecker._(this._context, this._checker, this._reporter);
 
   factory StrongChecker(AnalysisContext context, StrongModeOptions options) {
     // TODO(vsm): Remove this once analyzer_cli is completely switched to the
     // task model.
     if (!AnalysisEngine
         .instance.useTaskModel) enableDevCompilerInference(context, options);
     var rules = new RestrictedRules(context.typeProvider, options: options);
     var reporter = new _ErrorCollector(options.hints);
-    var checker = new CodeChecker(rules, reporter, options);
+    var checker = new CodeChecker(rules, reporter);
     return new StrongChecker._(context, checker, reporter);
   }
 
   /// Computes and returns DDC errors for the [source].
   AnalysisErrorInfo computeErrors(Source source) {
     var errors = new List<AnalysisError>();
     _reporter.errors = errors;
 
     for (Source librarySource in _context.getLibrariesContaining(source)) {
       var resolved = _context.resolveCompilationUnit2(source, librarySource);
@@ skipping 13 matching lines @@
   void onError(AnalysisError error) {
     // Unless DDC hints are requested, filter them out.
     var HINT = ErrorSeverity.INFO.ordinal;
     if (hints || error.errorCode.errorSeverity.ordinal > HINT) {
       errors.add(error);
     }
   }
 }
 
 class StrongModeOptions {
-  /// Whether to infer return types and field types from overridden members.
-  final bool inferFromOverrides;
-  static const inferFromOverridesDefault = true;
-
   /// Whether to infer types for consts and fields by looking at initializers on
   /// the RHS. For example, in a constant declaration like:
   ///
   ///      const A = B;
   ///
   /// We can infer the type of `A` based on the type of `B`.
   ///
   /// The inference algorithm determines what variables depend on others, and
   /// computes types by visiting the variable dependency graph in topological
   /// order. This ensures that the inferred type is deterministic when applying
@@ skipping 20 matching lines @@
   final List<String> nonnullableTypes;
   static const List<String> NONNULLABLE_TYPES = const <String>[];
 
   /// Whether to include hints about dynamic invokes and runtime checks.
   // TODO(jmesserly): this option is not used yet by DDC server mode or batch
   // compile to JS.
   final bool hints;
 
   const StrongModeOptions(
       {this.hints: false,
-      this.inferFromOverrides: inferFromOverridesDefault,
       this.inferTransitively: inferTransitivelyDefault,
       this.onlyInferConstsAndFinalFields: onlyInferConstAndFinalFieldsDefault,
       this.inferDownwards: inferDownwardsDefault,
       this.relaxedCasts: true,
       this.nonnullableTypes: StrongModeOptions.NONNULLABLE_TYPES});
 
   StrongModeOptions.fromArguments(ArgResults args, {String prefix: ''})
       : relaxedCasts = args[prefix + 'relaxed-casts'],
         inferDownwards = args[prefix + 'infer-downwards'],
-        inferFromOverrides = args[prefix + 'infer-from-overrides'],
         inferTransitively = args[prefix + 'infer-transitively'],
         onlyInferConstsAndFinalFields = args[prefix + 'infer-only-finals'],
         nonnullableTypes = _optionsToList(args[prefix + 'nonnullable'],
             defaultValue: StrongModeOptions.NONNULLABLE_TYPES),
         hints = args[prefix + 'hints'];
 
   static ArgParser addArguments(ArgParser parser,
       {String prefix: '', bool hide: false}) {
     return parser
       ..addFlag(prefix + 'hints',
           help: 'Display hints about dynamic casts and dispatch operations',
           defaultsTo: false,
           hide: hide)
       ..addFlag(prefix + 'relaxed-casts',
           help: 'Cast between Dart assignable types',
           defaultsTo: true,
           hide: hide)
       ..addOption(prefix + 'nonnullable',
           abbr: prefix == '' ? 'n' : null,
           help: 'Comma separated string of non-nullable types',
           defaultsTo: null,
           hide: hide)
       ..addFlag(prefix + 'infer-downwards',
           help: 'Infer types downwards from local context',
           defaultsTo: inferDownwardsDefault,
           hide: hide)
-      ..addFlag(prefix + 'infer-from-overrides',
-          help: 'Infer unspecified types of fields and return types from\n'
-              'definitions in supertypes',
-          defaultsTo: inferFromOverridesDefault,
-          hide: hide)
       ..addFlag(prefix + 'infer-transitively',
           help: 'Infer consts/fields from definitions in other libraries',
           defaultsTo: inferTransitivelyDefault,
           hide: hide)
       ..addFlag(prefix + 'infer-only-finals',
           help: 'Do not infer non-const or non-final fields',
           defaultsTo: onlyInferConstAndFinalFieldsDefault,
           hide: hide);
   }
 
   bool operator ==(Object other) {
     if (other is! StrongModeOptions) return false;
     StrongModeOptions s = other;
-    return inferFromOverrides == s.inferFromOverrides &&
-        inferTransitively == s.inferTransitively &&
+    return inferTransitively == s.inferTransitively &&
         onlyInferConstsAndFinalFields == s.onlyInferConstsAndFinalFields &&
         inferDownwards == s.inferDownwards &&
         relaxedCasts == s.relaxedCasts &&
         nonnullableTypes.length == s.nonnullableTypes.length &&
         new Set.from(nonnullableTypes).containsAll(s.nonnullableTypes);
   }
 }
 
 List<String> _optionsToList(String option,
     {List<String> defaultValue: const <String>[]}) {
   if (option == null) {
     return defaultValue;
   } else if (option.isEmpty) {
     return <String>[];
   } else {
     return option.split(',');
   }
 }