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); }