Fix Incompatible return value type error message for long tuple with Union and non-Union type mismatch

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!

[Luunynliny]

With the following setup :

classA:
a: str|Noneb: str|Nonec: str|Noned: str|Nonee: str|Nonef: str|Noneg: str|Noneh: str|Nonei: str|Nonej: str|Nonek: str|Nonel: str|None@propertydefx(
self,
) ->tuple[
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
str,
]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

mypy outputs this error (you can visualize it in this playground):

mypy_error.py:33: error: Incompatible return value type (0 tuple items are incompatible) [return-value]
Found 1 errors in 1 file (checked 1 source file)

when the expected error should be :

mypy_error.py:33: error: Incompatible return value type (12 tuple items are incompatible; 9 items are omitted) [return-value]
mypy_error.py:33: note: Expression tuple item 0 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 1 has type"str | None";"str" expected; mypy_error.py:33: note: Expression tuple item 2 has type"str | None";"str" expected; Found 1 error in 1 file (checked 1 source file)

Found it is due to the generate_incompatible_tuple_error function from the MessageBuilder class, not checking Union and non-Union mismatch type.

So, I added another condition to increment the error count by ensuring that both type are not the same, instead of just verifying if they are subtype related.

not is_subtype(str | None, str) --> False --> Does not increment error count
not is_same_type(str | None, str) --> True --> Increment error count

I also wrote a new unit test for this case in check-classes.test in the Propertysection.
As it is my first contribution, I'm not sure regarding the location nor the naming of this test, so feel free to suggest a better approach.

[sterliakov]

Please add a testcase with the opposite direction (annotated with tuple of unions, returns tuple of props)

[Luunynliny]

@sterliakov Just to make sure I understand, you would like me to test this configuration ?
Or something else ?

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], Union[str, None], Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

[sterliakov]

I'd love to see a test where the expected return type is wider than the actual return type, but the changed method is still triggered. In your example all items are assignable, so that method won't fire. Something like

classA:
a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: str@propertydefx(self) ->Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
return (
self.a,
self.b,
self.c,
self.d,
self.e,
self.f,
self.g,
self.h,
self.i,
self.j,
self.k,
self.l,
)

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is). And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

a: strb: strc: strd: stre: strf: strg: strh: stri: strj: strk: strl: strx: Tuple[
Union[str, int], Union[str, float], int, Union[str, None], Union[str, None],
Union[str, None], str, str, str, str, str, str,
] = (
a, b, c, d, e,
f, g, h, i, j,
k, l,
)

[sterliakov]

And a nit: please move this to check-tuples.test as the long tuple is the problem here, not the surrounding class.

[Luunynliny]

Thanks for the clarification and the provided example.

I adjusted the third union item to not be assignable, so that the comparator should be triggered (please check that it actually is).

It indeed triggers to relevant error. I also a Union to modified code works as expected.

And why is x a property, won't a simpler test without class do (and same question about the test you already added)?

Beside beging the configuration where I first encountered the error message issue, your suggestion triggers an Incompatible types in assignment (which works correctly) instead of a Incompatible return value type.

[sterliakov]

Looks good! Left a couple of style/scope comments on the testcases, the fix itself looks reasonable. I don't have write rights here, so you'll have to wait for someone else to approve&merge.

[hauntsaninja]

Thanks for the fix! I agree with sterliakov's nit that the test belongs better in check-tuples.test (but tests themselves are fine as is, just should be moved to different file)

[github-actions]

According to mypy_primer, this change doesn't affect type check results on a corpus of open source code. ✅

[hauntsaninja]

Thank you!!