internal void HandleStaticFieldInitializers(IEnumerable <AstNode> members)
{
// Translate static constructor into field initializers if the class is BeforeFieldInit
var staticCtor = members.OfType <ConstructorDeclaration>().FirstOrDefault(c => (c.Modifiers & Modifiers.Static) == Modifiers.Static);
if (staticCtor != null)
{
IMethod ctorMethod = staticCtor.GetSymbol() as IMethod;
if (!ctorMethod.MetadataToken.IsNil)
{
var metadata = context.TypeSystem.MainModule.PEFile.Metadata;
SRM.MethodDefinition ctorMethodDef = metadata.GetMethodDefinition((SRM.MethodDefinitionHandle)ctorMethod.MetadataToken);
SRM.TypeDefinition declaringType = metadata.GetTypeDefinition(ctorMethodDef.GetDeclaringType());
if (declaringType.HasFlag(System.Reflection.TypeAttributes.BeforeFieldInit))
{
while (true)
{
ExpressionStatement es = staticCtor.Body.Statements.FirstOrDefault() as ExpressionStatement;
if (es == null)
{
break;
}
AssignmentExpression assignment = es.Expression as AssignmentExpression;
if (assignment == null || assignment.Operator != AssignmentOperatorType.Assign)
{
break;
}
IMember fieldOrProperty = (assignment.Left.GetSymbol() as IMember)?.MemberDefinition;
if (!(fieldOrProperty is IField || fieldOrProperty is IProperty) || !fieldOrProperty.IsStatic)
{
break;
}
AstNode fieldOrPropertyDecl = members.FirstOrDefault(f => f.GetSymbol() == fieldOrProperty);
if (fieldOrPropertyDecl == null)
{
break;
}
if (fieldOrPropertyDecl is FieldDeclaration fd)
{
fd.Variables.Single().Initializer = assignment.Right.Detach();
}
else if (fieldOrPropertyDecl is PropertyDeclaration pd)
{
pd.Initializer = assignment.Right.Detach();
}
else
{
break;
}
es.Remove();
}
if (staticCtor.Body.Statements.Count == 0)
{
staticCtor.Remove();
}
}
}
}
}
private void InitializeMethodDefinition(Cts.MethodDesc entity, Method record)
{
record.Name = HandleString(entity.Name);
record.Signature = HandleMethodSignature(entity.Signature);
if (entity.HasInstantiation)
{
var genericParams = new List <GenericParameter>(entity.Instantiation.Length);
foreach (var p in entity.Instantiation)
{
genericParams.Add(HandleGenericParameter((Cts.GenericParameterDesc)p));
}
record.GenericParameters = genericParams;
}
if (entity.Signature.Length > 0)
{
List <Parameter> parameters = new List <Parameter>(entity.Signature.Length);
for (ushort i = 0; i < entity.Signature.Length; i++)
{
parameters.Add(new Parameter
{
Sequence = i
});
}
var ecmaEntity = entity as Cts.Ecma.EcmaMethod;
if (ecmaEntity != null)
{
Ecma.MetadataReader reader = ecmaEntity.MetadataReader;
Ecma.MethodDefinition methodDef = reader.GetMethodDefinition(ecmaEntity.Handle);
Ecma.ParameterHandleCollection paramHandles = methodDef.GetParameters();
Debug.Assert(paramHandles.Count == entity.Signature.Length);
int i = 0;
foreach (var paramHandle in paramHandles)
{
Ecma.Parameter param = reader.GetParameter(paramHandle);
parameters[i].Flags = param.Attributes;
parameters[i].Name = HandleString(reader.GetString(param.Name));
// TODO: CustomAttributes
// TODO: DefaultValue
i++;
}
}
record.Parameters = parameters;
}
record.Flags = GetMethodAttributes(entity);
record.ImplFlags = GetMethodImplAttributes(entity);
//TODO: MethodImpls
//TODO: RVA
//TODO: CustomAttributes
}
private MethodImplAttributes GetMethodImplAttributes(Cts.MethodDesc method)
{
var ecmaMethod = method as Cts.Ecma.EcmaMethod;
if (ecmaMethod != null)
{
Ecma.MetadataReader reader = ecmaMethod.MetadataReader;
Ecma.MethodDefinition methodDef = reader.GetMethodDefinition(ecmaMethod.Handle);
return methodDef.ImplAttributes;
}
else
throw new NotImplementedException();
}
// cf. MetadataDecoder<>.GetSignatureForMethod.
internal ImmutableArray<ParameterSignature> DecodeParameters(MethodDefinition methodDef)
{
var signatureReader = _reader.GetBlobReader(methodDef.Signature);
var signatureHeader = signatureReader.ReadSignatureHeader();
var typeParameterCount = signatureHeader.IsGeneric ? signatureReader.ReadCompressedInteger() : 0;
var parameterCount = signatureReader.ReadCompressedInteger();
var builder = ImmutableArray.CreateBuilder<ParameterSignature>(parameterCount);
var returnType = DecodeParameter(ref signatureReader);
for (int i = 0; i < parameterCount; i++)
{
builder.Add(DecodeParameter(ref signatureReader));
}
return builder.ToImmutable();
}
private void InitializeMethodDefinition(Cts.MethodDesc entity, Method record)
{
record.Name = HandleString(entity.Name);
record.Signature = HandleMethodSignature(entity.Signature);
if (entity.HasInstantiation)
{
record.GenericParameters.Capacity = entity.Instantiation.Length;
foreach (var p in entity.Instantiation)
{
record.GenericParameters.Add(HandleGenericParameter((Cts.GenericParameterDesc)p));
}
}
var ecmaEntity = entity as Cts.Ecma.EcmaMethod;
if (ecmaEntity != null)
{
Ecma.MetadataReader reader = ecmaEntity.MetadataReader;
Ecma.MethodDefinition methodDef = reader.GetMethodDefinition(ecmaEntity.Handle);
Ecma.ParameterHandleCollection paramHandles = methodDef.GetParameters();
record.Parameters.Capacity = paramHandles.Count;
foreach (var paramHandle in paramHandles)
{
Ecma.Parameter param = reader.GetParameter(paramHandle);
Parameter paramRecord = new Parameter
{
Flags = param.Attributes,
Name = HandleString(reader.GetString(param.Name)),
Sequence = checked ((ushort)param.SequenceNumber)
};
Ecma.ConstantHandle defaultValue = param.GetDefaultValue();
if (!defaultValue.IsNil)
{
paramRecord.DefaultValue = HandleConstant(ecmaEntity.Module, defaultValue);
}
Ecma.CustomAttributeHandleCollection paramAttributes = param.GetCustomAttributes();
if (paramAttributes.Count > 0)
{
paramRecord.CustomAttributes = HandleCustomAttributes(ecmaEntity.Module, paramAttributes);
}
record.Parameters.Add(paramRecord);
}
Ecma.CustomAttributeHandleCollection attributes = methodDef.GetCustomAttributes();
if (attributes.Count > 0)
{
record.CustomAttributes = HandleCustomAttributes(ecmaEntity.Module, attributes);
}
}
else
{
throw new NotImplementedException();
}
record.Flags = GetMethodAttributes(entity);
record.ImplFlags = GetMethodImplAttributes(entity);
//TODO: RVA
}
public ParseTarget CreateParseTarget(MethodDefinition methodDef)
{
var ret = CreateParseTarget(methodDef.GetDeclaringType());
ret.MethodName = Reader.GetString(methodDef.Name);
ret.MethodSignature = ILReader.ParseMethodSignature(this, Reader.GetBlobBytes(methodDef.Signature));
return ret;
}
internal ImportedMethod(ImportedModule module, MethodDefinition methodDef, ImportedType declaringType)
: base(module, methodDef.Name, declaringType)
{
_methodDef = methodDef;
_signature = SignatureDecoder.DecodeMethodSignature(_methodDef.Signature, Module.IrisTypeProvider);
}
public static MethodSignature GetSignature(this MetadataReader metadataReader, MethodDefinition methodDefinition)
{
return new MethodSignature(metadataReader.GetBlobReader(methodDefinition.Signature));
}
private bool IsPubliclyVisible(MetadataReader referenceMetadata, MethodDefinition methodDefinition, bool checkDeclaringType = false)
{
switch (methodDefinition.Attributes & MethodAttributes.MemberAccessMask)
{
case MethodAttributes.Public:
case MethodAttributes.Family:
case MethodAttributes.FamORAssem:
break;
case MethodAttributes.FamANDAssem:
case MethodAttributes.Assembly:
case MethodAttributes.Private:
case MethodAttributes.PrivateScope:
default:
return false;
}
if (checkDeclaringType)
{
TypeDefinition declaringTypeDefinition = referenceMetadata.GetTypeDefinition(methodDefinition.GetDeclaringType());
if (!IsPubliclyVisible(referenceMetadata, declaringTypeDefinition))
return false;
}
return true;
}
private string GetMetadataName(MetadataReader metadataReader, MethodDefinition methodDefinition)
{
TypeDefinition declaringTypeDefinition = metadataReader.GetTypeDefinition(methodDefinition.GetDeclaringType());
string typeName = GetMetadataName(metadataReader, declaringTypeDefinition);
string methodName = metadataReader.GetString(methodDefinition.Name);
return string.Format("{0}.{1}", typeName, methodName);
}
