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