/// <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 async Task <ModuleReference> TryImportAsync(string name)
{
ModuleReference res;
bool firstImport = false;
if (!_modules.TryGetValue(name, out res) || res == null)
{
var mod = await Task.Run(() => _interpreter.ImportModule(name));
_modules[name] = res = new ModuleReference(GetBuiltinModule(mod));
firstImport = true;
}
if (res != null && res.Module == null)
{
var mod = await Task.Run(() => _interpreter.ImportModule(name));
res.Module = GetBuiltinModule(mod);
}
if (firstImport && res != null && res.Module != null)
{
await Task.Run(() => _analyzer.DoDelayedSpecialization(name));
}
if (res != null && res.Module == null)
{
return(null);
}
return(res);
}
private IEnumerable <IAnalysisItemView> CalculateChildren()
{
if (_module == null)
{
_module = _interpreter.ImportModule(Name);
}
if (File.Exists(_idbPath))
{
yield return(RawView.FromFile(_idbPath));
}
var cpm = _module as Interpreter.LegacyDB.CPythonModule;
if (cpm != null)
{
cpm.EnsureLoaded();
}
if (cpm != null && cpm._hiddenMembers != null)
{
foreach (var keyValue in cpm._hiddenMembers)
{
yield return(MemberView.Make(_context, keyValue.Key, keyValue.Value));
}
}
foreach (var memberName in _module.GetMemberNames(_context))
{
yield return(MemberView.Make(_context, _module, memberName));
}
}
private IPythonModule GetModule()
{
var mod = Volatile.Read(ref _module);
if (mod != null)
{
return(mod);
}
foreach (var n in _importNames)
{
mod = _interpreter.ImportModule(n);
if (mod != null)
{
Debug.Assert(!(mod is AstNestedPythonModule), "ImportModule should not return nested module");
break;
}
}
if (mod == null)
{
mod = new SentinelModule(_importNames.FirstOrDefault() ?? "<unknown>", false);
}
return(Interlocked.CompareExchange(ref _module, mod, null) ?? mod);
}
/// <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 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);
}
public IPythonModule ImportModule(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return(null);
}
if (name == _builtinModule?.Name)
{
return(_builtinModule);
}
if (_modules.TryGetValue(name, out var mod))
{
return(mod);
}
var handle = Remote.LookupNamespace(name);
if (!handle.IsNull)
{
mod = MakeObject(handle) as IPythonModule;
if (mod != null)
{
return(_modules.GetOrAdd(name, mod));
}
}
var pythonModule = _pythonInterpreter.ImportModule(name);
if (pythonModule != null)
{
_modules.GetOrAdd(name, pythonModule);
return(pythonModule);
}
var nameParts = name.Split('.');
if (nameParts.Length > 1 && (mod = ImportModule(nameParts[0])) != null)
{
for (var i = 1; i < nameParts.Length && mod != null; ++i)
{
mod = mod.GetMember(IronPythonModuleContext.ShowClrInstance, nameParts[i]) as IPythonModule;
}
}
return(_modules.GetOrAdd(name, mod));
}
private IPythonModule GetModule()
{
var module = Volatile.Read(ref _module);
if (module != null)
{
return(module);
}
module = _interpreter.ImportModule(Name);
if (module != null)
{
Debug.Assert(!(module is AstNestedPythonModule), "ImportModule should not return nested module");
}
if (module == null)
{
module = new SentinelModule(Name, false);
}
return(Interlocked.CompareExchange(ref _module, module, null) ?? module);
}
