public GeneratorInfo(PythonAnalyzer projectState, IPythonProjectEntry entry) : base(projectState.ClassInfos[BuiltinTypeId.Generator]) { _declaringModule = entry; _declaringVersion = entry.AnalysisVersion; Yields = new VariableDef(); Sends = new VariableDef(); Returns = new VariableDef(); }
public CoroutineInfo(PythonAnalyzer projectState, IPythonProjectEntry entry) : base(projectState.ClassInfos[BuiltinTypeId.Generator]) { // Internally, coroutines are represented by generators with a CO_* // flag on the code object. Here we represent it as a separate info, // but reuse the underlying class info. _declaringModule = entry; _declaringVersion = entry.AnalysisVersion; Returns = new VariableDef(); }
public DropDownBarClient(IWpfTextView textView, IPythonProjectEntry pythonProjectEntry) { Utilities.ArgumentNotNull("textView", textView); Utilities.ArgumentNotNull("pythonProjectEntry", pythonProjectEntry); _projectEntry = pythonProjectEntry; _projectEntry.OnNewParseTree += ParserOnNewParseTree; _textView = textView; _topLevelEntries = _nestedEntries = EmptyEntries; _dispatcher = Dispatcher.CurrentDispatcher; _textView.Caret.PositionChanged += CaretPositionChanged; }
private ReadOnlyCollection<DropDownEntryInfo> _topLevelEntries; // entries for top-level members of the file #endregion Fields #region Constructors public DropDownBarClient(IWpfTextView textView, IPythonProjectEntry classifier) { Debug.Assert(textView != null); Debug.Assert(classifier != null); _classifier = classifier; _classifier.OnNewParseTree += ParserOnNewParseTree; _textView = textView; _topLevelEntries = _nestedEntries = EmptyEntries; _dispatcher = Dispatcher.CurrentDispatcher; _textView.Caret.PositionChanged += CaretPositionChanged; }
public FunctionScope( FunctionInfo function, Node node, InterpreterScope declScope, IPythonProjectEntry declModule ) : base(function, node, declScope) { ReturnValue = new VariableDef(); if (Function.FunctionDefinition.IsCoroutine) { Coroutine = new CoroutineInfo(function.ProjectState, declModule); ReturnValue.AddTypes(function.ProjectEntry, Coroutine.SelfSet, false); } else if (Function.FunctionDefinition.IsGenerator) { Generator = new GeneratorInfo(function.ProjectState, declModule); ReturnValue.AddTypes(function.ProjectEntry, Generator.SelfSet, false); } }
internal FunctionAnalysisUnit( FunctionInfo function, AnalysisUnit declUnit, InterpreterScope declScope, IPythonProjectEntry declEntry ) : base(function.FunctionDefinition, null) { _declUnit = declUnit; Function = function; _decoratorCalls = new Dictionary<Node, Expression>(); var scope = new FunctionScope(Function, Function.FunctionDefinition, declScope, declEntry); scope.EnsureParameters(this); _scope = scope; AnalysisLog.NewUnit(this); }
public T GetValue <T>(IPythonProjectEntry module, string variable, int index = 0) where T : AnalysisValue { var rs = module.Analysis.GetValuesByIndex(variable, index).ToArray(); if (rs.Length == 0) { Assert.Fail("'{0}.{1}' had no variables".FormatInvariant(module.ModuleName, variable)); } else if (rs.Length > 1) { foreach (var r in rs) { Trace.TraceInformation(r.ToString()); } Assert.Fail("'{0}.{1}' had multiple values: {2}".FormatInvariant(module.ModuleName, variable, AnalysisSet.Create(rs))); } else { Assert.IsInstanceOfType(rs[0], typeof(T), "'{0}.{1}' was not expected type".FormatInvariant(module.ModuleName, variable)); return((T)rs[0]); } return(default(T)); }
internal FunctionAnalysisUnit( FunctionInfo function, AnalysisUnit declUnit, InterpreterScope declScope, IPythonProjectEntry declEntry, bool concreteParameters ) : base(function.FunctionDefinition, null) { _declUnit = declUnit; Function = function; _concreteParameters = concreteParameters; _decoratorCalls = new Dictionary <Node, Expression>(); var scope = new FunctionScope(Function, Function.FunctionDefinition, declScope, declEntry); _scope = scope; if (GetType() == typeof(FunctionAnalysisUnit)) { AnalysisLog.NewUnit(this); } }
internal AggregateProjectEntry AggregateWith(IPythonProjectEntry with) { if (_aggregating.Contains(with)) { // we're not adding any new types return(this); } if (_next == null) { _next = new Dictionary <IProjectEntry, AggregateProjectEntry>(); } AggregateProjectEntry entry; if (!_next.TryGetValue(with, out entry)) { // We don't yet have the next transition, create it now. _next[with] = entry = with.ProjectState.GetAggregate(_aggregating, with); } return(entry); }
private SaveLoadResult SaveLoad(PythonLanguageVersion version, params AnalysisModule[] modules) { IPythonProjectEntry[] entries = new IPythonProjectEntry[modules.Length]; var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()); var interp = fact.CreateInterpreter(); var dbFolder = TestData.GetTempPath(randomSubPath: true); Directory.CreateDirectory(dbFolder); var state = new PythonAnalysis(fact, interp, SharedDatabaseState.BuiltinName2x); state.CreateProjectOnDisk = true; for (int i = 0; i < modules.Length; i++) { state.AddModule(modules[i].ModuleName, modules[i].Code, modules[i].Filename); } state.WaitForAnalysis(); new SaveAnalysis().Save(state.Analyzer, dbFolder); File.Copy( Path.Combine(PythonTypeDatabase.BaselineDatabasePath, "__builtin__.idb"), Path.Combine(dbFolder, "__builtin__.idb"), true ); var loadFactory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory( version.ToVersion(), null, dbFolder ); return(new SaveLoadResult(CreateAnalyzer(loadFactory), state.CodeFolder)); }
private static IEnumerable <MemberResult> GetModuleVariables( IPythonProjectEntry entry, GetMemberOptions opts, string prefix ) { var analysis = entry?.Analysis; if (analysis == null) { yield break; } foreach (var m in analysis.GetAllAvailableMembers(SourceLocation.None, opts)) { if (m.Values.Any(v => v.DeclaringModule == entry)) { if (string.IsNullOrEmpty(prefix) || m.Name.StartsWithOrdinal(prefix, ignoreCase: true)) { yield return(m); } } } }
public void AssertAttrIsType(IPythonProjectEntry module, string variable, string memberName, params PythonMemberType[] types) { AssertAttrIsType(module, variable, memberName, 0, types); }
public void AssertIsInstance(IPythonProjectEntry module, string expr, params BuiltinTypeId[] types) { AssertIsInstance(module, expr, 0, types); }
public void AssertIsInstance(IPythonProjectEntry module, string expr) { AssertIsInstance(module, expr, 0); }
public void AssertHasAttrExact(IPythonProjectEntry module, string expr, int index, params string[] attrs) { AssertUtil.ContainsExactly(GetMemberNames(module, expr, index), attrs); }
public IOverloadResult[] GetOverrideable(IPythonProjectEntry module, int index = 0) { return(module.Analysis.GetOverrideableByIndex(index).ToArray()); }
public AnalysisValue[] GetValues(IPythonProjectEntry module, string variable, int index = 0) { return(module.Analysis.GetValuesByIndex(variable, index).ToArray()); }
public void AssertConstantEquals(IPythonProjectEntry module, string expr, int index, string value) { var val = GetValue <AnalysisValue>(module, expr, index); Assert.AreEqual(val?.GetConstantValueAsString(), value, "{0}.{1}".FormatInvariant(module.ModuleName, expr)); }
private SaveLoadResult SaveLoad(PythonLanguageVersion version, params AnalysisModule[] modules) { IPythonProjectEntry[] entries = new IPythonProjectEntry[modules.Length]; var fact = InterpreterFactory; var interp = Interpreter; if (version != fact.GetLanguageVersion()) { fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()); interp = fact.CreateInterpreter(); } var codeFolder = TestData.GetTempPath(randomSubPath: true); var dbFolder = Path.Combine(codeFolder, "DB"); Directory.CreateDirectory(codeFolder); Directory.CreateDirectory(dbFolder); var state = PythonAnalyzer.CreateSynchronously(fact, interp, SharedDatabaseState.BuiltinName2x); for (int i = 0; i < modules.Length; i++) { var fullname = Path.Combine(codeFolder, modules[i].Filename); File.WriteAllText(fullname, modules[i].Code); entries[i] = state.AddModule(modules[i].ModuleName, fullname); Prepare(entries[i], new StringReader(modules[i].Code), version); } for (int i = 0; i < modules.Length; i++) { entries[i].Analyze(CancellationToken.None, false); } new SaveAnalysis().Save(state, dbFolder); File.Copy( Path.Combine(PythonTypeDatabase.BaselineDatabasePath, "__builtin__.idb"), Path.Combine(dbFolder, "__builtin__.idb"), true ); var loadFactory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory( version.ToVersion(), null, dbFolder ); return new SaveLoadResult(PythonAnalyzer.CreateSynchronously(loadFactory), codeFolder); }
internal static bool TryGetPythonAnalysis(this ITextBuffer buffer, out IPythonProjectEntry analysis) { IProjectEntry entry; if (buffer.TryGetAnalysis(out entry) && (analysis = entry as IPythonProjectEntry) != null) { return true; } analysis = null; return false; }
public AstScopeNode(PythonAst pythonAst, IPythonProjectEntry projectEntry) { _ast = pythonAst; _projectEntry = projectEntry; }
public static void Prepare(IPythonProjectEntry entry, TextReader sourceUnit, PythonLanguageVersion version = PythonLanguageVersion.V27) { using (var parser = Parser.CreateParser(sourceUnit, version, new ParserOptions() { BindReferences = true })) { entry.UpdateTree(parser.ParseFile(), null); } }
/// <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, IAnalysisSet>> GetTestCaseMembers( IPythonProjectEntry entry, AnalysisValue classValue ) { var methodFunctions = classValue.GetAllMembers(entry.Analysis.InterpreterContext) .Where(v => v.Value.Any(m => m.MemberType == PythonMemberType.Function || m.MemberType == PythonMemberType.Method)); var tests = methodFunctions.Where(v => v.Key.StartsWith("test")); var runTest = methodFunctions.Where(v => v.Key.Equals("runTest")); if (tests.Any()) { return tests; } else { return runTest; } }
private static IEnumerable<AnalysisValue> GetTestCaseClasses(IPythonProjectEntry entry) { if (entry.IsAnalyzed) { return entry.Analysis.GetAllAvailableMembersByIndex(0) .SelectMany(m => entry.Analysis.GetValuesByIndex(m.Name, 0)) .Where(v => v.MemberType == PythonMemberType.Class) .Where(v => v.Mro.SelectMany(v2 => v2).Any(IsTestCaseClass)); } else { return Enumerable.Empty<AnalysisValue>(); } }
public void AssertDescription(IPythonProjectEntry module, string expr, string description) { AssertDescription(module, expr, 0, description); }
public void AssertDescriptionContains(IPythonProjectEntry module, string expr, int index, params string[] description) { var val = GetValue <AnalysisValue>(module, expr, index); AssertUtil.Contains(val?.Description, description); }
public TagInfo(string doc, IPythonProjectEntry entry) { Documentation = doc; Entry = entry; }
private static void AnalyzeCode( out PythonAnalyzer analyzer, out IPythonProjectEntry entry, string code, Version preferredVersion = null, InterpreterArchitecture preferredArch = null, string module = "test-module" ) { var provider = InterpFactory; var factory = provider.GetInterpreterFactories().OrderByDescending(f => f.Configuration.Version) .Where(f => preferredVersion == null || f.Configuration.Version == preferredVersion) .Where(f => preferredArch == null || f.Configuration.Architecture == preferredArch) .FirstOrDefault(); Assert.IsNotNull(factory, "no factory found"); analyzer = PythonAnalyzer.CreateSynchronously(factory); var path = Path.Combine(TestData.GetTempPath(randomSubPath: true), module.Replace('.', '\\')); Directory.CreateDirectory(PathUtils.GetParent(path)); File.WriteAllText(path, code); entry = analyzer.AddModule(module, path); PythonAst ast; using (var p = Parser.CreateParser(new StringReader(code), factory.GetLanguageVersion())) { ast = p.ParseFile(); entry.UpdateTree(ast, null); } entry.Analyze(CancellationToken.None, true); }
private void BufferContentTypeChanged(object sender, ContentTypeChangedEventArgs e) { _spanCache = null; _buffer.Changed -= BufferChanged; _buffer.ContentTypeChanged -= BufferContentTypeChanged; if (_entry != null) { _entry.OnNewAnalysis -= OnNewAnalysis; _entry = null; } _buffer.Properties.RemoveProperty(typeof(PythonAnalysisClassifier)); }
public IOverloadResult[] GetSignatures(IPythonProjectEntry module, string exprText, int index = 0) { return(module.Analysis.GetSignaturesByIndex(exprText, index).ToArray()); }
private static void UpdateAnalysisTree(IPythonProjectEntry pyEntry, SortedDictionary<int, ParseResult> parseResults) { IAnalysisCookie cookie = new VersionCookie( parseResults.ToDictionary( x => x.Key, x => new BufferVersion(x.Value.Version, x.Value.Ast) ) ); var asts = parseResults.Where(x => x.Value.Ast != null).Select(x => x.Value.Ast).ToArray(); PythonAst finalAst; if (asts.Length == 1) { finalAst = asts[0]; } else if (asts.Length > 0) { // multiple ASTs, merge them together finalAst = new PythonAst( new SuiteStatement( asts.Select(ast => ast.Body).ToArray() ), new NewLineLocation[0], asts[0].LanguageVersion ); } else { // we failed to get any sort of AST out, so we can't analyze... // But we need to balance the UpdateTree call, so just fetch the // last valid ast and cookie. pyEntry.GetTreeAndCookie(out finalAst, out cookie); } pyEntry.UpdateTree(finalAst, cookie); }
public void AssertNotHasAttr(IPythonProjectEntry module, string expr, int index, params string[] attrs) { AssertUtil.DoesntContain(GetMemberNames(module, expr, index), attrs); }
private async void SendParseComplete(IPythonProjectEntry entry, SortedDictionary<int, ParseResult> parseResults) { await _connection.SendEventAsync( new AP.FileParsedEvent() { fileId = ProjectEntryMap.GetId(entry), buffers = parseResults.Select( x => new AP.BufferParseInfo() { bufferId = x.Key, version = x.Value.Version, errors = x.Value.Errors.Errors.Select(MakeError).ToArray(), warnings = x.Value.Errors.Warnings.Select(MakeError).ToArray(), hasErrors = x.Value.Errors.Errors.Any(), tasks = x.Value.Tasks.ToArray() } ).ToArray() } ); }
public void AssertHasParameters(IPythonProjectEntry module, string expr, int index, params string[] paramNames) { AssertUtil.AreEqual(module.Analysis.GetSignaturesByIndex(expr, index).Single().Parameters.Select(p => p.Name), paramNames); }
public ImportStatementWalker(PythonAst ast, IPythonProjectEntry entry, PythonAnalyzer analyzer) { _ast = ast; _entry = entry; _analyzer = analyzer; }
public void AssertIsInstance(IPythonProjectEntry module, string expr, int index) { AssertIsInstance(module, expr, index, Array.Empty <BuiltinTypeId>()); }
public ImportStatementWalker(IPythonProjectEntry entry, PythonAnalyzer analyzer) { _entry = entry; _analyzer = analyzer; }
public void AssertIsInstance(IPythonProjectEntry module, string expr, params string[] className) { AssertIsInstance(module, expr, 0, className); }
public void ListenForNextNewAnalysis(IPythonProjectEntry entry) { if (entry != null && !string.IsNullOrEmpty(entry.FilePath)) { entry.OnNewAnalysis += OnNewAnalysis; } }
public void AssertAttrIsType(IPythonProjectEntry module, string variable, string memberName, int index, params PythonMemberType[] types) { AssertUtil.ContainsExactly(GetMember(module, variable, memberName, index).Select(m => m.MemberType), types); }
public SysModulesDictionaryInfo(SysModuleInfo owner, IPythonProjectEntry declaringModule, Node node) : base(declaringModule, node) { _owner = owner; }
public void AssertDescriptionContains(IPythonProjectEntry module, string expr, params string[] description) { AssertDescriptionContains(module, expr, 0, description); }
public SingleIteratorValue(VariableDef indexTypes, BuiltinClassInfo iterType, IPythonProjectEntry declModule) : base(iterType) { _indexTypes = indexTypes; _declModule = declModule; }
public void AssertConstantEquals(IPythonProjectEntry module, string expr, string value) { AssertConstantEquals(module, expr, 0, value); }
private void RegisterTag(IPythonProjectEntry entry, Dictionary<string, TagInfo> tags, string name, string documentation = null) { TagInfo tag; if (!tags.TryGetValue(name, out tag) || (String.IsNullOrWhiteSpace(tag.Documentation) && !String.IsNullOrEmpty(documentation))) { tags[name] = tag = new TagInfo(documentation, entry); if (entry != null && _hookedEntries.Add(entry)) { entry.OnNewParseTree += OnNewParseTree; } } }
public void AssertReferencesInclude(IPythonProjectEntry module, string expr, int index, params VariableLocation[] expectedVars) { AssertReferencesWorker(module, expr, index, false, expectedVars); }
private IEnumerable<IPythonProjectEntry[]> MakeModulePermutations(string prefix, string[] code) { foreach (var p in Permutations(code.Length)) { var result = new IPythonProjectEntry[code.Length]; using (var state = PythonAnalyzer.CreateSynchronously(InterpreterFactory, Interpreter)) { state.Limits = GetLimits(); for (int i = 0; i < code.Length; i++) { result[p[i]] = state.AddModule(prefix + (p[i] + 1).ToString(), "fob", null); } for (int i = 0; i < code.Length; i++) { Prepare(result[p[i]], GetSourceUnit(code[p[i]])); } for (int i = 0; i < code.Length; i++) { result[p[i]].Analyze(CancellationToken.None, true); } state.AnalyzeQueuedEntries(CancellationToken.None); yield return result; } } }
/// <summary> /// Returns a sequence of candidate absolute module names for the given /// modules. /// </summary> /// <param name="projectEntry"> /// The project entry that is importing the module. /// </param> /// <param name="relativeModuleName"> /// A dotted name identifying the path to the module. /// </param> /// <returns> /// A sequence of strings representing the absolute names of the module /// in order of precedence. /// </returns> internal static IEnumerable <string> ResolvePotentialModuleNames( IPythonProjectEntry projectEntry, string relativeModuleName, bool absoluteImports ) { string importingFrom = null; if (projectEntry != null) { importingFrom = projectEntry.ModuleName; if (ModulePath.IsInitPyFile(projectEntry.FilePath)) { if (string.IsNullOrEmpty(importingFrom)) { importingFrom = "__init__"; } else { importingFrom += ".__init__"; } } } if (string.IsNullOrEmpty(relativeModuleName)) { yield break; } // Handle relative module names if (relativeModuleName.FirstOrDefault() == '.') { if (string.IsNullOrEmpty(importingFrom)) { // No source to import relative to. yield break; } var prefix = importingFrom.Split('.'); if (relativeModuleName.LastOrDefault() == '.') { // Last part empty means the whole name is dots, so there's // nothing to concatenate. yield return(string.Join(".", prefix.Take(prefix.Length - relativeModuleName.Length))); } else { var suffix = relativeModuleName.Split('.'); var dotCount = suffix.TakeWhile(bit => string.IsNullOrEmpty(bit)).Count(); if (dotCount < prefix.Length) { // If we have as many dots as prefix parts, the entire // name will disappear. Despite what PEP 328 says, in // reality this means the import will fail. yield return(string.Join(".", prefix.Take(prefix.Length - dotCount).Concat(suffix.Skip(dotCount)))); } } yield break; } // The two possible names that can be imported here are: // * relativeModuleName // * importingFrom.relativeModuleName // and the order they are returned depends on whether // absolute_import is enabled or not. // With absolute_import, we treat the name as complete first. if (absoluteImports) { yield return(relativeModuleName); } if (!string.IsNullOrEmpty(importingFrom)) { var prefix = importingFrom.Split('.'); if (prefix.Length > 1) { var adjacentModuleName = string.Join(".", prefix.Take(prefix.Length - 1)) + "." + relativeModuleName; yield return(adjacentModuleName); } } // Without absolute_import, we treat the name as complete last. if (!absoluteImports) { yield return(relativeModuleName); } }
private SaveLoadResult SaveLoad(PythonLanguageVersion version, params AnalysisModule[] modules) { IPythonProjectEntry[] entries = new IPythonProjectEntry[modules.Length]; var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()); var interp = fact.CreateInterpreter(); var dbFolder = TestData.GetTempPath(randomSubPath: true); Directory.CreateDirectory(dbFolder); var state = new PythonAnalysis(fact, interp, SharedDatabaseState.BuiltinName2x); state.CreateProjectOnDisk = true; for (int i = 0; i < modules.Length; i++) { state.AddModule(modules[i].ModuleName, modules[i].Code, modules[i].Filename); } state.WaitForAnalysis(); new SaveAnalysis().Save(state.Analyzer, dbFolder); File.Copy( Path.Combine(PythonTypeDatabase.BaselineDatabasePath, "__builtin__.idb"), Path.Combine(dbFolder, "__builtin__.idb"), true ); var loadFactory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory( version.ToVersion(), null, dbFolder ); return new SaveLoadResult(CreateAnalyzer(loadFactory), state.CodeFolder); }
public void StopListening(IPythonProjectEntry entry) { if (entry != null) { entry.OnNewAnalysis -= OnNewAnalysis; _taskProvider.Clear(entry, VsProjectAnalyzer.UnresolvedImportMoniker); } }
public StarArgsDictionaryInfo(IPythonProjectEntry declaringModule, Node node) : base(declaringModule, node) { }
public ImportedModuleNameWalker(IPythonProjectEntry entry, int location, PythonAst ast) : this(entry.ModuleName, entry.FilePath, location, ast) { }
internal void UpdateProjectEntry(IProjectEntry newEntry) { if (newEntry is IPythonProjectEntry) { _projectEntry.OnNewParseTree -= ParserOnNewParseTree; _projectEntry = (IPythonProjectEntry)newEntry; _projectEntry.OnNewParseTree += ParserOnNewParseTree; } }
public TagInfo(string doc, IPythonProjectEntry entry) { Documentation = doc; Entry = entry; }
public IEnumerable <string> GetAllNames(IPythonProjectEntry module, int index = 0) { return(module.Analysis.GetAllAvailableMembers(SourceLocation.MinValue).Select(m => m.Name)); }
public PartialFunctionInfo(ProjectEntry declProjEntry, IAnalysisSet function, IAnalysisSet[] args, NameExpression[] keywordArgNames) { _declProjEntry = declProjEntry; _function = function; _args = args; _keywordArgNames = keywordArgNames; }
public IEnumerable <string> GetNamesNoBuiltins(IPythonProjectEntry module, int index = 0) { return(module.Analysis.GetVariablesNoBuiltinsByIndex(index)); }