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 void RewriteChildren(NestedUnitNamespace unitNamespace)
{
if (!this.once)
{
List <INamespaceTypeDefinition> genericTypes = new List <INamespaceTypeDefinition>();
int count = 0;
for (int i = 0, n = unitNamespace.Members.Count; i < n; i++)
{
INamespaceTypeDefinition typ = unitNamespace.Members[i] as INamespaceTypeDefinition;
if (typ != null && typ.IsGeneric && !typ.Name.Value.Contains("<<>>"))
{
this.once = true;
if (count == this.number)
{
genericTypes.Add(typ);
break;
}
count++;
}
}
if (genericTypes.Count > 0)
{
foreach (var t in this.WithMoreGenericParameters(genericTypes))
{
unitNamespace.Members.Add(t);
}
}
}
base.RewriteChildren(unitNamespace);
}
public override List <INamespaceMember> Rewrite(List <INamespaceMember> namespaceMembers)
{
List <INamespaceMember> newList = new List <INamespaceMember>();
foreach (var namespaceMember in namespaceMembers)
{
INamespaceTypeDefinition namespaceTypeDefinition = namespaceMember as INamespaceTypeDefinition;
if (namespaceTypeDefinition != null)
{
if (this.ShouldWhack(namespaceTypeDefinition))
{
if (!this.WhackedTypes.ContainsKey(namespaceTypeDefinition.InternedKey))
{
this.WhackedTypes.Add(namespaceTypeDefinition.InternedKey, true);
}
continue;
}
var mutableNamespaceTypeDefinition = (NamespaceTypeDefinition)this.Rewrite(namespaceTypeDefinition);
if (this.backwardCompat)
{
mutableNamespaceTypeDefinition.IsBeforeFieldInit = false;
}
newList.Add(mutableNamespaceTypeDefinition);
}
else
{
newList.Add(base.Rewrite(namespaceMember));
}
}
return(newList);
}
public override INamespaceTypeDefinition Rewrite(INamespaceTypeDefinition namespaceTypeDefinition)
{
var typeContract = contractProvider.GetTypeContractFor(namespaceTypeDefinition);
VisitTypeDefinition(namespaceTypeDefinition, typeContract);
return(base.Rewrite(namespaceTypeDefinition));
}
public override void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
if (Process(namespaceTypeDefinition))
{
visitor.Visit(namespaceTypeDefinition);
}
base.Visit(namespaceTypeDefinition);
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition)
{
if (!_filter.Include(namespaceTypeDefinition))
{
return;
}
base.TraverseChildren(namespaceTypeDefinition);
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition)
{
if (_filter.Matches(namespaceTypeDefinition))
{
_visitor.TypeEnter(namespaceTypeDefinition);
base.TraverseChildren(namespaceTypeDefinition);
_visitor.TypeExit(namespaceTypeDefinition);
}
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition)
{
if (_filter.Matches(namespaceTypeDefinition))
{
_visitor.TypeEnter(namespaceTypeDefinition);
base.TraverseChildren(namespaceTypeDefinition);
_visitor.TypeExit(namespaceTypeDefinition);
}
}
internal static IModule GetInstrumented(IMetadataHost host, IModule module, PdbReader/*?*/ pdbReader, INamespaceTypeDefinition logger) {
var copier = new MetadataDeepCopier(host);
var copy = copier.Copy(module);
var loggerCopy = copier.Copy(logger);
loggerCopy.ContainingUnitNamespace = copy.UnitNamespaceRoot;
var logEdgeCount = TypeHelper.GetMethod(loggerCopy, host.NameTable.GetNameFor("LogEdgeCount"), host.PlatformType.SystemUInt32);
new Instrumenter(host, pdbReader, logEdgeCount).Rewrite(copy);
copy.AllTypes.Add(loggerCopy);
return copy;
}
public override void Visit(INamespaceTypeDefinition type)
{
string nsName = type.ContainingUnitNamespace.ResolvedUnitNamespace.ToString();
_currentClass = new TestNodeClass(type.Name.Value)
{
Namespace = nsName
};
_classes.Add(_currentClass);
}
public override void Visit(INamespaceTypeDefinition type)
{
string nsName = type.ContainingUnitNamespace.ResolvedUnitNamespace.ToString();
_currentClass = new TestNodeClass(type.Name.Value)
{
Namespace = nsName
};
_classes.Add(_currentClass);
}
public Type Load(INamespaceTypeDefinition namespaceTypeDefinition) {
//first create (but do not initialize) all typeBuilder builders, since they are needed to create member builders.
this.typeBuilderAllocator.Traverse(namespaceTypeDefinition);
//next create (but do not initialize) builder for all other kinds of typeBuilder members, since there may be forward references during initialization
this.memberBuilderAllocator.Traverse(namespaceTypeDefinition);
//now initialize all the builders
this.initializingTraverser.TraverseChildren(namespaceTypeDefinition);
//finally create the type and return it
this.typeCreator.Traverse(namespaceTypeDefinition);
return this.mapper.GetType(namespaceTypeDefinition);
}
private void trackPhoneApplicationClassname(ITypeDefinition typeDef)
{
if (PhoneCodeHelper.instance().PhonePlugin != null && typeDef.isPhoneApplicationClass(sink.host))
{
INamespaceTypeDefinition namedTypeDef = typeDef as INamespaceTypeDefinition;
// string fullyQualifiedName = namedTypeDef.ContainingNamespace.Name.Value + "." + namedTypeDef.Name.Value;
string fullyQualifiedName = namedTypeDef.ToString();
PhoneCodeHelper.instance().setMainAppTypeReference(typeDef);
PhoneCodeHelper.instance().setMainAppTypeName(fullyQualifiedName);
}
}
public override INamespaceTypeDefinition Rewrite(INamespaceTypeDefinition namespaceTypeDefinition)
{
var mutableNamespaceTypeDefinition = namespaceTypeDefinition as NamespaceTypeDefinition;
if (mutableNamespaceTypeDefinition == null)
{
return(namespaceTypeDefinition);
}
mutableNamespaceTypeDefinition.Name = this.host.NameTable.GetNameFor(this.pattern.Replace(namespaceTypeDefinition.Name.Value, this.evaluator));
this.RewriteChildren(mutableNamespaceTypeDefinition);
return(mutableNamespaceTypeDefinition);
}
public bool isMethodIgnoredForFeedback(IMethodDefinition methodTranslated)
{
INamespaceTypeDefinition type = methodTranslated.ContainingType.ResolvedType as INamespaceTypeDefinition;
if (type == null)
{
return(false);
}
string methodName = type.ContainingUnitNamespace.Name.Value + "." + type.Name + "." + methodTranslated.Name.Value;
return(ignoredHandlers.Contains(methodName));
}
// Base case
public override void Visit(INamespaceTypeDefinition type)
{
if (_visited.ContainsKey(type))
{
return;
}
_visited.Add(type, null);
AddTypeReference(type);
AddMembersWithExternalRelatives(type);
// Recursion
Visit(type.BaseClasses);
}
private void trackPhonePageNameVariableName(ITypeDefinition typeDef)
{
if (PhoneCodeHelper.instance().PhonePlugin != null && typeDef.isPhoneApplicationPageClass(sink.host))
{
INamespaceTypeDefinition namedTypeDef = typeDef as INamespaceTypeDefinition;
string fullyQualifiedName = namedTypeDef.ToString();
string xamlForClass = PhoneCodeHelper.instance().getXAMLForPage(fullyQualifiedName);
if (xamlForClass != null) // if not it is possibly an abstract page
{
string uriName = UriHelper.getURIBase(xamlForClass);
Bpl.Constant uriConstant = sink.FindOrCreateConstant(uriName);
PhoneCodeHelper.instance().setBoogieStringPageNameForPageClass(fullyQualifiedName, uriConstant.Name);
}
}
}
private INamespaceTypeDefinition VisitNamespaceType(INamespaceTypeDefinition def)
{
// All generated top-level types are assumed to be in the global namespace.
// However, this may be an embedded NoPIA type within a namespace.
// Since we do not support edits that include references to NoPIA types
// (see #855640), it's reasonable to simply drop such cases.
if (!string.IsNullOrEmpty(def.NamespaceName))
{
return null;
}
var topLevelTypes = this.GetTopLevelTypesByName();
INamespaceTypeDefinition otherDef;
topLevelTypes.TryGetValue(def.Name, out otherDef);
return otherDef;
}
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);
}
}
public override void RewriteChildren(RootUnitNamespace rootUnitNamespace)
{
this.classHoldingThreeArgVersions = this.GetContractClass(rootUnitNamespace);
base.RewriteChildren(rootUnitNamespace);
#region Possibly add class for any contract methods that were defined.
if (0 < this.threeArgumentVersionofContractMethod.Count)
{
// Only add class to assembly if any 3 arg versions were actually created
rootUnitNamespace.Members.Add(classHoldingThreeArgVersions);
this.allTypes.Add(classHoldingThreeArgVersions);
}
#endregion Possibly add class for any contract methods that were defined.
#region Create a reference to [ContractReferenceAssembly] to mark the assembly with
INamespaceTypeDefinition contractReferenceAssemblyAttribute = null;
#region First see if we can find it in the same assembly as the one we are rewriting
var unit = rootUnitNamespace.Unit;
contractReferenceAssemblyAttribute = UnitHelper.FindType(this.host.NameTable, unit, "System.Diagnostics.Contracts.ContractReferenceAssemblyAttribute")
as INamespaceTypeDefinition;
#endregion First see if we can find it in the same assembly as the one we are rewriting
#region If it doesn't exist there, then define it in the same place that the three-argument versions are defined
if (contractReferenceAssemblyAttribute is Dummy)
{
contractReferenceAssemblyAttribute = CreateContractReferenceAssemblyAttribute(rootUnitNamespace);
}
#endregion If it doesn't exist there, then define it in the same place that the three-argument versions are defined
#region Create a reference to the ctor
var ctorRef = new Microsoft.Cci.MutableCodeModel.MethodReference()
{
CallingConvention = CallingConvention.HasThis,
ContainingType = contractReferenceAssemblyAttribute,
InternFactory = this.host.InternFactory,
Name = host.NameTable.Ctor,
Type = systemVoidType,
};
var rm = ctorRef.ResolvedMethod;
this.ContractReferenceAssemblyAttributeInstance = new CustomAttribute()
{
Constructor = ctorRef,
};
#endregion Create a reference to the ctor
#endregion Create a reference to [ContractReferenceAssembly] to mark the assembly with
return;
}
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 override void TraverseChildren(IMethodCall methodCall)
{
if (PhoneCodeHelper.instance().PhoneFeedbackToggled)
{
// check for handlers we do not wish to add feedback checks to
if (methodCall.MethodToCall.Name.Value.StartsWith("add_"))
{
string eventName = methodCall.MethodToCall.Name.Value.Remove(0, "add_".Length);
if (PhoneCodeHelper.IgnoredEvents.Contains(eventName))
{
IMethodReference eventHandler = null;
foreach (IExpression arg in methodCall.Arguments)
{
ICreateDelegateInstance createDelegate = arg as ICreateDelegateInstance;
if (createDelegate == null)
{
continue;
}
ITypeReference typeRef = createDelegate.Type;
if (!typeRef.isRoutedEventHandlerClass(host))
{
continue;
}
eventHandler = createDelegate.MethodToCallViaDelegate;
break;
}
if (eventHandler != null)
{
INamespaceTypeReference namedType = eventHandler.ContainingType.ResolvedType as INamespaceTypeReference;
if (namedType != null)
{
INamespaceTypeDefinition namedTypeDef = namedType.ResolvedType;
if (namedTypeDef != null)
{
PhoneCodeHelper.instance().ignoreEventHandler(namedTypeDef.ContainingUnitNamespace.Name + "." + namedTypeDef.Name + "." + eventHandler.Name);
}
}
}
}
}
}
}
// 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 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);
}
//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");
}
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);
}
}
public IEnumerable <INamespaceTypeDefinition> GetTopLevelTypes(EmitContext context)
{
CommonPEModuleBuilder module = (CommonPEModuleBuilder)context.Module;
foreach (INamespaceTypeDefinition type in module.GetAnonymousTypes())
{
yield return(type);
}
foreach (ISymbol symbol in _changes.Keys)
{
INamespaceTypeDefinition namespaceTypeDef = (symbol as ITypeDefinition)?.AsNamespaceTypeDefinition(context);
if (namespaceTypeDef != null)
{
yield return(namespaceTypeDef);
}
}
}
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 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 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 static INamespaceTypeDefinition GetCorresponding(this IUnit unit, INamespaceTypeDefinition type)
{
INamespaceDefinition ns = unit.GetCorresponding(type.ContainingNamespace);
if (ns == null)
{
return(null);
}
foreach (var mem in ns.GetMembersNamed(type.Name, true))
{
INamespaceTypeDefinition candidate = mem as INamespaceTypeDefinition;
if (candidate == null)
{
continue;
}
if (candidate.GenericParameterCount == type.GenericParameterCount)
{
return(candidate);
}
}
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);
}
}
/// <summary>
/// Traverses the children of the namespace type definition.
/// </summary>
public virtual void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition)
{
Contract.Requires(namespaceTypeDefinition != null);
this.TraverseChildren((INamedTypeDefinition)namespaceTypeDefinition);
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition) {
object builder;
if (!this.loader.builderMap.TryGetValue(namespaceTypeDefinition, out builder)) return;
this.loader.builderMap.Remove(namespaceTypeDefinition);
var typeBuilder = builder as TypeBuilder;
if (typeBuilder == null) return;
this.CreateTypesThatNeedToBeLoadedBeforeLoading(namespaceTypeDefinition);
var type = typeBuilder.CreateType();
this.loader.mapper.DefineMapping(namespaceTypeDefinition, type);
this.Traverse(namespaceTypeDefinition.NestedTypes);
}
/// <summary>
/// Traverses the namespace type definition.
/// </summary>
public void Traverse(INamespaceTypeDefinition namespaceTypeDefinition)
{
Contract.Requires(namespaceTypeDefinition != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(namespaceTypeDefinition);
if (this.stopTraversal) return;
this.TraverseChildren(namespaceTypeDefinition);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(namespaceTypeDefinition);
}
internal PEAssemblyBuilderWithAdditionalReferences(CommonPEModuleBuilder builder, INamespaceTypeDefinition objectType) :
base((SourceModuleSymbol)builder.CommonSourceModule, builder.EmitOptions, builder.OutputKind, builder.SerializationProperties, builder.ManifestResources)
{
_builder = builder;
_objectType = new NamespaceTypeDefinitionNoBase(objectType);
}
public override void Visit(INamespaceTypeDefinition namespaceTypeDefinition) {
namespaceTypeDefinition.ContainingUnitNamespace.Dispatch(this);
this.Visit(namespaceTypeDefinition.Name.Value);
if (namespaceTypeDefinition.GenericParameterCount > 0) {
int h = this.hash;
h = (h << 5 + h) ^ (int)namespaceTypeDefinition.GenericParameterCount;
this.hash = h;
}
}
/// <summary>
/// Performs some computation with the given namespace type definition.
/// </summary>
public virtual void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
this.Visit((INamedTypeDefinition)namespaceTypeDefinition);
}
public override void TraverseInterfaceImplementationAttributes(INamespaceTypeDefinition namespaceTypeDefinition)
{
MethodEnter(namespaceTypeDefinition);
base.TraverseInterfaceImplementationAttributes(namespaceTypeDefinition);
MethodExit();
}
private static bool IsRecordType(INamespaceTypeDefinition t)
{
foreach (ICustomAttribute attr in t.Attributes) {
if (TypeHelper.GetTypeName(attr.Type) == NamespaceHelper.SystemDiagnosticsContractsCodeContractString + ".StringVccAttr") {
List<IMetadataExpression> args = new List<IMetadataExpression>(attr.Arguments);
if (args.Count == 2) {
IMetadataConstant attrName = args[0] as IMetadataConstant;
if (attrName != null && ((string)attrName.Value) == "record")
return true;
}
}
}
return false;
}
/// <summary>
/// Performs some computation with the given namespace type definition.
/// </summary>
/// <param name="namespaceTypeDefinition"></param>
public virtual void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
//^ ensures this.path.Count == old(this.path.Count);
{
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition)
{
if (!_filter.Include(namespaceTypeDefinition))
return;
base.TraverseChildren(namespaceTypeDefinition);
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition) {
var name = TypeHelper.GetTypeName(namespaceTypeDefinition, NameFormattingOptions.UseGenericTypeNameSuffix);
var attributes = GetTypeAttributes(namespaceTypeDefinition);
if (namespaceTypeDefinition.IsPublic) attributes |= TypeAttributes.Public;
var typeBuilder = this.loader.ModuleBuilder.DefineType(name, attributes);
this.AllocateGenericParametersIfNecessary(namespaceTypeDefinition, typeBuilder);
this.loader.builderMap.Add(namespaceTypeDefinition, typeBuilder);
this.loader.mapper.DefineMapping(namespaceTypeDefinition, typeBuilder); //so that typeBuilder references can be treated uniformly later on
foreach (var nestedType in namespaceTypeDefinition.NestedTypes)
this.TraverseChildren(nestedType);
//TODO: also look at private helper members and private helper types
}
public void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
throw new NotImplementedException();
}
internal NamespaceTypeDefinitionNoBase(INamespaceTypeDefinition underlyingType)
{
UnderlyingType = underlyingType;
}
/// <summary>
/// Rewrites the given namespace type definition.
/// </summary>
public virtual INamespaceTypeDefinition Rewrite(INamespaceTypeDefinition namespaceTypeDefinition)
{
return namespaceTypeDefinition;
}
/// <summary>
/// Traverses any attributes that describe how the namespace type definition implements its interfaces.
/// </summary>
public virtual void TraverseInterfaceImplementationAttributes(INamespaceTypeDefinition namespaceTypeDefinition)
{
Contract.Requires(namespaceTypeDefinition != null);
foreach (var iface in namespaceTypeDefinition.Interfaces) {
this.Traverse(namespaceTypeDefinition.AttributesFor(iface));
if (this.stopTraversal) break;
}
}
// Base case
public override void Visit(INamespaceTypeDefinition type)
{
if (_visited.ContainsKey(type))
return;
_visited.Add(type, null);
AddTypeReference(type);
AddMembersWithExternalRelatives(type);
// Recursion
Visit(type.BaseClasses);
}
public void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
this.traverser.Traverse(namespaceTypeDefinition);
}
public override void Visit(INamespaceTypeDefinition namespaceTypeDefinition) {
var builder = (TypeBuilder)this.loader.builderMap[namespaceTypeDefinition];
this.Visit(namespaceTypeDefinition, builder);
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Performs some computation with the given namespace type definition.
/// </summary>
/// <param name="namespaceTypeDefinition"></param>
public virtual void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
}
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition)
{ MethodEnter(namespaceTypeDefinition);
base.TraverseChildren(namespaceTypeDefinition);
MethodExit(); }
public override void TraverseChildren(INamespaceTypeDefinition namespaceTypeDefinition) {
PrintTypeDefinition(namespaceTypeDefinition as ITypeDefinition);
}
public override void Visit(INamespaceTypeDefinition type)
{
EmitType(type, type.Name.Value);
}
/// <summary>
/// Performs some computation with the given namespace type definition.
/// </summary>
public void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
this.Visit((INamedTypeDefinition)namespaceTypeDefinition);
if (!this.allTypes.Contains(namespaceTypeDefinition))
this.ReportError(MetadataError.GetAllTypesIsIncomplete, namespaceTypeDefinition);
}
public static INamespaceTypeDefinition GetCorresponding(this IUnit unit, INamespaceTypeDefinition type)
{
INamespaceDefinition ns = unit.GetCorresponding(type.ContainingNamespace);
if (ns == null) return null;
foreach (var mem in ns.GetMembersNamed(type.Name, true)) {
INamespaceTypeDefinition candidate = mem as INamespaceTypeDefinition;
if (candidate == null) continue;
if (candidate.GenericParameterCount == type.GenericParameterCount) return candidate;
}
return null;
}
public virtual void onMetadataElement(INamespaceTypeDefinition namespaceTypeDefinition) { }
public override void Visit(INamespaceTypeDefinition namespaceTypeDefinition)
{
if(Process(namespaceTypeDefinition)){visitor.Visit(namespaceTypeDefinition);}
base.Visit(namespaceTypeDefinition);
}
