Improve inlining of getters

[ironcev]

Using getters like vec.len() and calling them several times instead of once and storing the value in a temporary, is a very common and expected practice. The intuitive expectation is that getters will be properly inlined and that the resulting code will not have any overhead.

Moreover, in the std getters are heavily used in module implementations, although the values they are getting can be used directly. This is also an expected practice that encourages encapsulation, and is based on the same assumption, that calling getters will not produce any overhead.

Currently, this expectation does not hold. Getters, when used in common usage patterns, do not get optimized away, and the resulting code be significantly less performant.

Lets take a look at two common patterns, often seen in using, e.g., vec.len(). If we have the following struct:

struct S {
    val: u8,
}

impl S {
    fn val(self) -> u8 {
        self.val
    }
}

Passing self.val() + self.val() to a function will result in 160 bytes.
Passing self.val + self.val to a function will result in 72 bytes.
Moreover, in the second example, if we let temp = self.val; and then pass temp + temp we will again get a smaller result, 64 bytes.

Calling self.val() == other.val() will result in 120 bytes.
Calling self.val == other.val will result in 16 bytes.

The numbers, of course, depend on datatypes and usage patterns, but this examples already shows a huge improvement potential.