示例#1
0
        public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures, AstRoot ast, Action <object> triggerSession)
        {
            ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
            int           position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);

            // Retrieve parameter positions from the current text buffer snapshot
            ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position);

            if (parametersInfo != null)
            {
                position = Math.Min(parametersInfo.SignatureEnd, position);
                int start = Math.Min(position, snapshot.Length);
                int end   = Math.Min(parametersInfo.SignatureEnd, snapshot.Length);

                ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive);

                // Get collection of function signatures from documentation (parsed RD file)
                IFunctionInfo functionInfo = FunctionIndex.GetFunctionInfo(parametersInfo.FunctionName, triggerSession, session.TextView);
                if (functionInfo != null && functionInfo.Signatures != null)
                {
                    foreach (ISignatureInfo signatureInfo in functionInfo.Signatures)
                    {
                        ISignature signature = CreateSignature(session, functionInfo, signatureInfo, applicableToSpan, ast, position);
                        signatures.Add(signature);
                    }

                    session.Properties["functionInfo"] = functionInfo;
                    return(true);
                }
            }

            return(false);
        }
        public async System.Threading.Tasks.Task CollectSignatureLists(ISignatureHelpSession newSession)
        {
            JavaEditor javaEditor = null;
            if (TextBuffer.Properties.TryGetProperty<JavaEditor>(typeof(JavaEditor), out javaEditor) &&
                javaEditor.TypeRootIdentifier != null)
            {
                var textReader = new TextSnapshotToTextReader(TextBuffer.CurrentSnapshot) as TextReader;
                var position = newSession.GetTriggerPoint(TextBuffer).GetPosition(TextBuffer.CurrentSnapshot);
                var paramHelpRequest = ProtocolHandlers.CreateParamHelpRequest(
                    textReader,
                    javaEditor.TypeRootIdentifier,
                    position);
                var paramHelpResponse = await javaEditor.JavaPkgServer.Send(javaEditor, paramHelpRequest);

                if (paramHelpResponse.responseType == Protocol.Response.ResponseType.ParamHelp &&
                    paramHelpResponse.paramHelpResponse != null)
                {
                    if (paramHelpResponse.paramHelpResponse.status && paramHelpResponse.paramHelpResponse.signatures.Count != 0)
                    {
                        var applicableTo = TextBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(paramHelpResponse.paramHelpResponse.scopeStart, paramHelpResponse.paramHelpResponse.scopeLength), SpanTrackingMode.EdgeInclusive, 0);
                        int selectedParameterIndex = paramHelpResponse.paramHelpResponse.paramCount;
                        Signatures = TransformSignatures(TextBuffer, paramHelpResponse.paramHelpResponse.signatures, applicableTo, selectedParameterIndex); 
                    }
                }
            }
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            SnapshotPoint? point = session.GetTriggerPoint(_buffer.CurrentSnapshot);
            if (!point.HasValue)
                return;

            CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
            ParseItem item = document.StyleSheet.ItemBeforePosition(point.Value.Position);

            if (item == null)
                return;

            Declaration dec = item.FindType<Declaration>();
            if (dec == null || dec.PropertyName == null || dec.Colon == null)
                return;

            var span = _buffer.CurrentSnapshot.CreateTrackingSpan(dec.Colon.Start, dec.Length - dec.PropertyName.Length, SpanTrackingMode.EdgeNegative);

            ValueOrderFactory.AddSignatures method = ValueOrderFactory.GetMethod(dec);

            if (method != null)
            {
                signatures.Clear();
                method(session, signatures, dec, span);

                Dispatcher.CurrentDispatcher.BeginInvoke(
                    new Action(() => {
                        session.Properties.AddProperty("dec", dec);
                        session.Match();
                    }),
                    DispatcherPriority.Normal, null);
            }
        }
示例#4
0
        public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures, AstRoot ast,
                                                Action <ITextView, IEnumerable <IRFunctionSignatureHelp> > callback)
        {
            // Try cached if this was a re-trigger on async information retrieval
            var eis = new EditorIntellisenseSession(session, _services);

            if (GetCachedSignatures(signatures, eis))
            {
                return(true);
            }

            var editorBuffer = _textBuffer.ToEditorBuffer();
            var position     = session.GetTriggerPoint(_textBuffer).GetCurrentPosition();
            var context      = new RIntellisenseContext(eis, editorBuffer, ast, position);

            // See if information is immediately available
            var sigs = _engine.GetSignaturesAsync(context, null);

            if (sigs != null)
            {
                AddSignatures(signatures, ToVsEditorSignatures(sigs));
                return(true);
            }

            // If not available, start async retrieval. Session wil be re-triggered
            // when information becomes available.
            _engine.GetSignaturesAsync(context, s => callback(session.TextView, s));
            return(false);
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            if (!session.TextView.Properties.ContainsProperty(SessionKey))
            {
                return;
            }

            // Map the trigger point down to our buffer.
            var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);
            if (!subjectTriggerPoint.HasValue)
            {
                return;
            }

            var currentSnapshot = subjectTriggerPoint.Value.Snapshot;
            var querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
            var applicableToSpan = currentSnapshot.CreateTrackingSpan(
                querySpan.Start.Position,
                0,
                SpanTrackingMode.EdgeInclusive);

            string encouragement = encouragements.GetRandomEncouragement();
            var signature = new Signature(applicableToSpan, encouragement, "", "");
            signatures.Add(signature);
        }
        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;
            }
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            SnapshotPoint? point = session.GetTriggerPoint(_buffer.CurrentSnapshot);
            if (!point.HasValue)
                return;

            CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
            ParseItem item = document.StyleSheet.ItemBeforePosition(point.Value.Position);

            if (item == null)
                return;

            Declaration dec = item.FindType<Declaration>();
            if (dec == null || dec.PropertyName == null || dec.Colon == null)
                return;

            foreach (ISignature signature in signatures)
            {
                if (signature is ValueOrderSignature)
                {
                    signatures.RemoveAt(signatures.Count - 1);
                    break;
                }
            }
        }
示例#8
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            try {
                var snapshot         = _buffer.CurrentSnapshot;
                var trackingPoint    = session.GetTriggerPoint(_buffer);
                var position         = trackingPoint.GetPosition(snapshot);
                var file             = _compilerService.LatestResult?.GetFile(_document.FilePath);
                var compiledSnapshot = file?.Meta.Snapshot as ITextSnapshot;

                if (compiledSnapshot == null || compiledSnapshot.TextBuffer != _buffer)
                {
                    return;
                }

                var span             = new Span(position, 0);
                var applicableToSpan = _buffer.CurrentSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive, 0);
                var signature        = GetSignature(position, file.Ast, applicableToSpan);

                if (signature != null)
                {
                    signatures.Add(signature);
                }
            } catch (Exception e) {
                Debug.WriteLine("AugmentSignatureHelpSession failed");
                Debug.WriteLine(e.ToString());
            }
        }
示例#9
0
            public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
            {
                ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;

                // trigger point
                SnapshotPoint?point = session.GetTriggerPoint(snapshot);

                if (point == null)
                {
                    return;
                }

                // get syntax tree
                SyntaxTree syntaxTree = snapshot.GetSyntaxTree();
                var        root       = syntaxTree.Root as RobotsTxtDocumentSyntax;

                // find line in syntax tree
                ITextSnapshotLine   line       = point.Value.GetContainingLine();
                RobotsTxtLineSyntax lineSyntax = root.Records.SelectMany(r => r.Lines)
                                                 .Where(l => !l.NameToken.IsMissing && !l.DelimiterToken.IsMissing)
                                                 .FirstOrDefault(l => l.Span.IntersectsWith(line.Extent));

                // found
                if (lineSyntax != null)
                {
                    if (lineSyntax.DelimiterToken.Span.Span.End <= point.Value)
                    {
                        // get semantic model
                        ISemanticModel model = syntaxTree.GetSemanticModel();

                        // add signature
                        signatures.Add(new RobotsTxtSignature(model, lineSyntax));
                    }
                }
            }
示例#10
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            SnapshotPoint?point = session.GetTriggerPoint(_buffer.CurrentSnapshot);

            if (!point.HasValue)
            {
                return;
            }

            ITextSnapshotLine line     = point.Value.GetContainingLine();
            string            lineText = line.GetText().Trim();

            if (!lineText.StartsWith("[", StringComparison.Ordinal))
            {
                return;
            }

            _span = _buffer.CurrentSnapshot.CreateTrackingSpan(line.Extent, SpanTrackingMode.EdgeNegative);

            signatures.Add(new SectionSignature("[*.cs]", "Matches multiple files with a .cs file extension", _span, session));
            signatures.Add(new SectionSignature("[*.vb]", "Matches multiple files with a .vb file extension", _span, session));
            signatures.Add(new SectionSignature("[*.{cs,vb}]", "Matches multiple files with brace expansion notation", _span, session));
            signatures.Add(new SectionSignature("[app/**.js]", "Matches all .js files under lib directory", _span, session));
            signatures.Add(new SectionSignature("[{package.json,.npmrc}]", "Matches the exact files - either package.json or .npmrc", _span, session));
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            if (!session.TextView.Properties.ContainsProperty(SessionKey))
            {
                return;
            }

            // At the moment there is a bug in the javascript provider which causes it to
            // repeatedly insert the same Signature values into an ISignatureHelpSession
            // instance.  There is no way, other than reflection, for us to prevent this
            // from happening.  Instead we just ensure that our provider runs after
            // Javascript and then remove the values they add here
            signatures.Clear();

            // Map the trigger point down to our buffer.
            var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);
            if (!subjectTriggerPoint.HasValue)
            {
                return;
            }

            var currentSnapshot = subjectTriggerPoint.Value.Snapshot;
            var querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
            var applicableToSpan = currentSnapshot.CreateTrackingSpan(
                querySpan.Start.Position,
                0,
                SpanTrackingMode.EdgeInclusive);

            string encouragement = encouragements.GetRandomEncouragement();
            if (encouragement != null)
            {
                var signature = new Signature(applicableToSpan, encouragement, "", "");
                signatures.Add(signature);
            }
        }
示例#12
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
            int           position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);

            ITrackingSpan applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(
                new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);


            SnapshotPoint point        = session.TextView.Caret.Position.BufferPosition - 2;
            TextExtent    extent       = m_navigator.GetTextStructureNavigator(m_textBuffer).GetExtentOfWord(point);
            string        hintfunction = extent.Span.GetText();

            var knownFunctions = m_parsedProject.GetAvailableFunctionSignatures();

            foreach (var func in knownFunctions)
            {
                if (!func.Name.Text.Equals(hintfunction))
                {
                    continue;
                }

                foreach (var overload in func.Overloads)
                {
                    signatures.Add(CreateSignature(m_textBuffer, func.Name.Text, overload, "Documentation goes here.", applicableToSpan));
                }
            }
        }
示例#13
0
        public async System.Threading.Tasks.Task CollectSignatureLists(ISignatureHelpSession newSession)
        {
            JavaEditor javaEditor = null;

            if (TextBuffer.Properties.TryGetProperty <JavaEditor>(typeof(JavaEditor), out javaEditor) &&
                javaEditor.TypeRootIdentifier != null)
            {
                var textReader       = new TextSnapshotToTextReader(TextBuffer.CurrentSnapshot) as TextReader;
                var position         = newSession.GetTriggerPoint(TextBuffer).GetPosition(TextBuffer.CurrentSnapshot);
                var paramHelpRequest = ProtocolHandlers.CreateParamHelpRequest(
                    textReader,
                    javaEditor.TypeRootIdentifier,
                    position);
                var paramHelpResponse = await javaEditor.JavaPkgServer.Send(javaEditor, paramHelpRequest);

                if (paramHelpResponse.responseType == Protocol.Response.ResponseType.ParamHelp &&
                    paramHelpResponse.paramHelpResponse != null)
                {
                    if (paramHelpResponse.paramHelpResponse.status && paramHelpResponse.paramHelpResponse.signatures.Count != 0)
                    {
                        var applicableTo           = TextBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(paramHelpResponse.paramHelpResponse.scopeStart, paramHelpResponse.paramHelpResponse.scopeLength), SpanTrackingMode.EdgeInclusive, 0);
                        int selectedParameterIndex = paramHelpResponse.paramHelpResponse.paramCount;
                        Signatures = TransformSignatures(TextBuffer, paramHelpResponse.paramHelpResponse.signatures, applicableTo, selectedParameterIndex);
                    }
                }
            }
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            SnapshotPoint?point = session.GetTriggerPoint(_buffer.CurrentSnapshot);

            if (!point.HasValue)
            {
                return;
            }

            CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
            ParseItem         item     = document.StyleSheet.ItemBeforePosition(point.Value.Position);

            if (item == null)
            {
                return;
            }

            Declaration dec = item.FindType <Declaration>();

            if (dec == null || dec.PropertyName == null || dec.Colon == null)
            {
                return;
            }

            foreach (ISignature signature in signatures)
            {
                if (signature is ValueOrderSignature)
                {
                    signatures.RemoveAt(signatures.Count - 1);
                    break;
                }
            }
        }
            public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
            {
                ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;

                // trigger point
                SnapshotPoint? point = session.GetTriggerPoint(snapshot);
                if (point == null)
                    return;

                // get syntax tree
                SyntaxTree syntaxTree = snapshot.GetSyntaxTree();
                var root = syntaxTree.Root as RobotsTxtDocumentSyntax;

                // find line in syntax tree
                ITextSnapshotLine line = point.Value.GetContainingLine();
                RobotsTxtLineSyntax lineSyntax = root.Records.SelectMany(r => r.Lines)
                    .Where(l => !l.NameToken.IsMissing && !l.DelimiterToken.IsMissing)
                    .FirstOrDefault(l => l.Span.IntersectsWith(line.Extent));

                // found
                if (lineSyntax != null)
                {
                    if (lineSyntax.DelimiterToken.Span.Span.End <= point.Value)
                    {
                        // get semantic model
                        ISemanticModel model = syntaxTree.GetSemanticModel();

                        // add signature
                        signatures.Add(new RobotsTxtSignature(model, lineSyntax));
                    }
                }
            }
示例#16
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
            int           position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);

            Span span;

            if (session.Properties.ContainsProperty("span"))
            {
                span = session.Properties.GetProperty <Span>("span");
            }
            else
            {
                span = new Span(position + 1, 1);
            }

            ITrackingSpan applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward);

            if (session.Properties.ContainsProperty("word"))
            {
                string word = session.Properties.GetProperty <string>("word");

                if (nodeprovider.Funcs != null)
                {
                    foreach (var func in nodeprovider.Funcs)
                    {
                        if (StringComparer.InvariantCultureIgnoreCase.Equals(word, func.Name))
                        {
                            signatures.Add(CreateSignature(m_textBuffer, func.ToString(), func.Description, applicableToSpan));
                        }
                    }
                }

                if (nodeprovider.Triggers != null)
                {
                    foreach (var func in nodeprovider.Triggers)
                    {
                        if (StringComparer.InvariantCultureIgnoreCase.Equals(word, func.Name))
                        {
                            signatures.Add(CreateSignature(m_textBuffer, func.ToString(), string.Empty, applicableToSpan));
                        }
                    }
                }

                if (nodeprovider.CoreFuncs != null)
                {
                    foreach (var func in nodeprovider.CoreFuncs)
                    {
                        if (StringComparer.InvariantCultureIgnoreCase.Equals(word, func.Name))
                        {
                            signatures.Add(CreateSignature(m_textBuffer, func.ToString(), func.Description, applicableToSpan));
                        }
                    }
                }
            }
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            var snapshot = _textBuffer.CurrentSnapshot;
            int position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);

            var applicableToSpan = _textBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

            // Add to signatures list using CreateSignature() method here
            signatures.Add(CreateSignature(_textBuffer, "add(int firstInt, int secondInt)", "Documentation", applicableToSpan));
        }
示例#18
0
        /// <summary>
        /// The augment signature help session.
        /// </summary>
        /// <param name="session">
        /// The session.
        /// </param>
        /// <param name="signatures">
        /// The signatures.
        /// </param>
        public void AugmentSignatureHelpSession([NotNull] ISignatureHelpSession session, IList <ISignature> signatures)
        {
            var point            = session.GetTriggerPoint(this.textBuffer).GetPoint(this.textBuffer.CurrentSnapshot);
            var functionName     = this.provider.NavigatorService.GetTextStructureNavigator(this.textBuffer).GetExtentOfWord(point - 1).Span.GetText();
            var applicableToSpan = this.textBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(point, 0), SpanTrackingMode.EdgeInclusive, 0);

            foreach (var function in this.provider.DocumentProvider.GetDocument(this.textBuffer).GetFunctionsByName(functionName).ToArray())
            {
                signatures.Add(new Signature(this.textBuffer, function, applicableToSpan));
            }
        }
示例#19
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ITextSnapshot currentSnapshot       = _textBuffer.CurrentSnapshot;
            int           currentPosition       = session.GetTriggerPoint(_textBuffer).GetPosition(currentSnapshot);
            ITrackingSpan currentApplicableSpan = currentSnapshot.CreateTrackingSpan(new Span(currentPosition, 0), SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward);

            signatures.Add(CreateSignature(_textBuffer, "<content name=\"namedContentArea\" />", "Spools all output in the content element into a named text writer", currentApplicableSpan));
            signatures.Add(CreateSignature(_textBuffer, "<content var=\"variable\" />", "Spools all output into a temporary text writer", currentApplicableSpan));
            signatures.Add(CreateSignature(_textBuffer, "<content def=\"variable\" />", "Spools all output into a temporary text writer (same as 'var')", currentApplicableSpan));
            signatures.Add(CreateSignature(_textBuffer, "<default x=\"xValue\" y=\"yValue\" />", "Declares local variables if a symbol of a given name is not known to be in scope", currentApplicableSpan));
        }
示例#20
0
    //</Snippet17>

    //<Snippet18>
    public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
    {
        ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
        int           position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);

        ITrackingSpan applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(
            new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

        signatures.Add(CreateSignature(m_textBuffer, "add(int firstInt, int secondInt)", "Documentation for adding integers.", applicableToSpan));
        signatures.Add(CreateSignature(m_textBuffer, "add(double firstDouble, double secondDouble)", "Documentation for adding doubles.", applicableToSpan));
    }
示例#21
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            ITextSnapshot currentSnapshot = _textBuffer.CurrentSnapshot;
            int currentPosition = session.GetTriggerPoint(_textBuffer).GetPosition(currentSnapshot);
            ITrackingSpan currentApplicableSpan = currentSnapshot.CreateTrackingSpan(new Span(currentPosition, 0), SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward);

            signatures.Add(CreateSignature(_textBuffer, "<content name=\"namedContentArea\" />", "Spools all output in the content element into a named text writer", currentApplicableSpan));
            signatures.Add(CreateSignature(_textBuffer, "<content var=\"variable\" />", "Spools all output into a temporary text writer", currentApplicableSpan));
            signatures.Add(CreateSignature(_textBuffer, "<content def=\"variable\" />", "Spools all output into a temporary text writer (same as 'var')", currentApplicableSpan));
            signatures.Add(CreateSignature(_textBuffer, "<default x=\"xValue\" y=\"yValue\" />", "Declares local variables if a symbol of a given name is not known to be in scope", currentApplicableSpan));
        }
示例#22
0
        public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures, AstRoot ast, Action <object, string> triggerSession, string packageName)
        {
            ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
            int           position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);

            // Retrieve parameter positions from the current text buffer snapshot
            ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position);

            if (parametersInfo != null)
            {
                position = Math.Min(parametersInfo.SignatureEnd, position);
                int start = Math.Min(position, snapshot.Length);
                int end   = Math.Min(parametersInfo.SignatureEnd, snapshot.Length);

                ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive);
                IFunctionInfo functionInfo     = null;

                // First try user-defined function
                if (string.IsNullOrEmpty(parametersInfo.PackageName))
                {
                    functionInfo = ast.GetUserFunctionInfo(parametersInfo.FunctionName, position);
                }
                else
                {
                    packageName = parametersInfo.PackageName;
                }

                if (functionInfo == null)
                {
                    var functionIndex = _shell.ExportProvider.GetExportedValue <IFunctionIndex>();
                    // Then try package functions
                    packageName  = packageName ?? _packageName;
                    _packageName = null;
                    // Get collection of function signatures from documentation (parsed RD file)
                    functionInfo = functionIndex.GetFunctionInfo(parametersInfo.FunctionName, packageName, triggerSession, session);
                }

                if (functionInfo != null && functionInfo.Signatures != null)
                {
                    foreach (ISignatureInfo signatureInfo in functionInfo.Signatures)
                    {
                        ISignature signature = CreateSignature(session, parametersInfo.FunctionName, functionInfo, signatureInfo, applicableToSpan, ast, position);
                        signatures.Add(signature);
                    }

                    session.Properties["functionInfo"] = functionInfo;
                    return(true);
                }
            }

            return(false);
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ITextSnapshot snapshot = this.textBuffer.CurrentSnapshot;
            int           position = session.GetTriggerPoint(this.textBuffer).GetPosition(snapshot);

            ITrackingSpan applicableToSpan = this.textBuffer.CurrentSnapshot.CreateTrackingSpan(
                new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

            SnapshotPoint?sp = session.GetTriggerPoint(snapshot);

            if (!sp.HasValue)
            {
                return;
            }

            string word = navigator.GetExtentOfWord(sp.Value - 1).Span.GetText().Trim();

            ShaderlabDataManager.Instance.HLSLCGFunctions.ForEach(f =>
            {
                foreach (var item in f.Synopsis)
                {
                    if (f.Name.Equals(word))
                    {
                        signatures.Add(CreateSignature(this.textBuffer, item, f.Description, applicableToSpan));
                    }
                }
            });

            ShaderlabDataManager.Instance.UnityBuiltinFunctions.ForEach(f =>
            {
                foreach (var item in f.Synopsis)
                {
                    if (f.Name.Equals(word))
                    {
                        signatures.Add(CreateSignature(this.textBuffer, item, f.Description, applicableToSpan));
                    }
                }
            });
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            SnapshotPoint?point = session.GetTriggerPoint(_buffer.CurrentSnapshot);

            if (!point.HasValue)
            {
                return;
            }

            CssEditorDocument document = CssEditorDocument.FromTextBuffer(_buffer);
            ParseItem         item     = document.StyleSheet.ItemBeforePosition(point.Value.Position);

            if (item == null)
            {
                return;
            }

            Declaration dec = item.FindType <Declaration>();

            if (dec == null || dec.PropertyName == null || dec.Colon == null)
            {
                return;
            }

            int length = dec.Length - (dec.Colon.Start - dec.Start);
            var span   = _buffer.CurrentSnapshot.CreateTrackingSpan(dec.Colon.Start, length, SpanTrackingMode.EdgeNegative);

            ValueOrderFactory.AddSignatures method = ValueOrderFactory.GetMethod(dec);

            if (method != null)
            {
                signatures.Clear();
                method(session, signatures, dec, span);

                Dispatcher.CurrentDispatcher.BeginInvoke(
                    new Action(() =>
                {
                    if (session == null || session.Properties == null)
                    {
                        return;
                    }

                    session.Properties.AddProperty("dec", dec);
                    session.Match();
                }),
                    DispatcherPriority.Normal, null);
            }
        }
示例#25
0
        public List <ClassificationSpan> GetReplacementSpans(ISignatureHelpSession session)
        {
            ITextSnapshot snapshot       = this.textBuffer.CurrentSnapshot;
            int           currentVersion = snapshot.Version.VersionNumber;
            SnapshotPoint currentPoint   = session.GetTriggerPoint(snapshot).Value;

            if (replacementSpansVersion != currentVersion || replacementSpansPoint != currentPoint)
            {
                // TODO: detect when the current point is within the spans and re-use?
                this.replacementSpans        = this.GetReplacementSpans(currentPoint);
                this.replacementSpansVersion = currentVersion;
                this.replacementSpansPoint   = currentPoint;
            }

            return(this.replacementSpans);
        }
示例#26
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var snapshot      = _textBuffer.CurrentSnapshot;
            var triggerPoint  = session.GetTriggerPoint(_textBuffer);
            var snapshotPoint = triggerPoint.GetPoint(snapshot);
            var position      = triggerPoint.GetPosition(snapshot);

            var applicableToSpan = _textBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(position, 0), SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward);

            // Parse the entire document into an AST
            var index = CXIndex.Create(false, false);

            if ((_dte.ActiveDocument, snapshot).TryParseDocument(index, out var translationUnit, out _))
            {
                var visitor = new EmplacingVisitor(_dte.ActiveDocument.FullName, snapshotPoint.GetContainingLine().LineNumber);
                visitor.CtorFound += (templateParameters, parameters) =>
                {
                    // TODO: eliminate this stupid back-and-forth string handling

                    var signatureBuilder = new StringBuilder("emplace");
                    signatureBuilder.Append('(');
                    foreach (var parameter in parameters)
                    {
                        signatureBuilder.Append(parameter.Type).Append(' ').Append(parameter.Name).Append(", ");
                    }

                    if (parameters.Count > 0)
                    {
                        signatureBuilder.Length -= 2;
                    }
                    signatureBuilder.Append(')');

                    signatures.Add(CreateSignature(_textBuffer, signatureBuilder.ToString(), applicableToSpan));
                };

                visitor.Visit(translationUnit);
            }
        }
示例#27
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            // Map the trigger point down to our buffer.
            var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);

            if (!subjectTriggerPoint.HasValue)
            {
                return;
            }

            var currentSnapshot  = subjectTriggerPoint.Value.Snapshot;
            var querySpan        = new SnapshotSpan(subjectTriggerPoint.Value, 0);
            var applicableToSpan = currentSnapshot.CreateTrackingSpan(
                querySpan.Start.Position,
                1,
                SpanTrackingMode.EdgeInclusive);

            string encouragement = encouragements.GetRandomEncouragement();
            var    signature     = new Signature(applicableToSpan, encouragement, "", "");

            signatures.Add(signature);
        }
示例#28
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            //AsmDudeToolsStatic.Output_INFO("AsmSignatureHelpSource: AugmentSignatureHelpSession");

            //if (true) return;
            if (!Settings.Default.SignatureHelp_On)
            {
                return;
            }

            try
            {
                DateTime      time1            = DateTime.Now;
                ITextSnapshot snapshot         = this._buffer.CurrentSnapshot;
                int           position         = session.GetTriggerPoint(this._buffer).GetPosition(snapshot);
                ITrackingSpan applicableToSpan = this._buffer.CurrentSnapshot.CreateTrackingSpan(new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

                ITextSnapshotLine line    = snapshot.GetLineFromPosition(position);
                string            lineStr = line.GetText();
                //AsmDudeToolsStatic.Output_INFO("AsmSignatureHelpSource: AugmentSignatureHelpSession: lineStr=" + lineStr+ "; positionInLine=" + positionInLine);

                var             t        = AsmSourceTools.ParseLine(lineStr);
                IList <Operand> operands = AsmSourceTools.MakeOperands(t.Args);
                Mnemonic        mnemonic = t.Mnemonic;

                ISet <Arch> selectedArchitectures = AsmDudeToolsStatic.Get_Arch_Swithed_On();
                //AsmDudeToolsStatic.Output_INFO("AsmSignatureHelpSource: AugmentSignatureHelpSession: selected architectures=" + ArchTools.ToString(selectedArchitectures));

                foreach (AsmSignatureElement se in AsmSignatureHelpSource.Constrain_Signatures(this._store.GetSignatures(mnemonic), operands, selectedArchitectures))
                {
                    signatures.Add(Create_Signature(this._buffer, se, applicableToSpan));
                }
                AsmDudeToolsStatic.Print_Speed_Warning(time1, "Signature Help");
            }
            catch (Exception e)
            {
                AsmDudeToolsStatic.Output_ERROR(string.Format("{0}:AugmentSignatureHelpSession; e={1}", ToString(), e.ToString()));
            }
        }
示例#29
0
        public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures, AstRoot ast, Action<object, string> triggerSession) {
            ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
            int position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);

            // Retrieve parameter positions from the current text buffer snapshot
            ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position);
            if (parametersInfo != null) {
                position = Math.Min(parametersInfo.SignatureEnd, position);
                int start = Math.Min(position, snapshot.Length);
                int end = Math.Min(parametersInfo.SignatureEnd, snapshot.Length);

                ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive);
                IFunctionInfo functionInfo = null;

                // First try user-defined function
                functionInfo = ast.GetUserFunctionInfo(parametersInfo.FunctionName, position);
                if (functionInfo == null) {
                    var functionIndex = _shell.ExportProvider.GetExportedValue<IFunctionIndex>();
                    // Then try package functions
                    var packageName = _packageName;
                    _packageName = null;
                    // Get collection of function signatures from documentation (parsed RD file)
                    functionInfo = functionIndex.GetFunctionInfo(parametersInfo.FunctionName, packageName, triggerSession, session);
                }

                if (functionInfo != null && functionInfo.Signatures != null) {
                    foreach (ISignatureInfo signatureInfo in functionInfo.Signatures) {
                        ISignature signature = CreateSignature(session, parametersInfo.FunctionName, functionInfo, signatureInfo, applicableToSpan, ast, position);
                        signatures.Add(signature);
                    }

                    session.Properties["functionInfo"] = functionInfo;
                    return true;
                }
            }

            return false;
        }
示例#30
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var snapshot = _textBuffer.CurrentSnapshot;

            _triggerPos = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);

            if (ProbeSignatureHelpCommandHandler.s_typedChar == '(')
            {
                foreach (var sig in HandleOpenBracket(snapshot, ProbeEnvironment.CurrentAppSettings))
                {
                    signatures.Add(sig);
                }
            }
            else if (ProbeSignatureHelpCommandHandler.s_typedChar == ',')
            {
                foreach (var sig in HandleComma(snapshot, ProbeEnvironment.CurrentAppSettings))
                {
                    signatures.Add(sig);
                }
            }
        }
示例#31
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            if (!session.TextView.Properties.ContainsProperty(SessionKey))
            {
                return;
            }

            // At the moment there is a bug in the javascript provider which causes it to
            // repeatedly insert the same Signature values into an ISignatureHelpSession
            // instance.  There is no way, other than reflection, for us to prevent this
            // from happening.  Instead we just ensure that our provider runs after
            // Javascript and then remove the values they add here
            signatures.Clear();

            // Map the trigger point down to our buffer.
            var subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);

            if (!subjectTriggerPoint.HasValue)
            {
                return;
            }

            var currentSnapshot  = subjectTriggerPoint.Value.Snapshot;
            var querySpan        = new SnapshotSpan(subjectTriggerPoint.Value, 0);
            var applicableToSpan = currentSnapshot.CreateTrackingSpan(
                querySpan.Start.Position,
                0,
                SpanTrackingMode.EdgeInclusive);

            string encouragement = encouragements.GetRandomEncouragement();

            if (encouragement != null)
            {
                var signature = new Signature(applicableToSpan, encouragement, "", "");
                signatures.Add(signature);
            }
        }
示例#32
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            try
            {
                Debug("XSharpSignatureHelpSource.AugmentSignatureHelpSession()");
                m_session = session;
                XSharpModel.ModelWalker.Suspend();
                ITextSnapshot             snapshot = m_textBuffer.CurrentSnapshot;
                XSharpSignatureProperties props;
                int position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);
                session.Properties.TryGetProperty(typeof(XSharpSignatureProperties), out props);
                m_applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(props.Start, props.Length), SpanTrackingMode.EdgeInclusive, 0);

                object elt = props.Element;
                if (elt is IXSymbol)
                {
                    IXMemberSymbol element = elt as IXMemberSymbol;
                    //
                    if (elt is IXMemberSymbol xMember)
                    {
                        var names = new List <string>();
                        var proto = getProto(xMember, props);
                        names.Add(proto);
                        signatures.Add(CreateSignature(m_textBuffer, xMember, proto, ApplicableToSpan, xMember.Kind == XSharpModel.Kind.Constructor, m_file));
                        var overloads = xMember.GetOverloads();

                        foreach (var member in overloads)
                        {
                            if (member.Visibility < props.Visibility)
                            {
                                continue;
                            }
                            // prevent duplicate prototypes in the list  (when a child has overriden a method)
                            proto = getProto(member, props);
                            if (!names.Contains(proto))
                            {
                                signatures.Add(CreateSignature(m_textBuffer, member, proto, ApplicableToSpan, member.Kind == XSharpModel.Kind.Constructor, m_file));
                                names.Add(proto);
                            }
                        }
                    }
                    else if (element != null)
                    {
                        // Type ??
                        signatures.Add(CreateSignature(m_textBuffer, null, element.Prototype, ApplicableToSpan, false, m_file));
                    }
                    // why not ?
                    int paramCount = int.MaxValue;
                    foreach (ISignature sig in signatures)
                    {
                        if (sig.Parameters.Count < paramCount)
                        {
                            paramCount = sig.Parameters.Count;
                        }
                    }
                    //
                    m_textBuffer.Changed += new EventHandler <TextContentChangedEventArgs>(OnSubjectBufferChanged);
                }
                session.Dismissed += OnSignatureHelpSessionDismiss;
            }
            catch (Exception ex)
            {
                XSettings.LogException(ex, "XSharpSignatureHelpSource.AugmentSignatureHelpSession Exception failed ");
            }
            finally
            {
                XSharpModel.ModelWalker.Resume();
            }
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
        {
            ITextSnapshot snapshot = this.textBuffer.CurrentSnapshot;
            int position = session.GetTriggerPoint(this.textBuffer).GetPosition(snapshot);

            ITrackingSpan applicableToSpan = this.textBuffer.CurrentSnapshot.CreateTrackingSpan(
             new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

            SnapshotPoint? sp = session.GetTriggerPoint(snapshot);
            if (!sp.HasValue)
            {
                return;
            }

            string word = navigator.GetExtentOfWord(sp.Value - 1).Span.GetText().Trim();
            ShaderlabDataManager.Instance.HLSLCGFunctions.ForEach(f =>
                {
                    foreach (var item in f.Synopsis)
                    {
                        if (f.Name.Equals(word))
                        {
                            signatures.Add(CreateSignature(this.textBuffer, item, f.Description, applicableToSpan));
                        }
                    }
                });

            ShaderlabDataManager.Instance.UnityBuiltinFunctions.ForEach(f =>
                {
                    foreach (var item in f.Synopsis)
                    {
                        if (f.Name.Equals(word))
                        {
                            signatures.Add(CreateSignature(this.textBuffer, item, f.Description, applicableToSpan));
                        }
                    }
                });
        }
示例#34
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ContractsPackageAccessor.Current.Logger.PublicEntry(() => {
                //Record our start time for preformance considerations
                var startTime = DateTime.Now;

                //Do we have signatures?
                if (signatures == null || signatures.Count < 1)
                {
                    return;
                }

                //Do we have a well-formed session?
                if (session == null || session.TextView == null || session.TextView.TextBuffer == null)
                {
                    return;
                }

                //Can we get our trigger point?
                var triggerPoint = session.GetTriggerPoint(_textBuffer);
                if (triggerPoint == null)
                {
                    return;
                }

                //Can we get our snapshot?
                var workingSnapshot = _textBuffer.CurrentSnapshot;
                if (workingSnapshot == null)
                {
                    return;
                }

                //Can we get our SourceFile?
                var sourceFile = _textViewTracker.LatestSourceFile;
                if (sourceFile == null)
                {
                    return;
                }

                //Can we get our ParseTree?
                var parseTree = sourceFile.GetParseTree();
                if (parseTree == null)
                {
                    return;
                }

                //Can we get our compilation?
                var comp = _textViewTracker.LatestCompilation;
                if (comp == null)
                {
                    return;
                }

                //Is the model ready?
                if (!parseTree.IsModelReady() || _textViewTracker.IsLatestCompilationStale || _textViewTracker.IsLatestSourceFileStale)
                {
                    //Ask for a new model
                    ContractsPackageAccessor.Current.AskForNewVSModel(_textBuffer);

                    //Return a message saying we aren't ready yet
                    ContractsPackageAccessor.Current.Logger.WriteToLog("The VS model is out of date! Aborting contract lookup.");
                    return;//"(VS isn't ready for possible contract lookup yet. Please try again in a few seconds.)";
                }

                string[] contractContents = null;

                //Proceed cautiously
                try
                {
                    //Can we get a call node?
                    var callNode = IntellisenseContractsHelper.GetAnyCallNodeAboveTriggerPoint(triggerPoint, workingSnapshot, parseTree);
                    if (callNode == null || comp == null || sourceFile == null)
                    {
                        return;
                    }

                    //Can we get our semantic member?
                    var semanticMember = IntellisenseContractsHelper.GetSemanticMember(callNode, comp, sourceFile);
                    if (semanticMember == null)
                    {
                        return;
                    }

                    var declType = semanticMember.ContainingType;
                    // find all members of the same name (virt/non-virt)

                    var overloads = GetSignatureOverloads(declType, signatures, semanticMember);

                    contractContents = GetContractsForOverloads(overloads);


                    //Give up on our contracts if we get an exception
                }
                catch (IllFormedSemanticModelException)
                {
                    return;
                }
                catch (InvalidOperationException e)
                {
                    if (!e.Message.Contains(ContractsPackageAccessor.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate))
                    {
                        throw e;
                    }
                    else
                    {
                        this._textViewTracker.IsLatestCompilationStale = true;
                        return;
                    }
                }
                catch (System.Runtime.InteropServices.COMException)
                {
                    // various reasons for COMException
                    // - binding failed
                    // - project unavailable
                    // - ...
                    return;
                }

                //Enumerate the signatures and append our custom content
                for (int i = 0; i < signatures.Count; i++)
                {
                    var sig = signatures[i];

                    if (contractContents != null && !String.IsNullOrEmpty(contractContents[i]))
                    {
                        signatures[i] = new SignatureWithContracts(sig, contractContents[i]);
                    }
                }

                //Print our elapsed time for preformance considerations
                var elapseTime = DateTime.Now - startTime;
                ContractsPackageAccessor.Current.Logger.WriteToLog("Time to compute quickinfo: " + elapseTime.Milliseconds + "ms");
            }, "AugmentSignatureHelpSession");
        }
示例#35
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            try
            {
                Debug("XSharpSignatureHelpSource.AugmentSignatureHelpSession()");
                XSharpModel.ModelWalker.Suspend();
                ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
                int           position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);
                int           start    = (int)session.Properties["Start"];
                int           length   = (int)session.Properties["Length"];
                var           comma    = (bool)session.Properties["Comma"];
                var           file     = (XFile)session.Properties["File"];
                m_applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(
                    new Span(start, length), SpanTrackingMode.EdgeInclusive, 0);

                object elt = session.Properties["Element"];
                m_session = session;
                if (elt is IXElement)
                {
                    IXMember element = elt as IXMember;
                    //
                    if (elt is IXMember)
                    {
                        IXMember xMember = elt as IXMember;
                        var      names   = new List <string>();
                        var      proto   = xMember.Prototype;
                        names.Add(proto);
                        signatures.Add(CreateSignature(m_textBuffer, xMember, proto, "", ApplicableToSpan, comma, xMember.Kind == XSharpModel.Kind.Constructor, file));
                        var overloads = xMember.GetOverloads();
                        foreach (var member in overloads)
                        {
                            // prevent duplicate prototypes in the list  (when a child has overriden a method)
                            proto = member.Prototype;
                            if (!names.Contains(proto))
                            {
                                signatures.Add(CreateSignature(m_textBuffer, member, proto, "", ApplicableToSpan, comma, member.Kind == XSharpModel.Kind.Constructor, file));
                                names.Add(proto);
                            }
                        }
                    }
                    else if (element != null)
                    {
                        // Type ??
                        signatures.Add(CreateSignature(m_textBuffer, null, element.Prototype, "", ApplicableToSpan, comma, false, file));
                    }
                    // why not ?
                    int paramCount = int.MaxValue;
                    foreach (ISignature sig in signatures)
                    {
                        if (sig.Parameters.Count < paramCount)
                        {
                            paramCount = sig.Parameters.Count;
                        }
                    }
                    //
                    m_textBuffer.Changed += new EventHandler <TextContentChangedEventArgs>(OnSubjectBufferChanged);
                }
                session.Dismissed += OnSignatureHelpSessionDismiss;
            }
            catch (Exception ex)
            {
                package.DisplayOutPutMessage("XSharpSignatureHelpSource.AugmentSignatureHelpSession Exception failed ");
                package.DisplayException(ex);
            }
            finally
            {
                XSharpModel.ModelWalker.Resume();
            }
        }
示例#36
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
            int           position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);

            ITrackingSpan applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(
                new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

            //First try to get a compilable source code
            snapshot = snapshot.TextBuffer.Insert(position, "();");
            Span spanToRemove = new Span(position, 3);

            //StaDynParser parser = new StaDynParser(snapshot.TextBuffer, FileUtilities.Instance.getCurrentOpenDocumentFilePath());

            ////Parse source
            //StaDynSourceFileAST parseResult = parser.parseSource();

            //parseResult = DecorateAST.Instance.completeDecorateAndUpdate(parseResult);
            StaDynParser parser = new StaDynParser();

            parser.parseAll();
            StaDynSourceFileAST parseResult = ProjectFileAST.Instance.getAstFile(FileUtilities.Instance.getCurrentOpenDocumentFilePath());

            if (parseResult == null || parseResult.Ast == null)
            {
                snapshot = snapshot.TextBuffer.Delete(spanToRemove);
                return;
            }

            System.Drawing.Point caretPosition = FileUtilities.Instance.getCurrentCaretPoint();

            int column = caretPosition.Y;
            int line   = caretPosition.X + 1;

            //AstNode foundNode = (AstNode)parseResult.Ast.Accept(new VisitorFindNode(), new Location(Path.GetFileName(parseResult.FileName), line, column));
            AstNode foundNode = (AstNode)parseResult.Ast.Accept(new VisitorFindNode(), new Location(parseResult.FileName, line, column));

            //Signature help is not needed on method definition
            if (foundNode is MethodDefinition)
            {
                snapshot = snapshot.TextBuffer.Delete(spanToRemove);
                return;
            }
            AstNode lastInvocationNode = StaDynIntellisenseHelper.Instance.getCurrentInvocation(parseResult, snapshot, position, line, column);

            //StaDynSourceFileAST file = ProjectFileAST.Instance.getAstFile(FileUtilities.Instance.getCurrentOpenDocumentFilePath());
            //if (file.Ast == null) return ;
            //AstNode foundNode = (AstNode)file.Ast.Accept(new VisitorFindNode(), new Location(Path.GetFileName(file.FileName), line, column));
            //Remove added chars
            snapshot = snapshot.TextBuffer.Delete(spanToRemove);

            if (lastInvocationNode == null)
            {
                return;
            }

            this.createSignatures(lastInvocationNode, m_textBuffer, applicableToSpan, signatures);

            /*****************************************/

            //signatures.Add(CreateSignature(m_textBuffer, "add(int firstInt, int secondInt)", "Documentation for adding integers.", applicableToSpan));
            //signatures.Add(CreateSignature(m_textBuffer, "add(double firstDouble, double secondDouble)", "Documentation for adding doubles.", applicableToSpan));
        }
示例#37
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            Snapshot   snapshot = this.source.CurrentSnapshot;
            SyntaxTree tree     = this.source.Tree;

            int              triggerPosition = session.GetTriggerPoint(snapshot.ToITextSnapshot()).Value.Position;
            SyntaxNode       node            = tree?.GetNodeFromPosition(snapshot, triggerPosition);
            IdentifierSyntax identifier      = node as IdentifierSyntax;

            if (identifier?.Definition?.Kind != DefinitionKind.Function)
            {
                FunctionCallSyntax functionCall = null;

                foreach (SyntaxNode decendent in node.DescendantsAndSelf)
                {
                    if (decendent.SyntaxType == SyntaxType.FunctionCall)
                    {
                        functionCall = decendent as FunctionCallSyntax;
                        break;
                    }
                }

                if (functionCall == null)
                {
                    foreach (SyntaxNode ancestor in node.AncestorsAndSelf)
                    {
                        if (ancestor.SyntaxType == SyntaxType.FunctionCall)
                        {
                            functionCall = ancestor as FunctionCallSyntax;
                            break;
                        }
                    }
                }

                if (functionCall?.Identifier?.Definition != null && functionCall.Span.GetSpan(snapshot).Contains(triggerPosition))
                {
                    TrackingSpan span = null;

                    if (functionCall.RightParentheses == null)
                    {
                        SourceLine line = snapshot.GetLineFromPosition(functionCall.Span.GetSpan(snapshot).Start);

                        span = snapshot.CreateTrackingSpan(Span.Create(functionCall.Span.GetSpan(snapshot).Start, line.Span.End));
                    }
                    else
                    {
                        span = functionCall.Span;
                    }

                    for (int i = 0; i < functionCall.Identifier.Definition.Overloads.Count; i++)
                    {
                        signatures.Add(new GLSLSignature(functionCall.Identifier.Definition.Overloads[i], span, snapshot, session.TextView, session));
                    }
                }
            }
            else if (identifier?.Definition != null)
            {
                TrackingSpan span = null;

                if (node?.Parent.SyntaxType == SyntaxType.FunctionCall)
                {
                    span = node.Parent.Span;
                }
                else
                {
                    span = node.Span;
                }

                for (int i = 0; i < identifier.Definition.Overloads.Count; i++)
                {
                    signatures.Add(new GLSLSignature(identifier.Definition.Overloads[i], span, snapshot, session.TextView, session));
                }

                if (BuiltInData.Instance.Definitions.ContainsKey(identifier.Definition.Name.Text))
                {
                    for (int i = 0; i < BuiltInData.Instance.Definitions[identifier.Definition.Name.Text].Count; i++)
                    {
                        signatures.Add(new GLSLSignature(BuiltInData.Instance.Definitions[identifier.Definition.Name.Text][i], span, snapshot, session.TextView, session));
                    }
                }
            }
        }
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            try
            {
                XSharpProjectPackage.Instance.DisplayOutPutMessage("XSharpSignatureHelpSource.AugmentSignatureHelpSession()");
                XSharpModel.ModelWalker.Suspend();
                ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
                int           position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);
                int           start    = (int)session.Properties["Start"];
                int           length   = (int)session.Properties["Length"];
                var           comma    = (bool)session.Properties["Comma"];
                m_applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(
                    new Span(start, length), SpanTrackingMode.EdgeInclusive, 0);

                object elt = session.Properties["Element"];
                m_session = session;
                if (elt is XSharpModel.XElement)
                {
                    XSharpModel.XElement element = elt as XSharpModel.XElement;
                    signatures.Add(CreateSignature(m_textBuffer, element.Prototype, "", ApplicableToSpan, comma));
                    //
                    if (elt is XSharpModel.XTypeMember)
                    {
                        XSharpModel.XTypeMember        xMember  = elt as XSharpModel.XTypeMember;
                        List <XSharpModel.XTypeMember> namesake = xMember.Namesake();
                        foreach (var member in namesake)
                        {
                            signatures.Add(CreateSignature(m_textBuffer, member.Prototype, "", ApplicableToSpan, comma));
                        }
                        //
                    }
                    // why not ?
                    int paramCount = int.MaxValue;
                    foreach (ISignature sig in signatures)
                    {
                        if (sig.Parameters.Count < paramCount)
                        {
                            paramCount = sig.Parameters.Count;
                        }
                    }
                    //
                    m_textBuffer.Changed += new EventHandler <TextContentChangedEventArgs>(OnSubjectBufferChanged);
                }
                else if (elt is System.Reflection.MemberInfo)
                {
                    System.Reflection.MemberInfo  element  = elt as System.Reflection.MemberInfo;
                    XSharpLanguage.MemberAnalysis analysis = new XSharpLanguage.MemberAnalysis(element);
                    if (analysis.IsInitialized)
                    {
                        signatures.Add(CreateSignature(m_textBuffer, analysis.Prototype, "", ApplicableToSpan, comma));
                        // Any other member with the same name in the current Type and in the Parent(s) ?
                        SystemNameSake(element.DeclaringType, signatures, element.Name, analysis.Prototype, comma);
                        //
                        m_textBuffer.Changed += new EventHandler <TextContentChangedEventArgs>(OnSubjectBufferChanged);
                    }
                }
                session.Dismissed += OnSignatureHelpSessionDismiss;
            }
            catch (Exception ex)
            {
                XSharpProjectPackage.Instance.DisplayOutPutMessage("XSharpSignatureHelpSource.AugmentSignatureHelpSession Exception failed ");
                XSharpProjectPackage.Instance.DisplayException(ex);
            }
            finally
            {
                XSharpModel.ModelWalker.Resume();
            }
        }
示例#39
0
        public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures)
        {
            //if (!session.TextView.Properties.ContainsProperty(SessionKey)) {
            //    return;
            //}
            NSUtil.DebugPrintAlways("NSSig - AugmentSignatureHelpSession");

            if (NSPackage.nimsuggest == null)
            {
                return;
            }

            signatures.Clear();
            var caretpos = NSLangServ.CaretPosGet();

            NSPackage.nimsuggest.Query(NimSuggestProc.Qtype.con, caretpos["line"], caretpos["col"]);

            SnapshotPoint?point_trigger = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);

            if (!point_trigger.HasValue)
            {
                return;
            }

            //ITextSnapshot snapshot = subjectBuffer.CurrentSnapshot;
            //int position = session.GetTriggerPoint(subjectBuffer).GetPosition(subjectBuffer.CurrentSnapshot);
            int position = point_trigger.Value.Position;

            string text = subjectBuffer.CurrentSnapshot.GetText();

            SnapshotPoint point_curr = session.GetTriggerPoint(subjectBuffer).GetPoint(subjectBuffer.CurrentSnapshot);

            point_curr = point_trigger.Value;
            SnapshotPoint point_left  = point_curr;
            SnapshotPoint point_right = point_curr;

            ITextSnapshotLine line  = point_left.GetContainingLine();
            string            terms = "\n\r\t.:()[]{}?/+-;=*!<>";

            while (true)
            {
                point_left -= 1;
                if (point_left <= line.Start)
                {
                    point_left = line.Start;
                    break;
                }
                if (terms.IndexOf(point_left.GetChar()) != -1)
                {
                    point_left += 1;
                    break;
                }
            }
            while (true)
            {
                if (point_right >= line.End)
                {
                    point_right = line.End;
                    break;
                }
                if (terms.IndexOf(point_right.GetChar()) != -1)
                {
                    point_right -= 1;
                    break;
                }
                point_right += 1;
            }
            if (point_left > point_right)
            {
                point_right = point_left;
            }
            ITrackingSpan applicable_to_span = subjectBuffer.CurrentSnapshot.CreateTrackingSpan(point_left, point_right - point_left, SpanTrackingMode.EdgeInclusive);
            //ITrackingSpan applicableToSpan = subjectBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);

            string sig_help_default = "";

            foreach (string skey in NSPackage.nimsuggest.sugdct.Keys)
            {
                var sigdct = NSPackage.nimsuggest.sugdct[skey];
                if (sigdct["help"].Length > sig_help_default.Length)
                {
                    sig_help_default = sigdct["help"];
                }
            }

            foreach (string skey in NSPackage.nimsuggest.sugdct.Keys)
            {
                var sigdct = NSPackage.nimsuggest.sugdct[skey];
                //SortedDictionary<string,string>
                signatures.Add(SigAdd(subjectBuffer, skey, sigdct, sig_help_default, applicable_to_span, session));
            }

            //var currentSnapshot = subjectTriggerPoint.Value.Snapshot;
            //var querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
            //var applicableToSpan = currentSnapshot.CreateTrackingSpan(querySpan.Start.Position, 0, SpanTrackingMode.EdgeInclusive);

            //signatures.Add(CreateSignature(subjectBuffer, "add(int firstInt, int secondInt)", "Documentation for adding integers.", applicableToSpan));
            //signatures.Add(CreateSignature(subjectBuffer, "add(double firstDouble, double secondDouble)", "Documentation for adding doubles.", applicableToSpan));

            //string sighelp = "hey1";
            //if (sighelp != null) {
            //}
        }
示例#40
0
    public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures) {
      VSServiceProvider.Current.Logger.PublicEntry(() => {

        //Record our start time for preformance considerations
        var startTime = DateTime.Now;

        //Do we have signatures?
        if (signatures == null || signatures.Count < 1)
          return;

        //Do we have a well-formed session?
        if (session == null || session.TextView == null || session.TextView.TextBuffer == null)
          return;
        
        //Can we get our trigger point?
        var triggerPoint = session.GetTriggerPoint(_textBuffer);
        if (triggerPoint == null)
          return;

        //Can we get our snapshot?
        var workingSnapshot = _textBuffer.CurrentSnapshot;
        if (workingSnapshot == null)
          return;

        //Can we get our SourceFile?
        var sourceFile = _textViewTracker.LatestSourceFile;
        if (sourceFile == null)
          return;

        //Can we get our ParseTree?
        var parseTree = sourceFile.GetParseTree();
        if (parseTree == null)
          return;

        //Can we get our compilation?
        var comp = _textViewTracker.LatestCompilation;
        if (comp == null)
          return;

        //Is the model ready?
        if (!VSServiceProvider.IsModelReady(parseTree) || _textViewTracker.IsLatestCompilationStale || _textViewTracker.IsLatestSourceFileStale) {

          //Ask for a new model
          VSServiceProvider.Current.AskForNewVSModel();

          //Return a message saying we aren't ready yet
          VSServiceProvider.Current.Logger.WriteToLog("The VS model is out of date! Aborting contract lookup.");
          return;//"(VS isn't ready for possible contract lookup yet. Please try again in a few seconds.)";
        }

        string[] contractContents = null;

        //Proceed cautiously
        try
        {

            //Can we get a call node?
            var callNode = IntellisenseContractsHelper.GetAnyCallNodeAboveTriggerPoint(triggerPoint, workingSnapshot, parseTree);
            if (callNode == null || comp == null || sourceFile == null)
                return;

            //Can we get our semantic member?
            var semanticMember = IntellisenseContractsHelper.GetSemanticMember(callNode, comp, sourceFile);
            if (semanticMember == null)
                return;

            var declType = semanticMember.ContainingType;
            // find all members of the same name (virt/non-virt)

            var overloads = GetSignatureOverloads(declType, signatures, semanticMember);

            contractContents = GetContractsForOverloads(overloads);


            //Give up on our contracts if we get an exception
        }
        catch (IllFormedSemanticModelException)
        {
            return;
        }
        catch (InvalidOperationException e)
        {
            if (!e.Message.Contains(VSServiceProvider.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate))
                throw e;
            else
            {
                this._textViewTracker.IsLatestCompilationStale = true;
                return;
            }
        }
        catch (System.Runtime.InteropServices.COMException)
        {
          // various reasons for COMException
          // - binding failed
          // - project unavailable
          // - ...
          return;
        }

        //Enumerate the signatures and append our custom content
        for (int i = 0; i < signatures.Count; i++) {
          var sig = signatures[i];

          if (contractContents != null && !String.IsNullOrEmpty(contractContents[i]))
          {
              signatures[i] = new SignatureWithContracts(sig, contractContents[i]);
          }
        }

        //Print our elapsed time for preformance considerations
        var elapseTime = DateTime.Now - startTime;
        VSServiceProvider.Current.Logger.WriteToLog("Time to compute quickinfo: " + elapseTime.Milliseconds + "ms");
      
      }, "AugmentSignatureHelpSession");
    }