Lint support for the new task model.

pkg/analyzer/test/src/task/dart_test.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.
 
 library test.src.task.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisOptionsImpl, CacheState;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/html.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
@@ skipping 13 matching lines @@
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ComputeConstantDependenciesTaskTest);
   runReflectiveTests(ComputeConstantValueTaskTest);
   runReflectiveTests(ComputeInferableStaticVariableDependenciesTaskTest);
   runReflectiveTests(ContainingLibrariesTaskTest);
   runReflectiveTests(DartErrorsTaskTest);
   runReflectiveTests(EvaluateUnitConstantsTaskTest);
   runReflectiveTests(GatherUsedImportedElementsTaskTest);
   runReflectiveTests(GatherUsedLocalElementsTaskTest);
   runReflectiveTests(GenerateHintsTaskTest);
+  runReflectiveTests(GenerateLintsTaskTest);
   runReflectiveTests(InferInstanceMembersInUnitTaskTest);
   runReflectiveTests(InferStaticVariableTypesInUnitTaskTest);
   runReflectiveTests(InferStaticVariableTypeTaskTest);
   runReflectiveTests(LibraryErrorsReadyTaskTest);
   runReflectiveTests(LibraryUnitErrorsTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(PartiallyResolveUnitReferencesTaskTest);
   runReflectiveTests(ResolveFunctionBodiesInUnitTaskTest);
   runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ResolveUnitTypeNamesTaskTest);
@@ skipping 30 matching lines @@
 isInstanceOf isContainingLibrariesTask =
     new isInstanceOf<ContainingLibrariesTask>();
 isInstanceOf isDartErrorsTask = new isInstanceOf<DartErrorsTask>();
 isInstanceOf isEvaluateUnitConstantsTask =
     new isInstanceOf<EvaluateUnitConstantsTask>();
 isInstanceOf isGatherUsedImportedElementsTask =
     new isInstanceOf<GatherUsedImportedElementsTask>();
 isInstanceOf isGatherUsedLocalElementsTask =
     new isInstanceOf<GatherUsedLocalElementsTask>();
 isInstanceOf isGenerateHintsTask = new isInstanceOf<GenerateHintsTask>();
+isInstanceOf isGenerateLintsTask = new isInstanceOf<GenerateLintsTask>();
 isInstanceOf isInferInstanceMembersInUnitTask =
     new isInstanceOf<InferInstanceMembersInUnitTask>();
 isInstanceOf isInferStaticVariableTypesInUnitTask =
     new isInstanceOf<InferStaticVariableTypesInUnitTask>();
 isInstanceOf isInferStaticVariableTypeTask =
     new isInstanceOf<InferStaticVariableTypeTask>();
 isInstanceOf isLibraryErrorsReadyTask =
     new isInstanceOf<LibraryErrorsReadyTask>();
 isInstanceOf isLibraryUnitErrorsTask =
     new isInstanceOf<LibraryUnitErrorsTask>();
 isInstanceOf isParseDartTask = new isInstanceOf<ParseDartTask>();
 isInstanceOf isPartiallyResolveUnitReferencesTask =
     new isInstanceOf<PartiallyResolveUnitReferencesTask>();
 isInstanceOf isResolveFunctionBodiesInUnitTask =
     new isInstanceOf<ResolveFunctionBodiesInUnitTask>();
 isInstanceOf isResolveLibraryTypeNamesTask =
     new isInstanceOf<ResolveLibraryTypeNamesTask>();
 isInstanceOf isResolveUnitTypeNamesTask =
     new isInstanceOf<ResolveUnitTypeNamesTask>();
 isInstanceOf isResolveVariableReferencesTask =
     new isInstanceOf<ResolveVariableReferencesTask>();
 isInstanceOf isScanDartTask = new isInstanceOf<ScanDartTask>();
 isInstanceOf isVerifyUnitTask = new isInstanceOf<VerifyUnitTask>();
 
+final LintCode _testLintCode = new LintCode('test lint', 'test lint code');
+
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   Source source;
   LibrarySpecificUnit target;
 
   test_perform_find_constants() {
     _performBuildTask('''
 const x = 1;
 class C {
   static const y = 1;
@@ skipping 1734 matching lines @@
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, HINTS, matcher: isGenerateHintsTask);
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[HintCode.UNUSED_ELEMENT, HintCode.UNUSED_ELEMENT]);
   }
 }
 
 @reflectiveTest
+class GenerateLintsTaskTest extends _AbstractDartTaskTest {
+  void enableLints() {
+    AnalysisOptionsImpl options = context.analysisOptions;
+    options.lint = true;
+    context.analysisOptions = options;
+  }
+
+  @override
+  void setUp() {
+    super.setUp();
+    enableLints();
+  }
+
+  @override
+  void tearDown() {
+    LintGenerator.LINTERS.clear();
+    super.tearDown();
+  }
+
+  test_camel_case_types() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+class a { }
+''');
+
+    LintGenerator.LINTERS.clear();
+    LintGenerator.LINTERS.add(new GenerateLintsTaskTest_TestLinter());
+
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, LINTS, matcher: isGenerateLintsTask);
+    // validate
+    _fillErrorListener(LINTS);
+    errorListener.assertErrorsWithCodes(<ErrorCode>[_testLintCode]);
+  }
+}
+
+class GenerateLintsTaskTest_AstVisitor extends SimpleAstVisitor {
+  Linter linter;
+  GenerateLintsTaskTest_AstVisitor(this.linter);
+
+  @override
+  visitClassDeclaration(ClassDeclaration node) {
+    if (!new RegExp(r'^([_]*)([A-Z]+[a-z0-9]*)+$')
+        .hasMatch(node.name.toString())) {
+      linter.reporter.reportErrorForNode(_testLintCode, node, []);
+    }
+  }
+}
+
+class GenerateLintsTaskTest_TestLinter extends Linter {
+  @override
+  AstVisitor getVisitor() => new GenerateLintsTaskTest_AstVisitor(this);
+}
+
+@reflectiveTest
 class InferInstanceMembersInUnitTaskTest extends _AbstractDartTaskTest {
   void test_perform() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 class A {
   X f;
   Y m(Z x) {}
 }
@@ skipping 77 matching lines @@
 
     InterfaceType stringType = context.typeProvider.stringType;
     expect(topLevel.type, stringType);
     expect(field.type, stringType);
     expect(fieldDecl.initializer.staticType, stringType);
   }
 }
 
 @reflectiveTest
 class InferStaticVariableTypesInUnitTaskTest extends _AbstractDartTaskTest {
+  void test_perform_const_field() {
+    enableStrongMode();
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+class M {
+  static const X = "";
+}
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
+        matcher: isInferStaticVariableTypesInUnitTask);
+    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    VariableDeclaration declaration = getFieldInClass(unit, 'M', 'X');
+    InterfaceType stringType = context.typeProvider.stringType;
+    expect(declaration.element.type, stringType);
+  }
+
   void test_perform_nestedDeclarations() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 var f = (int x) {
   int squared(int value) => value * value;
   var xSquared = squared(x);
   return xSquared;
 };
@@ skipping 57 matching lines @@
     CompilationUnit unit = outputs[RESOLVED_UNIT6];
     TopLevelVariableDeclaration declaration = unit.declarations[1];
     FunctionExpression function =
         declaration.variables.variables[0].initializer;
     BlockFunctionBody body = function.body;
     ReturnStatement statement = body.block.statements[0];
     Expression expression = statement.expression;
     InterfaceType intType = context.typeProvider.intType;
     expect(expression.staticType, intType);
   }
-
-  void test_perform_const_field() {
-    enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-class M {
-  static const X = "";
-}
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT6,
-        matcher: isInferStaticVariableTypesInUnitTask);
-    CompilationUnit unit = outputs[RESOLVED_UNIT6];
-    VariableDeclaration declaration = getFieldInClass(unit, 'M', 'X');
-    InterfaceType stringType = context.typeProvider.stringType;
-    expect(declaration.element.type, stringType);
-  }
 }
 
 @reflectiveTest
 class InferStaticVariableTypeTaskTest extends _AbstractDartTaskTest {
   void test_getDeclaration_staticField() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 class C {
   var field = '';
@@ skipping 41 matching lines @@
 
     computeResult(field, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     InterfaceType stringType = context.typeProvider.stringType;
     expect(topLevel.type, stringType);
     expect(field.type, stringType);
     expect(fieldDecl.initializer.staticType, stringType);
     expect(outputs[INFER_STATIC_VARIABLE_ERRORS], hasLength(0));
   }
 
-  void test_perform_reresolution() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-const topLevel = '';
-class C {
-  String field = topLevel;
-}
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
-    CompilationUnit unit = outputs[RESOLVED_UNIT5];
-    VariableDeclaration topLevelDecl = getTopLevelVariable(unit, 'topLevel');
-    VariableDeclaration fieldDecl = getFieldInClass(unit, 'C', 'field');
-    VariableElement topLevel = topLevelDecl.name.staticElement;
-    VariableElement field = fieldDecl.name.staticElement;
-
-    computeResult(field, INFERRED_STATIC_VARIABLE,
-        matcher: isInferStaticVariableTypeTask);
-    InterfaceType stringType = context.typeProvider.stringType;
-    expect(topLevel.type, stringType);
-    expect(field.type, stringType);
-    expect(fieldDecl.initializer.staticType, stringType);
-    expect(outputs[INFER_STATIC_VARIABLE_ERRORS], hasLength(0));
-  }
-
   void test_perform_const() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 const topLevel = "hello";
 class C {
   var field = topLevel;
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
@@ skipping 58 matching lines @@
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     VariableElement a = getTopLevelVariable(unit, 'a').name.staticElement;
 
     computeResult(a, INFERRED_STATIC_VARIABLE,
         matcher: isInferStaticVariableTypeTask);
     expect(a.type.isDynamic, isTrue);
     expect(outputs[INFER_STATIC_VARIABLE_ERRORS], hasLength(0));
   }
+
+  void test_perform_reresolution() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+const topLevel = '';
+class C {
+  String field = topLevel;
+}
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    VariableDeclaration topLevelDecl = getTopLevelVariable(unit, 'topLevel');
+    VariableDeclaration fieldDecl = getFieldInClass(unit, 'C', 'field');
+    VariableElement topLevel = topLevelDecl.name.staticElement;
+    VariableElement field = fieldDecl.name.staticElement;
+
+    computeResult(field, INFERRED_STATIC_VARIABLE,
+        matcher: isInferStaticVariableTypeTask);
+    InterfaceType stringType = context.typeProvider.stringType;
+    expect(topLevel.type, stringType);
+    expect(field.type, stringType);
+    expect(fieldDecl.initializer.staticType, stringType);
+    expect(outputs[INFER_STATIC_VARIABLE_ERRORS], hasLength(0));
+  }
 }
 
 @reflectiveTest
 class LibraryErrorsReadyTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source library = newSource(
         '/lib.dart',
         r'''
 library lib;
 part 'part1.dart';
@@ skipping 343 matching lines @@
   }
 
   void _assertResolved(FunctionBody body) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     body.accept(verifier);
     verifier.assertResolved();
   }
 }
 
 @reflectiveTest
+class ResolveLibraryTypeNamesTaskTest extends _AbstractDartTaskTest {
+  test_perform() {
+    Source sourceLib = newSource(
+        '/my_lib.dart',
+        '''
+library my_lib;
+part 'my_part.dart';
+class A {}
+class B extends A {}
+''');
+    newSource(
+        '/my_part.dart',
+        '''
+part of my_lib;
+class C extends A {}
+''');
+    computeResult(sourceLib, LIBRARY_ELEMENT5,
+        matcher: isResolveLibraryTypeNamesTask);
+    // validate
+    LibraryElement library = outputs[LIBRARY_ELEMENT5];
+    {
+      ClassElement classB = library.getType('B');
+      expect(classB.supertype.displayName, 'A');
+    }
+    {
+      ClassElement classC = library.getType('C');
+      expect(classC.supertype.displayName, 'A');
+    }
+  }
+
+  test_perform_external() {
+    Source sourceA = newSource(
+        '/a.dart',
+        '''
+library a;
+import 'b.dart';
+class A extends B {}
+''');
+    newSource(
+        '/b.dart',
+        '''
+library b;
+class B {}
+''');
+    // The reference A to B should be resolved, but there's no requirement that
+    // the full class hierarchy be resolved.
+    computeResult(sourceA, LIBRARY_ELEMENT5,
+        matcher: isResolveLibraryTypeNamesTask);
+    // validate
+    LibraryElement library = outputs[LIBRARY_ELEMENT5];
+    {
+      ClassElement clazz = library.getType('A');
+      expect(clazz.displayName, 'A');
+      clazz = clazz.supertype.element;
+      expect(clazz.displayName, 'B');
+    }
+  }
+}
+
+@reflectiveTest
+class ResolveUnitTypeNamesTaskTest extends _AbstractDartTaskTest {
+  test_perform() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+class A {}
+class B extends A {}
+int f(String p) => p.length;
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT3, matcher: isResolveUnitTypeNamesTask);
+    // validate
+    CompilationUnit unit = outputs[RESOLVED_UNIT3];
+    {
+      ClassDeclaration nodeA = unit.declarations[0];
+      ClassDeclaration nodeB = unit.declarations[1];
+      DartType extendsType = nodeB.extendsClause.superclass.type;
+      expect(extendsType, nodeA.element.type);
+    }
+    {
+      FunctionDeclaration functionNode = unit.declarations[2];
+      DartType returnType = functionNode.returnType.type;
+      List<FormalParameter> parameters =
+          functionNode.functionExpression.parameters.parameters;
+      expect(returnType.displayName, 'int');
+      expect(parameters[0].element.type.displayName, 'String');
+    }
+  }
+
+  test_perform_errors() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+NoSuchClass f() => null;
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVE_TYPE_NAMES_ERRORS,
+        matcher: isResolveUnitTypeNamesTask);
+    // validate
+    _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
+    errorListener
+        .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
+  }
+
+  test_perform_typedef() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+typedef int F(G g);
+typedef String G(int p);
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT3, matcher: isResolveUnitTypeNamesTask);
+    // validate
+    CompilationUnit unit = outputs[RESOLVED_UNIT3];
+    FunctionTypeAlias nodeF = unit.declarations[0];
+    FunctionTypeAlias nodeG = unit.declarations[1];
+    {
+      FormalParameter parameter = nodeF.parameters.parameters[0];
+      DartType parameterType = parameter.element.type;
+      Element returnTypeElement = nodeF.returnType.type.element;
+      expect(returnTypeElement.displayName, 'int');
+      expect(parameterType.element, nodeG.element);
+    }
+    {
+      FormalParameter parameter = nodeG.parameters.parameters[0];
+      DartType parameterType = parameter.element.type;
+      expect(nodeG.returnType.type.element.displayName, 'String');
+      expect(parameterType.element.displayName, 'int');
+    }
+  }
+
+  test_perform_typedef_errors() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+typedef int F(NoSuchType p);
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVE_TYPE_NAMES_ERRORS,
+        matcher: isResolveUnitTypeNamesTask);
+    // validate
+    _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
+    errorListener
+        .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
+  }
+}
+
+@reflectiveTest
+class ResolveVariableReferencesTaskTest extends _AbstractDartTaskTest {
+  /**
+   * Verify that the mutated states of the given [variable] correspond to the
+   * [mutatedInClosure] and [mutatedInScope] matchers.
+   */
+  void expectMutated(VariableElement variable, Matcher mutatedInClosure,
+      Matcher mutatedInScope) {
+    expect(variable.isPotentiallyMutatedInClosure, mutatedInClosure);
+    expect(variable.isPotentiallyMutatedInScope, mutatedInScope);
+  }
+
+  test_perform_buildClosureLibraryElements() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+main() {
+}
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT4,
+        matcher: isResolveVariableReferencesTask);
+  }
+
+  test_perform_local() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+main() {
+  var v1 = 1;
+  var v2 = 1;
+  var v3 = 1;
+  var v4 = 1;
+  v2 = 2;
+  v4 = 2;
+  localFunction() {
+    v3 = 3;
+    v4 = 3;
+  }
+}
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT4,
+        matcher: isResolveVariableReferencesTask);
+    // validate
+    CompilationUnit unit = outputs[RESOLVED_UNIT4];
+    FunctionElement main = unit.element.functions[0];
+    expectMutated(main.localVariables[0], isFalse, isFalse);
+    expectMutated(main.localVariables[1], isFalse, isTrue);
+    expectMutated(main.localVariables[2], isTrue, isTrue);
+    expectMutated(main.localVariables[3], isTrue, isTrue);
+  }
+
+  test_perform_parameter() {
+    Source source = newSource(
+        '/test.dart',
+        '''
+main(p1, p2, p3, p4) {
+  p2 = 2;
+  p4 = 2;
+  localFunction() {
+    p3 = 3;
+    p4 = 3;
+  }
+}
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT4,
+        matcher: isResolveVariableReferencesTask);
+    // validate
+    CompilationUnit unit = outputs[RESOLVED_UNIT4];
+    FunctionElement main = unit.element.functions[0];
+    expectMutated(main.parameters[0], isFalse, isFalse);
+    expectMutated(main.parameters[1], isFalse, isTrue);
+    expectMutated(main.parameters[2], isTrue, isTrue);
+    expectMutated(main.parameters[3], isTrue, isTrue);
+  }
+}
+
+@reflectiveTest
+class ScanDartTaskTest extends _AbstractDartTaskTest {
+  test_perform_errors() {
+    _performScanTask('import "');
+    expect(outputs, hasLength(3));
+    expect(outputs[LINE_INFO], isNotNull);
+    expect(outputs[SCAN_ERRORS], hasLength(1));
+    expect(outputs[TOKEN_STREAM], isNotNull);
+  }
+
+  test_perform_noErrors() {
+    _performScanTask('class A {}');
+    expect(outputs, hasLength(3));
+    expect(outputs[LINE_INFO], isNotNull);
+    expect(outputs[SCAN_ERRORS], hasLength(0));
+    expect(outputs[TOKEN_STREAM], isNotNull);
+  }
+
+  test_perform_script() {
+    String scriptContent = '''
+      void buttonPressed() {
+    ''';
+    String htmlContent = '''
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>test page</title>
+    <script type='application/dart'>$scriptContent</script>
+  </head>
+  <body>Test</body>
+</html>
+''';
+    Source source = newSource('/test.html', htmlContent);
+    DartScript script =
+        new DartScript(source, [new ScriptFragment(97, 5, 36, scriptContent)]);
+
+    computeResult(script, TOKEN_STREAM, matcher: isScanDartTask);
+    expect(outputs[LINE_INFO], isNotNull);
+    expect(outputs[SCAN_ERRORS], isEmpty);
+    Token tokenStream = outputs[TOKEN_STREAM];
+    expect(tokenStream, isNotNull);
+    expect(tokenStream.lexeme, 'void');
+  }
+
+  void _performScanTask(String content) {
+    AnalysisTarget target = newSource('/test.dart', content);
+    computeResult(target, TOKEN_STREAM, matcher: isScanDartTask);
+  }
+}
+
+@reflectiveTest
 class StrongModeInferenceTest extends _AbstractDartTaskTest {
-
-  @override
-  void setUp() {
-    super.setUp();
-    enableStrongMode();
+  void assertAssignmentStatementTypes(
+      Statement stmt, DartType leftType, DartType rightType) {
+    AssignmentExpression assgn = (stmt as ExpressionStatement).expression;
+    expect(assgn.leftHandSide.staticType, leftType);
+    expect(assgn.rightHandSide.staticType, rightType);
   }
 
   // Check that even within a static variable cycle, inferred
   // types get propagated to the members of the cycle.
-  void test_perform_cycle() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-var piFirst = true;
-var pi = piFirst ? 3.14 : tau / 2;
-var tau = piFirst ? pi * 2 : 6.28;
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
-    VariableElement piFirst =
-        getTopLevelVariable(unit, 'piFirst').name.staticElement;
-    VariableElement pi = getTopLevelVariable(unit, 'pi').name.staticElement;
-    VariableElement tau = getTopLevelVariable(unit, 'tau').name.staticElement;
-    Expression piFirstUse = (getTopLevelVariable(unit, 'tau').initializer
-        as ConditionalExpression).condition;
-
-    expect(piFirstUse.staticType, context.typeProvider.boolType);
-    expect(piFirst.type, context.typeProvider.boolType);
-    expect(pi.type.isDynamic, isTrue);
-    expect(tau.type.isDynamic, isTrue);
-  }
-
-  void test_perform_local_explicit_disabled() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-      test() {
-        int x = 3;
-        x = "hi";
-      }
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-    InterfaceType stringType = context.typeProvider.stringType;
-
-    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
-    VariableDeclaration decl =
-        (statements[0] as VariableDeclarationStatement).variables.variables[0];
-    expect(decl.element.type, intType);
-    expect(decl.initializer.staticType, intType);
-
-    ExpressionStatement statement = statements[1];
-    AssignmentExpression assgn = statement.expression;
-    expect(assgn.leftHandSide.staticType, intType);
-    expect(assgn.rightHandSide.staticType, stringType);
-  }
-
-  void assertVariableDeclarationTypes(
-      VariableDeclaration decl, DartType varType, DartType initializerType) {
-    expect(decl.element.type, varType);
-    expect(decl.initializer.staticType, initializerType);
-  }
-
   void assertVariableDeclarationStatementTypes(
       Statement stmt, DartType varType, DartType initializerType) {
     VariableDeclaration decl =
         (stmt as VariableDeclarationStatement).variables.variables[0];
     assertVariableDeclarationTypes(decl, varType, initializerType);
   }
 
-  void assertAssignmentStatementTypes(
-      Statement stmt, DartType leftType, DartType rightType) {
-    AssignmentExpression assgn = (stmt as ExpressionStatement).expression;
-    expect(assgn.leftHandSide.staticType, leftType);
-    expect(assgn.rightHandSide.staticType, rightType);
-  }
-
-  // Test that local variables in method bodies are inferred appropriately
-  void test_perform_inference_local_variables() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-      test() {
-        int x = 3;
-        x = "hi";
-        var y = 3;
-        y = "hi";
-      }
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-    InterfaceType stringType = context.typeProvider.stringType;
-
-    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
-
-    assertVariableDeclarationStatementTypes(statements[0], intType, intType);
-    assertAssignmentStatementTypes(statements[1], intType, stringType);
-    assertVariableDeclarationStatementTypes(statements[2], intType, intType);
-    assertAssignmentStatementTypes(statements[3], intType, stringType);
-  }
-
-  // Test inference interactions between local variables and fields
-  void test_perform_inference_local_variables_fields() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-      class A {
-        int x = 0;
-
-        test1() {
-          var a = x;
-          a = "hi";
-          a = 3;
-          var b = y;
-          b = "hi";
-          b = 4;
-          var c = z;
-          c = "hi";
-          c = 4;
-        }
-
-        int y; // field def after use
-        final z = 42; // should infer `int`
-      }
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-    InterfaceType stringType = context.typeProvider.stringType;
-
-    List<Statement> statements = getStatementsInMethod(unit, "A", "test1");
-
-    assertVariableDeclarationStatementTypes(statements[0], intType, intType);
-    assertAssignmentStatementTypes(statements[1], intType, stringType);
-    assertAssignmentStatementTypes(statements[2], intType, intType);
-
-    assertVariableDeclarationStatementTypes(statements[3], intType, intType);
-    assertAssignmentStatementTypes(statements[4], intType, stringType);
-    assertAssignmentStatementTypes(statements[5], intType, intType);
-
-    assertVariableDeclarationStatementTypes(statements[6], intType, intType);
-    assertAssignmentStatementTypes(statements[7], intType, stringType);
-    assertAssignmentStatementTypes(statements[8], intType, intType);
-
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit, "A", "x"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit, "A", "z"), intType, intType);
-  }
-
-  // Test inference interactions between local variables and top level
-  // variables
-  void test_perform_inference_local_variables_topLevel() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-      int x = 0;
-
-      test1() {
-        var a = x;
-        a = /*severe:StaticTypeError*/"hi";
-        a = 3;
-        var b = y;
-        b = /*severe:StaticTypeError*/"hi";
-        b = 4;
-        var c = z;
-        c = /*severe:StaticTypeError*/"hi";
-        c = 4;
-      }
-
-      int y = 0; // field def after use
-      final z = 42; // should infer `int`
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-    InterfaceType stringType = context.typeProvider.stringType;
-
-    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test1");
-
-    assertVariableDeclarationStatementTypes(statements[0], intType, intType);
-    assertAssignmentStatementTypes(statements[1], intType, stringType);
-    assertAssignmentStatementTypes(statements[2], intType, intType);
-
-    assertVariableDeclarationStatementTypes(statements[3], intType, intType);
-    assertAssignmentStatementTypes(statements[4], intType, stringType);
-    assertAssignmentStatementTypes(statements[5], intType, intType);
-
-    assertVariableDeclarationStatementTypes(statements[6], intType, intType);
-    assertAssignmentStatementTypes(statements[7], intType, stringType);
-    assertAssignmentStatementTypes(statements[8], intType, intType);
-
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit, "x"), intType, intType);
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit, "y"), intType, intType);
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit, "z"), intType, intType);
-  }
-
-  // Test that inference does not propagate from null
-  void test_perform_inference_null() {
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-      var x = null;
-      var y = 3;
-      class A {
-        static var x = null;
-        static var y = 3;
-
-        var x2 = null;
-        var y2 = 3;
-      }
-
-      test() {
-        x = "hi";
-        y = /*severe:StaticTypeError*/"hi";
-        A.x = "hi";
-        A.y = /*severe:StaticTypeError*/"hi";
-        new A().x2 = "hi";
-        new A().y2 = /*severe:StaticTypeError*/"hi";
-      }
-''');
-    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
-    CompilationUnit unit = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-    InterfaceType stringType = context.typeProvider.stringType;
-    DartType bottomType = context.typeProvider.bottomType;
-    DartType dynamicType = context.typeProvider.dynamicType;
-
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit, "x"), dynamicType, bottomType);
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit, "y"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit, "A", "x"), dynamicType, bottomType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit, "A", "y"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit, "A", "x2"), dynamicType, bottomType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit, "A", "y2"), intType, intType);
-
-    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
-
-    assertAssignmentStatementTypes(statements[0], dynamicType, stringType);
-    assertAssignmentStatementTypes(statements[1], intType, stringType);
-    assertAssignmentStatementTypes(statements[2], dynamicType, stringType);
-    assertAssignmentStatementTypes(statements[3], intType, stringType);
-    assertAssignmentStatementTypes(statements[4], dynamicType, stringType);
-    assertAssignmentStatementTypes(statements[5], intType, stringType);
-  }
-
-  // Test inference across units (non-cyclic)
-  void test_perform_inference_cross_unit_non_cyclic() {
-    AnalysisTarget firstSource = newSource(
-        '/a.dart',
-        '''
-          var x = 2;
-          class A { static var x = 2; }
-''');
-    AnalysisTarget secondSource = newSource(
-        '/test.dart',
-        '''
-          import 'a.dart';
-          var y = x;
-          class B { static var y = A.x; }
-
-          test1() {
-            x = /*severe:StaticTypeError*/"hi";
-            y = /*severe:StaticTypeError*/"hi";
-            A.x = /*severe:StaticTypeError*/"hi";
-            B.y = /*severe:StaticTypeError*/"hi";
-          }
-''');
-    computeResult(
-        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT8);
-    CompilationUnit unit1 = outputs[RESOLVED_UNIT8];
-    computeResult(
-        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT8);
-    CompilationUnit unit2 = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-    InterfaceType stringType = context.typeProvider.stringType;
-
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit1, "x"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit1, "A", "x"), intType, intType);
-
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit2, "y"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit2, "B", "y"), intType, intType);
-
-    List<Statement> statements =
-        getStatementsInTopLevelFunction(unit2, "test1");
-
-    assertAssignmentStatementTypes(statements[0], intType, stringType);
-    assertAssignmentStatementTypes(statements[1], intType, stringType);
-  }
-
-  // Test inference across units (cyclic)
-  void test_perform_inference_cross_unit_cyclic() {
-    AnalysisTarget firstSource = newSource(
-        '/a.dart',
-        '''
-          import 'test.dart';
-          var x = 2;
-          class A { static var x = 2; }
-''');
-    AnalysisTarget secondSource = newSource(
-        '/test.dart',
-        '''
-          import 'a.dart';
-          var y = x;
-          class B { static var y = A.x; }
-
-          test1() {
-            int t = 3;
-            t = x;
-            t = y;
-            t = A.x;
-            t = B.y;
-          }
-''');
-    computeResult(
-        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT8);
-    CompilationUnit unit1 = outputs[RESOLVED_UNIT8];
-    computeResult(
-        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT8);
-    CompilationUnit unit2 = outputs[RESOLVED_UNIT8];
-
-    InterfaceType intType = context.typeProvider.intType;
-
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit1, "x"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit1, "A", "x"), intType, intType);
-
-    assertVariableDeclarationTypes(
-        getTopLevelVariable(unit2, "y"), intType, intType);
-    assertVariableDeclarationTypes(
-        getFieldInClass(unit2, "B", "y"), intType, intType);
-
-    List<Statement> statements =
-        getStatementsInTopLevelFunction(unit2, "test1");
-
-    assertAssignmentStatementTypes(statements[1], intType, intType);
-    assertAssignmentStatementTypes(statements[2], intType, intType);
-    assertAssignmentStatementTypes(statements[3], intType, intType);
-    assertAssignmentStatementTypes(statements[4], intType, intType);
-  }
-
-  // Test inference of instance fields across units
-  // TODO(leafp): Fix this
-  // https://github.com/dart-lang/dev_compiler/issues/354
+  void assertVariableDeclarationTypes(
+      VariableDeclaration decl, DartType varType, DartType initializerType) {
+    expect(decl.element.type, varType);
+    expect(decl.initializer.staticType, initializerType);
+  }
+
   void fail_perform_inference_cross_unit_instance() {
     List<Source> sources = newSources({
       '/a7.dart': '''
           import 'b7.dart';
           class A {
             final a2 = new B().b2;
           }
       ''',
       '/b7.dart': '''
           class B {
@@ skipping 22 matching lines @@
 
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), intType, intType);
 
     List<Statement> statements =
         getStatementsInTopLevelFunction(unit2, "test1");
 
     assertAssignmentStatementTypes(statements[1], intType, intType);
   }
 
-  // Test inference between static and instance fields
-  // TODO(leafp): Fix this
-  // https://github.com/dart-lang/dev_compiler/issues/354
   void fail_perform_inference_cross_unit_static_instance() {
     List<Source> sources = newSources({
       '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
       '/b.dart': '''
@@ skipping 30 matching lines @@
         getFieldInClass(unit1, "B", "b1"), intType, intType);
     assertVariableDeclarationTypes(
         getFieldInClass(unit1, "B", "b2"), intType, intType);
 
     List<Statement> statements =
         getStatementsInTopLevelFunction(unit2, "test1");
 
     assertAssignmentStatementTypes(statements[1], intType, intType);
     assertAssignmentStatementTypes(statements[2], intType, intType);
   }
+
+  @override
+  void setUp() {
+    super.setUp();
+    enableStrongMode();
+  }
+
+  // Test that local variables in method bodies are inferred appropriately
+  void test_perform_cycle() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+var piFirst = true;
+var pi = piFirst ? 3.14 : tau / 2;
+var tau = piFirst ? pi * 2 : 6.28;
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
+    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+    VariableElement piFirst =
+        getTopLevelVariable(unit, 'piFirst').name.staticElement;
+    VariableElement pi = getTopLevelVariable(unit, 'pi').name.staticElement;
+    VariableElement tau = getTopLevelVariable(unit, 'tau').name.staticElement;
+    Expression piFirstUse = (getTopLevelVariable(unit, 'tau').initializer
+        as ConditionalExpression).condition;
+
+    expect(piFirstUse.staticType, context.typeProvider.boolType);
+    expect(piFirst.type, context.typeProvider.boolType);
+    expect(pi.type.isDynamic, isTrue);
+    expect(tau.type.isDynamic, isTrue);
+  }
+
+  // Test inference interactions between local variables and fields
+  void test_perform_inference_cross_unit_cyclic() {
+    AnalysisTarget firstSource = newSource(
+        '/a.dart',
+        '''
+          import 'test.dart';
+          var x = 2;
+          class A { static var x = 2; }
+''');
+    AnalysisTarget secondSource = newSource(
+        '/test.dart',
+        '''
+          import 'a.dart';
+          var y = x;
+          class B { static var y = A.x; }
+
+          test1() {
+            int t = 3;
+            t = x;
+            t = y;
+            t = A.x;
+            t = B.y;
+          }
+''');
+    computeResult(
+        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT8);
+    CompilationUnit unit1 = outputs[RESOLVED_UNIT8];
+    computeResult(
+        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT8);
+    CompilationUnit unit2 = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit1, "x"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit1, "A", "x"), intType, intType);
+
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit2, "y"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit2, "B", "y"), intType, intType);
+
+    List<Statement> statements =
+        getStatementsInTopLevelFunction(unit2, "test1");
+
+    assertAssignmentStatementTypes(statements[1], intType, intType);
+    assertAssignmentStatementTypes(statements[2], intType, intType);
+    assertAssignmentStatementTypes(statements[3], intType, intType);
+    assertAssignmentStatementTypes(statements[4], intType, intType);
+  }
+
+  // Test inference interactions between local variables and top level
+  // variables
+  void test_perform_inference_cross_unit_non_cyclic() {
+    AnalysisTarget firstSource = newSource(
+        '/a.dart',
+        '''
+          var x = 2;
+          class A { static var x = 2; }
+''');
+    AnalysisTarget secondSource = newSource(
+        '/test.dart',
+        '''
+          import 'a.dart';
+          var y = x;
+          class B { static var y = A.x; }
+
+          test1() {
+            x = /*severe:StaticTypeError*/"hi";
+            y = /*severe:StaticTypeError*/"hi";
+            A.x = /*severe:StaticTypeError*/"hi";
+            B.y = /*severe:StaticTypeError*/"hi";
+          }
+''');
+    computeResult(
+        new LibrarySpecificUnit(firstSource, firstSource), RESOLVED_UNIT8);
+    CompilationUnit unit1 = outputs[RESOLVED_UNIT8];
+    computeResult(
+        new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT8);
+    CompilationUnit unit2 = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit1, "x"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit1, "A", "x"), intType, intType);
+
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit2, "y"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit2, "B", "y"), intType, intType);
+
+    List<Statement> statements =
+        getStatementsInTopLevelFunction(unit2, "test1");
+
+    assertAssignmentStatementTypes(statements[0], intType, stringType);
+    assertAssignmentStatementTypes(statements[1], intType, stringType);
+  }
+
+  // Test that inference does not propagate from null
+  void test_perform_inference_local_variables() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+      test() {
+        int x = 3;
+        x = "hi";
+        var y = 3;
+        y = "hi";
+      }
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
+    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+
+    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
+
+    assertVariableDeclarationStatementTypes(statements[0], intType, intType);
+    assertAssignmentStatementTypes(statements[1], intType, stringType);
+    assertVariableDeclarationStatementTypes(statements[2], intType, intType);
+    assertAssignmentStatementTypes(statements[3], intType, stringType);
+  }
+
+  // Test inference across units (non-cyclic)
+  void test_perform_inference_local_variables_fields() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+      class A {
+        int x = 0;
+
+        test1() {
+          var a = x;
+          a = "hi";
+          a = 3;
+          var b = y;
+          b = "hi";
+          b = 4;
+          var c = z;
+          c = "hi";
+          c = 4;
+        }
+
+        int y; // field def after use
+        final z = 42; // should infer `int`
+      }
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
+    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+
+    List<Statement> statements = getStatementsInMethod(unit, "A", "test1");
+
+    assertVariableDeclarationStatementTypes(statements[0], intType, intType);
+    assertAssignmentStatementTypes(statements[1], intType, stringType);
+    assertAssignmentStatementTypes(statements[2], intType, intType);
+
+    assertVariableDeclarationStatementTypes(statements[3], intType, intType);
+    assertAssignmentStatementTypes(statements[4], intType, stringType);
+    assertAssignmentStatementTypes(statements[5], intType, intType);
+
+    assertVariableDeclarationStatementTypes(statements[6], intType, intType);
+    assertAssignmentStatementTypes(statements[7], intType, stringType);
+    assertAssignmentStatementTypes(statements[8], intType, intType);
+
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit, "A", "x"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit, "A", "z"), intType, intType);
+  }
+
+  // Test inference across units (cyclic)
+  void test_perform_inference_local_variables_topLevel() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+      int x = 0;
+
+      test1() {
+        var a = x;
+        a = /*severe:StaticTypeError*/"hi";
+        a = 3;
+        var b = y;
+        b = /*severe:StaticTypeError*/"hi";
+        b = 4;
+        var c = z;
+        c = /*severe:StaticTypeError*/"hi";
+        c = 4;
+      }
+
+      int y = 0; // field def after use
+      final z = 42; // should infer `int`
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
+    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+
+    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test1");
+
+    assertVariableDeclarationStatementTypes(statements[0], intType, intType);
+    assertAssignmentStatementTypes(statements[1], intType, stringType);
+    assertAssignmentStatementTypes(statements[2], intType, intType);
+
+    assertVariableDeclarationStatementTypes(statements[3], intType, intType);
+    assertAssignmentStatementTypes(statements[4], intType, stringType);
+    assertAssignmentStatementTypes(statements[5], intType, intType);
+
+    assertVariableDeclarationStatementTypes(statements[6], intType, intType);
+    assertAssignmentStatementTypes(statements[7], intType, stringType);
+    assertAssignmentStatementTypes(statements[8], intType, intType);
+
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit, "x"), intType, intType);
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit, "y"), intType, intType);
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit, "z"), intType, intType);
+  }
+
+  // Test inference of instance fields across units
+  // TODO(leafp): Fix this
+  // https://github.com/dart-lang/dev_compiler/issues/354
+  void test_perform_inference_null() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+      var x = null;
+      var y = 3;
+      class A {
+        static var x = null;
+        static var y = 3;
+
+        var x2 = null;
+        var y2 = 3;
+      }
+
+      test() {
+        x = "hi";
+        y = /*severe:StaticTypeError*/"hi";
+        A.x = "hi";
+        A.y = /*severe:StaticTypeError*/"hi";
+        new A().x2 = "hi";
+        new A().y2 = /*severe:StaticTypeError*/"hi";
+      }
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
+    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+    DartType bottomType = context.typeProvider.bottomType;
+    DartType dynamicType = context.typeProvider.dynamicType;
+
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit, "x"), dynamicType, bottomType);
+    assertVariableDeclarationTypes(
+        getTopLevelVariable(unit, "y"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit, "A", "x"), dynamicType, bottomType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit, "A", "y"), intType, intType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit, "A", "x2"), dynamicType, bottomType);
+    assertVariableDeclarationTypes(
+        getFieldInClass(unit, "A", "y2"), intType, intType);
+
+    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
+
+    assertAssignmentStatementTypes(statements[0], dynamicType, stringType);
+    assertAssignmentStatementTypes(statements[1], intType, stringType);
+    assertAssignmentStatementTypes(statements[2], dynamicType, stringType);
+    assertAssignmentStatementTypes(statements[3], intType, stringType);
+    assertAssignmentStatementTypes(statements[4], dynamicType, stringType);
+    assertAssignmentStatementTypes(statements[5], intType, stringType);
+  }
+
+  // Test inference between static and instance fields
+  // TODO(leafp): Fix this
+  // https://github.com/dart-lang/dev_compiler/issues/354
+  void test_perform_local_explicit_disabled() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+      test() {
+        int x = 3;
+        x = "hi";
+      }
+''');
+    computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8);
+    CompilationUnit unit = outputs[RESOLVED_UNIT8];
+
+    InterfaceType intType = context.typeProvider.intType;
+    InterfaceType stringType = context.typeProvider.stringType;
+
+    List<Statement> statements = getStatementsInTopLevelFunction(unit, "test");
+    VariableDeclaration decl =
+        (statements[0] as VariableDeclarationStatement).variables.variables[0];
+    expect(decl.element.type, intType);
+    expect(decl.initializer.staticType, intType);
+
+    ExpressionStatement statement = statements[1];
+    AssignmentExpression assgn = statement.expression;
+    expect(assgn.leftHandSide.staticType, intType);
+    expect(assgn.rightHandSide.staticType, stringType);
+  }
 }
 
-@reflectiveTest
-class ResolveLibraryTypeNamesTaskTest extends _AbstractDartTaskTest {
-  test_perform() {
-    Source sourceLib = newSource(
-        '/my_lib.dart',
-        '''
-library my_lib;
-part 'my_part.dart';
-class A {}
-class B extends A {}
-''');
-    newSource(
-        '/my_part.dart',
-        '''
-part of my_lib;
-class C extends A {}
-''');
-    computeResult(sourceLib, LIBRARY_ELEMENT5,
-        matcher: isResolveLibraryTypeNamesTask);
-    // validate
-    LibraryElement library = outputs[LIBRARY_ELEMENT5];
-    {
-      ClassElement classB = library.getType('B');
-      expect(classB.supertype.displayName, 'A');
-    }
-    {
-      ClassElement classC = library.getType('C');
-      expect(classC.supertype.displayName, 'A');
-    }
-  }
-
-  test_perform_external() {
-    Source sourceA = newSource(
-        '/a.dart',
-        '''
-library a;
-import 'b.dart';
-class A extends B {}
-''');
-    newSource(
-        '/b.dart',
-        '''
-library b;
-class B {}
-''');
-    // The reference A to B should be resolved, but there's no requirement that
-    // the full class hierarchy be resolved.
-    computeResult(sourceA, LIBRARY_ELEMENT5,
-        matcher: isResolveLibraryTypeNamesTask);
-    // validate
-    LibraryElement library = outputs[LIBRARY_ELEMENT5];
-    {
-      ClassElement clazz = library.getType('A');
-      expect(clazz.displayName, 'A');
-      clazz = clazz.supertype.element;
-      expect(clazz.displayName, 'B');
-    }
-  }
-}
-
-@reflectiveTest
-class ResolveUnitTypeNamesTaskTest extends _AbstractDartTaskTest {
-  test_perform() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-class A {}
-class B extends A {}
-int f(String p) => p.length;
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT3, matcher: isResolveUnitTypeNamesTask);
-    // validate
-    CompilationUnit unit = outputs[RESOLVED_UNIT3];
-    {
-      ClassDeclaration nodeA = unit.declarations[0];
-      ClassDeclaration nodeB = unit.declarations[1];
-      DartType extendsType = nodeB.extendsClause.superclass.type;
-      expect(extendsType, nodeA.element.type);
-    }
-    {
-      FunctionDeclaration functionNode = unit.declarations[2];
-      DartType returnType = functionNode.returnType.type;
-      List<FormalParameter> parameters =
-          functionNode.functionExpression.parameters.parameters;
-      expect(returnType.displayName, 'int');
-      expect(parameters[0].element.type.displayName, 'String');
-    }
-  }
-
-  test_perform_errors() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-NoSuchClass f() => null;
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVE_TYPE_NAMES_ERRORS,
-        matcher: isResolveUnitTypeNamesTask);
-    // validate
-    _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
-    errorListener
-        .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
-  }
-
-  test_perform_typedef() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-typedef int F(G g);
-typedef String G(int p);
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT3, matcher: isResolveUnitTypeNamesTask);
-    // validate
-    CompilationUnit unit = outputs[RESOLVED_UNIT3];
-    FunctionTypeAlias nodeF = unit.declarations[0];
-    FunctionTypeAlias nodeG = unit.declarations[1];
-    {
-      FormalParameter parameter = nodeF.parameters.parameters[0];
-      DartType parameterType = parameter.element.type;
-      Element returnTypeElement = nodeF.returnType.type.element;
-      expect(returnTypeElement.displayName, 'int');
-      expect(parameterType.element, nodeG.element);
-    }
-    {
-      FormalParameter parameter = nodeG.parameters.parameters[0];
-      DartType parameterType = parameter.element.type;
-      expect(nodeG.returnType.type.element.displayName, 'String');
-      expect(parameterType.element.displayName, 'int');
-    }
-  }
-
-  test_perform_typedef_errors() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-typedef int F(NoSuchType p);
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVE_TYPE_NAMES_ERRORS,
-        matcher: isResolveUnitTypeNamesTask);
-    // validate
-    _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
-    errorListener
-        .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
-  }
-}
-
-@reflectiveTest
-class ResolveVariableReferencesTaskTest extends _AbstractDartTaskTest {
-  /**
-   * Verify that the mutated states of the given [variable] correspond to the
-   * [mutatedInClosure] and [mutatedInScope] matchers.
-   */
-  void expectMutated(VariableElement variable, Matcher mutatedInClosure,
-      Matcher mutatedInScope) {
-    expect(variable.isPotentiallyMutatedInClosure, mutatedInClosure);
-    expect(variable.isPotentiallyMutatedInScope, mutatedInScope);
-  }
-
-  test_perform_buildClosureLibraryElements() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-main() {
-}
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT4,
-        matcher: isResolveVariableReferencesTask);
-  }
-
-  test_perform_local() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-main() {
-  var v1 = 1;
-  var v2 = 1;
-  var v3 = 1;
-  var v4 = 1;
-  v2 = 2;
-  v4 = 2;
-  localFunction() {
-    v3 = 3;
-    v4 = 3;
-  }
-}
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT4,
-        matcher: isResolveVariableReferencesTask);
-    // validate
-    CompilationUnit unit = outputs[RESOLVED_UNIT4];
-    FunctionElement main = unit.element.functions[0];
-    expectMutated(main.localVariables[0], isFalse, isFalse);
-    expectMutated(main.localVariables[1], isFalse, isTrue);
-    expectMutated(main.localVariables[2], isTrue, isTrue);
-    expectMutated(main.localVariables[3], isTrue, isTrue);
-  }
-
-  test_perform_parameter() {
-    Source source = newSource(
-        '/test.dart',
-        '''
-main(p1, p2, p3, p4) {
-  p2 = 2;
-  p4 = 2;
-  localFunction() {
-    p3 = 3;
-    p4 = 3;
-  }
-}
-''');
-    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
-    computeResult(target, RESOLVED_UNIT4,
-        matcher: isResolveVariableReferencesTask);
-    // validate
-    CompilationUnit unit = outputs[RESOLVED_UNIT4];
-    FunctionElement main = unit.element.functions[0];
-    expectMutated(main.parameters[0], isFalse, isFalse);
-    expectMutated(main.parameters[1], isFalse, isTrue);
-    expectMutated(main.parameters[2], isTrue, isTrue);
-    expectMutated(main.parameters[3], isTrue, isTrue);
-  }
-}
-
-@reflectiveTest
-class ScanDartTaskTest extends _AbstractDartTaskTest {
-  test_perform_errors() {
-    _performScanTask('import "');
-    expect(outputs, hasLength(3));
-    expect(outputs[LINE_INFO], isNotNull);
-    expect(outputs[SCAN_ERRORS], hasLength(1));
-    expect(outputs[TOKEN_STREAM], isNotNull);
-  }
-
-  test_perform_noErrors() {
-    _performScanTask('class A {}');
-    expect(outputs, hasLength(3));
-    expect(outputs[LINE_INFO], isNotNull);
-    expect(outputs[SCAN_ERRORS], hasLength(0));
-    expect(outputs[TOKEN_STREAM], isNotNull);
-  }
-
-  test_perform_script() {
-    String scriptContent = '''
-      void buttonPressed() {
-    ''';
-    String htmlContent = '''
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>test page</title>
-    <script type='application/dart'>$scriptContent</script>
-  </head>
-  <body>Test</body>
-</html>
-''';
-    Source source = newSource('/test.html', htmlContent);
-    DartScript script =
-        new DartScript(source, [new ScriptFragment(97, 5, 36, scriptContent)]);
-
-    computeResult(script, TOKEN_STREAM, matcher: isScanDartTask);
-    expect(outputs[LINE_INFO], isNotNull);
-    expect(outputs[SCAN_ERRORS], isEmpty);
-    Token tokenStream = outputs[TOKEN_STREAM];
-    expect(tokenStream, isNotNull);
-    expect(tokenStream.lexeme, 'void');
-  }
-
-  void _performScanTask(String content) {
-    AnalysisTarget target = newSource('/test.dart', content);
-    computeResult(target, TOKEN_STREAM, matcher: isScanDartTask);
-  }
-}
-
 @reflectiveTest
 class VerifyUnitTaskTest extends _AbstractDartTaskTest {
   test_perform_constantError() {
     Source source = newSource(
         '/test.dart',
         '''
 main(int p) {
   const v = p;
 }
 ''');
@@ skipping 13 matching lines @@
 import 'no-such-file.dart';
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
+  void test_perform_reresolution() {
+    enableStrongMode();
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+const topLevel = 3;
+class C {
+  String field = topLevel;
+}
+''');
+    computeResult(new LibrarySpecificUnit(source, source), VERIFY_ERRORS);
+    // validate
+    _fillErrorListener(VERIFY_ERRORS);
+    errorListener.assertErrorsWithCodes(
+        <ErrorCode>[StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+  }
+
   test_perform_verifyError() {
     Source source = newSource(
         '/test.dart',
         '''
 main() {
   if (42) {
     print('Not bool!');
   }
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, VERIFY_ERRORS, matcher: isVerifyUnitTask);
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
-
-  void test_perform_reresolution() {
-    enableStrongMode();
-    AnalysisTarget source = newSource(
-        '/test.dart',
-        '''
-const topLevel = 3;
-class C {
-  String field = topLevel;
-}
-''');
-    computeResult(new LibrarySpecificUnit(source, source), VERIFY_ERRORS);
-    // validate
-    _fillErrorListener(VERIFY_ERRORS);
-    errorListener.assertErrorsWithCodes(
-        <ErrorCode>[StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-  }
 }
 
 class _AbstractDartTaskTest extends AbstractContextTest {
   Source emptySource;
 
   GatheringErrorListener errorListener = new GatheringErrorListener();
 
   void assertIsInvalid(AnalysisTarget target, ResultDescriptor descriptor) {
     CacheEntry entry = context.getCacheEntry(target);
     expect(entry.isInvalid(descriptor), isTrue);
@@ skipping 116 matching lines @@
   }
 
   List<Statement> getStatementsInTopLevelFunction(
       CompilationUnit unit, String functionName) {
     FunctionDeclaration function = getTopLevelFunction(unit, functionName);
     BlockFunctionBody body = function.functionExpression.body;
     return body.block.statements;
   }
 
   /**
+   * Return the declaration of the top-level function with the given
+   * [functionName] in the given compilation [unit].
+   */
+  FunctionDeclaration getTopLevelFunction(
+      CompilationUnit unit, String functionName) {
+    NodeList<CompilationUnitMember> unitMembers = unit.declarations;
+    for (CompilationUnitMember unitMember in unitMembers) {
+      if (unitMember is FunctionDeclaration) {
+        if (unitMember.name.name == functionName) {
+          return unitMember;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return the declaration of the top-level variable with the given
    * [variableName] in the given compilation [unit].
    */
   VariableDeclaration getTopLevelVariable(
       CompilationUnit unit, String variableName) {
     NodeList<CompilationUnitMember> unitMembers = unit.declarations;
     for (CompilationUnitMember unitMember in unitMembers) {
       if (unitMember is TopLevelVariableDeclaration) {
         NodeList<VariableDeclaration> variables =
             unitMember.variables.variables;
         for (VariableDeclaration variable in variables) {
           if (variable.name.name == variableName) {
             return variable;
           }
         }
       }
     }
     return null;
   }
 
-  /**
-   * Return the declaration of the top-level function with the given
-   * [functionName] in the given compilation [unit].
-   */
-  FunctionDeclaration getTopLevelFunction(
-      CompilationUnit unit, String functionName) {
-    NodeList<CompilationUnitMember> unitMembers = unit.declarations;
-    for (CompilationUnitMember unitMember in unitMembers) {
-      if (unitMember is FunctionDeclaration) {
-        if (unitMember.name.name == functionName) {
-          return unitMember;
-        }
-      }
-    }
-    return null;
-  }
-
   void setUp() {
     super.setUp();
     emptySource = newSource('/test.dart');
   }
 
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }