analyzer_experimental checkpoint and AnalysisContext example.

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // 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 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
@@ skipping 559 matching lines @@
     JUnitTestCase.assertSame(elementD.type, interfaces4[0]);
     _listener.assertNoErrors();
   }
   void test_visitSimpleFormalParameter_noType() {
     FormalParameter node = ASTFactory.simpleFormalParameter3("p");
     node.identifier.element = new ParameterElementImpl(ASTFactory.identifier2("p"));
     JUnitTestCase.assertSame(_typeProvider.dynamicType, resolve5(node, []));
     _listener.assertNoErrors();
   }
   void test_visitSimpleFormalParameter_type() {
-    InterfaceType intType8 = _typeProvider.intType;
-    ClassElement intElement = intType8.element;
+    InterfaceType intType9 = _typeProvider.intType;
+    ClassElement intElement = intType9.element;
     FormalParameter node = ASTFactory.simpleFormalParameter4(ASTFactory.typeName(intElement, []), "p");
     SimpleIdentifier identifier18 = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl(identifier18);
     identifier18.element = element;
-    JUnitTestCase.assertSame(intType8, resolve5(node, [intElement]));
+    JUnitTestCase.assertSame(intType9, resolve5(node, [intElement]));
     _listener.assertNoErrors();
   }
   void test_visitTypeName_noParameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     TypeName typeName5 = ASTFactory.typeName(classA, []);
     typeName5.type = null;
     resolveNode(typeName5, [classA]);
     JUnitTestCase.assertSame(classA.type, typeName5.type);
     _listener.assertNoErrors();
   }
@@ skipping 317 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
     verify([source]);
   }
   void fail_compileTimeConstantRaisesException() {
     Source source = addSource("/test.dart", EngineTestCase.createSource([]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]);
     verify([source]);
   }
-  void fail_constEvalThrowsException() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class C {", "  const C() { throw null; }", "}", "f() { return const C(); }"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
-    verify([source]);
-  }
   void fail_constWithNonConstantArgument() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class T {", "  T(a) {};", "}", "f(p) { return const T(p); }"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
     verify([source]);
   }
   void fail_constWithNonType() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;", "f() {", "  return const A();", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source]);
   }
   void fail_constWithTypeParameters() {
     Source source = addSource("/test.dart", EngineTestCase.createSource([]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS]);
     verify([source]);
   }
   void fail_constWithUndefinedConstructor() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  A(x) {}", "}", "f() {", "  return const A(0);", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
     verify([source]);
   }
-  void fail_defaultValueInFunctionTypeAlias() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["typedef F([x = 0]);"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
-    verify([source]);
-  }
   void fail_duplicateDefinition() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  int m = 0;", "  m(a) {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void fail_duplicateMemberName() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x = 0;", "  int x() {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME]);
@@ skipping 11 matching lines @@
     assertErrors([CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT]);
     verify([source]);
   }
   void fail_exportOfNonLibrary() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
     addSource("/lib1.dart", EngineTestCase.createSource(["part of lib;"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
-  void fail_extendsOrImplementsDisallowedClass_extends_bool() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends bool {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_extends_double() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends double {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_extends_int() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends int {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
   void fail_extendsOrImplementsDisallowedClass_extends_null() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends Null {}"]));
     resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_extends_num() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends num {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_extends_String() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends String {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_implements_bool() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements bool {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_implements_double() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements double {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_implements_int() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements int {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void fail_extendsOrImplementsDisallowedClass_implements_null() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements Null {}"]));
     resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_implements_num() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements num {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
-    verify([source]);
-  }
-  void fail_extendsOrImplementsDisallowedClass_implements_String() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements String {}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void fail_fieldInitializedByMultipleInitializers() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A() : x = 0, x = 1 {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
   void fail_fieldInitializedInInitializerAndDeclaration() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() : x = 1 {}", "}"]));
@@ skipping 574 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD]);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  const A() {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
     verify([source]);
   }
+  void test_constEvalThrowsException() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class C {", "  const C() { throw null; }", "}", "f() { return const C(); }"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
+    verify([source]);
+  }
   void test_constFormalParameter_fieldFormalParameter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  var x;", "  A(const this.x) {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
     verify([source]);
   }
   void test_constFormalParameter_simpleFormalParameter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(const x) {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
@@ skipping 10 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_constWithNonConst() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class T {", "  T(a, b, {c, d}) {}", "}", "f() { return const T(0, 1, c: 2, d: 3); }"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]);
     verify([source]);
   }
+  void test_defaultValueInFunctionTypeAlias() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["typedef F([x = 0]);"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
+    verify([source]);
+  }
   void test_duplicateMemberError() {
     Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
     Source sourceA = addSource("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     Source sourceB = addSource("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     resolve(librarySource, [sourceA, sourceB]);
     assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA, sourceB]);
   }
   void test_extendsNonClass() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;", "class B extends A {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.EXTENDS_NON_CLASS]);
     verify([source]);
   }
+  void test_extendsOrImplementsDisallowedClass_extends_bool() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends bool {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_extends_double() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends double {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_extends_int() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends int {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_extends_num() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends num {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_extends_String() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends String {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_implements_bool() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements bool {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_implements_double() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements double {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_implements_int() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements int {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_implements_num() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements num {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
+  void test_extendsOrImplementsDisallowedClass_implements_String() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements String {}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    verify([source]);
+  }
   void test_implementsNonClass() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;", "class B implements A {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
     verify([source]);
   }
   void test_labelInOuterScope() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class int {}", "", "class A {", "  void m(int i) {", "    l: while (i > 0) {", "      void f() {", "        break l;", "      };", "    }", "  }", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, ResolverErrorCode.CANNOT_BE_RESOLVED]);
@@ skipping 81 matching lines @@
         runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_field);
       });
       _ut.test('test_conflictingConstructorNameAndMember_method', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_method);
       });
       _ut.test('test_constConstructorWithNonFinalField', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField);
       });
+      _ut.test('test_constEvalThrowsException', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constEvalThrowsException);
+      });
       _ut.test('test_constFormalParameter_fieldFormalParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constFormalParameter_fieldFormalParameter);
       });
       _ut.test('test_constFormalParameter_simpleFormalParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constFormalParameter_simpleFormalParameter);
       });
       _ut.test('test_constInitializedWithNonConstValue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInitializedWithNonConstValue);
       });
       _ut.test('test_constWithInvalidTypeParameters', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithInvalidTypeParameters);
       });
       _ut.test('test_constWithNonConst', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithNonConst);
       });
+      _ut.test('test_defaultValueInFunctionTypeAlias', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
+      });
       _ut.test('test_duplicateMemberError', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateMemberError);
       });
       _ut.test('test_extendsNonClass', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsNonClass);
       });
+      _ut.test('test_extendsOrImplementsDisallowedClass_extends_String', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_String);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_extends_bool', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_bool);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_extends_double', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_double);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_extends_int', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_int);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_extends_num', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_num);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_implements_String', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_String);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_implements_bool', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_bool);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_implements_double', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_double);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_implements_int', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_int);
+      });
+      _ut.test('test_extendsOrImplementsDisallowedClass_implements_num', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_num);
+      });
       _ut.test('test_implementsNonClass', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsNonClass);
       });
       _ut.test('test_labelInOuterScope', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelInOuterScope);
       });
       _ut.test('test_labelUndefined_break', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 1469 matching lines @@
   List<ASTNode> _unresolvedNodes = new List<ASTNode>();
   /**
    * A list containing all of the AST nodes that were resolved to an element of the wrong type.
    */
   List<ASTNode> _wrongTypedNodes = new List<ASTNode>();
   /**
    * Initialize a newly created verifier to verify that all of the nodes in the visited AST
    * structures that are expected to have been resolved have an element associated with them.
    */
   ResolutionVerifier() {
-    _jtd_constructor_317_impl();
+    _jtd_constructor_319_impl();
   }
-  _jtd_constructor_317_impl() {
-    _jtd_constructor_318_impl(null);
+  _jtd_constructor_319_impl() {
+    _jtd_constructor_320_impl(null);
   }
   /**
    * Initialize a newly created verifier to verify that all of the identifiers in the visited AST
    * structures that are expected to have been resolved have an element associated with them. Nodes
    * in the set of known exceptions are not expected to have been resolved, even if they normally
    * would have been expected to have been resolved.
    * @param knownExceptions a set containing nodes that are known to not be resolvable and should
    * therefore not cause the test to fail
    */
   ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) {
-    _jtd_constructor_318_impl(knownExceptions2);
+    _jtd_constructor_320_impl(knownExceptions2);
   }
-  _jtd_constructor_318_impl(Set<ASTNode> knownExceptions2) {
+  _jtd_constructor_320_impl(Set<ASTNode> knownExceptions2) {
     this._knownExceptions = knownExceptions2;
   }
   /**
    * Assert that all of the visited identifiers were resolved.
    */
   void assertResolved() {
     if (!_unresolvedNodes.isEmpty || !_wrongTypedNodes.isEmpty) {
       PrintStringWriter writer = new PrintStringWriter();
       if (!_unresolvedNodes.isEmpty) {
         writer.print("Failed to resolve ");
@@ skipping 175 matching lines @@
    */
   StaticTypeAnalyzer _analyzer;
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
   void fail_visitFunctionExpressionInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
-  void fail_visitIndexExpression_typeParameters() {
-    InterfaceType intType6 = _typeProvider.intType;
-    InterfaceType listType2 = _typeProvider.listType;
-    MethodElement methodElement = getMethod(listType2, "[]");
-    SimpleIdentifier identifier = ASTFactory.identifier2("list");
-    identifier.staticType = listType2.substitute5(<Type2> [intType6]);
-    IndexExpression indexExpression2 = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
-    indexExpression2.element = methodElement;
-    JUnitTestCase.assertSame(intType6, analyze(indexExpression2));
-    _listener.assertNoErrors();
-  }
   void fail_visitMethodInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
   void fail_visitSimpleIdentifier() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
   void setUp() {
     _listener = new GatheringErrorListener();
@@ skipping 20 matching lines @@
   }
   void test_visitAssignmentExpression_compound() {
     InterfaceType numType6 = _typeProvider.numType;
     SimpleIdentifier identifier = resolvedVariable(_typeProvider.intType, "i");
     AssignmentExpression node = ASTFactory.assignmentExpression(identifier, TokenType.PLUS_EQ, resolvedInteger(1));
     node.element = getMethod(numType6, "+");
     JUnitTestCase.assertSame(numType6, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_simple() {
-    InterfaceType intType7 = _typeProvider.intType;
-    Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType7, "i"), TokenType.EQ, resolvedInteger(0));
-    JUnitTestCase.assertSame(intType7, analyze(node));
+    InterfaceType intType6 = _typeProvider.intType;
+    Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType6, "i"), TokenType.EQ, resolvedInteger(0));
+    JUnitTestCase.assertSame(intType6, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_equals() {
     Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.EQ_EQ, resolvedInteger(3));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_logicalAnd() {
     Expression node = ASTFactory.binaryExpression(ASTFactory.booleanLiteral(false), TokenType.AMPERSAND_AMPERSAND, ASTFactory.booleanLiteral(true));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
@@ skipping 167 matching lines @@
     Type2 dynamicType12 = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
     setType(p, dynamicType12);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, null, <Type2> [dynamicType12], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_getter() {
+    InterfaceType listType2 = _typeProvider.listType;
+    SimpleIdentifier identifier = resolvedVariable(listType2, "a");
+    IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
+    node.element = listType2.element.methods[0];
+    JUnitTestCase.assertSame(listType2.typeArguments[0], analyze(node));
+    _listener.assertNoErrors();
+  }
+  void test_visitIndexExpression_setter() {
     InterfaceType listType3 = _typeProvider.listType;
     SimpleIdentifier identifier = resolvedVariable(listType3, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
-    node.element = listType3.element.methods[0];
+    node.element = listType3.element.methods[1];
+    ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
     JUnitTestCase.assertSame(listType3.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
-  void test_visitIndexExpression_setter() {
+  void test_visitIndexExpression_typeParameters() {
+    InterfaceType intType7 = _typeProvider.intType;
     InterfaceType listType4 = _typeProvider.listType;
-    SimpleIdentifier identifier = resolvedVariable(listType4, "a");
-    IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
-    node.element = listType4.element.methods[1];
-    ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
-    JUnitTestCase.assertSame(listType4.typeArguments[0], analyze(node));
+    MethodElement methodElement = getMethod(listType4, "[]");
+    SimpleIdentifier identifier = ASTFactory.identifier2("list");
+    identifier.staticType = listType4.substitute5(<Type2> [intType7]);
+    IndexExpression indexExpression2 = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
+    indexExpression2.element = methodElement;
+    JUnitTestCase.assertSame(intType7, analyze(indexExpression2));
+    _listener.assertNoErrors();
+  }
+  void test_visitIndexExpression_typeParameters_inSetterContext() {
+    InterfaceType intType8 = _typeProvider.intType;
+    InterfaceType listType5 = _typeProvider.listType;
+    MethodElement methodElement = getMethod(listType5, "[]=");
+    SimpleIdentifier identifier = ASTFactory.identifier2("list");
+    identifier.staticType = listType5.substitute5(<Type2> [intType8]);
+    IndexExpression indexExpression3 = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
+    indexExpression3.element = methodElement;
+    ASTFactory.assignmentExpression(indexExpression3, TokenType.EQ, ASTFactory.integer(0));
+    JUnitTestCase.assertSame(intType8, analyze(indexExpression3));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_named() {
     ClassElement classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement(constructorName);
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructorType.returnType = classElement.type;
     constructor.type = constructorType;
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), [ASTFactory.identifier2(constructorName)]);
@@ skipping 325 matching lines @@
     return literal;
   }
   /**
    * Create a function expression that has an element associated with it, where the element has an
    * incomplete type associated with it (just like the one{@link ElementBuilder#visitFunctionExpression(FunctionExpression)} would have built if we had
    * run it).
    * @param parameters the parameters to the function
    * @param body the body of the function
    * @return a resolved function expression
    */
-  FunctionExpression resolvedFunctionExpression(FormalParameterList parameters15, FunctionBody body) {
-    for (FormalParameter parameter in parameters15.parameters) {
+  FunctionExpression resolvedFunctionExpression(FormalParameterList parameters16, FunctionBody body) {
+    for (FormalParameter parameter in parameters16.parameters) {
       ParameterElementImpl element = new ParameterElementImpl(parameter.identifier);
       element.parameterKind = parameter.kind;
       element.type = _typeProvider.dynamicType;
       parameter.identifier.element = element;
     }
-    FunctionExpression node = ASTFactory.functionExpression2(parameters15, body);
+    FunctionExpression node = ASTFactory.functionExpression2(parameters16, body);
     FunctionElementImpl element = new FunctionElementImpl.con1(null);
     element.type = new FunctionTypeImpl.con1(element);
     node.element = element;
     return node;
   }
   /**
    * Return an integer literal that has been resolved to the correct type.
    * @param value the value of the literal
    * @return an integer literal that has been resolved to the correct type
    */
@@ skipping 147 matching lines @@
         runJUnitTest(__test, __test.test_visitFunctionExpression_positional_expression);
       });
       _ut.test('test_visitIndexExpression_getter', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitIndexExpression_getter);
       });
       _ut.test('test_visitIndexExpression_setter', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitIndexExpression_setter);
       });
+      _ut.test('test_visitIndexExpression_typeParameters', () {
+        final __test = new StaticTypeAnalyzerTest();
+        runJUnitTest(__test, __test.test_visitIndexExpression_typeParameters);
+      });
+      _ut.test('test_visitIndexExpression_typeParameters_inSetterContext', () {
+        final __test = new StaticTypeAnalyzerTest();
+        runJUnitTest(__test, __test.test_visitIndexExpression_typeParameters_inSetterContext);
+      });
       _ut.test('test_visitInstanceCreationExpression_named', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitInstanceCreationExpression_named);
       });
       _ut.test('test_visitInstanceCreationExpression_typeParameters', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitInstanceCreationExpression_typeParameters);
       });
       _ut.test('test_visitInstanceCreationExpression_unnamed', () {
         final __test = new StaticTypeAnalyzerTest();
@@ skipping 481 matching lines @@
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_syntheticField() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const A();", "  set x(value) {}", "  get x {return 0;}", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
+  void test_defaultValueInFunctionTypeAlias() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["typedef F([x]);"]));
+    resolve(source, []);
+    assertErrors([]);
+    verify([source]);
+  }
   void test_duplicateDefinition_getter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["bool get a => true;"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_empty() {
     Source source = addSource("/test.dart", "");
     resolve(source, []);
     assertNoErrors();
@@ skipping 16 matching lines @@
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int get f => 0;", "  void set f(String s) {}", "}", "g (A a) {", "  a.f = a.f.toString();", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
+  void test_indexExpression_typeParameters() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  List<int> a;", "  a[0];", "  List<List<int>> b;", "  b[0][0];", "  List<List<List<int>>> c;", "  c[0][0][0];", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_indexExpression_typeParameters_invalidAssignmentWarning() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  List<List<int>> b;", "  b[0][0] = 'hi';", "}"]));
+    resolve(source, []);
+    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    verify([source]);
+  }
   void test_invalidAssignment() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var x;", "  var y;", "  x = y;", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidAssignment_toDynamic() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var g;", "  g = () => 0;", "}"]));
     resolve(source, []);
     assertNoErrors();
@@ skipping 180 matching lines @@
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_const);
       });
       _ut.test('test_constConstructorWithNonFinalField_final', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_final);
       });
       _ut.test('test_constConstructorWithNonFinalField_syntheticField', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_syntheticField);
       });
+      _ut.test('test_defaultValueInFunctionTypeAlias', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
+      });
       _ut.test('test_duplicateDefinition_getter', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_getter);
       });
       _ut.test('test_empty', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_empty);
       });
       _ut.test('test_forEachLoops_nonConflicting', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_forEachLoops_nonConflicting);
       });
       _ut.test('test_forLoops_nonConflicting', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_forLoops_nonConflicting);
       });
       _ut.test('test_functionTypeAlias', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_functionTypeAlias);
       });
       _ut.test('test_getterAndSetterWithDifferentTypes', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_getterAndSetterWithDifferentTypes);
       });
+      _ut.test('test_indexExpression_typeParameters', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_indexExpression_typeParameters);
+      });
+      _ut.test('test_indexExpression_typeParameters_invalidAssignmentWarning', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_indexExpression_typeParameters_invalidAssignmentWarning);
+      });
       _ut.test('test_invalidAssignment', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_invalidAssignment);
       });
       _ut.test('test_invalidAssignment_toDynamic', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_invalidAssignment_toDynamic);
       });
       _ut.test('test_invocationOfNonFunction_dynamic', () {
         final __test = new SimpleResolverTest();
@@ skipping 68 matching lines @@
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
     });
   }
 }
 main() {
-//  ElementResolverTest.dartSuite();
-//  LibraryElementBuilderTest.dartSuite();
-//  LibraryTest.dartSuite();
-//  StaticTypeAnalyzerTest.dartSuite();
-//  TypeProviderImplTest.dartSuite();
-//  TypeResolverVisitorTest.dartSuite();
-//  EnclosedScopeTest.dartSuite();
-//  LibraryImportScopeTest.dartSuite();
-//  LibraryScopeTest.dartSuite();
-//  ScopeTest.dartSuite();
-//  CompileTimeErrorCodeTest.dartSuite();
-//  ErrorResolverTest.dartSuite();
-//  SimpleResolverTest.dartSuite();
-//  StaticTypeWarningCodeTest.dartSuite();
-//  StaticWarningCodeTest.dartSuite();
+  ElementResolverTest.dartSuite();
+  LibraryElementBuilderTest.dartSuite();
+  LibraryTest.dartSuite();
+  StaticTypeAnalyzerTest.dartSuite();
+  TypeProviderImplTest.dartSuite();
+  TypeResolverVisitorTest.dartSuite();
+  EnclosedScopeTest.dartSuite();
+  LibraryImportScopeTest.dartSuite();
+  LibraryScopeTest.dartSuite();
+  ScopeTest.dartSuite();
+  CompileTimeErrorCodeTest.dartSuite();
+  ErrorResolverTest.dartSuite();
+  SimpleResolverTest.dartSuite();
+  StaticTypeWarningCodeTest.dartSuite();
+  StaticWarningCodeTest.dartSuite();
 }