remove most of the StrongOptions

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 106 matching lines @@
     for (var c in globalsAndStatics) {
       for (var e in _VarExtractor.extract(c.initializer)) {
         // Note: declaration is null for variables that come from other strongly
         // connected components.
         var declaration = elementToDeclaration[e];
         if (declaration != null) constGraph.addEdge(c, declaration);
       }
     }
 
     for (var component in constGraph.computeTopologicalSort()) {
-      if (_options.inferTransitively) {
-        component.forEach((v) => _reanalyzeVar(visitors, v));
-      }
+      component.forEach((v) => _reanalyzeVar(visitors, v));
       _inferVariableFromInitializer(component);
     }
   }
 
   _inferInstanceFields(List<ClassDeclaration> classes,
       Map<Source, RestrictedResolverVisitor> visitors) {
     // First propagate what was inferred from globals to all instance fields.
-    if (_options.inferTransitively) {
-      // TODO(sigmund): also do a fine-grain propagation between fields. We want
-      // infer-by-override to take precedence, so we would have to include
-      // classes in the dependency graph and ensure that fields depend on their
-      // class, and classes depend on superclasses.
-      classes
-          .expand((c) => c.members.where(_isInstanceField))
-          .expand((f) => f.fields.variables)
-          .forEach((v) => _reanalyzeVar(visitors, v));
-    }
+
+    // TODO(sigmund): also do a fine-grain propagation between fields. We want
+    // infer-by-override to take precedence, so we would have to include
+    // classes in the dependency graph and ensure that fields depend on their
+    // class, and classes depend on superclasses.
+    classes
+        .expand((c) => c.members.where(_isInstanceField))
+        .expand((f) => f.fields.variables)
+        .forEach((v) => _reanalyzeVar(visitors, v));
 
     // Track types in this strongly connected component, ensure we visit
     // supertypes before subtypes.
     var typeToDeclaration = <InterfaceType, ClassDeclaration>{};
     classes.forEach((c) => typeToDeclaration[c.element.type] = c);
     var seen = new Set<InterfaceType>();
     visit(ClassDeclaration cls) {
       var element = cls.element;
       var type = element.type;
       if (seen.contains(type)) return;
@@ skipping 100 matching lines @@
         }
       }
     }
   }
 
   void _inferVariableFromInitializer(Iterable<VariableDeclaration> variables) {
     for (var variable in variables) {
       var declaration = variable.parent as VariableDeclarationList;
       // Only infer on variables that don't have any declared type.
       if (declaration.type != null) continue;
-      if (_options.onlyInferConstsAndFinalFields &&
-          !declaration.isFinal &&
-          !declaration.isConst) {
-        return;
-      }
       var initializer = variable.initializer;
       if (initializer == null) continue;
       var type = initializer.staticType;
       if (type == null || type.isDynamic || type.isBottom) continue;
-      if (!_canInferFrom(initializer)) continue;
       var element = variable.element as PropertyInducingElement;
       // Note: it's ok to update the type here, since initializer.staticType
       // is already computed for all declarations in the library cycle. The
       // new types will only be propagated on a second run of the
       // ResolverVisitor.
       element.type = type;
       element.getter.returnType = type;
       if (!element.isFinal && !element.isConst) {
         element.setter.parameters[0].type = type;
       }
     }
   }
-
-  bool _canInferFrom(Expression expression) {
-    if (_options.inferTransitively) return true;
-    if (expression is Literal) return true;
-    if (expression is InstanceCreationExpression) return true;
-    if (expression is FunctionExpression) return true;
-    if (expression is AsExpression) return true;
-    if (expression is CascadeExpression) {
-      return _canInferFrom(expression.target);
-    }
-    if (expression is SimpleIdentifier || expression is PropertyAccess) {
-      return false;
-    }
-    if (expression is PrefixedIdentifier) {
-      if (expression.staticElement is PropertyAccessorElement) {
-        return false;
-      }
-      return _canInferFrom(expression.identifier);
-    }
-    if (expression is MethodInvocation) {
-      return _canInferFrom(expression.target);
-    }
-    if (expression is BinaryExpression) {
-      return _canInferFrom(expression.leftOperand);
-    }
-    if (expression is ConditionalExpression) {
-      return _canInferFrom(expression.thenExpression) &&
-          _canInferFrom(expression.elseExpression);
-    }
-    if (expression is PrefixExpression) {
-      return _canInferFrom(expression.operand);
-    }
-    if (expression is PostfixExpression) {
-      return _canInferFrom(expression.operand);
-    }
-    return false;
-  }
 }
 
 /// Extracts the [VariableElement]s used in an initializer expression.
 class _VarExtractor extends RecursiveAstVisitor {
   final elements = <VariableElement>[];
   visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e is PropertyAccessorElement) elements.add(e.variable);
   }
 
@@ skipping 457 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }