public WeakEventWeaver(FieldReference eventDelegate, ModuleImporter moduleimporter) { _eventDelegate = eventDelegate.Resolve(); _moduleimporter = moduleimporter; _closedGenericEventHandler = moduleimporter.GetClosedEventHandlerT(eventDelegate.FieldType.GetEventArgsType()); _isGenericHandler = _closedGenericEventHandler.FullName.Equals(eventDelegate.FieldType.FullName); }
private FieldReference FixFieldReference(FieldReference yourFieldRef) { if (yourFieldRef == null) { Log_called_to_fix_null("field"); return null; } Log_fixing_reference("field", yourFieldRef); Asserts.AssertTrue(yourFieldRef.DeclaringType != null); var yourFieldDef = yourFieldRef.Resolve(); if (yourFieldDef.IsDisablePatching()) { Log_trying_to_fix_disabled_reference("field", yourFieldRef); } var targetType = FixTypeReference(yourFieldRef.DeclaringType); var targetBaseFieldDef = yourFieldRef; if (yourFieldDef.Module.Assembly.IsPatchingAssembly()) { //additional checking var targetFieldDef = CurrentMemberCache.Fields.TryGet(yourFieldDef)?.TargetMember; if (targetFieldDef == null) { throw Errors.Could_not_resolve_reference("field", yourFieldRef); } targetBaseFieldDef = targetFieldDef; } else { //we assume that types that aren't in a patching assembly will never reference types in a patching assembly targetBaseFieldDef = yourFieldRef; } var newFieldRef = targetBaseFieldDef.CloneReference(); newFieldRef.DeclaringType = targetType; newFieldRef.FieldType = FixTypeReference(newFieldRef.FieldType); var targetFieldRef = TargetAssembly.MainModule.Import(newFieldRef); Log_fixed_reference("field", yourFieldRef, targetFieldRef); targetFieldRef.Module.Assembly.AssertEqual(TargetAssembly); return targetFieldRef; }
private bool CheckAndSaveStateField(FieldReference foundStateField) { FieldDefinition foundFieldDef = foundStateField.Resolve(); if (stateField == null) { stateField = foundFieldDef; } else if(stateField != foundFieldDef) { return false; } return true; }
private static void CreateWellName(FieldReference fr) { var name = CleanName(fr.Name); var start = name.IndexOf(NONWELLFLAG); if (start == -1) { if (IsNameRepeated(fr.DeclaringType, name)) name = "f_" + name + "_" + GetShortName(fr.FieldType); } else { var fd = fr.Resolve(); if (fd.DeclaringType.IsEnum) { var value = fd.Constant.ToString().Replace('-', 'n'); var suffix = "_" + value; name = Replace(name, start, 1, "V") + suffix; } else { var suffix = "_" + GetShortName(fd.FieldType); name = fd.IsLiteral ? Replace(name, start, 1, "CONST").ToUpper() + suffix.ToUpper() + "_" + Regex.Replace(fd.Constant.ToString(), @"\W", "_") : Replace(name, start, 1, "f") + suffix; } } fr.mWellName = Regex.Replace(name, @"\W", "_"); }
private bool IsBlacklisted(FieldReference field) { var fieldDef = field.Resolve(); if (fieldDef == null) return true; // TODO: log if (ReferenceEquals(Module, fieldDef.Module)) return false; return _accessLists.IsBlacklisted(fieldDef); }
protected virtual string GetFieldName(FieldReference field) { FieldDefinition fieldDefinition = field.Resolve(); if (fieldDefinition != null && fieldDefinition.Module.FilePath == this.ModuleContext.Module.FilePath) { if (this.TypeContext != null && this.TypeContext.BackingFieldToNameMap.ContainsKey(fieldDefinition)) { return this.TypeContext.BackingFieldToNameMap[fieldDefinition]; } return this.ModuleContext.RenamedMembersMap[fieldDefinition.MetadataToken.ToUInt32()]; } return Utilities.EscapeName(GenericHelper.GetNonGenericName(field.Name), this.Language); }
private UInt16 GetFieldReferenceId( FieldReference fieldReference) { UInt16 referenceId; if (_context.FieldReferencesTable.TryGetFieldReferenceId(fieldReference, out referenceId)) { referenceId |= 0x8000; // External field reference } else { _context.FieldsTable.TryGetFieldReferenceId(fieldReference.Resolve(), false, out referenceId); } return referenceId; }
static FieldDefinition GetFieldDefinition(FieldReference field) { if (field != null && field.DeclaringType.IsGenericInstance) return field.Resolve(); else return field as FieldDefinition; }
private void AddField(FieldReference field) { if (field == null || IsIgnored(field)) { return; } AddType(field.FieldType); AddType(field.DeclaringType); FieldDefinition resolvedField = field.Resolve(); fields.Add(resolvedField); }
private bool CheckAndSaveCurrentItemField(FieldReference foundCurrentItemFieldRef) { FieldDefinition fieldDef = foundCurrentItemFieldRef.Resolve(); if(currentItemField == null) { currentItemField = fieldDef; } else if(currentItemField != fieldDef) { return false; } return true; }
static bool IsObsolete(FieldReference field) { if (field == null) return false; bool obsolete = false; if (!fields.TryGetValue (field, out obsolete)) { FieldDefinition fd = field.Resolve (); obsolete = fd.HasAttribute ("System", "ObsoleteAttribute"); fields.Add (field, obsolete); } return obsolete; }
static bool GenericFieldComparer(FieldReference fieldReference, FieldDefinition fieldDefinition) { return fieldDefinition == fieldReference.Resolve(); }
public virtual FieldReference FindLinked(FieldReference field) { FieldDefinition def = field.Resolve(); if (def == null || !def.HasCustomAttributes) { return field; } CustomAttribute attrib = null; foreach (CustomAttribute attrib_ in def.CustomAttributes) { if (attrib_.AttributeType.FullName == "MonoMod.MonoModLinkTo") { attrib = attrib_; break; } } if (attrib == null) { return field; } TypeDefinition type = null; if (attrib.ConstructorArguments[0].Type.FullName == "System.String") { //TODO get type from name } else { type = FindType((TypeReference) attrib.ConstructorArguments[0].Value).Resolve(); } //TODO get method from name for (int i = 0; i < type.Fields.Count; i++) { if (type.Methods[i].Name == ((string) attrib.ConstructorArguments[1].Value)) { //Probably check for more than that field = type.Fields[i]; break; } } //TODO cache somewhere return field; }
private bool IsAutoPropertyConstructorInitializerExpression(FieldReference fieldReference, out PropertyDefinition property) { FieldDefinition fieldDefinition = fieldReference.Resolve(); if (fieldDefinition != null) { Dictionary<FieldDefinition, PropertyDefinition> map = this.typeContext.FieldToPropertyMap; if (map.ContainsKey(fieldDefinition) && map[fieldDefinition] != null && !map[fieldDefinition].ShouldStaySplit()) { property = map[fieldDefinition]; return true; } } property = null; return false; }
bool IsVisibleFrom (TypeDefinition type, FieldReference reference) { if (reference == null) return true; FieldDefinition field = reference.Resolve (); if (field == null) return true; TypeDefinition dec = (TypeDefinition) field.DeclaringType; if (!IsVisibleFrom (type, dec)) return false; if (field.IsPublic) return true; if (type == dec || IsNestedIn (type, dec)) return true; if (field.IsFamily && InHierarchy (type, dec)) return true; if (field.IsFamilyOrAssembly && (!AreInDifferentAssemblies (type, dec) || InHierarchy (type, dec))) return true; if (field.IsFamilyAndAssembly && (!AreInDifferentAssemblies (type, dec) && InHierarchy (type, dec))) return true; if (!AreInDifferentAssemblies (type, dec) && field.IsAssembly) return true; return false; }
/// <summary> /// Mark all reachable items in argument as such. /// </summary> private static void Walk(ReachableContext context, FieldReference field) { // Field type field.FieldType.MarkReachable(context, field.IsUsedInSerialization); var fieldDef = field as FieldDefinition; if (fieldDef != null) { // Custom attributes Walk(context, (ICustomAttributeProvider)fieldDef); // Walk imported java classes CustomAttribute javaImportAttr; if ((javaImportAttr = fieldDef.GetJavaImportAttribute()) != null) { string className; string memberName; string descriptor; javaImportAttr.GetDexOrJavaImportNames(fieldDef, out memberName, out descriptor, out className); ClassFile javaClass; if (context.TryLoadClass(className, out javaClass)) { var javaField = javaClass.Fields.FirstOrDefault(x => (x.Name == memberName) && (x.Descriptor == descriptor)); javaClass.MarkReachable(context); javaField.MarkReachable(context); } } } else { // Try to resolve field.Resolve(context).MarkReachable(context, field.IsUsedInSerialization); } }
/// <summary> /// Check the given field reference. /// </summary> private void Check(FieldReference field, string context) { if (!Check(field.DeclaringType, context)) return; var error = false; try { var fieldDef = field.Resolve(); error = (fieldDef == null); } catch (Exception) { error = true; } CheckResolveData data; var key = field.FullName; if (!resolveErrorFieldNames.TryGetValue(key, out data)) { data = new CheckResolveData { IsAvailable = !error }; resolveErrorFieldNames.Add(key, data); if (error) { Error(MessageTypes.MissingField, Format(field), field.DeclaringType.Scope, context); } } data.CheckCount++; }
private bool IsIgnored(FieldReference field) { var fieldDefenition = field.Resolve(); if (fieldDefenition != null) { var fieldInfo = TypeInfoProvider.GetMemberInformation<FieldInfo>(fieldDefenition); if (fieldInfo.IsIgnored) { return true; } } if (field.DeclaringType.IsGenericInstance) { if (IsIgnored(field.DeclaringType)) { return true; } } return false; }
static bool CheckField (FieldReference field) { // skip instance fields and generated static field (likely by the compiler) if ((field == null) || field.IsGeneratedCode ()) return false; // check if the field could be resolved FieldDefinition fd = field.Resolve (); if (fd == null) return false; // skip fields decorated with [ThreadStatic] (the runtime will use // thread local storage for these so they are thread safe) if (fd.HasCustomAttributes) { if (fd.CustomAttributes.ContainsType (ThreadStaticAttribute)) return false; } return true; }
private void AddField(FieldReference field) { if (field == null || IsIgnored(field)) { return; } AddType(field.FieldType); AddType(field.DeclaringType); FieldDefinition resolvedField = field.Resolve(); if (resolvedField != null) { Fields.Add(resolvedField); ProcessMarshallInfo(resolvedField.MarshalInfo); } }
public void Visit(FieldReference field, string referencingEntityName) { if (field.Resolve() != null) return; if (IsIgnoredType(field.DeclaringType)) return; Console.WriteLine("Error: field `{0}` doesn't exist in target framework. It is referenced from {1} at {2}.", field, field.Module.Name, referencingEntityName); }
/// <summary> /// A cecil field reference will be directed to this method. /// </summary> /// <param name="item">Cecil reference.</param> /// <param name="resolvedItem">Output parameter that will be populated with the resolved cecil definition.</param> /// <returns><c>true</c></returns> private static bool TryResolve(FieldReference item, out object resolvedItem) { resolvedItem = item.Resolve(); return true; }
FieldDefinition ResolveFieldDefinition (FieldReference field) { FieldDefinition fd = field as FieldDefinition; if (fd == null) fd = field.Resolve (); return fd; }
public static FieldDefinition Resolve(FieldReference fr, IEnumerable<AssemblyDefinition> assemblyList, ITextInfo info) { if (fr == null) return null; if (fr is FieldDefinition) return (FieldDefinition)fr; try { SetupResolveFirst(assemblyList); return fr.Resolve(); } catch(Exception ex) { if (info != null && !info.TextInfo.Contains(ex.Message)) info.AppendTextInfoLine(ex.Message); return null; } finally { RemoveResolveFirst(); } }