/// <summary> /// Adds a new module of code to the list of available modules and returns a ProjectEntry object. /// </summary> /// <param name="moduleName">The name of the module; used to associate with imports</param> /// <param name="filePath">The path to the file on disk</param> /// <param name="cookie">An application-specific identifier for the module</param> /// <returns></returns> public IPythonProjectEntry AddModule(string moduleName, string filePath, IAnalysisCookie cookie = null) { var entry = new ProjectEntry(this, moduleName, filePath, cookie); if (moduleName != null) { Modules[moduleName] = new ModuleReference(entry.MyScope); } if (filePath != null) { _modulesByFilename[filePath] = entry.MyScope; } return(entry); }
/// <summary> /// Gets a reference to a module. /// </summary> /// <param name="name">The full import name of the module.</param> /// <param name="res">The module reference object.</param> /// <returns> /// True if the module is available. This means that <c>res.Module</c> /// is not null. If this function returns false, <paramref name="res"/> /// may be valid and should not be replaced, but it is an unresolved /// reference. /// </returns> public bool TryImport(string name, out ModuleReference res) { bool firstImport = false; if (!_modules.TryGetValue(name, out res) || res == null) { _modules[name] = res = new ModuleReference(GetBuiltinModule(_interpreter.ImportModule(name))); firstImport = true; } if (res != null && res.Module == null) { res.Module = GetBuiltinModule(_interpreter.ImportModule(name)); } if (firstImport && res != null && res.Module != null) { _analyzer.DoDelayedSpecialization(name); } return(res != null && res.Module != null); }
private void LoadKnownTypes() { _itemCache.Clear(); ModuleReference moduleRef; if (Modules.TryImport(_builtinName, out moduleRef)) { _builtinModule = (BuiltinModule)moduleRef.Module; } else { var fallbackDb = PythonTypeDatabase.CreateDefaultTypeDatabase(LanguageVersion.ToVersion()); _builtinModule = _modules.GetBuiltinModule(fallbackDb.GetModule(SharedDatabaseState.BuiltinName2x)); Modules[_builtinName] = new ModuleReference(_builtinModule); } Types = new KnownTypes(this); ClassInfos = (IKnownClasses)Types; _noneInst = (ConstantInfo)GetCached(_nullKey, () => new ConstantInfo(ClassInfos[BuiltinTypeId.NoneType], (object)null)); DoNotUnionInMro = AnalysisSet.Create(new AnalysisValue[] { ClassInfos[BuiltinTypeId.Object], ClassInfos[BuiltinTypeId.Type] }); AddBuiltInSpecializations(); ModuleReference sysModule; if (_modules.TryImport("sys", out sysModule)) { var bm = sysModule.AnalysisModule as BuiltinModule; if (bm != null) { sysModule.Module = new SysModuleInfo(bm); } } }
private async Task LoadKnownTypesAsync() { if (_loadKnownTypesException != null) { _loadKnownTypesException.Throw(); } _itemCache.Clear(); Debug.Assert(_builtinModule != null, "LoadInitialKnownTypes was not called"); if (_builtinModule == null) { LoadInitialKnownTypes(); } var moduleRef = await Modules.TryImportAsync(_builtinName).ConfigureAwait(false); if (moduleRef != null) { _builtinModule = (BuiltinModule)moduleRef.Module; } else { Modules[_builtinName] = new ModuleReference(_builtinModule); } FinishLoadKnownTypes(null); var sysModule = await _modules.TryImportAsync("sys").ConfigureAwait(false); if (sysModule != null) { var bm = sysModule.AnalysisModule as BuiltinModule; if (bm != null) { sysModule.Module = new SysModuleInfo(bm); } } }
internal void ImportChildren(IPythonModule interpreterModule) { BuiltinModule module = null; foreach (var child in interpreterModule.GetChildrenModules()) { module = module ?? GetBuiltinModule(interpreterModule); ModuleReference modRef; var fullname = module.Name + "." + child; if (!_modules.TryGetValue(fullname, out modRef) || modRef == null || modRef.Module == null) { IAnalysisSet value; if (module.TryGetMember(child, out value)) { var mod = value as IModule; if (mod != null) { _modules[fullname] = new ModuleReference(mod); } } } } }
private void InitializeBuiltinModules() { var names = _interpreter.GetModuleNames(); foreach (string modName in names) { var mod = _interpreter.ImportModule(modName); if (mod != null) { ModuleReference modRef; if (Modules.TryGetValue(modName, out modRef)) { var existingBuiltin = modRef.Module as BuiltinModule; if (existingBuiltin != null && existingBuiltin._type == mod) { // don't replace existing module which is the same continue; } } Modules[modName] = new ModuleReference(new BuiltinModule(mod, this)); } } }
/// <summary> /// Gets a reference to a module. /// </summary> /// <param name="name">The full import name of the module.</param> /// <param name="moduleReference">The module reference object.</param> /// <returns> /// True if the module is available. This means that <c>moduleReference.Module</c> /// is not null. If this function returns false, <paramref name="moduleReference"/> /// may be valid and should not be replaced, but it is an unresolved /// reference. /// </returns> public bool TryImport(string name, out ModuleReference moduleReference) { var firstImport = false; if (!_modules.TryGetValue(name, out moduleReference) || moduleReference == null) { var pythonModule = _interpreter.ImportModule(name); moduleReference = SetModule(name, GetBuiltinModule(pythonModule)); firstImport = true; } if (moduleReference.Module == null) { moduleReference.Module = GetBuiltinModule(_interpreter.ImportModule(name)); } if (firstImport && moduleReference.Module != null) { _analyzer.DoDelayedSpecialization(name); } return(moduleReference.Module != null); }
private async Task LoadKnownTypesAsync() { _itemCache.Clear(); var fallback = new FallbackBuiltinModule(_langVersion); var moduleRef = await Modules.TryImportAsync(_builtinName).ConfigureAwait(false); if (moduleRef != null) { _builtinModule = (BuiltinModule)moduleRef.Module; } else { _builtinModule = new BuiltinModule(fallback, this); Modules[_builtinName] = new ModuleReference(_builtinModule, _builtinName); } Modules.AddBuiltinModuleWrapper("sys", SysModuleInfo.Wrap); Modules.AddBuiltinModuleWrapper("typing", TypingModuleInfo.Wrap); Types = KnownTypes.Create(this, fallback); ClassInfos = (IKnownClasses)Types; _noneInst = (ConstantInfo)GetCached( _nullKey, () => new ConstantInfo(ClassInfos[BuiltinTypeId.NoneType], null, PythonMemberType.Constant) ); DoNotUnionInMro = AnalysisSet.Create(new AnalysisValue[] { ClassInfos[BuiltinTypeId.Object], ClassInfos[BuiltinTypeId.Type] }); AddBuiltInSpecializations(); }
/// <summary> /// Gets a reference to a module that has already been imported. You /// probably want to use <see cref="TryImport"/>. /// </summary> /// <returns> /// True if an attempt to import the module was made during the analysis /// that used this module table. The reference may be null, or the /// module within the reference may be null, even if this function /// returns true. /// </returns> /// <remarks> /// This exists for inspecting the results of an analysis (for example, /// <see cref="SaveAnalysis"/>). To get access to a module while /// analyzing code, even (especially!) if the module may not exist, /// you should call <see cref="TryImport"/>. /// </remarks> internal bool TryGetImportedModule(string name, out ModuleReference res) { return(_modules.TryGetValue(name, out res)); }
public InitializedModuleLoadState(ModuleReference reference) { _reference = reference; }
public bool TryRemove(string name, out ModuleReference res) { return(_modules.TryRemove(name, out res)); }
public bool TryRemove(string name, out ModuleReference res) => _modules.TryRemove(name, out res);