private static IEnumerable <AnalysisValue> GetTestCaseClasses(IModuleAnalysis analysis) { return(analysis.GetAllMembers(SourceLocation.MinValue, GetMemberOptions.ExcludeBuiltins) .SelectMany(m => analysis.GetValues(m.Name, SourceLocation.MinValue)) .Where(v => v.MemberType == PythonMemberType.Class) .Where(v => v.Mro.SelectMany(v2 => v2).Any(IsTestCaseClass))); }
private async Task <Hover> GetSelfHoverAsync(Expression expr, IModuleAnalysis analysis, PythonAst tree, Position position, CancellationToken cancellationToken) { if (!(expr is NameExpression name) || name.Name != "self") { return(null); } var classDef = analysis.GetVariables(expr, position).FirstOrDefault(v => v.Type == VariableType.Definition); if (classDef == null) { return(null); } var instanceInfo = classDef.Variable.Types.OfType <IInstanceInfo>().FirstOrDefault(); if (instanceInfo == null) { return(null); } var cd = instanceInfo.ClassInfo.ClassDefinition; var classParams = new TextDocumentPositionParams { position = cd.NameExpression.GetStart(tree), textDocument = new TextDocumentIdentifier { uri = classDef.Location.DocumentUri } }; return(await Hover(classParams, cancellationToken)); }
public Task HandleCompletionAsync(Uri documentUri, IModuleAnalysis analysis, PythonAst tree, SourceLocation location, CompletionList completions, CancellationToken token) { Assert.IsNotNull(tree); Assert.IsNotNull(analysis); for (int i = 0; i < completions.items.Length; ++i) { completions.items[i].insertText = "*" + completions.items[i].insertText; } return(Task.CompletedTask); }
public CompletionAnalysis( IModuleAnalysis analysis, PythonAst tree, SourceLocation position, GetMemberOptions opts, ServerSettings.PythonCompletionOptions completionSettings, DocumentationBuilder textBuilder, ILogger log, Func <TextReader> openDocument ) { Analysis = analysis ?? throw new ArgumentNullException(nameof(analysis)); Tree = tree ?? throw new ArgumentNullException(nameof(tree)); Position = position; Index = Tree.LocationToIndex(Position); Options = opts; _pathResolver = analysis.ProjectState.CurrentPathResolver; _textBuilder = textBuilder; _log = log; _openDocument = openDocument; _addBrackets = completionSettings.addBrackets; var finder = new ExpressionFinder(Tree, new GetExpressionOptions { Names = true, Members = true, NamedArgumentNames = true, ImportNames = true, ImportAsNames = true, Literals = true, Errors = true }); finder.Get(Index, Index, out var node, out _statement, out _scope); var index = Index; var col = Position.Column; while (CanBackUp(Tree, node, _statement, _scope, col)) { col -= 1; index -= 1; finder.Get(index, index, out node, out _statement, out _scope); } Node = node ?? (_statement as ExpressionStatement)?.Expression; }
public static IEnumerable <BuiltinTypeId> GetTypeIdsByIndex(this IModuleAnalysis analysis, string exprText, int index) { return(analysis.GetValuesByIndex(exprText, index).Select(m => { if (m.PythonType.TypeId != BuiltinTypeId.Unknown) { return m.PythonType.TypeId; } var state = analysis.ProjectState; if (m == state._noneInst) { return BuiltinTypeId.NoneType; } var bci = m as BuiltinClassInfo; if (bci == null) { var bii = m as BuiltinInstanceInfo; if (bii != null) { bci = bii.ClassInfo; } } if (bci != null) { int count = (int)BuiltinTypeIdExtensions.LastTypeId; for (int i = 1; i <= count; ++i) { var bti = (BuiltinTypeId)i; if (!bti.IsVirtualId() && analysis.ProjectState.ClassInfos[bti] == bci) { return bti; } } } return BuiltinTypeId.Unknown; })); }
/// <summary> /// Get Test Case Members for a class. If the class has 'test*' tests /// return those. If there aren't any 'test*' tests return (if one at /// all) the runTest overridden method /// </summary> private static IEnumerable <KeyValuePair <string, ILocationInfo> > GetTestCaseMembers( PythonAst ast, string sourceFile, Uri documentUri, IModuleAnalysis analysis, AnalysisValue classValue ) { IEnumerable <KeyValuePair <string, ILocationInfo> > tests = null, runTest = null; if (ast != null && !string.IsNullOrEmpty(sourceFile)) { var walker = new TestMethodWalker(ast, sourceFile, documentUri, classValue.Locations); ast.Walk(walker); tests = walker.Methods.Where(v => v.Key.StartsWithOrdinal("test")); runTest = walker.Methods.Where(v => v.Key.Equals("runTest")); } var methodFunctions = classValue.GetAllMembers(analysis.InterpreterContext) .Where(v => v.Value.Any(m => m.MemberType == PythonMemberType.Function || m.MemberType == PythonMemberType.Method)) .Select(v => new KeyValuePair <string, ILocationInfo>(v.Key, v.Value.SelectMany(av => av.Locations).FirstOrDefault(l => l != null))); var analysisTests = methodFunctions.Where(v => v.Key.StartsWithOrdinal("test")); var analysisRunTest = methodFunctions.Where(v => v.Key.Equals("runTest")); tests = tests?.Concat(analysisTests) ?? analysisTests; runTest = runTest?.Concat(analysisRunTest) ?? analysisRunTest; if (tests.Any()) { return(tests); } else { return(runTest); } }
public static IEnumerable <IMemberResult> GetMemberByIndex(this IModuleAnalysis entry, string variable, string memberName, int index) { return(entry.GetMembersByIndex(variable, index).Where(m => m.Name == memberName)); }
public static IEnumerable <string> GetCompletionDocumentationByIndex(this IModuleAnalysis entry, string variable, string memberName, int index) { return(entry.GetMemberByIndex(variable, memberName, index).Select(m => m.Documentation)); }
public static IEnumerable <string> GetShortDescriptionsByIndex(this IModuleAnalysis entry, string variable, int index) { return(entry.GetValuesByIndex(variable, index).Select(m => m.ShortDescription)); }
public static IEnumerable <IPythonType> GetTypesByIndex(this IModuleAnalysis analysis, string exprText, int index) { return(analysis.GetValuesByIndex(exprText, index).Select(m => m.PythonType)); }
private IEnumerable <AnalysisValue> GetImportHover(IPythonProjectEntry entry, IModuleAnalysis analysis, PythonAst tree, Position position, out Hover hover) { hover = null; var index = tree.LocationToIndex(position); var w = new ImportedModuleNameWalker(entry, index, tree); tree.Walk(w); if (w.ImportedType != null) { return(analysis.GetValues(w.ImportedType.Name, position)); } var sb = new StringBuilder(); var span = SourceSpan.Invalid; foreach (var n in w.ImportedModules) { if (Analyzer.Modules.TryGetImportedModule(n.Name, out var modRef) && modRef.AnalysisModule != null) { if (sb.Length > 0) { sb.AppendLine(); sb.AppendLine(); } sb.Append(_displayTextBuilder.GetModuleDocumentation(modRef)); span = span.IsValid ? span.Union(n.SourceSpan) : n.SourceSpan; } } if (sb.Length > 0) { hover = new Hover { contents = sb.ToString(), range = span }; } return(Enumerable.Empty <AnalysisValue>()); }
public static ModuleAnalysisAssertions Should(this IModuleAnalysis moduleAnalysis) => new ModuleAnalysisAssertions(moduleAnalysis);
private static IEnumerable <IMemberResult> GetModuleVariables(ProjectEntry entry, GetMemberOptions opts, string prefix, IModuleAnalysis analysis) { var all = analysis.GetAllMembers(SourceLocation.None, opts); return(all .Where(m => { if (m.Values.Any(v => v.DeclaringModule == entry || v.Locations.Any(l => l.DocumentUri == entry.DocumentUri))) { if (string.IsNullOrEmpty(prefix) || m.Name.StartsWithOrdinal(prefix, ignoreCase: true)) { return true; } } return false; }) .Concat(GetChildScopesVariables(analysis, analysis.Scope, opts, 0))); }
private static IEnumerable <IMemberResult> GetScopeVariables(IModuleAnalysis analysis, IScope scope, GetMemberOptions opts, int currentDepth) => analysis.GetAllAvailableMembersFromScope(scope, opts).Concat(GetChildScopesVariables(analysis, scope, opts, currentDepth + 1));
private static IEnumerable <IMemberResult> GetChildScopesVariables(IModuleAnalysis analysis, IScope scope, GetMemberOptions opts, int currentDepth) => currentDepth < _symbolHierarchyDepthLimit ? scope.Children.SelectMany(c => GetScopeVariables(analysis, c, opts, currentDepth)) : Enumerable.Empty <IMemberResult>();
private static IEnumerable <IMemberResult> GetModuleVariables(ProjectEntry entry, GetMemberOptions opts, string prefix, IModuleAnalysis analysis) { var breadthFirst = analysis.Scope.TraverseBreadthFirst(s => s.Children); var all = breadthFirst.SelectMany(c => analysis.GetAllAvailableMembersFromScope(c, opts)); var result = all .Where(m => { if (m.Values.Any(v => v.DeclaringModule == entry || v.Locations .MaybeEnumerate() .ExcludeDefault() .Any(l => l.DocumentUri == entry.DocumentUri))) { return(string.IsNullOrEmpty(prefix) || m.Name.StartsWithOrdinal(prefix, ignoreCase: true)); } return(false); }) .Take(_symbolHierarchyMaxSymbols); return(result); }
public static IEnumerable <string> GetMemberNamesByIndex(this IModuleAnalysis analysis, string exprText, int index, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults) { return(analysis.GetMembersByIndex(exprText, index, options).Select(m => m.Name)); }