void AddType(TypeDefinition type, Action<ModelType, string> add)
{
MetadataReader reader = _reader.Value.Reader;
ModelType modelType = new ModelType { Name = reader.GetString(type.Name) };
add(modelType, reader.GetString(type.Namespace));
foreach (var hmember in type.GetFields())
{
FieldDefinition member = reader.GetFieldDefinition(hmember);
modelType.Members.Add(new ModelTypeMember
{
Name = "[f] " + reader.GetString(member.Name)
});
}
foreach (var hmember in type.GetMethods())
{
MethodDefinition member = reader.GetMethodDefinition(hmember);
modelType.Members.Add(new ModelMethod
{
Name = reader.GetString(member.Name) + "()",
Handle = hmember,
Type = type,
});
}
foreach (var hchild in type.GetNestedTypes())
{
TypeDefinition child = reader.GetTypeDefinition(hchild);
AddType(child, (m, typeNs) => modelType.Members.Add(m));
}
}
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();
}
}
}
}
}
public static string GetFullTypeName(this MetadataReader metadataReader, TypeDefinition typeDefinition)
{
var name = metadataReader.GetString(typeDefinition.Namespace) ?? "";
if (name != "")
{
name = name + ".";
}
name = name + metadataReader.GetString(typeDefinition.Name);
return name;
}
internal EcmaType(EcmaModule module, TypeDefinitionHandle handle)
{
_module = module;
_handle = handle;
_typeDefinition = module.MetadataReader.GetTypeDefinition(handle);
_baseType = this; // Not yet initialized flag
#if DEBUG
// Initialize name eagerly in debug builds for convenience
this.ToString();
#endif
}
private TypeAttributes GetTypeAttributes(Cts.MetadataType type)
{
TypeAttributes result;
var ecmaType = type as Cts.Ecma.EcmaType;
if (ecmaType != null)
{
Ecma.TypeDefinition ecmaRecord = ecmaType.MetadataReader.GetTypeDefinition(ecmaType.Handle);
result = ecmaRecord.Attributes;
}
else
{
result = 0;
if (type.IsExplicitLayout)
{
result |= TypeAttributes.ExplicitLayout;
}
if (type.IsSequentialLayout)
{
result |= TypeAttributes.SequentialLayout;
}
if (type.IsInterface)
{
result |= TypeAttributes.Interface;
}
if (type.IsSealed)
{
result |= TypeAttributes.Sealed;
}
if (type.IsBeforeFieldInit)
{
result |= TypeAttributes.BeforeFieldInit;
}
// Not set: Abstract, Ansi/Unicode/Auto, HasSecurity, Import, visibility, Serializable,
// WindowsRuntime, HasSecurity, SpecialName, RTSpecialName
}
return(result);
}
private void InitializeTypeDef(Cts.MetadataType entity, TypeDefinition record)
{
Debug.Assert(entity.IsTypeDefinition);
Cts.MetadataType containingType = (Cts.MetadataType)entity.ContainingType;
if (containingType != null)
{
var enclosingType = (TypeDefinition)HandleType(containingType);
record.EnclosingType = enclosingType;
enclosingType.NestedTypes.Add(record);
var namespaceDefinition =
HandleNamespaceDefinition(containingType.Module, entity.ContainingType.Namespace);
record.NamespaceDefinition = namespaceDefinition;
}
else
{
var namespaceDefinition = HandleNamespaceDefinition(entity.Module, entity.Namespace);
record.NamespaceDefinition = namespaceDefinition;
if (entity.IsModuleType)
{
// These don't get added to the global namespace.
// Instead, they have a dedicated field on the scope record.
}
else
{
namespaceDefinition.TypeDefinitions.Add(record);
}
}
record.Name = HandleString(entity.Name);
Cts.ClassLayoutMetadata layoutMetadata = entity.GetClassLayout();
record.Size = checked ((uint)layoutMetadata.Size);
record.PackingSize = checked ((ushort)layoutMetadata.PackingSize);
record.Flags = GetTypeAttributes(entity);
try
{
if (entity.HasBaseType)
{
record.BaseType = HandleType(entity.BaseType);
}
}
catch (Cts.TypeSystemException) when(HasNestedTypes(entity))
{
// We might have been forced to generate metadata for a type
// that wasn't looked at during code generation because it's an owning
// type of a type we did look at. Allow those to generate incomplete
// metadata. The ultimate fix is to rewrite metadata generation to be
// System.Reflection.Metadata-based as opposed to type system based.
// If there's no nested types, this is a bug and should tear down
// the compiler at this point.
}
try
{
record.Interfaces.Capacity = entity.ExplicitlyImplementedInterfaces.Length;
foreach (var interfaceType in entity.ExplicitlyImplementedInterfaces)
{
if (IsBlocked(interfaceType))
{
continue;
}
record.Interfaces.Add(HandleType(interfaceType));
}
}
catch (Cts.TypeSystemException) when(HasNestedTypes(entity))
{
// We might have been forced to generate metadata for a type
// that wasn't looked at during code generation because it's an owning
// type of a type we did look at. Allow those to generate incomplete
// metadata. The ultimate fix is to rewrite metadata generation to be
// System.Reflection.Metadata-based as opposed to type system based.
// If there's no nested types, this is a bug and should tear down
// the compiler at this point.
}
if (entity.HasInstantiation)
{
record.GenericParameters.Capacity = entity.Instantiation.Length;
foreach (var p in entity.Instantiation)
{
record.GenericParameters.Add(HandleGenericParameter((Cts.GenericParameterDesc)p));
}
}
foreach (var field in entity.GetFields())
{
if (_policy.GeneratesMetadata(field))
{
record.Fields.Add(HandleFieldDefinition(field));
}
}
foreach (var method in entity.GetMethods())
{
if (_policy.GeneratesMetadata(method))
{
record.Methods.Add(HandleMethodDefinition(method));
}
}
var ecmaEntity = entity as Cts.Ecma.EcmaType;
if (ecmaEntity != null)
{
Ecma.TypeDefinition ecmaRecord = ecmaEntity.MetadataReader.GetTypeDefinition(ecmaEntity.Handle);
foreach (var e in ecmaRecord.GetEvents())
{
Event evt = HandleEvent(ecmaEntity.EcmaModule, e);
if (evt != null)
{
record.Events.Add(evt);
}
}
foreach (var property in ecmaRecord.GetProperties())
{
Property prop = HandleProperty(ecmaEntity.EcmaModule, property);
if (prop != null)
{
record.Properties.Add(prop);
}
}
Ecma.CustomAttributeHandleCollection customAttributes = ecmaRecord.GetCustomAttributes();
if (customAttributes.Count > 0)
{
record.CustomAttributes = HandleCustomAttributes(ecmaEntity.EcmaModule, customAttributes);
}
/* COMPLETENESS
* foreach (var miHandle in ecmaRecord.GetMethodImplementations())
* {
* Ecma.MetadataReader reader = ecmaEntity.EcmaModule.MetadataReader;
*
* Ecma.MethodImplementation miDef = reader.GetMethodImplementation(miHandle);
*
* Cts.MethodDesc methodBody = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodBody);
* if (_policy.IsBlocked(methodBody))
* continue;
*
* Cts.MethodDesc methodDecl = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodDeclaration);
* if (_policy.IsBlocked(methodDecl.GetTypicalMethodDefinition()))
* continue;
*
* MethodImpl methodImplRecord = new MethodImpl
* {
* MethodBody = HandleQualifiedMethod(methodBody),
* MethodDeclaration = HandleQualifiedMethod(methodDecl)
* };
*
* record.MethodImpls.Add(methodImplRecord);
* }*/
}
public static MetadataDefinition Create(
MetadataReader reader, TypeDefinition definition)
{
var typeName = reader.GetString(definition.Name);
var index = typeName.IndexOf('`');
typeName = index > 0 ? typeName.Substring(0, index) : typeName;
return new MetadataDefinition(
MetadataDefinitionKind.Type,
typeName)
{
Type = definition
};
}
public string GetFullyQualifiedName(TypeDefinition type)
{
return GetFullyQualifiedNameCore(type.Namespace, type.Name);
}
private bool HasVisibleConstructors(MetadataReader metadataReader, TypeDefinition typeDefinition)
{
// for now, assume that the type has publicly-visible constructors.
return true;
}
private static void LookupMetadataDefinitions(
MetadataReader reader, TypeDefinition typeDefinition,
OrderPreservingMultiDictionary<string, MetadataDefinition> definitionMap)
{
// Only bother looking for extension methods in static types.
if ((typeDefinition.Attributes & TypeAttributes.Abstract) != 0 &&
(typeDefinition.Attributes & TypeAttributes.Sealed) != 0)
{
foreach (var child in typeDefinition.GetMethods())
{
var method = reader.GetMethodDefinition(child);
if ((method.Attributes & MethodAttributes.SpecialName) != 0 ||
(method.Attributes & MethodAttributes.RTSpecialName) != 0)
{
continue;
}
// SymbolTreeInfo is only searched for types and extension methods.
// So we don't want to pull in all methods here. As a simple approximation
// we just pull in methods that have attributes on them.
if ((method.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public &&
(method.Attributes & MethodAttributes.Static) != 0 &&
method.GetCustomAttributes().Count > 0)
{
var definition = new MetadataDefinition(
MetadataDefinitionKind.Member, reader.GetString(method.Name));
definitionMap.Add(definition.Name, definition);
}
}
}
foreach (var child in typeDefinition.GetNestedTypes())
{
var type = reader.GetTypeDefinition(child);
// We don't include internals from metadata assemblies. It's less likely that
// a project would have IVT to it and so it helps us save on memory. It also
// means we can avoid loading lots and lots of obfuscated code in the case the
// dll was obfuscated.
if (IsPublic(type.Attributes))
{
var definition = MetadataDefinition.Create(reader, type);
definitionMap.Add(definition.Name, definition);
}
}
}
private static bool TryGetAnonymousTypeKey(
MetadataReader reader,
TypeDefinition def,
ArrayBuilder<string> builder)
{
foreach (var typeParameterHandle in def.GetGenericParameters())
{
var typeParameter = reader.GetGenericParameter(typeParameterHandle);
string fieldName;
if (!GeneratedNames.TryParseAnonymousTypeParameterName(reader.GetString(typeParameter.Name), out fieldName))
{
return false;
}
builder.Add(fieldName);
}
return true;
}
private void InitializeTypeDef(Cts.MetadataType entity, TypeDefinition record)
{
if (entity.ContainingType != null)
{
var enclosingType = (TypeDefinition)HandleType(entity.ContainingType);
record.EnclosingType = enclosingType;
enclosingType.NestedTypes.Add(record);
var namespaceDefinition =
HandleNamespaceDefinition(entity.ContainingType.Module, entity.ContainingType.Namespace);
record.NamespaceDefinition = namespaceDefinition;
}
else
{
var namespaceDefinition = HandleNamespaceDefinition(entity.Module, entity.Namespace);
record.NamespaceDefinition = namespaceDefinition;
namespaceDefinition.TypeDefinitions.Add(record);
}
record.Name = HandleString(entity.Name);
Cts.ClassLayoutMetadata layoutMetadata = entity.GetClassLayout();
record.Size = checked ((uint)layoutMetadata.Size);
record.PackingSize = checked ((uint)layoutMetadata.PackingSize);
record.Flags = GetTypeAttributes(entity);
if (entity.HasBaseType)
{
record.BaseType = HandleType(entity.BaseType);
}
if (entity.ExplicitlyImplementedInterfaces.Length > 0)
{
record.Interfaces = entity.ExplicitlyImplementedInterfaces
.Where(i => !IsBlocked(i))
.Select(i => HandleType(i)).ToList();
}
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;
}
var fields = new List <Field>();
foreach (var field in entity.GetFields())
{
if (_policy.GeneratesMetadata(field))
{
fields.Add(HandleFieldDefinition(field));
}
}
record.Fields = fields;
var methods = new List <Method>();
foreach (var method in entity.GetMethods())
{
if (_policy.GeneratesMetadata(method))
{
methods.Add(HandleMethodDefinition(method));
}
}
record.Methods = methods;
var ecmaEntity = entity as Cts.Ecma.EcmaType;
if (ecmaEntity != null)
{
Ecma.TypeDefinition ecmaRecord = ecmaEntity.MetadataReader.GetTypeDefinition(ecmaEntity.Handle);
foreach (var property in ecmaRecord.GetProperties())
{
Property prop = HandleProperty(ecmaEntity.EcmaModule, property);
if (prop != null)
{
record.Properties.Add(prop);
}
}
// TODO: Events
// TODO: CustomAttributes
}
}
public static MetadataDefinition Create(
MetadataReader reader, TypeDefinition definition)
{
var typeName = GetMetadataNameWithoutBackticks(reader, definition.Name);
return new MetadataDefinition(MetadataDefinitionKind.Type,typeName)
{
Type = definition
};
}
/// <summary>
/// Determine if this type should be one of the `class` values passed to xunit. This
/// code doesn't actually resolve base types or trace through inherrited Fact attributes
/// hence we have to error on the side of including types with no tests vs. excluding them.
/// </summary>
private static bool ShouldIncludeType(MetadataReader reader, TypeDefinition type, int testMethodCount)
{
// xunit only handles public, non-abstract classes
var isPublic =
TypeAttributes.Public == (type.Attributes & TypeAttributes.Public) ||
TypeAttributes.NestedPublic == (type.Attributes & TypeAttributes.NestedPublic);
if (!isPublic ||
TypeAttributes.Abstract == (type.Attributes & TypeAttributes.Abstract) ||
TypeAttributes.Class != (type.Attributes & TypeAttributes.Class))
{
return false;
}
// Compiler generated types / methods have the shape of the heuristic that we are looking
// at here. Filter them out as well.
if (!IsValidIdentifier(reader, type.Name))
{
return false;
}
if (testMethodCount > 0)
{
return true;
}
// The case we still have to consider at this point is a class with 0 defined methods,
// inheritting from a class with > 0 defined test methods. That is a completely valid
// xunit scenario. For now we're just going to exclude types that inherit from object
// because they clearly don't fit that category.
return !(InheritsFromObject(reader, type) ?? false);
}
/// <summary>
/// Get the full name of a Type.
/// </summary>
private static string GetTypeFullName(MetadataReader metadataReader, TypeDefinition typeDefinition)
{
string fullName;
string typeName = metadataReader.GetString(typeDefinition.Name);
string nsName = metadataReader.GetString(typeDefinition.Namespace);
// Get the enclosing type if the type is nested
TypeDefinitionHandle declaringTypeHandle = typeDefinition.GetDeclaringType();
if (declaringTypeHandle.IsNil)
{
fullName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", nsName, typeName);
}
else
{
fullName = typeName;
while (!declaringTypeHandle.IsNil)
{
TypeDefinition declaringTypeDef = metadataReader.GetTypeDefinition(declaringTypeHandle);
declaringTypeHandle = declaringTypeDef.GetDeclaringType();
if (declaringTypeHandle.IsNil)
{
fullName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}+{2}",
metadataReader.GetString(declaringTypeDef.Namespace),
metadataReader.GetString(declaringTypeDef.Name),
fullName);
}
else
{
fullName = string.Format(CultureInfo.InvariantCulture, "{0}+{1}",
metadataReader.GetString(declaringTypeDef.Name),
fullName);
}
}
}
return fullName;
}
private static bool HasAttributes(System.Reflection.Metadata.TypeDefinition type, TypeAttributes attributes)
{
return((type.Attributes & attributes) == attributes);
}
private string GetMetadataName(MetadataReader metadataReader, EventDefinition eventDefinition, TypeDefinition declaringTypeDefinition)
{
string typeName = GetMetadataName(metadataReader, declaringTypeDefinition);
string eventName = metadataReader.GetString(eventDefinition.Name);
return string.Format("{0}.{1}", typeName, eventName);
}
private bool IsPubliclyVisible(MetadataReader metadataReader, TypeDefinition typeDefinition)
{
switch (typeDefinition.Attributes & TypeAttributes.VisibilityMask)
{
case TypeAttributes.Public:
return true;
case TypeAttributes.NestedPublic:
case TypeAttributes.NestedFamORAssem:
case TypeAttributes.NestedFamily:
TypeDefinition declaringType = metadataReader.GetTypeDefinition(typeDefinition.GetDeclaringType());
return IsPubliclyVisible(metadataReader, declaringType);
case TypeAttributes.NestedFamANDAssem:
case TypeAttributes.NestedPrivate:
case TypeAttributes.NotPublic:
default:
return false;
}
}
private bool IsMarkedPreliminary(MetadataReader metadataReader, TypeDefinition typeDefinition)
{
return false;
}
private string GetMetadataName(MetadataReader metadataReader, TypeDefinition typeDefinition)
{
if (typeDefinition.GetDeclaringType().IsNil)
{
string namespaceName = metadataReader.GetString(typeDefinition.Namespace);
string typeName = metadataReader.GetString(typeDefinition.Name);
return string.Format("{0}.{1}", namespaceName, typeName);
}
else
{
TypeDefinition declaringTypeDefinition = metadataReader.GetTypeDefinition(typeDefinition.GetDeclaringType());
string declaringTypeName = GetMetadataName(metadataReader, declaringTypeDefinition);
string name = metadataReader.GetString(typeDefinition.Name);
return string.Format("{0}+{1}", declaringTypeName, name);
}
}
private static bool? InheritsFromObject(MetadataReader reader, TypeDefinition type)
{
if (type.BaseType.Kind != HandleKind.TypeReference)
{
return null;
}
var typeRef = reader.GetTypeReference((TypeReferenceHandle)type.BaseType);
return
reader.GetString(typeRef.Namespace) == "System" &&
reader.GetString(typeRef.Name) == "Object";
}
void ParseEnum(TypeDefinition enumTypeDef)
{
// TODO: verify that int32 is the enums storage type for constant read below
InspectorEnum ienum = new InspectorEnum ();
ienum.Name = metaReader.GetString (enumTypeDef.Name);
InspectorEnums [ienum.Name] = ienum;
var fields = enumTypeDef.GetFields ();
foreach (var fieldHandle in fields) {
var inspectorField = new InspectorField ();
var fieldDef = metaReader.GetFieldDefinition (fieldHandle);
if ((fieldDef.Attributes & FieldAttributes.HasDefault) != 0) {
var constantHandle = fieldDef.GetDefaultValue ();
var constant = metaReader.GetConstant (constantHandle);
BlobReader constantReader = metaReader.GetBlobReader (constant.Value);
ienum.Values [metaReader.GetString (fieldDef.Name)] = constantReader.ReadInt32 ();
}
}
return;
}
/// <exception cref="BadImageFormatException">An exception from metadata reader.</exception>
internal static bool IsPublicNonInterfaceType(this MetadataReader reader, TypeDefinition typeDef, string namespaceName, string typeName)
{
return (typeDef.Attributes & (TypeAttributes.Public | TypeAttributes.Interface)) == TypeAttributes.Public &&
reader.StringComparer.Equals(typeDef.Name, typeName) &&
reader.StringComparer.Equals(typeDef.Namespace, namespaceName);
}
/// <exception cref="BadImageFormatException">An exception from metadata reader.</exception>
private static bool IsSystemObjectOrThrow(this MetadataReader reader, TypeDefinition typeDef)
{
return reader.StringComparer.Equals(typeDef.Name, "Object") &&
reader.StringComparer.Equals(typeDef.Namespace, "System");
}
private void InitializeTypeDef(Cts.MetadataType entity, TypeDefinition record)
{
Debug.Assert(entity.IsTypeDefinition);
Cts.MetadataType containingType = (Cts.MetadataType)entity.ContainingType;
if (containingType != null)
{
var enclosingType = (TypeDefinition)HandleType(containingType);
record.EnclosingType = enclosingType;
enclosingType.NestedTypes.Add(record);
var namespaceDefinition =
HandleNamespaceDefinition(containingType.Module, entity.ContainingType.Namespace);
record.NamespaceDefinition = namespaceDefinition;
}
else
{
var namespaceDefinition = HandleNamespaceDefinition(entity.Module, entity.Namespace);
record.NamespaceDefinition = namespaceDefinition;
namespaceDefinition.TypeDefinitions.Add(record);
}
record.Name = HandleString(entity.Name);
Cts.ClassLayoutMetadata layoutMetadata = entity.GetClassLayout();
record.Size = checked ((uint)layoutMetadata.Size);
record.PackingSize = checked ((ushort)layoutMetadata.PackingSize);
record.Flags = GetTypeAttributes(entity);
if (entity.HasBaseType)
{
record.BaseType = HandleType(entity.BaseType);
}
record.Interfaces.Capacity = entity.ExplicitlyImplementedInterfaces.Length;
foreach (var interfaceType in entity.ExplicitlyImplementedInterfaces)
{
if (IsBlocked(interfaceType))
{
continue;
}
record.Interfaces.Add(HandleType(interfaceType));
}
if (entity.HasInstantiation)
{
record.GenericParameters.Capacity = entity.Instantiation.Length;
foreach (var p in entity.Instantiation)
{
record.GenericParameters.Add(HandleGenericParameter((Cts.GenericParameterDesc)p));
}
}
foreach (var field in entity.GetFields())
{
if (_policy.GeneratesMetadata(field))
{
record.Fields.Add(HandleFieldDefinition(field));
}
}
foreach (var method in entity.GetMethods())
{
if (_policy.GeneratesMetadata(method))
{
record.Methods.Add(HandleMethodDefinition(method));
}
}
var ecmaEntity = entity as Cts.Ecma.EcmaType;
if (ecmaEntity != null)
{
Ecma.TypeDefinition ecmaRecord = ecmaEntity.MetadataReader.GetTypeDefinition(ecmaEntity.Handle);
foreach (var e in ecmaRecord.GetEvents())
{
Event evt = HandleEvent(ecmaEntity.EcmaModule, e);
if (evt != null)
{
record.Events.Add(evt);
}
}
foreach (var property in ecmaRecord.GetProperties())
{
Property prop = HandleProperty(ecmaEntity.EcmaModule, property);
if (prop != null)
{
record.Properties.Add(prop);
}
}
Ecma.CustomAttributeHandleCollection customAttributes = ecmaRecord.GetCustomAttributes();
if (customAttributes.Count > 0)
{
record.CustomAttributes = HandleCustomAttributes(ecmaEntity.EcmaModule, customAttributes);
}
foreach (var miHandle in ecmaRecord.GetMethodImplementations())
{
Ecma.MetadataReader reader = ecmaEntity.EcmaModule.MetadataReader;
Ecma.MethodImplementation miDef = reader.GetMethodImplementation(miHandle);
Cts.MethodDesc methodBody = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodBody);
if (_policy.IsBlocked(methodBody))
{
continue;
}
Cts.MethodDesc methodDecl = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodDeclaration);
if (_policy.IsBlocked(methodDecl.GetTypicalMethodDefinition()))
{
continue;
}
MethodImpl methodImplRecord = new MethodImpl
{
MethodBody = HandleQualifiedMethod(methodBody),
MethodDeclaration = HandleQualifiedMethod(methodDecl)
};
record.MethodImpls.Add(methodImplRecord);
}
}
}
private void Walk(TypeDefinition typeDefinition)
{
var baseTypeDefinitionHandle = typeDefinition.BaseType;
if (baseTypeDefinitionHandle.IsNil)
{
return;
}
var Kind = baseTypeDefinitionHandle.Kind;
if (Kind == HandleKind.TypeDefinition)
{
typeDefinition = metadataReader.GetTypeDefinition((TypeDefinitionHandle)baseTypeDefinitionHandle);
var typeFullName = metadataReader.GetFullTypeName(typeDefinition);
if (knownExportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownExportAttributeOrDerivedType.Add(typeFullName);
//isExportAttributeCache[baseTypeDefinitionHandle] = ExportOrInheritedExport.Export;
return;
}
else if (knownImportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownImportAttributeOrDerivedType.Add(typeFullName);
//isImportAttributeCache[baseTypeDefinitionHandle] = true;
return;
}
Walk(typeDefinition);
}
else if (Kind == HandleKind.TypeDefinition)
{
TypeReference typeReference = metadataReader.GetTypeReference((TypeReferenceHandle)baseTypeDefinitionHandle);
var typeFullName = metadataReader.GetFullTypeName(typeReference);
if (knownExportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownExportAttributeOrDerivedType.Add(typeFullName);
//isExportAttributeCache[baseTypeDefinitionHandle] = ExportOrInheritedExport.Export;
return;
}
else if (knownImportAttributeOrDerivedType.Contains(typeFullName))
{
typeFullName = metadataReader.GetFullTypeName(typeDefinition);
knownImportAttributeOrDerivedType.Add(typeFullName);
//isImportAttributeCache[baseTypeDefinitionHandle] = true;
return;
}
}
else if (Kind == HandleKind.TypeDefinition)
{
// TODO: not implemented
}
else
{
throw new NotImplementedException();
}
}
private string GetMetadataName(MetadataReader metadataReader, PropertyDefinition propertyDefinition, TypeDefinition declaringTypeDefinition)
{
string typeName = GetMetadataName(metadataReader, declaringTypeDefinition);
string propertyName = metadataReader.GetString(propertyDefinition.Name);
return string.Format("{0}.{1}", typeName, propertyName);
}
private static int GetMethodCount(MetadataReader reader, TypeDefinition type)
{
var count = 0;
foreach (var handle in type.GetMethods())
{
var methodDefinition = reader.GetMethodDefinition(handle);
if (methodDefinition.GetCustomAttributes().Count == 0 ||
!IsValidIdentifier(reader, methodDefinition.Name))
{
continue;
}
if (MethodAttributes.Public != (methodDefinition.Attributes & MethodAttributes.Public))
{
continue;
}
count++;
}
return count;
}
internal ImportedType(ImportedModule module, TypeDefinition typeDef)
: base(module, typeDef.Name, null)
{
_typeDef = typeDef;
}
private static string GetFullName(MetadataReader reader, TypeDefinition type)
{
var typeName = reader.GetString(type.Name);
if (TypeAttributes.NestedPublic == (type.Attributes & TypeAttributes.NestedPublic))
{
// Need to take into account the containing type.
var declaringType = reader.GetTypeDefinition(type.GetDeclaringType());
var declaringTypeFullName = GetFullName(reader, declaringType);
return $"{declaringTypeFullName}+{typeName}";
}
var namespaceName = reader.GetString(type.Namespace);
if (string.IsNullOrEmpty(namespaceName))
{
return typeName;
}
return $"{namespaceName}.{typeName}";
}
private static bool IsTheObjectClass(this MetadataReader reader, TypeDefinition typeDef)
{
return typeDef.BaseType.IsNil &&
reader.IsPublicNonInterfaceType(typeDef, "System", "Object");
}
