LogLine(2, " Module: {0}", module.Name);
foreach (var resource in module.Resources.OfType<EmbeddedResource>())
{
- Log(2, " Resource: {0}... ", resource.Name);
+ LogString(2, " Resource: {0}... ", resource.Name);
string classname;
if (!resource.IsXaml(out classname))
{
}
LogLine(2, "");
- Log(2, " Duplicating {0}.InitializeComponent () into {0}.InitCompRuntime ... ", typeDef.Name);
+ LogString(2, " Duplicating {0}.InitializeComponent () into {0}.InitCompRuntime ... ", typeDef.Name);
var initCompRuntime = new MethodDefinition("InitCompRuntime", initComp.Attributes, initComp.ReturnType);
initCompRuntime.Body = initComp.Body;
typeDef.Methods.Add(initCompRuntime);
md => md.IsConstructor && md.Parameters.Count == 1 && md.Parameters[0].ParameterType == module.TypeSystem.Boolean)
.FirstOrDefault();
if (altCtor != null)
- Log(2, " Replacing body of {0}.{0} (bool {1}) ... ", typeDef.Name, altCtor.Parameters[0].Name);
+ LogString(2, " Replacing body of {0}.{0} (bool {1}) ... ", typeDef.Name, altCtor.Parameters[0].Name);
else
{
- Log(2, " Adding {0}.{0} (bool useCompiledXaml) ... ", typeDef.Name);
+ LogString(2, " Adding {0}.{0} (bool useCompiledXaml) ... ", typeDef.Name);
altCtor = new MethodDefinition(".ctor",
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName, module.TypeSystem.Void);
LogLine(2, "");
}
- Log(1, "Writing the assembly... ");
+ LogString(1, "Writing the assembly... ");
assemblyDefinition.Write(Assembly, new WriterParameters
{
WriteSymbols = DebugSymbols
try
{
type = new XmlType(namespaceuri, name + "Extension", null);
- var typeref = type.GetTypeReference(contextProvider.Context.Body.Method.Module, null);
+ type.GetTypeReference(contextProvider.Context.Body.Method.Module, null);
}
catch (XamlParseException)
{
public class FixedCreateCSharpManifestResourceName : CreateCSharpManifestResourceName
{
[Output]
+#pragma warning disable 0108
public ITaskItem[] ResourceFilesWithManifestResourceNames { get; set; }
+#pragma warning restore 0108
public override bool Execute()
{
{
static class MethodReferenceExtensions
{
- [Obsolete]
- public static MethodReference MakeGeneric(this MethodReference self, params TypeReference[] arguments)
- {
- var reference = new MethodReference(self.Name, self.ReturnType)
- {
- DeclaringType = self.DeclaringType.MakeGenericInstanceType(arguments),
- HasThis = self.HasThis,
- ExplicitThis = self.ExplicitThis,
- CallingConvention = self.CallingConvention
- };
-
- foreach (var parameter in self.Parameters)
- reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType));
-
- foreach (var generic_parameter in self.GenericParameters)
- reference.GenericParameters.Add(new GenericParameter(generic_parameter.Name, reference));
-
- return reference;
- }
-
public static MethodReference ResolveGenericParameters(this MethodReference self, TypeReference declaringTypeRef,
ModuleDefinition module)
{
if (self == null)
- throw new ArgumentNullException("self");
+ throw new ArgumentNullException(nameof(self));
if (declaringTypeRef == null)
- throw new ArgumentNullException("declaringTypeRef");
+ throw new ArgumentNullException(nameof(declaringTypeRef));
var reference = new MethodReference(self.Name, self.ReturnType)
{
CallingConvention = self.CallingConvention
};
- foreach (var parameter in self.Parameters)
- reference.Parameters.Add(new ParameterDefinition(module.Import(parameter.ParameterType)));
+ foreach (var parameter in self.Parameters) {
+ var p = parameter.ParameterType.IsGenericParameter ? parameter.ParameterType : module.Import(parameter.ParameterType);
+ reference.Parameters.Add(new ParameterDefinition(p));
+ }
foreach (var generic_parameter in self.GenericParameters)
reference.GenericParameters.Add(new GenericParameter(generic_parameter.Name, reference));
MethodReference nullableCtor = null;
if (targetTypeRef.Resolve().FullName == "System.Nullable`1")
{
+ var nullableTypeRef = targetTypeRef;
targetTypeRef = ((GenericInstanceType)targetTypeRef).GenericArguments[0];
isNullable = true;
nullableCtor = originalTypeRef.GetMethods(md => md.IsConstructor && md.Parameters.Count == 1, module).Single().Item1;
- nullableCtor = nullableCtor.MakeGeneric(targetTypeRef);
+ nullableCtor = nullableCtor.ResolveGenericParameters(nullableTypeRef, module);
}
//Obvious Built-in conversions
if (targetTypeRef.Resolve().BaseType != null && targetTypeRef.Resolve().BaseType.FullName == "System.Enum")
var provideValueInfo = markExt.Methods.First(md => md.Name == "ProvideValue");
var provideValue = module.Import(provideValueInfo);
provideValue =
- module.Import(provideValue.MakeGeneric(markupExtension.GenericArguments.Select(tr => module.Import(tr)).ToArray()));
+ module.Import(provideValue.ResolveGenericParameters(markupExtension, module));
var typeNode = node.Properties[new XmlName("", "Type")];
TypeReference arrayTypeRef;
var provideValueInfo = markExt.Methods.First(md => md.Name == "ProvideValue");
var provideValue = module.Import(provideValueInfo);
provideValue =
- module.Import(provideValue.MakeGeneric(markupExtension.GenericArguments.Select(tr => module.Import(tr)).ToArray()));
+ module.Import(provideValue.ResolveGenericParameters(markupExtension, module));
vardefref.VariableDefinition = new VariableDefinition(module.Import(genericArguments.First()));
yield return Instruction.Create(OpCodes.Ldloc, context.Variables[node]);
var handled = false;
//If it's an attached BP, update elementType and propertyName
- var attached = GetNameAndTypeRef(ref elementType, propertyName.NamespaceURI, ref localName, context, iXmlLineInfo);
+ GetNameAndTypeRef(ref elementType, propertyName.NamespaceURI, ref localName, context, iXmlLineInfo);
//If the target is an event, connect
// IL_0007: ldloc.0
//SetDataTemplate
parentIl.Emit(OpCodes.Ldftn, loadTemplate);
+ var funcObjRef = module.Import(typeof(Func<object>));
var funcCtor =
- module.Import(typeof (Func<>))
- .MakeGenericInstanceType(module.TypeSystem.Object)
+ funcObjRef
.Resolve()
.Methods.First(md => md.IsConstructor && md.Parameters.Count == 2)
- .MakeGeneric(module.TypeSystem.Object);
+ .ResolveGenericParameters(funcObjRef, module);
parentIl.Emit(OpCodes.Newobj, module.Import(funcCtor));
+#pragma warning disable 0612
var propertySetter =
module.Import(typeof (IDataTemplate)).Resolve().Properties.First(p => p.Name == "LoadTemplate").SetMethod;
+#pragma warning restore 0612
parentContext.IL.Emit(OpCodes.Callvirt, module.Import(propertySetter));
}
}
if (IsCollectionItem(node, parentNode) && parentNode is IElementNode)
{
// Collection element, implicit content, or implicit collection element.
- CustomAttribute cpAttr;
var parentVar = Context.Variables[(IElementNode)parentNode];
if (parentVar.VariableType.ImplementsInterface(Module.Import(typeof (IEnumerable))))
{
<WarningLevel>4</WarningLevel>
<ConsolePause>false</ConsolePause>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
- <NoWarn>0108;0612;0436;0168;0219</NoWarn>
+ <NoWarn></NoWarn>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>full</DebugType>
</ItemGroup>
<ItemGroup>
<Compile Include="Properties\AssemblyInfo.cs" />
- <Compile Include="..\Xamarin.Forms.Xaml\XmlnsHelper.cs">
- <Link>XmlnsHelper.cs</Link>
- </Compile>
<Compile Include="XamlGTask.cs" />
<Compile Include="ILContext.cs" />
<Compile Include="CreateObjectVisitor.cs" />
}
}
- protected void Log(int level, string format, params object[] arg)
+ protected void LogString(int level, string format, params object[] arg)
{
if (level <= 0)
Console.Error.Write(format, arg);
var resourcesToPrune = new List<EmbeddedResource>();
foreach (var resource in module.Resources.OfType<EmbeddedResource>())
{
- Log(2, " Resource: {0}... ", resource.Name);
+ LogString(2, " Resource: {0}... ", resource.Name);
string classname;
if (!resource.IsXaml(out classname))
{
}
LogLine(2, "");
- Log(2, " Parsing Xaml... ");
+ LogString(2, " Parsing Xaml... ");
var rootnode = ParseXaml(resource.GetResourceStream(), typeDef);
if (rootnode == null)
{
try
{
- Log(2, " Replacing {0}.InitializeComponent ()... ", typeDef.Name);
+ LogString(2, " Replacing {0}.InitializeComponent ()... ", typeDef.Name);
var body = new MethodBody(initComp);
var il = body.GetILProcessor();
il.Emit(OpCodes.Nop);
if (OptimizeIL)
{
- Log(2, " Optimizing IL... ");
+ LogString(2, " Optimizing IL... ");
initComp.Body.OptimizeMacros();
LogLine(2, "done");
}
if (OutputGeneratedILAsCode)
{
var filepath = Path.Combine(Path.GetDirectoryName(Assembly), typeDef.FullName + ".decompiled.cs");
- Log(2, " Decompiling {0} into {1}...", typeDef.FullName, filepath);
+ LogString(2, " Decompiling {0} into {1}...", typeDef.FullName, filepath);
var decompilerContext = new DecompilerContext(module);
using (var writer = new StreamWriter(filepath))
{
LogLine(2, " Removing compiled xaml resources");
foreach (var resource in resourcesToPrune)
{
- Log(2, " Removing {0}... ", resource.Name);
+ LogString(2, " Removing {0}... ", resource.Name);
module.Resources.Remove(resource);
LogLine(2, "done");
}
return success;
}
- Log(1, "Writing the assembly... ");
+ LogString(1, "Writing the assembly... ");
try
{
assemblyDefinition.Write(Assembly, new WriterParameters
projects / platform / upstream / xamarin-forms.git / commitdiff