private static bool HasCorrectMethods(TypeDefinition type)
{
return type.Methods.Any(IsOnEntryMethod) &&
type.Methods.Any(IsOnExitMethod) &&
type.Methods.Any(IsOnExceptionMethod) &&
type.Methods.Any(IsOnTaskContinuationMethod);
}
void CreateFields(TypeDefinition targetTypeDefinition)
{
Target = new FieldDefinition("target", FieldAttributes.Public, targetTypeDefinition);
TypeDefinition.Fields.Add(Target);
PropertyName = new FieldDefinition("propertyName", FieldAttributes.Public, msCoreReferenceFinder.StringTypeReference);
TypeDefinition.Fields.Add(PropertyName);
}
public ArrayTypeDefinition(TypeDefinition baseType, int dimensions)
: base(baseType)
{
Dimensions = dimensions;
var systemNamespace = baseType.GetScope().ResolveIdentifier("System").ScopeProvider;
MemberType = systemNamespace.GetScope().ResolveIdentifier("Array").ScopeProvider as TypeDefinition;
}
void InjectField(TypeDefinition type, FieldDefinition fieldDefinition)
{
var staticConstructor = type.GetStaticConstructor();
staticConstructor.Body.SimplifyMacros();
var genericInstanceMethod = new GenericInstanceMethod(forContextDefinition);
if (type.IsCompilerGenerated() && type.IsNested)
{
genericInstanceMethod.GenericArguments.Add(type.DeclaringType.GetGeneric());
}
else
{
genericInstanceMethod.GenericArguments.Add(type.GetGeneric());
}
var instructions = staticConstructor.Body.Instructions;
type.Fields.Add(fieldDefinition);
var returns = instructions.Where(_ => _.OpCode == OpCodes.Ret)
.ToList();
var ilProcessor = staticConstructor.Body.GetILProcessor();
foreach (var returnInstruction in returns)
{
var newReturn = Instruction.Create(OpCodes.Ret);
ilProcessor.InsertAfter(returnInstruction, newReturn);
ilProcessor.InsertBefore(newReturn, Instruction.Create(OpCodes.Call, genericInstanceMethod));
ilProcessor.InsertBefore(newReturn, Instruction.Create(OpCodes.Stsfld, fieldDefinition.GetGeneric()));
returnInstruction.OpCode = OpCodes.Nop;
}
staticConstructor.Body.OptimizeMacros();
}
void FindGetLogger(TypeDefinition typeDefinition)
{
if (!typeDefinition.IsPublic)
{
var message = $"The logger factory type '{typeDefinition.FullName}' needs to be public.";
throw new WeavingException(message);
}
GetLoggerMethod = typeDefinition
.Methods
.FirstOrDefault(x =>
x.Name == "GetLogger" &&
x.IsStatic &&
x.HasGenericParameters &&
x.GenericParameters.Count == 1 &&
x.Parameters.Count == 0);
if (GetLoggerMethod == null)
{
throw new WeavingException("Found 'LoggerFactory' but it did not have a static 'GetLogger' method that takes 'string' as a parameter");
}
if (!GetLoggerMethod.Resolve().IsPublic)
{
var message = $"The logger factory method '{GetLoggerMethod.FullName}' needs to be public.";
throw new WeavingException(message);
}
}
public static MethodDefinition GetMethod(TypeDefinition type, string methodName, params string[] args)
{
return type.Methods.FirstOrDefault((methodDefinition) =>
{
if (methodDefinition.Name != methodName)
{
return false;
}
if (args == null)
{
return true;
}
if (methodDefinition.Parameters.Count != args.Length)
{
return false;
}
for (int i = 0; i < args.Length; i++)
{
if (methodDefinition.Parameters[i].ParameterType.FullName != args[i])
{
return false;
}
}
return true;
});
}
void InjectAsStreamReader(TypeDefinition targetType, FieldDefinition fieldDefinition)
{
AsStreamReaderMethod = new MethodDefinition("AsStreamReader", staticMethodAttributes, StreamReaderTypeReference);
var streamVariable = new VariableDefinition(StreamTypeReference);
AsStreamReaderMethod.Body.Variables.Add(streamVariable);
var pathParam = new ParameterDefinition(ModuleDefinition.TypeSystem.String);
AsStreamReaderMethod.Parameters.Add(pathParam);
AsStreamReaderMethod.Body.InitLocals = true;
var inst = AsStreamReaderMethod.Body.Instructions;
var skipReturn = Instruction.Create(OpCodes.Nop);
inst.Add(Instruction.Create(OpCodes.Ldsfld, fieldDefinition));
inst.Add(Instruction.Create(OpCodes.Ldarg, pathParam));
inst.Add(Instruction.Create(OpCodes.Callvirt, GetManifestResourceStreamMethod));
inst.Add(Instruction.Create(OpCodes.Stloc, streamVariable));
inst.Add(Instruction.Create(OpCodes.Ldloc, streamVariable));
inst.Add(Instruction.Create(OpCodes.Brtrue_S, skipReturn));
inst.Add(Instruction.Create(OpCodes.Ldnull));
inst.Add(Instruction.Create(OpCodes.Ret));
inst.Add(skipReturn);
inst.Add(Instruction.Create(OpCodes.Ldloc, streamVariable));
inst.Add(Instruction.Create(OpCodes.Newobj, StreamReaderConstructorReference));
inst.Add(Instruction.Create(OpCodes.Ret));
targetType.Methods.Add(AsStreamReaderMethod);
}
public static MethodDefinition GetMethod(TypeDefinition type, string methodName, params string[] args)
{
if (args == null)
{
return GetMethod(type, methodName);
}
for (int i = 0; i < type.Methods.Count; i++)
{
MethodDefinition m = type.Methods[i];
if (m.Name == methodName && m.Parameters.Count == args.Length)
{
bool b = true;
for (int j = 0; j < args.Length; j++)
{
if (m.Parameters[j].ParameterType.FullName != args[j])
{
b = false;
break;
}
}
if (b)
{
return m;
}
}
}
return null;
}
bool FindIsChangedEventInvokerMethodDefinition(TypeDefinition type, out MethodDefinition methodDefinition)
{
//todo: check bool type
methodDefinition = null;
var propertyDefinition = type.Properties
.FirstOrDefault(x =>
x.Name == isChangedPropertyName &&
x.SetMethod != null &&
x.SetMethod.IsPublic
);
if (propertyDefinition != null)
{
if (propertyDefinition.PropertyType.FullName != ModuleDefinition.TypeSystem.Boolean.FullName)
{
LogWarning(string.Format("Found '{0}' but is was of type '{1}' instead of '{2}' so it will not be used.", propertyDefinition.GetName(), propertyDefinition.PropertyType.Name, ModuleDefinition.TypeSystem.Boolean.Name));
return false;
}
if (propertyDefinition.SetMethod.IsStatic)
{
throw new WeavingException(string.Format("Found '{0}' but is was static. Change it to non static.", propertyDefinition.GetName()));
}
methodDefinition = propertyDefinition.SetMethod;
}
return methodDefinition != null;
}
void ProcessType(TypeDefinition typeDefinition)
{
foreach (var method in typeDefinition.Methods)
{
ProcessMethod(method);
}
}
public void Execute()
{
var validationTemplateAttribute = ModuleDefinition
.Assembly
.CustomAttributes
.FirstOrDefault(x=>x.AttributeType.Name == "ValidationTemplateAttribute");
if (validationTemplateAttribute == null)
{
LogInfo("Could not find a 'ValidationTemplateAttribute' on the current assembly. Going to search current assembly for 'ValidationTemplate'.");
TypeDefinition = ModuleDefinition
.GetTypes()
.FirstOrDefault(x =>
x.Name == "ValidationTemplate" ||
x.Name == "ValidationTemplate`1");
if (TypeDefinition == null)
{
throw new WeavingException("Could not find a type named 'ValidationTemplate'");
}
TypeReference = TypeDefinition;
FindConstructor();
}
else
{
var typeReference = (TypeReference) validationTemplateAttribute.ConstructorArguments.First().Value;
TypeReference = typeReference;
TypeDefinition = typeReference.Resolve();
FindConstructor();
TemplateConstructor = ModuleDefinition.Import(TemplateConstructor);
}
}
void CreateFields(TypeDefinition targetTypeDefinition)
{
TargetField = new FieldDefinition("target", FieldAttributes.Public, targetTypeDefinition);
TypeDefinition.Fields.Add(TargetField);
PropertyNameField = new FieldDefinition("propertyName", FieldAttributes.Public, ModuleWeaver.ModuleDefinition.TypeSystem.String);
TypeDefinition.Fields.Add(PropertyNameField);
}
public void ProcessType(TypeDefinition typeDefinition)
{
if (IsCompilerGenerated(typeDefinition.CustomAttributes))
{
return;
}
if (typeDefinition.IsNotPublic)
{
if (typeDefinition.IsNested)
{
typeDefinition.IsNestedPublic = true;
}
else
{
typeDefinition.IsPublic = true;
}
AddEditorBrowsableAttribute(typeDefinition.CustomAttributes);
}
if (typeDefinition.IsInterface)
{
return;
}
foreach (var method in typeDefinition.Methods)
{
ProcessMethod(method);
}
foreach (var field in typeDefinition.Fields)
{
ProcessField(field);
}
}
public EventInvokerMethod RecursiveFindEventInvoker(TypeDefinition typeDefinition)
{
var typeDefinitions = new Stack<TypeDefinition>();
MethodDefinition methodDefinition;
var currentTypeDefinition = typeDefinition;
do
{
typeDefinitions.Push(currentTypeDefinition);
if (FindEventInvokerMethodDefinition(currentTypeDefinition, out methodDefinition))
{
break;
}
var baseType = currentTypeDefinition.BaseType;
if (baseType == null || baseType.FullName == "System.Object")
{
return null;
}
currentTypeDefinition = Resolve(baseType);
} while (true);
return new EventInvokerMethod
{
MethodReference = GetMethodReference(typeDefinitions, methodDefinition),
IsVisibleFromChildren = IsVisibleFromChildren(methodDefinition),
InvokerType = ClassifyInvokerMethod(methodDefinition),
};
}
public EventInvokerMethod RecursiveFindMethod(TypeDefinition typeDefinition)
{
var typeDefinitions = new Stack<TypeDefinition>();
MethodDefinition methodDefinition;
var currentTypeDefinition = typeDefinition;
do
{
typeDefinitions.Push(currentTypeDefinition);
if (FindEventInvokerMethodDefinition(currentTypeDefinition, out methodDefinition))
{
break;
}
var baseType = currentTypeDefinition.BaseType;
if (baseType == null || baseType.FullName == "System.Object")
{
return null;
}
currentTypeDefinition = typeResolver.Resolve(baseType);
} while (true);
return new EventInvokerMethod
{
MethodReference = methodGenerifier.GetMethodReference(typeDefinitions, methodDefinition),
IsBeforeAfter = IsBeforeAfterMethod(methodDefinition),
};
}
public OperatorResolveResult(OperatorType @operator, TypeDefinition operatorType, params ResolveResult[] operands)
: base(operatorType)
{
Operator = @operator;
OperatorType = operatorType;
Operands = new ReadOnlyCollection<ResolveResult>(operands);
}
void InjectField(TypeDefinition type, FieldDefinition fieldDefinition)
{
var staticConstructor = type.GetStaticConstructor();
var instructions = staticConstructor.Body.Instructions;
if (type.HasGenericParameters)
{
instructions.Insert(0, Instruction.Create(OpCodes.Call, buildLoggerGenericMethod));
instructions.Insert(1, Instruction.Create(OpCodes.Stsfld, fieldDefinition.GetGeneric()));
}
else
{
var logName = type.FullName;
if (type.IsCompilerGenerated() && type.IsNested)
{
logName = type.DeclaringType.FullName;
}
instructions.Insert(0, Instruction.Create(OpCodes.Ldstr, logName));
instructions.Insert(1, Instruction.Create(OpCodes.Call, buildLoggerMethod));
instructions.Insert(2, Instruction.Create(OpCodes.Stsfld, fieldDefinition));
}
type.Fields.Add(fieldDefinition);
}
void CopyNestedTypes(TypeDefinition source, TypeDefinition target, bool signatureOnly)
{
foreach (var nestedType in source.NestedTypes)
{
var newNestedType = (from type in target.NestedTypes
where string.Equals(type.Name, nestedType.Name)
select type).FirstOrDefault();
var isExistingType = (newNestedType != null);
if (!isExistingType)
{
newNestedType = new TypeDefinition(nestedType.Namespace, nestedType.Name, nestedType.Attributes);
newNestedType.BaseType = Resolve(source.BaseType);
newNestedType.IsClass = source.IsClass;
target.NestedTypes.Add(newNestedType);
}
CopyNestedTypes(nestedType, newNestedType, signatureOnly);
if (!isExistingType)
{
CopyFields(nestedType, newNestedType);
}
CopyMethods(nestedType, newNestedType, signatureOnly);
}
}
private NullableTypeDefinition(Type type, Type underlyingType)
: base(type)
{
if (underlyingType == null) throw new ArgumentNullException("underlyingType");
underlyingTypeDef = TypeCache.GetTypeDefinition(underlyingType);
}
public EventInvokerMethod AddOnPropertyChangedMethod(TypeDefinition targetType)
{
var propertyChangedField = FindPropertyChangedField(targetType);
if (propertyChangedField == null)
{
return null;
}
if (FoundInterceptor)
{
if (targetType.HasGenericParameters)
{
var message = string.Format("Error processing '{0}'. Interception is not supported on generic types. To manually work around this problem add a [DoNotNotify] to the class and then manually implement INotifyPropertyChanged for that class and all child classes. If you would like this feature handled automatically please feel free to submit a pull request.", targetType.Name);
throw new WeavingException(message);
}
var methodDefinition = GetMethodDefinition(targetType, propertyChangedField);
return new EventInvokerMethod
{
MethodReference = InjectInterceptedMethod(targetType, methodDefinition).GetGeneric(),
InvokerType = InterceptorType,
IsVisibleFromChildren = true,
};
}
return new EventInvokerMethod
{
MethodReference = InjectMethod(targetType, EventInvokerNames.First(), propertyChangedField).GetGeneric(),
InvokerType = InterceptorType,
IsVisibleFromChildren = true,
};
}
/// <summary>
/// Creates the default constructor.
/// </summary>
public MethodDefinition CreateDefaultConstructor(TypeDefinition type)
{
_logInfo("AddDefaultConstructor() " + type.Name);
// Create method for a constructor
var methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
var method = new MethodDefinition(".ctor", methodAttributes, _moduleDefinition.TypeSystem.Void);
// Set parameters for constructor, and add corresponding assignment in method body:
// 1. Add each property in the class as a parameter for the constructor
// 2. Set the properties in the class from the constructor parameters
// Properties marked with the [ImmutableClassIgnore] attribute are ignored
foreach (var prop in type.Properties)
{
if (prop.CustomAttributes.ContainsAttribute("ImmutableClassIgnoreAttribute"))
{
_logInfo("Ignoring property " + prop.Name);
continue;
}
string paramName = Char.ToLowerInvariant(prop.Name [0]) + prop.Name.Substring (1); // convert first letter of name to lowercase
_logInfo("Adding parameter " + paramName + " to ctor");
var pd = (new ParameterDefinition(paramName, ParameterAttributes.HasDefault, prop.PropertyType));
method.Parameters.Add(pd);
_logInfo("Setting property " + prop.Name);
method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg, pd));
method.Body.Instructions.Add(Instruction.Create(OpCodes.Call, prop.SetMethod));
}
method.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
return method;
}
public bool IsSecurityCritical (TypeDefinition type)
{
string entry = type.GetFullName ();
if (critical.Contains (entry))
return true;
return type.IsNested ? IsSecurityCritical (type.DeclaringType) : false;
}
internal static TypeDefinition GetBaseType(TypeDefinition child)
{
if (child.BaseType == null)
return null;
return child.BaseType.Resolve ();
}
MethodDefinition InjectMethod(TypeDefinition targetType, string eventInvokerName, FieldReference propertyChangingField)
{
var method = new MethodDefinition(eventInvokerName, GetMethodAttributes(targetType), ModuleDefinition.TypeSystem.Void);
method.Parameters.Add(new ParameterDefinition("propertyName", ParameterAttributes.None, ModuleDefinition.TypeSystem.String));
var handlerVariable = new VariableDefinition(PropChangingHandlerReference);
method.Body.Variables.Add(handlerVariable);
var boolVariable = new VariableDefinition(ModuleDefinition.TypeSystem.Boolean);
method.Body.Variables.Add(boolVariable);
var instructions = method.Body.Instructions;
var last = Instruction.Create(OpCodes.Ret);
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldfld, propertyChangingField));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldnull));
instructions.Add(Instruction.Create(OpCodes.Ceq));
instructions.Add(Instruction.Create(OpCodes.Stloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Brtrue_S, last));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
instructions.Add(Instruction.Create(OpCodes.Newobj, ComponentModelPropertyChangingEventConstructorReference));
instructions.Add(Instruction.Create(OpCodes.Callvirt, ComponentModelPropertyChangingEventHandlerInvokeReference));
instructions.Add(last);
method.Body.InitLocals = true;
targetType.Methods.Add(method);
return method;
}
static FieldDefinition TryGetField(TypeDefinition typeDefinition, PropertyDefinition property)
{
var propertyName = property.Name;
var fieldsWithSameType = typeDefinition.Fields.Where(x => x.DeclaringType == typeDefinition).ToList();
foreach (var field in fieldsWithSameType)
{
//AutoProp
if (field.Name == $"<{propertyName}>k__BackingField")
{
return field;
}
}
foreach (var field in fieldsWithSameType)
{
//diffCase
var upperPropertyName = propertyName.ToUpper();
var fieldUpper = field.Name.ToUpper();
if (fieldUpper == upperPropertyName)
{
return field;
}
//underScore
if (fieldUpper == "_" + upperPropertyName)
{
return field;
}
}
return GetSingleField(property);
}
public void ImportAssemblyLoader()
{
var existingILTemplate = Module.GetAllTypeDefinitions().FirstOrDefault(x => x.FullName == "Costura.AssemblyLoader");
if (existingILTemplate != null)
{
AttachMethod = existingILTemplate.Methods.First(x => x.Name == "Attach");
return;
}
var moduleDefinition = GetTemplateModuleDefinition();
if (!CreateTemporaryAssemblies)
{
sourceType = moduleDefinition.Types.First(x => x.Name == "ILTemplate");
}
else
{
sourceType = moduleDefinition.Types.First(x => x.Name == "ILTemplateWithTempAssembly");
}
targetType = new TypeDefinition("Costura", "AssemblyLoader", sourceType.Attributes, Resolve(sourceType.BaseType));
Module.Types.Add(targetType);
CopyFields(sourceType);
CopyMethod(sourceType.Methods.First(x => x.Name == "ResolveAssembly"));
AttachMethod = CopyMethod(sourceType.Methods.First(x => x.Name == "Attach"));
}
MethodDefinition InjectInterceptedMethod(TypeDefinition targetType, MethodDefinition innerOnPropertyChanging)
{
var delegateHolderInjector = new DelegateHolderInjector
{
TargetTypeDefinition=targetType,
OnPropertyChangingMethodReference = innerOnPropertyChanging,
ModuleWeaver = this
};
delegateHolderInjector.InjectDelegateHolder();
var method = new MethodDefinition(EventInvokerNames.First(), GetMethodAttributes(targetType), ModuleDefinition.TypeSystem.Void);
var propertyName = new ParameterDefinition("propertyName", ParameterAttributes.None, ModuleDefinition.TypeSystem.String);
method.Parameters.Add(propertyName);
if (InterceptorType == InvokerTypes.Before)
{
var before = new ParameterDefinition("before", ParameterAttributes.None, ModuleDefinition.TypeSystem.Object);
method.Parameters.Add(before);
}
var action = new VariableDefinition("firePropertyChanging", ActionTypeReference);
method.Body.Variables.Add(action);
var variableDefinition = new VariableDefinition("delegateHolder", delegateHolderInjector.TypeDefinition);
method.Body.Variables.Add(variableDefinition);
var instructions = method.Body.Instructions;
var last = Instruction.Create(OpCodes.Ret);
instructions.Add(Instruction.Create(OpCodes.Newobj, delegateHolderInjector.ConstructorDefinition));
instructions.Add(Instruction.Create(OpCodes.Stloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
instructions.Add(Instruction.Create(OpCodes.Stfld, delegateHolderInjector.PropertyName));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Stfld, delegateHolderInjector.Target));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldftn, delegateHolderInjector.MethodDefinition));
instructions.Add(Instruction.Create(OpCodes.Newobj, ActionConstructorReference));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldfld, delegateHolderInjector.PropertyName));
if (InterceptorType == InvokerTypes.Before)
{
instructions.Add(Instruction.Create(OpCodes.Ldarg_2));
instructions.Add(Instruction.Create(OpCodes.Call, InterceptMethod));
}
else
{
instructions.Add(Instruction.Create(OpCodes.Call, InterceptMethod));
}
instructions.Add(last);
method.Body.InitLocals = true;
targetType.Methods.Add(method);
return method;
}
private static bool ShouldInclude(TypeDefinition type)
{
if (!type.IsClass)
{
return false;
}
if (type.IsSealed)
{
return false;
}
if (type.HasInterfaces)
{
return false;
}
if (type.IsNotPublic)
{
return false;
}
if (IsContainer(type))
{
return false;
}
return true;
}
public void FindSystemTypes()
{
var system = ModuleDefinition.AssemblyResolver.Resolve("System");
var systemTypes = system.MainModule.Types;
var editorBrowsableAttribute = systemTypes.FirstOrDefault(x => x.Name == "EditorBrowsableAttribute");
if (editorBrowsableAttribute == null)
{
var systemRuntime = ModuleDefinition.AssemblyResolver.Resolve("System.Runtime");
var systemRuntimeTypes = systemRuntime.MainModule.Types;
editorBrowsableAttribute = systemRuntimeTypes.FirstOrDefault(x => x.Name == "EditorBrowsableAttribute");
if (editorBrowsableAttribute == null)
{
throw new WeavingException("Could not find 'EditorBrowsableAttribute'. Searched in 'System' and 'System.Runtime'.");
}
EditorBrowsableStateType = systemRuntimeTypes.First(x => x.Name == "EditorBrowsableState");
}
else
{
EditorBrowsableStateType = systemTypes.First(x => x.Name == "EditorBrowsableState");
}
EditorBrowsableConstructor = ModuleDefinition.ImportReference(editorBrowsableAttribute.Methods.First(IsDesiredConstructor));
var fieldDefinition = EditorBrowsableStateType.Fields.First(x => x.Name == "Advanced");
AdvancedStateConstant = (int)fieldDefinition.Constant;
}
public void CheckTypeDefinitionForProperWinRTHome(TypeDefinition typeDefinition, string module)
{
ScopeDefinition scope = GetScopeDefinitionOfType(typeDefinition);
Assert.Equal(module, scope.Name.Value);
int windowsRuntimeFlag = ((int)System.Reflection.AssemblyContentType.WindowsRuntime << 9);
Assert.True((((int)scope.Flags) & windowsRuntimeFlag) == windowsRuntimeFlag);
}
private static string FindDeclarationsFile(AssemblyReference assemblyReference, string @namespace, TypeDefinition typeForError)
{
var fileTS = @namespace + ".ts";
var result = assemblyReference.AllTypescriptFiles.Where(a => Path.GetFileName(a) == fileTS).ToList();
if (result.Count == 1)
{
return(result.Single());
}
if (result.Count > 1)
{
throw new InvalidOperationException($"importing '{typeForError}' required but multiple '{fileTS}' were found inside '{assemblyReference.ReactDirectory}':\r\n{string.Join("\r\n", result.Select(a => " " + a).ToArray())}");
}
var fileT4S = @namespace + ".t4s";
result = assemblyReference.AllTypescriptFiles.Where(a => Path.GetFileName(a) == fileT4S).ToList();
if (result.Count == 1)
{
return(result.Single().RemoveSuffix(".t4s") + ".ts");
}
if (result.Count > 1)
{
throw new InvalidOperationException($"importing '{typeForError}' required but multiple '{fileT4S}' were found inside '{assemblyReference.ReactDirectory}':\r\n{string.Join("\r\n", result.Select(a => " " + a).ToArray())}");
}
throw new InvalidOperationException($"importing '{typeForError}' required but no '{fileTS}' or '{fileT4S}' found inside '{assemblyReference.ReactDirectory}'");
}
public bool IsExternal(TypeDefinition type)
{
return(type.Module.Assembly.Name.Name != CurrentAssembly &&
!AssemblyReferences.ContainsKey(type.Module.Assembly.Name.Name));
}
public static bool IsProtocol(this TypeDefinition self)
{
return(self.HasAttribute("ProtocolAttribute"));
}
private static string TypeScriptNameInternal(TypeReference type, TypeDefinition current, Options options, string errorContext)
{
type = type.UnNullify();
if (type.FullName == typeof(Boolean).FullName)
{
return("boolean");
}
if (type.FullName == typeof(Char).FullName)
{
return("string");
}
if (type.FullName == typeof(SByte).FullName ||
type.FullName == typeof(Byte).FullName ||
type.FullName == typeof(Int16).FullName ||
type.FullName == typeof(UInt16).FullName ||
type.FullName == typeof(Int32).FullName ||
type.FullName == typeof(UInt32).FullName ||
type.FullName == typeof(Int64).FullName ||
type.FullName == typeof(UInt64).FullName ||
type.FullName == typeof(Decimal).FullName ||
type.FullName == typeof(Single).FullName ||
type.FullName == typeof(Double).FullName)
{
return("number");
}
if (type.FullName == typeof(String).FullName)
{
return("string");
}
if (type.FullName == typeof(DateTime).FullName)
{
return("string");
}
if (type.FullName == typeof(Guid).FullName ||
type.FullName == typeof(Byte[]).FullName ||
type.FullName == typeof(TimeSpan).FullName)
{
return("string");
}
if (type.IsGenericParameter)
{
return(type.Name);
}
if (type is GenericInstanceType git)
{
return(RelativeName(type.Resolve(), current, options, errorContext) + "<" + string.Join(", ", git.GenericArguments.Select(a => TypeScriptName(a, current, options, errorContext)).ToList()) + ">");
}
else if (type.HasGenericParameters)
{
return(RelativeName(type.Resolve(), current, options, errorContext) + "<" + string.Join(", ", type.GenericParameters.Select(gp => gp.Name)) + ">");
}
else if (type is ArrayType at)
{
return(TypeScriptName(at.ElementType, current, options, errorContext) + "[]");
}
else
{
return(RelativeName(type.Resolve(), current, options, errorContext));
}
}
public static bool IsStaticClass(this TypeDefinition type)
{
return(type.IsAbstract && type.IsSealed);
}
private static IEnumerable <PropertyDefinition> GetProperties(TypeDefinition type)
{
return(type.Properties.Where(p => p.HasThis && p.GetMethod.IsPublic)
.Where(p => p.InTypeScript() ?? !(p.ContainsAttribute("HiddenPropertyAttribute") || p.ContainsAttribute("ExpressionFieldAttribute"))));
}
public static IEnumerable <TypeReference> AllInterfaces(this TypeDefinition type)
{
return(type.Interfaces.Select(a => a.InterfaceType).Concat(type.BaseType == null ? Enumerable.Empty <TypeReference>() : AllInterfaces(type.BaseType.Resolve())));
}
internal SubstitutionTarget([NotNull] TypeDefinition targetType, Parameters parameters)
{
TargetType = targetType;
Parameters = parameters;
}
private static bool?GetTypescriptUndefined(TypeDefinition declaringType)
{
var attr = GetAttributeInherit(declaringType, Cache.InTypeScriptAttribute.FullName);
return(attr == null ? null : (bool?)attr.Properties.SingleOrDefault(a => a.Name == "Undefined").Argument.Value);
}
object GetValueFromLanguagePrimitive(TypeReference typeRef, ElementNode node)
{
var module = Context.Module;
var hasValue = node.CollectionItems.Count == 1 && node.CollectionItems[0] is ValueNode &&
((ValueNode)node.CollectionItems[0]).Value is string;
var valueString = hasValue ? ((ValueNode)node.CollectionItems[0]).Value as string : string.Empty;
object ret = null;
TypeDefinition typedef = typeRef.ResolveCached();
switch (typedef.FullName)
{
case "System.SByte":
if (hasValue && sbyte.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out sbyte outsbyte))
{
ret = outsbyte;
}
else
{
ret = 0;
}
break;
case "System.Int16":
if (hasValue && short.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out short outshort))
{
ret = outshort;
}
else
{
ret = 0;
}
break;
case "System.Int32":
if (hasValue && int.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out int outint))
{
ret = outint;
}
else
{
ret = 0;
}
break;
case "System.Int64":
if (hasValue && long.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out long outlong))
{
ret = outlong;
}
else
{
ret = 0;
}
break;
case "System.Byte":
if (hasValue && byte.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out byte outbyte))
{
ret = outbyte;
}
else
{
ret = 0;
}
break;
case "System.UInt16":
if (hasValue && short.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out short outushort))
{
ret = outushort;
}
else
{
ret = 0;
}
break;
case "System.UInt32":
if (hasValue && uint.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out uint outuint))
{
ret = outuint;
}
else
{
ret = 0;
}
break;
case "System.UInt64":
if (hasValue && long.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out long outulong))
{
ret = outulong;
}
else
{
ret = 0;
}
break;
case "System.Boolean":
if (hasValue && bool.TryParse(valueString, out bool outbool))
{
ret = true;
}
else
{
ret = false;
}
break;
case "System.String":
ret = valueString;
break;
case "System.Object":
var ctorinfo =
module.TypeSystem.Object.ResolveCached()
.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters);
var ctor = module.ImportReference(ctorinfo);
ret = Create(Newobj, ctor);
break;
case "System.Char":
if (hasValue && char.TryParse(valueString, out char outchar))
{
ret = outchar;
}
else
{
ret = (char)0;
}
break;
case "System.Decimal":
decimal outdecimal;
if (hasValue && decimal.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out outdecimal))
{
ret = outdecimal;
}
else
{
ret = (decimal)0;
}
break;
case "System.Single":
if (hasValue && float.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out float outfloat))
{
ret = outfloat;
}
else
{
ret = 0f;
}
break;
case "System.Double":
if (hasValue && double.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out double outdouble))
{
ret = outdouble;
}
else
{
ret = 0d;
}
break;
case "System.TimeSpan":
if (hasValue && TimeSpan.TryParse(valueString, CultureInfo.InvariantCulture, out TimeSpan outspan))
{
ret = outspan;
}
else
{
ret = null;
}
break;
case "System.Uri":
if (hasValue && Uri.TryCreate(valueString, UriKind.RelativeOrAbsolute, out Uri outuri))
{
ret = outuri;
}
else
{
ret = null;
};
break;
default:
ret = new EXamlCreateObject(Context, null, typeRef);
break;
}
return(ret);
}
private static IEnumerable <PropertyDefinition> GetAllProperties(TypeDefinition type)
{
return(GetProperties(type).Concat(type.BaseType == null ? Enumerable.Empty <PropertyDefinition>() : GetAllProperties(type.BaseType.Resolve())));
}
public NestedCommandInjectionTypeProcessor([NotNull] CommandData command,
[NotNull] MethodDefinition initializeMethod, TypeDefinition type, ModuleWeaver moduleWeaver) : base(type, moduleWeaver)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (initializeMethod == null)
{
throw new ArgumentNullException("initializeMethod");
}
_command = command;
_initializeMethod = initializeMethod;
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node));
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
var value = GetValueFromLanguagePrimitive(typeref, node);
Context.Values[node] = value;
return;
}
TypeDefinition typedef = typeref.ResolveCached();
//if this is a MarkupExtension that can be compiled directly, compile and returns the value
var compiledMarkupExtensionName = typeref
.GetCustomAttribute(Module, (XamlTask.xamlAssemblyName, XamlTask.xamlNameSpace, "ProvideCompiledAttribute"))
?.ConstructorArguments?[0].Value as string;
Type compiledMarkupExtensionType;
ICompiledMarkupExtension markupProvider;
if (compiledMarkupExtensionName != null &&
(compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null &&
(markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null)
{
Context.Values[node] = markupProvider.ProvideValue(node, Module, Context);
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
var argumentList = GetCtorXArguments(node, factoryCtorInfo.Parameters.Count);
Context.Values[node] = new EXamlCreateObject(Context, null, typedef, argumentList.ToArray());
return;
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties[XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryMethodInfo == null)
{
var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeExtensionReference(Module, node));
typeExtensionRef = typeExtensionRef?.ResolveCached();
if (null != typeExtensionRef)
{
factoryMethodInfo = typeExtensionRef.ResolveCached().AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeExtensionRef, Module, Context));
}
}
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
var argumentList = GetCtorXArguments(node, factoryMethodInfo.Parameters.Count);
Context.Values[node] = new EXamlCreateObject(Context, null, typedef, factoryMethodInfo, argumentList?.ToArray());
return;
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Tizen.NUI.Binding.ParameterAttribute")));
}
string missingCtorParameter = null;
List <object> parameterizedCtorParams = null;
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node, out missingCtorParameter))
{
ctorInfo = parameterizedCtorInfo;
parameterizedCtorParams = GetCtorArguments(parameterizedCtorInfo, node, Context);
//Fang
//IL_0000: ldstr "foo"
//Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
if (null == ctorInfo)
{
foreach (var method in typedef.Methods)
{
if (method.IsConstructor && !method.IsStatic)
{
bool areAllParamsDefault = true;
foreach (var param in method.Parameters)
{
if (!param.HasDefault)
{
areAllParamsDefault = false;
break;
}
}
if (areAllParamsDefault)
{
if (null == ctorInfo)
{
ctorInfo = method;
}
else
{
throw new XamlParseException($"{typedef.FullName} has more than one constructor which params are all default.", node);
}
}
}
}
if (null == ctorInfo && !typedef.IsValueType)
{
throw new XamlParseException($"{typedef.FullName} has no constructor which params are all default.", node);
}
}
if (parameterizedCtorInfo != null && ctorInfo == null)
{
//there was a parameterized ctor, we didn't use it
throw new XamlParseException($"The Property '{missingCtorParameter}' is required to create a '{typedef.FullName}' object.", node);
}
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters[0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
Context.Values[node] = vnode.GetBaseValue(Context, typeref);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
var converterType = vnode.GetConverterType(new ICustomAttributeProvider[] { typeref.ResolveCached() });
if (null == converterType)
{
var realValue = vnode.GetBaseValue(Context, typeref);
Context.Values[node] = new EXamlCreateObject(Context, realValue, typeref);
}
else
{
var converterValue = new EXamlValueConverterFromString(Context, converterType.Resolve(), vnode.Value as string);
Context.Values[node] = new EXamlCreateObject(Context, converterValue, typeref);
}
}
else if (factorymethodinforef != null)
{
//Fang
//Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef));
//Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
var ctor = Module.ImportReference(ctorinforef);
//IL_0001: newobj instance void class [Tizen.NUI.Xaml.UIComponents]Tizen.NUI.Xaml.UIComponents.Button::'.ctor'()
//IL_0006: stloc.0
//Context.IL.Emit(OpCodes.Newobj, ctor);
//Context.IL.Emit(OpCodes.Stloc, vardef);
if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension")
{
typeref = Module.ImportReference(typeof(ArrayExtension));
typedef = typeref.ResolveCached();
}
var accordingType = this.GetType().Assembly.GetType(typedef.FullName);
if (null != accordingType && accordingType != typeof(Binding.Setter))
{
Context.Values[node] = new EXamlCreateObject(Context, Activator.CreateInstance(accordingType), typeref);
}
else if (null != parameterizedCtorParams)
{
Context.Values[node] = new EXamlCreateObject(Context, null, typeref, parameterizedCtorParams.ToArray());
}
else
{
bool canConvertCollectionItem = false;
if (!typeref.InheritsFromOrImplements(Context.Module.ImportReference(typeof(List <string>)).Resolve())
&&
node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null)
{
var valueNode = node.CollectionItems.First() as ValueNode;
if (valueNode.CanConvertValue(Context.Module, typeref, (TypeReference)null))
{
var converterType = valueNode.GetConverterType(new ICustomAttributeProvider[] { typeref.Resolve() });
if (null != converterType)
{
var converterValue = new EXamlValueConverterFromString(Context, converterType.Resolve(), valueNode.Value as string);
Context.Values[node] = new EXamlCreateObject(Context, converterValue, typeref);
}
else
{
var valueItem = valueNode.GetBaseValue(Context, typeref);
if (null == valueItem)
{
throw new XamlParseException($"Can't convert collection item \"{vnode.Value}\" to object", node);
}
Context.Values[node] = valueItem;
}
canConvertCollectionItem = true;
}
}
if (false == canConvertCollectionItem)
{
if (!ctorInfo.HasParameters)
{
Context.Values[node] = new EXamlCreateObject(Context, null, typeref);
}
else
{
object[] @params = new object[ctorInfo.Parameters.Count];
for (int i = 0; i < ctorInfo.Parameters.Count; i++)
{
var param = ctorInfo.Parameters[i];
if (ctorInfo.Parameters[i].ParameterType.ResolveCached().IsEnum)
{
@params[i] = NodeILExtensions.GetParsedEnum(Context, param.ParameterType, param.Constant.ToString());
}
else
{
@params[i] = param.Constant;
}
}
Context.Values[node] = new EXamlCreateObject(Context, null, typeref, @params);
}
}
}
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context))
{
//IL_0008: ldloca.s 1
//IL_000a: ldc.i4.1
//IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool)
//Fang
//var ctor = Module.ImportReference(ctorinforef);
//Context.IL.Emit(OpCodes.Ldloca, vardef);
//Context.IL.Append(PushCtorXArguments(factoryCtorInfo, node));
//Context.IL.Emit(OpCodes.Call, ctor);
}
else
{
//IL_0000: ldloca.s 0
//IL_0002: initobj Test/Foo
//Fang
//Context.IL.Emit(OpCodes.Ldloca, vardef);
//Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef));
}
if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension")
{
//Fang
//var visitor = new SetPropertiesVisitor(Context);
//foreach (var cnode in node.Properties.Values.ToList())
// cnode.Accept(visitor, node);
//foreach (var cnode in node.CollectionItems)
// cnode.Accept(visitor, node);
//markupProvider = new ArrayExtension();
//var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
//vardef = new VariableDefinition(typeref);
//Context.Variables[node] = vardef;
//Context.Body.Variables.Add(vardef);
//Context.IL.Append(il);
//Context.IL.Emit(OpCodes.Stloc, vardef);
////clean the node as it has been fully exhausted
//foreach (var prop in node.Properties)
// if (!node.SkipProperties.Contains(prop.Key))
// node.SkipProperties.Add(prop.Key);
//node.CollectionItems.Clear();
return;
}
}
}
/*
* Go through all reference assemblies of .NET Core and generate the type catalog -> Dictionary<NamespaceQualifiedTypeName, TPAStrongName>
* Then auto-generate the partial class 'PowerShellAssemblyLoadContext' that has the code to initialize the type catalog cache.
*
* In CoreCLR, there is no way to get all loaded TPA assemblies (.NET Framework Assemblies). In order to get type based on type name, powershell needs to know what .NET
* types are available and in which TPA assemblies. So we have to generate the type catalog based on the reference assemblies of .NET Core.
*/
public static void Main(string[] args)
{
if (args.Length < 2 || args.Length > 3)
{
string message = string.Format(CultureInfo.CurrentCulture, HelpMessage,
Param_TargetCSharpFilePath,
Param_ReferenceListPath,
Param_PrintDebugMessage);
Console.WriteLine(message);
return;
}
bool printDebugMessage = args.Length == 3 && string.Equals(Param_PrintDebugMessage, args[2], StringComparison.OrdinalIgnoreCase);
string targetFilePath = ResolveTargetFilePath(args[0]);
List <string> refAssemblyFiles = ResolveReferenceAssemblies(args[1]);
Dictionary <string, TypeMetadata> typeNameToAssemblyMap = new Dictionary <string, TypeMetadata>(StringComparer.OrdinalIgnoreCase);
// mscorlib.metadata_dll doesn't contain any type definition.
foreach (string filePath in refAssemblyFiles)
{
if (!filePath.EndsWith(".METADATA_DLL", StringComparison.OrdinalIgnoreCase) &&
!filePath.EndsWith(".DLL", StringComparison.OrdinalIgnoreCase))
{
string message = string.Format(CultureInfo.CurrentCulture, UnexpectedFileExtension, filePath);
throw new InvalidOperationException(message);
}
using (Stream stream = File.OpenRead(filePath))
using (PEReader peReader = new PEReader(stream))
{
MetadataReader metadataReader = peReader.GetMetadataReader();
string strongAssemblyName = GetAssemblyStrongName(metadataReader);
foreach (TypeDefinitionHandle typeHandle in metadataReader.TypeDefinitions)
{
// We only care about public types
TypeDefinition typeDefinition = metadataReader.GetTypeDefinition(typeHandle);
// The visibility mask is used to mask out the bits that contain the visibility.
// The visibilities are not combineable, e.g. you can't be both public and private, which is why these aren't independent powers of two.
TypeAttributes visibilityBits = typeDefinition.Attributes & TypeAttributes.VisibilityMask;
if (visibilityBits != TypeAttributes.Public && visibilityBits != TypeAttributes.NestedPublic)
{
continue;
}
string fullName = GetTypeFullName(metadataReader, typeDefinition);
bool isTypeObsolete = IsTypeObsolete(metadataReader, typeDefinition);
if (!typeNameToAssemblyMap.ContainsKey(fullName))
{
// Add unique type.
typeNameToAssemblyMap.Add(fullName, new TypeMetadata(strongAssemblyName, isTypeObsolete));
}
else if (typeNameToAssemblyMap[fullName].IsObsolete && !isTypeObsolete)
{
// Duplicate types found defined in different assemblies, but the previous one is obsolete while the current one is not.
// Replace the existing type with the current one.
if (printDebugMessage)
{
var existingTypeMetadata = typeNameToAssemblyMap[fullName];
Console.WriteLine($@"
REPLACE '{fullName}' from '{existingTypeMetadata.AssemblyName}' (IsObsolete? {existingTypeMetadata.IsObsolete})
WITH '{strongAssemblyName}' (IsObsolete? {isTypeObsolete})");
}
typeNameToAssemblyMap[fullName] = new TypeMetadata(strongAssemblyName, isTypeObsolete);
}
else if (printDebugMessage)
{
// Duplicate types found defined in different assemblies, and fall into one of the following conditions:
// - both are obsolete
// - both are not obsolete
// - the existing type is not obsolete while the new one is obsolete
var existingTypeMetadata = typeNameToAssemblyMap[fullName];
Console.WriteLine($@"
DUPLICATE key '{fullName}' from '{strongAssemblyName}' (IsObsolete? {isTypeObsolete}).
-- Already exist in '{existingTypeMetadata.AssemblyName}' (IsObsolete? {existingTypeMetadata.IsObsolete})");
}
}
}
}
WritePowerShellAssemblyLoadContextPartialClass(targetFilePath, typeNameToAssemblyMap);
}
internal void AddCanExecuteMethod(TypeDefinition commandType)
{
var field = commandType.Fields[0];
var method = new MethodDefinition("CanExecute",
MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot |
MethodAttributes.Virtual, Assets.TypeReferences.Boolean)
{
Body = { InitLocals = true }
};
var commandParameter = new ParameterDefinition("parameter", ParameterAttributes.None, Assets.TypeReferences.Object);
method.Parameters.Add(commandParameter);
var returnVariable = new VariableDefinition(Assets.TypeReferences.Boolean);
method.Body.Variables.Add(returnVariable);
commandType.Methods.Add(method);
var il = method.Body.GetILProcessor();
il.Append(Instruction.Create(OpCodes.Nop));
if (Command.CanExecuteMethods.Count == 0)
{
var returnBlock = Instruction.Create(OpCodes.Ldloc_0);
il.Append(Instruction.Create(OpCodes.Ldc_I4_1));
il.Append(Instruction.Create(OpCodes.Stloc_0));
il.Append(Instruction.Create(OpCodes.Br_S, returnBlock));
il.Append(returnBlock);
il.Append(Instruction.Create(OpCodes.Ret));
}
else
{
var canExecuteMethod = Command.CanExecuteMethods.Single();
var returnBlock = Instruction.Create(OpCodes.Nop);
il.Append(Instruction.Create(OpCodes.Ldarg_0));
il.Append(Instruction.Create(OpCodes.Ldfld, field));
if (canExecuteMethod.Parameters.Count == 1)
{
il.Append(Instruction.Create(OpCodes.Ldarg_1));
var parameter = canExecuteMethod.Parameters[0];
if (!parameter.ParameterType.FullNameMatches(Assets.TypeReferences.Object))
{
if (parameter.ParameterType.IsGenericInstance)
{
}
else
{
il.Append(Instruction.Create(OpCodes.Unbox_Any, parameter.ParameterType));
}
}
}
if (canExecuteMethod.IsVirtual)
{
il.Append(Instruction.Create(OpCodes.Callvirt, canExecuteMethod));
}
else
{
il.Append(Instruction.Create(OpCodes.Call, canExecuteMethod));
}
il.Append(Instruction.Create(OpCodes.Stloc_0));
il.Append(Instruction.Create(OpCodes.Br_S, returnBlock));
il.Append(returnBlock);
il.Append(Instruction.Create(OpCodes.Ldloc_0));
il.Append(Instruction.Create(OpCodes.Ret));
}
}
public static bool CanShow(TypeDefinition type)
{
return(true);
}
// Returns a list of default implementations of the given interface method on this type.
// Note that this returns a list to potentially cover the diamond case (more than one
// most specific implementation of the given interface methods). Linker needs to preserve
// all the implementations so that the proper exception can be thrown at runtime.
static IEnumerable <InterfaceImplementation> GetDefaultInterfaceImplementations(TypeDefinition type, MethodDefinition interfaceMethod)
{
// Go over all interfaces, trying to find a method that is an explicit MethodImpl of the
// interface method in question.
foreach (var interfaceImpl in type.Interfaces)
{
var potentialImplInterface = interfaceImpl.InterfaceType.Resolve();
if (potentialImplInterface == null)
{
continue;
}
bool foundImpl = false;
foreach (var potentialImplMethod in potentialImplInterface.Methods)
{
if (potentialImplMethod == interfaceMethod &&
!potentialImplMethod.IsAbstract)
{
yield return(interfaceImpl);
}
if (!potentialImplMethod.HasOverrides)
{
continue;
}
// This method is an override of something. Let's see if it's the method we are looking for.
foreach (var @override in potentialImplMethod.Overrides)
{
if (@override.Resolve() == interfaceMethod)
{
yield return(interfaceImpl);
foundImpl = true;
break;
}
}
if (foundImpl)
{
break;
}
}
// We haven't found a MethodImpl on the current interface, but one of the interfaces
// this interface requires could still provide it.
if (!foundImpl)
{
foreach (var impl in GetDefaultInterfaceImplementations(potentialImplInterface, interfaceMethod))
{
yield return(impl);
}
}
}
}
public static DeclaredTypeObject CreateFrom(ResolvedAssemblyObject ao, TypeDefinition typeDef)
{
DeclaredTypeObject to = new DeclaredTypeObject(ao._fs, ao._peReader, ao._metaReader, typeDef);
to.Assembly = ao;
return to;
}
private static void GenerateGeneric(TypeDefinition @static, ModuleDefinition mainModule)
{
var method = new MethodDefinition("Aggregate", Helper.StaticMethodAttributes, mainModule.TypeSystem.Void)
{
DeclaringType = @static,
AggressiveInlining = true,
CustomAttributes = { Helper.ExtensionAttribute }
};
@static.Methods.Add(method);
var genericParameters = method.GenericParameters;
var(T, TEnumerator, TEnumerable) = method.Define3GenericParameters();
var TAccumulate = new GenericParameter("TAccumulate", method);
genericParameters.Add(TAccumulate);
method.ReturnType = TAccumulate;
var IRefAction = new GenericInstanceType(mainModule.GetType("UniNativeLinq", "IRefAction`2"))
{
GenericArguments = { TAccumulate, T }
};
var TFunc = new GenericParameter("TFunc", method)
{
Constraints =
{
IRefAction
}
};
genericParameters.Add(TFunc);
method.Parameters.Add(new ParameterDefinition("@this", ParameterAttributes.In, new ByReferenceType(TEnumerable))
{
CustomAttributes = { Helper.GetSystemRuntimeCompilerServicesIsReadOnlyAttributeTypeReference() }
});
method.Parameters.Add(new ParameterDefinition("accumulate", ParameterAttributes.None, TAccumulate));
method.Parameters.Add(new ParameterDefinition("func", ParameterAttributes.In, new ByReferenceType(TFunc))
{
CustomAttributes = { Helper.GetSystemRuntimeCompilerServicesIsReadOnlyAttributeTypeReference() }
});
var body = method.Body;
var enumeratorVariable = new VariableDefinition(TEnumerator);
body.Variables.Add(enumeratorVariable);
body.Variables.Add(new VariableDefinition(method.Module.TypeSystem.Boolean));
body.Variables.Add(new VariableDefinition(new ByReferenceType(T)));
var loopStart = Instruction.Create(OpCodes.Ldarg_2);
var condition = Instruction.Create(OpCodes.Ldloca_S, enumeratorVariable);
body.GetILProcessor()
.LdArg(0)
.GetEnumeratorEnumerable(TEnumerable)
.StLoc(0)
.BrS(condition)
.Add(loopStart)
.LdArgA(1)
.LdLoc(2)
.Constrained(TFunc)
.CallVirtual(IRefAction.FindMethod("Execute"))
.Add(condition)
.LdLocA(1)
.TryGetNextEnumerator(TEnumerator)
.StLoc(2)
.LdLoc(1)
.BrTrueS(loopStart)
.LdLocA(0)
.DisposeEnumerator(TEnumerator)
.LdArg(1)
.Ret();
}
