public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            var snapshot = _textBuffer.CurrentSnapshot;
            var triggerPoint = session.GetTriggerPoint(snapshot);
            if (!triggerPoint.HasValue) return;

            var triggerLine = triggerPoint.Value.GetContainingLine();
            var searchSpan = new SnapshotSpan(triggerLine.Start, triggerPoint.Value);

            var analysisResult = ThreadHelper.JoinableTaskFactory.Run(
                () => _documentAnalysis.GetAnalysisResultAsync(snapshot));

            var triggerBlock = analysisResult.GetBlock(searchSpan.Start);
            var triggerToken = triggerBlock.Tokens
                .Where(t => ContainsInclusive(searchSpan, t.Span))
                .OrderBy(t => t.Span.Start)
                .FirstOrDefault(t => t.Type == RadAsmTokenType.FunctionReference || t.Type == RadAsmTokenType.Instruction);

            if (triggerToken == null) return;

            var applicableSpan = new SnapshotSpan(triggerToken.Span.End, triggerLine.End);
            var trackingSpan = snapshot.CreateTrackingSpan(applicableSpan, SpanTrackingMode.EdgeInclusive);
            var parameterSpan = new SnapshotSpan(applicableSpan.Start, triggerPoint.Value);
            var parameterIdx = parameterSpan.GetCurrentParameter(_signatureConfig.TriggerParameterChar);

            switch (triggerToken.Type)
            {
                case RadAsmTokenType.FunctionReference:
                    AddFunctionSignature(trackingSpan, triggerToken, parameterIdx, signatures); 
                    break;
                case RadAsmTokenType.Instruction:
                    AddInstructionSignature(snapshot, trackingSpan, triggerToken, parameterIdx, signatures);
                    break;
            }
        }
        private void ChangeParameterSignatureSession()
        {
            if (_currentSignatureSession == null)
            {
                return;
            }
            if (_currentSignatureSession.Signatures.Count == 0)
            {
                return;
            }

            // all signatures have the same applicable span
            var trackingSpan    = _currentSignatureSession.Signatures[0].ApplicableToSpan;
            var currentPosition = _textView.Caret.Position.BufferPosition;
            var trackingStart   = trackingSpan.GetStartPoint(currentPosition.Snapshot);

            // check left border of applicable span, it might be invalid token
            if (trackingStart == currentPosition)
            {
                _currentSignatureSession.Recalculate();
                // if there is no applicable token, then current signatureSession will be null
                if (_currentSignatureSession == null)
                {
                    return;
                }
            }

            var searchParam  = new SnapshotSpan(trackingStart, currentPosition);
            var currentParam = searchParam.GetCurrentParameter(_signatureConfig.TriggerParameterChar);

            foreach (var signature in _currentSignatureSession.Signatures)
            {
                if (signature is ISyntaxSignature syntaxSignature)
                {
                    syntaxSignature.SetCurrentParameter(currentParam);
                }
            }
        }