internal void AddReturnTypes(Node node, AnalysisUnit unit, IAnalysisSet types, bool enqueue = true)
{
if (IsOriginalClosureScope(OuterScope))
{
// Do not add return types to original scope of closure functions
return;
}
if (types?.Any() != true)
{
return;
}
if (Coroutine != null)
{
Coroutine.AddReturn(node, unit, types, enqueue);
}
else if (Generator != null)
{
Generator.AddReturn(node, unit, types, enqueue);
}
else
{
ReturnValue.MakeUnionStrongerIfMoreThan(unit.State.Limits.ReturnTypes, types);
ReturnValue.AddTypes(unit, types, enqueue);
}
}
public override IAnalysisSet GetMember(Node node, AnalysisUnit unit, string name)
{
// Must unconditionally call the base implementation of GetMember
var ignored = base.GetMember(node, unit, name);
var mro = ClassInfo._mro;
if (!mro.IsValid)
{
return(AnalysisSet.Empty);
}
// First item in MRO list is always the class itself.
var member = Values.Mro.GetMemberFromMroNoReferences(mro.Skip(1), node, unit, name, addRef: true);
if (member == null)
{
return(AnalysisSet.Empty);
}
var instances = _instances.Any() ? _instances : unit.ProjectState._noneInst.SelfSet;
IAnalysisSet result = AnalysisSet.Empty;
foreach (var instance in instances)
{
var desc = member.GetDescriptor(node, instance, this, unit);
result = result.Union(desc);
}
return(result);
}
public static bool IsResolvable(this IAnalysisSet set)
{
if (set is AnalysisValue av)
{
return(av.IsResolvable());
}
return(set.Any(IsResolvable));
}
public override IEnumerable <KeyValuePair <string, string> > GetRichDescription()
{
if (_yielded.Any() || _sent.Any() || _returned.Any())
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "["));
if (_yielded.Any())
{
foreach (var kv in _yielded.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]"))
{
yield return(kv);
}
}
else
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "[]"));
}
if (_sent.Any())
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", "));
foreach (var kv in _sent.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]"))
{
yield return(kv);
}
}
else if (_returned.Any())
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", "));
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "[]"));
}
if (_returned.Any())
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", "));
foreach (var kv in _sent.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]"))
{
yield return(kv);
}
}
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "]"));
}
}
internal override int UnionHashCode(int strength)
{
if (strength < MergeStrength.ToObject && _indexTypes.Any())
{
var type = ProjectState.ClassInfos[TypeId];
if (type != null)
{
// Use our unspecialized type's hash code.
return(type.UnionHashCode(strength));
}
}
return(base.UnionHashCode(strength));
}
public override IEnumerable <KeyValuePair <string, string> > GetRichDescription()
{
if (_yielded.Any())
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "["));
foreach (var kv in _yielded.GetRichDescriptions())
{
yield return(kv);
}
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "]"));
}
}
internal void AddReturnTypes(Node node, AnalysisUnit unit, IAnalysisSet types, bool enqueue = true) {
if (types?.Any() != true) {
return;
}
if (Coroutine != null) {
Coroutine.AddReturn(node, unit, types, enqueue);
} else if (Generator != null) {
Generator.AddReturn(node, unit, types, enqueue);
} else {
ReturnValue.MakeUnionStrongerIfMoreThan(unit.ProjectState.Limits.ReturnTypes, types);
ReturnValue.AddTypes(unit, types, enqueue);
}
}
public override IEnumerable <KeyValuePair <string, string> > GetRichDescription()
{
if (_valueType.Any())
{
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "["));
if (_keyType.Any(k => k.TypeId != BuiltinTypeId.Int))
{
foreach (var kv in _keyType.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]"))
{
yield return(kv);
}
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", "));
}
foreach (var kv in _valueType.GetRichDescriptions(unionPrefix: "[", unionSuffix: "]"))
{
yield return(kv);
}
yield return(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "]"));
}
}
internal void AssignTo(Node assignStmt, Expression left, IAnalysisSet values)
{
if (left is ExpressionWithAnnotation)
{
left = ((ExpressionWithAnnotation)left).Expression;
// "x:t=..." is a recommended pattern - we do not want to
// actually assign the ellipsis in this case.
if (values.Any(v => v.TypeId == BuiltinTypeId.Ellipsis))
{
values = AnalysisSet.Create(values.Where(v => v.TypeId != BuiltinTypeId.Ellipsis), values.Comparer);
}
}
if (left is NameExpression)
{
var l = (NameExpression)left;
if (!string.IsNullOrEmpty(l.Name))
{
Scope.AssignVariable(
l.Name,
l,
_unit,
values
);
}
}
else if (left is MemberExpression)
{
var l = (MemberExpression)left;
if (!string.IsNullOrEmpty(l.Name))
{
foreach (var obj in Evaluate(l.Target).Resolve(_unit))
{
obj.SetMember(l, _unit, l.Name, values.Resolve(_unit));
}
}
}
else if (left is IndexExpression)
{
var l = (IndexExpression)left;
var indexObj = Evaluate(l.Index);
foreach (var obj in Evaluate(l.Target).Resolve(_unit))
{
obj.SetIndex(assignStmt, _unit, indexObj, values.Resolve(_unit));
}
}
else if (left is SequenceExpression)
{
// list/tuple
var l = (SequenceExpression)left;
var valuesArr = values.ToArray();
for (var i = 0; i < l.Items.Count; i++)
{
if (valuesArr.Length > 0)
{
foreach (var value in valuesArr)
{
AssignTo(assignStmt, l.Items[i], value.GetIndex(assignStmt, _unit, ProjectState.GetConstant(i)));
}
}
else
{
AssignTo(assignStmt, l.Items[i], AnalysisSet.Empty);
}
}
}
}
public override string ToString()
{
return(string.Join(", ", Args.Take(Count).Select(a => a.ToString())) +
(SequenceArgs.Any() ? ", *" + SequenceArgs.ToString() : "") +
(DictArgs.Any() ? ", **" + DictArgs.ToString() : ""));
}
