int GetByRefParamCount(CallableSignature signature) { int count = 0; foreach (IParameter param in signature.Parameters) { if (param.IsByRef) ++count; } return count; }
public CallableSignature GetSignature() { if (null == _signature) { IMethod invoke = GetInvokeMethod(); if (null == invoke) return null; _signature = invoke.CallableType.GetSignature(); } return _signature; }
override public bool Equals(object other) { CallableSignature rhs = other as CallableSignature; if (null == rhs || _returnType != rhs._returnType || _acceptVarArgs != rhs._acceptVarArgs) { return(false); } return(AreSameParameters(_parameters, rhs._parameters)); }
internal AnonymousCallableType(TypeSystemServices services, CallableSignature signature) { if (null == services) { throw new ArgumentNullException("services"); } if (null == signature) { throw new ArgumentNullException("signature"); } _typeSystemServices = services; _signature = signature; }
public CallableSignature GetSignature() { if (null == _signature) { IMethod invoke = GetInvokeMethod(); if (null == invoke) { return(null); } _signature = invoke.CallableType.GetSignature(); } return(_signature); }
public CallableSignature GetSignature() { if (_signature == null) { CallableSignature definitionSignature = ((ICallableType)_definition).GetSignature(); IParameter[] parameters = GenericMapping.Map(definitionSignature.Parameters); IType returnType = GenericMapping.Map(definitionSignature.ReturnType); _signature = new CallableSignature(parameters, returnType); } return _signature; }
public CallableSignature GetSignature() { if (_signature == null) { CallableSignature definitionSignature = ((ICallableType)_definition).GetSignature(); IParameter[] parameters = GenericMapping.Map(definitionSignature.Parameters); IType returnType = GenericMapping.Map(definitionSignature.ReturnType); _signature = new CallableSignature(parameters, returnType); } return(_signature); }
public CallableSignature GetSignature() { if (_signature == null) { CallableSignature definitionSignature = _definition.GetSignature(); IParameter[] parameters = Array.ConvertAll <IParameter, IParameter>( definitionSignature.Parameters, delegate(IParameter p) { return(new MappedParameter(_typeSystemServices, (ExternalParameter)p, this)); }); _signature = new CallableSignature(parameters, MapType(definitionSignature.ReturnType)); } return(_signature); }
public bool IsCallableTypeAssignableFrom(ICallableType lhs, IType rhs) { if (lhs == rhs || Null.Default == rhs) { return(true); } ICallableType other = rhs as ICallableType; if (null != other) { 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) { for (int i = 0; i < rparams.Length; ++i) { IType lparamType = lparams[i].Type; IType rparamType = rparams[i].Type; if (!AreTypesRelated(lparamType, rparamType)) { return(false); } } if (VoidType != lvalue.ReturnType && VoidType != rvalue.ReturnType) { return(AreTypesRelated(lvalue.ReturnType, rvalue.ReturnType)); } return(true); } } return(false); }
public bool IsCallableTypeAssignableFrom(ICallableType lhs, IType rhs) { if (lhs == rhs) { return(true); } if (rhs.IsNull()) { 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)); }
public virtual void VisitCallableType(ICallableType callableType) { if (_inCallableTypes.Contains(callableType)) { return; } _inCallableTypes.Push(callableType); try { CallableSignature sig = callableType.GetSignature(); foreach (IParameter parameter in sig.Parameters) { Visit(parameter.Type); } Visit(sig.ReturnType); } finally { _inCallableTypes.Pop(); } }
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 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(UpCastScore); } for (int i = 0; i < siggyType.Parameters.Length; i++) { if (siggyType.Parameters[i].Type != siggyArg.Parameters[i].Type) { // In the case that these parameters simply don't match if (!siggyType.Parameters[i].Type.IsAssignableFrom(siggyArg.Parameters[i].Type)) { return(ImplicitConversionScore); } return(UpCastScore); } } return(ExactMatchScore); }
public ICallableType GetCallableType(IMethodBase method) { var signature = new CallableSignature(method); return GetCallableType(signature); }
private IType[] GetParameterTypes(CallableSignature signature) { return Array.ConvertAll<IParameter, IType>( signature.Parameters, delegate(IParameter p) { return p.Type; }); }
/// <summary> /// Maps a type involving generic parameters to the corresponding type after substituting concrete /// arguments for generic parameters. /// </summary> /// <remarks> /// If the source type is a generic parameter, it is mapped to the corresponding argument. /// If the source type is an open generic type using any of the specified generic parameters, it /// is mapped to a closed constructed type based on the specified arguments. /// TODO: complete this /// </remarks> public IType MapType(IType sourceType) { if (sourceType == null) { return(null); } // If sourceType is a reference type, map its element type if (sourceType.IsByRef) { return(MapType(sourceType.GetElementType())); } // Map generic parameter to corresponding argument IGenericParameter gp = sourceType as IGenericParameter; if (null != gp && _map.ContainsKey(gp)) { return(_map[gp]); } // Map open constructed type using generic parameters to closed constructed type // using corresponding arguments if (null != sourceType.GenericTypeInfo) { IType[] mappedArguments = Array.ConvertAll <IType, IType>( sourceType.GenericTypeInfo.GenericArguments, MapType); IType mapped = sourceType.GenericTypeInfo. GenericDefinition.GenericTypeDefinitionInfo. MakeGenericType(mappedArguments); return(mapped); } // Map array types IArrayType array = (sourceType as IArrayType); if (array != null) { IType elementType = array.GetElementType(); IType mappedElementType = MapType(elementType); if (mappedElementType != elementType) { return(_tss.GetArrayType(mappedElementType, array.GetArrayRank())); } } // Map callable types ICallableType callable = sourceType as ICallableType; if (callable != null) { CallableSignature signature = callable.GetSignature(); IType returnType = MapType(signature.ReturnType); IParameter[] parameters = Array.ConvertAll <IParameter, IParameter>( signature.Parameters, delegate(IParameter p) { return(new MappedParameter(_tss, (ExternalParameter)p, this)); }); CallableSignature mappedSignature = new CallableSignature( parameters, returnType, signature.AcceptVarArgs); return(_tss.GetCallableType(mappedSignature)); } // If source type doesn't require mapping, return it as is return(sourceType); }
public virtual IType GetConcreteCallableType(Node sourceNode, CallableSignature signature) { return(_anonymousCallablesManager.GetConcreteCallableType(sourceNode, signature)); }
public static bool CheckOverrideSignature(IParameter[] implParameters, IParameter[] baseParameters) { return(CallableSignature.AreSameParameters(implParameters, baseParameters)); }
private bool CompatibleReturnTypes(CallableSignature lvalue, CallableSignature rvalue) { if (VoidType != lvalue.ReturnType && VoidType != rvalue.ReturnType) return CanBeReachedFrom(lvalue.ReturnType, rvalue.ReturnType); return true; }
public ICallableType GetCallableType(IMethodBase method) { var signature = new CallableSignature(method); return(GetCallableType(signature)); }
public AnonymousCallableType GetCallableType(IMethod method) { CallableSignature signature = new CallableSignature(method); return(GetCallableType(signature)); }
public AnonymousCallableType GetCallableType(CallableSignature signature) { AnonymousCallableType type = GetCachedCallableType(signature); if (type == null) { type = new AnonymousCallableType(TypeSystemServices, signature); _cache.Add(signature, type); } return type; }
public IType GetConcreteCallableType(Node sourceNode, CallableSignature signature) { AnonymousCallableType type = GetCallableType(signature); return(GetConcreteCallableType(sourceNode, type)); }
/// <summary> /// Maps a type involving generic parameters to the corresponding type after substituting concrete /// arguments for generic parameters. /// </summary> /// <remarks> /// If the source type is a generic parameter, it is mapped to the corresponding argument. /// If the source type is an open generic type using any of the specified generic parameters, it /// is mapped to a closed constructed type based on the specified arguments. /// </remarks> protected virtual IType MapType(IType sourceType) { if (sourceType == null) { return(null); } // Strip reference types if (sourceType.IsByRef) { return(MapType(sourceType.GetElementType())); } // Map generic parameter to corresponding argument IGenericParameter gp = sourceType as IGenericParameter; if (null != gp && _map.ContainsKey(gp)) { return(_map[gp]); } // Map open constructed type using generic parameters to closed constructed type // using corresponding arguments if (null != sourceType.ConstructedInfo) { IType[] mappedArguments = Array.ConvertAll <IType, IType>( sourceType.ConstructedInfo.GenericArguments, MapType); IType mapped = sourceType.ConstructedInfo. GenericDefinition.GenericInfo. ConstructType(mappedArguments); return(mapped); } // TODO: Map nested types // GenericType[of T].NestedType => GenericType[of int].NestedType // Map array types IArrayType array = (sourceType as IArrayType); if (array != null) { IType elementType = array.GetElementType(); IType mappedElementType = MapType(elementType); if (mappedElementType != elementType) { return(_tss.GetArrayType(mappedElementType, array.GetArrayRank())); } } // Map callable types ICallableType callable = sourceType as ICallableType; if (callable != null) { CallableSignature signature = callable.GetSignature(); IType returnType = MapType(signature.ReturnType); IParameter[] parameters = Map(signature.Parameters); CallableSignature mappedSignature = new CallableSignature( parameters, returnType, signature.AcceptVarArgs); return(_tss.GetCallableType(mappedSignature)); } // If source type doesn't require mapping, return it as is return(sourceType); }
public AnonymousCallableType GetCallableType(IMethod method) { CallableSignature signature = new CallableSignature(method); return GetCallableType(signature); }
private bool CompatibleReturnTypes(CallableSignature lvalue, CallableSignature rvalue) { if (VoidType != lvalue.ReturnType && VoidType != rvalue.ReturnType) { return AreTypesRelated(lvalue.ReturnType, rvalue.ReturnType); } return true; }
private void InitializeDependencies(IGenericParameter[] genericParameters, CallableSignature signature) { IType[] parameterTypes = GetParameterTypes(signature); foreach (IType parameterType in parameterTypes) { ICallableType callableParameterType = parameterType as ICallableType; if (callableParameterType == null) continue; CalculateDependencies(callableParameterType.GetSignature()); } }
public ICallableType GetCallableType(CallableSignature signature) { return _anonymousCallablesManager.GetCallableType(signature); }
void ImplementRegularICallableCall( Method call, InternalCallableType type, ClassDefinition node, CallableSignature signature) { MethodInvocationExpression mie = CreateInvokeInvocation(type); IParameter[] parameters = signature.Parameters; int fixedParametersLength = signature.AcceptVarArgs ? parameters.Length - 1 : parameters.Length; for (int i=0; i<fixedParametersLength; ++i) { SlicingExpression slice = CodeBuilder.CreateSlicing( CodeBuilder.CreateReference(call.Parameters[0]), i); mie.Arguments.Add(slice); } if (signature.AcceptVarArgs) { if (parameters.Length == 1) { mie.Arguments.Add(CodeBuilder.CreateReference(call.Parameters[0])); } else { mie.Arguments.Add( CodeBuilder.CreateMethodInvocation( RuntimeServices_GetRange1, CodeBuilder.CreateReference(call.Parameters[0]), CodeBuilder.CreateIntegerLiteral(fixedParametersLength))); } } if (TypeSystemServices.VoidType == signature.ReturnType) { call.Body.Add(mie); } else { call.Body.Add(new ReturnStatement(mie)); } }
public virtual IType GetConcreteCallableType(Node sourceNode, CallableSignature signature) { return _anonymousCallablesManager.GetConcreteCallableType(sourceNode, signature); }
void ImplementByRefICallableCall( Method call, InternalCallableType type, ClassDefinition node, CallableSignature signature, int byRefCount) { MethodInvocationExpression mie = CreateInvokeInvocation(type); IParameter[] parameters = signature.Parameters; ReferenceExpression args = CodeBuilder.CreateReference(call.Parameters[0]); InternalLocal[] temporaries = new InternalLocal[byRefCount]; int byRefIndex = 0; for (int i=0; i<parameters.Length; ++i) { SlicingExpression slice = CodeBuilder.CreateSlicing(args.CloneNode(), i); IParameter parameter = parameters[i]; if (parameter.IsByRef) { IType tempType = parameter.Type; if (tempType.IsByRef) { tempType = tempType.ElementType; } temporaries[byRefIndex] = CodeBuilder.DeclareLocal(call, "__temp_" + parameter.Name, tempType); call.Body.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateReference(temporaries[byRefIndex]), CodeBuilder.CreateCast( tempType, slice))); mie.Arguments.Add( CodeBuilder.CreateReference( temporaries[byRefIndex])); ++byRefIndex; } else { mie.Arguments.Add(slice); } } if (TypeSystemServices.VoidType == signature.ReturnType) { call.Body.Add(mie); PropagateByRefParameterChanges(call, parameters, temporaries); } else { InternalLocal invokeReturnValue = CodeBuilder.DeclareLocal(call, "__returnValue", signature.ReturnType); call.Body.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateReference(invokeReturnValue), mie)); PropagateByRefParameterChanges(call, parameters, temporaries); call.Body.Add( new ReturnStatement( CodeBuilder.CreateReference(invokeReturnValue))); } }
private AnonymousCallableType GetCachedCallableType(CallableSignature signature) { AnonymousCallableType result = null; _cache.TryGetValue(signature, out result); return result; }
/// <summary> /// Maps a type involving generic parameters to the corresponding type after substituting concrete /// arguments for generic parameters. /// </summary> /// <remarks> /// If the source type is a generic parameter, it is mapped to the corresponding argument. /// If the source type is an open generic type using any of the specified generic parameters, it /// is mapped to a closed constructed type based on the specified arguments. /// </remarks> protected virtual IType MapType(IType sourceType) { if (sourceType == null) { return null; } // Strip reference types if (sourceType.IsByRef) { return MapType(sourceType.GetElementType()); } // Map generic parameter to corresponding argument IGenericParameter gp = sourceType as IGenericParameter; if (null != gp && _map.ContainsKey(gp)) { return _map[gp]; } // Map open constructed type using generic parameters to closed constructed type // using corresponding arguments if (null != sourceType.ConstructedInfo) { IType[] mappedArguments = Array.ConvertAll<IType, IType>( sourceType.ConstructedInfo.GenericArguments, MapType); IType mapped = sourceType.ConstructedInfo. GenericDefinition.GenericInfo. ConstructType(mappedArguments); return mapped; } // TODO: Map nested types // GenericType[of T].NestedType => GenericType[of int].NestedType // Map array types IArrayType array = (sourceType as IArrayType); if (array != null) { IType elementType = array.GetElementType(); IType mappedElementType = MapType(elementType); if (mappedElementType != elementType) { return _tss.GetArrayType(mappedElementType, array.GetArrayRank()); } } // Map callable types ICallableType callable = sourceType as ICallableType; if (callable != null && EntityNeedsMapping(callable)) { CallableSignature signature = callable.GetSignature(); IType returnType = MapType(signature.ReturnType); IParameter[] parameters = Map(signature.Parameters); CallableSignature mappedSignature = new CallableSignature( parameters, returnType, signature.AcceptVarArgs); return _tss.GetCallableType(mappedSignature); } // If source type doesn't require mapping, return it as is return sourceType; }
public ICallableType GetCallableType(CallableSignature signature) { return(_anonymousCallablesManager.GetCallableType(signature)); }
Method CreateInvokeMethod(AnonymousCallableType anonymousType) { CallableSignature signature = anonymousType.GetSignature(); return(CodeBuilder.CreateRuntimeMethod("Invoke", signature.ReturnType, signature.Parameters, signature.AcceptVarArgs)); }
public IType GetConcreteCallableType(Node sourceNode, CallableSignature signature) { AnonymousCallableType type = GetCallableType(signature); return GetConcreteCallableType(sourceNode, type); }
public IType GetConcreteCallableType(Node sourceNode, CallableSignature signature) { var type = GetCallableType(signature); var anonymous = type as AnonymousCallableType; return anonymous != null ? GetConcreteCallableType(sourceNode, anonymous) : type; }
public static CompilerWarning InvalidEventUnsubscribe(Node node, string eventName, CallableSignature expected) { return new CompilerWarning("BCW0005", AstUtil.SafeLexicalInfo(node), eventName, expected); }
private void CalculateDependencies(CallableSignature signature) { foreach (IType inputType in GetParameterTypes(signature)) { CalculateDependencies(inputType, signature.ReturnType); } }