New analyzer_experimental snapshot.

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';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 935 matching lines @@
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidFactoryNameNotAClass() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_invalidMethodOverrideNamedParamType() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({int a}) {}", "}", "class B implements A {", "  m({int a, int b}) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invalidOverrideDifferentDefaultValues_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({int p : 0}) {}", "}", "class B extends A {", "  m({int p : 0}) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invalidOverrideDifferentDefaultValues_positional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([int p = 0]) {}", "}", "class B extends A {", "  m([int p = 0]) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invalidOverrideDifferentDefaultValues_positional_changedOrder() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([int a = 0, String b = '0']) {}", "}", "class B extends A {", "  m([int b = 0, String a = '0']) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_invalidOverrideNamed_unorderedNamedParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m({a, b}) {}", "}", "class B extends A {", "  m({b, a}) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_interface() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource(["abstract class A {", "  num m();", "}", "class B implements A {", "  int m() { return 1; }", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 184 matching lines @@
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonBoolExpression_assert_functionType() {
     Source source = addSource(EngineTestCase.createSource(["bool makeAssertion() => true;", "f() {", "  assert(makeAssertion);", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_nonConstantDefaultValue_function_named() {
+    Source source = addSource(EngineTestCase.createSource(["f({x : 2 + 3}) {}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_function_positional() {
+    Source source = addSource(EngineTestCase.createSource(["f([x = 2 + 3]) {}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_inConstructor_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A({x : 2 + 3}) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_inConstructor_positional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A([x = 2 + 3]) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_method_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({x : 2 + 3}) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_method_positional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([x = 2 + 3]) {}", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_nonConstCaseExpression() {
     Source source = addSource(EngineTestCase.createSource(["f(Type t) {", "  switch (t) {", "    case bool:", "    case int:", "      return true;", "    default:", "      return false;", "  }", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_const() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  const {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 268 matching lines @@
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_unnamed() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends A {", "  B() : super();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_undefinedConstructorInInitializer_hasOptionalParameters() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A([p]) {}", "}", "class B extends A {", "  B();", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_undefinedConstructorInInitializer_implicit() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends A {", "  B();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_implicit_typedef() {
     Source source = addSource(EngineTestCase.createSource(["class M {}", "typedef A = Object with M;", "class B extends A {", "  B();", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 404 matching lines @@
         runJUnitTest(__test, __test.test_invalidAssignment_compoundAssignment);
       });
       _ut.test('test_invalidAssignment_toDynamic', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidAssignment_toDynamic);
       });
       _ut.test('test_invalidFactoryNameNotAClass', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidFactoryNameNotAClass);
       });
+      _ut.test('test_invalidMethodOverrideNamedParamType', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidMethodOverrideNamedParamType);
+      });
+      _ut.test('test_invalidOverrideDifferentDefaultValues_named', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_named);
+      });
+      _ut.test('test_invalidOverrideDifferentDefaultValues_positional', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional);
+      });
+      _ut.test('test_invalidOverrideDifferentDefaultValues_positional_changedOrder', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional_changedOrder);
+      });
       _ut.test('test_invalidOverrideNamed_unorderedNamedParameter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidOverrideNamed_unorderedNamedParameter);
       });
       _ut.test('test_invalidOverrideReturnType_returnType_interface', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidOverrideReturnType_returnType_interface);
       });
       _ut.test('test_invalidOverrideReturnType_returnType_interface2', () {
         final __test = new NonErrorResolverTest();
@@ skipping 164 matching lines @@
         runJUnitTest(__test, __test.test_nonConstValueInInitializer_redirecting);
       });
       _ut.test('test_nonConstValueInInitializer_super', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonConstValueInInitializer_super);
       });
       _ut.test('test_nonConstValueInInitializer_unary', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonConstValueInInitializer_unary);
       });
+      _ut.test('test_nonConstantDefaultValue_function_named', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_function_named);
+      });
+      _ut.test('test_nonConstantDefaultValue_function_positional', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_function_positional);
+      });
+      _ut.test('test_nonConstantDefaultValue_inConstructor_named', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_inConstructor_named);
+      });
+      _ut.test('test_nonConstantDefaultValue_inConstructor_positional', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_inConstructor_positional);
+      });
+      _ut.test('test_nonConstantDefaultValue_method_named', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_method_named);
+      });
+      _ut.test('test_nonConstantDefaultValue_method_positional', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_method_positional);
+      });
       _ut.test('test_nonGenerativeConstructor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonGenerativeConstructor);
       });
       _ut.test('test_nonTypeInCatchClause_isClass', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonTypeInCatchClause_isClass);
       });
       _ut.test('test_nonTypeInCatchClause_isFunctionTypeAlias', () {
         final __test = new NonErrorResolverTest();
@@ skipping 124 matching lines @@
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
       _ut.test('test_undefinedConstructorInInitializer_explicit_named', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_named);
       });
       _ut.test('test_undefinedConstructorInInitializer_explicit_unnamed', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_unnamed);
       });
+      _ut.test('test_undefinedConstructorInInitializer_hasOptionalParameters', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_hasOptionalParameters);
+      });
       _ut.test('test_undefinedConstructorInInitializer_implicit', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit);
       });
       _ut.test('test_undefinedConstructorInInitializer_implicit_typedef', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit_typedef);
       });
       _ut.test('test_undefinedConstructorInInitializer_redirecting', () {
         final __test = new NonErrorResolverTest();
@@ skipping 331 matching lines @@
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolExpression() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(0);", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
     verify([source]);
   }
+  void test_returnOfInvalidType_expressionFunctionBody_function() {
+    Source source = addSource(EngineTestCase.createSource(["int f() => '0';"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
+  void test_returnOfInvalidType_expressionFunctionBody_getter() {
+    Source source = addSource(EngineTestCase.createSource(["int get g => '0';"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
+  void test_returnOfInvalidType_expressionFunctionBody_localFunction() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  String m() {", "    int f() => '0';", "  }", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
+  void test_returnOfInvalidType_expressionFunctionBody_method() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int f() => '0';", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
+  void test_returnOfInvalidType_expressionFunctionBody_void() {
+    Source source = addSource(EngineTestCase.createSource(["void f() => 42;"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
   void test_returnOfInvalidType_function() {
     Source source = addSource(EngineTestCase.createSource(["int f() { return '0'; }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
+  void test_returnOfInvalidType_getter() {
+    Source source = addSource(EngineTestCase.createSource(["int get g { return '0'; }"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
   void test_returnOfInvalidType_localFunction() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  String m() {", "    int f() { return '0'; }", "  }", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int f() { return '0'; }", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
@@ skipping 151 matching lines @@
         runJUnitTest(__test, __test.test_nonBoolCondition_if);
       });
       _ut.test('test_nonBoolCondition_while', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonBoolCondition_while);
       });
       _ut.test('test_nonBoolExpression', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonBoolExpression);
       });
+      _ut.test('test_returnOfInvalidType_expressionFunctionBody_function', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_function);
+      });
+      _ut.test('test_returnOfInvalidType_expressionFunctionBody_getter', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_getter);
+      });
+      _ut.test('test_returnOfInvalidType_expressionFunctionBody_localFunction', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_localFunction);
+      });
+      _ut.test('test_returnOfInvalidType_expressionFunctionBody_method', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_method);
+      });
+      _ut.test('test_returnOfInvalidType_expressionFunctionBody_void', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_void);
+      });
       _ut.test('test_returnOfInvalidType_function', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_function);
       });
+      _ut.test('test_returnOfInvalidType_getter', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_getter);
+      });
       _ut.test('test_returnOfInvalidType_localFunction', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_localFunction);
       });
       _ut.test('test_returnOfInvalidType_method', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_method);
       });
       _ut.test('test_returnOfInvalidType_void', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 366 matching lines @@
       _ut.test('test_visitTypeName_void', () {
         final __test = new TypeResolverVisitorTest();
         runJUnitTest(__test, __test.test_visitTypeName_void);
       });
     });
   }
 }
 class ResolverTestCase extends EngineTestCase {
 
   /**
-   * The source factory used to create {@link Source sources}.
+   * The source factory used to create [Source sources].
    */
   SourceFactory _sourceFactory;
 
   /**
    * The analysis context used to parse the compilation units being resolved.
    */
   AnalysisContextImpl _analysisContext;
   void setUp() {
     reset();
   }
@@ skipping 58 matching lines @@
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
   Source cacheSource(String filePath, String contents) {
     Source source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(filePath));
     _sourceFactory.setContents(source, contents);
     return source;
   }
 
   /**
-   * Create a library element that represents a library named {@code "test"} containing a single
+   * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisContextImpl(), "test", []);
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    * @param libraryName the name of the library to be created
    * @return the library element that was created
@@ skipping 36 matching lines @@
    * reset test instance to reuse it.
    */
   void reset() {
     _analysisContext = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _analysisContext.sourceFactory;
   }
 
   /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
    * the parts. This assumes that the sources for the library and its parts have already been added
-   * to the content provider using the method {@link #addSource(String,String)}.
+   * to the content provider using the method [addSource].
    * @param librarySource the source for the compilation unit that defines the library
    * @return the element representing the resolved library
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElement resolve(Source librarySource) => _analysisContext.computeLibraryElement(librarySource);
 
   /**
    * Return the resolved compilation unit corresponding to the given source in the given library.
    * @param source the source of the compilation unit to be returned
    * @param library the library in which the compilation unit is to be resolved
@@ skipping 608 matching lines @@
     resolve(source);
     assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
   void fail_mixinOfNonClass() {
     Source source = addSource(EngineTestCase.createSource(["var A;", "class B extends Object mixin A {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
-  void fail_nonConstantDefaultValue_named() {
-    Source source = addSource(EngineTestCase.createSource(["f({x : 2 + 3}) {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
-    verify([source]);
-  }
-  void fail_nonConstantDefaultValue_positional() {
-    Source source = addSource(EngineTestCase.createSource(["f([x = 2 + 3]) {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
-    verify([source]);
-  }
   void fail_objectCannotExtendAnotherClass() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]);
     verify([source]);
   }
   void fail_recursiveCompileTimeConstant() {
     Source source = addSource(EngineTestCase.createSource(["const x = y + 1;", "const y = x + 1;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
@@ skipping 452 matching lines @@
   }
   void test_extendsNonClass_class() {
     Source source = addSource(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(EngineTestCase.createSource(["class A extends bool {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_double() {
     Source source = addSource(EngineTestCase.createSource(["class A extends double {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_int() {
     Source source = addSource(EngineTestCase.createSource(["class A extends int {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_num() {
     Source source = addSource(EngineTestCase.createSource(["class A extends num {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_String() {
     Source source = addSource(EngineTestCase.createSource(["class A extends String {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
+    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_implements_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A implements bool {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_implements_double() {
     Source source = addSource(EngineTestCase.createSource(["class A implements double {}"]));
@@ skipping 95 matching lines @@
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A.named() {}", "  A(this.x) : this.named();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
 
   /**
    * This test doesn't test the FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR code, but tests the
    * FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION code instead. It is provided here to show
    * coverage over all of the permutations of initializers in constructor declarations.
-   * <p>
+   *
    * Note: FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION covers a subset of
    * FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, since it more specific, we use it instead of
    * the broader code
    */
   void test_finalInitializedInDeclarationAndConstructor_initializers() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x = 0;", "  A() : x = 0 {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     verify([source]);
   }
   void test_finalInitializedInDeclarationAndConstructor_initializingFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x = 0;", "  A(this.x) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
     verify([source]);
   }
   void test_finalInitializedMultipleTimes_initializers() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A() : x = 0, x = 0 {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
 
   /**
    * This test doesn't test the FINAL_INITIALIZED_MULTIPLE_TIMES code, but tests the
    * FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER code instead. It is provided here to show
    * coverage over all of the permutations of initializers in constructor declarations.
-   * <p>
+   *
    * Note: FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER covers a subset of
    * FINAL_INITIALIZED_MULTIPLE_TIMES, since it more specific, we use it instead of the broader code
    */
   void test_finalInitializedMultipleTimes_initializingFormal_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A(this.x) : x = 0 {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
     verify([source]);
   }
   void test_finalInitializedMultipleTimes_initializingFormals() {
@@ skipping 373 matching lines @@
     resolve(source);
     assertErrors([ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_newWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f() { return new A<A>(); }"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
+  void test_nonConstantDefaultValue_function_named() {
+    Source source = addSource(EngineTestCase.createSource(["int y;", "f({x : y}) {}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_function_positional() {
+    Source source = addSource(EngineTestCase.createSource(["int y;", "f([x = y]) {}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_inConstructor_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  A({x : y}) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_inConstructor_positional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  A([x = y]) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_method_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  m({x : y}) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
+  void test_nonConstantDefaultValue_method_positional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  m([x = y]) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
   void test_nonConstCaseExpression() {
     Source source = addSource(EngineTestCase.createSource(["f(int p, int q) {", "  switch (p) {", "    case 3 + q:", "      break;", "  }", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
     verify([source]);
   }
   void test_nonConstListElement() {
     Source source = addSource(EngineTestCase.createSource(["f(a) {", "  return const [a];", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
@@ skipping 1130 matching lines @@
         runJUnitTest(__test, __test.test_nonConstValueInInitializer_field);
       });
       _ut.test('test_nonConstValueInInitializer_redirecting', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstValueInInitializer_redirecting);
       });
       _ut.test('test_nonConstValueInInitializer_super', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstValueInInitializer_super);
       });
+      _ut.test('test_nonConstantDefaultValue_function_named', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_function_named);
+      });
+      _ut.test('test_nonConstantDefaultValue_function_positional', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_function_positional);
+      });
+      _ut.test('test_nonConstantDefaultValue_inConstructor_named', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_inConstructor_named);
+      });
+      _ut.test('test_nonConstantDefaultValue_inConstructor_positional', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_inConstructor_positional);
+      });
+      _ut.test('test_nonConstantDefaultValue_method_named', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_method_named);
+      });
+      _ut.test('test_nonConstantDefaultValue_method_positional', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nonConstantDefaultValue_method_positional);
+      });
       _ut.test('test_nonGenerativeConstructor_explicit', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonGenerativeConstructor_explicit);
       });
       _ut.test('test_nonGenerativeConstructor_implicit', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonGenerativeConstructor_implicit);
       });
       _ut.test('test_notEnoughRequiredArguments_const', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 228 matching lines @@
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooFew);
       });
       _ut.test('test_wrongNumberOfParametersForSetter_method_tooMany', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooMany);
       });
     });
   }
 }
 /**
- * Instances of the class {@code StaticTypeVerifier} verify that all of the nodes in an AST
+ * Instances of the class `StaticTypeVerifier` verify that all of the nodes in an AST
  * structure that should have a static type associated with them do have a static type.
  */
 class StaticTypeVerifier extends GeneralizingASTVisitor<Object> {
 
   /**
    * A list containing all of the AST Expression nodes that were not resolved.
    */
   List<Expression> _unresolvedExpressions = new List<Expression>();
 
   /**
@@ skipping 113 matching lines @@
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
   }
 }
 /**
- * The class {@code StrictModeTest} contains tests to ensure that the correct errors and warnings
+ * The class `StrictModeTest` contains tests to ensure that the correct errors and warnings
  * are reported when the analysis engine is run in strict mode.
  */
 class StrictModeTest extends ResolverTestCase {
   void fail_for() {
     Source source = addSource(EngineTestCase.createSource(["int f(List<int> list) {", "  num sum = 0;", "  for (num i = 0; i < list.length; i++) {", "    sum += list[i];", "  }", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void setUp() {
     super.setUp();
@@ skipping 1059 matching lines @@
     resolve(source);
     assertErrors([StaticWarningCode.INCORRECT_NUMBER_OF_ARGUMENTS]);
     verify([source]);
   }
   void fail_invalidFactoryName() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.INVALID_FACTORY_NAME]);
     verify([source]);
   }
-  void fail_invalidOverrideDifferentDefaultValues() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([int p = 0]) {}", "}", "class B extends A {", "  m([int p = 1]) {}", "}"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES]);
-    verify([source]);
-  }
   void fail_invocationOfNonFunction() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.INVOCATION_OF_NON_FUNCTION]);
     verify([source]);
   }
   void fail_mismatchedAccessorTypes_getterAndSuperSetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int get g { return 0; }", "  set g(int v) {}", "}", "class B extends A {", "  set g(String v) {}", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
@@ skipping 477 matching lines @@
     resolve(source);
     assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_void() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int m() {}", "}", "class B extends A {", "  void m() {}", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
+  void test_invalidOverrideDifferentDefaultValues_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({int p : 0}) {}", "}", "class B extends A {", "  m({int p : 1}) {}", "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
+    verify([source]);
+  }
+  void test_invalidOverrideDifferentDefaultValues_positional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([int p = 0]) {}", "}", "class B extends A {", "  m([int p = 1]) {}", "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL]);
+    verify([source]);
+  }
   void test_invalidSetterOverrideNormalParamType() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void set s(int v) {}", "}", "class B extends A {", "  void set s(String v) {}", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
     verify([source]);
   }
   void test_mismatchedAccessorTypes_class() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int get g { return 0; }", "  set g(String v) {}", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
@@ skipping 21 matching lines @@
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A.name();", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A.name() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
+  void test_noDefaultSuperConstructorExplicit() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p);", "}", "class B extends A {", "  B() {}", "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
+    verify([source]);
+  }
+  void test_noDefaultSuperConstructorImplicit_superHasParameters() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p);", "}", "class B extends A {", "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    verify([source]);
+  }
+  void test_noDefaultSuperConstructorImplicit_superOnlyNamed() {
+    Source source = addSource(EngineTestCase.createSource(["class A { A.named() {} }", "class B extends A {}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    verify([source]);
+  }
   void test_nonAbstractClassInheritsAbstractMemberFivePlus() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "  p();", "  q();", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberFour() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "  p();", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
@@ skipping 34 matching lines @@
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  set s(int i);", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
+  void test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  get a => 'a';", "}", "abstract class B implements A {", "  get b => 'b';", "}", "class C extends B {", "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    verify([source]);
+  }
   void test_nonAbstractClassInheritsAbstractMemberThree() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberTwo() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
@@ skipping 446 matching lines @@
         runJUnitTest(__test, __test.test_invalidMethodOverrideReturnType_superclass);
       });
       _ut.test('test_invalidMethodOverrideReturnType_superclass2', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidMethodOverrideReturnType_superclass2);
       });
       _ut.test('test_invalidMethodOverrideReturnType_void', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidMethodOverrideReturnType_void);
       });
+      _ut.test('test_invalidOverrideDifferentDefaultValues_named', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_named);
+      });
+      _ut.test('test_invalidOverrideDifferentDefaultValues_positional', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional);
+      });
       _ut.test('test_invalidSetterOverrideNormalParamType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidSetterOverrideNormalParamType);
       });
       _ut.test('test_mismatchedAccessorTypes_class', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_class);
       });
       _ut.test('test_mismatchedAccessorTypes_topLevel', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_topLevel);
       });
       _ut.test('test_newWithAbstractClass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithAbstractClass);
       });
       _ut.test('test_newWithNonType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithNonType);
       });
       _ut.test('test_newWithUndefinedConstructor', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructor);
       });
       _ut.test('test_newWithUndefinedConstructorDefault', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
       });
+      _ut.test('test_noDefaultSuperConstructorExplicit', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_noDefaultSuperConstructorExplicit);
+      });
+      _ut.test('test_noDefaultSuperConstructorImplicit_superHasParameters', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superHasParameters);
+      });
+      _ut.test('test_noDefaultSuperConstructorImplicit_superOnlyNamed', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superOnlyNamed);
+      });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberFivePlus', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFivePlus);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberFour', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFour);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 16 matching lines @@
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass);
       });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface);
+      });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberThree', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberThree);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberTwo', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberTwo);
       });
       _ut.test('test_nonTypeInCatchClause_noElement', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 130 matching lines @@
         runJUnitTest(__test, __test.test_breakLabelOnSwitchMember);
       });
       _ut.test('test_continueLabelOnSwitch', () {
         final __test = new ErrorResolverTest();
         runJUnitTest(__test, __test.test_continueLabelOnSwitch);
       });
     });
   }
 }
 /**
- * Instances of the class {@code TestTypeProvider} implement a type provider that can be used by
+ * Instances of the class `TestTypeProvider` implement a type provider that can be used by
  * tests without creating the element model for the core library.
  */
 class TestTypeProvider implements TypeProvider {
 
   /**
    * The type representing the built-in type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
@@ skipping 100 matching lines @@
       initializeNumericTypes();
     }
     return _intType;
   }
   InterfaceType get iterableType {
     if (_iterableType == null) {
       ClassElementImpl iterableElement = ElementFactory.classElement2("Iterable", ["E"]);
       _iterableType = iterableElement.type;
       Type2 eType = iterableElement.typeVariables[0].type;
       iterableElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("iterator", false, iteratorType.substitute5(<Type2> [eType])), ElementFactory.getterElement("last", false, eType)];
+      propagateTypeArguments(iterableElement);
     }
     return _iterableType;
   }
   InterfaceType get iteratorType {
     if (_iteratorType == null) {
       ClassElementImpl iteratorElement = ElementFactory.classElement2("Iterator", ["E"]);
       _iteratorType = iteratorElement.type;
       Type2 eType = iteratorElement.typeVariables[0].type;
       iteratorElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("current", false, eType)];
+      propagateTypeArguments(iteratorElement);
     }
     return _iteratorType;
   }
   InterfaceType get listType {
     if (_listType == null) {
       ClassElementImpl listElement = ElementFactory.classElement2("List", ["E"]);
       listElement.constructors = <ConstructorElement> [ElementFactory.constructorElement(listElement, null)];
       _listType = listElement.type;
       Type2 eType = listElement.typeVariables[0].type;
       InterfaceType supertype = iterableType.substitute5(<Type2> [eType]);
       listElement.supertype = supertype;
       listElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
-      listElement.methods = <MethodElement> [ElementFactory.methodElement("[]", eType, [intType]), ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [intType, eType])];
+      listElement.methods = <MethodElement> [ElementFactory.methodElement("[]", eType, [intType]), ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [intType, eType]), ElementFactory.methodElement("add", VoidTypeImpl.instance, [eType])];
+      propagateTypeArguments(listElement);
     }
     return _listType;
   }
   InterfaceType get mapType {
     if (_mapType == null) {
       ClassElementImpl mapElement = ElementFactory.classElement2("Map", ["K", "V"]);
       _mapType = mapElement.type;
       mapElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
+      propagateTypeArguments(mapElement);
     }
     return _mapType;
   }
   InterfaceType get numType {
     if (_numType == null) {
       initializeNumericTypes();
     }
     return _numType;
   }
   InterfaceType get objectType {
@@ skipping 48 matching lines @@
     List<FieldElement> fields = <FieldElement> [ElementFactory.fieldElement("NAN", true, false, true, _doubleType), ElementFactory.fieldElement("INFINITY", true, false, true, _doubleType), ElementFactory.fieldElement("NEGATIVE_INFINITY", true, false, true, _doubleType), ElementFactory.fieldElement("MIN_POSITIVE", true, false, true, _doubleType), ElementFactory.fieldElement("MAX_FINITE", true, false, true, _doubleType)];
     doubleElement.fields = fields;
     int fieldCount = fields.length;
     List<PropertyAccessorElement> accessors = new List<PropertyAccessorElement>(fieldCount);
     for (int i = 0; i < fieldCount; i++) {
       accessors[i] = fields[i].getter;
     }
     doubleElement.accessors = accessors;
     doubleElement.methods = <MethodElement> [ElementFactory.methodElement("remainder", _doubleType, [_numType]), ElementFactory.methodElement("+", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, [_numType]), ElementFactory.methodElement("*", _doubleType, [_numType]), ElementFactory.methodElement("%", _doubleType, [_numType]), ElementFactory.methodElement("/", _doubleType, [_numType]), ElementFactory.methodElement("~/", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, []), ElementFactory.methodElement("abs", _doubleType, []), ElementFactory.methodElement("round", _doubleType, []), ElementFactory.methodElement("floor", _doubleType, []), ElementFactory.methodElement("ceil", _doubleType, []), ElementFactory.methodElement("truncate", _doubleType, []), ElementFactory.methodElement("toString", _stringType, [])];
   }
+
+  /**
+   * Given a class element representing a class with type parameters, propagate those type
+   * parameters to all of the accessors, methods and constructors defined for the class.
+   * @param classElement the element representing the class with type parameters
+   */
+  void propagateTypeArguments(ClassElementImpl classElement) {
+    List<Type2> typeArguments = TypeVariableTypeImpl.getTypes(classElement.typeVariables);
+    for (PropertyAccessorElement accessor in classElement.accessors) {
+      FunctionTypeImpl functionType = accessor.type as FunctionTypeImpl;
+      functionType.typeArguments = typeArguments;
+    }
+    for (MethodElement method in classElement.methods) {
+      FunctionTypeImpl functionType = method.type as FunctionTypeImpl;
+      functionType.typeArguments = typeArguments;
+    }
+    for (ConstructorElement constructor in classElement.constructors) {
+      FunctionTypeImpl functionType = constructor.type as FunctionTypeImpl;
+      functionType.typeArguments = typeArguments;
+    }
+  }
 }
 /**
- * The class {@code AnalysisContextFactory} defines utility methods used to create analysis contexts
+ * The class `AnalysisContextFactory` defines utility methods used to create analysis contexts
  * for testing purposes.
  */
 class AnalysisContextFactory {
 
   /**
    * Create an analysis context that has a fake core library already resolved.
    * @return the analysis context that was created
    */
   static AnalysisContextImpl contextWithCore() {
     AnalysisContextImpl sdkContext = DirectoryBasedDartSdk.defaultSdk.context as AnalysisContextImpl;
@@ skipping 152 matching lines @@
         runJUnitTest(__test, __test.test_getErrorListener);
       });
       _ut.test('test_prefixedAndNonPrefixed', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_prefixedAndNonPrefixed);
       });
     });
   }
 }
 /**
- * Instances of the class {@code ResolutionVerifier} verify that all of the nodes in an AST
+ * Instances of the class `ResolutionVerifier` verify that all of the nodes in an AST
  * structure that should have been resolved were resolved.
  */
 class ResolutionVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * A set containing nodes that are known to not be resolvable and should therefore not cause the
    * test to fail.
    */
   Set<ASTNode> _knownExceptions;
 
@@ skipping 540 matching lines @@
     indexExpression.staticElement = indexMethod;
     indexExpression.element = indexMethod;
     ASTFactory.assignmentExpression(indexExpression, TokenType.EQ, ASTFactory.integer(0));
     JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_named() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, constructorName);
+    constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
-    constructorType.returnType = classElement.type;
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), [ASTFactory.identifier3(constructorName)]);
     node.element = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_typeParameters() {
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement(elementC, null);
     elementC.constructors = <ConstructorElement> [constructor];
+    constructor.returnType = elementC.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
-    constructorType.returnType = elementC.type;
     constructor.type = constructorType;
     TypeName typeName = ASTFactory.typeName(elementC, [ASTFactory.typeName(elementI, [])]);
     typeName.type = elementC.type.substitute5(<Type2> [elementI.type]);
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, typeName, []);
     node.element = 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() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, null);
+    constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
-    constructorType.returnType = classElement.type;
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), []);
     node.element = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIntegerLiteral() {
     Expression node = resolvedInteger(42);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
@@ skipping 302 matching lines @@
    * @return an integer literal that has been resolved to the correct type
    */
   DoubleLiteral resolvedDouble(double value) {
     DoubleLiteral literal = ASTFactory.doubleLiteral(value);
     literal.staticType = _typeProvider.doubleType;
     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
+   * incomplete type associated with it (just like the one[ElementBuilder#visitFunctionExpression] 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 parameters2, FunctionBody body) {
     for (FormalParameter parameter in parameters2.parameters) {
       ParameterElementImpl element = new ParameterElementImpl(parameter.identifier);
       element.parameterKind = parameter.kind;
       element.type = _typeProvider.dynamicType;
@@ skipping 383 matching lines @@
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
   Scope_17(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
-   * The source factory used to create {@link Source sources}.
+   * The source factory used to create [Source sources].
    */
   SourceFactory _sourceFactory;
   void setUp() {
     _sourceFactory = new SourceFactory.con2([new FileUriResolver()]);
   }
   void test_accessorsAcrossFiles() {
     Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "part 'first.dart';", "part 'second.dart';"]));
     addSource("/first.dart", EngineTestCase.createSource(["part of lib;", "int get V => 0;"]));
     addSource("/second.dart", EngineTestCase.createSource(["part of lib;", "void set V(int v) {}"]));
     LibraryElement element = buildLibrary(librarySource, []);
@@ skipping 542 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_resolveAgainstNull() {
     Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_setter_inherited() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int get x => 0;", "  set x(int p) {}", "}", "class B extends A {", "  int get x => super.x == null ? 0 : super.x;", "  void f() => x = 1;", "}"]));
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int get x => 0;", "  set x(int p) {}", "}", "class B extends A {", "  int get x => super.x == null ? 0 : super.x;", "  int f() => x = 1;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_setter_static() {
     Source source = addSource(EngineTestCase.createSource(["set s(x) {", "}", "", "main() {", "  s = 123;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
 
   /**
    * Resolve the given source and verify that the arguments in a specific method invocation were
    * correctly resolved.
-   * <p>
+   *
    * The source is expected to be source for a compilation unit, the first declaration is expected
    * to be a class, the first member of which is expected to be a method with a block body, and the
    * first statement in the body is expected to be an expression statement whose expression is a
    * method invocation. It is the arguments to that method invocation that are tested. The method
    * invocation can contain errors.
-   * <p>
+   *
    * The arguments were resolved correctly if the number of expressions in the list matches the
    * length of the array of indices and if, for each index in the array of indices, the parameter to
    * which the argument expression was resolved is the parameter in the invoked method's list of
    * parameters at that index. Arguments that should not be resolved to a parameter because of an
    * error can be denoted by including a negative index in the array of indices.
    * @param source the source to be resolved
    * @param indices the array of indices used to associate arguments with parameters
    * @throws Exception if the source could not be resolved or if the structure of the source is not
    * valid
    */
@@ skipping 213 matching lines @@
 //  TypeOverrideManagerTest.dartSuite();
 //  TypeProviderImplTest.dartSuite();
 //  TypeResolverVisitorTest.dartSuite();
 //  EnclosedScopeTest.dartSuite();
 //  LibraryImportScopeTest.dartSuite();
 //  LibraryScopeTest.dartSuite();
 //  ScopeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
-//  PubSuggestionCodeTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }