public IMember GetMember(IModuleContext context, string name)
{
IMember member;
lock (_members) {
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 = _members[name] = new AstPythonSequence(
(context as IPythonInterpreter)?.GetBuiltinType(BuiltinTypeId.Tuple),
DeclaringModule,
Mro
);
return(member);
}
}
foreach (var m in Mro.Skip(1))
{
member = m.GetMember(context, name);
if (member != null)
{
return(member);
}
}
return(null);
}
private IPythonType MakeSequenceType(BuiltinTypeId typeId, IReadOnlyList <IPythonType> types)
{
var res = _scope.Interpreter.GetBuiltinType(typeId);
if (types.Count > 0)
{
res = new AstPythonSequence(res, _scope.Module, types.Select(Finalize));
}
return(res);
}
internal void SetBases(IPythonInterpreter interpreter, IEnumerable <IPythonType> bases)
{
if (Bases != null)
{
throw new InvalidOperationException("cannot set Bases multiple times");
}
Bases = bases.MaybeEnumerate().ToArray();
lock (_members) {
if (Bases.Count > 0)
{
_members["__base__"] = Bases[0];
}
_members["__bases__"] = new AstPythonSequence(interpreter?.GetBuiltinType(BuiltinTypeId.Tuple), DeclaringModule, Bases);
}
}
public IMember GetMember(IModuleContext context, string name)
{
IMember member;
lock (_members) {
if (!_members.TryGetValue(name, out member))
{
switch (name)
{
case "__mro__":
member = _members[name] = new AstPythonSequence(
(context as IPythonInterpreter)?.GetBuiltinType(BuiltinTypeId.Tuple),
DeclaringModule,
Mro
);
break;
}
}
}
return(member);
}
public IMember GetMember(IModuleContext context, string name)
{
IMember member;
lock (_members) {
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 = _members[name] = new AstPythonSequence(
(context as IPythonInterpreter)?.GetBuiltinType(BuiltinTypeId.Tuple),
DeclaringModule,
Mro,
(context as IPythonInterpreter)?.GetBuiltinType(BuiltinTypeId.TupleIterator)
);
return(member);
}
}
if (Push())
{
try {
foreach (var m in Mro.Reverse())
{
if (m == this)
{
return(member);
}
member = member ?? m.GetMember(context, name);
}
} finally {
Pop();
}
}
return(null);
}
internal void SetBases(IPythonInterpreter interpreter, IEnumerable <IPythonType> bases)
{
lock (_members) {
if (Bases != null)
{
return; // Already set
}
Bases = bases.MaybeEnumerate().ToArray();
if (Bases.Count > 0)
{
_members["__base__"] = Bases[0];
}
_members["__bases__"] = new AstPythonSequence(
interpreter?.GetBuiltinType(BuiltinTypeId.Tuple),
DeclaringModule,
Bases,
interpreter?.GetBuiltinType(BuiltinTypeId.TupleIterator)
);
}
}
public IPythonType GetTypeFromLiteral(Expression expr)
{
if (expr is ConstantExpression ce)
{
if (ce.Value == null)
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.NoneType));
}
switch (Type.GetTypeCode(ce.Value.GetType()))
{
case TypeCode.Boolean: return(Interpreter.GetBuiltinType(BuiltinTypeId.Bool));
case TypeCode.Double: return(Interpreter.GetBuiltinType(BuiltinTypeId.Float));
case TypeCode.Int32: return(Interpreter.GetBuiltinType(BuiltinTypeId.Int));
case TypeCode.String: return(Interpreter.GetBuiltinType(BuiltinTypeId.Unicode));
case TypeCode.Object:
if (ce.Value.GetType() == typeof(Complex))
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Complex));
}
else if (ce.Value.GetType() == typeof(AsciiString))
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Bytes));
}
else if (ce.Value.GetType() == typeof(BigInteger))
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Long));
}
else if (ce.Value.GetType() == typeof(Ellipsis))
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Ellipsis));
}
break;
}
return(null);
}
if (expr is ListExpression || expr is ListComprehension)
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.List));
}
if (expr is DictionaryExpression || expr is DictionaryComprehension)
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Dict));
}
if (expr is TupleExpression tex)
{
var types = tex.Items
.Select(x => {
IPythonType t = null;
if (x is NameExpression ne)
{
t = (GetInScope(ne.Name) as AstPythonConstant)?.Type;
}
return(t ?? Interpreter.GetBuiltinType(BuiltinTypeId.Unknown));
}).ToArray();
var res = Interpreter.GetBuiltinType(BuiltinTypeId.Tuple);
if (types.Length > 0)
{
var iterRes = Interpreter.GetBuiltinType(BuiltinTypeId.TupleIterator);
res = new AstPythonSequence(res, Module, types, iterRes);
}
return(res);
}
if (expr is SetExpression || expr is SetComprehension)
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Set));
}
if (expr is LambdaExpression)
{
return(Interpreter.GetBuiltinType(BuiltinTypeId.Function));
}
return(null);
}
