Turn on infer-from-overrides by default, rename inferStaticFromOtherStatics to

lib/src/options.dart

 // Copyright (c) 2014, 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.
 
 /// Set of flags and options passed to the compiler
 library dev_compiler.src.options;
 
 import 'dart:io';
 
 import 'package:args/args.dart';
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:dev_compiler/config.dart';
 import 'package:logging/logging.dart' show Level;
 
 /// Options used by our TypeResolver.
 class ResolverOptions {
   /// Whether to resolve 'package:' uris using the multi-package resolver.
   final bool useMultiPackage;
 
   /// Package root when resolving 'package:' urls the standard way.
   final String packageRoot;
 
   /// List of paths used for the multi-package resolver.
   final List<String> packagePaths;
 
   /// Whether to infer return types and field types from overriden members.
   final bool inferFromOverrides;
-  static const inferFromOverridesDefault = false;
+  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 current
   /// implementation of this inference is limited to ensure the answer is
   /// deterministic when applying inference on library cycles. In the example
   /// above, `A` is inferred to have `B`'s declared type if they are both in the
   /// same library cycle. However, if `B`'s definition is not in the same
   /// connected component as `A`, we use `B`'s inferred type instead.
   ///
   /// Because this might be surprising to users, this is turned off by default.
   /// In the future, inference might track dependencies between variables in
   /// more detail so that, in the example above, we can use `B`'s inferred type
   /// always.
-  final bool inferStaticsFromIdentifiers;
-  static const inferStaticsFromIdentifiersDefault = false;
+  final bool inferTransitively;
+  static const inferTransitivelyDefault = false;
 
   /// Restrict inference of fields and top-levels to those that are final and
   /// const.
   final bool onlyInferConstsAndFinalFields;
   static const onlyInferConstAndFinalFieldsDefault = false;
 
   ResolverOptions({this.useMultiPackage: false, this.packageRoot: 'packages/',
       this.packagePaths: const <String>[],
       this.inferFromOverrides: inferFromOverridesDefault,
-      this.inferStaticsFromIdentifiers: inferStaticsFromIdentifiersDefault,
+      this.inferTransitively: inferTransitivelyDefault,
       this.onlyInferConstsAndFinalFields: onlyInferConstAndFinalFieldsDefault});
 }
 
 // TODO(vsm): Merge RulesOptions and TypeOptions
 /// Options used by our RestrictedRules.
 class RulesOptions extends TypeOptions {
   /// Whether to allow casts in constant contexts.
   final bool allowConstCasts;
 
   /// Whether to use covariant generics
@@ skipping 97 matching lines @@
   @override
   final List<String> packagePaths;
 
   /// Whether to infer return types and field types from overriden members.
   @override
   final bool inferFromOverrides;
 
   /// Whether to infer types for consts and static fields by looking at
   /// identifiers on the RHS.
   @override
-  final bool inferStaticsFromIdentifiers;
+  final bool inferTransitively;
 
   /// Restrict inference of fields and top-levels to those that are final and
   /// const.
   @override
   final bool onlyInferConstsAndFinalFields;
 
   /// List of non-nullable types.
   @override
   final List<String> nonnullableTypes;
 
   /// Whether to use static types for code generation.
   @override
   final bool ignoreTypes;
 
   /// Whether to emit the source map files.
   @override
   final bool emitSourceMaps;
 
   CompilerOptions({this.allowConstCasts: true, this.checkSdk: false,
       this.dumpInfo: false, this.dumpInfoFile, this.dumpSrcDir,
       this.forceCompile: false, this.formatOutput: false,
       this.cheapTestFormat: false, this.ignoreTypes: false, this.outputDir,
       this.outputDart: false, this.useColors: true,
       this.covariantGenerics: true, this.relaxedCasts: true,
       this.useMultiPackage: false, this.packageRoot: 'packages/',
       this.packagePaths: const <String>[],
       this.inferFromOverrides: ResolverOptions.inferFromOverridesDefault,
-      this.inferStaticsFromIdentifiers: ResolverOptions.inferStaticsFromIdentifiersDefault,
+      this.inferTransitively: ResolverOptions.inferTransitivelyDefault,
       this.onlyInferConstsAndFinalFields: ResolverOptions.onlyInferConstAndFinalFieldsDefault,
       this.nonnullableTypes: TypeOptions.NONNULLABLE_TYPES, this.help: false,
       this.useMockSdk: false, this.dartSdkPath, this.logLevel: Level.SEVERE,
       this.emitSourceMaps: true, this.entryPointFile: null,
       this.serverMode: false, this.port: 8080});
 }
 
 /// Parses options from the command-line
 CompilerOptions parseOptions(List<String> argv) {
   ArgResults args = argParser.parse(argv);
@@ skipping 14 matching lines @@
       ignoreTypes: args['ignore-types'],
       outputDart: args['dart-gen'],
       outputDir: args['out'],
       covariantGenerics: args['covariant-generics'],
       relaxedCasts: args['relaxed-casts'],
       useColors: useColors,
       useMultiPackage: args['use-multi-package'],
       packageRoot: args['package-root'],
       packagePaths: args['package-paths'].split(','),
       inferFromOverrides: args['infer-from-overrides'],
-      inferStaticsFromIdentifiers: args['infer-transitively'],
+      inferTransitively: args['infer-transitively'],
       onlyInferConstsAndFinalFields: args['infer-only-finals'],
       nonnullableTypes: optionsToList(args['nonnullable'],
           defaultValue: TypeOptions.NONNULLABLE_TYPES),
       help: args['help'],
       useMockSdk: args['mock-sdk'],
       dartSdkPath: sdkPath,
       logLevel: Level.LEVELS.firstWhere((Level l) => l.name == levelName,
           orElse: () => Level.SEVERE),
       emitSourceMaps: args['source-maps'],
       entryPointFile: args.rest.length == 0 ? null : args.rest.first,
@@ skipping 18 matching lines @@
   ..addOption('nonnullable',
       abbr: 'n',
       help: 'Comma separated string of non-nullable types',
       defaultsTo: null)
   ..addFlag('infer-from-overrides',
       help: 'Infer unspecified types of fields and return types from '
       'definitions in supertypes',
       defaultsTo: ResolverOptions.inferFromOverridesDefault)
   ..addFlag('infer-transitively',
       help: 'Infer consts/fields from definitions in other libraries',
-      defaultsTo: ResolverOptions.inferStaticsFromIdentifiersDefault)
+      defaultsTo: ResolverOptions.inferTransitivelyDefault)
   ..addFlag('infer-only-finals',
       help: 'Do not infer non-const or non-final fields',
       defaultsTo: ResolverOptions.onlyInferConstAndFinalFieldsDefault)
 
   // input/output options
   ..addOption('out', abbr: 'o', help: 'Output directory', defaultsTo: null)
   ..addOption('dart-sdk', help: 'Dart SDK Path', defaultsTo: null)
   ..addFlag('dart-gen',
       abbr: 'd', help: 'Generate dart output', defaultsTo: false)
   ..addFlag('dart-gen-fmt',
@@ skipping 19 matching lines @@
       defaultsTo: '8080')
   ..addFlag('force-compile',
       help: 'Compile code with static errors', defaultsTo: false)
   ..addOption('log', abbr: 'l', help: 'Logging level', defaultsTo: 'severe')
   ..addFlag('dump-info',
       abbr: 'i', help: 'Dump summary information', defaultsTo: false)
   ..addOption('dump-info-file',
       abbr: 'f',
       help: 'Dump info json file (requires dump-info)',
       defaultsTo: null);