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