Warn when implicit default value overrides explicit one that differs.

pkg/analyzer/test/generated/static_warning_code_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.static_warning_code_test;
 
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:unittest/unittest.dart';
@@ skipping 1691 matching lines @@
   int m() { return 0; }
 }
 class B extends A {
   void m() {}
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
 
+  void test_invalidOverride_defaultOverridesNonDefault() {
+    // If the base class provided an explicit value for a default parameter,
+    // then it is a static warning for the derived class to provide a different
+    // value, even if implicitly.
+    Source source = addSource(r'''
+class A {
+  foo([x = 1]) {}
+}
+class B extends A {
+  foo([x]) {}
+}
+''');
+    resolve(source);
+    assertErrors(source, [
+        StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL]);
+    verify([source]);
+  }
+
+  void test_invalidOverride_defaultOverridesNonDefault_named() {
+    // If the base class provided an explicit value for a default parameter,
+    // then it is a static warning for the derived class to provide a different
+    // value, even if implicitly.
+    Source source = addSource(r'''
+class A {
+  foo({x: 1}) {}
+}
+class B extends A {
+  foo({x}) {}
+}
+''');
+    resolve(source);
+    assertErrors(source, [
+        StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
+    verify([source]);
+  }
+
+  void test_invalidOverride_defaultOverridesNonDefaultNull() {

[Brian Wilkerson, 2014/11/04 18:46:42]

I'm not sure whether we want to continue, but the current convention is for
tests of errors and warnings that ensure that no error is produced when it
shouldn't be are all in the class NonErrorResolverTest.

+    // If the base class provided an explicit null value for a default
+    // parameter, then it is ok for the derived class to let the default value
+    // be implicit, because the implicit default value of null matches the
+    // explicit default value of null.
+    Source source = addSource(r'''
+class A {
+  foo([x = null]) {}
+}
+class B extends A {
+  foo([x]) {}
+}
+''');
+    resolve(source);
+    assertNoErrors(source);

[scheglov, 2014/11/04 18:43:20]

Test cases without errors should be added to NonErrorResolverTest.

+    verify([source]);
+  }
+
+  void test_invalidOverride_defaultOverridesNonDefaultNull_named() {
+    // If the base class provided an explicit null value for a default
+    // parameter, then it is ok for the derived class to let the default value
+    // be implicit, because the implicit default value of null matches the
+    // explicit default value of null.
+    Source source = addSource(r'''
+class A {
+  foo({x: null}) {}
+}
+class B extends A {
+  foo({x}) {}
+}
+''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_invalidOverride_nonDefaultOverridesDefault() {
+    // If the base class lets the default parameter be implicit, then it is ok
+    // for the derived class to provide an explicit default value, even if it's
+    // not null.
+    Source source = addSource(r'''
+class A {
+  foo([x]) {}
+}
+class B extends A {
+  foo([x = 1]) {}
+}
+''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_invalidOverride_nonDefaultOverridesDefault_named() {
+    // If the base class lets the default parameter be implicit, then it is ok
+    // for the derived class to provide an explicit default value, even if it's
+    // not null.
+    Source source = addSource(r'''
+class A {
+  foo({x}) {}
+}
+class B extends A {
+  foo({x: 1}) {}
+}
+''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_invalidOverrideDifferentDefaultValues_named() {
     Source source = addSource(r'''
 class A {
   m({int p : 0}) {}
 }
 class B extends A {
   m({int p : 1}) {}
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
@@ skipping 1415 matching lines @@
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
   }
 }
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(StaticWarningCodeTest);
 }