InternalPhasedActionConnection connection = (InternalPhasedActionConnection) getDelegate();
        PhasedActionResultListener listener = new DefaultPhasedActionResultListener(getHandler(phasedBuildAction.getProjectsLoadedAction()),
            getHandler(phasedBuildAction.getBuildFinishedAction()));
        InternalPhasedAction internalPhasedAction = getPhasedAction(phasedBuildAction, operationParameters.getProjectDir(), getVersionDetails());

        val element = elements.firstOrNull() ?: return BindingContext.EMPTY
        return getHandler(element).resolveSession.orThrowResolutionNotPerformedError().bindingContext
    }

    override fun getOrigin(file: VirtualFile): KaSymbolOrigin {
        return KaSymbolOrigin.SOURCE
    }

    private fun getHandler(useSiteElement: KtElement): KaFe10AnalysisHandlerExtension {
        val project = useSiteElement.project

        executer.phasedBuildAction.getProjectsLoadedAction().getHandler() == projectsLoadedHandler
        executer.phasedBuildAction.getBuildFinishedAction().getAction() == buildFinishedAction
        executer.phasedBuildAction.getBuildFinishedAction().getHandler() == buildFinishedHandler
    }

    def "exception when multiple actions per phase"() {
        when:

                getAction() >> projectsLoadedAction
                getHandler() >> projectsLoadedHandler
            }
            getBuildFinishedAction() >> Stub(PhasedBuildAction.BuildActionWrapper) {
                getAction() >> buildFinishedAction
                getHandler() >> buildFinishedHandler
            }
        }
        def parameters = Stub(ConsumerOperationParameters)

        }

        @Override
        public BuildAction<T> getAction() {
            return buildAction;
        }

        @Override
        public IntermediateResultHandler<? super T> getHandler() {
            return resultHandler;
        }
    }

    @Nullable
    BuildActionWrapper<?> getBuildFinishedAction();

    interface BuildActionWrapper<T> {

        BuildAction<T> getAction();

        IntermediateResultHandler<? super T> getHandler();
    }

		w.Write(responseBody)
		return
	})

	mux := http.NewServeMux()
	mux.Handle(urlGet, WithProbabilisticGoaway(getHandler, 0))
	mux.Handle(urlPost, WithProbabilisticGoaway(postHandler, 0))
	mux.Handle(urlWatch, WithProbabilisticGoaway(watchHandler, 0))
	mux.Handle(urlGetWithGoaway, WithProbabilisticGoaway(getHandler, 1))
	mux.Handle(urlPostWithGoaway, WithProbabilisticGoaway(postHandler, 1))

        handlers
    }

    void reset() {
        realm = null
        securityHandler?.stop()
        securityHandler = null
        handlers.stop()
        delegate = handlers
        handlers.setHandlers(new Handler[0])
        handlers.start()
    }

    @Override
    void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {

    }

    public void setDeployPath(String deployPath) {
        this.deployPath = deployPath;
    }

    public String getHandle() {
        return handle;
    }

    public void setHandle(String handle) {
        this.handle = handle;
    }

    @Override
    public void appendNode(Node parentNode) {
        Map<String, Object> attributes = new LinkedHashMap<>();

	case *hx != nil:
		// Only type parameter x has an inferred type. Use handle of x.
		u.setHandle(y, hx)
	// This case is treated like the default case.
	// case *hy != nil:
	// 	// Only type parameter y has an inferred type. Use handle of y.
	//	u.setHandle(x, hy)
	default:
		// Neither type parameter has an inferred type. Use handle of y.
		u.setHandle(x, hy)
	}
	return true
}