C# ICallableType类代码示例

		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);
 }