private bool WeHidThisType(INamedTypeDefinition type)
{
// walk up all the declaring types to see if we hid one of them
INamedTypeDefinition curType = type;
while (curType != null && curType != Dummy.Type)
{
if (ShouldHideType(curType))
{
return(true);
}
INestedTypeDefinition nestedType = curType as INestedTypeDefinition;
if (nestedType != null)
{
curType = Util.CanonicalizeType(nestedType.ContainingType);
}
else
{
curType = null;
}
}
return(false);
}
public override uint GetFieldOffset(object item)
{
FieldDeclaration field = item as FieldDeclaration;
INestedTypeDefinition nestedTypeDef = item as INestedTypeDefinition;
uint result = field != null?MemberHelper.ComputeFieldOffset(field.FieldDefinition, field.FieldDefinition.ContainingTypeDefinition) : MemberHelper.ComputeFieldOffset(nestedTypeDef, this.TypeDefinition);
// This distinguishes between anonymous nested types, where we need to walk upwards to the surrounding type,
// and nested types that have their own field name, where we must not do this
// the current AST representation requires such a complicated approach
bool nestedTypeHasFieldName = false;
ITypeDefinition containingDef = this.ContainingTypeDeclaration.TypeDefinition;
foreach (ITypeDefinitionMember member in containingDef.Members)
{
IFieldDefinition fieldMember = member as IFieldDefinition;
if (fieldMember != null && fieldMember.Type.ResolvedType == this.TypeDefinition && !String.IsNullOrEmpty(fieldMember.Name.Value))
{
nestedTypeHasFieldName = true;
break;
}
}
if (!nestedTypeHasFieldName)
{
result += this.ContainingTypeDeclaration.GetFieldOffset(this.TypeDefinition);
}
return(result);
}
public virtual void PrintTypeDefinitionName(ITypeDefinition typeDefinition)
{
INamespaceTypeDefinition namespaceTypeDefinition = typeDefinition as INamespaceTypeDefinition;
if (namespaceTypeDefinition != null)
{
PrintIdentifier(namespaceTypeDefinition.Name);
return;
}
INestedTypeDefinition nestedTypeDefinition = typeDefinition as INestedTypeDefinition;
if (nestedTypeDefinition != null)
{
PrintIdentifier(nestedTypeDefinition.Name);
return;
}
INamedEntity namedEntity = typeDefinition as INamedEntity;
if (namedEntity != null)
{
PrintIdentifier(namedEntity.Name);
}
else
{
sourceEmitterOutput.Write(typeDefinition.ToString());
}
}
public override INestedTypeDefinition Rewrite(INestedTypeDefinition nestedTypeDefinition)
{
var typeContract = contractProvider.GetTypeContractFor(nestedTypeDefinition);
VisitTypeDefinition(nestedTypeDefinition, typeContract);
return(base.Rewrite(nestedTypeDefinition));
}
public override void Visit(INestedTypeDefinition nestedTypeDefinition)
{
if (Process(nestedTypeDefinition))
{
visitor.Visit(nestedTypeDefinition);
}
base.Visit(nestedTypeDefinition);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
if (!_filter.Include((ITypeDefinition)nestedTypeDefinition))
{
return;
}
base.TraverseChildren(nestedTypeDefinition);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
if (!this.printCompilerGeneratedMembers && AttributeHelper.Contains(nestedTypeDefinition.Attributes, nestedTypeDefinition.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
{
return;
}
PrintTypeDefinition(nestedTypeDefinition as ITypeDefinition);
}
public bool IsForwardable(ITypeDefinition type)
{
INestedTypeDefinition nestedType = type as INestedTypeDefinition;
if (nestedType != null)
{
return(false);
}
return(true);
}
public void AddSynthesizedDefinition(TNamedTypeSymbol container, INestedTypeDefinition nestedType)
{
Debug.Assert(nestedType != null);
SynthesizedDefinitions defs = GetCacheOfSynthesizedDefinitions(container);
if (defs.NestedTypes == null)
{
Interlocked.CompareExchange(ref defs.NestedTypes, new Queue <INestedTypeDefinition>(), null);
}
defs.NestedTypes.Enqueue(nestedType);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
if (IsCompilerGenerated(nestedTypeDefinition))
return;
if (ContractHelper.IsContractClass(_host, nestedTypeDefinition))
return;
if (nestedTypeDefinition.GetType().Name == "GenericTypeParameter")
return;
if (!MemberHelper.IsVisibleOutsideAssembly(nestedTypeDefinition))
return;
base.TraverseChildren(nestedTypeDefinition);
}
public static string MemberGroupHeading(ITypeDefinitionMember member)
{
if (member == null)
{
return(null);
}
IMethodDefinition method = member as IMethodDefinition;
if (method != null)
{
if (method.IsConstructor)
{
return("Constructors");
}
return("Methods");
}
IFieldDefinition field = member as IFieldDefinition;
if (field != null)
{
return("Fields");
}
IPropertyDefinition property = member as IPropertyDefinition;
if (property != null)
{
return("Properties");
}
IEventDefinition evnt = member as IEventDefinition;
if (evnt != null)
{
return("Events");
}
INestedTypeDefinition nType = member as INestedTypeDefinition;
if (nType != null)
{
return("Nested Types");
}
return(null);
}
// Base case
public override void Visit(INestedTypeDefinition type)
{
if (_visited.ContainsKey(type))
{
return;
}
_visited.Add(type, null);
AddTypeReference(type);
AddMembersWithExternalRelatives(type);
// Recursion
Visit(type.BaseClasses);
Visit(type.ContainingType);
}
static private bool IsPublic(ITypeDefinition typeDefinition)
{
INamespaceTypeDefinition namespaceTypeDefinition = typeDefinition as INamespaceTypeDefinition;
if (namespaceTypeDefinition != null)
{
return(namespaceTypeDefinition.IsPublic);
}
INestedTypeDefinition nestedTypeDefinition = typeDefinition as INestedTypeDefinition;
if (nestedTypeDefinition != null)
{
return(nestedTypeDefinition.Visibility == TypeMemberVisibility.Public);
}
return(false);
}
public virtual void PrintTypeDefinitionVisibility(ITypeDefinition typeDefinition)
{
if (typeDefinition is INamespaceTypeDefinition)
{
INamespaceTypeDefinition namespaceTypeDefinition = typeDefinition as INamespaceTypeDefinition;
if (namespaceTypeDefinition.IsPublic)
{
PrintKeywordPublic();
}
}
else if (typeDefinition is INestedTypeDefinition)
{
INestedTypeDefinition nestedTypeDefinition = typeDefinition as INestedTypeDefinition;
PrintTypeMemberVisibility(nestedTypeDefinition.Visibility);
}
}
static string GetVisibility(INestedTypeDefinition nestedType)
{
switch (nestedType.Visibility)
{
case TypeMemberVisibility.Assembly: return("internal");
case TypeMemberVisibility.Family: return("protected");
case TypeMemberVisibility.FamilyAndAssembly: return("protected and internal");
case TypeMemberVisibility.FamilyOrAssembly: return("protected internal");
case TypeMemberVisibility.Public: return("public");
default: return("private");
}
}
internal static IModule GetModuleForType(ITypeDefinition typeDefinition)
{
INestedTypeDefinition ntd = typeDefinition as INestedTypeDefinition;
while (ntd != null)
{
typeDefinition = ntd.ContainingTypeDefinition;
ntd = typeDefinition as INestedTypeDefinition;
}
INamespaceTypeDefinition nstd = typeDefinition as INamespaceTypeDefinition;
if (nstd != null)
{
return(nstd.ContainingUnitNamespace.Unit as IModule);
}
return(null);
}
public static INamedTypeDefinition GetCorresponding(this IUnit unit, ITypeDefinition type)
{
INamespaceTypeDefinition nstd = type as INamespaceTypeDefinition;
if (nstd != null)
{
return(unit.GetCorresponding(nstd));
}
INestedTypeDefinition nested = type as INestedTypeDefinition;
if (nested != null)
{
return(unit.GetCorresponding(nested));
}
return(null);
}
public static INamespaceDefinition GetNamespace(this ITypeDefinition type)
{
INamespaceTypeDefinition nsType = type as INamespaceTypeDefinition;
if (nsType != null)
{
return(nsType.ContainingNamespace);
}
INestedTypeDefinition ntType = type as INestedTypeDefinition;
if (ntType != null)
{
return(GetNamespace(ntType.ContainingTypeDefinition));
}
return(null);
}
public static string Name(this ITypeDefinition type)
{
INamespaceTypeDefinition nsType = type as INamespaceTypeDefinition;
if (nsType != null)
{
return(nsType.Name.Value);
}
INestedTypeDefinition nType = type as INestedTypeDefinition;
if (nType != null)
{
return(nType.Name.Value);
}
throw new NotImplementedException(LocalizedStrings.CalledNameOnUnsupportedDefinition);
}
// this method doesn't take into account the FrameworkInternal annotation
public static bool IsTypeExternallyVisible(INamedTypeDefinition type)
{
INamespaceTypeDefinition nsType = type as INamespaceTypeDefinition;
if (nsType != null)
{
return(nsType.IsPublic);
}
INestedTypeDefinition nestedType = type as INestedTypeDefinition;
if (nestedType != null)
{
return(IsMemberExternallyVisible(nestedType));
}
throw new Exception("We shouldn't ask this question on anything else");
}
public static string Name(this ITypeDefinition type)
{
INamespaceTypeDefinition nsType = type as INamespaceTypeDefinition;
if (nsType != null)
{
return(nsType.Name.Value);
}
INestedTypeDefinition nType = type as INestedTypeDefinition;
if (nType != null)
{
return(nType.Name.Value);
}
throw new NotImplementedException("Called .Name on a currently unsupported type definition!");
}
private static IEnumerable <string> AllNamespaces(this ITypeDefinition type)
{
INestedTypeDefinition nestedType = type as INestedTypeDefinition;
if (nestedType != null)
{
return(nestedType.AllNamespaces());
}
INamespaceTypeReference namespaceType = type as INamespaceTypeReference;
if (namespaceType != null)
{
return(namespaceType.AllNamespaces());
}
return("".Return());
}
public override void Visit(ITypeDefinition type)
{
INamespaceTypeDefinition nsType = type as INamespaceTypeDefinition;
INestedTypeDefinition nestedType = type as INestedTypeDefinition;
if (nsType != null)
{
Visit(nsType);
}
else if (nestedType != null)
{
Visit(nestedType);
}
else
{
base.Visit(type);
}
}
//private IApiInformationProvider m_apiInformation;
// this method takes into account the FrameworkInternal annotation
private bool IsTypeExternallyVisible2(INamedTypeDefinition type)
{
INamespaceTypeDefinition nsType = type as INamespaceTypeDefinition;
if (nsType != null)
{
return(nsType.IsPublic || m_implModel.IsFrameworkInternal(type));
}
INestedTypeDefinition nestedType = type as INestedTypeDefinition;
if (nestedType != null)
{
return(IsMemberExternallyVisible2(nestedType));
}
throw new Exception("We shouldn't ask this question on anything else");
}
internal static string TypeDefinitionMember(IUnit currentUnit, ITypeDefinitionMember typeDefinitionMember)
{
INestedTypeDefinition nestedTypeDefinition = typeDefinitionMember as INestedTypeDefinition;
if (nestedTypeDefinition != null)
{
StringBuilder sb = new StringBuilder(".class ");
sb.Append(nestedTypeDefinition.Name.Value);
return(sb.ToString());
}
IMethodDefinition methodDefinition = typeDefinitionMember as IMethodDefinition;
if (methodDefinition != null)
{
StringBuilder sb = new StringBuilder(".method ");
sb.AppendFormat("{0} : {1}", methodDefinition.Name.Value, Helper.SignatureDefinition(currentUnit, methodDefinition));
return(sb.ToString());
}
IFieldDefinition fieldDefinition = typeDefinitionMember as IFieldDefinition;
if (fieldDefinition != null)
{
StringBuilder sb = new StringBuilder(".field ");
sb.AppendFormat("{0} : {1}", fieldDefinition.Name.Value, Helper.TypeDefinition(currentUnit, fieldDefinition.Type.ResolvedType));
return(sb.ToString());
}
IEventDefinition eventDefinition = typeDefinitionMember as IEventDefinition;
if (eventDefinition != null)
{
StringBuilder sb = new StringBuilder(".event ");
sb.AppendFormat("{0} : {1}", eventDefinition.Name.Value, Helper.TypeDefinition(currentUnit, eventDefinition.Type.ResolvedType));
return(sb.ToString());
}
IPropertyDefinition propertyDefinition = typeDefinitionMember as IPropertyDefinition;
if (propertyDefinition != null)
{
StringBuilder sb = new StringBuilder(".property ");
sb.AppendFormat("{0} : {1}", propertyDefinition.Name.Value, Helper.SignatureDefinition(currentUnit, propertyDefinition));
return(sb.ToString());
}
return("!?!Error-TypeMember!?!");
}
private List <IMethodImplementation> GetExplicitImplementationOverrides(TypeDefinitionMember member, List <IMethodImplementation> methodImpls)
{
INamespaceTypeDefinition namespaceTypeDef = member.ContainingTypeDefinition as INamespaceTypeDefinition;
INestedTypeDefinition nestedTypeDef = member.ContainingTypeDefinition as INestedTypeDefinition;
if (namespaceTypeDef != null)
{
methodImpls = ((NamespaceTypeDefinition)namespaceTypeDef).ExplicitImplementationOverrides;
}
else if (nestedTypeDef != null)
{
methodImpls = ((NamespaceTypeDefinition)namespaceTypeDef).ExplicitImplementationOverrides;
}
else
{
throw new InvalidOperationException("ExplicitImplementationOverrides can only be accessed on a NamespaceTypeDefinition or a NestedTypeDefinition object");
}
return(methodImpls);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
if (IsCompilerGenerated(nestedTypeDefinition))
{
return;
}
if (ContractHelper.IsContractClass(_host, nestedTypeDefinition))
{
return;
}
if (nestedTypeDefinition.GetType().Name == "GenericTypeParameter")
{
return;
}
if (!MemberHelper.IsVisibleOutsideAssembly(nestedTypeDefinition))
{
return;
}
base.TraverseChildren(nestedTypeDefinition);
}
public override List <INestedTypeDefinition> Rewrite(List <INestedTypeDefinition> nestedTypeDefinitions)
{
List <INestedTypeDefinition> newList = new List <INestedTypeDefinition>();
bool inParentSpecialType = CurrentTrimElement is SpecialTrimType;
if (nestedTypeDefinitions == null)
{
return(newList);
}
foreach (INestedTypeDefinition nestedType in nestedTypeDefinitions)
{
string typeName = Util.FullyQualifiedTypeNameFromType(nestedType);
Element currentElement = null;
if (inParentSpecialType)
{
currentElement = new SpecialTrimType(typeName);
}
else
{
currentElement = _currentTrimAssembly.GetTypeElement(typeName);
}
// special case for the module class. In mscorlib we don't have any global functions, etc.
// TODO: process its members too.
if (currentElement != null)
{
_trimElements.Push(currentElement);
// Need to create the Mutable copy here
INestedTypeDefinition newType = Rewrite(nestedType);
newList.Add(newType);
MutateType(newType, currentElement);
_trimElements.Pop();
}
}
return(newList);
}
public static INestedTypeDefinition GetCorresponding(this IUnit unit, INestedTypeDefinition type)
{
var parent = unit.GetCorresponding(type.ContainingTypeDefinition);
if (parent == null)
{
return(null);
}
foreach (var candidate in parent.GetMembersNamed(type.Name, false))
{
INestedTypeDefinition result = candidate as INestedTypeDefinition;
if (result == null)
{
continue;
}
if (result.GenericParameterCount == type.GenericParameterCount)
{
return(result);
}
}
return(null);
}
private bool ShouldWhack(ITypeDefinition typeDefinition)
{
if (SecurityWhatToKeep == SecurityKeepOptions.OnlyNonCritical)
{
if (IsSecurityCritical(typeDefinition))
{
return(true);
}
}
switch (this.WhatToKeep)
{
case KeepOptions.All:
return(false);
case KeepOptions.ExtVis:
if (typeDefinition is INamespaceTypeDefinition || typeDefinition is INestedTypeDefinition)
{
return(!TypeHelper.IsVisibleOutsideAssembly(typeDefinition));
}
return(false); // REVIEW: what is the right thing to do here?
case KeepOptions.NonPrivate:
INamespaceTypeDefinition namespaceTypeDefinition = typeDefinition as INamespaceTypeDefinition;
if (namespaceTypeDefinition != null)
{
return(!namespaceTypeDefinition.IsPublic);
}
INestedTypeDefinition nestedTypeDefinition = typeDefinition as INestedTypeDefinition;
if (nestedTypeDefinition != null)
{
return(nestedTypeDefinition.Visibility == TypeMemberVisibility.Private);
}
return(false);
default:
return(false);
}
}
private void CheckSurface(INestedTypeDefinition nested, IEnumerable <INestedTypeDefinition> nestedTypes)
{
Contract.Requires(nested != null);
Contract.Requires(nestedTypes != null);
foreach (INamedTypeDefinition candidate in nestedTypes)
{
if (candidate.Name.UniqueKey == nested.Name.UniqueKey)
{
CheckTypeSurface(nested, candidate);
return;
}
}
if (nested.IsInterface && !TypeHelper.IsVisibleOutsideAssembly(nested))
{
// Allow internal interfaces to be in our contract reference assemblies in order to get right virtual bits on some members.
Warning("Nested interface {0} only exists in contract reference assembly, but it is internal only, so allowed.", TypeHelper.GetTypeName(nested));
}
else
{
Error("Nested type {0} only exists in contract reference assembly", TypeHelper.GetTypeName(nested));
}
}
/// <summary>
/// Traverses the nested type definition.
/// </summary>
public void Traverse(INestedTypeDefinition nestedTypeDefinition)
{
Contract.Requires(nestedTypeDefinition != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(nestedTypeDefinition);
if (this.stopTraversal) return;
this.TraverseChildren(nestedTypeDefinition);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(nestedTypeDefinition);
}
/// <summary>
/// Rewrites the given nested type definition.
/// </summary>
public virtual INestedTypeDefinition Rewrite(INestedTypeDefinition namespaceTypeDefinition)
{
return namespaceTypeDefinition;
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
if (!_filter.Include((ITypeDefinition)nestedTypeDefinition))
return;
base.TraverseChildren(nestedTypeDefinition);
}
public void Visit(INestedTypeDefinition nestedTypeDefinition)
{
throw new NotImplementedException();
}
public override void Visit(INestedTypeDefinition nestedType)
{
EmitType(nestedType, nestedType.Name.Value);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{ MethodEnter(nestedTypeDefinition);
base.TraverseChildren(nestedTypeDefinition);
MethodExit(); }
void LoadNestedTypesOfType(
TypeBase moduleType
) {
uint currentClassRowId = moduleType.TypeDefRowId;
uint numberOfNestedClassRows = this.PEFileReader.NestedClassTable.NumberOfRows;
var moduleTypeArray = this.ModuleTypeDefArray;
uint firstNestedClassRow = 0;
uint nestedClassCounter = 0;
for (uint i = 1; i <= numberOfNestedClassRows; ++i) {
NestedClassRow nestedClassRow = this.PEFileReader.NestedClassTable[i];
if (nestedClassRow.EnclosingClass != currentClassRowId) continue;
if (firstNestedClassRow == 0) firstNestedClassRow = i;
nestedClassCounter++;
// Check if its already created by someone else
NestedType/*?*/ currType = moduleTypeArray[nestedClassRow.NestedClass] as NestedType;
if (currType == null) {
currType = this.CreateModuleNestedType(nestedClassRow.NestedClass, this.PEFileReader.TypeDefTable[nestedClassRow.NestedClass], moduleType);
var redirectedType = this.ModuleReader.metadataReaderHost.Redirect(this.Module, currType);
if (redirectedType == currType) moduleType.AddMember(currType);
moduleTypeArray[nestedClassRow.NestedClass] = currType;
this.RedirectedTypeDefArray[nestedClassRow.NestedClass] = redirectedType;
this.ModuleTypeDefLoadState[nestedClassRow.NestedClass] = LoadState.Loaded;
}
}
if (nestedClassCounter > 0) {
var nestedTypes = new INestedTypeDefinition[nestedClassCounter];
uint j = 0;
for (uint i = firstNestedClassRow; j < nestedClassCounter && i <= numberOfNestedClassRows; ++i) {
NestedClassRow nestedClassRow = this.PEFileReader.NestedClassTable[i];
if (nestedClassRow.EnclosingClass != currentClassRowId) continue;
nestedTypes[j++] = (INestedTypeDefinition)moduleTypeArray[nestedClassRow.NestedClass];
Contract.Assume(nestedTypes[j-1] != null);
}
Contract.Assume(j == nestedClassCounter);
moduleType.nestedTypes = IteratorHelper.GetReadonly(nestedTypes);
}
}
public override void Visit(INestedTypeDefinition nestedTypeDefinition) {
var builder = (TypeBuilder)this.loader.builderMap[nestedTypeDefinition];
this.Visit(nestedTypeDefinition, builder);
}
/// <summary>
///
/// </summary>
/// <param name="host"></param>
/// <param name="closureClass"></param>
/// <returns></returns>
public static ISourceMethodBody/*?*/ FindClosureGetEnumerator(IMetadataHost host, INestedTypeDefinition closureClass) {
return null;
}
public override void Visit(INestedTypeDefinition nestedTypeDefinition)
{
if(Process(nestedTypeDefinition)){visitor.Visit(nestedTypeDefinition);}
base.Visit(nestedTypeDefinition);
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Performs some computation with the given nested type definition.
/// </summary>
/// <param name="nestedTypeDefinition"></param>
public virtual void Visit(INestedTypeDefinition nestedTypeDefinition)
{
}
public override void Visit(INestedTypeDefinition nestedTypeDefinition) {
nestedTypeDefinition.ContainingTypeDefinition.Dispatch(this);
this.Visit(nestedTypeDefinition.Name.Value);
if (nestedTypeDefinition.GenericParameterCount > 0) {
int h = this.hash;
h = (h << 5 + h) ^ (int)nestedTypeDefinition.GenericParameterCount;
this.hash = h;
}
}
public void Visit(INestedTypeDefinition nestedTypeDefinition)
{
this.traverser.Traverse(nestedTypeDefinition);
}
public override INestedTypeDefinition Rewrite(INestedTypeDefinition nestedTypeDefinition) {
this.VisitTypeDefinition(nestedTypeDefinition);
return base.Rewrite(nestedTypeDefinition);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition) {
object builder;
if (!this.loader.builderMap.TryGetValue(nestedTypeDefinition, out builder)) return;
this.loader.builderMap.Remove(nestedTypeDefinition);
var typeBuilder = builder as TypeBuilder;
if (typeBuilder == null) return;
this.CreateTypesThatNeedToBeLoadedBeforeLoading(nestedTypeDefinition);
var type = typeBuilder.CreateType();
this.loader.mapper.DefineMapping(nestedTypeDefinition, type);
this.Traverse(nestedTypeDefinition.NestedTypes);
}
// Base case
public override void Visit(INestedTypeDefinition type)
{
if (_visited.ContainsKey(type))
return;
_visited.Add(type, null);
AddTypeReference(type);
AddMembersWithExternalRelatives(type);
// Recursion
Visit(type.BaseClasses);
Visit(type.ContainingType);
}
/// <summary>
/// Performs some computation with the given nested type definition.
/// </summary>
/// <param name="nestedTypeDefinition"></param>
public virtual void Visit(INestedTypeDefinition nestedTypeDefinition)
//^ ensures this.path.Count == old(this.path.Count);
{
}
/// <summary>
/// Traverses the children of the nested type definition.
/// </summary>
public virtual void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
Contract.Requires(nestedTypeDefinition != null);
this.TraverseChildren((INamedTypeDefinition)nestedTypeDefinition);
}
/// <summary>
/// Traverses the children of the nested type definition.
/// </summary>
public virtual void TraverseChildren(INestedTypeDefinition nestedTypeDefinition)
{
this.TraverseChildren((INamedTypeDefinition)nestedTypeDefinition);
}
/// <summary>
/// Performs some computation with the given nested type definition.
/// </summary>
public virtual void Visit(INestedTypeDefinition nestedTypeDefinition)
{
this.Visit((INamedTypeDefinition)nestedTypeDefinition);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition) {
var name = nestedTypeDefinition.Name.Value;
if (nestedTypeDefinition.IsGeneric) name = name + "`" + nestedTypeDefinition.GenericParameterCount;
var attributes = GetTypeAttributes(nestedTypeDefinition);
attributes |= GetNestedTypeVisibility(nestedTypeDefinition);
var containingType = (TypeBuilder)this.loader.mapper.GetType(nestedTypeDefinition.ContainingTypeDefinition);
var typeBuilder = containingType.DefineNestedType(name);
this.AllocateGenericParametersIfNecessary(nestedTypeDefinition, typeBuilder);
this.loader.builderMap.Add(nestedTypeDefinition, typeBuilder); //so that typeBuilder references can be treated uniformly later on
this.loader.mapper.DefineMapping(nestedTypeDefinition, typeBuilder);
foreach (var nestedType in nestedTypeDefinition.NestedTypes)
this.TraverseChildren(nestedType);
}
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition) {
if (!this.printCompilerGeneratedMembers && AttributeHelper.Contains(nestedTypeDefinition.Attributes, nestedTypeDefinition.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
return;
PrintTypeDefinition(nestedTypeDefinition as ITypeDefinition);
}
private void CheckSurface(INestedTypeDefinition nested, IEnumerable<INestedTypeDefinition> nestedTypes)
{
Contract.Requires(nested != null);
Contract.Requires(nestedTypes != null);
foreach (INamedTypeDefinition candidate in nestedTypes)
{
if (candidate.Name.UniqueKey == nested.Name.UniqueKey)
{
CheckTypeSurface(nested, candidate);
return;
}
}
if (nested.IsInterface && !TypeHelper.IsVisibleOutsideAssembly(nested))
{
// Allow internal interfaces to be in our contract reference assemblies in order to get right virtual bits on some members.
Warning("Nested interface {0} only exists in contract reference assembly, but it is internal only, so allowed.", TypeHelper.GetTypeName(nested));
}
else
{
Error("Nested type {0} only exists in contract reference assembly", TypeHelper.GetTypeName(nested));
}
}
/// <summary>
/// Performs some computation with the given nested type definition.
/// </summary>
public void Visit(INestedTypeDefinition nestedTypeDefinition)
{
this.Visit((INamedTypeDefinition)nestedTypeDefinition);
if (!this.allTypes.Contains(nestedTypeDefinition))
this.ReportError(MetadataError.GetAllTypesIsIncomplete, nestedTypeDefinition);
}
public static INestedTypeDefinition GetCorresponding(this IUnit unit, INestedTypeDefinition type)
{
var parent = unit.GetCorresponding(type.ContainingTypeDefinition);
if (parent == null) return null;
foreach (var candidate in parent.GetMembersNamed(type.Name, false))
{
INestedTypeDefinition result = candidate as INestedTypeDefinition;
if (result == null) continue;
if (result.GenericParameterCount == type.GenericParameterCount) return result;
}
return null;
}
public virtual void onMetadataElement(INestedTypeDefinition nestedTypeDefinition) { }
/// <summary>
/// Visits the specified nested type definition.
/// </summary>
/// <param name="nestedTypeDefinition">The nested type definition.</param>
public override INestedTypeDefinition Visit(INestedTypeDefinition nestedTypeDefinition)
{
var result = base.Visit(nestedTypeDefinition);
if (this.contractProvider != null) {
ITypeContract/*?*/ typeContract = this.contractProvider.GetTypeContractFor(nestedTypeDefinition);
if (typeContract != null)
this.contractProvider.AssociateTypeWithContract(result, this.Visit(typeContract));
}
return result;
}
