Issue 8742. Preserve leading line comments during java2dart translation.

pkg/analyzer/test/generated/resolver_test.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
 import 'element_test.dart' show ElementFactory;
 
 class TypePropagationTest extends ResolverTestCase {
   void fail_propagatedReturnType_functionExpression() {
+    // TODO(scheglov) disabled because we don't resolve function expression
     String code = EngineTestCase.createSource(["main() {", "  var v = (() {return 42;})();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_as() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  bool get g => true;",
         "}",
         "A f(var p) {",
@@ skipping 69 matching lines @@
         "  for (var e in p) {",
         "    e;",
         "  }",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType stringType = typeProvider.stringType;
+    // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e in", SimpleIdentifier);
       JUnitTestCase.assertSame(stringType, identifier.propagatedType);
     }
+    // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e;", SimpleIdentifier);
       JUnitTestCase.assertSame(stringType, identifier.propagatedType);
     }
   }
 
   void test_functionExpression_asInvocationArgument() {
     String code = EngineTestCase.createSource([
         "class MyMap<K, V> {",
         "  forEach(f(K key, V value)) {}",
         "}",
         "f(MyMap<int, String> m) {",
         "  m.forEach((k, v) {",
         "    k;",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    // k
     Type2 intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
     SimpleIdentifier kIdentifier = EngineTestCase.findNode(unit, code, "k;", SimpleIdentifier);
     JUnitTestCase.assertSame(intType, kIdentifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.dynamicType, kIdentifier.staticType);
+    // v
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.dynamicType, vIdentifier.staticType);
   }
 
   void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
     String code = EngineTestCase.createSource([
         "class MyMap<K, V> {",
         "  forEach(f(K key, V value)) {}",
         "}",
         "f(MyMap<int, String> m) {",
         "  var m2 = m;",
         "  m2.forEach((k, v) {});",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    // k
     Type2 intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
+    // v
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
   }
 
   void test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
     String code = EngineTestCase.createSource([
         "main() {",
         "  (f(String value)) {} ((v) {",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    // v
     Type2 dynamicType = typeProvider.dynamicType;
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", FormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
     JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
   }
 
   void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
     String code = EngineTestCase.createSource([
         "class MyList {",
         "  forEach(f(Object value)) {}",
         "}",
         "f(MyList list) {",
         "  list.forEach((int v) {",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    // v
     Type2 intType = typeProvider.intType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(null, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(intType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(intType, vIdentifier.staticType);
     JUnitTestCase.assertSame(null, vIdentifier.propagatedType);
   }
 
   void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
     String code = EngineTestCase.createSource([
         "class MyList<E> {",
         "  forEach(f(E value)) {}",
         "}",
         "f(MyList<String> list) {",
         "  list.forEach((Object v) {",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    // v
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.objectType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
   }
 
   void test_Future_then() {
     String code = EngineTestCase.createSource([
         "import 'dart:async';",
         "main(Future<int> firstFuture) {",
         "  firstFuture.then((p1) {",
         "    return 1.0;",
         "  }).then((p2) {",
         "    return new Future<String>.value('str');",
         "  }).then((p3) {",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    // p1
     FormalParameter p1 = EngineTestCase.findNode(unit, code, "p1) {", SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.intType, p1.identifier.propagatedType);
+    // p2
     FormalParameter p2 = EngineTestCase.findNode(unit, code, "p2) {", SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.doubleType, p2.identifier.propagatedType);
+    // p3
     FormalParameter p3 = EngineTestCase.findNode(unit, code, "p3) {", SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.stringType, p3.identifier.propagatedType);
   }
 
   void test_initializer() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
+    // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement = statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       JUnitTestCase.assertSame(typeProvider.dynamicType, variableName.staticType);
       JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
     }
+    // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
     }
   }
 
   void test_initializer_dereference() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 'String';", "  v.", "}"]));
     LibraryElement library = resolve(source);
@@ skipping 57 matching lines @@
         "  if (p is String) {",
         "    return p;",
         "  } else {",
         "    return null;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    //    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
+    //    InterfaceType typeA = classA.getElement().getType();
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(null, variableName.propagatedType);
   }
 
   void test_is_if_logicalAnd() {
     Source source = addSource(EngineTestCase.createSource([
@@ skipping 385 matching lines @@
   /**
    * @param code the code that assigns the value to the variable "v", no matter how. We check that
    *          "v" has expected static and propagated type.
    */
   void check_propagatedReturnType(String code, Type2 expectedStaticType, Type2 expectedPropagatedType) {
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
+    //
     SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = ", SimpleIdentifier);
     JUnitTestCase.assertSame(expectedStaticType, identifier.staticType);
     JUnitTestCase.assertSame(expectedPropagatedType, identifier.propagatedType);
   }
 
   static dartSuite() {
     _ut.group('TypePropagationTest', () {
       _ut.test('test_Future_then', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_Future_then);
@@ skipping 819 matching lines @@
         "library lib1;",
         "class A {}",
         "@deprecated",
         "class B {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateDefinition_emptyName() {
+    // Note: This code has two FunctionElements '() {}' with an empty name, this tests that the
+    // empty string is not put into the scope (more than once).
     Source source = addSource(EngineTestCase.createSource([
         "Map _globalMap = {",
         "  'a' : () {},",
         "  'b' : () {}",
         "};"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 607 matching lines @@
   }
 
   void test_instanceMethodNameCollidesWithSuperclassStatic_method() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib.dart';",
         "class B extends A {",
         "  _m() {}",
         "}"]));
     addSource2("/lib.dart", EngineTestCase.createSource(["library L;", "class A {", "  static _m() {}", "}"]));
     resolve(source);
-    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    assertErrors(source, []);
     verify([source]);
   }
 
   void test_invalidAnnotation_constantVariable_field() {
     Source source = addSource(EngineTestCase.createSource(["@A.C", "class A {", "  static const C = 0;", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 5145 matching lines @@
     verify([source]);
   }
 
   void fail_missingReturn_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int m() {}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
+  void fail_overriddingPrivateMember_getter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {",
+        "  get _g => 0;",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  get _g => 0;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+
+  void fail_overriddingPrivateMember_method() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {",
+        "  _m(int x) => 0;",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  _m(int x) => 0;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+
+  void fail_overriddingPrivateMember_method2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {}",
+        "class C extends B {",
+        "  _m(int x) => 0;",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  _m(int x) => 0;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+
+  void fail_overriddingPrivateMember_setter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {",
+        "  set _s(int x) {}",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  set _s(int x) {}", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+
   void fail_overrideEqualsButNotHashCode() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  bool operator ==(x) {}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? 1 : 2;", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse_nested() {
+    // test that a dead else-statement can't generate additional violations
     Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? true : false && false;", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? 1 : 2;", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf_nested() {
+    // test that a dead then-statement can't generate additional violations
     Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? false && false : true;", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {} else {}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else_nested() {
+    // test that a dead else-statement can't generate additional violations
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {} else {if (false) {}}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_nested() {
+    // test that a dead then-statement can't generate additional violations
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {if(false) {}}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while_nested() {
+    // test that a dead while body can't generate additional violations
     Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {if(false) {}}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f() {",
         "  try {} catch (e) {} catch (e) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_nested() {
+    // test that a dead catch clause can't generate additional violations
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f() {",
         "  try {} catch (e) {} catch (e) {if(false) {}}",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_object() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  try {} on Object catch (e) {} catch (e) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_object_nested() {
+    // test that a dead catch clause can't generate additional violations
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  try {} on Object catch (e) {} catch (e) {if(false) {}}",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "f() {",
         "  try {} on A catch (e) {} on B catch (e) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype_nested() {
+    // test that a dead catch clause can't generate additional violations
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "f() {",
         "  try {} on A catch (e) {} on B catch (e) {if(false) {}}",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
@@ skipping 277 matching lines @@
   }
 
   void test_divisionOptimization_int() {
     Source source = addSource(EngineTestCase.createSource(["f(int x, int y) {", "  var v = (x / y).toInt();", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_propagatedType() {
+    // Tests the propagated type information of the '/' method
     Source source = addSource(EngineTestCase.createSource([
         "f(x, y) {",
         "  x = 1;",
         "  y = 1;",
         "  var v = (x / y).toInt();",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
@@ skipping 52 matching lines @@
     verify([source]);
   }
 
   void test_isNotDouble() {
     Source source = addSource(EngineTestCase.createSource(["var v = 1 is! double;"]));
     resolve(source);
     assertErrors(source, [HintCode.IS_NOT_DOUBLE]);
     verify([source]);
   }
 
-  void test_overriddingPrivateMember_getter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "class B extends A {",
-        "  get _g => 0;",
-        "}"]));
-    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  get _g => 0;", "}"]));
-    resolve(source);
-    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
-    verify([source, source2]);
-  }
-
-  void test_overriddingPrivateMember_method() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "class B extends A {",
-        "  _m(int x) => 0;",
-        "}"]));
-    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  _m(int x) => 0;", "}"]));
-    resolve(source);
-    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
-    verify([source, source2]);
-  }
-
-  void test_overriddingPrivateMember_method2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "class B extends A {}",
-        "class C extends B {",
-        "  _m(int x) => 0;",
-        "}"]));
-    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  _m(int x) => 0;", "}"]));
-    resolve(source);
-    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
-    verify([source, source2]);
-  }
-
-  void test_overriddingPrivateMember_setter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "class B extends A {",
-        "  set _s(int x) {}",
-        "}"]));
-    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  set _s(int x) {}", "}"]));
-    resolve(source);
-    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
-    verify([source, source2]);
-  }
-
   void test_typeCheck_type_is_Null() {
     Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is Null;", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.TYPE_CHECK_IS_NULL]);
     verify([source]);
   }
 
   void test_typeCheck_type_not_Null() {
     Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! Null;", "}"]));
     resolve(source);
@@ skipping 416 matching lines @@
         runJUnitTest(__test, __test.test_duplicateImport3);
       });
       _ut.test('test_isDouble', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_isDouble);
       });
       _ut.test('test_isNotDouble', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_isNotDouble);
       });
-      _ut.test('test_overriddingPrivateMember_getter', () {
-        final __test = new HintCodeTest();
-        runJUnitTest(__test, __test.test_overriddingPrivateMember_getter);
-      });
-      _ut.test('test_overriddingPrivateMember_method', () {
-        final __test = new HintCodeTest();
-        runJUnitTest(__test, __test.test_overriddingPrivateMember_method);
-      });
-      _ut.test('test_overriddingPrivateMember_method2', () {
-        final __test = new HintCodeTest();
-        runJUnitTest(__test, __test.test_overriddingPrivateMember_method2);
-      });
-      _ut.test('test_overriddingPrivateMember_setter', () {
-        final __test = new HintCodeTest();
-        runJUnitTest(__test, __test.test_overriddingPrivateMember_setter);
-      });
       _ut.test('test_typeCheck_type_is_Null', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_typeCheck_type_is_Null);
       });
       _ut.test('test_typeCheck_type_not_Null', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_typeCheck_type_not_Null);
       });
       _ut.test('test_undefinedGetter', () {
         final __test = new HintCodeTest();
@@ skipping 140 matching lines @@
   void fail_visitMethodDeclaration() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitVariableDeclaration() {
     JUnitTestCase.fail("Not yet tested");
     ClassElement type = ElementFactory.classElement2("A", []);
     VariableDeclaration node = ASTFactory.variableDeclaration("a");
     ASTFactory.variableDeclarationList(null, ASTFactory.typeName(type, []), [node]);
+    //resolve(node);
     JUnitTestCase.assertSame(type.type, node.name.staticType);
     _listener.assertNoErrors();
   }
 
   void setUp() {
     _listener = new GatheringErrorListener();
     SourceFactory factory = new SourceFactory.con2([new FileUriResolver()]);
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = factory;
     Source librarySource = new FileBasedSource.con1(factory.contentCache, FileUtilities2.createFile("/lib.dart"));
     _library = new Library(context, _listener, librarySource);
     LibraryElementImpl element = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
     _typeProvider = new TestTypeProvider();
     _visitor = new TypeResolverVisitor.con1(_library, librarySource, _typeProvider);
   }
 
   void test_visitCatchClause_exception() {
+    // catch (e)
     CatchClause clause = ASTFactory.catchClause("e", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
     resolve(clause, _typeProvider.dynamicType, null, []);
     _listener.assertNoErrors();
   }
 
   void test_visitCatchClause_exception_stackTrace() {
+    // catch (e, s)
     CatchClause clause = ASTFactory.catchClause2("e", "s", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement = new LocalVariableElementImpl(stackTraceParameter);
     resolve(clause, _typeProvider.dynamicType, _typeProvider.stackTraceType, []);
     _listener.assertNoErrors();
   }
 
   void test_visitCatchClause_on_exception() {
+    // on E catch (e)
     ClassElement exceptionElement = ElementFactory.classElement2("E", []);
     TypeName exceptionType = ASTFactory.typeName(exceptionElement, []);
     CatchClause clause = ASTFactory.catchClause4(exceptionType, "e", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
     resolve(clause, exceptionElement.type, null, [exceptionElement]);
     _listener.assertNoErrors();
   }
 
   void test_visitCatchClause_on_exception_stackTrace() {
+    // on E catch (e, s)
     ClassElement exceptionElement = ElementFactory.classElement2("E", []);
     TypeName exceptionType = ASTFactory.typeName(exceptionElement, []);
     (exceptionType.name as SimpleIdentifier).staticElement = exceptionElement;
     CatchClause clause = ASTFactory.catchClause5(exceptionType, "e", "s", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement = new LocalVariableElementImpl(stackTraceParameter);
     resolve(clause, exceptionElement.type, _typeProvider.stackTraceType, [exceptionElement]);
     _listener.assertNoErrors();
   }
 
   void test_visitClassDeclaration() {
+    // class A extends B with C implements D {}
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
     ExtendsClause extendsClause = ASTFactory.extendsClause(ASTFactory.typeName(elementB, []));
     WithClause withClause = ASTFactory.withClause([ASTFactory.typeName(elementC, [])]);
     ImplementsClause implementsClause = ASTFactory.implementsClause([ASTFactory.typeName(elementD, [])]);
     ClassDeclaration declaration = ASTFactory.classDeclaration(null, "A", null, extendsClause, withClause, implementsClause, []);
     declaration.name.staticElement = elementA;
     resolveNode(declaration, [elementA, elementB, elementC, elementD]);
     JUnitTestCase.assertSame(elementB.type, elementA.supertype);
     List<InterfaceType> mixins = elementA.mixins;
     EngineTestCase.assertLength(1, mixins);
     JUnitTestCase.assertSame(elementC.type, mixins[0]);
     List<InterfaceType> interfaces = elementA.interfaces;
     EngineTestCase.assertLength(1, interfaces);
     JUnitTestCase.assertSame(elementD.type, interfaces[0]);
     _listener.assertNoErrors();
   }
 
   void test_visitClassTypeAlias() {
+    // class A = B with C implements D;
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
     WithClause withClause = ASTFactory.withClause([ASTFactory.typeName(elementC, [])]);
     ImplementsClause implementsClause = ASTFactory.implementsClause([ASTFactory.typeName(elementD, [])]);
     ClassTypeAlias alias = ASTFactory.classTypeAlias("A", null, null, ASTFactory.typeName(elementB, []), withClause, implementsClause);
     alias.name.staticElement = elementA;
     resolveNode(alias, [elementA, elementB, elementC, elementD]);
     JUnitTestCase.assertSame(elementB.type, elementA.supertype);
@@ skipping 35 matching lines @@
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = ASTFactory.typeName4("int", []);
     String parameterName = "p";
     FormalParameter node = ASTFactory.fieldFormalParameter(null, intTypeName, parameterName);
     node.identifier.staticElement = ElementFactory.requiredParameter(parameterName);
     JUnitTestCase.assertSame(intType, resolve6(node, [intType.element]));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_noType() {
+    // p
     FormalParameter node = ASTFactory.simpleFormalParameter3("p");
     node.identifier.staticElement = new ParameterElementImpl.con1(ASTFactory.identifier3("p"));
     JUnitTestCase.assertSame(_typeProvider.dynamicType, resolve6(node, []));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_type() {
+    // int p
     InterfaceType intType = _typeProvider.intType;
     ClassElement intElement = intType.element;
     FormalParameter node = ASTFactory.simpleFormalParameter4(ASTFactory.typeName(intElement, []), "p");
     SimpleIdentifier identifier = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl.con1(identifier);
     identifier.staticElement = element;
     JUnitTestCase.assertSame(intType, resolve6(node, [intElement]));
     _listener.assertNoErrors();
   }
 
@@ skipping 350 matching lines @@
   }
 
   static dartSuite() {
     _ut.group('ResolverTestCase', () {
     });
   }
 }
 
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
+    //
+    // Create a mock library element with the types expected to be in dart:core. We cannot use
+    // either ElementFactory or TestTypeProvider (which uses ElementFactory) because we side-effect
+    // the elements in ways that would break other tests.
+    //
     InterfaceType objectType = classElement("Object", null, []).type;
     InterfaceType boolType = classElement("bool", objectType, []).type;
     InterfaceType numType = classElement("num", objectType, []).type;
     InterfaceType doubleType = classElement("double", numType, []).type;
     InterfaceType functionType = classElement("Function", objectType, []).type;
     InterfaceType intType = classElement("int", numType, []).type;
     InterfaceType listType = classElement("List", objectType, ["E"]).type;
     InterfaceType mapType = classElement("Map", objectType, ["K", "V"]).type;
     InterfaceType stackTraceType = classElement("StackTrace", objectType, []).type;
     InterfaceType stringType = classElement("String", objectType, []).type;
     InterfaceType symbolType = classElement("Symbol", objectType, []).type;
     InterfaceType typeType = classElement("Type", objectType, []).type;
     CompilationUnitElementImpl unit = new CompilationUnitElementImpl("lib.dart");
     unit.types = <ClassElement> [
         boolType.element,
         doubleType.element,
         functionType.element,
         intType.element,
         listType.element,
         mapType.element,
         objectType.element,
         stackTraceType.element,
         stringType.element,
         symbolType.element,
         typeType.element];
     LibraryElementImpl library = new LibraryElementImpl(new AnalysisContextImpl(), ASTFactory.libraryIdentifier2(["lib"]));
     library.definingCompilationUnit = unit;
+    //
+    // Create a type provider and ensure that it can return the expected types.
+    //
     TypeProviderImpl provider = new TypeProviderImpl(library);
     JUnitTestCase.assertSame(boolType, provider.boolType);
     JUnitTestCase.assertNotNull(provider.bottomType);
     JUnitTestCase.assertSame(doubleType, provider.doubleType);
     JUnitTestCase.assertNotNull(provider.dynamicType);
     JUnitTestCase.assertSame(functionType, provider.functionType);
     JUnitTestCase.assertSame(intType, provider.intType);
     JUnitTestCase.assertSame(listType, provider.listType);
     JUnitTestCase.assertSame(mapType, provider.mapType);
     JUnitTestCase.assertSame(objectType, provider.objectType);
@@ skipping 784 matching lines @@
         "class A {",
         "  A() {}",
         "}",
         "class B extends Object mixin A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
 
   void fail_mixinOfNonClass() {
+    // TODO(brianwilkerson) Compare with MIXIN_WITH_NON_CLASS_SUPERCLASS.
     Source source = addSource(EngineTestCase.createSource(["var A;", "class B extends Object mixin A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
 
   void fail_objectCannotExtendAnotherClass() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]);
@@ skipping 1001 matching lines @@
         "class A {",
         "  final int x;",
         "  const A() : x = '';",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_fieldInitializerOutsideConstructor() {
+    // TODO(brianwilkerson) Fix the duplicate error messages.
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  m(this.x) {}", "}"]));
     resolve(source);
     assertErrors(source, [
         ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
         CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_fieldInitializerOutsideConstructor_defaultParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  m([this.x]) {}", "}"]));
@@ skipping 251 matching lines @@
         "  var f;",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
 
   void test_importInternalLibrary() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_interceptors';"]));
     resolve(source);
+    // Note, in these error cases we may generate an UNUSED_IMPORT hint, while we could prevent
+    // the hint from being generated by testing the import directive for the error, this is such a
+    // minor corner case that we don't think we should add the additional computation time to figure
+    // out such cases.
     assertErrors(source, [
         CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
         HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
 
   void test_importInternalLibrary_collection() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_collection-dev';"]));
     resolve(source);
+    // Note, in these error cases we may generate an UNUSED_IMPORT hint, while we could prevent
+    // the hint from being generated by testing the import directive for the error, this is such a
+    // minor corner case that we don't think we should add the additional computation time to figure
+    // out such cases.
     assertErrors(source, [
         CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
         HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
 
   void test_importOfNonLibrary() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
     addSource2("/part.dart", EngineTestCase.createSource(["part of lib;", "class A{}"]));
     resolve(source);
@@ skipping 582 matching lines @@
         "class A {}",
         "class B extends A {",
         "  B() : super(), super() {}",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]);
     verify([source]);
   }
 
   void test_nativeClauseInNonSDKCode() {
+    // TODO(jwren) Move this test somewhere else: This test verifies a parser error code is generated
+    // through the ErrorVerifier, it is not a CompileTimeErrorCode.
     Source source = addSource(EngineTestCase.createSource(["class A native 'string' {}"]));
     resolve(source);
     assertErrors(source, [ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
     verify([source]);
   }
 
   void test_nativeFunctionBodyInNonSDKCode_function() {
+    // TODO(jwren) Move this test somewhere else: This test verifies a parser error code is generated
+    // through the ErrorVerifier, it is not a CompileTimeErrorCode.
     Source source = addSource(EngineTestCase.createSource(["int m(a) native 'string';"]));
     resolve(source);
     assertErrors(source, [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
     verify([source]);
   }
 
   void test_nativeFunctionBodyInNonSDKCode_method() {
+    // TODO(jwren) Move this test somewhere else: This test verifies a parser error code is generated
+    // through the ErrorVerifier, it is not a CompileTimeErrorCode.
     Source source = addSource(EngineTestCase.createSource(["class A{", "  static int m(a) native 'string';", "}"]));
     resolve(source);
     assertErrors(source, [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
     verify([source]);
   }
 
   void test_noAnnotationConstructorArguments() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "@A", "main() {", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS]);
@@ skipping 2595 matching lines @@
     return null;
   }
 
   Object visitImportDirective(ImportDirective node) => null;
 
   Object visitLabel(Label node) => null;
 
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
+    // In cases where we have a prefixed identifier where the prefix is dynamic, we don't want to
+    // assert that the node will have a type.
     if (node.staticType == null && identical(node.prefix.staticType, DynamicTypeImpl.instance)) {
       return null;
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
+    // In cases where identifiers are being used for something other than an expressions,
+    // then they can be ignored.
     ASTNode parent = node.parent;
     if (parent is MethodInvocation && identical(node, parent.methodName)) {
       return null;
     } else if (parent is RedirectingConstructorInvocation && identical(node, parent.constructorName)) {
       return null;
     } else if (parent is SuperConstructorInvocation && identical(node, parent.constructorName)) {
       return null;
     } else if (parent is ConstructorName && identical(node, parent.name)) {
       return null;
     } else if (parent is ConstructorFieldInitializer && identical(node, parent.fieldName)) {
       return null;
     } else if (node.staticElement is PrefixElement) {
+      // Prefixes don't have a type.
       return null;
     }
     return super.visitSimpleIdentifier(node);
   }
 
   Object visitTypeName(TypeName node) {
+    // Note: do not visit children from this node, the child SimpleIdentifier in TypeName
+    // (i.e. "String") does not have a static type defined.
     if (node.type == null) {
       _unresolvedTypes.add(node);
     } else {
       _resolvedTypeCount++;
     }
     return null;
   }
 
   String getFileName(ASTNode node) {
+    // TODO (jwren) there are two copies of this method, one here and one in ResolutionVerifier,
+    // they should be resolved into a single method
     if (node != null) {
       ASTNode root = node.root;
       if (root is CompilationUnit) {
         CompilationUnit rootCU = root;
         if (rootCU.element != null) {
           return rootCU.element.source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
@@ skipping 229 matching lines @@
    */
   ResolverVisitor _visitor;
 
   /**
    * The resolver being used to resolve the test cases.
    */
   ElementResolver _resolver;
 
   void fail_visitExportDirective_combinators() {
     JUnitTestCase.fail("Not yet tested");
+    // Need to set up the exported library so that the identifier can be resolved
     ExportDirective directive = ASTFactory.exportDirective2(null, [ASTFactory.hideCombinator2(["A"])]);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionExpressionInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_noPrefix() {
     JUnitTestCase.fail("Not yet tested");
+    // Need to set up the imported library so that the identifier can be resolved
     ImportDirective directive = ASTFactory.importDirective2(null, null, [ASTFactory.showCombinator2(["A"])]);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_prefix() {
     JUnitTestCase.fail("Not yet tested");
+    // Need to set up the imported library so that the identifiers can be resolved
     String prefixName = "p";
     _definingLibrary.imports = <ImportElement> [ElementFactory.importFor(null, ElementFactory.prefix(prefixName), [])];
     ImportDirective directive = ASTFactory.importDirective2(null, prefixName, [
         ASTFactory.showCombinator2(["A"]),
         ASTFactory.hideCombinator2(["B"])]);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void fail_visitRedirectingConstructorInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _resolver = createResolver();
   }
 
   void test_lookUpMethodInInterfaces() {
     InterfaceType intType = _typeProvider.intType;
+    //
+    // abstract class A { int operator[](int index); }
+    //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     MethodElement operator = ElementFactory.methodElement("[]", intType, [intType]);
     classA.methods = <MethodElement> [operator];
+    //
+    // class B implements A {}
+    //
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
+    //
+    // class C extends Object with B {}
+    //
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classC.mixins = <InterfaceType> [classB.type];
+    //
+    // class D extends C {}
+    //
     ClassElementImpl classD = ElementFactory.classElement("D", classC.type, []);
+    //
+    // D a;
+    // a[i];
+    //
     SimpleIdentifier array = ASTFactory.identifier3("a");
     array.staticType = classD.type;
     IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.identifier3("i"));
     JUnitTestCase.assertSame(operator, resolve5(expression, []));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compound() {
     InterfaceType intType = _typeProvider.intType;
     SimpleIdentifier leftHandSide = ASTFactory.identifier3("a");
@@ skipping 238 matching lines @@
     target.staticType = classA.type;
     PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(getterName));
     resolveNode(identifier, []);
     JUnitTestCase.assertSame(getter, identifier.staticElement);
     JUnitTestCase.assertSame(getter, identifier.identifier.staticElement);
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    // set accessors
     String propName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter, setter];
+    // prepare "A.m"
     SimpleIdentifier target = ASTFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(propName));
+    // resolve
     resolveNode(identifier, []);
     JUnitTestCase.assertSame(getter, identifier.staticElement);
     JUnitTestCase.assertSame(getter, identifier.identifier.staticElement);
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_method() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    // set accessors
     String propName = "m";
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setter];
+    // set methods
     MethodElement method = ElementFactory.methodElement("m", _typeProvider.intType, []);
     classA.methods = <MethodElement> [method];
+    // prepare "A.m"
     SimpleIdentifier target = ASTFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(propName));
     ASTFactory.assignmentExpression(identifier, TokenType.EQ, ASTFactory.nullLiteral());
+    // resolve
     resolveNode(identifier, []);
     JUnitTestCase.assertSame(method, identifier.staticElement);
     JUnitTestCase.assertSame(method, identifier.identifier.staticElement);
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_setter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    // set accessors
     String propName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter, setter];
+    // prepare "A.b = null"
     SimpleIdentifier target = ASTFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(propName));
     ASTFactory.assignmentExpression(identifier, TokenType.EQ, ASTFactory.nullLiteral());
+    // resolve
     resolveNode(identifier, []);
     JUnitTestCase.assertSame(setter, identifier.staticElement);
     JUnitTestCase.assertSame(setter, identifier.identifier.staticElement);
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = ASTFactory.identifier3("i");
     operand.staticType = numType;
@@ skipping 10 matching lines @@
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = ASTFactory.identifier3("a");
     target.staticType = classA.type;
     PropertyAccess access = ASTFactory.propertyAccess2(target, getterName);
     resolveNode(access, []);
     JUnitTestCase.assertSame(getter, access.propertyName.staticElement);
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_getter_super() {
+    //
+    // class A {
+    //  int get b;
+    // }
+    // class B {
+    //   ... super.m ...
+    // }
+    //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SuperExpression target = ASTFactory.superExpression();
     target.staticType = ElementFactory.classElement("B", classA.type, []).type;
     PropertyAccess access = ASTFactory.propertyAccess2(target, getterName);
     ASTFactory.methodDeclaration2(null, null, null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([]), ASTFactory.expressionFunctionBody(access));
     resolveNode(access, []);
     JUnitTestCase.assertSame(getter, access.propertyName.staticElement);
@@ skipping 2217 matching lines @@
         "abstract class B extends A {",
         "  m(p);",
         "}",
         "class C extends B {}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() {
+    // bug 15028
     Source source = addSource(EngineTestCase.createSource([
         "class C {",
         "  foo(int x) => x;",
         "}",
         "abstract class D {",
         "  foo(x, [y]);",
         "}",
         "class E extends C implements D {}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
@@ skipping 42 matching lines @@
         "  m(p);",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() {
+    // 7640
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x(int a);",
         "}",
         "abstract class B {",
         "  int x(int a, [int b]);",
         "}",
         "class C implements A, B {",
         "}"]));
     resolve(source);
@@ skipping 19 matching lines @@
         "  set s(int i);",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface() {
+    // bug 11154
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get a => 'a';",
         "}",
         "abstract class B implements A {",
         "  get b => 'b';",
         "}",
         "class C extends B {",
         "}"]));
     resolve(source);
@@ skipping 1269 matching lines @@
    * Creates new [AnalysisContext] using [AnalysisContextFactory#contextWithCore].
    */
   AnalysisContextHelper() {
     context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = context.sourceFactory;
     _cache = _sourceFactory.contentCache;
   }
 
   Source addSource(String path, String code) {
     Source source = new FileBasedSource.con1(_cache, FileUtilities2.createFile(path));
+    // add source
     {
       _sourceFactory.setContents(source, "");
       ChangeSet changeSet = new ChangeSet();
       changeSet.added(source);
       context.applyChanges(changeSet);
     }
+    // update source
     context.setContents(source, code);
     return source;
   }
 
   CompilationUnit resolveDefiningUnit(Source source) {
     LibraryElement libraryElement = context.computeLibraryElement(source);
     return context.resolveCompilationUnit(source, libraryElement);
   }
 }
 
@@ skipping 307 matching lines @@
       _typeType = ElementFactory.classElement2("Type", []).type;
     }
     return _typeType;
   }
 
   /**
    * Initialize the numeric types. They are created as a group so that we can (a) create the right
    * hierarchy and (b) add members to them.
    */
   void initializeNumericTypes() {
+    //
+    // Create the type hierarchy.
+    //
     ClassElementImpl numElement = ElementFactory.classElement2("num", []);
     _numType = numElement.type;
     ClassElementImpl intElement = ElementFactory.classElement("int", _numType, []);
     _intType = intElement.type;
     ClassElementImpl doubleElement = ElementFactory.classElement("double", _numType, []);
     _doubleType = doubleElement.type;
+    //
+    // Force the referenced types to be cached.
+    //
     boolType;
     stringType;
+    //
+    // Add the methods.
+    //
     numElement.methods = <MethodElement> [
         ElementFactory.methodElement("+", _numType, [_numType]),
         ElementFactory.methodElement("-", _numType, [_numType]),
         ElementFactory.methodElement("*", _numType, [_numType]),
         ElementFactory.methodElement("%", _numType, [_numType]),
         ElementFactory.methodElement("/", _doubleType, [_numType]),
         ElementFactory.methodElement("~/", _numType, [_numType]),
         ElementFactory.methodElement("-", _numType, []),
         ElementFactory.methodElement("remainder", _numType, [_numType]),
         ElementFactory.methodElement("<", _boolType, [_numType]),
@@ skipping 95 matching lines @@
 
   /**
    * Initialize the given analysis context with a fake core library already resolved.
    *
    * @param context the context to be initialized (not `null`)
    * @return the analysis context that was created
    */
   static AnalysisContextImpl initContextWithCore(AnalysisContextImpl context) {
     AnalysisContext sdkContext = DirectoryBasedDartSdk.defaultSdk.context;
     SourceFactory sourceFactory = sdkContext.sourceFactory;
+    //
+    // dart:core
+    //
     TestTypeProvider provider = new TestTypeProvider();
     CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     sdkContext.setContents(coreSource, "");
     coreUnit.source = coreSource;
     coreUnit.types = <ClassElement> [
         provider.boolType.element,
         provider.deprecatedType.element,
         provider.doubleType.element,
         provider.functionType.element,
@@ skipping 11 matching lines @@
     TopLevelVariableElement proxyTopLevelVariableElt = ElementFactory.topLevelVariableElement3("proxy", true, false, ElementFactory.classElement2("_Proxy", []).type);
     TopLevelVariableElement deprecatedTopLevelVariableElt = ElementFactory.topLevelVariableElement3("deprecated", true, false, provider.deprecatedType);
     coreUnit.accessors = <PropertyAccessorElement> [
         proxyTopLevelVariableElt.getter,
         proxyTopLevelVariableElt.setter,
         deprecatedTopLevelVariableElt.getter,
         deprecatedTopLevelVariableElt.setter];
     coreUnit.topLevelVariables = <TopLevelVariableElement> [proxyTopLevelVariableElt, deprecatedTopLevelVariableElt];
     LibraryElementImpl coreLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
+    //
+    // dart:html
+    //
     CompilationUnitElementImpl htmlUnit = new CompilationUnitElementImpl("html_dartium.dart");
     Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
     sdkContext.setContents(htmlSource, "");
     htmlUnit.source = htmlSource;
     ClassElementImpl elementElement = ElementFactory.classElement2("Element", []);
     InterfaceType elementType = elementElement.type;
     ClassElementImpl documentElement = ElementFactory.classElement("Document", elementType, []);
     ClassElementImpl htmlDocumentElement = ElementFactory.classElement("HtmlDocument", documentElement.type, []);
     htmlDocumentElement.methods = <MethodElement> [ElementFactory.methodElement("query", elementType, <Type2> [provider.stringType])];
     htmlUnit.types = <ClassElement> [
@@ skipping 323 matching lines @@
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     node.visitChildren(this);
     if (node.element is LibraryElement) {
       _wrongTypedNodes.add(node);
     }
     return null;
   }
 
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.visitChildren(this);
+    // TODO(brianwilkerson) If we start resolving function expressions, then conditionally check to
+    // see whether the node was resolved correctly.
     return null;
   }
 
   Object visitImportDirective(ImportDirective node) {
+    // Not sure how to test the combinators given that it isn't an error if the names are not defined.
     checkResolved2(node, node.element, ImportElement);
     SimpleIdentifier prefix = node.prefix;
     if (prefix == null) {
       return null;
     }
     return checkResolved2(prefix, prefix.staticElement, PrefixElement);
   }
 
   Object visitIndexExpression(IndexExpression node) {
     node.visitChildren(this);
@@ skipping 83 matching lines @@
       }
     } else if (expectedClass != null) {
       if (!isInstanceOf(element, expectedClass)) {
         _wrongTypedNodes.add(node);
       }
     }
     return null;
   }
 
   String getFileName(ASTNode node) {
+    // TODO (jwren) there are two copies of this method, one here and one in StaticTypeVerifier,
+    // they should be resolved into a single method
     if (node != null) {
       ASTNode root = node.root;
       if (root is CompilationUnit) {
         CompilationUnit rootCU = root;
         if (rootCU.element != null) {
           return rootCU.element.source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
@@ skipping 161 matching lines @@
     _listener.assertNoErrors();
   }
 
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _analyzer = createAnalyzer();
   }
 
   void test_visitAdjacentStrings() {
+    // "a" "b"
     Expression node = ASTFactory.adjacentStrings([resolvedString("a"), resolvedString("b")]);
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitArgumentDefinitionTest() {
+    // ?p
     Expression node = ASTFactory.argumentDefinitionTest("p");
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitAsExpression() {
+    // class A { ... this as B ... }
+    // class B extends A {}
     ClassElement superclass = ElementFactory.classElement2("A", []);
     InterfaceType superclassType = superclass.type;
     ClassElement subclass = ElementFactory.classElement("B", superclassType, []);
     Expression node = ASTFactory.asExpression(ASTFactory.thisExpression(), ASTFactory.typeName(subclass, []));
     JUnitTestCase.assertSame(subclass.type, analyze2(node, superclassType));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compound() {
+    // i += 1
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier identifier = resolvedVariable(_typeProvider.intType, "i");
     AssignmentExpression node = ASTFactory.assignmentExpression(identifier, TokenType.PLUS_EQ, resolvedInteger(1));
     MethodElement plusMethod = getMethod(numType, "+");
     node.staticElement = plusMethod;
     JUnitTestCase.assertSame(numType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_simple() {
+    // i = 0
     InterfaceType intType = _typeProvider.intType;
     Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType, "i"), TokenType.EQ, resolvedInteger(0));
     JUnitTestCase.assertSame(intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_equals() {
+    // 2 == 3
     Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.EQ_EQ, resolvedInteger(3));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_logicalAnd() {
+    // false && true
     Expression node = ASTFactory.binaryExpression(ASTFactory.booleanLiteral(false), TokenType.AMPERSAND_AMPERSAND, ASTFactory.booleanLiteral(true));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_logicalOr() {
+    // false || true
     Expression node = ASTFactory.binaryExpression(ASTFactory.booleanLiteral(false), TokenType.BAR_BAR, ASTFactory.booleanLiteral(true));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_notEquals() {
+    // 2 != 3
     Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.BANG_EQ, resolvedInteger(3));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_plusID() {
+    // 1 + 2.0
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(1), TokenType.PLUS, resolvedDouble(2.0));
     node.staticElement = getMethod(_typeProvider.numType, "+");
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_plusII() {
+    // 1 + 2
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(1), TokenType.PLUS, resolvedInteger(2));
     node.staticElement = getMethod(_typeProvider.numType, "+");
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_slash() {
+    // 2 / 2
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.SLASH, resolvedInteger(2));
     node.staticElement = getMethod(_typeProvider.numType, "/");
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_star_notSpecial() {
+    // class A {
+    //   A operator *(double value);
+    // }
+    // (a as A) * 2.0
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     MethodElement operator = ElementFactory.methodElement("*", typeA, [_typeProvider.doubleType]);
     classA.methods = <MethodElement> [operator];
     BinaryExpression node = ASTFactory.binaryExpression(ASTFactory.asExpression(ASTFactory.identifier3("a"), ASTFactory.typeName(classA, [])), TokenType.PLUS, resolvedDouble(2.0));
     node.staticElement = operator;
     JUnitTestCase.assertSame(typeA, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_starID() {
+    // 1 * 2.0
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(1), TokenType.PLUS, resolvedDouble(2.0));
     node.staticElement = getMethod(_typeProvider.numType, "*");
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBooleanLiteral_false() {
+    // false
     Expression node = ASTFactory.booleanLiteral(false);
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitBooleanLiteral_true() {
+    // true
     Expression node = ASTFactory.booleanLiteral(true);
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitCascadeExpression() {
+    // a..length
     Expression node = ASTFactory.cascadeExpression(resolvedString("a"), [ASTFactory.propertyAccess2(null, "length")]);
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_differentTypes() {
+    // true ? 1.0 : 0
     Expression node = ASTFactory.conditionalExpression(ASTFactory.booleanLiteral(true), resolvedDouble(1.0), resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.numType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_sameTypes() {
+    // true ? 1 : 0
     Expression node = ASTFactory.conditionalExpression(ASTFactory.booleanLiteral(true), resolvedInteger(1), resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitDoubleLiteral() {
+    // 4.33
     Expression node = ASTFactory.doubleLiteral(4.33);
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_named_block() {
+    // ({p1 : 0, p2 : 0}) {}
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p1"), resolvedInteger(0));
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p1"] = dynamicType;
     expectedNamedTypes["p2"] = dynamicType;
     assertFunctionType(dynamicType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_named_expression() {
+    // ({p : 0}) -> 0;
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
     setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p"] = dynamicType;
     assertFunctionType(_typeProvider.intType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normal_block() {
+    // (p1, p2) {}
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.simpleFormalParameter3("p2");
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(dynamicType, <Type2> [dynamicType, dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normal_expression() {
+    // (p1, p2) -> 0
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.simpleFormalParameter3("p");
     setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndNamed_block() {
+    // (p1, {p2 : 0}) {}
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p2"] = dynamicType;
     assertFunctionType(dynamicType, <Type2> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndNamed_expression() {
+    // (p1, {p2 : 0}) -> 0
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p2"] = dynamicType;
     assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndPositional_block() {
+    // (p1, [p2 = 0]) {}
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(dynamicType, <Type2> [dynamicType], <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndPositional_expression() {
+    // (p1, [p2 = 0]) -> 0
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_block() {
+    // ([p1 = 0, p2 = 0]) {}
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p1"), resolvedInteger(0));
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(dynamicType, null, <Type2> [dynamicType, dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_expression() {
+    // ([p1 = 0, p2 = 0]) -> 0
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
     setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, null, <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_getter() {
+    // List a;
+    // a[2]
     InterfaceType listType = _typeProvider.listType;
     SimpleIdentifier identifier = resolvedVariable(listType, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
     MethodElement indexMethod = listType.element.methods[0];
     node.staticElement = indexMethod;
     JUnitTestCase.assertSame(listType.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_setter() {
+    // List a;
+    // a[2] = 0
     InterfaceType listType = _typeProvider.listType;
     SimpleIdentifier identifier = resolvedVariable(listType, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
     MethodElement indexMethod = listType.element.methods[1];
     node.staticElement = indexMethod;
     ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
     JUnitTestCase.assertSame(listType.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_typeParameters() {
+    // List<int> list = ...
+    // list[0]
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
+    // (int) -> E
     MethodElement methodElement = getMethod(listType, "[]");
+    // "list" has type List<int>
     SimpleIdentifier identifier = ASTFactory.identifier3("list");
     InterfaceType listOfIntType = listType.substitute4(<Type2> [intType]);
     identifier.staticType = listOfIntType;
+    // list[0] has MethodElement element (int) -> E
     IndexExpression indexExpression = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
+    // analyze and assert result of the index expression
     JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_typeParameters_inSetterContext() {
+    // List<int> list = ...
+    // list[0] = 0;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
+    // (int, E) -> void
     MethodElement methodElement = getMethod(listType, "[]=");
+    // "list" has type List<int>
     SimpleIdentifier identifier = ASTFactory.identifier3("list");
     InterfaceType listOfIntType = listType.substitute4(<Type2> [intType]);
     identifier.staticType = listOfIntType;
+    // list[0] has MethodElement element (int) -> E
     IndexExpression indexExpression = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
+    // list[0] should be in a setter context
     ASTFactory.assignmentExpression(indexExpression, TokenType.EQ, ASTFactory.integer(0));
+    // analyze and assert result of the index expression
     JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_named() {
+    // new C.m()
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, constructorName, []);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), [ASTFactory.identifier3(constructorName)]);
     node.staticElement = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_typeParameters() {
+    // new C<I>()
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(elementC, null, []);
     elementC.constructors = <ConstructorElement> [constructor];
     constructor.returnType = elementC.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     TypeName typeName = ASTFactory.typeName(elementC, [ASTFactory.typeName(elementI, [])]);
     typeName.type = elementC.type.substitute4(<Type2> [elementI.type]);
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, typeName, []);
     node.staticElement = constructor;
     InterfaceType interfaceType = analyze(node) as InterfaceType;
     List<Type2> typeArgs = interfaceType.typeArguments;
     JUnitTestCase.assertEquals(1, typeArgs.length);
     JUnitTestCase.assertEquals(elementI.type, typeArgs[0]);
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
+    // new C()
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, null, []);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), []);
     node.staticElement = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitIntegerLiteral() {
+    // 42
     Expression node = resolvedInteger(42);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitIsExpression_negated() {
+    // a is! String
     Expression node = ASTFactory.isExpression(resolvedString("a"), true, ASTFactory.typeName4("String", []));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitIsExpression_notNegated() {
+    // a is String
     Expression node = ASTFactory.isExpression(resolvedString("a"), false, ASTFactory.typeName4("String", []));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_empty() {
+    // []
     Expression node = ASTFactory.listLiteral([]);
     Type2 resultType = analyze(node);
     assertType2(_typeProvider.listType.substitute4(<Type2> [_typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_nonEmpty() {
+    // [0]
     Expression node = ASTFactory.listLiteral([resolvedInteger(0)]);
     Type2 resultType = analyze(node);
     assertType2(_typeProvider.listType.substitute4(<Type2> [_typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_empty() {
+    // {}
     Expression node = ASTFactory.mapLiteral2([]);
     Type2 resultType = analyze(node);
     assertType2(_typeProvider.mapType.substitute4(<Type2> [_typeProvider.dynamicType, _typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_nonEmpty() {
+    // {"k" : 0}
     Expression node = ASTFactory.mapLiteral2([ASTFactory.mapLiteralEntry("k", resolvedInteger(0))]);
     Type2 resultType = analyze(node);
     assertType2(_typeProvider.mapType.substitute4(<Type2> [_typeProvider.dynamicType, _typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_then() {
+    // then()
     Expression node = ASTFactory.methodInvocation(null, "then", []);
     analyze(node);
     _listener.assertNoErrors();
   }
 
   void test_visitNamedExpression() {
+    // n: a
     Expression node = ASTFactory.namedExpression2("n", resolvedString("a"));
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitNullLiteral() {
+    // null
     Expression node = ASTFactory.nullLiteral();
     JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitParenthesizedExpression() {
+    // (0)
     Expression node = ASTFactory.parenthesizedExpression(resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression_minusMinus() {
+    // 0--
     PostfixExpression node = ASTFactory.postfixExpression(resolvedInteger(0), TokenType.MINUS_MINUS);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression_plusPlus() {
+    // 0++
     PostfixExpression node = ASTFactory.postfixExpression(resolvedInteger(0), TokenType.PLUS_PLUS);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_getter() {
     Type2 boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PrefixedIdentifier node = ASTFactory.identifier5("a", "b");
     node.identifier.staticElement = getter;
@@ skipping 14 matching lines @@
   void test_visitPrefixedIdentifier_variable() {
     VariableElementImpl variable = ElementFactory.localVariableElement2("b");
     variable.type = _typeProvider.boolType;
     PrefixedIdentifier node = ASTFactory.identifier5("a", "b");
     node.identifier.staticElement = variable;
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_bang() {
+    // !0
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.BANG, resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_minus() {
+    // -0
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.MINUS, resolvedInteger(0));
     MethodElement minusMethod = getMethod(_typeProvider.numType, "-");
     node.staticElement = minusMethod;
     JUnitTestCase.assertSame(_typeProvider.numType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_minusMinus() {
+    // --0
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.MINUS_MINUS, resolvedInteger(0));
     MethodElement minusMethod = getMethod(_typeProvider.numType, "-");
     node.staticElement = minusMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_not() {
+    // !true
     Expression node = ASTFactory.prefixExpression(TokenType.BANG, ASTFactory.booleanLiteral(true));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_plusPlus() {
+    // ++0
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.PLUS_PLUS, resolvedInteger(0));
     MethodElement plusMethod = getMethod(_typeProvider.numType, "+");
     node.staticElement = plusMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_tilde() {
+    // ~0
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.TILDE, resolvedInteger(0));
     MethodElement tildeMethod = getMethod(_typeProvider.intType, "~");
     node.staticElement = tildeMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_getter() {
     Type2 boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier3("a"), "b");
     node.propertyName.staticElement = getter;
     JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_setter() {
     Type2 boolType = _typeProvider.boolType;
     FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType);
     PropertyAccessorElement setter = field.setter;
     PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier3("a"), "b");
     node.propertyName.staticElement = setter;
     JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleStringLiteral() {
+    // "a"
     Expression node = resolvedString("a");
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitStringInterpolation() {
+    // "a${'b'}c"
     Expression node = ASTFactory.string([
         ASTFactory.interpolationString("a", "a"),
         ASTFactory.interpolationExpression(resolvedString("b")),
         ASTFactory.interpolationString("c", "c")]);
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitSuperExpression() {
+    // super
     InterfaceType superType = ElementFactory.classElement2("A", []).type;
     InterfaceType thisType = ElementFactory.classElement("B", superType, []).type;
     Expression node = ASTFactory.superExpression();
     JUnitTestCase.assertSame(thisType, analyze2(node, thisType));
     _listener.assertNoErrors();
   }
 
   void test_visitSymbolLiteral() {
     JUnitTestCase.assertSame(_typeProvider.symbolType, analyze(ASTFactory.symbolLiteral(["a"])));
   }
 
   void test_visitThisExpression() {
+    // this
     InterfaceType thisType = ElementFactory.classElement("B", ElementFactory.classElement2("A", []).type, []).type;
     Expression node = ASTFactory.thisExpression();
     JUnitTestCase.assertSame(thisType, analyze2(node, thisType));
     _listener.assertNoErrors();
   }
 
   void test_visitThrowExpression_withoutValue() {
+    // throw
     Expression node = ASTFactory.throwExpression();
     JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node));
     _listener.assertNoErrors();
   }
 
   void test_visitThrowExpression_withValue() {
+    // throw 0
     Expression node = ASTFactory.throwExpression2(resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node));
     _listener.assertNoErrors();
   }
 
   /**
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
    *
    * @param node the expression with which the type is associated
@@ skipping 948 matching lines @@
         "f(var a) {",
         "  if(a is A) {",
         "    a.b = 0;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_unnecessaryCast_13855_parameter_A() {
+    // dartbug.com/13855, dartbug.com/13732
     Source source = addSource(EngineTestCase.createSource([
         "class A{",
         "  a() {}",
         "}",
         "class B<E> {",
         "  E e;",
         "  m() {",
         "    (e as A).a();",
         "  }",
         "}"]));
@@ skipping 1165 matching lines @@
         "  void m1() {}",
         "  void m2() {}",
         "  void m() {",
         "    A a = new A();",
         "    a..m1()",
         "     ..name = 'name'",
         "     ..m2();",
         "  }",
         "}"]));
     resolve(source);
+    // failing with error code: INVOCATION_OF_NON_FUNCTION
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_resolveAgainstNull() {
     Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
     resolve(source);
     assertNoErrors(source);
   }
 
@@ skipping 263 matching lines @@
   List<bool> found;
 
   List<AnalysisException> thrownException;
 
   RecursiveASTVisitor_SimpleResolverTest_test_localVariable_types_invoked(this.SimpleResolverTest_this, this.found, this.thrownException) : super();
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.name == "myVar" && node.parent is MethodInvocation) {
       try {
         found[0] = true;
+        // check static type
         Type2 staticType = node.staticType;
         JUnitTestCase.assertSame(SimpleResolverTest_this.typeProvider.dynamicType, staticType);
+        // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         JUnitTestCase.assertEquals(SimpleResolverTest_this.typeProvider.stringType, propagatedType.returnType);
       } on AnalysisException catch (e) {
         thrownException[0] = e;
       }
     }
     return null;
   }
 }
 
 class SubtypeManagerTest extends EngineTestCase {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
 
   void test_computeAllSubtypes_infiniteLoop() {
+    //
+    // class A extends B
+    // class B extends A
+    //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     classA.supertype = classB.type;
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     EngineTestCase.assertSize3(2, subtypesOfA);
     EngineTestCase.assertContains(arraySubtypesOfA, [classA, classB]);
   }
 
   void test_computeAllSubtypes_manyRecursiveSubtypes() {
+    //
+    // class A
+    // class B extends A
+    // class C extends B
+    // class D extends B
+    // class E extends B
+    //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
     ClassElementImpl classD = ElementFactory.classElement("D", classB.type, []);
     ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
     _definingCompilationUnit.types = <ClassElement> [classA, classB, classC, classD, classE];
     Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     Set<ClassElement> subtypesOfB = _subtypeManager.computeAllSubtypes(classB);
     List<ClassElement> arraySubtypesOfB = new List.from(subtypesOfB);
     EngineTestCase.assertSize3(4, subtypesOfA);
     EngineTestCase.assertContains(arraySubtypesOfA, [classB, classC, classD, classE]);
     EngineTestCase.assertSize3(3, subtypesOfB);
     EngineTestCase.assertContains(arraySubtypesOfB, [classC, classD, classE]);
   }
 
   void test_computeAllSubtypes_noSubtypes() {
+    //
+    // class A
+    //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     _definingCompilationUnit.types = <ClassElement> [classA];
     Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     EngineTestCase.assertSize3(0, subtypesOfA);
   }
 
   void test_computeAllSubtypes_oneSubtype() {
+    //
+    // class A
+    // class B extends A
+    //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     EngineTestCase.assertSize3(1, subtypesOfA);
     EngineTestCase.assertContains(arraySubtypesOfA, [classB]);
   }
 
   void setUp() {
@@ skipping 280 matching lines @@
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }