Transitive inference using SCC

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';
@@ skipping 26 matching lines @@
   /// 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.

[vsm, 2015/03/21 15:52:19]

Can you update the comment?  :-)

Have you seen any noticeable analysis perf impact from turning this on?

[Siggi Cherem (dart-lang), 2015/03/23 20:06:31]

Good point. done.
I haven't noticed much change, no. I think it is because we still have a pretty
tight bound on how many times we analyze/resolve a piece of code.

Before this change we were analyzing every initializer twice:
  - once before inference
  - once more after inference
the latter was to improve codegen of the initializer expression given the new
types and to resolve portions of initializers that were skipped over at first,
like function expressions.

With this change, now we likely still do 2 passes over an initializer, but at
most 3 times:
  - once before inference
  - once after inferring the type of the dependencies
  - possibly once more if the initializer contained a function expression with a
body.

So I don't think we are adding that much more to what we were doing already.

   final bool inferTransitively;
-  static const inferTransitivelyDefault = false;
+  static const inferTransitivelyDefault = true;
 
   /// 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.inferTransitively: inferTransitivelyDefault,
@@ skipping 335 matching lines @@
     // The pub-cache directory is two levels up, but we verify that the layout
     // looks correct.
     if (path.basename(dir) != 'dev_compiler') return null;
     dir = path.dirname(dir);
     if (path.basename(dir) != 'global_packages') return null;
     dir = path.dirname(dir);
     return path.join(dir, cacheDir, 'lib', 'runtime');
   }
   return null;
 }