co19/LanguageFeatures/Super-parameters/type_inference_A05_t03

[scheglov]

FAILED: dart2analyzer-none release_x64 co19/LanguageFeatures/Super-parameters/type_inference_A05_t03
Expected: Pass
Actual: CompileTimeError

--- Command "dart2analyzer" (took 41ms):
DART_CONFIGURATION=ReleaseX64 sdk/bin/dartanalyzer --enable-experiment=super-parameters --ignore-unrecognized-flags --packages=/Users/scheglov/Source/Dart/sdk.git/sdk/.packages --format=json --no-hints /Users/scheglov/Source/Dart/sdk.git/sdk/tests/co19/src/LanguageFeatures/Super-parameters/type_inference_A05_t03.dart

unexpected analysis errors in type_inference_A05_t03.dart:
- Line 31, column 25: COMPILE_TIME_ERROR.SUPER_FORMAL_PARAMETER_TYPE_IS_NOT_SUBTYPE_OF_ASSOCIATED
  The type 'num' of this parameter is not a subtype of the type 'int' of the associated super-constructor parameter.

- Line 31, column 33: COMPILE_TIME_ERROR.MISSING_DEFAULT_VALUE_FOR_PARAMETER
  The parameter 'x' can't have a value of 'null' because of its type, but the implicit default value is 'null'.

- Line 31, column 46: COMPILE_TIME_ERROR.SUPER_FORMAL_PARAMETER_TYPE_IS_NOT_SUBTYPE_OF_ASSOCIATED
  The type 'num' of this parameter is not a subtype of the type 'int' of the associated super-constructor parameter.

unexpected analysis errors in ../../Utils/expect_common.dart:
- Line 291, column 11: TODO.TODO
  TODO check that key sets are equivalent. Following method does not work:

--- Re-run this test:
python3 tools/test.py -m release -c dart2analyzer co19/LanguageFeatures/Super-parameters/type_inference_A05_t03

[eernstg]

Presumably, this one should test that when the default value (1) of the parameter s1 of the S constructor has a type which is a subtype of the declared type of the super parameter s1 of the C constructor, then the super parameter will implicitly get that default value.

But the declared type of the super parameter is num, so that's an error, and we never get around to test the treatment of the default values.

Similarly for s2.

[sgrekhov]

@eernstg I did a change but now I'm in doubt. Let's go back to the initial test.

class S {
  int s1;
  S([this.s1 = 1]);
}

class C extends S {
  C([num super.s1]);
}

According to the spec

We also copy the default value of the associated super-constructor if applicable:

If p is optional, does not declare a default value, the associated super-constructor parameter is also optional and has a default value d, and d is a subtype of the (declared or inferred above) type of p, then p gets the default value d.

Here p ([num super.s1]) is optional, doesn't declare default value, the associated super-constructor parameter is also optional and has a defaulf value 1 and 1 is a subtype of the type p (num). Why the default value is not copied from the super-constructor and why there is an error here?

[eernstg]

The error arises because it's an error to have a super parameter of type num which is associated with a parameter in the superconstructor whose type is int (because this is similar to int x = anExpressionOfTypeNum;). So the error is there just because of the parameter types, and we don't even get to the point where the properties of the default value are checked.

If you want to have a non-trivial subtype relationship you can use the following:

class A { const A(); }
class B extends A { const B(); }
class B2 extends A { const B2(); }

class S {
  A s1;
  S([this.s1 = const B()]);
}

class C extends S {
  C([B super.s1]); // But `C([B2 super.s1])` would be an error.
}

In this case we have a default value in the S constructor which is a proper subtype B of the declared parameter type A, and in the B constructor the super parameter gets the default value const B() because it is an expression whose type is a subtype of the declared type of the super parameter. (In other words, the default value from the superconstructor "works", so we'll use it.) If the parameter type had been B2 then we would have an error (because that parameter must have a default type, and the one we can get from the superconstructor does not work).