private static TypeReference LiftGenericTypeDefinition(TypeDefinition node)
		{
			var typeRef = new GenericTypeReference(node.LexicalInfo, node.QualifiedName);
			foreach (GenericParameterDeclaration parameter in node.GenericParameters)
				typeRef.GenericArguments.Add(Lift(parameter.Name));
			return typeRef;
		}

		void LeaveTypeDefinition(TypeDefinition node)
		{
			if (!node.IsVisibilitySet)
				node.Modifiers |= Context.Parameters.DefaultTypeVisibility;

			node.Name = NormalizeName(node.Name);
		}

		private void OnCandidatePartialDefinition(TypeDefinition node)
		{
			if (!node.IsPartial)
				return;

			var typeName = node.FullName;

			TypeDefinition originalDefinition;
			if (_partials.TryGetValue(typeName, out originalDefinition))
			{
				if (node == originalDefinition) // MergePartialTypes can be executed more than once
					return;

				if (originalDefinition.NodeType != node.NodeType)
				{
					Errors.Add(CompilerErrorFactory.IncompatiblePartialDefinition(node, typeName, AstUtil.TypeKeywordFor(originalDefinition), AstUtil.TypeKeywordFor(node)));
					return;
				}

				MergeImports(node, originalDefinition);
				originalDefinition.Merge(node);
				RemoveCurrentNode();
			}
			else
				_partials[typeName] = node;
		}

        //use this to build a type member name unique in the inheritance hierarchy.
        public static string BuildUniqueTypeMemberName(TypeDefinition type, string name)
        {
            if (string.IsNullOrEmpty(name))
                throw new ArgumentNullException("name");

            StringBuilder nameBuilder = new StringBuilder("$");
            nameBuilder.Append(name);
            nameBuilder.Append("__");
            nameBuilder.Append(type.QualifiedName);
            if (type.HasGenericParameters)
            {
                nameBuilder.Append("_");
                string[] parameterNames = Array.ConvertAll<GenericParameterDeclaration, string>(
                    type.GenericParameters.ToArray(),
                    delegate(GenericParameterDeclaration gpd) { return gpd.Name; });
                foreach (string parameterName in parameterNames)
                {
                    nameBuilder.Append("_");
                    nameBuilder.Append(parameterName);
                }
            }
            nameBuilder.Replace('.', '_');
            nameBuilder.Append("$");
            return nameBuilder.ToString();
        }

		void EnterTypeDefinition(TypeDefinition node)
		{
			List<Field> list = new List<Field>();
			fieldStack.Push(list);
			foreach (TypeMember member in node.Members) {
				if (member is Field)
					list.Add((Field)member);
			}
		}

        public static void BindMembers(string cacheName,TypeDefinition type){
            if (!cache.ContainsKey(cacheName)) return;
            foreach (var member in cache[cacheName]){ 
                type.Members.Add(member);
            }
            cache.Remove(cacheName);

            new Method().Parameters.Add(new ParameterDeclaration("name",new SimpleTypeReference("string")));
        }

		private void OnTypeDefinition(TypeDefinition node)
		{
			var old = _currentType;
			_currentType = (IType)node.Entity;
			Visit(node.Attributes);
			Visit(node.BaseTypes);
			Visit(node.Members);
			Visit(node.GenericParameters);
			_currentType = old;
		}

        public InternalGenericParameter(TypeSystemServices tss, GenericParameterDeclaration declaration)
        {
            _tss = tss;
            _declaration = declaration;

            // Determine and remember declaring type and declaring method (if applicable)
            _declaringMethod = declaration.ParentNode as Method;
            _declaringType = (
                _declaringMethod == null ?
                declaration.ParentNode as TypeDefinition : _declaringMethod.DeclaringType);
        }

 protected override void ExtendBaseClass(TypeDefinition definition)
 {
     Property property = new Property("Environment");
     property.Getter = new Method("getter_Environment");
     property.Getter.Body.Add(
         new ReturnStatement(
             new StringLiteralExpression(environment ?? "")
             )
         );
     definition.Members.Add(property);
 }

		void CheckMembers(TypeDefinition node)
		{
			_members.Clear();
			
			foreach (TypeMember member in node.Members)
			{
				if (member.NodeType == NodeType.StatementTypeMember)
					continue;

				var list = GetMemberList(member.Name);
				CheckMember(list, member);
				list.Add(member);
			}
		}

        static void MergeImports(TypeDefinition from, TypeDefinition to)
        {
            Module fromModule = from.EnclosingModule;
            Module toModule = to.EnclosingModule;
            if (fromModule == toModule) return;
            if (toModule.ContainsAnnotation(fromModule)) return;

            toModule.Imports.ExtendWithClones(fromModule.Imports.Where(i => !toModule.Imports.Any(i2 => i.Matches(i2))));
            // annotate so we remember not to merge the imports
            // again in the future
            toModule.Annotate(fromModule);

            //annotate so that we know these modules have been merged
            //this is used by checkneverusedmembers step
            if (!fromModule.ContainsAnnotation("merged-module"))
                fromModule.Annotate("merged-module");
            if (!toModule.ContainsAnnotation("merged-module"))
                toModule.Annotate("merged-module");
        }

		override public void LeaveTypeDefinition(TypeDefinition node)
		{
			_safeVars.Clear(); //clear type var cache (CheckAmbiguousVariableNames)

			if (node.NodeType == NodeType.Module)
				return;

			string qualifiedName = node.QualifiedName;
			if (node.HasGenericParameters)
			{
				qualifiedName += "`" + node.GenericParameters.Count;
			}

			if (_types.ContainsKey(qualifiedName))
			{
				Errors.Add(CompilerErrorFactory.NamespaceAlreadyContainsMember(node, GetNamespace(node), node.Name));
				return;
			}
			_types.Add(qualifiedName, node); 
		}

		public BaseTypeResolution(CompilerContext context, TypeDefinition typeDefinition, List<TypeDefinition> visited) : base(context)
		{
			_typeDefinition = typeDefinition;
			_visited = visited;
			_visited.Add(_typeDefinition);

			_removed = 0;
			_index = -1;

			NameResolutionService nameResolution = NameResolutionService;
			INamespace previous = nameResolution.CurrentNamespace;
			nameResolution.EnterNamespace(ParentNamespaceOf(_typeDefinition));
			try
			{
				Run();
			}
			finally
			{
				nameResolution.EnterNamespace(previous);
			}
		}

		private void GenerateConstructors(TypeDefinition definition)
		{
			ConstructorInfo[] ctors =
				baseClass.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
			foreach (ConstructorInfo ctor in ctors)
			{
				if (ctor.IsPrivate)
					continue;
				Constructor constructor = new Constructor(definition.LexicalInfo);
				definition.Members.Add(constructor);
				MethodInvocationExpression super = new MethodInvocationExpression(new SuperLiteralExpression());
				constructor.Body.Add(super);
				foreach (ParameterInfo info in ctor.GetParameters())
				{
					SimpleTypeReference typeReference =
						new SimpleTypeReference(TypeUtilities.GetFullName(info.ParameterType));
					constructor.Parameters.Add(new ParameterDeclaration(info.Name,
																		typeReference)
						);
					super.Arguments.Add(new ReferenceExpression(info.Name));
				}
			}
		}

 Constructor GetStaticConstructor(TypeDefinition type)
 {
     return CodeBuilder.GetOrCreateStaticConstructorFor(type);
 }

 private Method GetInitializerFor(TypeDefinition type, bool isStatic)
 {
     string methodName = isStatic ? "$static_initializer$" : "$initializer$";
     Method method = (Method)type[methodName];
     if (null == method)
     {
         if (isStatic)
         {
             if (!type.HasStaticConstructor)
             {
                 // when the class doesnt have a static constructor
                 // yet, create one and use it as the static
                 // field initializer method
                 method = CodeBuilder.CreateStaticConstructor(type);
             }
             else
             {
                 method = CreateInitializerMethod(type, methodName, TypeMemberModifiers.Static);
                 AddInitializerToStaticConstructor(type, (InternalMethod)method.Entity);
             }
         }
         else
         {
             method = CreateInitializerMethod(type, methodName, TypeMemberModifiers.None);
         }
         type[methodName] = method;
     }
     return method;
 }

        private Field GetFieldsInitializerInitializedField(TypeDefinition type)
        {
            string name = AstUtil.BuildUniqueTypeMemberName(type, "initialized");
            Field field= (Field) type.Members[name];

            if (null == field)
            {
                field = CodeBuilder.CreateField(name, TypeSystemServices.BoolType);
                field.Visibility = TypeMemberModifiers.Private;
                type.Members.Add(field);
                MarkVisited(field);
            }
            return field;
        }

 Method CreateInitializerMethod(TypeDefinition type, string name, TypeMemberModifiers modifiers)
 {
     Method method = CodeBuilder.CreateMethod(name, TypeSystemServices.VoidType, modifiers);
     type.Members.Add(method);
     MarkVisited(method);
     return method;
 }

 void AddInitializerToStaticConstructor(TypeDefinition type, InternalMethod initializer)
 {
     GetStaticConstructor(type).Body.Insert(0,
                                            CodeBuilder.CreateMethodInvocation(initializer));
 }

        void AddInitializerToInstanceConstructors(TypeDefinition type, Method initializer)
        {
            int n = 0;

            //count number of non-static constructors
            foreach (TypeMember node in type.Members)
            {
                if (NodeType.Constructor == node.NodeType && !node.IsStatic)
                    n++;
            }

            //if there is more than one we need $initialized$ guard check
            if (n > 1)
                AddInitializedGuardToInitializer(type, initializer);

            foreach (TypeMember node in type.Members)
            {
                if (NodeType.Constructor == node.NodeType && !node.IsStatic)
                {
                    Constructor constructor = (Constructor) node;
                    n = GetIndexAfterSuperInvocation(constructor.Body);
                    foreach (Statement st in initializer.Body.Statements)
                    {
                        constructor.Body.Insert(n, (Statement) st.Clone());
                        n++;
                    }
                    foreach (Local loc in initializer.Locals)
                    {
                        constructor.Locals.Add(loc);
                    }
                }
            }
        }