(this is a contrived example, but in complex programs similar constructions can easily occur).
Really? I don't think I've ever seen something like that happening in real-world code. A function shouldn't be trying to modify a direct reference to a variable it's receiving as a parameter. (Or, depending on how you look at it, a user shouldn't go passing something as a parameter to a method that the method already has a direct reference to.) Where have you seen something like that happen?
In the FPC compiler itself, albeit with a global variable that's (sometimes) passed as var-parameter to a function that also directly uses this global variable. The principle is the same though.
I agree that in general this is bad practice, but with OOP it can easily happen in case
a) a method may be used to operate on different fields (so instead of writing one version of the method per field, or hardcoding the different fields in the method and passing some selector parameter to the method to indicate on which field it should operate, you pass the field it should operate on by var-parameter)
b) this method calls other methods that work directly with the various fields (i.e., those other methods don't get the field passed by var-parameter)
It certainly is possible to rewrite such code (e.g., by changing the interface of the secondary methods to also take their input via var-parameters), and that may even be the right thing to do, but the original code is still valid Pascal with behaviour that's fully defined.
Recent
