public static EditFilter GetOrCreate(
PythonEditorServices editorServices,
ITextView textView,
IOleCommandTarget next = null
)
{
var vsTextView = editorServices.EditorAdaptersFactoryService.GetViewAdapter(textView);
return(textView.Properties.GetOrCreateSingletonProperty(() => new EditFilter(
editorServices,
vsTextView,
textView,
next
)));
}
internal BufferParser GetOrCreateBufferParser(PythonEditorServices services)
{
BufferParser parser;
if (!_bufferParser.TryGetTarget(out parser) || parser == null || parser.IsDisposed)
{
parser = new BufferParser(services, Analyzer, Path)
{
IsTemporaryFile = IsTemporaryFile,
SuppressErrorList = SuppressErrorList
};
_bufferParser.SetTarget(parser);
}
return(parser);
}
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)))
{
if (snapshotGroup.Key?.AnalysisEntry == 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 = snapshotGroup.Key.AnalysisEntry.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);
}
}
}
public UnresolvedImportSquiggleProvider(IServiceProvider serviceProvider, TaskProvider taskProvider)
{
if (taskProvider == null)
{
throw new ArgumentNullException(nameof(taskProvider));
}
_services = serviceProvider.GetComponentModel().GetService <PythonEditorServices>();
_taskProvider = taskProvider;
var options = _services.Python?.GeneralOptions;
if (options != null)
{
_enabled = options.UnresolvedImportWarning;
options.Changed += GeneralOptions_Changed;
}
}
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;
}
analyzer._analysisComplete = false;
Interlocked.Increment(ref analyzer._parsePending);
foreach (var update in updates)
{
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);
}
}
}
private EditFilter(
PythonEditorServices editorServices,
IVsTextView vsTextView,
ITextView textView,
IOleCommandTarget next
)
{
_editorServices = editorServices;
_vsTextView = vsTextView;
_textView = textView;
_next = next;
BraceMatcher.WatchBraceHighlights(_editorServices, textView);
if (_next == null)
{
ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next));
}
}
public DropDownBarClient(IServiceProvider serviceProvider, IWpfTextView textView, AnalysisEntry analysisEntry)
{
Utilities.ArgumentNotNull(nameof(serviceProvider), serviceProvider);
Utilities.ArgumentNotNull(nameof(textView), textView);
Utilities.ArgumentNotNull(nameof(analysisEntry), analysisEntry);
_serviceProvider = serviceProvider;
_uiThread = _serviceProvider.GetUIThread();
_services = _serviceProvider.GetComponentModel().GetService <PythonEditorServices>();
_analysisEntry = analysisEntry;
_textView = textView;
_services.GetBufferInfo(_textView.TextBuffer).OnNewParseTree += ParserOnNewParseTree;
_dispatcher = Dispatcher.CurrentDispatcher;
_textView.Caret.PositionChanged += CaretPositionChanged;
for (int i = 0; i < NavigationLevels; i++)
{
_curSelection[i] = -1;
}
}
public DropDownBarClient(IServiceProvider serviceProvider, ITextView textView)
{
Utilities.ArgumentNotNull(nameof(serviceProvider), serviceProvider);
Utilities.ArgumentNotNull(nameof(textView), textView);
_serviceProvider = serviceProvider;
_uiThread = _serviceProvider.GetUIThread();
_services = _serviceProvider.GetComponentModel().GetService <PythonEditorServices>();
_textView = textView;
_dispatcher = Dispatcher.CurrentDispatcher;
_textView.Caret.PositionChanged += CaretPositionChanged;
foreach (var tb in PythonTextBufferInfo.GetAllFromView(textView))
{
tb.AddSink(this, this);
}
textView.BufferGraph.GraphBuffersChanged += BufferGraph_GraphBuffersChanged;
for (int i = 0; i < NavigationLevels; i++)
{
_curSelection[i] = -1;
}
}
internal static async Task ParseBuffersAsync(
PythonEditorServices services,
VsProjectAnalyzer analyzer,
IEnumerable <ITextSnapshot> snapshots,
bool retryOnFailure
)
{
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.SelectMany(s => GetUpdatesForSnapshot(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 {
documentUri = entry.DocumentUri,
updates = updates
}
)));
}
var needRetry = new List <ITextSnapshot>();
foreach (var task in tasks)
{
var res = await task.Item2;
if (res?.failed ?? false)
{
Interlocked.Decrement(ref analyzer._parsePending);
if (res != null)
{
needRetry.AddRange(task.Item1);
}
}
else
{
analyzer.OnAnalysisStarted();
ValidateBufferContents(task.Item1, res);
}
}
if (retryOnFailure && needRetry.Any())
{
foreach (var bi in needRetry.Select(s => PythonTextBufferInfo.TryGetForBuffer(s.TextBuffer)))
{
bi.ClearSentSnapshot();
}
await ParseBuffersAsync(services, analyzer, needRetry, false);
}
}
internal DecoratorCompletionAnalysis(PythonEditorServices services, ICompletionSession session, ITextView view, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options)
: base(services, session, view, span, textBuffer, options)
{
}
internal NormalCompletionAnalysis(PythonEditorServices services, ICompletionSession session, ITextView view, ITextSnapshot snapshot, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options)
: base(services, session, view, span, textBuffer, options)
{
_snapshot = snapshot;
}
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 static CompletionAnalysis Make(PythonEditorServices services, IList <ClassificationSpan> tokens, ICompletionSession session, ITextView view, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options)
{
Debug.Assert(tokens[0].Span.GetText() == "import" || tokens[0].Span.GetText() == "from");
if (tokens.Count >= 2)
{
var ns = new List <string>();
bool expectDot = false, skipToComma = false;
foreach (var tok in tokens.SkipWhile(tok => !tok.ClassificationType.IsOfType(PredefinedClassificationTypeNames.Identifier)))
{
if (skipToComma)
{
if (tok.ClassificationType.IsOfType(PythonPredefinedClassificationTypeNames.Comma))
{
expectDot = false;
skipToComma = false;
ns.Clear();
}
}
else if (expectDot)
{
if (tok.ClassificationType.IsOfType(PythonPredefinedClassificationTypeNames.Dot))
{
expectDot = false;
}
else if (tok.ClassificationType.IsOfType(PythonPredefinedClassificationTypeNames.Comma))
{
expectDot = false;
ns.Clear();
}
else
{
skipToComma = true;
}
}
else
{
if (tok.ClassificationType.IsOfType(PredefinedClassificationTypeNames.Identifier))
{
ns.Add(tok.Span.GetText());
expectDot = true;
}
else
{
skipToComma = true;
}
}
}
if (skipToComma)
{
return(EmptyCompletionContext);
}
if (expectDot)
{
return(new AsKeywordCompletionAnalysis(services, session, view, span, textBuffer, options));
}
return(new ImportCompletionAnalysis(services, ns.ToArray(), session, view, span, textBuffer, options));
}
return(new ImportCompletionAnalysis(services, new string[0], session, view, span, textBuffer, options));
}
public PythonNavigateToItemProviderFactory(PythonEditorServices editorServices)
{
_services = editorServices;
}
public ExtractMethodSuggestedActionSourceProvider([Import] PythonEditorServices services)
{
_services = services;
}
internal StringLiteralCompletionList(PythonEditorServices services, ICompletionSession session, ITextView view, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options)
: base(services, session, view, span, textBuffer, options)
{
}
public OutliningTagger(PythonEditorServices services)
{
_services = services;
Enabled = _services.Python?.AdvancedOptions.EnterOutliningModeOnOpen ?? true;
}
public MethodExtractor(PythonEditorServices services, ITextView textView)
{
_view = textView;
_services = services;
}
public ImportKeywordCompletionAnalysis(PythonEditorServices services, ICompletionSession session, ITextView view, ITrackingSpan span, ITextBuffer buffer, CompletionOptions options)
: base(services, session, view, span, buffer, options)
{
}
public OutliningTaggerProvider([Import] PythonEditorServices services)
{
_services = services;
}
private FromImportCompletionAnalysis(PythonEditorServices services, string[] ns, bool includeStar, ICompletionSession session, ITextView view, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options)
: base(services, session, view, span, textBuffer, options)
{
_namespace = ns;
_includeStar = includeStar;
}
public PythonClassifierProvider(PythonEditorServices services)
{
_services = services;
_type = _services.ContentTypeRegistryService.GetContentType(PythonCoreConstants.ContentType);
}
public static CompletionAnalysis Make(PythonEditorServices services, IList <ClassificationSpan> tokens, ICompletionSession session, ITextView view, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options)
{
Debug.Assert(tokens[0].Span.GetText() == "from");
var ns = new List <string>();
bool nsComplete = false;
bool seenImport = false;
bool seenName = false;
bool seenAs = false;
bool seenAlias = false;
bool includeStar = true;
foreach (var token in tokens.Skip(1))
{
if (token == null || token.Span.End > span.GetEndPoint(textBuffer.CurrentSnapshot).Position)
{
break;
}
if (!seenImport)
{
if (token.ClassificationType.IsOfType(PredefinedClassificationTypeNames.Identifier))
{
ns.Add(token.Span.GetText());
nsComplete = true;
}
else if (token.ClassificationType.IsOfType(PythonPredefinedClassificationTypeNames.Dot))
{
nsComplete = false;
}
seenImport = IsKeyword(token, "import");
}
else if (token.ClassificationType.IsOfType(PythonPredefinedClassificationTypeNames.Comma))
{
seenName = false;
seenAs = false;
seenAlias = false;
includeStar = false;
}
else if (token.Span.GetText() == "*")
{
// Nothing comes after a star
return(EmptyCompletionContext);
}
else if (IsKeyword(token, "as"))
{
seenAs = true;
}
else if (token.ClassificationType.IsOfType(PredefinedClassificationTypeNames.Identifier))
{
if (seenAlias)
{
return(EmptyCompletionContext);
}
else if (seenAs)
{
seenAlias = true;
}
else if (seenName)
{
return(EmptyCompletionContext);
}
else
{
seenName = true;
}
}
else
{
includeStar = false;
}
}
if (!seenImport)
{
if (nsComplete)
{
return(new ImportKeywordCompletionAnalysis(services, session, view, span, textBuffer, options));
}
else
{
return(ImportCompletionAnalysis.Make(services, tokens, session, view, span, textBuffer, options));
}
}
if (!nsComplete || seenAlias || seenAs)
{
return(EmptyCompletionContext);
}
if (seenName)
{
return(new AsKeywordCompletionAnalysis(services, session, view, span, textBuffer, options));
}
return(new FromImportCompletionAnalysis(services, ns.ToArray(), includeStar, session, view, span, textBuffer, options));
}
public XamlTextViewCreationListener(PythonEditorServices services)
{
_services = services;
}
public PythonSuggestedActionsSource(PythonEditorServices services)
{
_services = services;
_uiThread = _services.Site.GetUIThread();
}
