Does lambda in Kotlin always hold reference to the object where it was created?

I have a question about kotlin lambdas and implicit references to this. Lets look at this code:

class MyViewModel: ViewModel {
    val eventFlow = mutableSharedFlow<Unit>()
}

class MyFragment: Fragment() {
    val viewModel = MyViewModel()

    val lambda_1: (Unit) -> Unit = { Log.v("TAG", "Event happened") }
    val lambda_2: (Unit) -> Unit = { processEvent() }

    fun processEvent() {
        //do smth
    }
    
    override fun onCreate(bundle: Bundle?) {
        lifecycleScope.launchWhenStarted {
            viewModel.eventFlow.collect(lambda_1)
        }
        lifecycleScope.launchWhenStarted {
            viewModel.eventFlow.collect(lambda_2)
        }
    }
}

Please tell me if I'm correct or not:

1. lambda_1 does NOT call any methods or variables of MyFragment, so it does NOT hold reference to MyFragment object.
2. lambda_2 DOES call a method from MyFragment, so it DOES hold a reference to MyFrgament object.
3. If 2nd is correct, then when using such a lambda, we violate one of the points of MVVM ("ViewModel must not have reference to View"), because there is a reference chain viewModel -> eventFlow -> lambda_2 -> MyFragment.

Tried to read byte code but couldn't figure out answers from it.

1. Yes, this is correct. lambda_1 doesn't need a reference to MyFragment, so it doesn't keep one. As a matter of fact, because the lambda_1 could be entirely static, the Kotlin compiler creates a singleton and reuses the same instance for all instances of MyFragment.

2. This is also correct. lambda_2 needs a reference to MyFragment, so it keeps one. In this specific case it works in a similar way to an inner class, so when MyFragment instantiates the lambda, it passes a reference to itself through a constructor. In general it is different as lambda holds references to any object it needs, no matter if it is the "outer" class or not.

3. To be honest, I'm not very familiar with MVVM, but I assume its restrictions are the same as with general good practices.

a). If your concern is around the application architecture and separation of concerns, so lower layer should not call the higher layer, then this case doesn't violate this rule. View only registers an event in viewmodel, but viewmodel still doesn't reference views directly and doesn't know them.

b). If your concern is that the instance of MyFragment is leaked, it can't be garbage collected, then this is not a problem in this specific case. MyFragment uses lifecycleScope when collecting the flow. When the fragment is destroyed, its lifecycleScope cancels all launched coroutines, flow collector is also cancelled, and as a result the lambda is not needed anymore and can be garbage collected.