BooClassBuilder CreateClosureClass(ForeignReferenceCollector collector, InternalMethod closure)
		{
			Method method = closure.Method;
			TypeDefinition parent = method.DeclaringType;
			parent.Members.Remove(method);
			
			BooClassBuilder builder = collector.CreateSkeletonClass(closure.Name, method.LexicalInfo);
			parent.Members.Add(builder.ClassDefinition);
			builder.ClassDefinition.Members.Add(method);
			method.Name = "Invoke";
			
			if (method.IsStatic)
			{
				// need to adjust paremeter indexes (parameter 0 is now self)
				foreach (ParameterDeclaration parameter in method.Parameters)
				{
					((InternalParameter)parameter.Entity).Index += 1;
				}
			}
			
			method.Modifiers = TypeMemberModifiers.Public;
			var coll = new GenericTypeCollector(CodeBuilder);
			coll.Process(builder.ClassDefinition);
			return builder;
		}

		IType InferGeneratorItemTypeFor(InternalMethod generator)
		{
			if (TypeSystemServices.IsGenericGeneratorReturnType(generator.ReturnType))
				return generator.ReturnType.ConstructedInfo.GenericArguments[0];

			var yieldExpressions = generator.YieldExpressions;
			return yieldExpressions.Count > 0
				? TypeSystemServices.GetMostGenericType(yieldExpressions)
				: TypeSystemServices.ObjectType;
		}

 public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
 {
     _labels = new List();
     _mapping = new Hashtable();
     _generator = method;
     _generatorItemType = (IType)_generator.Method["GeneratorItemType"];
     _enumerable = (BooClassBuilder)_generator.Method["GeneratorClassBuilder"];
     Debug.Assert(null != _generatorItemType);
     Debug.Assert(null != _enumerable);
     Initialize(context);
 }

		public override void Initialize(CompilerContext context)
		{
			base.Initialize(context);

			_currentModule = null;
			_currentMethod = null;
			_methodStack = new Stack<InternalMethod>();
			_memberStack = new Stack();
			_callableResolutionService = new EnvironmentProvision<CallableResolutionService>();
			_invocationTypeReferenceRules = new EnvironmentProvision<InvocationTypeInferenceRules>();
			_typeChecker = new EnvironmentProvision<TypeChecker>();
			_methodCache = new EnvironmentProvision<RuntimeMethodCache>();
		}

		public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
		{
			_labels = new List<LabelStatement>();
			_mapping = new Hashtable();
			_generator = method;

			var skeleton = My<GeneratorSkeletonBuilder>.Instance.SkeletonFor(method);
			_generatorItemType = skeleton.GeneratorItemType;
			_enumerable = skeleton.GeneratorClassBuilder;
			_getEnumeratorBuilder = skeleton.GetEnumeratorBuilder;

			Initialize(context);
		}

        public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
        {
            _labels = new List();
            _mapping = new Hashtable();
            _generator = method;

            GeneratorSkeleton skeleton = context.Provide<GeneratorSkeletonBuilder>().SkeletonFor(method);
            _generatorItemType = skeleton.GeneratorItemType;
            _enumerable = skeleton.GeneratorClassBuilder;
            _getEnumeratorBuilder = skeleton.GetEnumeratorBuilder;

            Initialize(context);
        }

        void TryToResolveReturnType(InternalMethod entity)
        {
            if (entity.IsGenerator)
            {
                ResolveGeneratorReturnType(entity);
                return;
            }

            if (CanResolveReturnType(entity))
                ResolveReturnType(entity);
        }

 void ResolveReturnType(InternalMethod entity)
 {
     var method = entity.Method;
     method.ReturnType = entity.ReturnExpressions == null
         ? CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType)
         : GetMostGenericTypeReference(entity.ReturnExpressions);
     TraceReturnType(method, entity);
 }

 void ResolveGeneratorReturnType(InternalMethod entity)
 {
     IType returnType = GetGeneratorReturnType(entity);
     entity.Method.ReturnType = CodeBuilder.CreateTypeReference(returnType);
 }

 void ProcessNodeInMethodContext(InternalMethod entity, INamespace ns, Node node)
 {
     PushMethodInfo(entity);
     EnterNamespace(ns);
     try
     {
         Visit(node);
     }
     finally
     {
         LeaveNamespace();
         PopMethodInfo();
     }
 }

 void ProcessMethodBody(InternalMethod entity, INamespace ns)
 {
     ProcessNodeInMethodContext(entity, ns, entity.Method.Body);
 }

 static bool CanResolveReturnType(InternalMethod method)
 {
     var expressions = method.ReturnExpressions;
     if (null != expressions)
     {
         foreach (var expression in expressions)
         {
             IType type = expression.ExpressionType;
             if (type == null || TypeSystemServices.IsUnknown(type))
                 return false;
         }
     }
     return true;
 }

        /// <summary>
        /// Allows a different language to use custom rules for generator
        /// return types.
        /// </summary>
        /// <param name="generator"></param>
        /// <returns></returns>
        protected virtual IType GetGeneratorReturnType(InternalMethod generator)
        {
            // Make method return a generic IEnumerable
            IType itemType = GeneratorItemTypeFor(generator);
            if (TypeSystemServices.VoidType == itemType)
                // circunvent exception in MakeGenericType
                return TypeSystemServices.ErrorEntity;

            IType enumerableType = TypeSystemServices.IEnumerableGenericType;
            return enumerableType.GenericInfo.ConstructType(itemType);
        }

 private string GetMostSimilarBaseMethodName(InternalMethod entity)
 {
     return NameResolutionService.GetMostSimilarMemberName(entity.DeclaringType.BaseType, entity.Name, EntityType.Method);
 }

 private void MethodHidesInheritedNonVirtual(InternalMethod hidingMethod, IMethod hiddenMethod)
 {
     Warnings.Add(CompilerWarningFactory.MethodHidesInheritedNonVirtual(hidingMethod.Method, hidingMethod, hiddenMethod));
 }

        private static IMethod FindMethodOverridenBy(InternalMethod entity, IEntity candidates)
        {
            if (EntityType.Method == candidates.EntityType)
            {
                var candidate = (IMethod)candidates;
                if (TypeSystemServices.CheckOverrideSignature(entity, candidate))
                    return candidate;
            }

            if (EntityType.Ambiguous == candidates.EntityType)
                foreach (IMethod candidate in ((Ambiguous) candidates).Entities)
                    if (TypeSystemServices.CheckOverrideSignature(entity, candidate))
                        return candidate;

            return null;
        }

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

        void ProcessMethodOverride(InternalMethod entity, IMethod baseMethod)
        {
            CallableSignature baseSignature = TypeSystemServices.GetOverriddenSignature(baseMethod, entity);

            if (TypeSystemServices.IsUnknown(entity.ReturnType))
            {
                entity.Method.ReturnType = CodeBuilder.CreateTypeReference(entity.Method.LexicalInfo, baseSignature.ReturnType);
            }
            else if (baseSignature.ReturnType != entity.ReturnType)
            {
                Error(CompilerErrorFactory.InvalidOverrideReturnType(
                    entity.Method.ReturnType,
                    baseMethod,
                    baseMethod.ReturnType,
                    entity.ReturnType));
            }
            SetOverride(entity, baseMethod);
        }

        void CheckGeneratorCantReturnValues(InternalMethod entity)
        {
            if (!entity.IsGenerator) return;
            if (null == entity.ReturnExpressions) return;

            foreach (Expression e in entity.ReturnExpressions)
            {
                Error(CompilerErrorFactory.GeneratorCantReturnValue(e));
            }
        }

        void PushMethodInfo(InternalMethod entity)
        {
            _methodStack.Push(_currentMethod);

            _currentMethod = entity;
        }