public virtual void VisitCallableType(ICallableType callableType)
		{
			CallableSignature sig = callableType.GetSignature();
			foreach (IParameter parameter in sig.Parameters)
			{
				Visit(parameter.Type);
			}
			Visit(sig.ReturnType);
		}

        public Method CreateEndInvokeMethod(ICallableType anonymousType)
        {
            CallableSignature signature = anonymousType.GetSignature();
            Method method = CodeBuilder.CreateRuntimeMethod("EndInvoke", signature.ReturnType);

            int delta = 1;
            foreach (IParameter p in signature.Parameters)
            {
                if (p.IsByRef)
                {
                    method.Parameters.Add(
                        CodeBuilder.CreateParameterDeclaration(++delta,
                                p.Name,
                                p.Type,
                                true));
                }
            }
            delta = method.Parameters.Count;
            method.Parameters.Add(
                CodeBuilder.CreateParameterDeclaration(delta + 1, "result", TypeSystemServices.Map(typeof(IAsyncResult))));
            return method;
        }

        void ProcessCallableTypeInvocation(MethodInvocationExpression node, ICallableType type)
        {
            NamedArgumentsNotAllowed(node);

            if (node.Arguments.Count == 1)
            {
                AssertTypeCompatibility(node.Arguments[0], type, GetExpressionType(node.Arguments[0]));
                node.ParentNode.Replace(
                    node,
                    CodeBuilder.CreateCast(
                        type,
                        node.Arguments[0]));
            }
            else
            {
                IConstructor ctor = GetCorrectConstructor(node, type, node.Arguments);
                if (null != ctor)
                {
                    BindConstructorInvocation(node, ctor);
                }
                else
                {
                    Error(node);
                }
            }
        }

 bool AssertParameterTypes(ICallableType method, ExpressionCollection args, int count, bool reportErrors)
 {
     IParameter[] parameters = method.GetSignature().Parameters;
     for (int i=0; i<count; ++i)
     {
         IParameter param = parameters[i];
         IType parameterType = param.Type;
         IType argumentType = GetExpressionType(args[i]);
         if (param.IsByRef)
         {
             if (!(args[i] is ReferenceExpression
                 || args[i] is SlicingExpression
                 || (args[i] is SelfLiteralExpression && argumentType.IsValueType)))
             {
                 if (reportErrors)
                     Error(CompilerErrorFactory.RefArgTakesLValue(args[i]));
                 return false;
             }
             if (!CallableResolutionService.IsValidByRefArg(param, parameterType, argumentType, args[i]))
             {
                 return false;
             }
         }
         else
         {
             if (!CanBeReachedFrom(args[i], parameterType, argumentType))
                 return false;
         }
     }
     return true;
 }

        private void AddInferredClosureParameterTypes(BlockExpression node, ICallableType callableType)
        {
            IParameter[] parameters = (callableType == null ? null : callableType.GetSignature().Parameters);
            for (int i = 0; i < node.Parameters.Count; i++)
            {
                ParameterDeclaration pd = node.Parameters[i];
                if (pd.Type != null) continue;

                IType inferredType;
                if (parameters != null && i < parameters.Length)
                {
                    inferredType = parameters[i].Type;
                }
                else if (pd.IsParamArray)
                {
                    inferredType = TypeSystemServices.ObjectArrayType;
                }
                else
                {
                    inferredType = TypeSystemServices.ObjectType;
                }

                pd.Type = CodeBuilder.CreateTypeReference(inferredType);
            }
        }

 protected bool CheckVarArgsParameters(ICallableType method, ExpressionCollection args)
 {
     return CallableResolutionService.IsValidVargsInvocation(method.GetSignature().Parameters, args);
 }

 protected bool CheckExactArgsParameters(ICallableType method, ExpressionCollection args, bool reportErrors)
 {
     if (method.GetSignature().Parameters.Length != args.Count) return false;
     return AssertParameterTypes(method, args, args.Count, reportErrors);
 }

		private bool InferCallableType(ICallableType formalType, IType actualType, TypeInference inference)
		{
			ICallableType callableActualType = actualType as ICallableType;
			if (callableActualType == null) return false;

			CallableSignature formalSignature = formalType.GetSignature();
			CallableSignature actualSignature = callableActualType.GetSignature();

			if (formalSignature.AcceptVarArgs)
			{
				if (actualSignature.Parameters.Length < formalSignature.Parameters.Length)
					return false;
			}
			else if (formalSignature.Parameters.Length != actualSignature.Parameters.Length)
			{
				return false;
			}

			// Infer return type, maintaining inference direction
			if (!Infer(formalSignature.ReturnType, actualSignature.ReturnType, inference))
			{
				return false;
			}

			// Infer parameter types, inverting inference direction
			for (int i = 0; i < formalSignature.Parameters.Length; ++i)
			{
				bool inferenceSuccessful = Infer(
					formalSignature.Parameters[i].Type,
					actualSignature.Parameters[i].Type,
					Invert(inference));

				if (!inferenceSuccessful) return false;
			}
			return true;
		}

		public GenericConstructedCallableType(ICallableType definition, IType[] arguments) 
			: base(definition, arguments) 
		{
		}

		Method CreateBeginInvokeMethod(ICallableType anonymousType)
		{
			Method method = CodeBuilder.CreateRuntimeMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)),
															anonymousType.GetSignature().Parameters, false);

			int delta = method.Parameters.Count;
			method.Parameters.Add(
					CodeBuilder.CreateParameterDeclaration(delta + 1, "callback", TypeSystemServices.Map(typeof(AsyncCallback))));
			method.Parameters.Add(
					CodeBuilder.CreateParameterDeclaration(delta + 1, "asyncState", TypeSystemServices.ObjectType));
			return method;
		}

 ClassDefinition GetAdaptor(ICallableType to, ICallableType from)
 {
     ClassDefinition adaptor = FindAdaptor(to, from);
     if (null == adaptor)
         adaptor = CreateAdaptor(to, from);
     return adaptor;
 }

 private bool CheckParameters(ICallableType method, ExpressionCollection args, bool reportErrors)
 {
     return AcceptVarArgs(method)
         ? CheckVarArgsParameters(method, args)
         : CheckExactArgsParameters(method, args, reportErrors);
 }

        bool AssertParameters(Node sourceNode, IEntity sourceEntity, ICallableType method, ExpressionCollection args)
        {
            if (CheckParameters(method, args, true)) return true;

            Error(CompilerErrorFactory.MethodSignature(sourceNode, sourceEntity.ToString(), GetSignature(args)));
            return false;
        }

        private static int CalculateCallableScore(ICallableType parameterType, ICallableType argType)
        {
            // upcast
            // parameterType == ICallableType, "ThreadStart"
            // argumentType == ICallableType, "Anonymous Closure"
            // RULES:
            // Number of arguments for argumentType && parameterType == same
            // Either: all arguments "IsAssignableFrom"
            //			OR
            //			all arguments == exactly (best case scenario)
            // ExactMatch -- (best case)
            // UpCast -- "not exact match, but very close" (this is OK)
            // ImplicitConversion -- "assignable, but wrong number of parameters / whatever" (boo does the normal thing)

            CallableSignature siggyType = parameterType.GetSignature();
            CallableSignature siggyArg = argType.GetSignature();
            // Ensuring that these callables have same number of arguments.
            // def foo(a, b,c) == { a, b, c| print foobar }
            if (siggyType.Parameters.Length != siggyArg.Parameters.Length)
            {
                return CallableUpCastScore;
            }
            for (int i = 0; i < siggyType.Parameters.Length; i++)
            {
                if (siggyType.Parameters[i].Type != siggyArg.Parameters[i].Type)
                {
                    return CallableImplicitConversionScore;
                }
            }
            return siggyType.ReturnType == siggyArg.ReturnType
                ? CallableExactMatchScore : CallableUpCastScore;
        }

 void RegisterAdaptor(ICallableType to, ICallableType from, ClassDefinition adaptor)
 {
     _adaptors.Add(new AdaptorRecord(to, from, adaptor));
     TypeSystemServices.GetCompilerGeneratedTypesModule().Members.Add(adaptor);
 }

        void ProcessDelegateInvocation(MethodInvocationExpression node, ICallableType delegateType)
        {
            if (!AssertParameters(node.Target, delegateType, delegateType, node.Arguments))
            {
                Error(node);
                return;
            }

            var invoke = ResolveMethod(delegateType, "Invoke");
            node.Target = CodeBuilder.CreateMemberReference(node.Target, invoke);
            BindExpressionType(node, invoke.ReturnType);
        }

 public AdaptorRecord(ICallableType to, ICallableType from, ClassDefinition adaptor)
 {
     To = to;
     From = from;
     Adaptor = adaptor;
 }

		public bool IsCallableTypeAssignableFrom(ICallableType lhs, IType rhs)
		{
			if (lhs == rhs) return true;
			if (Null.Default == rhs) return true;

			var other = rhs as ICallableType;
			if (null == other) return false;

			CallableSignature lvalue = lhs.GetSignature();
			CallableSignature rvalue = other.GetSignature();
			if (lvalue == rvalue) return true;

			IParameter[] lparams = lvalue.Parameters;
			IParameter[] rparams = rvalue.Parameters;
			if (lparams.Length < rparams.Length) return false;

			for (int i = 0; i < rparams.Length; ++i)
				if (!CanBeReachedFrom(lparams[i].Type, rparams[i].Type))
					return false;

			return CompatibleReturnTypes(lvalue, rvalue);
		}

 private void InferInputTypesFromContextType(ICallableType type)
 {
     CallableSignature sig = type.GetSignature();
     for (int i = 0; i < Math.Min(ParameterTypes.Length, sig.Parameters.Length); i++)
     {
         if (ParameterTypes[i] != null) continue;
         ParameterTypes[i] = sig.Parameters[i].Type;
     }
 }

 Expression Adapt(ICallableType expected, Expression callable)
 {
     ICallableType actual = GetExpressionType(callable) as ICallableType;
     if (null == actual)
     {
         // TODO: should we adapt System.Object, System.Delegate,
         // System.MulticastDelegate and ICallable as well?
         return null;
     }
     ClassDefinition adaptor = GetAdaptor(expected, actual);
     Method adapt = (Method)adaptor.Members["Adapt"];
     return CodeBuilder.CreateMethodInvocation((IMethod)adapt.Entity, callable);
 }