public WaitForCompleteAnalysisDialog(VsProjectAnalyzer analyzer) { _analyzer = analyzer; InitializeComponent(); new Thread(AnalysisComplete).Start(); }
internal ExpressionAnalysis(VsProjectAnalyzer analyzer, string expression, ModuleAnalysis analysis, int index, ITrackingSpan span) { _expr = expression; _analysis = analysis; _index = index; _span = span; _analyzer = analyzer; }
public PreviewChangesEngine(IRenameVariableInput input, ExpressionAnalysis analysis, RenameVariableRequest request, string originalName, string privatePrefix, VsProjectAnalyzer analyzer, IEnumerable<IAnalysisVariable> variables) { _analysis = analysis; _analyzer = analyzer; _renameReq = request; _originalName = originalName; _privatePrefix = privatePrefix; _variables = variables; _input = input; _list = new PreviewList(CreatePreviewItems().ToArray()); }
private static async Task <VsProjectAnalyzer> CreateAnalyzerAsync(PythonVersion version) { version.AssertInstalled(); var factory = new MockPythonInterpreterFactory(version.Configuration); var sp = new MockServiceProvider(); var services = new Microsoft.PythonTools.Editor.PythonEditorServices(sp); var interpreters = new MockInterpreterOptionsService(); interpreters.AddProvider(new MockPythonInterpreterFactoryProvider("Test Provider", factory)); services.InterpreterRegistryService = interpreters; services.InterpreterOptionsService = interpreters; return(await VsProjectAnalyzer.CreateForTestsAsync( services, factory )); }
public AnalysisEntry( VsProjectAnalyzer analyzer, string path, int fileId, bool isTemporaryFile = false, bool suppressErrorList = false ) { Analyzer = analyzer; Path = path; FileId = fileId; Properties = new Dictionary <object, object>(); IsTemporaryFile = isTemporaryFile; SuppressErrorList = suppressErrorList; _bufferParser = new WeakReference <BufferParser>(null); }
public BufferParser(AnalysisEntry analysis, VsProjectAnalyzer parser, ITextBuffer buffer) { Debug.Assert(analysis != null); _parser = parser; _timer = new Timer(ReparseTimer, null, Timeout.Infinite, Timeout.Infinite); _buffers = new[] { buffer }; AnalysisEntry = analysis; analysis.BufferParser = this; InitBuffer(buffer, 0); // lock not necessary for _bufferInfo, no one has access to us yet... ParseBuffers(new[] { buffer.CurrentSnapshot }, new[] { _bufferInfo[buffer] }).DoNotWait(); }
public AnalysisEntry( VsProjectAnalyzer analyzer, string path, Uri documentUri, bool isTemporaryFile = false, bool suppressErrorList = false ) { Analyzer = analyzer; Path = path; DocumentUri = documentUri ?? (!string.IsNullOrEmpty(path) ? new Uri(path) : null); Properties = new Dictionary <object, object>(); IsTemporaryFile = isTemporaryFile; SuppressErrorList = suppressErrorList; _bufferParser = new WeakReference <BufferParser>(null); }
public void AnalyzeBadEgg() { var factories = new[] { InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(new Version(3, 4)) }; var services = PythonToolsTestUtilities.CreateMockServiceProvider().GetEditorServices(); using (var analyzer = new VsProjectAnalyzer(services, factories[0])) { analyzer.SetSearchPathsAsync(new[] { TestData.GetPath(@"TestData\BadEgg.egg") }).Wait(); analyzer.WaitForCompleteAnalysis(_ => true); // Analysis result must contain the module for the filename inside the egg that is a valid identifier, // and no entries for the other filename which is not. var moduleNames = analyzer.GetModulesResult(true).Result.Select(x => x.Name); AssertUtil.Contains(moduleNames, "module"); AssertUtil.DoesntContain(moduleNames, "42"); } }
public override CompletionSet GetCompletions(IGlyphService glyphService) { var start = _stopwatch.ElapsedMilliseconds; var line = Span.GetStartPoint(TextBuffer.CurrentSnapshot).GetContainingLine(); var startPos = line.Start.Position + line.GetText().IndexOf("def"); var analysis = GetAnalysisEntry(); var snapshot = TextBuffer.CurrentSnapshot; var pos = VsProjectAnalyzer.TranslateIndex(startPos, snapshot, analysis); var cls = analysis.GetDefinitionTree(pos).LastOrDefault(member => member.MemberType == Interpreter.PythonMemberType.Class); var members = analysis.GetOverrideable(pos).ToArray(); var completions = members .Select(member => PythonCompletion(glyphService, member.Name, MakeCompletionString(member, cls.Name), member.Documentation, StandardGlyphGroup.GlyphGroupOverload)); CompletionSet res; if (completions.Any()) { res = new FuzzyCompletionSet( "PythonOverrides", "Python", Span, completions, _options, CompletionComparer.UnderscoresLast ); } else { res = new CompletionSet(); } var end = _stopwatch.ElapsedMilliseconds; if (/*Logging &&*/ end - start > TooMuchTime) { Trace.WriteLine(String.Format("{0} lookup time {1} for {2} classes", this, end - start, res.Completions.Count)); } return(res); }
private async Task AnalyzeReferenceAsync(VsProjectAnalyzer interp) { if (interp == null) { _failedToAnalyze = true; return; } _failedToAnalyze = false; var resp = await interp.AddReferenceAsync(new ProjectAssemblyReference(AssemblyName, Url)); if (resp == null) { _failedToAnalyze = true; } }
internal async Task AddAnalyzedAssembly(VsProjectAnalyzer interp) { if (interp != null) { var asmName = AssemblyName; string outFile; try { outFile = ReferencedProjectOutputPath; } catch (COMException) { _failedToAnalyze = true; return; } _failedToAnalyze = false; _curReference = null; if (!string.IsNullOrEmpty(asmName)) { _asmName = new AssemblyName(asmName); _curReference = new ProjectAssemblyReference(_asmName, ReferencedProjectOutputPath); } else if (File.Exists(outFile)) { _asmName = null; _curReference = new ProjectReference(outFile, ProjectReferenceKind.ExtensionModule); } else { if (ReferencedProjectObject == null || !Utilities.GuidEquals(PythonConstants.ProjectFactoryGuid, ReferencedProjectObject.Kind)) { // Only failed if the reference isn't to another Python // project. _failedToAnalyze = true; } } if (_curReference != null) { try { await interp.AddReferenceAsync(_curReference); } catch (Exception) { _failedToAnalyze = true; } } } }
public SimpleLocationInfo(VsProjectAnalyzer analyzer, IServiceProvider serviceProvider, string searchText, AnalysisLocation locInfo, StandardGlyphGroup glyphType) { _serviceProvider = serviceProvider; _locationInfo = locInfo; _glyphType = glyphType; _pathText = GetSearchDisplayText(); AnalysisEntry entry = analyzer.GetAnalysisEntryFromPath(_locationInfo.FilePath); if (entry != null) { _lineText = entry.GetLine(_locationInfo.Line) ?? ""; } else { _lineText = ""; } }
private async Task <VsProjectAnalyzer> CreateAnalyzerAsync(IPythonInterpreterFactory factory, string location) { _site.MustBeCalledFromUIThread(); var pythonServices = _site.GetPythonToolsService(); var res = await VsProjectAnalyzer.CreateForWorkspaceAsync( pythonServices.EditorServices, factory, location ); res.AbnormalAnalysisExit += OnAnalysisProcessExited; await UpdateAnalyzerSearchPathsAsync(res); return(res); }
/// <summary> /// Implements Goto Definition. Called when the user selects Goto Definition from the /// context menu or hits the hotkey associated with Goto Definition. /// /// If there is 1 and only one definition immediately navigates to it. If there are /// no references displays a dialog box to the user. Otherwise it opens the find /// symbols dialog with the list of results. /// </summary> private async void GotoDefinition() { UpdateStatusForIncompleteAnalysis(); var caret = _textView.GetPythonCaret(); if (caret != null) { var defs = await VsProjectAnalyzer.AnalyzeExpressionAsync(_serviceProvider, _textView, caret.Value); if (defs == null) { return; } Dictionary<AnalysisLocation, SimpleLocationInfo> references, definitions, values; GetDefsRefsAndValues(_textView.GetAnalyzerAtCaret(_serviceProvider), _serviceProvider, defs.Expression, defs.Variables, out definitions, out references, out values); if ((values.Count + definitions.Count) == 1) { if (values.Count != 0) { foreach (var location in values.Keys) { GotoLocation(location); break; } } else { foreach (var location in definitions.Keys) { GotoLocation(location); break; } } } else if (values.Count + definitions.Count == 0) { if (String.IsNullOrWhiteSpace(defs.Expression)) { MessageBox.Show(String.Format("Cannot go to definition. The cursor is not on a symbol."), "Python Tools for Visual Studio"); } else { MessageBox.Show(String.Format("Cannot go to definition \"{0}\"", defs.Expression), "Python Tools for Visual Studio"); } } else if (definitions.Count == 0) { ShowFindSymbolsDialog(defs.Expression, new SymbolList("Values", StandardGlyphGroup.GlyphForwardType, values.Values)); } else if (values.Count == 0) { ShowFindSymbolsDialog(defs.Expression, new SymbolList("Definitions", StandardGlyphGroup.GlyphLibrary, definitions.Values)); } else { ShowFindSymbolsDialog(defs.Expression, new LocationCategory("Goto Definition", new SymbolList("Definitions", StandardGlyphGroup.GlyphLibrary, definitions.Values), new SymbolList("Values", StandardGlyphGroup.GlyphForwardType, values.Values) ) ); } } }
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 static void GetDefsRefsAndValues(VsProjectAnalyzer analyzer, IServiceProvider serviceProvider, string expr, IReadOnlyList <IAnalysisVariable> variables, out Dictionary <LocationInfo, SimpleLocationInfo> definitions, out Dictionary <LocationInfo, SimpleLocationInfo> references, out Dictionary <LocationInfo, SimpleLocationInfo> values) { references = new Dictionary <LocationInfo, SimpleLocationInfo>(); definitions = new Dictionary <LocationInfo, SimpleLocationInfo>(); values = new Dictionary <LocationInfo, SimpleLocationInfo>(); if (variables == null) { Debug.Fail("unexpected null variables"); return; } foreach (var v in variables) { if (v?.Location == null) { Debug.Fail("unexpected null variable or location"); continue; } if (v.Location.FilePath == null) { // ignore references in the REPL continue; } switch (v.Type) { case VariableType.Definition: values.Remove(v.Location); definitions[v.Location] = new SimpleLocationInfo(analyzer, serviceProvider, expr, v.Location, StandardGlyphGroup.GlyphGroupField); break; case VariableType.Reference: references[v.Location] = new SimpleLocationInfo(analyzer, serviceProvider, expr, v.Location, StandardGlyphGroup.GlyphGroupField); break; case VariableType.Value: if (!definitions.ContainsKey(v.Location)) { values[v.Location] = new SimpleLocationInfo(analyzer, serviceProvider, expr, v.Location, StandardGlyphGroup.GlyphGroupField); } break; } } }
public ClassifierHelper(string code, PythonLanguageVersion version) { _vs = new MockVs(); var reg = _vs.ContentTypeRegistry; var providers = _vs.ComponentModel.GetExtensions <IClassifierProvider>().ToArray(); _provider1 = providers.OfType <PythonClassifierProvider>().Single(); _provider2 = providers.OfType <PythonAnalysisClassifierProvider>().Single(); var factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()); _analyzer = new VsProjectAnalyzer(_vs.ServiceProvider, factory, new[] { factory }); _view = _vs.CreateTextView(PythonCoreConstants.ContentType, code, v => { v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), _analyzer); }); }
private void AddMissingImports(List <string> importList, SnapshotPoint point) { if (importList.Count == 0) { return; } var bi = _services.GetBufferInfo(_textView.TextBuffer); var entry = bi?.AnalysisEntry; if (entry == null) { return; } SourceLocation loc; try { var line = point.GetContainingLine(); loc = new SourceLocation( point.Position, line.LineNumber + 1, point.Position - line.Start + 1 ); } catch (ArgumentException ex) { Debug.Fail(ex.ToUnhandledExceptionMessage(GetType())); return; } foreach (var import in importList) { var isMissing = entry.Analyzer.WaitForRequest( entry.Analyzer.IsMissingImportAsync(entry, import, loc), "ExpansionClient.IsMissingImportAsync", false ); if (isMissing) { VsProjectAnalyzer.AddImport(_textView.TextBuffer, null, import); } } }
internal void AddBuffer(ITextBuffer textBuffer) { int newId; var bi = _services.GetBufferInfo(textBuffer); var entry = bi.AnalysisEntry; if (entry == null) { throw new InvalidOperationException("buffer must have a project entry before parsing"); } lock (this) { var existing = _buffers.FirstOrDefault(b => b.Buffer == bi); if (existing != null) { existing.AddRef(); return; } _buffers = _buffers.Concat(Enumerable.Repeat(new PythonTextBufferInfoWithRefCount(bi), 1)).ToArray(); newId = _buffers.Length - 1; if (!bi.SetAnalysisBufferId(newId)) { // Raced, and now the buffer belongs somewhere else. Debug.Fail("Race condition adding the buffer to a parser"); _buffers[newId] = null; return; } _bufferIdMapping[newId] = bi; } if (bi.ParseImmediately) { // Any buffer requesting immediate parsing enables it for // the whole file. _parseImmediately = true; } bi.AddSink(this, this); VsProjectAnalyzer.ConnectErrorList(bi); }
public void Invoke(CancellationToken cancellationToken) { Debug.Assert(!string.IsNullOrEmpty(_name)); AnalysisEntry entry; if (!_source._services.AnalysisEntryService.TryGetAnalysisEntry(_source._view, _buffer, out entry)) { return; } VsProjectAnalyzer.AddImport( entry, _fromModule, _name, _source._view, _buffer ); }
/// <summary> /// Gets the best analyzer for this text view, accounting for things like REPL windows and /// difference windows. /// </summary> internal static VsProjectAnalyzer GetBestAnalyzer(this ITextView textView, IServiceProvider serviceProvider) { // If we have set an analyzer explicitly, return that VsProjectAnalyzer analyzer = null; if (textView.TextBuffer.Properties.TryGetProperty(typeof(VsProjectAnalyzer), out analyzer)) { return(analyzer); } // If we have a REPL evaluator we'll use it's analyzer var evaluator = textView.TextBuffer.GetInteractiveWindow()?.Evaluator as IPythonInteractiveIntellisense; if (evaluator != null) { return(evaluator.Analyzer); } // If we have a difference viewer we'll match the LHS w/ the RHS IWpfDifferenceViewerFactoryService diffService = null; try { diffService = serviceProvider.GetComponentModel().GetService <IWpfDifferenceViewerFactoryService>(); } catch (System.ComponentModel.Composition.CompositionException) { } catch (System.ComponentModel.Composition.ImportCardinalityMismatchException) { } if (diffService != null) { var viewer = diffService.TryGetViewerForTextView(textView); if (viewer != null) { var entry = GetAnalysisEntry(null, viewer.DifferenceBuffer.LeftBuffer, serviceProvider) ?? GetAnalysisEntry(null, viewer.DifferenceBuffer.RightBuffer, serviceProvider); if (entry != null) { return(entry.Analyzer); } } } return(serviceProvider.GetPythonToolsService().DefaultAnalyzer); }
protected override void Reload() { using (new DebugTimer("Project Load")) { _intermediateOutputPath = Path.Combine(ProjectHome, GetProjectProperty("BaseIntermediateOutputPath")); if (_analyzer != null && _analyzer.RemoveUser()) { _analyzer.Dispose(); } _analyzer = new VsProjectAnalyzer(ProjectFolder); _analyzer.MaxLogLength = NodejsPackage.Instance.IntellisenseOptionsPage.AnalysisLogMax; LogAnalysisLevel(); base.Reload(); SyncFileSystem(); NodejsPackage.Instance.CheckSurveyNews(false); ModulesNode.ReloadHierarchySafe(); // scan for files which were loaded from cached analysis but no longer // exist and remove them. _analyzer.ReloadComplete(); var ignoredPaths = GetProjectProperty(NodejsConstants.AnalysisIgnoredDirectories); if (!string.IsNullOrWhiteSpace(ignoredPaths)) { _analysisIgnoredDirs = ignoredPaths.Split(';').Select(x => '\\' + x + '\\').ToArray(); } else { _analysisIgnoredDirs = new string[0]; } var maxFileSizeProp = GetProjectProperty(NodejsConstants.AnalysisMaxFileSize); int maxFileSize; if (maxFileSizeProp != null && Int32.TryParse(maxFileSizeProp, out maxFileSize)) { _maxFileSize = maxFileSize; } } }
public ITextBuffer CreatePythonTextBuffer(string input, string filePath, VsProjectAnalyzer testAnalyzer = null) { var textBufferFactory = _exportProvider.GetExportedValue <ITextBufferFactoryService>(); var textDocumentFactoryService = _exportProvider.GetExportedValue <ITextDocumentFactoryService>(); var textContentType = _exportProvider.GetExportedValue <IContentTypeRegistryService>().GetContentType(PythonCoreConstants.ContentType); var textBuffer = textBufferFactory.CreateTextBuffer(input, textContentType); textDocumentFactoryService.CreateTextDocument(textBuffer, filePath); if (testAnalyzer != null) { textBuffer.Properties.AddProperty(VsProjectAnalyzer._testAnalyzer, testAnalyzer); } textBuffer.Properties.AddProperty(VsProjectAnalyzer._testFilename, filePath); return(textBuffer); }
private async Task ExtractMethodTest(string input, Func <Span> extract, TestResult expected, string scopeName = null, string targetName = "g", Version version = null, params string[] parameters) { var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version ?? new Version(2, 7)); var editorTestToolset = new EditorTestToolset().WithPythonToolsService(); var services = editorTestToolset.GetPythonEditorServices(); using (var analyzer = await VsProjectAnalyzer.CreateForTestsAsync(services, fact)) { var analysisStartedTask = EventTaskSources.VsProjectAnalyzer.AnalysisStarted.Create(analyzer); var buffer = editorTestToolset.CreatePythonTextBuffer(input, Path.Combine(TestData.GetTempPath(), "fob.py"), analyzer); var view = editorTestToolset.CreateTextView(buffer); await analysisStartedTask; var bi = services.GetBufferInfo(buffer); bi.ParseImmediately = true; var entry = await analyzer.AnalyzeFileAsync(bi.DocumentUri, bi.Filename); Assert.AreEqual(entry, bi.TrySetAnalysisEntry(entry, null)); var bp = entry.GetOrCreateBufferParser(services); bp.AddBuffer(buffer); await bp.EnsureCodeSyncedAsync(bi.Buffer, true); ExtractMethodTestInput extractInput = new ExtractMethodTestInput(true, scopeName, targetName, parameters ?? new string[0]); await editorTestToolset.UIThread.InvokeTask(() => { view.Selection.Select(new SnapshotSpan(view.TextBuffer.CurrentSnapshot, extract()), false); return(new Microsoft.PythonTools.Refactoring.MethodExtractor(services, view).ExtractMethod(extractInput)); }); if (expected.IsError) { Assert.AreEqual(expected.Text, extractInput.FailureReason); Assert.AreEqual(input, view.TextBuffer.CurrentSnapshot.GetText()); } else { Assert.AreEqual(null, extractInput.FailureReason); Assert.AreEqual(expected.Text, view.TextBuffer.CurrentSnapshot.GetText()); } } }
private static async Task CodeFormattingTest(string input, object selection, string expected, object expectedSelection, CodeFormattingOptions options, bool selectResult = true) { var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(new Version(2, 7)); var editorTestToolset = new EditorTestToolset().WithPythonToolsService(); var services = editorTestToolset.GetPythonEditorServices(); using (var analyzer = await VsProjectAnalyzer.CreateForTestsAsync(services, fact)) { var analysisStartedTask = EventTaskSources.VsProjectAnalyzer.AnalysisStarted.Create(analyzer); var buffer = editorTestToolset.CreatePythonTextBuffer(input, analyzer); var view = editorTestToolset.CreateTextView(buffer); await analysisStartedTask; var bi = services.GetBufferInfo(buffer); var entry = await analyzer.AnalyzeFileAsync(bi.Filename); Assert.AreEqual(entry, bi.TrySetAnalysisEntry(entry, null), "Failed to set analysis entry"); entry.GetOrCreateBufferParser(services).AddBuffer(buffer); var selectionSpan = new SnapshotSpan( buffer.CurrentSnapshot, ExtractMethodTests.GetSelectionSpan(input, selection) ); editorTestToolset.UIThread.Invoke(() => view.Selection.Select(selectionSpan, false)); await analyzer.FormatCodeAsync( selectionSpan, view, options, selectResult ); Assert.AreEqual(expected, view.TextBuffer.CurrentSnapshot.GetText()); if (expectedSelection != null) { Assert.AreEqual( ExtractMethodTests.GetSelectionSpan(expected, expectedSelection), view.Selection.StreamSelectionSpan.SnapshotSpan.Span ); } } }
public async void Invoke(CancellationToken cancellationToken) { Debug.Assert(!string.IsNullOrEmpty(_name)); var entryService = _source._provider.GetEntryService(); AnalysisEntry entry; if (entryService == null || !entryService.TryGetAnalysisEntry(_source._view, _buffer, out entry)) { return; } await VsProjectAnalyzer.AddImportAsync( entry, _fromModule, _name, _source._view, _buffer ); }
private void UninitBuffer(PythonTextBufferInfo subjectBuffer) { if (subjectBuffer == null) { throw new ArgumentNullException(nameof(subjectBuffer)); } subjectBuffer.OnChangedLowPriority -= BufferChangedLowPriority; VsProjectAnalyzer.DisconnectErrorList(subjectBuffer); lock (this) { _bufferIdMapping.Remove(subjectBuffer.AnalysisEntryId); subjectBuffer.SetAnalysisEntryId(-1); } if (_document != null) { _document.EncodingChanged -= EncodingChanged; _document = null; } }
/// <summary> /// Implements Find All References. Called when the user selects Find All References from /// the context menu or hits the hotkey associated with find all references. /// /// Always opens the Find Symbol Results box to display the results. /// </summary> private async void FindAllReferences() { UpdateStatusForIncompleteAnalysis(); var caret = _textView.GetPythonCaret(); if (caret != null) { var references = await VsProjectAnalyzer.AnalyzeExpressionAsync(_serviceProvider, _textView, caret.Value); if (references == null) { return; } var locations = GetFindRefLocations(_textView.GetAnalyzerAtCaret(_serviceProvider), _serviceProvider, references.Expression, references.Variables); ShowFindSymbolsDialog(references.Expression, locations); } }
public PythonSignature(VsProjectAnalyzer analyzer, ITrackingSpan span, AP.Signature overload, int paramIndex, string lastKeywordArg = null) { _span = span; _overload = overload; _analyzer = analyzer; _listParamIndex = _dictParamIndex = int.MaxValue; if (string.IsNullOrEmpty(lastKeywordArg)) { _initialParameterIndex = paramIndex; } else { _initialParameterIndex = int.MaxValue; _initialParameterName = lastKeywordArg; } _documentation = overload.doc; }
private IEnumerable <CompletionResult> GetAvailableCompletions(PythonTextBufferInfo bufferInfo, SnapshotPoint point) { var analysis = bufferInfo.AnalysisEntry; if (analysis == null) { return(Enumerable.Empty <CompletionResult>()); } var analyzer = analysis.Analyzer; lock (analyzer) { var location = VsProjectAnalyzer.TranslateIndex( point.Position, point.Snapshot, analysis ); return(analyzer.WaitForRequest(analyzer.GetAllAvailableMembersAsync(analysis, location, _options.MemberOptions), "GetCompletions.GetAllAvailableMembers") .MaybeEnumerate()); } }
public static Dictionary <string, TagInfo> GetFilters(this VsProjectAnalyzer analyzer) { var filtersRes = analyzer.SendExtensionCommandAsync( DjangoAnalyzer.Name, DjangoAnalyzer.Commands.GetFilters, string.Empty ).WaitOrDefault(1000); var res = new Dictionary <string, TagInfo>(); if (filtersRes != null) { var filters = new JavaScriptSerializer().Deserialize <Dictionary <string, string> >(filtersRes); foreach (var filter in filters) { res[filter.Key] = new TagInfo(filter.Value, null); } } return(res); }
/* * Needed if we switch to per project Analysis levels * internal NodejsTools.Options.AnalysisLevel AnalysisLevel(){ * var analyzer = _analyzer; * if (_analyzer != null) { * return _analyzer.AnalysisLevel; * } * return NodejsTools.Options.AnalysisLevel.None; * } */ private void IntellisenseOptionsPageAnalysisLevelChanged(object sender, EventArgs e) { var oldAnalyzer = _analyzer; _analyzer = null; var analyzer = new VsProjectAnalyzer(ProjectFolder); Reanalyze(this, analyzer); if (oldAnalyzer != null) { analyzer.SwitchAnalyzers(oldAnalyzer); if (oldAnalyzer.RemoveUser()) { oldAnalyzer.Dispose(); } } _analyzer = analyzer; _analyzer.MaxLogLength = NodejsPackage.Instance.IntellisenseOptionsPage.AnalysisLogMax; LogAnalysisLevel(); }
private void UpdateDefaultAnalyzer(object sender, EventArgs args) { // no need to update if analyzer isn't created yet. if (_analyzer == null) { return; } _container.GetUIThread().InvokeAsync(() => { if (_analyzer != null) { var analyzer = CreateAnalyzer(); if (_analyzer != null) { analyzer.SwitchAnalyzers(_analyzer); } _analyzer = analyzer; } }).DoNotWait(); }
internal AnalysisQueue(VsProjectAnalyzer analyzer) { _workEvent = new AutoResetEvent(false); _cancel = new CancellationTokenSource(); _analyzer = analyzer; _queue = new List<IAnalyzable>[PriorityCount]; for (int i = 0; i < PriorityCount; i++) { _queue[i] = new List<IAnalyzable>(); } _workThread = new Thread(Worker); _workThread.Name = "J Analysis Queue"; _workThread.Priority = ThreadPriority.BelowNormal; _workThread.IsBackground = true; // start the thread, wait for our synchronization context to be created using (AutoResetEvent threadStarted = new AutoResetEvent(false)) { _workThread.Start(threadStarted); threadStarted.WaitOne(); } }
protected override void Close() { base.Close(); if (_ownsAnalyzer && _replAnalyzer != null) { _replAnalyzer.Dispose(); _replAnalyzer = null; } }
internal NormalCompletionAnalysis(VsProjectAnalyzer analyzer, ITextSnapshot snapshot, ITrackingSpan span, ITextBuffer textBuffer, CompletionOptions options) : base(span, textBuffer, options) { _snapshot = snapshot; _analyzer = analyzer; }
/*!*/ internal static IReplWindow EnsureReplWindow(VsProjectAnalyzer analyzer) { return EnsureReplWindow(analyzer.InterpreterFactory); }
public BufferParser(Dispatcher dispatcher, IProjectEntry initialProjectEntry, VsProjectAnalyzer parser, ITextBuffer buffer) { _parser = parser; _timer = new Timer(ReparseTimer, null, Timeout.Infinite, Timeout.Infinite); _buffers = new[] { buffer }; _currentProjEntry = initialProjectEntry; _dispatcher = dispatcher; InitBuffer(buffer); }
/// <summary> /// Creates a new parse queue which will parse using the provided parser. /// </summary> /// <param name="parser"></param> public ParseQueue(VsProjectAnalyzer parser) { _parser = parser; }
protected override void Connect() { _interpreter = GetInterpreterFactory(); var processInfo = new ProcessStartInfo(Path.Combine(JToolsPackage.GetJToolsInstallPath(), (Interpreter.Configuration.Architecture == ProcessorArchitecture.X86 ? "j32" : "j64"), "J.Console.exe")); #if DEBUG const string debugReplEnv = "DEBUG_REPL"; Environment.SetEnvironmentVariable(debugReplEnv, "true"); bool debugMode = Environment.GetEnvironmentVariable(debugReplEnv) != null; processInfo.CreateNoWindow = !debugMode; processInfo.UseShellExecute = debugMode; processInfo.RedirectStandardOutput = !debugMode; processInfo.RedirectStandardError = !debugMode; processInfo.RedirectStandardInput = !debugMode; #else processInfo.CreateNoWindow = true; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = true; processInfo.RedirectStandardError = true; processInfo.RedirectStandardInput = true; #endif Socket conn; int portNum; CreateConnection(out conn, out portNum); List<string> args = new List<string>(); if (!String.IsNullOrWhiteSpace(InterpreterOptions)) { args.Add(InterpreterOptions); } string filename, dir, extraArgs = null; VsProjectAnalyzer analyzer; if (JToolsPackage.TryGetStartupFileAndDirectory(out filename, out dir, out analyzer)) { processInfo.WorkingDirectory = dir; var startupProj = JToolsPackage.GetStartupProject(); if (startupProj != null) { string searchPath = startupProj.GetProjectProperty(CommonConstants.SearchPath, true); string pathEnvVar = Interpreter.Configuration.PathEnvironmentVariable; if (!string.IsNullOrEmpty(searchPath) && !String.IsNullOrWhiteSpace(pathEnvVar)) { processInfo.EnvironmentVariables[pathEnvVar] = searchPath; } string interpArgs = startupProj.GetProjectProperty(CommonConstants.InterpreterArguments, true); if (!String.IsNullOrWhiteSpace(interpArgs)) { args.Add(interpArgs); } extraArgs = startupProj.GetProjectProperty(CommonConstants.CommandLineArguments, true); } if (analyzer.InterpreterFactory == _interpreter) { if (_replAnalyzer != null && _replAnalyzer != analyzer) { analyzer.SwitchAnalyzers(_replAnalyzer); } _replAnalyzer = analyzer; _ownsAnalyzer = false; } } //args.Add("\"" + Path.Combine(JToolsPackage.GetJToolsInstallPath(), "visualstudio_py_repl.py") + "\""); args.Add("--port"); args.Add(portNum.ToString()); args.Add("-r"); if (!String.IsNullOrWhiteSpace(StartupScript)) { args.Add("--launch_file"); args.Add("\"" + StartupScript + "\""); } _enableAttach = EnableAttach; if (EnableAttach) { args.Add("--enable-attach"); } bool multipleScopes = true; if (!String.IsNullOrWhiteSpace(ExecutionMode)) { // change ID to module name if we have a registered mode var modes = J.Tools.Options.ExecutionMode.GetRegisteredModes(); string modeValue = ExecutionMode; foreach (var mode in modes) { if (mode.Id == ExecutionMode) { modeValue = mode.Type; multipleScopes = mode.SupportsMultipleScopes; break; } } args.Add("--execution_mode"); args.Add(modeValue); } SetMultipleScopes(multipleScopes); processInfo.Arguments = String.Join(" ", args); var process = new Process(); process.StartInfo = processInfo; try { process.Start(); } catch (Exception e) { Window.WriteError(String.Format("Failed to start interactive process: {0}{1}{2}", Environment.NewLine, e.ToString(), Environment.NewLine)); return; } CreateCommandProcessor(conn, null, processInfo.RedirectStandardOutput, process); }
internal void RecreateAnalyzer() { if (_analyzer != null) { _analyzer.Dispose(); } _analyzer = CreateAnalyzer(); }
internal static bool TryGetStartupFileAndDirectory(out string filename, out string dir, out VsProjectAnalyzer analyzer) { var startupProject = GetStartupProject(); if (startupProject != null) { filename = startupProject.GetStartupFile(); dir = startupProject.GetWorkingDirectory(); analyzer = ((JProjectNode)startupProject).GetAnalyzer(); } else { var textView = CommonPackage.GetActiveTextView(); if (textView == null) { filename = null; dir = null; analyzer = null; return false; } filename = textView.GetFilePath(); analyzer = textView.GetAnalyzer(); dir = Path.GetDirectoryName(filename); } return true; }