private final String callableName;
        private final String callerClassName;
        private final CallKind kind;
        private boolean isMatchedAtDispatchSite = false;

        public EntryPointCallSiteImpl(String callableName, String callerClassName, CallKind kind) {
            this.callableName = callableName;
            this.callerClassName = callerClassName;

    public String findCallerForCurrentCallIfNotIntercepted(String callableName, CallKind kind) {
        return perThreadImplementation.get().findCallerForCurrentCallIfNotIntercepted(callableName, kind);
    }

    @Override
    public void markCurrentCallAsIntercepted(String callableName, CallKind kind) {
        perThreadImplementation.get().markCurrentCallAsIntercepted(callableName, kind);
    }

    private final String callableName;
    private final CallableReturnTypeInfo returnType;
    private final List<ParameterInfo> parameters;

    public CallableInfoImpl(CallableKindInfo kind, CallableOwnerInfo owner, String callableName, CallableReturnTypeInfo returnType, List<ParameterInfo> parameters) {
        this.kind = kind;
        this.owner = owner;
        this.callableName = callableName;

     * call described by the {@code callableName} and {@code kind}
     * from a class identified by {@code consumerClass}.
     * After running the callable, ensures that the entry point leaves the context and returns the callable's result.
     */

                .getCallableSymbols(callableId.callableName).toList()

            if (declaredSymbols.isNotEmpty()) {
                return declaredSymbols
            }

            // Fake overrides are absent in the declared member scope
            return classSymbol.getCombinedMemberScope()
                .getCallableSymbols(callableId.callableName)
                .filter { it.getContainingSymbol() == classSymbol }

     * @return an entry point call site token that must later be passed to {@link InstrumentedGroovyCallsTracker#leaveCall}
     */
    EntryPointCallSite enterCall(String callerClassName, String callableName, CallKind callKind);

    /**
     * Unregisters the instrumented call site. The entry point must be the instance returned from the {@link InstrumentedGroovyCallsTracker#enterCall}

                    .map { functionProto -> nameResolver.getName(functionProto.name) }

                val callableNames = (propertyNames + functionNames).distinct()
                callableNames.forEach { callableName ->
                    getTopLevelCallableSymbols(packageFqName, callableName).forEach { symbol ->

        matchAndInterceptStandardCallableSignature(request, implTypeField, code, callableName, interceptedCallableDescriptor, matchOpcodeExpression);

        if (interceptedCallable.getParameters().stream().anyMatch(it -> it.getKind() == ParameterKindInfo.KOTLIN_DEFAULT_MASK)) {
            matchAndInterceptKotlinDefaultSignature(request, implTypeField, code, callableName, interceptedCallable, matchOpcodeExpression);
        }
    }

    public static void addInvocationHooksToMetaClassIfInstrumented(Class<?> javaClass, String callableName) {
        // In BeanDynamicObject we can't filter interceptors, so we have to apply all interceptors
        CallInterceptorResolver resolver = ClosureCallInterceptorResolver.of(ALL);
        if (resolver.isAwareOfCallSiteName(callableName)) {
            addInvocationHooksToMetaClass(javaClass, resolver);
        }
    }

    abstract val resolvedClassId: ClassId?
}

internal class NonStarImport(
    override val packageFqName: FqName,
    override val relativeClassName: FqName?,
    override val resolvedClassId: ClassId?,
    val callableName: Name?,
    val aliasName: Name?,
) : Import()

internal class StarImport(
    override val packageFqName: FqName,
    override val relativeClassName: FqName?,
    override val resolvedClassId: ClassId?,