public CommonType GetCommonType(IMetadataType type)
{
if (type is IMetadataArrayType)
return GetCommonType(((IMetadataArrayType) type).TypeInfo);
if (type is IMetadataClassType)
return GetCommonType(((IMetadataClassType) type).Type);
Trace.Fail(string.Format("Instance of type {0} cannot be converted to CommonType", type));
throw new Exception();
}
public static Metadata Get(IMetadataType type, string description)
{
if (!Metadatas.ContainsKey(type))
{
Metadatas[type] = new Dictionary <string, Metadata>(100);
}
if (!Metadatas[type].ContainsKey(description))
{
Metadatas[type][description] = new Metadata(type, description);
}
return(Metadatas[type][description]);
}
public static ITypeInfo GetType(IMetadataType type, MetadataTypeInfoAdapter2 typeInfo,
MetadataMethodInfoAdapter2 methodInfo)
{
var classType = type as IMetadataClassType;
if (classType != null)
return new MetadataTypeInfoAdapter2(classType);
var argumentReferenceType = type as IMetadataGenericArgumentReferenceType;
if (argumentReferenceType != null)
return GetTypeFromGenericArgumentReferenceType(argumentReferenceType, typeInfo, methodInfo);
return null;
}
public CommonType GetCommonType(IMetadataType type)
{
if (type is IMetadataArrayType)
{
return(GetCommonType(((IMetadataArrayType)type).TypeInfo));
}
if (type is IMetadataClassType)
{
return(GetCommonType(((IMetadataClassType)type).Type));
}
Trace.Fail($"Instance of type {type} cannot be converted to CommonType");
throw new Exception();
}
public static ITypeInfo GetType(IMetadataType type, MetadataTypeInfoAdapter2 typeInfo,
MetadataMethodInfoAdapter2 methodInfo)
{
var classType = type as IMetadataClassType;
if (classType != null)
{
return(new MetadataTypeInfoAdapter2(classType));
}
var argumentReferenceType = type as IMetadataGenericArgumentReferenceType;
if (argumentReferenceType != null)
{
return(GetTypeFromGenericArgumentReferenceType(argumentReferenceType, typeInfo, methodInfo));
}
return(null);
}
public static PartiallyIgnoredTypeBuilder Create(IMetadataType original)
{
switch (original)
{
case IMetadataClass @class:
return(new PartiallyIgnoredClassBuilder(@class));
case IMetadataStruct @struct:
return(new PartiallyIgnoredStructBuilder(@struct));
case IMetadataInterface @interface:
return(new PartiallyIgnoredInterfaceBuilder(@interface));
case IMetadataEnum @enum:
return(new PartiallyIgnoredEnumBuilder(@enum));
case IMetadataDelegate @delegate:
return(new PartiallyIgnoredDelegateBuilder(@delegate));
default:
throw new NotImplementedException();
}
}
public bool TryUnignoreNested(TextNode referencePath, IReadOnlyList <IMetadataType> parentTypes, int parentIndex, IMetadataType typeToUnignore)
{
var nextParentIndex = parentIndex + 1;
if (nextParentIndex != parentTypes.Count)
{
var nextParent = parentTypes[nextParentIndex];
var builder = nestedTypeBuilders.FirstOrDefault(_ => _.Name == nextParent.Name);
if (builder == null)
{
nestedTypeBuilders.Add(builder = Create(nextParent));
}
return(builder.TryUnignoreNested(referencePath, parentTypes, nextParentIndex, typeToUnignore));
}
else
{
var builder = nestedTypeBuilders.FirstOrDefault(_ => _.Name == typeToUnignore.Name);
if (builder == null)
{
nestedTypeBuilders.Add(builder = Create(typeToUnignore));
}
return(builder.TryUnignore(referencePath));
}
}
private PartiallyIgnoredTypeBuilder(IMetadataType original)
{
this.original = original;
}
/// <summary>
/// Returns <see langword="false"/> if the type is not found or if it has already been unignored.
/// </summary>
public bool TryUnignore(TextNode referencePath, string topLevelName, IReadOnlyList <string> nestedNames, out IMetadataType unignoredType)
{
var current = originalNamespace.Types.FirstOrDefault(_ => _.Name == topLevelName);
if (current != null)
{
if (nestedNames.Count == 0)
{
var builder = typeBuilders.FirstOrDefault(_ => _.Name == topLevelName);
if (builder == null)
{
typeBuilders.Add(builder = PartiallyIgnoredTypeBuilder.Create(current));
}
if (!builder.TryUnignore(referencePath))
{
unignoredType = null;
return(false);
}
unignoredType = current;
return(true);
}
else
{
var parentTypes = new List <IMetadataType>(nestedNames.Count);
foreach (var name in nestedNames)
{
parentTypes.Add(current);
current = current.NestedTypes.FirstOrDefault(_ => _.Name == name);
if (current == null)
{
unignoredType = null;
return(false);
}
}
var builder = typeBuilders.FirstOrDefault(_ => _.Name == topLevelName);
if (builder == null)
{
typeBuilders.Add(builder = PartiallyIgnoredTypeBuilder.Create(parentTypes[0]));
}
if (builder.TryUnignoreNested(referencePath, parentTypes, 0, current))
{
unignoredType = current;
return(true);
}
}
}
unignoredType = null;
return(false);
}
private void VisitNonignoredType(TextNode typeName, IMetadataType type)
{
// Types should not be brought in via interface implementations;
// if interface implementations are the only thing bringing it in, that requires naming the ignored type.
// Generic type and method constraints don't need to be considered;
// they'll be picked up in an output position already by VisitTypeReference.
foreach (var field in type.Fields)
{
VisitTypeReference((typeName + ".") + field.Name, field.FieldType);
}
var @delegate = type as IMetadataDelegate;
if (@delegate != null)
{
// Delegate parameters don't require naming the ignored type in order to receive values from them.
// when passing the delegate as a parameter.
foreach (var parameter in @delegate.Parameters)
{
VisitTypeReference((typeName + " parameter ") + parameter.Name, parameter.ParameterType);
}
// Delegate returns don't require naming the ignored type in order to receive values from them
// when invoking them.
VisitTypeReference(typeName + " return type", @delegate.ReturnType);
}
foreach (var method in type.Methods) // Covers constructors, operators, properties and events
{
if (@delegate != null && (
method.Name == "Invoke" ||
method.Name == "BeginInvoke" ||
method.Name == "EndInvoke"))
{
continue;
}
var methodName = (typeName + ".") + method.Name;
foreach (var parameter in method.Parameters)
{
if (parameter.IsOut || // Out var
(ParameterIsNamedType(parameter.ParameterType) &&
(!metadataReferenceResolver.TryGetIsDelegateType(parameter.ParameterType, out var isDelegate) || // Better safe than sorry
isDelegate))) // Delegate parameter types can be syntactically inferred, so ignored types could be used without naming them
{
// For delegates we could be even smarter and skip if it has no byval parameters. Future enhancement.
VisitTypeReference((methodName + " parameter ") + parameter.Name, parameter.ParameterType);
}
// Otherwise, types should not be brought in via method parameters;
// if method parameters are the only thing bringing it in, that requires naming the ignored type.
}
VisitTypeReference(methodName + " return type", method.ReturnType);
}
if (type.BaseType != null)
{
VisitTypeReference(typeName + " base type", type.BaseType);
}
foreach (var nestedType in type.NestedTypes)
{
VisitNonignoredType((typeName + ".") + nestedType.Name, nestedType);
}
}
public MetadataMock(IMetadataType type, string description)
{
Type = type;
Description = description;
}
public static CommonType ToCommon(this IMetadataType type)
{
return(IntrospectionUtility.Instance.GetCommonType(type));
}
/// <summary>
/// Initializes a new instance of the <see cref="Metadata"/> class.
/// </summary>
private Metadata(IMetadataType type, string description)
{
Type = type;
Description = description;
}
private CommonMember GetCommonMember(IMetadataTypeMember member, IMetadataType type)
{
return(new CommonMember(member.Name, type.ToCommon()));
}
