public ISymbolReader GetSymbolReader(ModuleDefinition module, Stream symbolStream)
{
Mixin.CheckModule (module);
Mixin.CheckStream (symbolStream);
return new PdbReader (Disposable.NotOwned (symbolStream));
}
public static ImageWriter CreateDebugWriter(ModuleDefinition module, MetadataBuilder metadata, Disposable<Stream> stream)
{
var writer = new ImageWriter (module, "PDB V1.0", metadata, stream, metadataOnly: true);
var length = metadata.text_map.GetLength ();
writer.text = new Section { SizeOfRawData = length, VirtualSize = length };
return writer;
}
public void ReadModule()
{
if (pdbFound)
{
using (var symbolStream = File.OpenRead(pdbPath))
{
var readerParameters = new ReaderParameters
{
AssemblyResolver = this,
ReadSymbols = pdbFound || mdbFound,
SymbolReaderProvider = debugReaderProvider,
SymbolStream = symbolStream
};
ModuleDefinition = ModuleDefinition.ReadModule(AssemblyFilePath, readerParameters);
}
}
else
{
var readerParameters = new ReaderParameters
{
AssemblyResolver = this,
ReadSymbols = pdbFound || mdbFound,
SymbolReaderProvider = debugReaderProvider,
};
ModuleDefinition = ModuleDefinition.ReadModule(AssemblyFilePath, readerParameters);
}
}
public void OtherMethod(ModuleDefinition module)
{
var type = module.GetType ("Others");
Assert.IsTrue (type.HasProperties);
var properties = type.Properties;
Assert.AreEqual (1, properties.Count);
var property = properties [0];
Assert.IsNotNull (property);
Assert.AreEqual ("Context", property.Name);
Assert.IsNotNull (property.PropertyType);
Assert.AreEqual ("System.String", property.PropertyType.FullName);
Assert.IsTrue (property.HasOtherMethods);
Assert.AreEqual (2, property.OtherMethods.Count);
var other = property.OtherMethods [0];
Assert.AreEqual ("let_Context", other.Name);
other = property.OtherMethods [1];
Assert.AreEqual ("bet_Context", other.Name);
}
internal PdbWriter (SymWriter writer, ModuleDefinition module, string assembly)
{
m_writer = writer;
m_module = module;
m_documents = new Hashtable ();
m_assembly = assembly;
}
public void TestUseCombinedSkinsSchemaWhenNoDefaultTemplate()
{
var templateInfo = new StringTemplateInfo("test", "");
var templateInfo2 = new StringTemplateInfo("test2", "");
var schema1 = new JSchema();
var schema2 = new JSchema();
var templateSchemaProvider = new Mock<ISchemaProvider>();
templateSchemaProvider.Setup(f => f.GetSchemaFromTemplateAsync(templateInfo)).Returns(Task.FromResult(schema1));
templateSchemaProvider.Setup(f => f.GetSchemaFromTemplateAsync(templateInfo2)).Returns(Task.FromResult(schema2));
var combiner = new Mock<SchemaCombiner>();
combiner.Setup(c =>
c.Apply(It.Is<JSchema>(s => s == schema1), It.Is<JSchema>(s => s == schema2), It.IsAny<SchemaComparisionReport>(), It.IsAny<string>()))
.Returns(new JSchema());
var moduleDefintion = new ModuleDefinition("testmod", null, new Dictionary<string, TemplateInfo>
{
{"skin1", templateInfo},
{"skin2", templateInfo2}
});
var underTest = new DefaultModuleSchemaProvider(combiner.Object, templateSchemaProvider.Object);
var result = underTest.GetSchemaFromModuleAsync(moduleDefintion);
Assert.IsNotNull(result);
combiner.Verify();
}
public ISymbolReader GetSymbolReader(ModuleDefinition module, string fileName)
{
Mixin.CheckModule (module);
Mixin.CheckFileName (fileName);
return new PdbReader (Disposable.Owned (File.OpenRead (Mixin.GetPdbFileName (fileName)) as Stream));
}
public string ReplaceTokens(string template, ModuleDefinition moduleDefinition, Repository repo, string changestring)
{
var assemblyVersion = moduleDefinition.Assembly.Name.Version;
var branch = repo.Head;
template = template.Replace("%version%", assemblyVersion.ToString());
template = template.Replace("%version1%", assemblyVersion.ToString(1));
template = template.Replace("%version2%", assemblyVersion.ToString(2));
template = template.Replace("%version3%", assemblyVersion.ToString(3));
template = template.Replace("%version4%", assemblyVersion.ToString(4));
template = template.Replace("%now%", now.ToShortDateString());
template = template.Replace("%utcnow%", utcNow.ToShortDateString());
template = template.Replace("%githash%", branch.Tip.Sha);
template = template.Replace("%shorthash%", branch.Tip.Sha.Substring(0, 8));
template = template.Replace("%branch%", branch.FriendlyName);
template = template.Replace("%haschanges%", repo.IsClean() ? "" : changestring);
template = template.Replace("%user%", FormatUserName());
template = template.Replace("%machine%", Environment.MachineName);
template = reEnvironmentToken.Replace(template, FormatEnvironmentVariable);
template = reNow.Replace(template, FormatTime);
template = reUtcNow.Replace(template, FormatUtcTime);
return template.Trim();
}
public ReflectionController (ModuleDefinition module)
{
m_reader = new AggressiveReflectionReader (module);
m_writer = new ReflectionWriter (module);
m_helper = new ReflectionHelper (module);
m_importer = new DefaultImporter (module);
}
public virtual void ReadModule()
{
string symbolsPath;
if (pdbFound)
{
symbolsPath = pdbPath;
}
else
{
symbolsPath = mdbPath;
}
var tempAssembly = $"{AssemblyFilePath}.tmp";
var tempSymbols = $"{symbolsPath}.tmp";
File.Copy(AssemblyFilePath, tempAssembly,true);
File.Copy(symbolsPath, tempSymbols, true);
SymbolStream = File.OpenRead(tempSymbols);
var readerParameters = new ReaderParameters
{
AssemblyResolver = this,
ReadSymbols = true,
SymbolReaderProvider = debugReaderProvider,
SymbolStream = SymbolStream,
};
ModuleDefinition = ModuleDefinition.ReadModule(tempAssembly, readerParameters);
}
internal TypeReference GetTypeReference(ModuleDefinition module)
{
var ret = _type as Type;
return ret != null
? module.SafeImport(ret)
: module.SafeImport(_type as TypeReference);
}
internal PdbWriter(ISymbolWriter writer, ModuleDefinition module, string pdb)
{
m_writer = writer;
m_module = module;
m_documents = new Hashtable ();
m_pdb = pdb;
}
internal PortablePdbReader(Image image, ModuleDefinition module)
{
this.image = image;
this.module = module;
this.reader = module.reader;
this.debug_reader = new MetadataReader (image, module, this.reader);
}
private void IdentifyModule(ModuleDefinition module)
{
if (_allMethods.ContainsKey(module)) return;
_allMethods.Add(module, new Dictionary<ClassDecl, List<Method>>());
foreach (var decl in module.TopLevelDecls)
IdentifyTopLevelDecl(decl);
}
public RefinementToken(IToken tok, ModuleDefinition m)
: base(tok)
{
Contract.Requires(tok != null);
Contract.Requires(m != null);
this.InheritingModule = m;
}
public ExportedType(string @namespace, string name, ModuleDefinition module, IMetadataScope scope)
{
this.@namespace = @namespace;
this.name = name;
this.scope = scope;
this.module = module;
}
public async Task<JSchema> GetSchemaFromModuleAsync(ModuleDefinition module)
{
IEnumerable<TemplateInfo> templates;
if (module.Skins != null)
templates = module.Skins.Values;
else
templates = Enumerable.Empty<TemplateInfo>();
if (module.DefaultTemplate != null)
templates = templates.Union(new[] {module.DefaultTemplate});
var enumerator = templates.GetEnumerator();
if (!enumerator.MoveNext())
return null;
var result = await _schemaProvider.GetSchemaFromTemplateAsync(enumerator.Current).ConfigureAwait(false);
var report = new SchemaComparisionReport();
while (enumerator.MoveNext())
{
var schema = await _schemaProvider.GetSchemaFromTemplateAsync(enumerator.Current).ConfigureAwait(false);
result = _schemaCombiner.Apply(result, schema, report);
}
return result;
}
private static ModuleDefinition GetClrBasicsFor(string file, PEFile pe)
{
var stream = new MemoryStream(File.ReadAllBytes(file));
var reader = new BinaryStreamReader(stream, new byte[1024]);
pe.ReadFrom(reader);
var clrDirectory = pe.OptionalHeader.DataDirectories[(int)DataDirectoryKind.Clr];
var rvaStream = new RvaStream(
stream,
pe.SectionHeaders.Select(
s => new RvaStream.Range
{
PhysicalAddress = s.PointerToRawData,
Size = s.VirtualSize,
VirtualAddress = s.VirtualAddress
})
.ToArray());
rvaStream.Position = clrDirectory.VirtualAddress;
var sectionReader = new BinaryStreamReader(rvaStream, new byte[32]);
var clrmod = new ModuleDefinition();
ClrModuleReader.Read(sectionReader, clrmod);
return clrmod;
}
public void Main (ModuleDefinition module)
{
var type = module.GetType ("Program");
var main = type.GetMethod ("Main");
AssertCode (@"
.locals init (System.Int32 i)
.line 7,7:0,0 'C:\sources\cecil\symbols\Mono.Cecil.Mdb\Test\Resources\assemblies\hello.cs'
IL_0000: ldc.i4.0
IL_0001: stloc.0
.line 7,7:0,0 'C:\sources\cecil\symbols\Mono.Cecil.Mdb\Test\Resources\assemblies\hello.cs'
IL_0002: br IL_0013
.line 8,8:0,0 'C:\sources\cecil\symbols\Mono.Cecil.Mdb\Test\Resources\assemblies\hello.cs'
IL_0007: ldarg.0
IL_0008: ldloc.0
IL_0009: ldelem.ref
IL_000a: call System.Void Program::Print(System.String)
.line 7,7:0,0 'C:\sources\cecil\symbols\Mono.Cecil.Mdb\Test\Resources\assemblies\hello.cs'
IL_000f: ldloc.0
IL_0010: ldc.i4.1
IL_0011: add
IL_0012: stloc.0
IL_0013: ldloc.0
IL_0014: ldarg.0
IL_0015: ldlen
IL_0016: conv.i4
IL_0017: blt IL_0007
.line 10,10:0,0 'C:\sources\cecil\symbols\Mono.Cecil.Mdb\Test\Resources\assemblies\hello.cs'
IL_001c: ldc.i4.0
IL_001d: ret
", main);
}
public static Collection<GenericParameter> GetGenericParameters (
this IGenericParameterProvider self,
ModuleDefinition module)
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.ReadGenericParameters (provider))
: new Collection<GenericParameter> ();
}
public static bool GetHasGenericParameters (
this IGenericParameterProvider self,
ModuleDefinition module)
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.HasGenericParameters (provider))
: false;
}
public ISymbolReader CreateReader (ModuleDefinition module, string assemblyFileName)
{
#if NATIVE_READER
return new PdbReader (PdbHelper.CreateReader (assemblyFileName));
#else
return new PdbCciReader (module, GetPdbFileName (assemblyFileName));
#endif
}
public static bool GetHasMarshalInfo (
this IMarshalInfoProvider self,
ModuleDefinition module)
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.HasMarshalInfo (provider))
: false;
}
public static Collection<CustomAttribute> GetCustomAttributes (
this ICustomAttributeProvider self,
ModuleDefinition module)
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.ReadCustomAttributes (provider))
: new Collection<CustomAttribute> ();
}
public Task UpdateModelForModuleAsync(ModuleDefinition moduleDefinition, string dataId, object content)
{
var filePath = GetPath(moduleDefinition, dataId != null ? PathInfo.Create(dataId) : DefaultFilename);
if (!_fileSystem.DirectoryExists(_fileSystem.Path.GetDirectoryName(filePath)))
_fileSystem.CreateDirectory(_fileSystem.Path.GetDirectoryName(filePath));
return Update(content, filePath);
}
public static MarshalInfo GetMarshalInfo (
this IMarshalInfoProvider self,
ModuleDefinition module)
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.ReadMarshalInfo (provider))
: null;
}
public static bool GetHasCustomAttributes (
this ICustomAttributeProvider self,
ModuleDefinition module)
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.HasCustomAttributes (provider))
: false;
}
private static void AddICollectionTProxy(ModuleDefinition moduleDefinition, TypeDefinition type, GenericInstanceType collectionT)
{
var itemType = collectionT.GenericArguments[0];
var itemArray = itemType.MakeArrayType();
var proxyType = CreateProxy(moduleDefinition, type);
TypeReference proxyTypeRef = proxyType;
if (type.HasGenericParameters)
proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(gp => new GenericParameter(gp.Position, gp.Type, gp.Module)).ToArray());
var field = proxyType.Fields[0];
var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef);
var countProperty = type.Properties.First(p => p.Name == "Count" || p.Name == "System.Collections.ICollection.Count");
MethodReference countMethod = countProperty.GetMethod;
MethodReference copyToMethod = type.Methods.First(p => p.Name == "CopyTo" || p.Name == "System.Collections.ICollection.CopyTo");
if (type.HasGenericParameters)
{
countMethod = countMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(gp => new GenericParameter(gp.Position, gp.Type, gp.Module)).ToArray());
copyToMethod = copyToMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(gp => new GenericParameter(gp.Position, gp.Type, gp.Module)).ToArray());
}
var getMethod = new MethodDefinition("get_Items", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, itemArray);
var getMethodBody = getMethod.Body;
var localItems = new VariableDefinition("items", itemArray);
getMethodBody.Variables.Add(localItems);
getMethodBody.SimplifyMacros();
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, countMethod));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Newarr, itemType));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Stloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldlen));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Conv_I4));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, copyToMethod));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ret));
getMethodBody.InitLocals = true;
getMethodBody.OptimizeMacros();
proxyType.Methods.Add(getMethod);
var property = new PropertyDefinition("Items", PropertyAttributes.None, itemArray);
property.GetMethod = getMethod;
var debuggerBrowsableAttribute = new CustomAttribute(ReferenceFinder.DebuggerBrowsableAttributeCtor);
debuggerBrowsableAttribute.ConstructorArguments.Add(new CustomAttributeArgument(ReferenceFinder.DebuggerBrowsableStateType, DebuggerBrowsableState.RootHidden));
property.CustomAttributes.Add(debuggerBrowsableAttribute);
proxyType.Properties.Add(property);
AddDebuggerTypeProxyAttribute(type, proxyType);
}
public ISymbolReader GetSymbolReader(ModuleDefinition module, string fileName)
{
Mixin.CheckModule (module);
Mixin.CheckFileName (fileName);
return IsPortablePdb (Mixin.GetPdbFileName (fileName))
? new PortablePdbReaderProvider ().GetSymbolReader (module, fileName)
: new NativePdbReaderProvider ().GetSymbolReader (module, fileName);
}
public static MarshalInfo GetMarshalInfo(
IMarshalInfoProvider self,
ref MarshalInfo variable,
ModuleDefinition module)
{
return Mixin.HasImage(module)
? module.Read(ref variable, self, (provider, reader) => reader.ReadMarshalInfo(provider))
: null;
}
public IMetadataImporter GetMetadataImporter(ModuleDefinition module)
{
return(new CoreLibMetadataImporter(module));
}
public void VisitModuleDefinition(ModuleDefinition module)
{
}
public static TypeReference GetBindablePropertyTypeConverter(this FieldReference bpRef, ModuleDefinition module)
{
TypeReference _;
var owner = bpRef.DeclaringType;
var bpName = bpRef.Name.EndsWith("Property", StringComparison.Ordinal) ? bpRef.Name.Substring(0, bpRef.Name.Length - 8) : bpRef.Name;
var property = owner.GetProperty(pd => pd.Name == bpName, out _);
var staticGetter = owner.GetMethods(md => md.Name == $"Get{bpName}" &&
md.IsStatic &&
md.IsPublic &&
md.Parameters.Count == 1 &&
md.Parameters[0].ParameterType.InheritsFromOrImplements(module.ImportReference(typeof(BindableObject))), module).SingleOrDefault()?.Item1;
var attributes = new List <CustomAttribute>();
if (property != null && property.HasCustomAttributes)
{
attributes.AddRange(property.CustomAttributes);
}
if (property != null && property.PropertyType.Resolve().HasCustomAttributes)
{
attributes.AddRange(property.PropertyType.Resolve().CustomAttributes);
}
if (staticGetter != null && staticGetter.HasCustomAttributes)
{
attributes.AddRange(staticGetter.CustomAttributes);
}
if (staticGetter != null && staticGetter.ReturnType.Resolve().HasCustomAttributes)
{
attributes.AddRange(staticGetter.ReturnType.Resolve().CustomAttributes);
}
return(attributes.FirstOrDefault(cad => TypeConverterAttribute.TypeConvertersType.Contains(cad.AttributeType.FullName))?.ConstructorArguments [0].Value as TypeReference);
}
public PortablePdbWriter(MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer)
: this(pdb_metadata, module)
{
this.writer = writer;
}
public void MatchDifferentCorLibTypeSignatures()
{
var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld);
Assert.NotEqual(module.CorLibTypeFactory.Byte, module.CorLibTypeFactory.Boolean, _comparer);
}
/// <inheritdoc/>
public async Task <bool?> TryEvaluateModuleAsync(IEvaluationScheduler scheduler, ModuleDefinition module, QualifierId qualifierId)
{
Contract.Requires(scheduler != null);
Contract.Requires(module != null);
Contract.Requires(qualifierId.IsValid);
Contract.Assert(m_resolverState == State.ResolverInitialized);
Contract.Assert(m_owningModules != null, "Owning modules should not be null if the instance is initialized.");
var moduleDefinition = (ModuleDefinition)module;
if (!m_owningModules.TryGetValue(moduleDefinition.Descriptor.Id, out Package package))
{
// Current resolver doesn't own the given module.
return(null);
}
return(await DoTryEvaluateModuleAsync(scheduler, moduleDefinition, qualifierId));
}
public ISymbolReader GetSymbolReader(ModuleDefinition module, string fileName)
{
return(IsPortablePdb(GetPdbFileName(fileName))
? new PortablePdbReaderProvider().GetSymbolReader(module, fileName)
: new NativePdbReaderProvider().GetSymbolReader(module, fileName));
}
// Called after the patching process and after scripts are compiled.
// Used to link references between both assemblies
// Return true if successful
public bool Link(ModuleDefinition gameModule, ModuleDefinition modModule)
{
return(true);
}
private async Task <bool> DoTryEvaluateModuleAsync(IEvaluationScheduler scheduler, ModuleDefinition module, QualifierId qualifierId)
{
var qualifier = QualifierValue.Create(qualifierId, QualifierValueCache, Context.QualifierTable, Context.StringTable);
// We don't want to evaluate the transitive closure of the import/export relationship, just the package.
var evalJobs = module.Specs.Select(
spec => EvaluateAsync(scheduler, spec, qualifier, asPackageEvaluation: false));
var allTasks = await Task.WhenAll(evalJobs);
var result = allTasks.All(t => t.Success);
if (m_evaluationDecorator != null)
{
foreach (var evaluationResult in allTasks)
{
m_evaluationResults.Enqueue(evaluationResult);
}
}
return(result);
}
/// <summary>
/// Executes this property weaver.
/// </summary>
public void Execute()
{
var reactiveUI = ModuleDefinition.AssemblyReferences.Where(x => x.Name == "ReactiveUI").OrderByDescending(x => x.Version).FirstOrDefault();
if (reactiveUI == null)
{
LogInfo("Could not find assembly: ReactiveUI (" + string.Join(", ", ModuleDefinition.AssemblyReferences.Select(x => x.Name)) + ")");
return;
}
LogInfo($"{reactiveUI.Name} {reactiveUI.Version}");
var helpers = ModuleDefinition.AssemblyReferences.Where(x => x.Name == "ReactiveUI.Fody.Helpers").OrderByDescending(x => x.Version).FirstOrDefault();
if (helpers == null)
{
LogInfo("Could not find assembly: ReactiveUI.Fody.Helpers (" + string.Join(", ", ModuleDefinition.AssemblyReferences.Select(x => x.Name)) + ")");
return;
}
LogInfo($"{helpers.Name} {helpers.Version}");
var reactiveObject = ModuleDefinition.FindType("ReactiveUI", "ReactiveObject", reactiveUI);
// The types we will scan are subclasses of ReactiveObject
var targetTypes = ModuleDefinition.GetAllTypes().Where(x => x.BaseType != null && reactiveObject.IsAssignableFrom(x.BaseType));
var observableAsPropertyHelper = ModuleDefinition.FindType("ReactiveUI", "ObservableAsPropertyHelper`1", reactiveUI, "T");
var observableAsPropertyAttribute = ModuleDefinition.FindType("ReactiveUI.Fody.Helpers", "ObservableAsPropertyAttribute", helpers);
var observableAsPropertyHelperGetValue = ModuleDefinition.ImportReference(observableAsPropertyHelper.Resolve().Properties.Single(x => x.Name == "Value").GetMethod);
var exceptionDefinition = FindType(typeof(Exception).FullName);
var constructorDefinition = exceptionDefinition.GetConstructors().Single(x => x.Parameters.Count == 1);
var exceptionConstructor = ModuleDefinition.ImportReference(constructorDefinition);
foreach (var targetType in targetTypes)
{
foreach (var property in targetType.Properties.Where(x => x.IsDefined(observableAsPropertyAttribute) || (x.GetMethod?.IsDefined(observableAsPropertyAttribute) ?? false)).ToArray())
{
var genericObservableAsPropertyHelper = observableAsPropertyHelper.MakeGenericInstanceType(property.PropertyType);
var genericObservableAsPropertyHelperGetValue = observableAsPropertyHelperGetValue.Bind(genericObservableAsPropertyHelper);
ModuleDefinition.ImportReference(genericObservableAsPropertyHelperGetValue);
// Declare a field to store the property value
var field = new FieldDefinition("$" + property.Name, FieldAttributes.Private, genericObservableAsPropertyHelper);
targetType.Fields.Add(field);
// It's an auto-property, so remove the generated field
if (property.SetMethod != null && property.SetMethod.HasBody)
{
// Remove old field (the generated backing field for the auto property)
var oldField = (FieldReference)property.GetMethod.Body.Instructions.Where(x => x.Operand is FieldReference).Single().Operand;
var oldFieldDefinition = oldField.Resolve();
targetType.Fields.Remove(oldFieldDefinition);
// Re-implement setter to throw an exception
property.SetMethod.Body = new MethodBody(property.SetMethod);
property.SetMethod.Body.Emit(il =>
{
il.Emit(OpCodes.Ldstr, "Never call the setter of an ObservabeAsPropertyHelper property.");
il.Emit(OpCodes.Newobj, exceptionConstructor);
il.Emit(OpCodes.Throw);
il.Emit(OpCodes.Ret);
});
}
property.GetMethod.Body = new MethodBody(property.GetMethod);
property.GetMethod.Body.Emit(il =>
{
var isValid = il.Create(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0); // this
il.Emit(OpCodes.Ldfld, field.BindDefinition(targetType)); // pop -> this.$PropertyName
il.Emit(OpCodes.Dup); // Put an extra copy of this.$PropertyName onto the stack
il.Emit(OpCodes.Brtrue, isValid); // If the helper is null, return the default value for the property
il.Emit(OpCodes.Pop); // Drop this.$PropertyName
EmitDefaultValue(property.GetMethod.Body, il, property.PropertyType); // Put the default value onto the stack
il.Emit(OpCodes.Ret); // Return that default value
il.Append(isValid); // Add a marker for if the helper is not null
il.Emit(OpCodes.Callvirt, genericObservableAsPropertyHelperGetValue); // pop -> this.$PropertyName.Value
il.Emit(OpCodes.Ret); // Return the value that is on the stack
});
}
}
}
public static TypeDefinition InjectClassDefinition(ModuleDefinition mdef, string name, TypeReference baseType)
{
return(InjectTypeDefinition(mdef, name, baseType));
}
public XUnitInstrumentator(ModuleDefinition testModule, InstrumentatorParameters parameters) : base(testModule, parameters)
{
}
public override void Execute()
{
foreach (var definitionType in ModuleDefinition.Types.Where(x => x.Properties.Any()))
{
var equals =
new MethodDefinition(
nameof(object.Equals),
MethodAttributes.Public
| MethodAttributes.HideBySig
| MethodAttributes.Virtual,
ModuleDefinition.TypeSystem.Boolean)
{
Body =
{
MaxStackSize = 2,
InitLocals = true
}
};
// Init arguments.
var argumentObj = new ParameterDefinition("other", ParameterAttributes.None, ModuleDefinition.TypeSystem.Object);
equals.Parameters.Add(argumentObj);
equals.Body.Variables.Add(new VariableDefinition(definitionType));
equals.Body.Variables.Add(new VariableDefinition(ModuleDefinition.TypeSystem.Boolean));
equals.Body.Variables.Add(new VariableDefinition(ModuleDefinition.TypeSystem.Int32));
equals.Body.Variables.Add(new VariableDefinition(ModuleDefinition.TypeSystem.Boolean));
// Labels for goto.
var labelReturnFalse = Instruction.Create(OpCodes.Nop);
var processor = equals.Body.GetILProcessor();
// Foo foo = other as Foo;
processor.Append(Instruction.Create(OpCodes.Ldarg_1));
processor.Append(Instruction.Create(OpCodes.Isinst, definitionType));
processor.Append(Instruction.Create(OpCodes.Stloc_0));
// if (foo != null)
processor.Append(Instruction.Create(OpCodes.Ldloc_0));
processor.Append(Instruction.Create(OpCodes.Ldnull));
processor.Append(Instruction.Create(OpCodes.Cgt_Un));
processor.Append(Instruction.Create(OpCodes.Stloc_1));
processor.Append(Instruction.Create(OpCodes.Ldloc_1));
processor.Append(Instruction.Create(OpCodes.Brfalse_S, labelReturnFalse));
// return Identify.Equals(foo.Identify);
var property = definitionType.Properties.First();
processor.Append(Instruction.Create(OpCodes.Ldarg_0));
processor.Append(Instruction.Create(OpCodes.Call, property.GetMethod));
processor.Append(Instruction.Create(OpCodes.Stloc_2));
processor.Append(Instruction.Create(OpCodes.Ldloca_S, equals.Body.Variables[2]));
processor.Append(Instruction.Create(OpCodes.Ldloc_0));
processor.Append(Instruction.Create(OpCodes.Callvirt, property.GetMethod));
var intDefinition = ModuleDefinition.TypeSystem.Int32.Resolve();
var equalsByInt = intDefinition
.Methods
.Single(x =>
x.Name == nameof(int.Equals) &&
x.Parameters.Count == 1 &&
x.Parameters.Single().ParameterType.FullName == intDefinition.FullName);
processor.Append(Instruction.Create(OpCodes.Call, ModuleDefinition.ImportReference(equalsByInt)));
processor.Append(Instruction.Create(OpCodes.Ret));
// return false;
processor.Append(labelReturnFalse);
processor.Append(Instruction.Create(OpCodes.Ldc_I4_0));
processor.Append(Instruction.Create(OpCodes.Ret));
definitionType.Methods.Add(equals);
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="module">The module to rewrite.</param>
/// <param name="rewriteType">Handle or rewrite a type reference if needed.</param>
/// <param name="rewriteInstruction">Handle or rewrite a CIL instruction if needed.</param>
public RecursiveRewriter(ModuleDefinition module, RewriteTypeDelegate rewriteType, RewriteInstructionDelegate rewriteInstruction)
{
this.Module = module;
this.RewriteTypeImpl = rewriteType;
this.RewriteInstructionImpl = rewriteInstruction;
}
public ISymbolReader GetSymbolReader(ModuleDefinition module, Stream symbolStream)
{
return(IsPortablePdb(symbolStream)
? new PortablePdbReaderProvider().GetSymbolReader(module, symbolStream)
: new NativePdbReaderProvider().GetSymbolReader(module, symbolStream));
}
static bool SetterValueIsCollection(FieldReference bindablePropertyReference, ModuleDefinition module, BaseNode node, ILContext context)
{
var items = (node as IElementNode)?.CollectionItems;
if (items == null || items.Count <= 0)
{
return(false);
}
// Is this a generic type ?
var generic = bindablePropertyReference.GetBindablePropertyType(node, module) as GenericInstanceType;
// With a single generic argument?
if (generic?.GenericArguments.Count != 1)
{
return(false);
}
// Is the generic argument assignable from this value?
var genericType = generic.GenericArguments[0];
if (!(items[0] is IElementNode firstItem))
{
return(false);
}
return(context.Variables[firstItem].VariableType.InheritsFromOrImplements(genericType));
}
ISymbolReader GetSymbolReader(ModuleDefinition module, Disposable <Stream> symbolStream, string fileName)
{
return(new PortablePdbReader(ImageReader.ReadPortablePdb(symbolStream, fileName), module));
}
public IEnumerable <Instruction> ProvideValue(VariableDefinitionReference vardefref, ModuleDefinition module, BaseNode node, ILContext context)
{
INode valueNode = null;
if (!((IElementNode)node).Properties.TryGetValue(new XmlName("", "Value"), out valueNode) &&
!((IElementNode)node).Properties.TryGetValue(new XmlName(XamlParser.XFUri, "Value"), out valueNode) &&
((IElementNode)node).CollectionItems.Count == 1)
{
valueNode = ((IElementNode)node).CollectionItems[0];
}
var bpNode = ((ValueNode)((IElementNode)node).Properties[new XmlName("", "Property")]);
var bpRef = (new BindablePropertyConverter()).GetBindablePropertyFieldReference((string)bpNode.Value, module, bpNode);
if (SetterValueIsCollection(bpRef, module, node, context))
{
yield break;
}
if (valueNode == null)
{
throw new XamlParseException("Missing Value for Setter", (IXmlLineInfo)node);
}
//if it's an elementNode, there's probably no need to convert it
if (valueNode is IElementNode)
{
yield break;
}
var value = ((string)((ValueNode)valueNode).Value);
var setterType = ("Microsoft.Maui.Controls", "Microsoft.Maui.Controls", "Setter");
//push the setter
foreach (var instruction in vardefref.VariableDefinition.LoadAs(module.GetTypeDefinition(setterType), module))
{
yield return(instruction);
}
//push the value
foreach (var instruction in ((ValueNode)valueNode).PushConvertedValue(context, bpRef, valueNode.PushServiceProvider(context, bpRef: bpRef), boxValueTypes: true, unboxValueTypes: false))
{
yield return(instruction);
}
//set the value
yield return(Instruction.Create(OpCodes.Callvirt, module.ImportPropertySetterReference(setterType, propertyName: "Value")));
}
public PortablePdbWriter(MetadataBuilder pdb_metadata, ModuleDefinition module)
{
this.pdb_metadata = pdb_metadata;
this.module = module;
}
private static void UpdateModuleDictionary(ModuleDefinition module, string moduleFilePath)
{
moduleDictionary[moduleFilePath.CleanFileName()] = new Tuple <DateTime, ModuleDefinition>(File.GetLastWriteTime(moduleFilePath), module);
}
public void TerminateModuleDefinition(ModuleDefinition module)
{
}
public ClientRpcProcessor(ModuleDefinition module, Readers readers, Writers writers, IWeaverLogger logger) : base(module, readers, writers, logger)
{
}
public MemberReferenceConverter(ModuleDefinition module)
{
this.module = module;
}
public static FieldReference CreateImportedType(this FieldReference fieldRef, ModuleDefinition module)
{
var declaringType = fieldRef.DeclaringType.CreateImportedType(module);
var fieldType = fieldRef.FieldType.CreateImportedType(module);
var importedField = new FieldReference(fieldRef.Name, fieldType, declaringType);
return(module.ImportReference(importedField));
}
public static TypeReference GetBindablePropertyType(this FieldReference bpRef, IXmlLineInfo iXmlLineInfo, ModuleDefinition module)
{
if (!bpRef.Name.EndsWith("Property", StringComparison.InvariantCulture))
{
throw new XamlParseException($"The name of the bindable property {bpRef.Name} does not ends with \"Property\". This is the kind of convention the world is build upon, a bit like Planck's constant.", iXmlLineInfo);
}
var bpName = bpRef.Name.Substring(0, bpRef.Name.Length - 8);
var owner = bpRef.DeclaringType;
TypeReference _;
var getter = owner.GetProperty(pd => pd.Name == bpName, out _)?.GetMethod;
if (getter == null || getter.IsStatic || !getter.IsPublic)
{
getter = null;
}
getter = getter ?? owner.GetMethods(md => md.Name == $"Get{bpName}" &&
md.IsStatic &&
md.IsPublic &&
md.Parameters.Count == 1 &&
md.Parameters[0].ParameterType.InheritsFromOrImplements(module.ImportReference(typeof(BindableObject))), module).SingleOrDefault()?.Item1;
if (getter == null)
{
throw new XamlParseException($"Missing a public static Get{bpName} or a public instance property getter for the attached property \"{bpRef.DeclaringType}.{bpRef.Name}\"", iXmlLineInfo);
}
return(getter.ReturnType);
}
public CommonTypeSystem(ModuleDefinition module)
: base(module)
{
}
public CoreLibMetadataImporter(ModuleDefinition module)
{
_module = module;
_defaultMetadataImporter = new DefaultMetadataImporter(module);
}
TypeSystem(ModuleDefinition module)
{
this.module = module;
}
public ModuleDefinition reload(byte[] newModuleData, DumpedMethods dumpedMethods)
{
AssemblyResolver.Instance.removeModule(module);
DotNetUtils.typeCaches.invalidate(module);
return(setModule(ModuleDefinition.ReadModule(new MemoryStream(newModuleData), getReaderParameters(), dumpedMethods)));
}
public static MethodReference ImportMethod <T>(ModuleDefinition module, string name)
{
return(module.ImportReference(typeof(T).GetMethod(name, Type.EmptyTypes)));
}