public ClassifierHelper(string code, PythonLanguageVersion version) { _view = new PythonEditor("", version); var providers = _view.VS.ComponentModel.GetExtensions <IClassifierProvider>().ToArray(); _provider1 = providers.OfType <PythonClassifierProvider>().Single(); _provider2 = providers.OfType <PythonAnalysisClassifierProvider>().Single(); _classificationsReady1 = new ManualResetEventSlim(); _classificationsReady2 = new ManualResetEventSlim(); AstClassifier.ClassificationChanged += (s, e) => _classificationsReady1.SetIfNotDisposed(); var startVersion = _view.CurrentSnapshot.Version; AnalysisClassifier.ClassificationChanged += (s, e) => { try { var bi = PythonTextBufferInfo.TryGetForBuffer(_view.View.TextView.TextBuffer); if (bi?.LastAnalysisReceivedVersion == null) { return; } // make sure we have classifications from the version we analyzed after // setting the text below. if (bi.LastAnalysisReceivedVersion.VersionNumber > startVersion.VersionNumber) { _classificationsReady2.SetIfNotDisposed(); } } catch (Exception ex) { _excInfo = ExceptionDispatchInfo.Capture(ex); } }; _view.Text = code; }
internal int RemoveBuffer(ITextBuffer subjectBuffer) { int result; var bi = PythonTextBufferInfo.TryGetForBuffer(subjectBuffer); lock (this) { if (bi != null) { var existing = _buffers.FirstOrDefault(b => b.Buffer == bi); if (existing != null && existing.Release()) { _buffers = _buffers.Where(b => b != existing).ToArray(); bi.RemoveSink(this); VsProjectAnalyzer.DisconnectErrorList(bi); _bufferIdMapping.Remove(bi.AnalysisBufferId); bi.SetAnalysisBufferId(-1); bi.Buffer.Properties.RemoveProperty(typeof(PythonTextBufferInfo)); } } result = _buffers.Length; } return(result); }
private static void ValidateBufferContents(IEnumerable <ITextSnapshot> snapshots, AP.FileUpdateResponse response) { #if DEBUG if (response.newCode == null) { return; } foreach (var snapshot in snapshots) { var bi = PythonTextBufferInfo.TryGetForBuffer(snapshot.TextBuffer); if (bi == null) { continue; } string newCode; if (!response.newCode.TryGetValue(bi.AnalysisBufferId, out newCode)) { continue; } if (newCode.TrimEnd() != snapshot.GetText().TrimEnd()) { Console.Error.WriteLine($"New Code: [{newCode}]"); Console.Error.WriteLine($"Snapshot: [{snapshot.GetText()}]"); Debug.Fail("Buffer content mismatch"); } } #endif }
public void BasicProjectTest() { var sln = Generator.Project( "HelloWorld", ProjectGenerator.Compile("server", "") ).Generate(); using (var vs = sln.ToMockVs()) { Assert.IsNotNull(vs.WaitForItem("HelloWorld", "Python Environments")); Assert.IsNotNull(vs.WaitForItem("HelloWorld", "References")); Assert.IsNotNull(vs.WaitForItem("HelloWorld", "Search Paths")); Assert.IsNotNull(vs.WaitForItem("HelloWorld", "server.py")); var view = vs.OpenItem("HelloWorld", "server.py"); var bi = PythonTextBufferInfo.TryGetForBuffer(view.TextView.TextBuffer); for (int retries = 20; retries > 0 && bi.AnalysisEntry == null; --retries) { Thread.Sleep(500); } view.Invoke(() => view.Type("import")); view.Invoke(() => view.Type(" ")); using (var sh = view.WaitForSession <ICompletionSession>()) { AssertUtil.Contains(sh.Session.Completions(), "sys"); } } }
private static void ValidateBufferContents(IEnumerable <ITextSnapshot> snapshots, AP.FileUpdateResponse response) { #if DEBUG if (response.newCode == null) { return; } foreach (var snapshot in snapshots) { var bi = PythonTextBufferInfo.TryGetForBuffer(snapshot.TextBuffer); if (bi == null) { continue; } string newCode; if (!response.newCode.TryGetValue(bi.AnalysisBufferId, out newCode)) { continue; } Debug.Assert(newCode.TrimEnd() == snapshot.GetText().TrimEnd(), "Buffer content mismatch"); } #endif }
internal PythonTextBufferInfo GetBufferInfo() { var bi = PythonTextBufferInfo.TryGetForBuffer(TextBuffer); Debug.Assert(bi != null, "Getting completions from uninitialized buffer " + TextBuffer.ToString()); return(bi); }
internal AnalysisEntry GetAnalysisEntry() { var bi = PythonTextBufferInfo.TryGetForBuffer(TextBuffer); Debug.Assert(bi != null, "Getting completions from uninitialized buffer " + TextBuffer.ToString()); Debug.Assert(bi?.AnalysisEntry != null, "Failed to get project entry for buffer " + TextBuffer.ToString()); return(bi?.AnalysisEntry); }
internal bool GetPrecedingExpression(out string parentExpression, out SnapshotSpan expressionExtent) { parentExpression = string.Empty; expressionExtent = default(SnapshotSpan); var bi = PythonTextBufferInfo.TryGetForBuffer(_snapshot.TextBuffer); if (bi == null) { return(false); } var span = Span.GetSpan(_snapshot); var expr = bi.GetExpressionAtPoint(span, GetExpressionOptions.EvaluateMembers); if (expr != null) { parentExpression = expr.Value.GetText() ?? ""; expressionExtent = new SnapshotSpan(expr.Value.Start, span.End); return(true); } expr = bi.GetExpressionAtPoint(span, GetExpressionOptions.Rename); if (expr != null) { expressionExtent = expr.Value; return(true); } var tok = bi.GetTokenAtPoint(span.End); if (tok == null) { expressionExtent = span; return(true); } switch (tok.Value.Category) { case TokenCategory.Delimiter: case TokenCategory.Grouping: case TokenCategory.Operator: case TokenCategory.WhiteSpace: // Expect top-level completions after these expressionExtent = span; return(true); case TokenCategory.BuiltinIdentifier: case TokenCategory.Identifier: case TokenCategory.Keyword: // Expect filtered top-level completions here // (but the return value is no different) expressionExtent = span; return(true); } return(false); }
public static Task <AnalysisEntry> GetAnalysisEntryAsync(this ITextBuffer buffer, PythonEditorServices services = null, CancellationToken cancellationToken = default(CancellationToken)) { var bi = services == null?PythonTextBufferInfo.TryGetForBuffer(buffer) : services.GetBufferInfo(buffer); if (bi != null) { return(bi.GetAnalysisEntryAsync(cancellationToken)); } return(Task.FromResult <AnalysisEntry>(null)); }
public bool TryGetAnalyzer(ITextBuffer textBuffer, out ProjectAnalyzer analyzer, out string filename) { // If we have an analyzer in Properties, we will use that // NOTE: This should only be used for tests. if (textBuffer.Properties.TryGetProperty(VsProjectAnalyzer._testAnalyzer, out analyzer)) { if (!textBuffer.Properties.TryGetProperty(VsProjectAnalyzer._testFilename, out filename)) { filename = textBuffer.GetFilePath(); } return(true); } // Fastest check is for an existing analysis entry var bufferInfo = PythonTextBufferInfo.TryGetForBuffer(textBuffer); if (bufferInfo?.AnalysisEntry != null) { analyzer = bufferInfo.AnalysisEntry.Analyzer; filename = bufferInfo.Filename; return(true); } // If we have a REPL evaluator we'll use its analyzer IPythonInteractiveIntellisense evaluator; if ((evaluator = textBuffer.GetInteractiveWindow()?.Evaluator as IPythonInteractiveIntellisense) != null) { analyzer = evaluator.Analyzer; filename = evaluator.AnalysisFilename; return(true); } // If we find an associated project, use its analyzer // This should only happen while racing with text view creation var path = PythonTextBufferInfo.TryGetForBuffer(textBuffer)?.Filename ?? textBuffer.GetFilePath(); if (path != null) { analyzer = _services.Site.GetProjectFromFile(path)?.GetAnalyzer(); if (analyzer != null) { // Don't check whether the analyzer knows about us yet, // since this request is probably finding out which analyzer // to add the file to. filename = path; return(true); } } analyzer = null; filename = null; return(false); }
private void BufferGraph_GraphBuffersChanged(object sender, VisualStudio.Text.Projection.GraphBuffersChangedEventArgs e) { foreach (var b in e.RemovedBuffers) { PythonTextBufferInfo.TryGetForBuffer(b)?.RemoveSink(typeof(DropDownBarClient)); } foreach (var b in e.AddedBuffers) { _services.GetBufferInfo(b).AddSink(typeof(DropDownBarClient), this); } }
public int GetBufferId(ITextBuffer buffer) { // May get null if there is no analysis entry associated with the file yet. // This can happen when you have a document that is open but hasn't had focus // causing the full load of our intellisense controller. In that case there // is only a single buffer which is buffer 0. An easy repro for this is to // open a IronPython WPF project and close it with the XAML file focused and // the .py file still open. Re-open the project, and double click on a button // on the XAML page. The python file isn't loaded and we have no // PythonTextBufferInfo associated with it. return(PythonTextBufferInfo.TryGetForBuffer(buffer)?.AnalysisBufferId ?? 0); }
/// <summary> /// Gets the internal analyzer object from either a text view or buffer. Both arguments /// are optional, and <c>null</c> may be passed. /// </summary> public VsProjectAnalyzer GetVsAnalyzer(ITextView view, ITextBuffer buffer) { // This function has to do everything it can to find an analyzer // without an AnalysisEntry, so that callers can use this to find // the right analyzer to create the entry for. buffer = buffer ?? view?.TextBuffer; if (buffer == null) { return(null); } // Quick check for an existing entry var bufferInfo = PythonTextBufferInfo.TryGetForBuffer(buffer); if (bufferInfo?.AnalysisEntry?.Analyzer != null) { return(bufferInfo.AnalysisEntry.Analyzer); } // If we have an analyzer in Properties, we will use that // NOTE: This should only be used for tests. ProjectAnalyzer analyzer; if (buffer.Properties.TryGetProperty(VsProjectAnalyzer._testAnalyzer, out analyzer)) { return(analyzer as VsProjectAnalyzer); } // If we have a REPL evaluator we'll use its analyzer IPythonInteractiveIntellisense evaluator; if ((evaluator = buffer.GetInteractiveWindow()?.Evaluator as IPythonInteractiveIntellisense) != null) { return(evaluator.Analyzer); } // If we find an associated project, use its analyzer // This should only happen while racing with text view creation var path = buffer.GetFilePath(); if (path != null) { analyzer = _services.Site.GetProjectFromFile(path)?.GetAnalyzer(); if (analyzer is VsProjectAnalyzer vpa) { return(vpa); } } return(null); }
public static PythonClassifier GetPythonClassifier(this ITextBuffer buffer) { var bi = PythonTextBufferInfo.TryGetForBuffer(buffer); if (bi == null) { return(null); } var provider = bi.Services.ComponentModel.GetService <PythonClassifierProvider>(); return(provider.GetClassifier(buffer) as PythonClassifier); }
internal static async Task ParseBuffersAsync( PythonEditorServices services, VsProjectAnalyzer analyzer, IEnumerable <ITextSnapshot> snapshots ) { var updates = snapshots .GroupBy(s => PythonTextBufferInfo.TryGetForBuffer(s.TextBuffer)?.AnalysisEntry.FileId ?? -1) .Where(g => g.Key >= 0) .Select(g => Tuple.Create( g.Key, g.Select(s => GetUpdateForSnapshot(services, s)).Where(u => u != null).ToArray() )) .ToList(); if (!updates.Any()) { return; } foreach (var update in updates) { if (update.Item1 < 0) { continue; } analyzer._analysisComplete = false; Interlocked.Increment(ref analyzer._parsePending); var res = await analyzer.SendRequestAsync( new AP.FileUpdateRequest() { fileId = update.Item1, updates = update.Item2 } ); if (res != null) { Debug.Assert(res.failed != true); analyzer.OnAnalysisStarted(); ValidateBufferContents(snapshots, res); } else { Interlocked.Decrement(ref analyzer._parsePending); } } }
internal static async Task ParseBuffersAsync( PythonEditorServices services, VsProjectAnalyzer analyzer, IEnumerable <ITextSnapshot> snapshots ) { var tasks = new List <Tuple <ITextSnapshot[], Task <AP.FileUpdateResponse> > >(); foreach (var snapshotGroup in snapshots.GroupBy(s => PythonTextBufferInfo.TryGetForBuffer(s.TextBuffer))) { var entry = snapshotGroup.Key?.AnalysisEntry; if (entry == null) { continue; } var updates = snapshotGroup.Select(s => GetUpdateForSnapshot(snapshotGroup.Key, s)).Where(u => u != null).ToArray(); if (!updates.Any()) { continue; } analyzer._analysisComplete = false; Interlocked.Increment(ref analyzer._parsePending); tasks.Add(Tuple.Create(snapshotGroup.ToArray(), analyzer.SendRequestAsync( new AP.FileUpdateRequest { fileId = entry.FileId, updates = updates } ))); } foreach (var task in tasks) { var res = await task.Item2; if (res != null) { Debug.Assert(res.failed != true); analyzer.OnAnalysisStarted(); ValidateBufferContents(task.Item1, res); } else { Interlocked.Decrement(ref analyzer._parsePending); } } }
private Tokenizer GetTokenizer(ITextSnapshot snapshot) { if (_tokenizers == null) { _tokenizers = new Dictionary <PythonLanguageVersion, Tokenizer>(); } Tokenizer res; var bi = PythonTextBufferInfo.TryGetForBuffer(snapshot.TextBuffer); var version = bi?.LanguageVersion ?? PythonLanguageVersion.None; if (!_tokenizers.TryGetValue(version, out res)) { _tokenizers[version] = res = new Tokenizer(version, options: TokenizerOptions.Verbatim | TokenizerOptions.VerbatimCommentsAndLineJoins); } return(res); }
public int GetDataTipText(TextSpan[] pSpan, out string pbstrText) { if (!_wpfTextView.TextBuffer.ContentType.IsOfType(PythonCoreConstants.ContentType)) { pbstrText = null; return(VSConstants.E_NOTIMPL); } if (pSpan.Length != 1) { throw new ArgumentException("Array parameter should contain exactly one TextSpan", "pSpan"); } // Adjust the span to expression boundaries. var snapshot = _wpfTextView.TextSnapshot; var pt = new SourceLocation(pSpan[0].iStartLine + 1, pSpan[0].iStartIndex + 1); var bi = PythonTextBufferInfo.TryGetForBuffer(snapshot.TextBuffer); var analyzer = bi?.AnalysisEntry?.Analyzer; if (analyzer == null) { pbstrText = null; return(VSConstants.E_FAIL); } SourceSpan?expr; try { expr = _editorServices.Site.GetUIThread().InvokeTaskSync(async() => { return(await analyzer.GetExpressionSpanAtPointAsync(bi, pt, ExpressionAtPointPurpose.Hover, TimeSpan.FromSeconds(1.0))); }, CancellationTokens.After1s); } catch (OperationCanceledException) { expr = null; } if (expr == null) { pbstrText = null; return(VSConstants.E_ABORT); } var span = expr.Value.ToSnapshotSpan(snapshot); return(_debugger.GetDataTipValue(_vsTextLines, pSpan, span.GetText(), out pbstrText)); }
public ReverseExpressionParser(ITextSnapshot snapshot, ITextBuffer buffer, ITrackingSpan span) { _snapshot = snapshot; _buffer = buffer; _span = span; var loc = span.GetSpan(snapshot); var line = _curLine = snapshot.GetLineFromPosition(loc.Start); var targetSpan = new Span(line.Start.Position, span.GetEndPoint(snapshot).Position - line.Start.Position); _classifier = PythonTextBufferInfo.TryGetForBuffer(_buffer)?.Classifier; if (_classifier == null) { throw new ArgumentException(Strings.ReverseExpressionParserFailedToGetClassifierFromBufferException); } }
/// <summary> /// Gets the analysis entry for the given buffer. /// /// This will only succeed if the buffer is a file on disk. It is not able to support things like /// difference views because we don't know what view this buffer is hosted in. This method should /// only be used when we don't know the current view for the buffer. Otherwise, use /// <see cref="TryGetAnalysisEntry(ITextView, ITextBuffer, out AnalysisEntry)"/> /// </summary> public bool TryGetAnalysisEntry(ITextBuffer textBuffer, out AnalysisEntry entry) { if (textBuffer == null) { entry = null; return(false); } // If we have a REPL evaluator we'll use its analyzer IPythonInteractiveIntellisense evaluator; if ((evaluator = textBuffer.GetInteractiveWindow()?.Evaluator as IPythonInteractiveIntellisense) != null) { entry = evaluator.Analyzer?.GetAnalysisEntryFromPath(evaluator.AnalysisFilename); if (entry != null) { return(true); } } var bufferInfo = PythonTextBufferInfo.TryGetForBuffer(textBuffer); if (bufferInfo?.AnalysisEntry != null) { entry = bufferInfo.AnalysisEntry; return(true); } // Fall back on finding the analyzer and path separately ProjectAnalyzer analyzer; string path; if (TryGetAnalyzer(textBuffer, out analyzer, out path)) { entry = (analyzer as VsProjectAnalyzer)?.GetAnalysisEntryFromPath(path); if (entry != null) { return(true); } } entry = null; return(false); }
private static void ValidateBufferContents(IEnumerable <ITextSnapshot> snapshots, Dictionary <int, string> code) { foreach (var snapshot in snapshots) { var bi = PythonTextBufferInfo.TryGetForBuffer(snapshot.TextBuffer); if (bi == null) { continue; } string newCode; if (!code.TryGetValue(bi.AnalysisEntryId, out newCode)) { continue; } Debug.Assert(newCode.TrimEnd() == snapshot.GetText().TrimEnd(), "Buffer content mismatch"); } }
private void DetachWindow(IInteractiveEvaluator oldEval) { var oldView = oldEval?.CurrentWindow?.TextView; if (oldView != null) { foreach (var buffer in oldView.BufferGraph.GetTextBuffers(EditorExtensions.IsPythonContent)) { if (oldEval.CurrentWindow.CurrentLanguageBuffer == buffer) { continue; } var tb = PythonTextBufferInfo.TryGetForBuffer(buffer); if (tb != null) { tb.DoNotParse = true; } } } }
internal int RemoveBuffer(ITextBuffer subjectBuffer) { int result; var bi = PythonTextBufferInfo.TryGetForBuffer(subjectBuffer); lock (this) { if (bi != null) { EnsureMutableBuffers(); _buffers.Remove(bi); } result = _buffers.Count; } if (bi != null) { UninitBuffer(bi); } return(result); }
protected override async Task <ExecutionResult> ResetWorkerAsync(bool initialize, bool quiet) { // suppress reporting "failed to launch repl" process var thread = Interlocked.Exchange(ref _thread, null); if (thread == null) { if (!quiet) { WriteError(Strings.ReplNotStarted); } return(ExecutionResult.Success); } foreach (var buffer in CurrentWindow.TextView.BufferGraph.GetTextBuffers(b => b.ContentType.IsOfType(PythonCoreConstants.ContentType))) { var tb = PythonTextBufferInfo.TryGetForBuffer(buffer); if (tb != null) { tb.DoNotParse = true; } } if (!quiet) { WriteOutput(Strings.ReplReset); } thread.IsProcessExpectedToExit = quiet; thread.Dispose(); var options = _serviceProvider.GetPythonToolsService().InteractiveOptions; UseSmartHistoryKeys = options.UseSmartHistory; LiveCompletionsOnly = options.LiveCompletionsOnly; EnableMultipleScopes = false; return(ExecutionResult.Success); }
internal bool GetPrecedingExpression(out string parentExpression, out SnapshotSpan expressionExtent) { parentExpression = string.Empty; expressionExtent = default(SnapshotSpan); var bi = PythonTextBufferInfo.TryGetForBuffer(_snapshot.TextBuffer); if (bi == null) { return(false); } var span = Span.GetSpan(_snapshot); var expr = bi.GetExpressionAtPoint(span, GetExpressionOptions.EvaluateMembers); if (expr != null) { parentExpression = expr.Value.GetText() ?? ""; expressionExtent = new SnapshotSpan(expr.Value.Start, span.End); return(true); } expr = bi.GetExpressionAtPoint(span, GetExpressionOptions.Rename); if (expr != null) { expressionExtent = expr.Value; return(true); } var tok = bi.GetTokenAtPoint(span.End); if (tok == null) { expressionExtent = span; return(true); } return(false); }
//public void SetAnalyzer(ITextBuffer textBuffer, VsProjectAnalyzer analyzer) { // if (textBuffer == null) { // throw new ArgumentNullException(nameof(textBuffer)); // } // // if (analyzer == null) { // textBuffer.Properties.RemoveProperty(typeof(VsProjectAnalyzer)); // return; // } // // textBuffer.Properties[typeof(VsProjectAnalyzer)] = analyzer; // // TaskCompletionSource<object> tcs; // if (textBuffer.Properties.TryGetProperty(_waitForAnalyzerKey, out tcs)) { // tcs.TrySetResult(null); // textBuffer.Properties.RemoveProperty(_waitForAnalyzerKey); // } //} /// <summary> /// Gets the analysis entry for the given view and buffer. /// /// For files on disk this is pretty easy - we analyze each file on it's own in a buffer parser. /// Therefore we map filename -> analyzer and then get the analysis from the analyzer. If we /// determine an analyzer but the file isn't loaded into it for some reason this would return null. /// We can also apply some policy to buffers depending upon the view that they're hosted in. For /// example if a buffer is outside of any projects, but hosted in a difference view with a buffer /// that is in a project, then we'll look in the view that has the project. /// /// For interactive windows we will use the analyzer that's configured for the window. /// </summary> public bool TryGetAnalysisEntry(ITextView textView, ITextBuffer textBuffer, out AnalysisEntry entry) { var bi = PythonTextBufferInfo.TryGetForBuffer(textBuffer ?? textView?.TextBuffer); if (bi == null && textView != null) { // If we have a difference viewer we'll match the LHS w/ the RHS var viewer = _diffService?.TryGetViewerForTextView(textView); if (viewer != null) { if (TryGetAnalysisEntry(viewer.DifferenceBuffer.RightBuffer, out entry)) { return(true); } if (TryGetAnalysisEntry(viewer.DifferenceBuffer.LeftBuffer, out entry)) { return(true); } } } entry = bi?.AnalysisEntry; return(entry != null); }
public async Task RenameVariable(IRenameVariableInput input, IVsPreviewChangesService previewChanges) { if (IsModuleName(input)) { input.CannotRename(Strings.RenameVariable_CannotRenameModuleName); return; } var caret = _view.GetPythonCaret(); var entry = _view.GetAnalysisAtCaret(_serviceProvider); var buffer = entry?.TryGetBufferParser()?.DefaultBufferInfo ?? PythonTextBufferInfo.TryGetForBuffer(_view.TextBuffer); if (caret == null || entry == null || buffer == null) { input.CannotRename(Strings.RenameVariable_UnableGetAnalysisCurrentTextView); return; } var analysis = await entry.Analyzer.AnalyzeExpressionAsync(entry, caret.Value, ExpressionAtPointPurpose.Rename); if (analysis == null || string.IsNullOrEmpty(analysis.Expression) || !(analysis.Variables?.Any() ?? false)) { input.CannotRename(Strings.RenameVariable_UnableGetExpressionAnalysis); return; } string privatePrefix = analysis.PrivatePrefix; var originalName = analysis.Variables .Where(r => r.Type == VariableType.Definition) .Where(r => r.Location.DocumentUri == buffer.DocumentUri && buffer.LocationTracker.CanTranslateFrom(r.Version ?? -1)) .Select(r => { var snapshot = buffer.CurrentSnapshot; try { return(buffer.LocationTracker.Translate(r.Location.Span, r.Version ?? -1, snapshot).GetText()); } catch (ArgumentException) { return(null); } }) .Where(n => !string.IsNullOrEmpty(n)) .FirstOrDefault() ?? analysis.Expression; if (analysis.PrivatePrefix != null && originalName != null && originalName.StartsWithOrdinal("_" + analysis.PrivatePrefix)) { originalName = originalName.Substring(analysis.PrivatePrefix.Length + 1); privatePrefix = analysis.PrivatePrefix; } if (originalName != null && _view.Selection.IsActive && !_view.Selection.IsEmpty) { if (_view.Selection.Start.Position < analysis.Span.GetStartPoint(_view.TextBuffer.CurrentSnapshot) || _view.Selection.End.Position > analysis.Span.GetEndPoint(_view.TextBuffer.CurrentSnapshot)) { originalName = null; } } if (originalName == null) { input.CannotRename(Strings.RenameVariable_SelectSymbol); return; } if (!analysis.Variables.Any(v => v.Type == VariableType.Definition || v.Type == VariableType.Reference)) { input.CannotRename(Strings.RenameVariable_NoInformationAvailableForVariable.FormatUI(originalName)); return; } PythonLanguageVersion languageVersion = PythonLanguageVersion.None; var analyzer = _view.GetAnalyzerAtCaret(_serviceProvider); var factory = analyzer != null ? analyzer.InterpreterFactory : null; if (factory != null) { languageVersion = factory.Configuration.Version.ToLanguageVersion(); } var info = input.GetRenameInfo(originalName, languageVersion); if (info != null) { var engine = new PreviewChangesEngine(_serviceProvider, input, analysis.Expression, info, originalName, privatePrefix, _view.GetAnalyzerAtCaret(_serviceProvider), analysis.Variables); if (info.Preview) { previewChanges.PreviewChanges(engine); } else { ErrorHandler.ThrowOnFailure(engine.ApplyChanges()); } } }
public static PythonClassifier GetPythonClassifier(this ITextBuffer buffer) { return(PythonTextBufferInfo.TryGetForBuffer(buffer)?.Classifier); }
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span) { var classifications = new List <ClassificationSpan>(); var snapshot = span.Snapshot; if (span.Length <= 0 || snapshot.IsReplBufferWithCommand()) { return(classifications); } var bi = PythonTextBufferInfo.TryGetForBuffer(snapshot.TextBuffer); if (bi == null) { return(classifications); } AP.AnalysisClassification[] spans; int fromVersion; lock (_spanCacheLock) { spans = _spanCache; fromVersion = _spanFromVersion; } if (spans == null) { if (_provider._colorNames) { if (bi?.AnalysisEntry != null && bi.AnalysisEntry.IsAnalyzed) { // Trigger the request so we get info on first open OnNewAnalysisAsync(bi, bi.AnalysisEntry).HandleAllExceptions(bi.Services.Site, GetType()).DoNotWait(); } } return(classifications); } if (spans.Length == 0) { return(classifications); } // find where in the spans we should start scanning from (they're sorted by // starting position in the old buffer) var start = bi.LocationTracker.Translate(span.Start.ToSourceLocation(), snapshot, fromVersion); var end = bi.LocationTracker.Translate(span.End.ToSourceLocation(), snapshot, fromVersion); var startIndex = Array.BinarySearch(spans, start, IndexComparer.Instance); if (startIndex < 0) { startIndex = ~startIndex - 1; if (startIndex < 0) { startIndex = 0; } } for (int i = startIndex; i < spans.Length; i++) { var spanSpan = new SourceSpan( new SourceLocation(spans[i].startLine, spans[i].startColumn), new SourceLocation(spans[i].endLine, spans[i].endColumn) ); if (spanSpan.Start > end) { // we're past the span our caller is interested in, stop scanning... break; } var cs = bi.LocationTracker.Translate(spanSpan, fromVersion, snapshot); string typeName = ToVsClassificationName(spans[i]); IClassificationType classificationType; if (typeName != null && _provider.CategoryMap.TryGetValue(typeName, out classificationType)) { classifications.Add(new ClassificationSpan(cs, classificationType)); } } return(classifications); }
public static OutliningTaggerProvider.OutliningTagger GetOutliningTagger(this ITextView self) { return(PythonTextBufferInfo.TryGetForBuffer(self.TextBuffer)?.OutliningTagger); }