/// <summary> /// Scores the given constructor based on the number of dependencies we can fill. /// </summary> static int Rate(MethodBase constructor, TypeTracker typeTracker) { // Preserve the default behaviour of preferring explicitly marked constructors. if (constructor.IsDefined(typeof(InjectionConstructorAttribute), false)) return int.MaxValue; var score = 0; foreach (var parameter in constructor.GetParameters()) { if(parameter.IsOut || parameter.IsRetval) return -1; if (typeTracker.HasDependency(parameter.ParameterType)) { score++; } else { // We don't know how to fill this parameter so try a different constructor return -1; } } return score; }
public static bool IsOneWay(MethodBase method) { return method.IsDefined (typeof (OneWayAttribute), false); }
// // Imports SRE parameters // public static AParametersCollection Create (ParameterInfo [] pi, MethodBase method) { if (pi.Length == 0) { if (method != null && (method.CallingConvention & CallingConventions.VarArgs) != 0) return new ParametersCollection (new IParameterData [0], Type.EmptyTypes, method, false); return Parameters.EmptyReadOnlyParameters; } Type [] types = new Type [pi.Length]; IParameterData [] par = new IParameterData [pi.Length]; bool is_params = false; for (int i = 0; i < types.Length; i++) { types [i] = TypeManager.TypeToCoreType (pi [i].ParameterType); ParameterInfo p = pi [i]; Parameter.Modifier mod = 0; if (types [i].IsByRef) { if ((p.Attributes & (ParameterAttributes.Out | ParameterAttributes.In)) == ParameterAttributes.Out) mod = Parameter.Modifier.OUT; else mod = Parameter.Modifier.REF; // // Strip reference wrapping // types [i] = TypeManager.GetElementType (types [i]); } else if (i == 0 && TypeManager.extension_attribute_type != null && method != null && method.IsStatic && (method.DeclaringType.Attributes & Class.StaticClassAttribute) == Class.StaticClassAttribute && method.IsDefined (TypeManager.extension_attribute_type, false)) { mod = Parameter.Modifier.This; } else if (i >= pi.Length - 2 && types [i].IsArray) { if (p.IsDefined (TypeManager.param_array_type, false)) { mod = Parameter.Modifier.PARAMS; is_params = true; } } par [i] = new ParameterData (p.Name, mod); } return method != null ? new ParametersCollection (par, types, method, is_params) : new ParametersCollection (par, types); }
// TODO: better filtering in DLR private static bool IsVisibleFrame(MethodBase/*!*/ method) { // filter out the _stub_ methods if (method.Name.StartsWith("_stub_")) { return false; } Type type = method.DeclaringType; if (type != null) { string typeName = type.FullName; if (typeName.StartsWith("System.Reflection.") || typeName.StartsWith("System.Runtime") || typeName.StartsWith("System.Dynamic") || typeName.StartsWith("Microsoft.Scripting")) { return false; } // TODO: check loaded assemblies if (type.Assembly == typeof(RubyOps).Assembly) { return false; } if (method.IsDefined(typeof(RubyStackTraceHiddenAttribute), false)) { return false; } if (type.Assembly.IsDefined(typeof(RubyLibraryAttribute), false)) { return method.IsDefined(typeof(RubyMethodAttribute), false); } } return true; }
public static bool IsPrerequisiteTestMethod(MethodBase method) { return method.IsDefined(typeof(PrerequisiteAttribute), false); }
public static bool IsTestMethod(MethodBase method) { return method.IsDefined(typeof(TestAttribute), false); }
public static bool IsExceptionResilientTestMethod(MethodBase method) { return method.IsDefined(typeof(ExceptionResilientAttribute), false); }
public static string GetSignature(this MethodBase method, bool includeAccessModifiers = false, bool includeReturn = false, bool includeDeclaringType = true, bool useFullNames = false, bool includeParameters = true, bool includeParametersNames = false, Func <bool, bool, MethodBase, object, string> parametersFunction = null, object parametersFunctionArguments = null ) { var res = new StringBuilder(); // Access modifiers if (includeAccessModifiers) { if (method.IsPublic) { res.Append("public "); } else if (method.IsPrivate) { res.Append("private "); } else if (method.IsAssembly) { res.Append("internal "); } if (method.IsFamily) { res.Append("protected "); } if (method.IsStatic) { res.Append("static "); } if (method.IsVirtual) { res.Append("virtual "); } if (method.IsAbstract) { res.Append("abstract "); } } // Return type if (includeReturn) { res.Append(((MethodInfo)method).ReturnType.GetSignature(useFullNames) + " "); } // Method name if (includeDeclaringType) { res.Append(method.DeclaringType.GetSignature(useFullNames) + "."); } res.Append(method.Name); // Generics arguments if (method.IsGenericMethod) { res.Append("<"); var genericArgs = method.GetGenericArguments(); for (var i = 0; i < genericArgs.Length; i++) { res.Append((i > 0 ? ", " : "") + genericArgs[i].GetSignature(useFullNames)); } res.Append(">"); } // Parameters if (includeParameters) { res.Append("("); if (parametersFunction != null) { res.Append(parametersFunction(useFullNames, includeParametersNames, method, parametersFunctionArguments)); } else { var pars = method.GetParameters(); for (var i = 0; i < pars.Length; i++) { var par = pars[i]; if (i == 0 && method.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false)) { res.Append("this "); } if (par.ParameterType.IsByRef) { res.Append("ref "); } else if (par.IsOut) { res.Append("out "); } res.Append(par.ParameterType.GetSignature(useFullNames)); if (includeParametersNames) { res.Append(" " + par.Name); } if (i < pars.Length - 1) { res.Append(", "); } } } res.Append(")"); } return(res.ToString()); }
public void Resolve(IDictionary<Identifier, IReferencable> referencables) { if (referencables.ContainsKey(identifier)) { IsResolved = true; IReferencable referencable = referencables[identifier]; var method = referencable as Method; if (method == null) { throw new InvalidOperationException("Cannot resolve to '" + referencable.GetType().FullName + "'"); } ReturnType = method.ReturnType; if (ReturnType != null && !ReturnType.IsResolved) { ReturnType.Resolve(referencables); } declaration = method.declaration; if (declaration != null && declaration.IsDefined(typeof (ObsoleteAttribute))) { ObsoleteReason = declaration.GetCustomAttribute<ObsoleteAttribute>().Message; } if (!Summary.IsResolved) { Summary.Resolve(referencables); } if (!Remarks.IsResolved) { Remarks.Resolve(referencables); } foreach (MethodParameter para in Parameters) { if ((para.Reference != null) && (!para.Reference.IsResolved)) { para.Reference.Resolve(referencables); } } } else { ConvertToExternalReference(); } }
public static bool IsSupportedExtensionMethod(MethodBase method,Type extendedType) { if (!method.IsDefined(typeof(ExtensionAttribute), false)) return false; var methodParameters = method.GetParameters(); if (methodParameters.Length < 1) return false; var hasValidGenericParameter = false; for (var i = 0; i < methodParameters.Length; i++) { var parameterType = methodParameters[i].ParameterType; if (i == 0) { if (parameterType.IsGenericParameter) { var parameterConstraints = parameterType.GetGenericParameterConstraints(); if (parameterConstraints.Length == 0 || !parameterConstraints[0].IsAssignableFrom(extendedType)) return false; hasValidGenericParameter = true; } else if (!parameterType.IsAssignableFrom(extendedType)) return false; } else if (parameterType.IsGenericParameter) { var parameterConstraints = parameterType.GetGenericParameterConstraints(); if (parameterConstraints.Length == 0 || !parameterConstraints[0].IsClass) return false; hasValidGenericParameter = true; } } return hasValidGenericParameter || !method.ContainsGenericParameters; }
/// <summary> /// Method executed when entering a test method. /// </summary> /// <param name="instance"> The instance of the context specification. </param> /// <param name="methodInfo"> The test method. </param> /// <param name="becauseAction"> The because method. </param> private void OnTestMethodEntry( IContextSpecification instance, MethodBase methodInfo, Action becauseAction) { var isRunningInTheContextOfAnotherTest = instance.ArePrerequisiteTestsRunning; if (isRunningInTheContextOfAnotherTest) { return; } var isRunningPrerequisite = methodInfo.IsDefined(typeof(PrerequisiteAttribute), true); becauseAction(); if (!isRunningPrerequisite) { this.RunPrerequisiteTestsMethod(); } }
public MethodProxy(MethodBase methodBase, object hardTarget) { this.methodBase = methodBase; this.hardTarget = hardTarget; parameters = methodBase.GetParameters(); if (_length == null) _length = new Number(0) { attributes = JSObjectAttributesInternal.ReadOnly | JSObjectAttributesInternal.DoNotDelete | JSObjectAttributesInternal.DoNotEnum | JSObjectAttributesInternal.SystemObject }; var pc = methodBase.GetCustomAttributes(typeof(Modules.ArgumentsLengthAttribute), false).ToArray(); if (pc.Length != 0) _length.iValue = (pc[0] as Modules.ArgumentsLengthAttribute).Count; else _length.iValue = parameters.Length; for (int i = 0; i < parameters.Length; i++) { var t = parameters[i].GetCustomAttribute(typeof(Modules.ConvertValueAttribute)) as Modules.ConvertValueAttribute; if (t != null) { if (paramsConverters == null) paramsConverters = new Modules.ConvertValueAttribute[parameters.Length]; paramsConverters[i] = t; } } if (methodBase is MethodInfo) { var methodInfo = methodBase as MethodInfo; returnConverter = methodInfo.ReturnParameter.GetCustomAttribute(typeof(Modules.ConvertValueAttribute), false) as Modules.ConvertValueAttribute; forceInstance = methodBase.IsDefined(typeof(InstanceMemberAttribute), false); if (forceInstance) { if (!methodInfo.IsStatic || (parameters.Length == 0) || (parameters.Length > 2) || (parameters[0].ParameterType != typeof(JSObject)) || (parameters.Length > 1 && parameters[1].ParameterType != typeof(Arguments))) throw new ArgumentException("Force-instance method \"" + methodBase + "\" have invalid signature"); raw = true; } if (!PartiallyTrusted && !methodInfo.IsStatic && (parameters.Length == 0 || (parameters.Length == 1 && parameters[0].ParameterType == typeof(Arguments))) #if PORTABLE && !methodInfo.ReturnType.GetTypeInfo().IsValueType && !methodInfo.DeclaringType.GetTypeInfo().IsValueType) #else && !methodInfo.ReturnType.IsValueType && !methodInfo.DeclaringType.IsValueType) #endif { var t = methodBase.GetCustomAttributes(typeof(AllowUnsafeCallAttribute), false).ToArray(); alternedTypes = new AllowUnsafeCallAttribute[t.Length]; for (var i = 0; i < t.Length; i++) alternedTypes[i] = (AllowUnsafeCallAttribute)t[i]; } #region Magic if (alternedTypes != null) { if (methodInfo.ReturnType == typeof(void)) { if (parameters.Length == 0) { #if PORTABLE var methodDelegate = methodInfo.CreateDelegate(typeof(Action<>).MakeGenericType(methodBase.DeclaringType)); var handle = handleInfo.GetValue(methodDelegate); var forceConverterConstructor = typeof(Action<object>).GetTypeInfo().DeclaredConstructors.First(); #else var forceConverterConstructor = typeof(Action<object>).GetConstructors().First(); var handle = methodInfo.MethodHandle.GetFunctionPointer(); #endif action1 = (Action<object>)forceConverterConstructor.Invoke(new object[] { null, (IntPtr)handle }); mode = _Mode.A1; } else // 1 { #if PORTABLE var methodDelegate = methodInfo.CreateDelegate(typeof(Action<,>).MakeGenericType(methodBase.DeclaringType, typeof(Arguments))); var handle = handleInfo.GetValue(methodDelegate); var forceConverterConstructor = typeof(Action<object, object>).GetTypeInfo().DeclaredConstructors.First(); #else var forceConverterConstructor = typeof(Action<object, object>).GetConstructors().First(); var handle = methodInfo.MethodHandle.GetFunctionPointer(); #endif action2 = (Action<object, object>)forceConverterConstructor.Invoke(new object[] { null, (IntPtr)handle }); mode = _Mode.A2; } } else { if (parameters.Length == 0) { #if PORTABLE var methodDelegate = methodInfo.CreateDelegate(typeof(Func<,>).MakeGenericType(methodBase.DeclaringType, methodInfo.ReturnType)); var handle = handleInfo.GetValue(methodDelegate); var forceConverterConstructor = typeof(Func<object, object>).GetTypeInfo().DeclaredConstructors.First(); #else var forceConverterConstructor = typeof(Func<object, object>).GetConstructors().First(); var handle = methodInfo.MethodHandle.GetFunctionPointer(); #endif func1 = (Func<object, object>)forceConverterConstructor.Invoke(new object[] { getDummy(), (IntPtr)handle }); mode = _Mode.F1; } else // 1 { #if PORTABLE var methodDelegate = methodInfo.CreateDelegate(typeof(Func<,,>).MakeGenericType(methodBase.DeclaringType, typeof(Arguments), methodInfo.ReturnType)); var handle = handleInfo.GetValue(methodDelegate); var forceConverterConstructor = typeof(Func<object, object, object>).GetTypeInfo().DeclaredConstructors.First(); #else var forceConverterConstructor = typeof(Func<object, object, object>).GetConstructors().First(); var handle = methodInfo.MethodHandle.GetFunctionPointer(); #endif func2 = (Func<object, object, object>)forceConverterConstructor.Invoke(new object[] { getDummy(), (IntPtr)handle }); mode = _Mode.F2; } } raw = true; return; // больше ничего не требуется, будет вызывать через этот путь } #endregion #if PORTABLE makeMethodOverExpression(methodInfo); #else makeMethodOverEmit(methodInfo); #endif } else if (methodBase is ConstructorInfo) { makeConstructorOverExpression(methodBase as ConstructorInfo); } else throw new NotImplementedException(); }
// // Imports SRE parameters // public static AParametersCollection Create (ParameterInfo [] pi, MethodBase method) { int varargs = method != null && (method.CallingConvention & CallingConventions.VarArgs) != 0 ? 1 : 0; if (pi.Length == 0 && varargs == 0) return ParametersCompiled.EmptyReadOnlyParameters; Type [] types = new Type [pi.Length + varargs]; IParameterData [] par = new IParameterData [pi.Length + varargs]; bool is_params = false; PredefinedAttribute extension_attr = PredefinedAttributes.Get.Extension; PredefinedAttribute param_attr = PredefinedAttributes.Get.ParamArray; for (int i = 0; i < pi.Length; i++) { types [i] = TypeManager.TypeToCoreType (pi [i].ParameterType); ParameterInfo p = pi [i]; Parameter.Modifier mod = 0; Expression default_value = null; if (types [i].IsByRef) { if ((p.Attributes & (ParameterAttributes.Out | ParameterAttributes.In)) == ParameterAttributes.Out) mod = Parameter.Modifier.OUT; else mod = Parameter.Modifier.REF; // // Strip reference wrapping // types [i] = TypeManager.GetElementType (types [i]); } else if (i == 0 && extension_attr.IsDefined && method != null && method.IsStatic && (method.DeclaringType.Attributes & Class.StaticClassAttribute) == Class.StaticClassAttribute && method.IsDefined (extension_attr.Type, false)) { mod = Parameter.Modifier.This; } else { if (i >= pi.Length - 2 && types[i].IsArray) { if (p.IsDefined (param_attr.Type, false)) { mod = Parameter.Modifier.PARAMS; is_params = true; } } if (!is_params && p.IsOptional) { object value = p.DefaultValue; if (value == Missing.Value) { default_value = EmptyExpression.Null; } else if (value == null) { default_value = new NullLiteral (Location.Null); } else { default_value = Constant.CreateConstant (value.GetType (), value, Location.Null); } } } par [i] = new ParameterData (p.Name, mod, default_value); } if (varargs != 0) { par [par.Length - 1] = new ArglistParameter (Location.Null); types [types.Length - 1] = InternalType.Arglist; } return method != null ? new ParametersImported (par, types, varargs != 0, is_params) : new ParametersImported (par, types); }
private static bool HasHiddenOrNonUserCodeOrInternalAttribute(MethodBase method) { return method.IsDefined(typeof(DebuggerHiddenAttribute), true) || method.IsDefined(typeof(DebuggerNonUserCodeAttribute), true) || method.IsDefined(typeof(SystemInternalAttribute), true); }
public static bool IsExpectedExceptionTestMethod(MethodBase method) { return method.IsDefined(typeof(ExpectedExceptionAttribute), false); }
private static bool HasTestEntryPointAttribute(MethodBase method) { return method.IsDefined(typeof(UserCodeEntryPointAttribute), true); }
// // Imports SRE parameters // public static AParametersCollection Create(TypeSpec parent, ParameterInfo [] pi, MethodBase method) { int varargs = method != null && (method.CallingConvention & CallingConventions.VarArgs) != 0 ? 1 : 0; if (pi.Length == 0 && varargs == 0) return ParametersCompiled.EmptyReadOnlyParameters; TypeSpec [] types = new TypeSpec [pi.Length + varargs]; IParameterData [] par = new IParameterData [pi.Length + varargs]; bool is_params = false; PredefinedAttribute extension_attr = PredefinedAttributes.Get.Extension; for (int i = 0; i < pi.Length; i++) { ParameterInfo p = pi [i]; Parameter.Modifier mod = 0; Expression default_value = null; if (p.ParameterType.IsByRef) { if ((p.Attributes & (ParameterAttributes.Out | ParameterAttributes.In)) == ParameterAttributes.Out) mod = Parameter.Modifier.OUT; else mod = Parameter.Modifier.REF; // // Strip reference wrapping // types [i] = Import.ImportType (p.ParameterType.GetElementType ()); } else if (i == 0 && method.IsStatic && parent.IsStatic && extension_attr.IsDefined && extension_attr.IsDefined && method.IsDefined (extension_attr.Type.GetMetaInfo (), false)) { mod = Parameter.Modifier.This; types[i] = Import.ImportType (p.ParameterType); } else { types[i] = Import.ImportType (p.ParameterType); if (i >= pi.Length - 2 && types[i] is ArrayContainer) { var cattrs = CustomAttributeData.GetCustomAttributes (p); if (cattrs != null && cattrs.Any (l => l.Constructor.DeclaringType == typeof (ParamArrayAttribute))) { mod = Parameter.Modifier.PARAMS; is_params = true; } } if (!is_params && p.IsOptional) { object value = p.DefaultValue; if (value == Missing.Value) { default_value = EmptyExpression.Null; } else if (value == null) { default_value = new NullLiteral (Location.Null); } else { default_value = Constant.CreateConstant (null, Import.ImportType (value.GetType ()), value, Location.Null); } } } par [i] = new ParameterData (p.Name, mod, default_value); } if (varargs != 0) { par [par.Length - 1] = new ArglistParameter (Location.Null); types [types.Length - 1] = InternalType.Arglist; } return method != null ? new ParametersImported (par, types, varargs != 0, is_params) : new ParametersImported (par, types); }