public ParameterWrapper(ActionBinder binder, ParameterInfo info)
: this(binder, info.ParameterType) {
_name = SymbolTable.StringToId(info.Name ?? "<unknown>");
#if FULL
_prohibitNull = info.IsDefined(typeof(NotNullAttribute), false);
#endif
_isParams = info.IsDefined(typeof(ParamArrayAttribute), false);
#if FULL
_isParamsDict = info.IsDefined(typeof(ParamDictionaryAttribute), false);
#endif
}
public ParameterWrapper(ActionBinder binder, ParameterInfo info)
: this(binder, info.ParameterType)
{
_name = SymbolTable.StringToId(info.Name ?? "<unknown>");
_isParams = info.IsDefined(typeof(ParamArrayAttribute), false);
}
public override Expression/*!*/ ConvertExpression(Expression/*!*/ expr, ParameterInfo info, Type/*!*/ toType) {
Type fromType = expr.Type;
// block:
if (fromType == typeof(MissingBlockParam)) {
Debug.Assert(toType == typeof(BlockParam) || toType == typeof(MissingBlockParam));
return AstUtils.Constant(null);
}
if (fromType == typeof(BlockParam) && toType == typeof(MissingBlockParam)) {
return AstUtils.Constant(null);
}
// protocol conversions:
if (info != null && info.IsDefined(typeof(DefaultProtocolAttribute), false)) {
var action = RubyConversionAction.TryGetDefaultConversionAction(toType);
if (action != null) {
// TODO: once we work with MetaObjects, we could inline these dynamic sites:
return Ast.Dynamic(action, toType, ContextExpression, expr);
}
throw new InvalidOperationException(String.Format("No default protocol conversion for type {0}.", toType));
}
return Binder.ConvertExpression(expr, toType, ConversionResultKind.ExplicitCast, ScopeExpression);
}
public static Parameter FromParameterInfo(ParameterInfo parameterInfo) {
Parameter parameter = new Parameter();
parameter._name = parameterInfo.Name;
parameter._position = parameterInfo.Position;
parameter._parameterType = parameterInfo.ParameterType;
parameter._isParamArray = parameterInfo.IsDefined(typeof(ParamArrayAttribute), true);
return parameter;
}
private static void BuildParameter(ParameterBuilder builder, ParameterInfo parameter)
{
Debug.Assert(parameter != null);
Debug.Assert(builder != null);
builder.Name = parameter.Name;
builder.ParameterType = parameter.ParameterType;
builder.Position = parameter.Position;
builder.IsParamArray = parameter.IsDefined(typeof(ParamArrayAttribute), true);
//
// Build via attributes.
//
object[] attributes = parameter.GetCustomAttributes(typeof(IParameterReflector), true);
foreach (IParameterReflector reflector in attributes)
reflector.Build(builder, parameter);
}
public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (attributeType == null)
{
throw new ArgumentNullException("attributeType");
}
if (!attributeType.IsSubclassOf(typeof(Attribute)) && (attributeType != typeof(Attribute)))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
}
MemberTypes memberType = element.Member.MemberType;
if (memberType == MemberTypes.Constructor)
{
return element.IsDefined(attributeType, false);
}
if (memberType != MemberTypes.Method)
{
if (memberType != MemberTypes.Property)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParamInfo"));
}
return element.IsDefined(attributeType, false);
}
return InternalParamIsDefined(element, attributeType, inherit);
}
internal ServiceDependency InstantiateDependency(ParameterInfo formalParameter, ContainerService.Builder builder)
{
ValueWithType actualArgument;
if (builder.Arguments != null && builder.Arguments.TryGet(formalParameter.Name, out actualArgument))
return containerContext.Constant(formalParameter, actualArgument.value);
var parameters = builder.Configuration.ParametersSource;
object actualParameter;
if (parameters != null && parameters.TryGet(formalParameter.Name, formalParameter.ParameterType, out actualParameter))
return containerContext.Constant(formalParameter, actualParameter);
var dependencyConfiguration = builder.Configuration.GetOrNull(formalParameter);
Type implementationType = null;
if (dependencyConfiguration != null)
{
if (dependencyConfiguration.ValueAssigned)
return containerContext.Constant(formalParameter, dependencyConfiguration.Value);
if (dependencyConfiguration.Factory != null)
{
var dependencyBuilder = new ContainerService.Builder(new ServiceName(formalParameter.ParameterType))
{
Context = builder.Context,
DependencyName = formalParameter.Name
};
builder.Context.Stack.Add(dependencyBuilder);
dependencyBuilder.CreateInstanceBy(CallTarget.F(dependencyConfiguration.Factory), true);
builder.Context.Stack.RemoveLast();
return dependencyBuilder.GetService().AsDependency(containerContext, formalParameter.Name, false);
}
implementationType = dependencyConfiguration.ImplementationType;
}
implementationType = implementationType ?? formalParameter.ParameterType;
FromResourceAttribute resourceAttribute;
if (implementationType == typeof (Stream) && formalParameter.TryGetCustomAttribute(out resourceAttribute))
{
var resourceStream = builder.Type.Assembly.GetManifestResourceStream(builder.Type, resourceAttribute.Name);
if (resourceStream == null)
return containerContext.Error(null, formalParameter.Name,
"can't find resource [{0}] in namespace of [{1}], assembly [{2}]",
resourceAttribute.Name, builder.Type, builder.Type.Assembly.GetName().Name);
return containerContext.Resource(formalParameter, resourceAttribute.Name, resourceStream);
}
var dependencyName = ServiceName.Parse(implementationType.UnwrapEnumerable(),
InternalHelpers.ParseContracts(formalParameter));
if (dependencyName.Type.IsSimpleType())
{
if (!formalParameter.HasDefaultValue)
return containerContext.Error(null, formalParameter.Name,
"parameter [{0}] of service [{1}] is not configured",
formalParameter.Name, builder.Type.FormatName());
return containerContext.Constant(formalParameter, formalParameter.DefaultValue);
}
var resultService = ResolveCore(dependencyName, false, null, builder.Context);
if (resultService.Status.IsBad())
return containerContext.ServiceError(resultService);
var isEnumerable = dependencyName.Type != implementationType;
if (isEnumerable)
return containerContext.Service(resultService, resultService.GetAllValues());
if (resultService.Status == ServiceStatus.NotResolved)
{
if (formalParameter.HasDefaultValue)
return containerContext.Service(resultService, formalParameter.DefaultValue);
if (formalParameter.IsDefined<OptionalAttribute>() || formalParameter.IsDefined("CanBeNullAttribute"))
return containerContext.Service(resultService, null);
return containerContext.NotResolved(resultService);
}
return resultService.AsDependency(containerContext, null, false);
}
/// <summary>
/// 如果给定的参数信息是 params 参数，则返回对应的数组元素类型；否则为 <c>null</c>。
/// </summary>
/// <param name="parameter">参数信息。</param>
/// <returns>params 参数的元素类型。</returns>
internal static Type GetParamArrayType(ParameterInfo parameter)
{
if (parameter.ParameterType.IsArray && parameter.IsDefined(typeof(ParamArrayAttribute), true))
{
return parameter.ParameterType.GetElementType();
}
return null;
}
private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool inherit)
{
if (param.IsDefined(type, false))
{
return true;
}
if ((param.Member.DeclaringType != null) && inherit)
{
for (ParameterInfo info = GetParentDefinition(param); info != null; info = GetParentDefinition(info))
{
object[] customAttributes = info.GetCustomAttributes(type, false);
for (int i = 0; i < customAttributes.Length; i++)
{
AttributeUsageAttribute attributeUsage = InternalGetAttributeUsage(customAttributes[i].GetType());
if ((customAttributes[i] is Attribute) && attributeUsage.Inherited)
{
return true;
}
}
}
}
return false;
}
public static void CopyParameterAttributes(ParameterInfo from, ParameterBuilder to) {
if (from.IsDefined(typeof(ParamArrayAttribute), false)) {
to.SetCustomAttribute(new CustomAttributeBuilder(
typeof(ParamArrayAttribute).GetConstructor(Type.EmptyTypes), ArrayUtils.EmptyObjects)
);
} else if (from.IsDefined(typeof(ParamDictionaryAttribute), false)) {
to.SetCustomAttribute(new CustomAttributeBuilder(
typeof(ParamDictionaryAttribute).GetConstructor(Type.EmptyTypes), ArrayUtils.EmptyObjects)
);
}
if ((from.Attributes & ParameterAttributes.HasDefault) != 0) {
to.SetConstant(from.DefaultValue);
}
}
private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool inherit)
{
Contract.Requires(param != null);
Contract.Requires(type != null);
// For ParameterInfo's we need to make sure that we chain through all the MethodInfo's in the inheritance chain.
// We pick up all the CustomAttributes for the starting ParameterInfo. We need to pick up only attributes
// that are marked inherited from the remainder of the ParameterInfo's in the inheritance chain.
// For MethodInfo's on an interface we do not do an inheritance walk. For ParameterInfo's on a
// Class we walk up the inheritance chain but do not look at the MethodInfo's on the interfaces that the class inherits from.
if (param.IsDefined(type, false))
return true;
if (param.Member.DeclaringType == null || !inherit) // This is an interface so we are done.
return false;
ParameterInfo baseParam = GetParentDefinition(param);
while (baseParam != null)
{
Object[] objAttr = baseParam.GetCustomAttributes(type, false);
for (int i =0; i < objAttr.Length; i++)
{
Type objType = objAttr[i].GetType();
AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType);
if ((objAttr[i] is Attribute) && (attribUsage.Inherited))
return true;
}
baseParam = GetParentDefinition(baseParam);
}
return false;
}
/// <summary>
/// Determine whether any data is available for a parameter.
/// </summary>
/// <param name="parameter">A ParameterInfo representing one
/// argument to a parameterized test</param>
/// <returns>
/// True if any data is available, otherwise false.
/// </returns>
public bool HasDataFor(ParameterInfo parameter)
{
return parameter.IsDefined(typeof(DataAttribute), false);
}
internal static bool IsDefined(ParameterInfo target, Type caType, bool inherit) {
// JScript implements subclasses of ParameterInfo which throw an exception when Module is
// accessed. We know that none of these are from a ReflectionOnly assembly.
Type t = target.GetType();
if (t.Assembly == typeof(CustomAttribute).Assembly || !target.Member.Module.Assembly.ReflectionOnly)
return target.IsDefined(caType, inherit);
return CustomAttribute.CheckForCustomAttribute(CustomAttributeData.GetCustomAttributes(target), caType);
}
internal static void BuildParameter(ParameterBuilder builder, ParameterInfo parameter)
{
Debug.Assert(parameter != null);
Debug.Assert(builder != null);
//
// Build...
//
builder.Name = parameter.Name;
builder.ParameterType = parameter.ParameterType;
builder.IsParamArray = parameter.IsDefined(typeof(ParamArrayAttribute), true);
//
// Modify...
//
object[] modifiers = GetCustomAttributes(parameter, typeof(IParameterModifier), true);
foreach (IParameterModifier modifier in modifiers)
modifier.Modify(builder);
}
public static bool IsParamDictionary(ParameterInfo parameter) {
return parameter.IsDefined(typeof(ParamDictionaryAttribute), false);
}
/// <summary>
/// Emits code converting argument on the evaluation stack to a specified type using PHP.NET library conversions.
/// Used for conversion of elements of params array optional arguments,
/// for conversion of a content of mandatory by-ref holder, and
/// for conversion of mandatory in argument.
/// </summary>
/// <param name="dstType">
/// The type of the formal argument. Shouldn't be <see cref="Type.IsByRef"/>.
/// </param>
/// <param name="srcTypeOrValue">
/// The type of the formal argument or its value if it is a literal.
/// </param>
/// <param name="allowImplicitCast">Whether to allow implicit cast of types PhpArray, PhpObject, PhpResource.</param>
/// <param name="param">The formal argument description.</param>
/// <param name="additionalValuesOnStackCount">Amount of values pushed on stackl, that have to be cleaned up in case of failed conversion.</param>
internal void EmitArgumentConversion(Type dstType, object srcTypeOrValue, bool allowImplicitCast, ParameterInfo param, int additionalValuesOnStackCount = 0)
{
Debug.Assert(!dstType.IsByRef);
Type src_type = srcTypeOrValue as Type;
// passing void parameter is the same as passing null reference:
if (src_type == Types.Void)
{
srcTypeOrValue = null;
src_type = null;
}
// unites treatment of enums and ints:
if (src_type != null && src_type.IsEnum) src_type = typeof(int);
if (dstType.IsEnum) dstType = typeof(int);
// no conversions needed:
if (dstType == src_type)
{
// deep copy if needed (doesn't produce unnecessary copying):
if (param.IsDefined(typeof(PhpDeepCopyAttribute), false))
{
// CALL (<dstType>)PhpVariable.Copy(STACK,CopyReason.PassedByCopy);
il.LdcI4((int)CopyReason.PassedByCopy);
il.Emit(OpCodes.Call, Methods.PhpVariable.Copy);
if (dstType != typeof(object))
il.Emit(OpCodes.Castclass, dstType);
}
return;
}
// if dst type is reference then src type should be also a reference
// (reference - reference combination was eliminated in previous statement):
Debug.Assert(dstType != typeof(PhpReference), "Formal type cannot be reference if actual is not.");
// dereferences a reference:
if (src_type == typeof(PhpReference))
{
il.Emit(OpCodes.Ldfld, Fields.PhpReference_Value);
src_type = typeof(object);
}
#region dst is integer, long integer, bool, double, string, PhpBytes, char
// to integer (can be loaded from literal):
if (dstType == typeof(int))
{
if (src_type == null)
{
il.LdcI4(Convert.ObjectToInteger(srcTypeOrValue));
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToInteger);
}
return;
}
// to long integer (can be loaded from literal):
if (dstType == typeof(long))
{
if (src_type == null)
{
il.LdcI8(Convert.ObjectToLongInteger(srcTypeOrValue));
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToLongInteger);
}
return;
}
// to boolean (can be loaded from literal):
if (dstType == typeof(bool))
{
if (src_type == null)
{
il.LdcI4(Convert.ObjectToBoolean(srcTypeOrValue) ? 1 : 0);
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToBoolean);
}
return;
}
// to double (can be loaded from literal):
if (dstType == typeof(double))
{
if (src_type == null)
{
il.Emit(OpCodes.Ldc_R8, Convert.ObjectToDouble(srcTypeOrValue));
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToDouble);
}
return;
}
// to string (can be loaded from literal):
if (dstType == typeof(string))
{
if (src_type == null)
{
il.Emit(OpCodes.Ldstr, Convert.ObjectToString(srcTypeOrValue));
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToString);
}
return;
}
// to bytes:
if (dstType == typeof(PhpBytes))
{
if (src_type == null)
{
il.EmitLoadPhpBytes(Convert.ObjectToPhpBytes(srcTypeOrValue));
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToPhpBytes);
}
return;
}
// to char:
if (dstType == typeof(char))
{
if (src_type == null)
{
il.LdcI4((int)Convert.ObjectToChar(srcTypeOrValue));
}
else
{
// boxing and conversion:
if (src_type.IsValueType) il.Emit(OpCodes.Box, src_type);
il.Emit(OpCodes.Call, Methods.Convert.ObjectToChar);
}
return;
}
#endregion
// further conversions doesn't work with empty stack => loads literal on eval stack:
if (src_type == null)
src_type = il.LoadLiteral(srcTypeOrValue);
if (src_type.IsValueType)
il.Emit(OpCodes.Box, src_type);
// to callback:
if (dstType == typeof(PhpCallback))
{
il.Emit(OpCodes.Call, Methods.Convert.ObjectToCallback);
return;
}
Debug.Assert(!dstType.IsValueType);
if (param.IsDefined(typeof(PhpDeepCopyAttribute), false))
{
// do not copy literals:
if (!src_type.IsValueType && src_type != typeof(string))
{
// CALL (<src_type>)PhpVariable.Copy(STACK,CopyReason.PassedByCopy);
il.LdcI4((int)CopyReason.PassedByCopy);
il.Emit(OpCodes.Call, Methods.PhpVariable.Copy);
// src_type was on the eval. stack before copy was called:
if (src_type != typeof(object))
il.Emit(OpCodes.Castclass, src_type);
}
}
// to object:
if (dstType == typeof(object)) return;
//
// cast the value to the target type
//
if (allowImplicitCast)
{
// cast the value, without the checking of the success
il.Emit(OpCodes.Isinst, dstType);
}
else
{
// if implicit cast is not allowed => a condition checking the result of the cast
// is emitted (conditional call to InvalidImplicitCast)
// conversion of array, object, and resource:
string type_name = PhpVariable.GetAssignableTypeName(dstType);
Label endif_label = il.DefineLabel();
Label endblock_label = il.DefineLabel();
//LocalBuilder loc_typed = null;
bool needsCast;
LocalBuilder loc_obj = il.DeclareLocal(typeof(object));
il.Emit(OpCodes.Dup);
il.Stloc(loc_obj);
// IF (obj == null) goto ENDIF;
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Beq_S, endblock_label);
// (obj) on top of eval stack, eat it:
if (dstType.IsSealed)
{
needsCast = true;
// if (<obj>.GetType() == typeof(<dstType>)) goto ENDIF; // little JIT hack
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Callvirt, Methods.Object_GetType);
il.Emit(OpCodes.Ldtoken, dstType);
il.Emit(OpCodes.Call, Methods.GetTypeFromHandle);
il.Emit(OpCodes.Call, Methods.Equality_Type_Type);
il.Emit(OpCodes.Brtrue, endif_label);
// (object)<obj> on stack
}
else
{
needsCast = false;
//loc_typed = il.DeclareLocal(dstType);
// <loc_typed> = <obj> as <dstType>:
il.Emit(OpCodes.Isinst, dstType);
//il.Stloc(loc_typed);
// (obj as dstType) is on top of the evaluation stack
// IF (obj!=null) goto ENDIF;
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Brtrue_S, endif_label);
// (<obj> as <dstType>) on stack
}
if (true)
{
il.Emit(OpCodes.Pop); // pops <obj> from stack
// CALL PhpException.InvalidImplicitCast(obj,<PhpTypeName>,<functionName>);
il.Ldloc(loc_obj); // pushes original <obj>
il.Emit(OpCodes.Ldstr, type_name);
il.Emit(OpCodes.Ldstr, this.functionName.ToString());
il.Emit(OpCodes.Call, Methods.PhpException.InvalidImplicitCast);
if (debug)
il.Emit(OpCodes.Nop);
// pops all arguments already pushed:
int popsCount = pushedArgsCount + additionalValuesOnStackCount;
for (int i = 0; i < popsCount; ++i)
il.Emit(OpCodes.Pop);
Debug.Assert(overloadCallSkipEmitter != null);
// GOTO <end of call>;
//il.Emit(OpCodes.Br, overloadCallEndLabel);
overloadCallSkipEmitter(il);
}
// ENDIF;
il.MarkLabel(endif_label);
// load <obj>
if (needsCast)
{
// cast <obj> from top of the stack
il.Emit(OpCodes.Castclass, dstType);
}
// ENDBLOCK:
il.MarkLabel(endblock_label);
}
}
static bool InternalParamIsDefined (ParameterInfo parameter, Type attributeType, bool inherit)
{
if (parameter.IsDefined (attributeType, inherit))
return true;
if (!inherit)
return false;
var member = parameter.Member;
if (member.MemberType != MemberTypes.Method)
return false;
var method = ((MethodInfo) member).GetBaseMethod ();
while (true) {
var param = method.GetParametersInternal () [parameter.Position];
if (param.IsDefined (attributeType, false))
return true;
var base_method = method.GetBaseMethod ();
if (base_method == method)
break;
method = base_method;
}
return false;
}
internal static ParameterResult GetParameterResultFromParameterInfo(ParameterInfo param)
{
// TODO: Get parameter documentation
var pyType = ClrModule.GetPythonType(param.ParameterType);
string name = param.Name;
string typeName = PythonType.Get__name__(pyType);
if (param.IsDefined(typeof(ParamArrayAttribute), false)) {
name = "*" + name;
if (param.ParameterType.IsArray) {
var elemType = param.ParameterType.GetElementType();
if (elemType == typeof(object)) {
typeName = "sequence";
} else {
typeName = PythonType.Get__name__(DynamicHelpers.GetPythonTypeFromType(elemType)) + " sequence";
}
}
} else if (param.IsDefined(typeof(ParamDictionaryAttribute), false)) {
name = "**" + name;
typeName = "object";
}
bool isOptional = false;
if (param.DefaultValue != DBNull.Value && !(param.DefaultValue is Missing)) {
name = name + " = " + PythonOps.Repr(DefaultContext.Default, param.DefaultValue);
} else if (param.IsOptional) {
object missing = CompilerHelpers.GetMissingValue(param.ParameterType);
if (missing != Missing.Value) {
name = name + " = " + PythonOps.Repr(DefaultContext.Default, missing);
} else {
isOptional = true;
}
}
return new ParameterResult(name, "", typeName, isOptional);
}
private string GetParameterModifiers(ParameterInfo x, bool includeParams)
{
if (x.ParameterType.IsByRef)
if (x.IsOut) return "out ";
else return "ref ";
else if (x.IsDefined(typeof(ParamArrayAttribute), false) && includeParams)
return "params ";
else
return string.Empty;
}
//SetSpecified(Parameter|Field) has to be here, because .NET generates proxy objects with special parameters when value type is present.
//The reason is value types are not Nullable so this special parameter indicates if value is present or not
//http://stackoverflow.com/questions/3362574/how-to-get-rid-of-xmlignoreattribute-when-creating-proxy-dynamically-from-wsdl
private bool SetSpecifiedParameter(List<object> resultParams, ParameterInfo pi)
{
//check XmlIgnoreAttribute
//There is case when field always has to be specified so *Specified field isn't present
if (lastPrimitive && pi.IsDefined(typeof(System.Xml.Serialization.XmlIgnoreAttribute), false))
{
resultParams.Add(true);
lastPrimitive = false;
return true;
}
lastPrimitive = false;
return false;
}
public override Expression/*!*/ Convert(DynamicMetaObject/*!*/ metaObject, Type restrictedType, ParameterInfo info, Type/*!*/ toType) {
Expression expr = metaObject.Expression;
Type fromType = restrictedType ?? expr.Type;
// block:
if (fromType == typeof(MissingBlockParam)) {
Debug.Assert(toType == typeof(BlockParam) || toType == typeof(MissingBlockParam));
return AstUtils.Constant(null);
}
if (fromType == typeof(BlockParam) && toType == typeof(MissingBlockParam)) {
return AstUtils.Constant(null);
}
// protocol conversions:
if (info != null && info.IsDefined(typeof(DefaultProtocolAttribute), false)) {
var action = RubyConversionAction.TryGetDefaultConversionAction(Context, toType);
if (action != null) {
// TODO: inline implicit conversions:
return Ast.Dynamic(action, toType, expr);
}
// Do not throw an exception here to allow generic type parameters to be used with D.P. attribute.
// The semantics should be to use DP if available for the current instantiation and ignore it otherwise.
}
if (restrictedType != null) {
if (restrictedType == typeof(DynamicNull)) {
if (!toType.IsValueType || toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) {
return AstUtils.Constant(null, toType);
} else if (toType == typeof(bool)) {
return AstUtils.Constant(false);
}
}
if (toType.IsAssignableFrom(restrictedType)) {
// expr can be converted to restrictedType, which can be converted toType => we can convert expr to toType:
return AstUtils.Convert(expr, CompilerHelpers.GetVisibleType(toType));
}
// if there is a simple conversion from restricted type, convert the expression to the restricted type and use that conversion:
Type visibleRestrictedType = CompilerHelpers.GetVisibleType(restrictedType);
if (Converter.CanConvertFrom(metaObject, visibleRestrictedType, toType, false, NarrowingLevel.None, false, false)) {
expr = AstUtils.Convert(expr, visibleRestrictedType);
}
}
return Converter.ConvertExpression(expr, toType, _args.RubyContext, _args.MetaContext.Expression, _implicitProtocolConversions);
}
/// <summary>
/// Determines whether a type represented by a class object is
/// convertible to another type represented by a class object using a
/// method invocation conversion, treating object types of primitive
/// types as if they were primitive types (that is, a Boolean actual
/// parameter type matches boolean primitive formal type). This behavior
/// is because this method is used to determine applicable methods for
/// an actual parameter list, and primitive types are represented by
/// their object duals in reflective method calls.
/// </summary>
/// <param name="formal">the formal parameter type to which the actual parameter type should be convertible</param>
/// <param name="actual">the actual parameter type.</param>
/// <returns>
/// true if either formal type is assignable from actual type,
/// or formal is a primitive type and actual is its corresponding object
/// type or an object type of a primitive type that can be converted to
/// the formal type.
/// </returns>
private static bool IsMethodInvocationConvertible(ParameterInfo formal, Type actual)
{
Type underlyingType = formal.ParameterType;
if (formal.IsDefined(typeof(ParamArrayAttribute), false))
{
underlyingType = formal.ParameterType.GetElementType();
}
// if it's a null, it means the arg was null
if (actual == null && !underlyingType.IsPrimitive)
{
return true;
}
// Check for identity or widening reference conversion
if (actual != null && underlyingType.IsAssignableFrom(actual))
{
return true;
}
// Check for boxing with widening primitive conversion.
if (underlyingType.IsPrimitive)
{
if (underlyingType == typeof(Boolean) && actual == typeof(Boolean))
return true;
if (underlyingType == typeof(Char) && actual == typeof(Char))
return true;
if (underlyingType == typeof(Byte) && actual == typeof(Byte))
return true;
if (underlyingType == typeof(Int16) && (actual == typeof(Int16) || actual == typeof(Byte)))
return true;
if (underlyingType == typeof(Int32) &&
(actual == typeof(Int32) || actual == typeof(Int16) || actual == typeof(Byte)))
return true;
if (underlyingType == typeof(Int64) &&
(actual == typeof(Int64) || actual == typeof(Int32) || actual == typeof(Int16) || actual == typeof(Byte)))
return true;
if (underlyingType == typeof(Single) &&
(actual == typeof(Single) || actual == typeof(Int64) || actual == typeof(Int32) || actual == typeof(Int16) ||
actual == typeof(Byte)))
return true;
if (underlyingType == typeof(Double) &&
(actual == typeof(Double) || actual == typeof(Single) || actual == typeof(Int64) || actual == typeof(Int32) ||
actual == typeof(Int16) || actual == typeof(Byte)))
return true;
}
return false;
}
bool IsParamsArg (ParameterInfo pi)
{
return pi.ParameterType.IsArray && pi.IsDefined (typeof (ParamArrayAttribute));
}
private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool inherit)
{
if (param.IsDefined(type, false))
{
return true;
}
if (param.Member.DeclaringType == null || !inherit)
{
return false;
}
for (ParameterInfo parentDefinition = Attribute.GetParentDefinition(param); parentDefinition != null; parentDefinition = Attribute.GetParentDefinition(parentDefinition))
{
object[] customAttributes = parentDefinition.GetCustomAttributes(type, false);
for (int i = 0; i < customAttributes.Length; i++)
{
Type type2 = customAttributes[i].GetType();
AttributeUsageAttribute attributeUsageAttribute = Attribute.InternalGetAttributeUsage(type2);
if (customAttributes[i] is Attribute && attributeUsageAttribute.Inherited)
{
return true;
}
}
}
return false;
}
public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit)
{
// Returns true is a custom attribute subclass of attributeType class/interface with inheritance walk
if (element == null)
throw new ArgumentNullException(nameof(element));
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
Contract.EndContractBlock();
MemberInfo member = element.Member;
switch(member.MemberType)
{
case MemberTypes.Method: // We need to climb up the member hierarchy
return InternalParamIsDefined(element, attributeType, inherit);
case MemberTypes.Constructor:
return element.IsDefined(attributeType, false);
case MemberTypes.Property:
return element.IsDefined(attributeType, false);
default:
Contract.Assert(false, "Invalid type for ParameterInfo member in Attribute class");
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParamInfo"));
}
}
internal static bool IsDefined(ParameterInfo/*!*/ param)
{
return param != null && param.IsDefined(typeof(PhpRwAttribute), false);
}
public static bool IsDefined (ParameterInfo element, Type attributeType, bool inherit)
{
CheckParameters (element, attributeType);
if (element.IsDefined (attributeType, inherit))
return true;
if (inherit)
return IsDefinedOnParameter (element, attributeType);
return false;
}
private void CheckParameter(ParameterInfo parameterInfo, object parameterValue,
IMethodCallMessage mcall, IDictionary<string, object> symbolStore)
{
Type type = parameterValue.GetType();
if (!type.IsPrimitive)
{
RpcAdapterValidate(parameterValue, parameterInfo, symbolStore);
return;
}
bool checkSuccess = false;
if ((parameterInfo.IsDefined(typeof(PossibleValueAttribute), false)
|| parameterInfo.IsDefined(typeof(PossibleValueRangeAttribute), false)))
{
Attribute[] attributes =
(Attribute[])parameterInfo.GetCustomAttributes(typeof(Attribute), false);
foreach (Attribute attribute in attributes)
{
if (attribute is PossibleValueRangeAttribute && !checkSuccess)
{
checkSuccess =
MessageUtils.CheckValueByRange(parameterValue, (PossibleValueRangeAttribute)attribute);
}
if (attribute is PossibleValueAttribute && !checkSuccess)
{
checkSuccess =
messageUtils.CheckValueByEnum(parameterValue, ((PossibleValueAttribute)attribute).EnumType);
}
}
}
else
{
checkSuccess = true;
}
if (!checkSuccess)
{
throw new InvalidOperationException(
String.Format("Value of parameter '{0}' in method '{1}' is not one of its specified values",
parameterInfo.Name, mcall.MethodBase));
}
}
private static object GetDefaultValueFor(ParameterInfo parameter)
{
var type = parameter.ParameterType;
if (type == typeof(bool))
{
return false;
}
if (type.IsEnum)
{
return Enum.ToObject(type, 0);
}
if (type == typeof(char))
{
return Char.MinValue;
}
if (type.IsPrimitive)
{
return 0;
}
if(type.IsArray && parameter.IsDefined(typeof(ParamArrayAttribute), true))
{
return Array.CreateInstance(type.GetElementType(), 0);
}
return null;
}
public override Expression/*!*/ Convert(DynamicMetaObject/*!*/ metaObject, Type restrictedType, ParameterInfo info, Type/*!*/ toType) {
Expression expr = metaObject.Expression;
Type fromType = restrictedType ?? expr.Type;
// block:
if (fromType == typeof(MissingBlockParam)) {
Debug.Assert(toType == typeof(BlockParam) || toType == typeof(MissingBlockParam));
return AstUtils.Constant(null);
}
if (fromType == typeof(BlockParam) && toType == typeof(MissingBlockParam)) {
return AstUtils.Constant(null);
}
// protocol conversions:
if (info != null && info.IsDefined(typeof(DefaultProtocolAttribute), false)) {
var action = RubyConversionAction.TryGetDefaultConversionAction(Context, toType);
if (action != null) {
// TODO: inline implicit conversions:
return Ast.Dynamic(action, toType, expr);
}
throw new InvalidOperationException(String.Format("No default protocol conversion for type {0}.", toType));
}
if (restrictedType != null) {
if (restrictedType == typeof(DynamicNull)) {
if (!toType.IsValueType || toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) {
return AstUtils.Constant(null, toType);
} else if (toType == typeof(bool)) {
return AstUtils.Constant(false);
}
}
if (toType.IsAssignableFrom(restrictedType)) {
// expr can be converted to restrictedType, which can be converted toType => we can convert expr to toType:
return AstUtils.Convert(expr, CompilerHelpers.GetVisibleType(toType));
}
// if there is a simple conversion from restricted type, convert the expression to the restricted type and use that conversion:
Type visibleRestrictedType = CompilerHelpers.GetVisibleType(restrictedType);
if (Converter.CanConvertFrom(visibleRestrictedType, toType, NarrowingLevel.One, false)) {
expr = AstUtils.Convert(expr, visibleRestrictedType);
}
}
return Converter.ConvertExpression(expr, toType, _args.RubyContext, _args.MetaContext.Expression, _implicitProtocolConversions);
}
