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