public void SetOfOne_Add_Union()
{
var set = AnalysisSet.CreateUnion(nsA1, UnionComparer.Instances[0]);
bool added;
set = set.Add(nsA1, out added, true);
Assert.IsInstanceOfType(set, typeof(AnalysisSetOneUnion));
Assert.IsFalse(added);
set = set.Add(nsA1, out added, false);
Assert.IsInstanceOfType(set, typeof(AnalysisSetOneUnion));
Assert.IsFalse(added);
set = set.Add(nsB1, out added, true);
Assert.IsInstanceOfType(set, typeof(AnalysisSetTwoUnion));
AssertUtil.ContainsExactly(set, nsA1, nsB1);
Assert.IsTrue(added);
set = AnalysisSet.CreateUnion(nsA1, UnionComparer.Instances[0]);
var set2 = set.Add(nsA2, out added, true);
Assert.AreNotSame(set, set2);
Assert.IsTrue(added);
AssertUtil.ContainsExactly(set2, nsAU1);
}
internal IAnalysisSet[] GetParameterTypes(int unionStrength = 0)
{
var result = new IAnalysisSet[FunctionDefinition.Parameters.Count];
var units = new HashSet <AnalysisUnit>();
units.Add(AnalysisUnit);
if (_allCalls != null)
{
units.UnionWith(_allCalls.Values);
}
for (int i = 0; i < result.Length; ++i)
{
result[i] = (unionStrength >= 0 && unionStrength <= UnionComparer.MAX_STRENGTH)
? AnalysisSet.CreateUnion(UnionComparer.Instances[unionStrength])
: AnalysisSet.Empty;
VariableDef param;
foreach (var unit in units)
{
if (unit != null && unit.Scope != null && unit.Scope.TryGetVariable(FunctionDefinition.Parameters[i].Name, out param))
{
result[i] = result[i].Union(param.TypesNoCopy);
}
}
}
return(result);
}
public ProtocolInfo(IPythonProjectEntry declaringModule, PythonAnalyzer state)
{
_protocols = AnalysisSet.CreateUnion(1);
DeclaringModule = declaringModule;
DeclaringVersion = declaringModule?.AnalysisVersion ?? -1;
_references = new ReferenceDict();
State = state ?? throw new ArgumentNullException(nameof(state));
}
public void ManySet_Union()
{
var set = AnalysisSet.CreateUnion(new[] { nsA1, nsA2, nsB1, nsB2, nsC1 }, UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisHashSet>().And.OnlyContain(nsAU1, nsBU1, nsC1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA1, nsA2, nsA2, nsB1, nsB1, nsB2, nsB2, nsC1 },
UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisHashSet>().And.OnlyContain(nsAU2, nsBU2, nsC1);
}
public void SetOfTwo_Union()
{
var set = AnalysisSet.CreateUnion(new[] { nsA1, nsA2, nsB1, nsB2 }, UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetTwoUnion>().And.OnlyContain(nsAU1, nsBU1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA1, nsA2, nsA2, nsB1, nsB1, nsB2, nsB2 },
UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetTwoUnion>().And.OnlyContain(nsAU2, nsBU2);
}
internal static AnalysisValue GetUnionType(this IAnalysisSet types)
{
var union = AnalysisSet.CreateUnion(types, UnionComparer.Instances[0]);
AnalysisValue type = null;
if (union.Count == 2)
{
type = union.FirstOrDefault(t => t.GetConstantValue() != null);
}
return(type ?? union.FirstOrDefault());
}
public void SetOfTwo_Union()
{
var set = AnalysisSet.CreateUnion(new[] { nsA1, nsA2, nsB1, nsB2 }, UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetTwoUnion));
AssertUtil.ContainsExactly(set, nsAU1, nsBU1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA1, nsA2, nsA2, nsB1, nsB1, nsB2, nsB2 }, UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetTwoUnion));
AssertUtil.ContainsExactly(set, nsAU2, nsBU2);
}
public void ManySet_Union()
{
var set = AnalysisSet.CreateUnion(new[] { nsA1, nsA2, nsB1, nsB2, nsC1 }, UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisHashSet));
Assert.AreEqual(3, set.Count);
AssertUtil.ContainsExactly(set, nsAU1, nsBU1, nsC1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA1, nsA2, nsA2, nsB1, nsB1, nsB2, nsB2, nsC1 }, UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisHashSet));
Assert.AreEqual(3, set.Count);
AssertUtil.ContainsExactly(set, nsAU2, nsBU2, nsC1);
}
internal void MakeUnionStronger()
{
var cmp = KeyValues.Comparer as UnionComparer;
if (cmp != null && cmp.Strength == UnionComparer.MAX_STRENGTH)
{
return;
}
if (cmp == null)
{
cmp = UnionComparer.Instances[0];
}
else
{
cmp = UnionComparer.Instances[cmp.Strength + 1];
}
var matches = new Dictionary <AnalysisValue, List <KeyValuePair <AnalysisValue, IAnalysisSet> > >(cmp);
foreach (var keyValue in KeyValues)
{
List <KeyValuePair <AnalysisValue, IAnalysisSet> > values;
if (!matches.TryGetValue(keyValue.Key, out values))
{
values = matches[keyValue.Key] = new List <KeyValuePair <AnalysisValue, IAnalysisSet> >();
}
values.Add(keyValue);
}
var keyValues = new Dictionary <AnalysisValue, IAnalysisSet>(cmp);
foreach (var list in matches.Values)
{
var key = AnalysisSet.CreateUnion(list.Select(kv => kv.Key), cmp);
var value = AnalysisSet.CreateUnion(list.SelectMany(kv => kv.Value), cmp);
foreach (var k in key)
{
if (keyValues.TryGetValue(k, out var existing))
{
keyValues[k] = value.Union(existing);
}
else
{
keyValues[k] = value;
}
}
}
KeyValues = keyValues;
}
public IAnalysisSet Union(IEnumerable <AnalysisProxy> items, out bool wasChanged)
{
if (items == null || items is AnalysisSetEmptyObject || items is AnalysisSetEmptyUnion)
{
wasChanged = false;
return(this);
}
if (items is AnalysisSetOneUnion || items is AnalysisSetTwoUnion)
{
wasChanged = true;
return((IAnalysisSet)items);
}
wasChanged = items.Any();
return(wasChanged ? AnalysisSet.CreateUnion(items, Comparer) : this);
}
internal IAnalysisSet GetReturnValue(int unionStrength = 0)
{
var result = (unionStrength >= 0 && unionStrength <= UnionComparer.MAX_STRENGTH)
? AnalysisSet.CreateUnion(UnionComparer.Instances[unionStrength])
: AnalysisSet.Empty;
var fau = AnalysisUnit as FunctionAnalysisUnit;
if (fau != null)
{
result = result.Union(fau.ReturnValue.TypesNoCopy.Resolve(fau));
}
return(result);
}
public void SetOfOne_Union()
{
var set = AnalysisSet.CreateUnion(nsA1, UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetOneUnion>().And.OnlyContain(nsA1);
set = AnalysisSet.CreateUnion(new[] { nsA1 }.AsEnumerable(), UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetOneUnion>().And.OnlyContain(nsA1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA1 }.AsEnumerable(), UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetOneUnion>().And.OnlyContain(nsA1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA2 }.AsEnumerable(), UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetOneUnion>().And.OnlyContain(nsAU1);
}
internal IAnalysisSet GetReturnValue(int unionStrength = 0)
{
var result = (unionStrength >= 0 && unionStrength <= UnionComparer.MAX_STRENGTH)
? AnalysisSet.CreateUnion(UnionComparer.Instances[unionStrength])
: AnalysisSet.Empty;
var units = new HashSet <AnalysisUnit>();
units.Add(AnalysisUnit);
if (_allCalls != null)
{
units.UnionWith(_allCalls.Values);
}
result = result.UnionAll(units.OfType <FunctionAnalysisUnit>().Select(unit => unit.ReturnValue.TypesNoCopy));
return(result);
}
public void EmptySet_Add_Union()
{
var set = AnalysisSet.EmptyUnion;
set.Should().BeOfType <AnalysisSetEmptyUnion>();
set = AnalysisSet.CreateUnion(UnionComparer.Instances[0]);
set.Should().BeOfType <AnalysisSetEmptyUnion>().And.BeSameAs(AnalysisSet.EmptyUnion);
set = set.Add(nsA1, out var added, false);
added.Should().BeTrue();
set.Should().OnlyContain(nsA1);
set = AnalysisSet.EmptyUnion;
set = set.Add(nsA1, out added, true);
added.Should().BeTrue();
set.Should().OnlyContain(nsA1);
}
public void ManySet_Add_Union()
{
var set = AnalysisSet.CreateUnion(new[] { nsA1, nsB1, nsC1 }, UnionComparer.Instances[0]);
IAnalysisSet set2;
bool added;
foreach (var o in new[] { nsA1, nsB1, nsC1 })
{
set2 = set.Add(o, out added, true);
Assert.AreSame(set, set2);
Assert.IsFalse(added);
set2 = set.Add(o, out added, false);
Assert.AreSame(set, set2);
Assert.IsFalse(added);
}
set2 = set.Add(nsA2, out added, true);
Assert.AreSame(set, set2);
Assert.IsInstanceOfType(set2, typeof(AnalysisHashSet));
AssertUtil.ContainsExactly(set2, nsAU1, nsB1, nsC1);
Assert.IsTrue(added);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsB1, nsC1 }, UnionComparer.Instances[0]);
set2 = set.Add(nsA2, out added, false);
Assert.AreNotSame(set, set2);
Assert.IsInstanceOfType(set2, typeof(AnalysisHashSet));
AssertUtil.ContainsExactly(set2, nsAU1, nsB1, nsC1);
Assert.IsTrue(added);
set2 = set.Add(nsB2, out added, false);
Assert.AreNotSame(set, set2);
Assert.IsInstanceOfType(set2, typeof(AnalysisHashSet));
AssertUtil.ContainsExactly(set2, nsA1, nsBU1, nsC1);
Assert.IsTrue(added);
set2 = set.Add(nsC2, out added, false);
Assert.AreNotSame(set, set2);
Assert.IsInstanceOfType(set2, typeof(AnalysisHashSet));
AssertUtil.ContainsExactly(set2, nsA1, nsB1, nsCU1);
Assert.IsTrue(added);
}
public void ManySet_Add_Union()
{
var set = AnalysisSet.CreateUnion(new[] { nsA1, nsB1, nsC1 }, UnionComparer.Instances[0]);
IAnalysisSet set2;
bool added;
foreach (var o in new[] { nsA1, nsB1, nsC1 })
{
set2 = set.Add(o, out added, true);
set2.Should().BeSameAs(set);
added.Should().BeFalse();
set2 = set.Add(o, out added, false);
set2.Should().BeSameAs(set);
added.Should().BeFalse();
}
set2 = set.Add(nsA2, out added, true);
set2.Should().BeSameAs(set)
.And.BeOfType <AnalysisHashSet>()
.And.OnlyContain(nsAU1, nsB1, nsC1);
added.Should().BeTrue();
set = AnalysisSet.CreateUnion(new[] { nsA1, nsB1, nsC1 }, UnionComparer.Instances[0]);
set2 = set.Add(nsA2, out added, false);
set2.Should().NotBeSameAs(set)
.And.BeOfType <AnalysisHashSet>()
.And.OnlyContain(nsAU1, nsB1, nsC1);
added.Should().BeTrue();
set2 = set.Add(nsB2, out added, false);
set2.Should().NotBeSameAs(set)
.And.BeOfType <AnalysisHashSet>()
.And.OnlyContain(nsA1, nsBU1, nsC1);
added.Should().BeTrue();
set2 = set.Add(nsC2, out added, false);
set2.Should().NotBeSameAs(set)
.And.BeOfType <AnalysisHashSet>()
.And.OnlyContain(nsA1, nsB1, nsCU1);
added.Should().BeTrue();
}
public void SetOfOne_Union()
{
var set = AnalysisSet.CreateUnion(nsA1, UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetOneUnion));
AssertUtil.ContainsExactly(set, nsA1);
set = AnalysisSet.CreateUnion(new[] { nsA1 }.AsEnumerable(), UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetOneUnion));
AssertUtil.ContainsExactly(set, nsA1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA1 }.AsEnumerable(), UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetOneUnion));
AssertUtil.ContainsExactly(set, nsA1);
set = AnalysisSet.CreateUnion(new[] { nsA1, nsA2 }.AsEnumerable(), UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetOneUnion));
AssertUtil.ContainsExactly(set, nsAU1);
}
internal bool MakeUnion(int strength)
{
if (strength > UnionStrength)
{
bool anyChanged = false;
_emptySet = AnalysisSet.CreateUnion(strength);
foreach (var value in _dependencies.Values)
{
anyChanged |= value.MakeUnion(strength);
}
if (anyChanged)
{
EnqueueDependents();
return(true);
}
}
return(false);
}
public void EmptySet_Add_Union()
{
var set = AnalysisSet.EmptyUnion;
Assert.IsInstanceOfType(set, typeof(AnalysisSetEmptyUnion));
set = AnalysisSet.CreateUnion(UnionComparer.Instances[0]);
Assert.IsInstanceOfType(set, typeof(AnalysisSetEmptyUnion));
Assert.AreSame(AnalysisSet.EmptyUnion, set);
bool added;
set = set.Add(nsA1, out added, false);
Assert.IsTrue(added);
AssertUtil.ContainsExactly(set, nsA1);
set = AnalysisSet.EmptyUnion;
set = set.Add(nsA1, out added, true);
Assert.IsTrue(added);
AssertUtil.ContainsExactly(set, nsA1);
}
public void SetOfOne_Add_Union()
{
var set = AnalysisSet.CreateUnion(nsA1, UnionComparer.Instances[0]);
set = set.Add(nsA1, out var added, true);
added.Should().BeFalse();
set.Should().BeOfType <AnalysisSetOneUnion>();
set = set.Add(nsA1, out added, false);
added.Should().BeFalse();
set.Should().BeOfType <AnalysisSetOneUnion>();
set = set.Add(nsB1, out added, true);
added.Should().BeTrue();
set.Should().BeOfType <AnalysisSetTwoUnion>().And.OnlyContain(nsA1, nsB1);
set = AnalysisSet.CreateUnion(nsA1, UnionComparer.Instances[0]);
var set2 = set.Add(nsA2, out added, true);
added.Should().BeTrue();
set2.Should().NotBeSameAs(set).And.OnlyContain(nsAU1);
}
internal IAnalysisSet[] GetParameterTypes(int unionStrength = 0)
{
var result = new IAnalysisSet[FunctionDefinition.Parameters.Length];
var units = new HashSet <AnalysisUnit>();
units.Add(AnalysisUnit);
for (int i = 0; i < result.Length; ++i)
{
result[i] = unionStrength >= 0 && unionStrength <= UnionComparer.MAX_STRENGTH
? AnalysisSet.CreateUnion(UnionComparer.Instances[unionStrength])
: AnalysisSet.Empty;
foreach (var unit in units)
{
if (unit != null && unit.InterpreterScope != null && unit.InterpreterScope.TryGetVariable(FunctionDefinition.Parameters[i].Name, out var param))
{
result[i] = result[i].Union(param.Types);
}
}
}
return(result);
}
