private void AssignVariables(FromImportStatement node, IImportSearchResult imports, PythonVariableModule variableModule) { if (variableModule == null) { return; } var names = node.Names; var asNames = node.AsNames; if (names.Count == 1 && names[0].Name == "*") { // TODO: warn this is not a good style per // TODO: https://docs.python.org/3/faq/programming.html#what-are-the-best-practices-for-using-import-in-a-module // TODO: warn this is invalid if not in the global scope. HandleModuleImportStar(variableModule); return; } for (var i = 0; i < names.Count; i++) { var memberName = names[i].Name; if (!string.IsNullOrEmpty(memberName)) { var variableName = asNames[i]?.Name ?? memberName; var value = variableModule.GetMember(memberName) ?? GetValueFromImports(variableModule, imports as IImportChildrenSource, memberName); Eval.DeclareVariable(variableName, value, VariableSource.Import, names[i]); } } }
private void AssignVariables(FromImportStatement node, IImportSearchResult imports, PythonVariableModule variableModule) { if (variableModule == null) { return; } var names = node.Names; var asNames = node.AsNames; if (names.Count == 1 && names[0].Name == "*") { // TODO: warn this is not a good style per // TODO: https://docs.python.org/3/faq/programming.html#what-are-the-best-practices-for-using-import-in-a-module // TODO: warn this is invalid if not in the global scope. HandleModuleImportStar(variableModule, imports is ImplicitPackageImport, node.StartIndex); return; } for (var i = 0; i < names.Count; i++) { var memberName = names[i].Name; if (!string.IsNullOrEmpty(memberName)) { var nameExpression = asNames[i] ?? names[i]; var variableName = nameExpression?.Name ?? memberName; var variable = variableModule.Analysis?.GlobalScope?.Variables[memberName]; var exported = variable ?? variableModule.GetMember(memberName); var value = exported ?? GetValueFromImports(variableModule, imports as IImportChildrenSource, memberName); // Do not allow imported variables to override local declarations Eval.DeclareVariable(variableName, value, VariableSource.Import, nameExpression, CanOverwriteVariable(variableName, node.StartIndex)); } } }
private void AssignVariables(FromImportStatement node, IImportSearchResult imports, PythonVariableModule variableModule) { if (variableModule == null) { return; } var names = node.Names; var asNames = node.AsNames; if (names.Count == 1 && names[0].Name == "*") { // TODO: warn this is not a good style per // TODO: https://docs.python.org/3/faq/programming.html#what-are-the-best-practices-for-using-import-in-a-module // TODO: warn this is invalid if not in the global scope. HandleModuleImportStar(variableModule, imports, node.StartIndex, names[0]); return; } for (var i = 0; i < names.Count; i++) { var memberName = names[i].Name; if (!string.IsNullOrEmpty(memberName)) { var nameExpression = asNames[i] ?? names[i]; var variableName = nameExpression?.Name ?? memberName; if (!string.IsNullOrEmpty(variableName)) { DeclareVariable(variableModule, memberName, imports, variableName, node.StartIndex, nameExpression); } } } }
public bool TryGetChildImport(string name, out IImportSearchResult child) { foreach (var edge in _edges) { var index = edge.End.GetChildIndex(name); if (index == -1) { continue; } var childEdge = edge.Append(index); if (_snapshot.TryCreateModuleImport(childEdge, out var moduleImport)) { child = moduleImport; } else { child = new ImplicitPackageImport(new ChildrenSource(_snapshot, childEdge), childEdge.End.Name, childEdge.End.FullModuleName); } return(true); } child = default; return(false); }
private void HandleSearchResults(IImportSearchResult searchResult) { switch (searchResult) { case ModuleImport moduleImport when !Ignore(_moduleResolution, moduleImport.FullName, moduleImport.ModulePath): Dependencies.Add(new AnalysisModuleKey(moduleImport.FullName, moduleImport.ModulePath, _isTypeshed)); return; case PossibleModuleImport possibleModuleImport when !Ignore(_moduleResolution, possibleModuleImport.PrecedingModuleFullName, possibleModuleImport.PrecedingModulePath): Dependencies.Add(new AnalysisModuleKey(possibleModuleImport.PrecedingModuleFullName, possibleModuleImport.PrecedingModulePath, _isTypeshed)); return; default: return; } }
private void HandleModuleImportStar(PythonVariableModule variableModule, IImportSearchResult imports, int importPosition, NameExpression nameExpression) { if (variableModule.Module == Module) { // from self import * won't define any new members return; } // If __all__ is present, take it, otherwise declare all members from the module that do not begin with an underscore. var memberNames = imports is ImplicitPackageImport ? variableModule.GetMemberNames() : variableModule.Analysis.StarImportMemberNames ?? variableModule.GetMemberNames().Where(s => !s.StartsWithOrdinal("_")); foreach (var memberName in memberNames) { DeclareVariable(variableModule, memberName, imports, memberName, importPosition, nameExpression); } }
private void AssignVariables(FromImportStatement node, IImportSearchResult imports, PythonVariableModule variableModule) { var names = node.Names; var asNames = node.AsNames; if (variableModule != null && names.Count == 1 && names[0].Name == "*") { // TODO: warn this is not a good style per // TODO: https://docs.python.org/3/faq/programming.html#what-are-the-best-practices-for-using-import-in-a-module // TODO: warn this is invalid if not in the global scope. HandleModuleImportStar(variableModule, imports, node.StartIndex, names[0]); return; } for (var i = 0; i < names.Count; i++) { var memberName = names[i].Name; if (string.IsNullOrEmpty(memberName)) { continue; } var nameExpression = asNames[i] ?? names[i]; var variableName = nameExpression?.Name ?? memberName; if (!string.IsNullOrEmpty(variableName)) { DeclareVariable(variableModule, memberName, imports, variableName, node.StartIndex, nameExpression); } if (imports is IImportChildrenSource cs && cs.TryGetChildImport(memberName, out var csr) && HandleImportSearchResult(csr, variableModule, null, names[i], out var childModule)) { _importedVariableHandler.EnsureModule(childModule); } } }
private static CompletionResult GetResultFromImportSearch(IImportSearchResult importSearchResult, CompletionContext context, bool prependStar, SourceSpan?applicableSpan = null) { var document = context.Analysis.Document; var mres = document.Interpreter.ModuleResolution; IPythonModule module; switch (importSearchResult) { case ModuleImport moduleImports: module = mres.GetImportedModule(moduleImports.FullName); break; case PossibleModuleImport possibleModuleImport: module = mres.GetImportedModule(possibleModuleImport.PossibleModuleFullName); break; case ImplicitPackageImport _: module = null; break; default: return(CompletionResult.Empty); } var completions = new List <CompletionItem>(); if (prependStar) { completions.Add(CompletionItemSource.Star); } if (module != null) { completions.AddRange(module.GetMemberNames() .Where(n => !string.IsNullOrEmpty(n)) .Select(n => context.ItemSource.CreateCompletionItem(n, module.GetMember(n)))); } if (importSearchResult is IImportChildrenSource children) { foreach (var childName in children.GetChildrenNames()) { if (!children.TryGetChildImport(childName, out var imports)) { continue; } switch (imports) { case ImplicitPackageImport packageImport: completions.Add(CompletionItemSource.CreateCompletionItem(packageImport.Name, CompletionItemKind.Module)); break; case ModuleImport moduleImport when !moduleImport.ModulePath.PathEquals(document.FilePath): completions.Add(CompletionItemSource.CreateCompletionItem(moduleImport.Name, CompletionItemKind.Module)); break; } } } return(new CompletionResult(completions, applicableSpan)); }
/// <summary> /// Determines value of the variable and declares it. Value depends if source module has submodule /// that is named the same as the variable and/or it has internal variables named same as the submodule. /// </summary> /// <example>'from a.b import c' when 'c' is both submodule of 'b' and a variable declared inside 'b'.</example> /// <param name="variableModule">Source module of the variable such as 'a.b' in 'from a.b import c as d'. May be null if the module was not found.</param> /// <param name="memberName">Module member name such as 'c' in 'from a.b import c as d'.</param> /// <param name="imports">Import search result.</param> /// <param name="variableName">Name of the variable to declare, such as 'd' in 'from a.b import c as d'.</param> /// <param name="importPosition">Position of the import statement.</param> /// <param name="nameLocation">Location of the variable name expression.</param> private void DeclareVariable(PythonVariableModule variableModule, string memberName, IImportSearchResult imports, string variableName, int importPosition, Node nameLocation) { IMember value = Eval.UnknownType; if (variableModule != null) { // First try imports since child modules should win, i.e. in 'from a.b import c' // 'c' should be a submodule if 'b' has one, even if 'b' also declares 'c = 1'. value = GetValueFromImports(variableModule, imports as IImportChildrenSource, memberName); // First try exported or child submodules. var member = variableModule.GetMember(memberName); // Value may be variable or submodule. If it is variable, we need it in order to add reference. var variable = _importedVariableHandler.GetVariable(variableModule, memberName); if (member is PythonVariableModule vm && vm.Equals(variable?.Value)) { // If member is submodule, use actual variable so it can be linked through for goto definition. value = variable; } else if (value == null) { if (member is PythonVariableModule) { // If member is submodule, use it. value = member; } else if (variable?.Value != null) { // Otherwise use variable, if available so references can be linked. value = variable; } else if (member != null) { value = member; } else { value = Eval.UnknownType; } } }
/// <summary> /// Determines value of the variable and declares it. Value depends if source module has submodule /// that is named the same as the variable and/or it has internal variables named same as the submodule. /// </summary> /// <example>'from a.b import c' when 'c' is both submodule of 'b' and a variable declared inside 'b'.</example> /// <param name="variableModule">Source module of the variable such as 'a.b' in 'from a.b import c as d'.</param> /// <param name="memberName">Module member name such as 'c' in 'from a.b import c as d'.</param> /// <param name="imports">Import search result.</param> /// <param name="variableName">Name of the variable to declare, such as 'd' in 'from a.b import c as d'.</param> /// <param name="importPosition">Position of the import statement.</param> /// <param name="nameLocation">Location of the variable name expression.</param> private void DeclareVariable(PythonVariableModule variableModule, string memberName, IImportSearchResult imports, string variableName, int importPosition, Node nameLocation) { // First try imports since child modules should win, i.e. in 'from a.b import c' // 'c' should be a submodule if 'b' has one, even if 'b' also declares 'c = 1'. var value = GetValueFromImports(variableModule, imports as IImportChildrenSource, memberName); // First try exported or child submodules. value = value ?? variableModule.GetMember(memberName); // Value may be variable or submodule. If it is variable, we need it in order to add reference. var variable = variableModule.Analysis?.GlobalScope?.Variables[memberName]; value = variable?.Value?.Equals(value) == true ? variable : value; // If nothing is exported, variables are still accessible. value = value ?? variableModule.Analysis?.GlobalScope?.Variables[memberName]?.Value ?? Eval.UnknownType; // Do not allow imported variables to override local declarations var canOverwrite = CanOverwriteVariable(variableName, importPosition, value); // Do not declare references to '*' var locationExpression = nameLocation is NameExpression nex && nex.Name == "*" ? null : nameLocation; Eval.DeclareVariable(variableName, value, VariableSource.Import, locationExpression, canOverwrite); // Make sure module is loaded and analyzed. if (value is IPythonModule m) { ModuleResolution.GetOrLoadModule(m.Name); } }
private static void HandleSearchResults(bool isTypeshed, HashSet <AnalysisModuleKey> dependencies, IModuleManagement moduleResolution, IImportSearchResult searchResult) { switch (searchResult) { case ModuleImport moduleImport when !Ignore(moduleResolution, moduleImport.FullName): dependencies.Add(new AnalysisModuleKey(moduleImport.FullName, moduleImport.ModulePath, isTypeshed)); return; case PossibleModuleImport possibleModuleImport when !Ignore(moduleResolution, possibleModuleImport.PrecedingModuleFullName): dependencies.Add(new AnalysisModuleKey(possibleModuleImport.PrecedingModuleFullName, possibleModuleImport.PrecedingModulePath, isTypeshed)); return; default: return; } }
public bool TryGetChildImport(string name, out IImportSearchResult child) => _childrenSource.TryGetChildImport(name, out child);
public bool TryGetChildImport(string name, out IImportSearchResult child) { child = default; return(false); }