C++: Fix some FPs in cpp/missing-check-scanf (third attempt!)

[MathiasVP]

This PR brings back the changes from #17938 and fixes the performance by inlining the ensures (and to some degree the compares) predicates which became too large after the improvements.

Commit-by-commit review recommended:

• 20dfbdc reverts the revert
• 6f73aa5 does a small refactoring which I've been meaning to do for a while now that we can use abstract classes in user-facing classes by using final extensions.
• 404dd33 and 3bdfdd0 do the actual performance fix: we inline the ensures predicates, and move the cacheing to the implementation predicates. This should that we don't get expensive recomputations and that the user-facing predicates are never materialized.

As an extra bonus, the inlining makes the performance fix added in 19d53fb unnecessary 🎉

After several rounds of join order fixes QA looks good 🎉 (0.55% analysis time difference). You can find the QA run in the backlink if you're curious.

[MathiasVP]

Fixed in 913357b

[MathiasVP]

Fixed in 913357b

[jketema]

Why was this removed?

[MathiasVP]

Before the introduction of final aliases this class couldn't be made abstract (since it would expose a abstract class from our libraries to queries). So instead of having this class be abstract we followed the pattern of:

1. Specifying each subclass of this "pseudo-abstract" class in the charpred
2. Provide a subclass that extended this "pseudo-abstract" class and repeated the required charpred to define the subclass.

That is, we've had to do:

class Base {
  Base() {
     myImpl1(this) or myImpl2(this)
  }
}

class MyImpl1 extends Base {
  MyImpl1() {
    myImpl1(this)
  }
}

class MyImpl2 extends Base {
  MyImpl2() {
    myImpl1(this)
  }
}

Now that we have final classes we can get rid of this pattern (as we've done many other places) and actually use abstract classes. And abstract classes don't need this charpred since they're defined as the union of all the subclasses.

That is, we can rewrite the above example to:

private abstract class BaseImpl { } // <--- Note: We can now remove the charpred and only have it in the subclasses

final class Base = BaseImpl;

class MyImpl1 extends BaseImpl {
  MyImpl1() {
    myImpl1(this)
  }
}

class MyImpl2 extends BaseImpl {
  MyImpl2() {
    myImpl1(this)
  }
}

Does that make sense?

[jketema]

Makes total sense.

[jketema]

Additional changes after the revert-revert make sense.

[MathiasVP]

Thanks a lot, Jeroen! DCA results are in and shows nothing of interest 🎉