public IEnumerable <TypeDefinition> GetSubTypes(TypeDefinition type)
{
var comparer = new TypeEqualityComparer();
return(Types.Where(t => !comparer.Equals(t, type) &&
GetBaseTypes(t).Contains(type, comparer)));
}
private static void AssertNotEqual(Type x, Type y)
{
var eq = new TypeEqualityComparer();
Assert.IsFalse(eq.Equals(x, y));
Assert.IsFalse(eq.Equals(y, x));
Assert.AreNotEqual(eq.GetHashCode(x), eq.GetHashCode(y));
}
/// <summary>
/// <para>
/// Do a strict validation upon the configuration.
/// It means that every events need to be dispatched in at least one bus.
/// </para>
/// <para>
/// If the configuration was not build with the strict flag, this will returns true in all cases.
/// </para>
/// </summary>
/// <returns>True if the configuration is stricly valid, false otherwise.</returns>
public bool ValidateStrict()
{
if (_strict)
{
var typeComparer = new TypeEqualityComparer();
var allTypes = ReflectionTools.GetAllTypes().Where(t =>
(typeof(IDomainEvent).IsAssignableFrom(t) || typeof(ICommand).IsAssignableFrom(t)) && t.IsClass).ToList();
return(allTypes.All(t =>
EventDispatchersConfiguration.Any(cfg => cfg.BusesTypes.WhereNotNull().Any())));
}
return(true);
}
internal void Patch(ModuleDef module)
{
List <TypeDependency> owned = PatchDependency(module, typeDependencies.Concat(typeMixins.Select(m => m.Dependency)));
typeDependencies.RemoveAll(owned.Contains);
typeMixins.RemoveAll(m => owned.Contains(m.Dependency));
HashSet <MethodSig> originals = new HashSet <MethodSig>();
foreach (MethodSig original in typeDependencies.SelectMany(t => t.Originals.Select(module.ToSig)))
{
originals.Add(original);
}
foreach (KeyValuePair <MethodSignature, List <Action <MethodDef> > > method in mixins)
{
MethodDef methodDef = Resolve(module, method.Key);
foreach (Action <MethodDef> action in method.Value)
{
action(methodDef);
}
}
PatchModule?.Invoke(module);
TypeEqualityComparer typeComparer = new TypeEqualityComparer(ComparerOptions);
SignatureEqualityComparer comparer = new SignatureEqualityComparer(ComparerOptions);
Dictionary <TypeSig, TypeSig> typeSubstitutions = this.typeSubstitutions.GroupBy(p => module.ToSig(p.Key), p => module.ToSig(p.Value), typeComparer).Where(g => !typeComparer.Equals(g.Key, g.First())).ToDictionary(g => g.Key, Enumerable.First, typeComparer);
Dictionary <FieldSig, FieldSig> fieldSubstitutions = this.fieldSubstitutions.GroupBy(p => module.ToSig(p.Key), p => module.ToSig(p.Value), comparer).Where(g => !comparer.Equals(g.Key, g.First())).ToDictionary(g => g.Key, Enumerable.First, comparer);
Dictionary <MethodSig, MethodSig> methodSubstitutions = this.methodSubstitutions.GroupBy(p => module.ToSig(p.Key), p => module.ToSig(p.Value), comparer).Where(g => !comparer.Equals(g.Key, g.First())).ToDictionary(g => g.Key, Enumerable.First, comparer);
foreach (TypeDef type in module.GetTypes())
{
foreach (FieldDef field in type.Fields)
{
while (fieldSubstitutions.TryGetValue(field.FieldSig, out FieldSig newFieldSig))
{
field.FieldSig = newFieldSig;
}
field.FieldType = field.FieldType.ApplyToLeaf(typeSubstitutions.Substitute);
}
foreach (MethodDef method in type.Methods)
{
method.MethodSig = methodSubstitutions.Substitute(method.MethodSig);
foreach (Parameter parameter in method.Parameters)
{
parameter.Type = parameter.Type.ApplyToLeaf(typeSubstitutions.Substitute);
}
method.ReturnType = method.ReturnType.ApplyToLeaf(typeSubstitutions.Substitute);
}
}
}
public void TypeEquality_ProtectedNulls()
{
var eq = new TypeEqualityComparer();
foreach (var equals in eq.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name.StartsWith("Equals")))
{
var t = default(object);
var ps = equals.GetParameters();
if (ps.Length == 2)
{
if (ps[0].ParameterType == typeof(Type) && ps[1].ParameterType == typeof(Type))
{
t = typeof(int);
}
else if (ps[0].ParameterType == typeof(IEnumerable <Type>) && ps[1].ParameterType == typeof(IEnumerable <Type>))
{
t = new[] { typeof(int) };
}
else
{
continue;
}
Assert.IsTrue((bool)equals.Invoke(eq, new object[] { null, null }));
Assert.IsFalse((bool)equals.Invoke(eq, new object[] { t, null }));
Assert.IsFalse((bool)equals.Invoke(eq, new object[] { null, t }));
}
}
foreach (var getHashCode in eq.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name.StartsWith("GetHashCode")))
{
var ps = getHashCode.GetParameters();
if (ps.Length == 1)
{
if (ps[0].ParameterType == typeof(Type))
{
Assert.AreNotEqual(0, (int)getHashCode.Invoke(eq, new object[] { null }));
}
}
}
}
public void TypeSlimExtensions_KnownTypes()
{
var d = new Dictionary <Type, TypeSlim>
{
{ typeof(Action), TypeSlimExtensions.ActionType },
{ typeof(bool), TypeSlimExtensions.BooleanType },
{ typeof(Expression <>), TypeSlimExtensions.GenericExpressionType },
{ typeof(int), TypeSlimExtensions.IntegerType },
{ typeof(void), TypeSlimExtensions.VoidType },
};
var eqt = new TypeEqualityComparer();
var eqs = new TypeSlimEqualityComparer();
foreach (var kv in d)
{
Assert.IsTrue(eqt.Equals(kv.Key, kv.Value.ToType()));
Assert.IsTrue(eqs.Equals(kv.Key.ToTypeSlim(), kv.Value));
}
}
public void StructuralTypeEqualityComparer_StructuralEquals()
{
var rt1 = RuntimeCompiler.CreateRecordType(new Dictionary <string, Type>
{
{ "Foo", typeof(int) },
{ "Bar", typeof(string) }
},
true);
var rt2 = RuntimeCompiler.CreateRecordType(new Dictionary <string, Type>
{
{ "Foo", typeof(int) },
{ "Bar", typeof(string) },
},
true);
var at1 = RuntimeCompiler.CreateAnonymousType(new Dictionary <string, Type>
{
{ "Foo", typeof(int) },
{ "Bar", typeof(string) }
},
null);
var at2 = RuntimeCompiler.CreateAnonymousType(new Dictionary <string, Type>
{
{ "Foo", typeof(int) },
{ "Bar", typeof(string) }
},
null);
var eq = new StructuralTypeEqualityComparer();
var orig = new TypeEqualityComparer();
Assert.IsFalse(orig.Equals(rt1, rt2));
Assert.IsTrue(eq.Equals(rt1, rt2));
Assert.IsFalse(orig.Equals(at1, at2));
Assert.IsTrue(eq.Equals(at1, at2));
}
private static void AdaptEncodingOperators(IEncoding oldEncoding, IEncoding newEncoding)
{
if (oldEncoding.GetType() != newEncoding.GetType())
{
return;
}
if (oldEncoding.GetType() == typeof(MultiEncoding))
{
var oldMultiEncoding = (MultiEncoding)oldEncoding;
var newMultiEncoding = (MultiEncoding)newEncoding;
if (!oldMultiEncoding.Encodings.SequenceEqual(newMultiEncoding.Encodings, new TypeEqualityComparer <IEncoding>()))
{
return;
}
var nestedEncodings = oldMultiEncoding.Encodings.Zip(newMultiEncoding.Encodings, (o, n) => new { oldEnc = o, newEnc = n });
foreach (var multi in nestedEncodings)
{
AdaptEncodingOperators(multi.oldEnc, multi.newEnc);
}
}
var comparer = new TypeEqualityComparer <IOperator>();
var cloner = new Cloner();
var oldOperators = oldEncoding.Operators;
var newOperators = newEncoding.Operators;
cloner.RegisterClonedObject(oldEncoding, newEncoding);
var operators = oldOperators.Intersect(newOperators, comparer)
.Select(cloner.Clone)
.Union(newOperators, comparer).ToList();
newEncoding.ConfigureOperators(operators);
newEncoding.Operators = operators;
}
public override bool Execute()
{
if (string.IsNullOrWhiteSpace(DestinationDirectory))
{
Log.LogMessageFromText(nameof(DestinationDirectory) + " is an empty string", MessageImportance.High);
return(false);
}
using (var assemblyFactory = new AssemblyFactory(ReferencePath.Select(a => a.ItemSpec))) {
AssemblyRef netstandardAsmRef = null;
AssemblyDef netstandardAsm = null;
var typeComparer = new TypeEqualityComparer(SigComparerOptions.DontCompareTypeScope);
var netstandardTypes = new HashSet <IType>(typeComparer);
OutputReferencePath = new ITaskItem[ReferencePath.Length];
for (int i = 0; i < ReferencePath.Length; i++)
{
var file = ReferencePath[i];
OutputReferencePath[i] = file;
var filename = file.ItemSpec;
var fileExt = Path.GetExtension(filename);
var asmSimpleName = Path.GetFileNameWithoutExtension(filename);
if (!ShouldPatchAssembly(asmSimpleName))
{
continue;
}
if (!File.Exists(filename))
{
Log.LogMessageFromText($"File does not exist: {filename}", MessageImportance.High);
return(false);
}
var patchDir = DestinationDirectory;
Directory.CreateDirectory(patchDir);
var fileInfo = new FileInfo(filename);
long filesize = fileInfo.Length;
long writeTime = fileInfo.LastWriteTimeUtc.ToBinary();
var extraInfo = $"_{VERSION} {filesize} {writeTime}_";
var patchedFilename = Path.Combine(patchDir, asmSimpleName + extraInfo + fileExt);
if (StringComparer.OrdinalIgnoreCase.Equals(patchedFilename, filename))
{
continue;
}
if (!File.Exists(patchedFilename))
{
var asm = assemblyFactory.Resolve(asmSimpleName);
if (asm == null)
{
throw new Exception($"Couldn't resolve assembly {filename}");
}
var mod = (ModuleDefMD)asm.ManifestModule;
if (!ShouldPatchAssembly(mod))
{
continue;
}
if (netstandardAsm == null)
{
netstandardAsm = assemblyFactory.Resolve("netstandard");
if (netstandardAsm == null)
{
throw new Exception("Couldn't find a netstandard file");
}
netstandardAsmRef = netstandardAsm.ToAssemblyRef();
foreach (var type in netstandardAsm.ManifestModule.GetTypes())
{
if (type.IsGlobalModuleType)
{
continue;
}
if (IsPublic(type))
{
netstandardTypes.Add(type);
}
}
foreach (var type in netstandardAsm.ManifestModule.ExportedTypes)
{
netstandardTypes.Add(type);
}
}
for (uint rid = 1; ; rid++)
{
var tr = mod.ResolveTypeRef(rid);
if (tr == null)
{
break;
}
if (!netstandardTypes.Contains(tr))
{
continue;
}
if (tr.ResolutionScope is AssemblyRef asmRef && CanReplaceAssemblyRef(asmRef))
{
tr.ResolutionScope = netstandardAsmRef;
}
}
var options = new ModuleWriterOptions(mod);
mod.Write(patchedFilename, options);
var xmlDocFile = Path.ChangeExtension(filename, "xml");
if (File.Exists(xmlDocFile))
{
var newXmlDocFile = Path.ChangeExtension(patchedFilename, "xml");
if (File.Exists(newXmlDocFile))
{
File.Delete(newXmlDocFile);
}
File.Copy(xmlDocFile, newXmlDocFile);
}
}
OutputReferencePath[i] = new TaskItem(patchedFilename);
}
return(true);
}
}
public void StructuralTypeEqualityComparer_ManOrBoy2_Success()
{
var rtc = new RuntimeCompiler();
var rt1 = rtc.GetNewRecordTypeBuilder();
var rt2 = rtc.GetNewRecordTypeBuilder();
var at1 = rtc.GetNewAnonymousTypeBuilder();
var at2 = rtc.GetNewAnonymousTypeBuilder();
rtc.DefineRecordType(
rt1,
new Dictionary <string, Type>
{
{ "Self", rt1 },
{ "Copy", rt2 },
{ "Other", typeof(int) }
},
true);
rtc.DefineRecordType(
rt2,
new Dictionary <string, Type>
{
{ "Self", rt2 },
{ "Copy", rt1 },
{ "Other", typeof(int) }
},
true);
rtc.DefineAnonymousType(
at1,
new Dictionary <string, Type>
{
{ "Self", at1 },
{ "Copy", at2 },
{ "Other", typeof(int) }
},
null);
rtc.DefineAnonymousType(
at2,
new Dictionary <string, Type>
{
{ "Self", at2 },
{ "Copy", at1 },
{ "Other", typeof(int) }
},
null);
var rt1c = rt1.CreateType();
var rt2c = rt2.CreateType();
var at1c = at1.CreateType();
var at2c = at2.CreateType();
var eq = new StructuralTypeEqualityComparer();
var orig = new TypeEqualityComparer();
Assert.IsFalse(orig.Equals(rt1c, rt2c));
Assert.IsTrue(eq.Equals(rt1c, rt2c));
Assert.IsFalse(orig.Equals(at1c, at2c));
Assert.IsTrue(eq.Equals(at1c, at2c));
}
public TestScope(Dictionary <Type, object> instances)
{
_instances = new ReadOnlyDictionary <Type, object>(instances);
_typeComparer = new TypeEqualityComparer();
}
public void EqualsWithEqualObjects()
{
var comparer = new TypeEqualityComparer();
Assert.IsTrue(comparer.Equals(typeof(string), typeof(string)));
}
public void EqualsWithBothObjectsNull()
{
var comparer = new TypeEqualityComparer();
Assert.IsFalse(comparer.Equals(null, null));
}
public void EqualsWithSecondObjectNull()
{
var comparer = new TypeEqualityComparer();
Assert.IsFalse(comparer.Equals(typeof(object), null));
}
public void EqualsWithFirstObjectNull()
{
var comparer = new TypeEqualityComparer();
Assert.IsFalse(comparer.Equals(null, typeof(object)));
}
public GenericParamComparer(TypeEqualityComparer typeComparer = null) => this.typeComparer = typeComparer ?? new TypeEqualityComparer(default);
