public override IAnalysisSet GetAsyncEnumeratorTypes(Node node, AnalysisUnit unit)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetAsyncEnumeratorTypes(node, unit))));
}
public override IAnalysisSet GetDescriptor(Node node, AnalysisValue instance, AnalysisValue context, AnalysisUnit unit)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetDescriptor(node, instance, context, unit))));
}
public override IAnalysisSet Await(Node node, AnalysisUnit unit)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.Await(node, unit))));
}
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.Call(node, unit, args, keywordArgNames))));
}
public override IAnalysisSet GetTypeMember(Node node, AnalysisUnit unit, string name)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetTypeMember(node, unit, name))));
}
public IAnalysisSet Finalize(string name, IReadOnlyList <IAnalysisSet> args)
{
if (string.IsNullOrEmpty(name) || args == null || args.Count == 0)
{
return(null);
}
switch (name)
{
case "Union":
return(AnalysisSet.UnionAll(args.Select(a => Finalize(a))));
case "Optional":
return(Finalize(args[0]).Add(NoneType));
case "List":
case "Tuple":
case "Container":
case "MutableSequence":
case "Sequence":
try {
return(Scope.GetOrMakeNodeValue(_node, NodeValueKind.Sequence, n => {
var t = GetSequenceType(name);
if (t == null)
{
throw new KeyNotFoundException(name);
}
var seq = t.MakeFromIndexes(n, Entry);
seq.AddTypes(_unit, args.Select(ToInstance).ToArray());
return seq;
}));
} catch (KeyNotFoundException) {
return(null);
}
case "KeysView":
return((Scope.GetOrMakeNodeValue(_node, NodeValueKind.DictLiteral, n => {
var di = new DictionaryInfo(Entry, n);
di.AddTypes(
n,
_unit,
ToInstance(args[0]),
None
);
return di;
}) as DictionaryInfo)?.GetKeysView(_unit));
case "ValuesView":
return((Scope.GetOrMakeNodeValue(_node, NodeValueKind.DictLiteral, n => {
var di = new DictionaryInfo(Entry, n);
di.AddTypes(
n,
_unit,
None,
ToInstance(args[0])
);
return di;
}) as DictionaryInfo)?.GetValuesView(_unit));
case "MutableSet":
case "Set":
case "FrozenSet":
try {
return(Scope.GetOrMakeNodeValue(_node, NodeValueKind.Set, n => {
return new SetInfo(
GetSetType(name) ?? throw new KeyNotFoundException(name),
n,
Entry,
args.Select(ToVariableDef).ToArray()
);
}));
} catch (KeyNotFoundException) {
private IAnalysisSet CreateNamedTuple(Node node, AnalysisUnit unit, IAnalysisSet namedTupleName, IAnalysisSet namedTupleArgs)
{
var args = namedTupleArgs == null ? null : TypingTypeInfo.ToTypeList(namedTupleArgs);
var res = new ProtocolInfo(unit.ProjectEntry, unit.State);
string name;
var description = new List <KeyValuePair <string, string> >();
if (args != null && args.Any())
{
var tupleItem = new List <IAnalysisSet>();
foreach (var a in args)
{
// each arg is going to be either a union containing a string literal and type,
// or a list with string literal and type.
IAnalysisSet nameSet = a, valueSet = a;
if (a is TypingTypeInfo tti)
{
var list = tti.ToTypeList();
if (list != null && list.Count >= 2)
{
nameSet = list[0];
valueSet = AnalysisSet.UnionAll(list.Skip(1));
}
}
if (!nameSet.Split(out IReadOnlyList <ConstantInfo> names, out var rest))
{
names = a.OfType <ConstantInfo>().ToArray();
}
name = names.Select(n => n.GetConstantValueAsString()).FirstOrDefault(n => !string.IsNullOrEmpty(n)) ?? "unnamed";
var p = new NamespaceProtocol(res, name);
var value = ToInstance(valueSet);
p.SetMember(node, unit, name, value);
tupleItem.Add(value);
res.AddProtocol(p);
if (description.Any())
{
description.Add(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", "));
}
description.AddRange(p.GetRichDescription());
}
res.AddProtocol(new TupleProtocol(res, tupleItem));
}
name = namedTupleName?.GetConstantValueAsString().FirstOrDefault() ?? "tuple";
var np = new NameProtocol(res, name);
if (description.Any())
{
np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "("));
np.ExtendDescription(description);
np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, ")"));
}
res.AddProtocol(np);
return(res);
}
public override IAnalysisSet GetInstanceType()
{
_instance = _instance ?? AnalysisSet.UnionAll(_protocols.Select(p => p.GetInstanceType()));
return(_instance);
}
private bool GetSequenceTypes(string name, IReadOnlyList <IAnalysisSet> args, out IPythonType realType, out IAnalysisSet keyTypes, out IAnalysisSet valueTypes)
{
switch (name)
{
case "List":
case "Container":
case "Sequence":
case "MutableSequence":
realType = Types[BuiltinTypeId.List];
keyTypes = ClassInfo[BuiltinTypeId.Int].Instance;
valueTypes = AnalysisSet.UnionAll(args.Select(ToInstance));
return(true);
case "Tuple":
realType = Types[BuiltinTypeId.Tuple];
keyTypes = ClassInfo[BuiltinTypeId.Int].Instance;
valueTypes = AnalysisSet.UnionAll(args.Select(ToInstance));
return(true);
case "MutableSet":
case "Set":
realType = Types[BuiltinTypeId.Set];
keyTypes = null;
valueTypes = AnalysisSet.UnionAll(args.Select(ToInstance));
return(true);
case "FrozenSet":
realType = Types[BuiltinTypeId.FrozenSet];
keyTypes = null;
valueTypes = AnalysisSet.UnionAll(args.Select(ToInstance));
return(true);
case "KeysView":
if (args.Count >= 1)
{
realType = Types[BuiltinTypeId.DictKeys];
keyTypes = null;
valueTypes = AnalysisSet.UnionAll(GetTypeList(args[0]).Select(ToInstance));
return(true);
}
break;
case "ValuesView":
if (args.Count >= 1)
{
realType = Types[BuiltinTypeId.DictValues];
keyTypes = null;
valueTypes = AnalysisSet.UnionAll(GetTypeList(args[0]).Select(ToInstance));
return(true);
}
break;
case "ItemsView":
if (args.Count >= 2)
{
realType = Types[BuiltinTypeId.DictItems];
keyTypes = null;
valueTypes = MakeTuple(
AnalysisSet.UnionAll(GetTypeList(args[0]).Select(ToInstance)),
AnalysisSet.UnionAll(GetTypeList(args[1]).Select(ToInstance))
);
return(true);
}
break;
case "Dict":
case "Mapping":
if (args.Count >= 2)
{
realType = Types[BuiltinTypeId.Dict];
keyTypes = AnalysisSet.UnionAll(GetTypeList(args[0]).Select(ToInstance));
valueTypes = AnalysisSet.UnionAll(GetTypeList(args[1]).Select(ToInstance));
return(true);
}
break;
}
realType = null;
keyTypes = null;
valueTypes = null;
return(false);
}
public IAnalysisSet Finalize(string name, IReadOnlyList <IAnalysisSet> args)
{
if (string.IsNullOrEmpty(name) || args == null || args.Count == 0)
{
return(null);
}
NameProtocol np;
IPythonType realType;
IAnalysisSet keyTypes, valueTypes;
switch (name)
{
case "Union":
return(AnalysisSet.UnionAll(args.Select(a => Finalize(a))));
case "Optional":
return(Finalize(args[0]).Add(NoneType));
case "Tuple":
if (!args.SelectMany(a => a).Any(a => a.TypeId == BuiltinTypeId.Ellipsis))
{
return(MakeTuple(args.Select(ToInstance).ToArray()));
}
goto case "List";
case "List":
case "Container":
case "MutableSequence":
case "Sequence":
case "MutableSet":
case "Set":
case "FrozenSet":
case "KeysView":
case "ValuesView":
case "ItemsView":
if (GetSequenceTypes(name, args, out realType, out keyTypes, out valueTypes))
{
var p = new ProtocolInfo(Entry, State);
p.AddReference(_node, _unit);
np = realType == null ? new NameProtocol(p, name) : new NameProtocol(p, realType);
np.ExtendDescription(valueTypes.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]", alwaysUsePrefixSuffix: true));
p.AddProtocol(np);
p.AddProtocol(new IterableProtocol(p, valueTypes));
if (keyTypes != null)
{
p.AddProtocol(new GetItemProtocol(p, keyTypes, valueTypes));
}
return(p);
}
break;
case "Mapping":
case "MappingView":
case "MutableMapping":
case "Dict":
if (GetSequenceTypes(name, args, out realType, out keyTypes, out valueTypes))
{
var p = new ProtocolInfo(Entry, State);
p.AddReference(_node, _unit);
np = realType == null ? new NameProtocol(p, name) : new NameProtocol(p, realType);
np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "["));
np.ExtendDescription(keyTypes.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]", defaultIfEmpty: "Any"));
np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", "));
np.ExtendDescription(valueTypes.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]", defaultIfEmpty: "Any"));
np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "]"));
p.AddProtocol(np);
p.AddProtocol(new MappingProtocol(p, keyTypes, valueTypes, MakeTuple(keyTypes, valueTypes)));
return(p);
}
break;
case "Callable":
if (args.Count > 0)
{
var p = new ProtocolInfo(Entry, State);
p.AddReference(_node, _unit);
np = new NameProtocol(p, Types[BuiltinTypeId.Function]);
var call = new CallableProtocol(
p,
null,
GetTypeList(args[0]).Select(ToInstance).ToArray(),
ToInstance(args.ElementAtOrDefault(1) ?? AnalysisSet.Empty)
);
np.ExtendDescription(call.GetRichDescription());
p.AddProtocol(np);
p.AddProtocol(call);
return(p);
}
break;
case "Iterable":
if (args.Count > 0)
{
var p = new ProtocolInfo(Entry, State);
p.AddReference(_node, _unit);
np = new NameProtocol(p, "iterable", memberType: PythonMemberType.Class);
var ip = new IterableProtocol(p, AnalysisSet.UnionAll(args.Select(ToInstance)));
np.ExtendDescription(ip.GetRichDescription());
p.AddProtocol(np);
p.AddProtocol(ip);
return(p);
}
break;
case "Iterator":
if (args.Count > 0)
{
var p = new ProtocolInfo(Entry, State);
p.AddReference(_node, _unit);
np = new NameProtocol(p, "iterator", memberType: PythonMemberType.Class);
var ip = new IteratorProtocol(p, AnalysisSet.UnionAll(args.Select(ToInstance)));
np.ExtendDescription(ip.GetRichDescription());
p.AddProtocol(np);
p.AddProtocol(ip);
return(p);
}
break;
case "Generator":
if (args.Count > 0)
{
var p = new ProtocolInfo(Entry, State);
p.AddReference(_node, _unit);
np = new NameProtocol(p, Types[BuiltinTypeId.Generator]);
var yielded = ToInstance(args[0]);
var sent = args.Count > 1 ? ToInstance(args[1]) : AnalysisSet.Empty;
var returned = args.Count > 2 ? ToInstance(args[2]) : AnalysisSet.Empty;
var gp = new GeneratorProtocol(p, yielded, sent, returned);
np.ExtendDescription(gp.GetRichDescription());
p.AddProtocol(np);
p.AddProtocol(gp);
return(p);
}
break;
case "NamedTuple":
return(CreateNamedTuple(_node, _unit, args.ElementAtOrDefault(0), args.ElementAtOrDefault(1)));
case " List":
return(AnalysisSet.UnionAll(args.Select(ToInstance)));
}
return(null);
}
public TupleProtocol(ProtocolInfo self, IEnumerable <IAnalysisSet> values) : base(self, AnalysisSet.UnionAll(values))
{
_values = values.Select(s => s.AsUnion(1)).ToArray();
}
public override IAnalysisSet MakeUnion(IReadOnlyList <IAnalysisSet> types)
{
return(AnalysisSet.UnionAll(types));
}
IAnalysisSet ReturnUnionOfInputs(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames)
{
return(AnalysisSet.UnionAll(args));
}
public override IAnalysisSet GetDescriptor(PythonAnalyzer projectState, AnalysisValue instance, AnalysisValue context)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetDescriptor(projectState, instance, context))));
}
public override IAnalysisSet GetInstanceType()
{
_instance = _instance ?? AnalysisSet.UnionAll(_protocols.Select(p => p.GetInstanceType()).WhereNotNull().DefaultIfEmpty(this));
return(_instance);
}
public override IAnalysisSet GetIndex(Node node, AnalysisUnit unit, IAnalysisSet index)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetIndex(node, unit, index))));
}
public override IAnalysisSet GetReturnForYieldFrom(Node node, AnalysisUnit unit)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetReturnForYieldFrom(node, unit)).WhereNotNull()));
}
public override IAnalysisSet GetIterator(Node node, AnalysisUnit unit)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.GetIterator(node, unit))));
}
public override IAnalysisSet UnaryOperation(Node node, AnalysisUnit unit, PythonOperator operation)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.UnaryOperation(node, unit, operation)).WhereNotNull()));
}
public override IAnalysisSet ReverseBinaryOperation(Node node, AnalysisUnit unit, PythonOperator operation, IAnalysisSet rhs)
{
return(AnalysisSet.UnionAll(_protocols.Select(p => p.ReverseBinaryOperation(node, unit, operation, rhs))));
}
internal static IAnalysisSet GetReturnTypes(IPythonFunction func, PythonAnalyzer projectState)
{
return(AnalysisSet.UnionAll(func.Overloads
.Where(fn => fn.ReturnType != null)
.Select(fn => projectState.GetAnalysisSetFromObjects(fn.ReturnType))));
}
