| Weird legacy stuff in test cases | |
| ================================ | |
| Due to historical reasons, test cases contain things that may appear | |
| baffling without extra context. This file attempts to describe most of | |
| them. | |
| Dummy if statements to prevent redefinition | |
| ------------------------------------------- | |
| Many test cases use if statements to prevent an assignment from creating | |
| a new variable. This in anticipation of allowing assignments to redefine | |
| variables by default. Conditional assignments will continue to refine | |
| a previously defined variable instead of defining a new one. When the | |
| test cases were written, we didn't anticipate that variables could be | |
| allowed to be redefined, and adding if statements was the easiest way | |
| to migrate these tests. | |
| Example: | |
| ``` | |
| x = 0 | |
| if int(): | |
| x = '' # Always generates an error since this is not a redefinition | |
| y = 0 | |
| y = '' # This could be valid if a new 'y' is defined here | |
| ``` | |
| Note that some of the checks may turn out to be redundant, as the | |
| exact rules for what constitutes a redefinition are still up for | |
| debate. This is okay since the extra if statements generally don't | |
| otherwise affect semantics. | |
| There are a few ways this is used, depending on the context: | |
| * `if int():` is the most common one. Assignments in the if body won't | |
| redefine variables defined before the if statement. | |
| * `if 1:` is used if the body of the if statement returns a value, and | |
| mypy would complain about a missing return statement otherwise. This | |
| works since `if 1:` is treated as an always taken condition, whereas | |
| `if int():` is not recognized as such. | |
| * `if str():` is used if the builtins fixture doesn't define `int` for | |
| some reason. | |
| Function definition to prevent redefinition | |
| ------------------------------------------- | |
| Sometimes test cases assume that a variable is not redefined, and we | |
| insert a dummy function definition to prevent this, since variables won't | |
| be able to be redefined across a function definition. Example: | |
| ``` | |
| x = 0 | |
| def f(): pass | |
| x = '' # Does not redefine x because of the definition of f() above | |
| ``` | |
| Dummy variable reference to allow redefinition | |
| ---------------------------------------------- | |
| The plan is to only allow a variable to be redefined if the value has | |
| been accessed. This wouldn't count as redefinition, since `x` is never | |
| read: | |
| ``` | |
| x = 0 | |
| x = '' # Not a redefinition | |
| ``` | |
| Sometimes we add a dummy variable access to allow redefinition in the | |
| future, or to trigger the redefinition machinery even if redefinition | |
| should not be okay: | |
| ``` | |
| x = 0 | |
| x | |
| x = '' # Could be a redefinition | |
| ``` | |
| The reason for this special case is type comments with dummy | |
| initializers, where the second assignment should never be treated | |
| as a redefinition: | |
| ``` | |
| x = None # type: int | |
| x = '' # Should not redefine x, since it has only been declared | |
| ``` | |
| Similarly, if there is only a variable annotation, the first | |
| assignment won't redefine the variable, as this would override | |
| the declared type: | |
| ``` | |
| x: int | |
| x = '' # Should not redefine x | |
| ``` |