housecleaning: remove nonnullableTypes

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 90 matching lines @@
   final bool onlyInferConstsAndFinalFields;
   static const onlyInferConstAndFinalFieldsDefault = false;
 
   /// Whether to infer types downwards from local context
   final bool inferDownwards;
   static const inferDownwardsDefault = true;
 
   /// Whether to inject casts between Dart assignable types.
   final bool relaxedCasts;
 
-  /// A list of non-nullable type names (e.g., 'int')
-  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.inferTransitively: inferTransitivelyDefault,
       this.onlyInferConstsAndFinalFields: onlyInferConstAndFinalFieldsDefault,
       this.inferDownwards: inferDownwardsDefault,
-      this.relaxedCasts: true,
-      this.nonnullableTypes: StrongModeOptions.NONNULLABLE_TYPES});
+      this.relaxedCasts: true});
 
   StrongModeOptions.fromArguments(ArgResults args, {String prefix: ''})
       : relaxedCasts = args[prefix + 'relaxed-casts'],
         inferDownwards = args[prefix + 'infer-downwards'],
         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',
@@ skipping 18 matching lines @@
           defaultsTo: onlyInferConstAndFinalFieldsDefault,
           hide: hide);
   }
 
   bool operator ==(Object other) {
     if (other is! StrongModeOptions) return false;
     StrongModeOptions s = other;
     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);
+        relaxedCasts == s.relaxedCasts;
   }
 }
-
-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(',');
-  }
-}