public override IMember GetMember(string name)
{
IMember member;
lock (_lock) {
if (Members.TryGetValue(name, out member))
{
return(member);
}
// Special case names that we want to add to our own Members dict
switch (name)
{
case "__mro__":
member = AddMember(name, PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, Mro), true);
return(member);
}
}
if (Push())
{
try {
foreach (var m in Mro.Reverse())
{
if (m == this)
{
return(member);
}
member = member ?? m.GetMember(name);
}
} finally {
Pop();
}
}
return(null);
}
// Constructor call
public override IMember CreateInstance(IArgumentSet args)
{
var builtins = DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule;
// Specializations
switch (Name)
{
case "list":
return(PythonCollectionType.CreateList(builtins, args));
case "dict": {
// self, then contents
var contents = args.Values <IMember>().Skip(1).FirstOrDefault();
return(new PythonDictionary(builtins, contents));
}
case "tuple": {
var contents = args.Values <IMember>();
return(PythonCollectionType.CreateTuple(builtins, contents));
}
}
// Metaclasses return type, not instance.
if (Bases.MaybeEnumerate().Any(b => b.Name == "type" && b.DeclaringModule.ModuleType == ModuleType.Builtins))
{
return(this);
}
return(new PythonInstance(this));
}
public override IMember GetMember(string name)
{
lock (MembersLock) {
if (Members.TryGetValue(name, out var member))
{
return(member);
}
}
// Special case names that we want to add to our own Members dict
var is3x = DeclaringModule.Interpreter.LanguageVersion.Is3x();
switch (name)
{
case "__mro__":
case "mro":
return(is3x ? PythonCollectionType.CreateList(DeclaringModule, Mro) : UnknownType as IMember);
case "__dict__":
return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Dict) : UnknownType);
case @"__weakref__":
return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object) : UnknownType);
}
using (_memberGuard.Push(this, out var reentered)) {
if (!reentered)
{
return(Mro.Skip(1).Select(c => c.GetMember(name)).ExcludeDefault().FirstOrDefault());
}
return(null);
}
}
public IMember GetValueFromList(ListExpression expression)
{
var contents = new List <IMember>();
foreach (var item in expression.Items)
{
var value = GetValueFromExpression(item) ?? UnknownType;
contents.Add(value);
}
return(PythonCollectionType.CreateList(Module.Interpreter, GetLoc(expression), contents));
}
public IMember GetValueFromList(ListExpression expression)
{
var contents = new List <IMember>();
foreach (var item in expression.Items.Take(MaxCollectionSize))
{
var value = GetValueFromExpression(item) ?? UnknownType;
contents.Add(value);
}
return(PythonCollectionType.CreateList(Module, contents, exact: expression.Items.Count <= MaxCollectionSize));
}
public async Task <IMember> GetValueFromListAsync(ListExpression expression, CancellationToken cancellationToken = default)
{
var contents = new List <IMember>();
foreach (var item in expression.Items)
{
var value = await GetValueFromExpressionAsync(item, cancellationToken) ?? UnknownType;
contents.Add(value);
}
return(PythonCollectionType.CreateList(Module.Interpreter, GetLoc(expression), contents));
}
private void HandleAllAppendExtend(CallExpression node)
{
if (!(node.Target is MemberExpression me))
{
return;
}
if (!IsHandleableAll(me.Target))
{
return;
}
if (node.Args.Count == 0)
{
return;
}
var arg = node.Args[0].Expression;
var v = Eval.GetValueFromExpression(arg);
if (v == null)
{
_allIsUsable = false;
return;
}
IPythonCollection values = null;
switch (me.Name)
{
case "append":
values = PythonCollectionType.CreateList(Module.Interpreter, Eval.GetLoc(arg), new List <IMember>()
{
v
}, exact: true);
break;
case "extend":
values = v as IPythonCollection;
break;
}
if (values == null)
{
_allIsUsable = false;
return;
}
ExtendAll(node, values);
}
private IEnumerable <IPythonType> CreateBases(ClassModel cm, ModuleFactory mf, IGlobalScope gs)
{
var ntBases = cm.NamedTupleBases
.Select(ntb => MemberFactory.CreateMember(ntb, ModuleFactory, GlobalScope, _cls))
.OfType <IPythonType>()
.ToArray();
var is3x = mf.Module.Interpreter.LanguageVersion.Is3x();
var basesNames = cm.Bases.Select(b => is3x && b == "object" ? null : b).ExcludeDefault().ToArray();
var bases = basesNames.Select(mf.ConstructType).ExcludeDefault().Concat(ntBases).ToArray();
// Make sure base types are realized
foreach (var b in bases.OfType <PythonLazyClassType>())
{
b.EnsureContent();
}
if (cm.GenericBaseParameters.Length > 0)
{
// Generic class. Need to reconstruct generic base so code can then
// create specific types off the generic class.
var genericBase = bases.OfType <IGenericType>().FirstOrDefault(b => b.Name == "Generic");
if (genericBase != null)
{
var typeVars = cm.GenericBaseParameters.Select(n => gs.Variables[n]?.Value).OfType <IGenericTypeParameter>().ToArray();
//Debug.Assert(typeVars.Length > 0, "Class generic type parameters were not defined in the module during restore");
if (typeVars.Length > 0)
{
var genericWithParameters = genericBase.CreateSpecificType(new ArgumentSet(typeVars, null, null));
if (genericWithParameters != null)
{
bases = bases.Except(Enumerable.Repeat(genericBase, 1)).Concat(Enumerable.Repeat(genericWithParameters, 1)).ToArray();
}
}
}
else
{
Debug.Fail("Generic class does not have generic base.");
}
}
if (bases.Length > 0)
{
_cls.AddMember("__base__", bases[0], true);
}
_cls.AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule, bases), true);
return(bases);
}
/// <summary>
/// Sets class bases. If scope is provided, detects loops in base classes and removes them.
/// </summary>
/// <param name="bases">List of base types.</param>
/// <param name="currentScope">Current scope to look up base types.
/// Can be null if class is restored from database, in which case
/// there is no need to try and disambiguate bases.</param>
internal void SetBases(IEnumerable <IPythonType> bases, IScope currentScope = null)
{
if (_bases != null)
{
return; // Already set
}
// Consider
// from X import A
// class A(A): ...
bases = DisambiguateBases(bases, currentScope).ToArray();
// For Python 3+ attach object as a base class by default except for the object class itself.
if (DeclaringModule.Interpreter.LanguageVersion.Is3x() && DeclaringModule.ModuleType != ModuleType.Builtins)
{
var objectType = DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object);
// During processing of builtins module some types may not be available yet.
// Specialization will attach proper base at the end.
Debug.Assert(!objectType.IsUnknown());
if (!bases.Any(b => objectType.Equals(b)))
{
bases = bases.Concat(Enumerable.Repeat(objectType, 1));
}
}
_bases = bases.ToList();
if (_bases.Count > 0)
{
AddMember("__base__", _bases[0], true);
}
// Invalidate MRO
_mro = null;
DecideGeneric();
if (DeclaringModule is BuiltinsPythonModule)
{
// TODO: If necessary, we can set __bases__ on builtins when the module is fully analyzed.
return;
}
AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule, _bases), true);
}
public override IMember GetMember(string name)
{
IMember member;
lock (_lock) {
if (Members.TryGetValue(name, out member))
{
return(member);
}
// Special case names that we want to add to our own Members dict
var is3x = DeclaringModule.Interpreter.LanguageVersion.Is3x();
switch (name)
{
case "__mro__":
case "mro":
return(is3x ? PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, Mro) : UnknownType);
case "__dict__":
return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Dict) : UnknownType);
case @"__weakref__":
return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object) : UnknownType);
}
}
if (Push(this))
{
try {
foreach (var m in Mro.Reverse())
{
if (m == this)
{
return(member);
}
member = member ?? m.GetMember(name);
}
} finally {
Pop();
}
}
return(null);
}
public IMember GetValueFromComprehension(Comprehension node)
{
var oldVariables = CurrentScope.Variables.OfType <Variable>().ToDictionary(k => k.Name, v => v);
try {
ProcessComprehension(node);
// TODO: Evaluate comprehensions to produce exact contents, if possible.
switch (node)
{
case ListComprehension lc:
var v1 = GetValueFromExpression(lc.Item) ?? UnknownType;
return(PythonCollectionType.CreateList(Module, new[] { v1 }));
case SetComprehension sc:
var v2 = GetValueFromExpression(sc.Item) ?? UnknownType;
return(PythonCollectionType.CreateSet(Module, new[] { v2 }));
case DictionaryComprehension dc:
var k = GetValueFromExpression(dc.Key) ?? UnknownType;
var v = GetValueFromExpression(dc.Value) ?? UnknownType;
return(new PythonDictionary(new PythonDictionaryType(Interpreter.ModuleResolution.BuiltinsModule), new Dictionary <IMember, IMember> {
{ k, v }
}));
}
return(UnknownType);
} finally {
// Remove temporary variables since this is assignment and the right hand
// side comprehension does not leak internal variables into the scope.
var newVariables = CurrentScope.Variables.ToDictionary(k => k.Name, v => v);
var variables = (VariableCollection)CurrentScope.Variables;
foreach (var kvp in newVariables)
{
if (!oldVariables.ContainsKey(kvp.Key))
{
variables.RemoveVariable(kvp.Key);
}
}
}
}
// Constructor call
public override IMember CreateInstance(string typeName, IArgumentSet args)
{
// Specializations
switch (typeName)
{
case "list":
return(PythonCollectionType.CreateList(DeclaringModule.Interpreter, args));
case "dict": {
// self, then contents
var contents = args.Values <IMember>().Skip(1).FirstOrDefault();
return(new PythonDictionary(DeclaringModule.Interpreter, contents));
}
case "tuple": {
var contents = args.Values <IMember>();
return(PythonCollectionType.CreateTuple(DeclaringModule.Interpreter, contents));
}
}
return(new PythonInstance(this));
}
internal void SetBases(IPythonInterpreter interpreter, IEnumerable <IPythonType> bases)
{
lock (_lock) {
if (Bases != null)
{
return; // Already set
}
Bases = bases.MaybeEnumerate().ToArray();
if (Bases.Count > 0)
{
AddMember("__base__", Bases[0], true);
}
if (!(DeclaringModule is BuiltinsPythonModule))
{
// TODO: If necessary, we can set __bases__ on builtins when the module is fully analyzed.
AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, Bases), true);
}
}
}
internal void SetBases(IEnumerable <IPythonType> bases)
{
lock (_lock) {
if (_bases != null)
{
return; // Already set
}
bases = bases != null?bases.Where(b => !b.GetPythonType().IsUnknown()).ToArray() : Array.Empty <IPythonType>();
// For Python 3+ attach object as a base class by default except for the object class itself.
if (DeclaringModule.Interpreter.LanguageVersion.Is3x() && DeclaringModule.ModuleType != ModuleType.Builtins)
{
var objectType = DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object);
// During processing of builtins module some types may not be available yet.
// Specialization will attach proper base at the end.
Debug.Assert(!objectType.IsUnknown());
if (!bases.Any(b => objectType.Equals(b)))
{
bases = bases.Concat(Enumerable.Repeat(objectType, 1));
}
}
_bases = bases.ToList();
if (_bases.Count > 0)
{
AddMember("__base__", _bases[0], true);
}
// Invalidate MRO
_mro = null;
if (DeclaringModule is BuiltinsPythonModule)
{
// TODO: If necessary, we can set __bases__ on builtins when the module is fully analyzed.
return;
}
AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, _bases), true);
}
}
public override IMember GetMember(string name)
{
// Push/Pop should be lock protected.
if (Members.TryGetValue(name, out var member))
{
return(member);
}
// Special case names that we want to add to our own Members dict
var is3x = DeclaringModule.Interpreter.LanguageVersion.Is3x();
switch (name)
{
case "__mro__":
case "mro":
return(is3x ? PythonCollectionType.CreateList(DeclaringModule.Interpreter, Mro) : UnknownType as IMember);
case "__dict__":
return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Dict) : UnknownType);
case @"__weakref__":
return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object) : UnknownType);
}
using (_memberGuard.Push(this, out var reentered)) {
if (!reentered)
{
foreach (var m in Mro.Reverse())
{
if (m == this)
{
return(member);
}
member = member ?? m.GetMember(name);
}
}
return(null);
}
}
// Constructor call
public override IPythonInstance CreateInstance(IArgumentSet args)
{
var builtins = DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule;
// Specializations
switch (Name)
{
case "list":
return(PythonCollectionType.CreateList(builtins, args));
case "dict": {
// self, then contents
var contents = args.Values <IMember>().Skip(1).FirstOrDefault();
return(new PythonDictionary(builtins, contents));
}
case "tuple": {
var contents = args.Values <IMember>();
return(PythonCollectionType.CreateTuple(builtins, contents));
}
}
return(new PythonInstance(this));
}
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, LocationInfo location, IReadOnlyList <IMember> args) => PythonCollectionType.CreateList(interpreter, location, args);
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) => PythonCollectionType.CreateList(interpreter.ModuleResolution.BuiltinsModule, argSet);
private IPythonCollection CreateList(IReadOnlyList <IMember> items) => PythonCollectionType.CreateList(Type.DeclaringModule.Interpreter, items, false);
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, LocationInfo location, IArgumentSet argSet) => PythonCollectionType.CreateList(interpreter, location, argSet);
