Why do methods get called twice when used in a prop of an async component?

Below is a very simplified example of my actual use case, so I’m looking to understand what’s going on, rather than find a workaround.

If I use a method inside a prop of an async component, the method gets called twice. However, if the component is included normally the method runs once as expected. Sure, the end result is the same, but it seems inefficient - especially if several async components are loaded, like in my actual case.

Here’s a working version: https://codesandbox.io/s/eloquent-rain-2e8ex

You can see in the console that ‘getMsg called’ is logged twice.

  <div id="app">
    <HelloWorld :msg="getMsg()"/>

export default {
  name: "App",
  components: {
    HelloWorld: () => import("./components/HelloWorld")
  methods: {
    getMsg() {
      console.log("getMsg called");
      return "Hello Vue in CodeSandbox!";

I don’t know exactly, but I think that the logic is:
As you probably know template is compiled into render function and finally it looks like createElement('HelloWorld', {props: {msg:getMsg()}}) - 1st call. And the fact that ‘HelloWorld’ is not loaded yet doesn’t stop the render process (it is async component), so vue starts loading and returns nothing (or some plug) instead of component. After async component has been loaded vue invokes render loop again and since you use the method (not computed) it also gets (2nd) call at this render loop.

After async component has been loaded vue invokes render loop again

I wasn’t aware of this, thanks! It does make sense now that I take this into account. So am I right in saying the render loop will be invoked (at least) 5 times if there are 5 async components on the page, rather than be invoked once all components have loaded? What are the performance implications of this?

if they are nested components - I think there is no other way, if they are siblings, then in a theory vue can collects them and does promise.all, but I think it will be undesired behavior in most cases, because usually the render loop is many times faster than loading.