internal void StoreExportedType(IMetadataScope scope, String fullName, TypeReference exportedTo)
 {
     if (scope != null)
     {
         exportMappings[GetTypeKey(scope, fullName)] = exportedTo;
     }
 }

 /// <summary>
 /// Add the given message to the log.
 /// </summary>
 private void Log(MessageTypes type, string member, IMetadataScope scope, string msg)
 {
     if (IsDisposed) return;
     if (InvokeRequired)
     {
         Invoke(new Action<MessageTypes, string, IMetadataScope, string>(Log), type, member, scope, msg);
     }
     else
     {
         if ((type >= MessageTypes.MissingFirst) && (type <= MessageTypes.MissingLast))
         {
             MemberNode node;
             if (!nodes.TryGetValue(member, out node))
             {
                 node = new MemberNode(member, scope, type);
                 node.ImageIndex = (int) type;
                 nodes.Add(member, node);
                 tvList.Nodes.Add(node);
             }
             node.Messages.Add(msg);
             if (node == tvList.SelectedNode)
             {
                 tvUsedIn.Nodes.Add(new TreeNode(msg));
             }
         }
         else
         {
             tvLog.Nodes.Add(new TreeNode(msg) { ImageIndex = (int) type });
         }
         miCopy.Enabled = (tvList.Nodes.Count > 0);
     }
 }

 public ExportedType(string @namespace, string name, ModuleDefinition module, IMetadataScope scope)
 {
     [email protected] = @namespace;
     this.name = name;
     this.scope = scope;
     this.module = module;
 }

 internal static string GetScopeName(IMetadataScope scope)
 {
     if (scope is AssemblyNameReference)
         return ((AssemblyNameReference)scope).Name;
     if (scope is ModuleDefinition)
         return ((ModuleDefinition) scope).Assembly.Name.Name;
     throw new Exception("Unsupported scope: " + scope);
 }

 public ProjectReference FindProjectReference(IMetadataScope scope)
 {
     if (scope == null)
         return null;
     string assemblyFullName = scope.AssemblyFullName();
     return References.FirstOrDefault(
         item => string.
             Equals(item.FullName, assemblyFullName, StringComparison.InvariantCultureIgnoreCase));
 }

 public static TypeReference FindType(this ModuleDefinition currentModule, string @namespace, string typeName, IMetadataScope scope = null, params string[] typeParameters)
 {
     var result = new TypeReference(@namespace, typeName, currentModule, scope);
     foreach (var typeParameter in typeParameters)
     {
         result.GenericParameters.Add(new GenericParameter(typeParameter, result));
     }
     return result;
 }

        public static MModule getModule(IMetadataScope scope)
        {
            if (scope is ModuleDefinition)
                return getModule((ModuleDefinition)scope);
            else if (scope is AssemblyNameReference)
                return getModule((AssemblyNameReference)scope);

            return null;
        }

 internal static string GetScopeName(IMetadataScope scope)
 {
     string scopeStr = null;
     if (scope is AssemblyNameReference)
         scopeStr = ((AssemblyNameReference) scope).Name;
     if (scope is ModuleDefinition)
         scopeStr = ((ModuleDefinition) scope).Assembly.Name.Name;
     return scopeStr;
 }

 private static AssemblyNameReference GetReference(IMetadataScope scope)
 {
     ModuleDefinition definition = scope as ModuleDefinition;
     if (definition != null)
     {
         return definition.Assembly.Name;
     }
     return (AssemblyNameReference) scope;
 }

 public static AssemblyNameReference GetAssemblyNameReference(IMetadataScope scope)
 {
     switch (scope.MetadataScopeType)
     {
         case MetadataScopeType.AssemblyNameReference:
             return (AssemblyNameReference)scope;
         case MetadataScopeType.ModuleDefinition:
             return ((ModuleDefinition)scope).Assembly.Name;
         default:
             return null;
     }
 }

 /// <summary>
 /// Returns the <see cref="AssemblyNameReference"/> associated with the <see cref="IMetadataScope"/>
 /// </summary>
 /// <param name="scope">A <see cref="IMetadataScope"/></param>
 /// <returns>The associated <see cref="AssemblyNameReference"/></returns>
 private static AssemblyNameReference GetAssemblyFromScope(IMetadataScope scope)
 {
     switch (scope.MetadataScopeType)
     {
         case MetadataScopeType.AssemblyNameReference:
             return (AssemblyNameReference)scope;
         case MetadataScopeType.ModuleDefinition:
             return ((ModuleDefinition) scope).Assembly.Name;
         default:
             throw new NotSupportedException();
     }
 }

        /// <summary>
        /// Are the given scopes the same?
        /// </summary>
        public static bool AreSame(this IMetadataScope x, IMetadataScope y)
        {
            // Both null?
            if ((x == null) && (y == null)) { return true; }

            // One null, other not null
            if ((x == null) || (y == null)) { return false; }

            var nx = GetName(x);
            var ny = GetName(y);

            return (nx == ny);
        }

        static AssemblyNameReference GetAssemblyNameReference(IMetadataScope scope)
        {
            AssemblyNameReference reference;
            if (scope is ModuleDefinition)
            {
                AssemblyDefinition asm = ((ModuleDefinition)scope).Assembly;
                reference = asm.Name;
            }
            else
                reference = (AssemblyNameReference)scope;

            return reference;
        }

        IMetadataScope ImportScope(IMetadataScope scope)
        {
            switch (scope.MetadataScopeType)
            {
                case MetadataScopeType.AssemblyNameReference:
                    return ImportAssemblyName((AssemblyNameReference)scope);
                case MetadataScopeType.ModuleDefinition:
                    return ImportAssemblyName(((ModuleDefinition)scope).Assembly.Name);
                case MetadataScopeType.ModuleReference:
                    throw new NotImplementedException();
            }

            throw new NotSupportedException();
        }

 public IMetadataScope GetLoggerAdapterMetadataScope()
 {
     if (_loggerScope == null)
     {
         //Check if reference to adapter assembly is present. If not, add it (we only look for the name, we assume that different versions are backward compatible)
         var loggerReference = _moduleDefinition.AssemblyReferences.FirstOrDefault(assRef => assRef.Name.Equals(_configuration.AssemblyNameReference.Name));
         if (loggerReference == null)
         {
             loggerReference = _configuration.AssemblyNameReference;
             _moduleDefinition.AssemblyReferences.Add(loggerReference);
         }
         _loggerScope = loggerReference;
     }
     return _loggerScope;
 }

        internal TypeReference Import(ModuleDefinition module, IMetadataScope scope, IInjector injector)
        {
            var reference = new TypeReference(
                ParentType == null ? Attr.Namespace : "",
                InjecteeType.Name,
                module,
                module.ImportScope(injector.MapMetadataScope(scope)),
                InjecteeType.IsValueType);

            MetadataSystem.TryProcessPrimitiveTypeReference(reference);

            if (ParentType != null)
            {
                var declDef = module.FindMatchingType(ParentType, true);
                reference.DeclaringType = CreateDeclRef(declDef, module, injector);
            }

            if (InjecteeType.ContainsGenericParameters)
                CecilHelpers.ImportGenericParameters(reference, InjecteeType);

            return reference;
        }

        public ITypeContainer Resolve(IMetadataScope scope)
        {
            AssemblyNameReference assemblyName = scope as AssemblyNameReference;

            if (assemblyName != null)
            {
                var assembly = Assembly.Load(new AssemblyName(assemblyName.FullName));
                return new AssemblyTypeContainer(assembly);
            }

            ModuleDefinition moduleDefinition = scope as ModuleDefinition;

            if (moduleDefinition != null)
            {
                if (moduleDefinition.Assembly != null)
                {
                    var assembly = Assembly.Load(new AssemblyName(moduleDefinition.Assembly.FullName));
                    return new AssemblyTypeContainer(assembly);
                }
            }

            throw new NotImplementedException();
        }

 public MemberNode(string member, IMetadataScope scope, MessageTypes type)
 {
     this.member = member;
     this.scope = scope;
     this.type = type;
     Text = member;
     // Cells.Add(new Cell((scope != null) ? scope.ToString() : ""));
 }

		public TypeReference (string name, string ns, IMetadataScope scope, bool valueType) :
			this (name, ns, scope)
		{
			m_isValueType = valueType;
		}

		internal void AttachToScope (IMetadataScope scope)
		{
			m_scope = scope;
		}