public static FieldInfoMirror GetMonoField(TypeMirror monoType, DmdFieldInfo field)
{
var fields = field.DeclaringType.DeclaredFields;
int fieldIndex = GetIndex(fields, field);
return(GetMonoField(monoType, fields, fieldIndex));
}
public ReferenceTypeFieldAddress(DebuggerRuntimeImpl runtime, DbgDotNetValue objValue, DmdFieldInfo field)
: base(runtime, field.FieldType)
{
Debug.Assert(!field.ReflectedType.IsValueType && !objValue.Type.IsArray);
this.objValue = objValue;
this.field = field;
}
protected override void FormatFieldName(IDbgTextWriter output, DmdFieldInfo field)
{
var name = Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(field.Name);
var color = MemberUtils.GetColor(field);
output.Write(color, name);
}
protected override void FormatFieldName(ITextColorWriter output, DmdFieldInfo field)
{
var name = Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(field.Name);
var color = MemberUtils.GetColor(field);
output.Write(color, name);
}
static DmdFieldInfo TryGetBuilderFieldByType(DmdType type)
{
DmdFieldInfo builderField = null;
foreach (var field in type.Fields)
{
var fieldType = field.FieldType;
if (fieldType.IsNested)
{
continue;
}
if (fieldType.IsConstructedGenericType)
{
fieldType = fieldType.GetGenericTypeDefinition();
}
foreach (var info in builderWellKnownTypeNames)
{
if (fieldType.MetadataNamespace == info.@namespace && fieldType.MetadataName == info.name)
{
return(field);
}
}
if ((object)builderField == null && fieldType.MetadataName != null &&
(fieldType.MetadataName.EndsWith("MethodBuilder", StringComparison.Ordinal) ||
fieldType.MetadataName.EndsWith("MethodBuilder`1", StringComparison.Ordinal)))
{
builderField = field;
}
}
return(builderField);
}
public ValueTypeFieldAddress(DebuggerRuntimeImpl runtime, AddressILValue objValue, DmdFieldInfo field)
: base(runtime, field.FieldType)
{
Debug.Assert(field.ReflectedType.IsValueType);
this.objValue = objValue;
this.field = field;
}
public override ILValue LoadFieldAddress(DmdFieldInfo field)
{
if (field.ReflectedType.IsValueType)
{
return(runtime.LoadValueTypeFieldAddress(this, field));
}
return(null);
}
static int GetIndex(ReadOnlyCollection<DmdFieldInfo> fields, DmdFieldInfo field) {
for (int i = 0; i < fields.Count; i++) {
var f = fields[i];
if (f.MetadataToken == field.MetadataToken && f.Module == field.Module)
return i;
}
throw new InvalidOperationException();
}
public override ILValue LoadFieldAddress(DmdFieldInfo field)
{
if (!fields.ContainsKey(field))
{
return(null);
}
return(new FakeFieldAddress(fields, field));
}
public override ILValue?LoadFieldAddress(DmdFieldInfo field)
{
if (!field.ReflectedType !.IsValueType)
{
return(runtime.LoadReferenceTypeFieldAddress(ObjValue, field));
}
return(null);
}
public override bool StoreField(DmdFieldInfo field, ILValue value)
{
if (!fields.ContainsKey(field))
{
return(false);
}
fields[field] = value;
return(true);
}
void WriteEnumField(DmdFieldInfo field)
{
if (Edit)
{
FormatType(field.ReflectedType);
OutputWrite(".", DbgTextColor.Operator);
}
OutputWrite(VisualBasicTypeFormatter.GetFormattedIdentifier(field.Name), DbgTextColor.EnumField);
}
void WriteEnumField(DmdFieldInfo field)
{
if (Edit)
{
FormatType(field.ReflectedType);
OutputWrite(".", BoxedTextColor.Operator);
}
OutputWrite(CSharpTypeFormatter.GetFormattedIdentifier(field.Name), BoxedTextColor.EnumField);
}
public bool StoreField(DmdFieldInfo field, ILValue value)
{
InitFields(field.ReflectedType);
if (!AllFields.ContainsKey(field))
{
return(false);
}
AllFields[field] = value;
return(true);
}
internal bool StoreStaticField(DmdFieldInfo field, object value)
{
var error = runtime.StoreField(evalInfo, null, field, value);
if (error != null)
{
throw new InterpreterMessageException(error);
}
return(true);
}
internal bool StoreInstanceField(DbgDotNetValue objValue, DmdFieldInfo field, object value)
{
var error = runtime.StoreField(context, frame, objValue, field, value, cancellationToken);
if (error != null)
{
throw new InterpreterMessageException(error);
}
return(true);
}
/// <summary>
/// Gets the builder instance. It's assumed to be stored in a field in the current 'this' instance.
///
/// The decompiler should already know the field. If that info isn't available, we'll try to find
/// the field by name, and if that fails, by field type.
///
/// null is returned if we couldn't find the field or if we failed to read the field.
/// </summary>
/// <param name="evalInfo">Evaluation info</param>
/// <param name="builderFieldModule">Module of builder field or null if unknown</param>
/// <param name="builderFieldToken">Token of builder field or 0 if unknown</param>
/// <returns></returns>
public static DbgDotNetValue TryGetBuilder(DbgEvaluationInfo evalInfo, DmdModule builderFieldModule, uint builderFieldToken)
{
DbgDotNetValueResult thisArg = default;
DbgDotNetValueResult tmpResult = default;
try {
var runtime = evalInfo.Runtime.GetDotNetRuntime();
thisArg = runtime.GetParameterValue(evalInfo, 0);
if (!thisArg.IsNormalResult || thisArg.Value.IsNull)
{
return(null);
}
if (thisArg.Value.Type.IsByRef)
{
tmpResult = thisArg.Value.LoadIndirect();
if (!tmpResult.IsNormalResult || tmpResult.Value.IsNull)
{
return(null);
}
thisArg.Value?.Dispose();
thisArg = tmpResult;
tmpResult = default;
}
DmdFieldInfo builderField = null;
if (builderFieldModule != null && builderFieldToken != 0)
{
builderField = thisArg.Value.Type.GetField(builderFieldModule, (int)builderFieldToken);
}
if ((object)builderField == null)
{
builderField = TryGetBuilderField(thisArg.Value.Type);
}
if ((object)builderField == null)
{
return(null);
}
Debug.Assert((object)builderField == TryGetBuilderFieldByType(thisArg.Value.Type));
Debug.Assert((object)TryGetBuilderFieldByname(thisArg.Value.Type) == null ||
(object)TryGetBuilderFieldByname(thisArg.Value.Type) == TryGetBuilderFieldByType(thisArg.Value.Type));
tmpResult = runtime.LoadField(evalInfo, thisArg.Value, builderField);
if (!tmpResult.IsNormalResult || tmpResult.Value.IsNull)
{
return(null);
}
var fieldValue = tmpResult.Value;
tmpResult = default;
return(fieldValue);
}
finally {
thisArg.Value?.Dispose();
tmpResult.Value?.Dispose();
}
}
public override ILValue LoadStaticFieldAddress(DmdFieldInfo field)
{
var addrValue = runtime.LoadFieldAddress(evalInfo, null, field);
if (addrValue != null)
{
Debug.Assert(addrValue.Type.IsByRef);
return(new ByRefILValueImpl(this, RecordValue(addrValue)));
}
return(new StaticFieldAddress(this, field));
}
internal ILValue LoadReferenceTypeFieldAddress(DbgDotNetValue objValue, DmdFieldInfo field)
{
Debug.Assert(!field.ReflectedType.IsValueType);
var addrValue = runtime.LoadFieldAddress(evalInfo, objValue, field);
if (addrValue != null)
{
Debug.Assert(addrValue.Type.IsByRef);
return(new ByRefILValueImpl(this, RecordValue(addrValue)));
}
return(new ReferenceTypeFieldAddress(this, objValue, field));
}
internal ILValue LoadValueTypeFieldAddress(AddressILValue objValue, DmdFieldInfo field)
{
Debug.Assert(field.ReflectedType.IsValueType);
var dnObjValue = TryGetDotNetValue(objValue, canCreateValue: false);
if (dnObjValue != null)
{
var addrValue = runtime.LoadFieldAddress(evalInfo, dnObjValue, field);
if (addrValue != null)
{
Debug.Assert(addrValue.Type.IsByRef);
return(new ByRefILValueImpl(this, RecordValue(addrValue)));
}
}
return(new ValueTypeFieldAddress(this, objValue, field));
}
public static DbgTextColor GetColor(DmdFieldInfo field)
{
if (field.ReflectedType.IsEnum)
{
return(DbgTextColor.EnumField);
}
if (field.IsLiteral)
{
return(DbgTextColor.LiteralField);
}
if (field.IsStatic)
{
return(DbgTextColor.StaticField);
}
return(DbgTextColor.InstanceField);
}
public override DmdFieldInfo[] ReadDeclaredFields(DmdType declaringType, DmdType reflectedType)
{
var ridList = reader.Metadata.GetFieldRidList(Rid);
if (ridList.Count == 0)
{
return(Array.Empty <DmdFieldInfo>());
}
var fields = new DmdFieldInfo[ridList.Count];
for (int i = 0; i < fields.Length; i++)
{
uint rid = ridList[i];
fields[i] = reader.CreateFieldDef(rid, declaringType, reflectedType);
}
return(fields);
}
public static (DmdFieldInfo hasValueField, DmdFieldInfo valueField) TryGetNullableFields(DmdType type)
{
Debug.Assert(type.IsNullable);
DmdFieldInfo hasValueField = null;
DmdFieldInfo valueField = null;
var fields = type.DeclaredFields;
for (int i = 0; i < fields.Count; i++)
{
var field = fields[i];
if (field.IsStatic || field.IsLiteral)
{
continue;
}
switch (field.Name)
{
case HasValueFieldName:
case HasValueFieldName_Mono:
if ((object)hasValueField != null)
{
return(null, null);
}
hasValueField = field;
break;
case ValueFieldName:
if ((object)valueField != null)
{
return(null, null);
}
valueField = field;
break;
default:
return(null, null);
}
}
if ((object)hasValueField == null || (object)valueField == null)
{
return(null, null);
}
return(hasValueField, valueField);
}
DmdFieldInfo[] ReadDeclaredFields_COMThread(DmdType declaringType, DmdType reflectedType)
{
reader.Dispatcher.VerifyAccess();
var tokens = MDAPI.GetFieldTokens(reader.MetaDataImport, (uint)MetadataToken);
if (tokens.Length == 0)
{
return(Array.Empty <DmdFieldInfo>());
}
var fields = new DmdFieldInfo[tokens.Length];
for (int i = 0; i < fields.Length; i++)
{
uint rid = tokens[i] & 0x00FFFFFF;
fields[i] = reader.CreateFieldDef_COMThread(rid, declaringType, reflectedType);
}
return(fields);
}
public static (DmdFieldInfo keyField, DmdFieldInfo valueField) TryGetFields(DmdType type)
{
Debug.Assert(IsKeyValuePair(type));
DmdFieldInfo keyField = null;
DmdFieldInfo valueField = null;
var fields = type.DeclaredFields;
for (int i = 0; i < fields.Count; i++)
{
var field = fields[i];
if (field.IsStatic || field.IsLiteral)
{
continue;
}
switch (field.Name)
{
case KeyFieldName:
if ((object)keyField != null)
{
return(null, null);
}
keyField = field;
break;
case ValueFieldName:
if ((object)valueField != null)
{
return(null, null);
}
valueField = field;
break;
default:
return(null, null);
}
}
if ((object)keyField == null || (object)valueField == null)
{
return(null, null);
}
return(keyField, valueField);
}
public static (DmdFieldInfo keyField, DmdFieldInfo valueField) TryGetFields(DmdType type, string keyFieldName, string valueFieldName)
{
DmdFieldInfo keyField = null;
DmdFieldInfo valueField = null;
var fields = type.DeclaredFields;
for (int i = 0; i < fields.Count; i++)
{
var field = fields[i];
if (field.IsStatic || field.IsLiteral)
{
continue;
}
if (field.Name == keyFieldName)
{
if ((object)keyField != null)
{
return(null, null);
}
keyField = field;
}
else if (field.Name == valueFieldName)
{
if ((object)valueField != null)
{
return(null, null);
}
valueField = field;
}
else
{
return(null, null);
}
}
if ((object)keyField == null || (object)valueField == null)
{
return(null, null);
}
return(keyField, valueField);
}
public static bool IsMatch(DmdFieldInfo field, DmdBindingFlags bindingAttr)
{
var attr = DmdBindingFlags.Default;
if (field.IsPublic)
{
attr |= DmdBindingFlags.Public;
}
else
{
attr |= DmdBindingFlags.NonPublic;
}
if (field.IsStatic)
{
attr |= DmdBindingFlags.Static;
}
else
{
attr |= DmdBindingFlags.Instance;
}
if ((object)field.ReflectedType != field.DeclaringType)
{
if (field.IsStatic)
{
if (field.IsPrivate)
{
return(false);
}
attr |= DmdBindingFlags.FlattenHierarchy;
}
else
{
if (field.IsPrivate)
{
return(false);
}
}
}
return((attr & bindingAttr) == attr);
}
/// <summary> /// Stores a value in a static field or returns false on failure /// </summary> /// <param name="field">Field</param> /// <param name="value">Value to store in the field</param> public abstract bool StoreStaticField(DmdFieldInfo field, ILValue value);
/// <summary> /// Returns the address of a static field or returns null on failure /// </summary> /// <param name="field">Field</param> /// <returns></returns> public abstract ILValue LoadStaticFieldAddress(DmdFieldInfo field);
/// <summary> /// Creates a <see cref="RuntimeFieldHandle"/> value or returns null on failure /// </summary> /// <param name="field">Field</param> /// <returns></returns> public abstract ILValue CreateRuntimeFieldHandle(DmdFieldInfo field);
