C# ICallableType.GetSignature方法代码示例

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

        private void ProcessClosureInMethodInvocation(GenericParameterInferrer inferrer, BlockExpression closure, ICallableType formalType)
        {
            var sig = formalType.GetSignature();

            var replacer = new TypeReplacer();
            var collector = new TypeCollector(delegate(IType t)
            {
                IGenericParameter gp = t as IGenericParameter;
                if (gp == null) return false;
                return gp.DeclaringEntity == inferrer.GenericMethod;
            });

            collector.Visit(formalType);
            foreach (var typeParameter in collector.Matches)
            {
                var inferredType = inferrer.GetInferredType((IGenericParameter)typeParameter);
                if (inferredType != null)
                    replacer.Replace(typeParameter, inferredType);
            }

            for (var i = 0; i < sig.Parameters.Length; i++)
            {
                var pd = closure.Parameters[i];
                if (pd.Type != null) continue;
                pd.Type = CodeBuilder.CreateTypeReference(replacer.MapType(sig.Parameters[i].Type));
            }

            ProcessClosureBody(closure);
        }

        void BindNullableParameters(ExpressionCollection args, ICallableType target)
        {
            if (null == target)
                return;

            IParameter[] parameters = target.GetSignature().Parameters;
            for (int i = 0; i < parameters.Length; ++i) {
                if (!TypeSystemServices.IsNullable(parameters[i].Type))
                    continue;
                if (TypeSystemServices.IsNullable(GetExpressionType(args[i])))
                    continue; //already nullable
                args.Replace(args[i], CreateNullableInstantiation(args[i], parameters[i].Type));
                Visit(args[i]);
            }
        }

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

 bool AcceptVarArgs(ICallableType method)
 {
     return method.GetSignature().AcceptVarArgs;
 }

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

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

        ClassDefinition CreateAdaptor(ICallableType to, ICallableType from)
        {
            BooClassBuilder adaptor = CodeBuilder.CreateClass("$adaptor$" + from.Name + "$" + to.Name + "$" + _adaptors.Count);
            adaptor.AddBaseType(TypeSystemServices.ObjectType);
            adaptor.Modifiers = TypeMemberModifiers.Final|TypeMemberModifiers.Internal;

            Field callable = adaptor.AddField("$from", from);

            BooMethodBuilder constructor = adaptor.AddConstructor();
            ParameterDeclaration param = constructor.AddParameter("from", from);
            constructor.Body.Add(
                CodeBuilder.CreateSuperConstructorInvocation(TypeSystemServices.ObjectType));
            constructor.Body.Add(
                CodeBuilder.CreateAssignment(
                    CodeBuilder.CreateReference(callable),
                    CodeBuilder.CreateReference(param)));

            CallableSignature signature = to.GetSignature();
            BooMethodBuilder invoke = adaptor.AddMethod("Invoke", signature.ReturnType);
            foreach (IParameter parameter in signature.Parameters)
            {
                invoke.AddParameter(parameter.Name, parameter.Type, parameter.IsByRef);
            }
            MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
                            CodeBuilder.CreateReference(callable),
                            GetInvokeMethod(from));
            int fromParameterCount = from.GetSignature().Parameters.Length;
            for (int i=0; i<fromParameterCount; ++i)
            {
                mie.Arguments.Add(
                    CodeBuilder.CreateReference(invoke.Parameters[i]));
            }
            if (signature.ReturnType != TypeSystemServices.VoidType &&
                from.GetSignature().ReturnType != TypeSystemServices.VoidType)
            {
                invoke.Body.Add(new ReturnStatement(mie));
            }
            else
            {
                invoke.Body.Add(mie);
            }

            BooMethodBuilder adapt = adaptor.AddMethod("Adapt", to);
            adapt.Modifiers = TypeMemberModifiers.Static|TypeMemberModifiers.Public;
            param = adapt.AddParameter("from", from);
            adapt.Body.Add(
                new ReturnStatement(
                    CodeBuilder.CreateConstructorInvocation(
                        to.GetConstructors().First(),
                        CodeBuilder.CreateConstructorInvocation(
                            (IConstructor)constructor.Entity,
                            CodeBuilder.CreateReference(param)),
                        CodeBuilder.CreateAddressOfExpression(invoke.Entity))));

            RegisterAdaptor(to, from, adaptor.ClassDefinition);

            return adaptor.ClassDefinition;
        }

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

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

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