public static bool ShouldWarn(PythonBinder/*!*/ binder, MethodBase/*!*/ method, out WarningInfo info) {
Assert.NotNull(method);
ObsoleteAttribute[] os = (ObsoleteAttribute[])method.GetCustomAttributes(typeof(ObsoleteAttribute), true);
if (os.Length > 0) {
info = new WarningInfo(
PythonExceptions.DeprecationWarning,
String.Format("{0}.{1} has been obsoleted. {2}",
NameConverter.GetTypeName(method.DeclaringType),
method.Name,
os[0].Message
)
);
return true;
}
if (binder.WarnOnPython3000) {
Python3WarningAttribute[] py3kwarnings = (Python3WarningAttribute[])method.GetCustomAttributes(typeof(Python3WarningAttribute), true);
if (py3kwarnings.Length > 0) {
info = new WarningInfo(
PythonExceptions.DeprecationWarning,
py3kwarnings[0].Message
);
return true;
}
}
#if !SILVERLIGHT
// no apartment states on Silverlight
if (method.DeclaringType == typeof(Thread)) {
if (method.Name == "Sleep") {
info = new WarningInfo(
PythonExceptions.RuntimeWarning,
"Calling Thread.Sleep on an STA thread doesn't pump messages. Use Thread.CurrentThread.Join instead.",
Expression.Equal(
Expression.Call(
Expression.Property(
null,
typeof(Thread).GetProperty("CurrentThread")
),
typeof(Thread).GetMethod("GetApartmentState")
),
AstUtils.Constant(ApartmentState.STA)
),
() => Thread.CurrentThread.GetApartmentState() == ApartmentState.STA
);
return true;
}
}
#endif
info = null;
return false;
}
public string GetBaseName(MethodBase method, Func<DisplayAsAttribute, string> selectName)
{
var nameAttribute = method.GetCustomAttributes(typeof(DisplayAsAttribute), true);
if(nameAttribute.Length != 0)
return selectName(((DisplayAsAttribute)nameAttribute[0]));
return NormalizeNamePattern.Replace(method.Name, " ");
}
public bool MethodShouldBeProxied(MethodBase method, IList aspects, Type baseType)
{
foreach (IAspect aspect in aspects)
{
IGenericAspect tmpAspect;
if (aspect is IGenericAspect)
tmpAspect = (IGenericAspect) aspect;
else
tmpAspect = TypedToGenericConverter.Convert((ITypedAspect) aspect);
foreach (IPointcut pointcut in tmpAspect.Pointcuts)
{
if (pointcut.IsMatch(method, baseType))
return true;
}
}
foreach (FixedInterceptorAttribute fixedInterceptorAttribute in method.GetCustomAttributes(typeof(FixedInterceptorAttribute), true))
return true;
if (baseType != null)
{
foreach (FixedInterceptorAttribute fixedInterceptorAttribute in baseType.GetCustomAttributes(typeof(FixedInterceptorAttribute), true))
return true;
}
return false;
}
private static string GetMethodName(MethodBase mb)
{
object[] attr = mb.GetCustomAttributes(typeof(NameSigAttribute), false);
if (attr.Length == 1)
{
return(((NameSigAttribute)attr[0]).Name);
}
else if (mb.Name == ".ctor")
{
return("<init>");
}
else if (mb.Name == ".cctor")
{
return("<clinit>");
}
else if (mb.Name.StartsWith(NamePrefix.DefaultMethod, StringComparison.Ordinal))
{
return(mb.Name.Substring(NamePrefix.DefaultMethod.Length));
}
else if (mb.Name.StartsWith(NamePrefix.Bridge, StringComparison.Ordinal))
{
return(mb.Name.Substring(NamePrefix.Bridge.Length));
}
else if (mb.IsSpecialName)
{
return(UnicodeUtil.UnescapeInvalidSurrogates(mb.Name));
}
else
{
return(mb.Name);
}
}
private MongoSessionAttribute GetMongoSessionAttribute(MethodBase methodBase)
{
// ���忡 Ư���� �����Ǿ� �ִ��� Ȯ���Ѵ�.
object[] attrs
= methodBase.GetCustomAttributes(typeof(MongoSessionAttribute), true);
MongoSessionAttribute sessionAttribute = null;
if (attrs != null && attrs.Length > 0)
{
sessionAttribute = (MongoSessionAttribute)attrs[0];
}
else
{
// Ŭ������ Ư���� �����Ǿ� �ִ��� Ȯ���Ѵ�.
attrs = methodBase.ReflectedType.GetCustomAttributes(
typeof(MongoSessionAttribute), true);
if (attrs != null && attrs.Length > 0)
{
sessionAttribute = (MongoSessionAttribute)attrs[0];
}
}
return sessionAttribute;
}
static bool WebAttributesOCEExtender (MethodBase method, object[] customAttributes, ref OperationContractAttribute oca)
{
int caLength = customAttributes == null ? 0 : customAttributes.Length;
if (method == null && caLength == 0)
return false;
if (caLength == 0) {
customAttributes = method.GetCustomAttributes (false);
if (customAttributes.Length == 0)
return false;
}
bool foundWebAttribute = false;
foreach (object o in customAttributes) {
if (o is WebInvokeAttribute || o is WebGetAttribute) {
foundWebAttribute = true;
break;
}
}
if (!foundWebAttribute)
return false;
// LAMESPEC: .NET allows for contract methods decorated only with
// Web{Get,Invoke}Attribute and _without_ the OperationContractAttribute.
if (oca == null)
oca = new OperationContractAttribute ();
return true;
}
private static bool IsUnitTestMethod(MethodBase method)
{
// Look for NUnit [Test] attribute on method
var testAttributes = method.GetCustomAttributes(typeof(TestAttribute), true);
return testAttributes.Any();
}
GetOperationContractAttribute (MethodBase method)
{
object [] matts = method.GetCustomAttributes (
typeof (OperationContractAttribute), false);
if (matts.Length == 0)
return null;
return (OperationContractAttribute) matts [0];
}
public override bool CompileTimeValidate(MethodBase method)
{
return
(method.GetCustomAttributes(typeof(CompilerGeneratedAttribute), true).Length == 0 &&
!method.Name.StartsWith("get_") &&
!method.Name.StartsWith("set_") &&
!method.IsConstructor);
}
public bool Matches(MethodBase member)
{
Guard.ArgumentNotNull(member, "member");
object[] attribues = member.GetCustomAttributes(attributeType, inherited);
return (attribues != null && attribues.Length > 0);
}
protected void AddSnippet(ServiceOutput output, MethodBase methodBase)
{
if (output == null)
{
throw new ArgumentNullException("output");
}
if (methodBase == null)
{
throw new ArgumentNullException("methodBase");
}
// get the action associated with the call
SnippetAction action = SnippetManager.Instance.Parse(HttpContext.Current.Request.Params);
if (action.IsEnabled)
{
bool snippetMatch = false;
//get the name of the snippet that needs to be loaded
string snippetName = action.Name;
// make sure the method can support this snippet.
object[] attributes = methodBase.GetCustomAttributes(typeof(SupportedSnippetAttribute), false);
foreach (object a in attributes)
{
SupportedSnippetAttribute attribute = a as SupportedSnippetAttribute;
if (attribute != null &&
attribute.Name.Equals(attribute.Name, StringComparison.OrdinalIgnoreCase) )
{
snippetMatch = true;
break;
}
}
logger.Log(LogLevel.Debug, "SnippetName - [{0}] , Match - {1}", snippetName, snippetMatch);
// asked snippet can be supported by the service.
if (snippetMatch &&
SnippetManager.Instance.IsRegistered(snippetName))
{
// load the snippet control from the location
Control control = FormlessPage.GetControl(SnippetManager.Instance.GetControlPath(snippetName));
SnippetControl snippet = control as SnippetControl;
if (snippet != null)
{
logger.Log(LogLevel.Debug, "Got snippet [{0}], invoking to get output.", snippetName);
//set the control values
snippet.SetProperties(action.Properties);
output.AddOutput(Constants.Json.Html, snippet.GetJsonHtml());
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodMemberDescriptor"/> class.
/// </summary>
/// <param name="methodBase">The MethodBase (MethodInfo or ConstructorInfo) got through reflection.</param>
/// <param name="accessMode">The interop access mode.</param>
/// <exception cref="System.ArgumentException">Invalid accessMode</exception>
public MethodMemberDescriptor(MethodBase methodBase, InteropAccessMode accessMode = InteropAccessMode.Default)
{
CheckMethodIsCompatible(methodBase, true);
IsConstructor = (methodBase is ConstructorInfo);
this.MethodInfo = methodBase;
bool isStatic = methodBase.IsStatic || IsConstructor;
if (IsConstructor)
m_IsAction = false;
else
m_IsAction = ((MethodInfo)methodBase).ReturnType == typeof(void);
ParameterInfo[] reflectionParams = methodBase.GetParameters();
ParameterDescriptor[] parameters;
if (this.MethodInfo.DeclaringType.IsArray)
{
m_IsArrayCtor = true;
int rank = this.MethodInfo.DeclaringType.GetArrayRank();
parameters = new ParameterDescriptor[rank];
for (int i = 0; i < rank; i++)
parameters[i] = new ParameterDescriptor("idx" + i.ToString(), typeof(int));
}
else
{
parameters = reflectionParams.Select(pi => new ParameterDescriptor(pi)).ToArray();
}
bool isExtensionMethod = (methodBase.IsStatic && parameters.Length > 0 && methodBase.GetCustomAttributes(typeof(ExtensionAttribute), false).Any());
base.Initialize(methodBase.Name, isStatic, parameters, isExtensionMethod);
// adjust access mode
if (Script.GlobalOptions.Platform.IsRunningOnAOT())
accessMode = InteropAccessMode.Reflection;
if (accessMode == InteropAccessMode.Default)
accessMode = UserData.DefaultAccessMode;
if (accessMode == InteropAccessMode.HideMembers)
throw new ArgumentException("Invalid accessMode");
if (parameters.Any(p => p.Type.IsByRef))
accessMode = InteropAccessMode.Reflection;
this.AccessMode = accessMode;
if (AccessMode == InteropAccessMode.Preoptimized)
((IOptimizableDescriptor)this).Optimize();
}
private static bool IsNative(MethodBase m)
{
object[] methodFlagAttribs = m.GetCustomAttributes(typeof(ModifiersAttribute), false);
if (methodFlagAttribs.Length == 1)
{
ModifiersAttribute modifiersAttrib = (ModifiersAttribute)methodFlagAttribs[0];
return((modifiersAttrib.Modifiers & Modifiers.Native) != 0);
}
return(false);
}
public bool Matches(MethodBase member)
{
Guard.ArgumentNotNull(member, "member");
bool hasNoPoliciesAttribute =
(member.GetCustomAttributes(typeof(ApplyNoPoliciesAttribute), false).Length != 0);
hasNoPoliciesAttribute |=
(member.DeclaringType.GetCustomAttributes(typeof(ApplyNoPoliciesAttribute), false).
Length != 0);
return !hasNoPoliciesAttribute;
}
public static bool IsBoxedMath(MethodBase m)
{
Type t = m.DeclaringType;
if ( t == typeof(Numbers))
{
object[] boxedMaths = m.GetCustomAttributes(typeof(WarnBoxedMathAttribute), true);
if (boxedMaths.Length > 0)
return ((WarnBoxedMathAttribute)boxedMaths[0]).Value;
ParameterInfo[] pis = ((MethodBase)m).GetParameters();
foreach (ParameterInfo param in pis)
if (param.ParameterType.Equals(typeof(object)) )
return true;
}
return false;
}
public static OperationContractAttribute GetOperationContractAttribute (MethodBase method)
{
object [] matts = method.GetCustomAttributes (typeof (OperationContractAttribute), false);
OperationContractAttribute oca;
if (matts.Length == 0)
oca = null;
else
oca = matts [0] as OperationContractAttribute;
if (getOperationContractAttributeExtenders != null && getOperationContractAttributeExtenders.Count > 0) {
foreach (var extender in getOperationContractAttributeExtenders)
if (extender (method, matts, ref oca))
break;
}
return oca;
}
private static string GetMethodName(MethodBase mb)
{
object[] attr = mb.GetCustomAttributes(typeof(NameSigAttribute), false);
if (attr.Length == 1)
{
return(((NameSigAttribute)attr[0]).Name);
}
else if (mb.Name == ".ctor")
{
return("<init>");
}
else if (mb.Name == ".cctor")
{
return("<clinit>");
}
else
{
return(mb.Name);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodMemberDescriptor" /> class.
/// </summary>
/// <param name="methodBase">The MethodBase (MethodInfo or ConstructorInfo) got through reflection.</param>
/// <param name="accessMode">The interop access mode.</param>
/// <exception cref="System.ArgumentException">Invalid accessMode</exception>
public MethodMemberDescriptor(MethodBase methodBase, InteropAccessMode accessMode = InteropAccessMode.Default)
{
CheckMethodIsCompatible(methodBase, true);
IsConstructor = (methodBase is ConstructorInfo);
MethodInfo = methodBase;
var isStatic = methodBase.IsStatic || IsConstructor;
if (IsConstructor)
m_IsAction = false;
else
m_IsAction = ((MethodInfo) methodBase).ReturnType == typeof (void);
var reflectionParams = methodBase.GetParameters();
var parameters = reflectionParams.Select(pi => new ParameterDescriptor(pi)).ToArray();
var isExtensionMethod = (methodBase.IsStatic && parameters.Length > 0 &&
methodBase.GetCustomAttributes(typeof (ExtensionAttribute), false).Any());
Initialize(methodBase.Name, isStatic, parameters, isExtensionMethod);
// adjust access mode
if (Script.GlobalOptions.Platform.IsRunningOnAOT())
accessMode = InteropAccessMode.Reflection;
if (accessMode == InteropAccessMode.Default)
accessMode = UserData.DefaultAccessMode;
if (accessMode == InteropAccessMode.HideMembers)
throw new ArgumentException("Invalid accessMode");
if (parameters.Any(p => p.Type.IsByRef))
accessMode = InteropAccessMode.Reflection;
AccessMode = accessMode;
if (AccessMode == InteropAccessMode.Preoptimized)
((IOptimizableDescriptor) this).Optimize();
}
static string GetTestCaseName(bool fullName)
{
System.Diagnostics.StackTrace trace = StackTraceHelper.Create();
var frames = trace.GetFrames();
for (int i = 0; i < frames.Length; i++)
{
System.Reflection.MethodBase method = frames[i].GetMethod();
object[] testAttrs = method.GetCustomAttributes(typeof(NUnit.Framework.TestAttribute), false).ToArray();
if (testAttrs != null && testAttrs.Length > 0)
{
if (fullName)
{
return(method.DeclaringType.FullName + "." + method.Name);
}
else
{
return(method.Name);
}
}
}
return("GetTestCaseName[UnknownTestMethod]");
}
/// <summary>
/// TODO: Resolve IsPublic, IsNotPublic semantics of reflection
/// </summary>
/// <param name="ci"></param>
/// <returns></returns>
private bool OkToUseBase(MethodBase ci, out string message)
{
if (ci.IsAbstract)
{
message = "Will not use: method or constructor is abstract: " + ci.ToString();
return false;
}
foreach (ParameterInfo pi in ci.GetParameters())
{
if (pi.ParameterType.Name.EndsWith("&"))
{
message = "Will not use: method or constructor has a parameter containing \"&\": " + ci.ToString();
return false;
}
if (pi.IsOut)
{
message = "Will not use: method or constructor has an out parameter: " + ci.ToString();
return false;
}
if (pi.ParameterType.IsGenericParameter)
{
message = "Will not use: method or constructor has a generic parameter: " + ci.ToString();
return false;
}
}
if (!this.useInternal && !ci.IsPublic)
{
message = "Will not use: method or constructor is not public: " + ci.ToString();
return false;
}
if (ci.IsPrivate)
{
message = "Will not use: method or constructor is private: " + ci.ToString();
return false;
}
if (ci.IsStatic)
{
if (!useStaticMethods)
{
message = "Will not use: method or constructor is static: " + ci.ToString();
return false;
}
}
if (ci.DeclaringType.Equals(typeof(object)))
{
message = "Will not use: method is System.Object's: " + ci.ToString();
return false;
}
foreach (Attribute attr in ci.GetCustomAttributes(true))
{
if (attr is ObsoleteAttribute)
{
//WriteLine("Obsolete Method " + ci.DeclaringType + "::" + ci.Name + "()" + "detected\n");
message = "Will not use: has attribute System.ObsoleteAttribute: " + ci.ToString();
return false;
}
//TODO: there are still cases where an obsolete method is not caught. e.g. System.Xml.XmlSchema::ElementType
}
message = "@@@OK8" + ci.ToString();
return true;
}
public static CheckDescription AnalyzeSignature(MethodBase method)
{
var result = new CheckDescription { Check = method };
if (method.IsStatic)
{
#if !CORE
// check if this is an extension method
if (method.GetCustomAttributes(typeof(ExtensionAttribute), false).Length > 0)
{
var parameters = method.GetParameters();
var param = parameters[0];
var paramType = param.ParameterType;
if (!paramType.IsGenericType)
{
// this is not an check implementation
return null;
}
// if it is specific to chains
if (paramType.Name == "ICheckLink`1")
{
paramType = paramType.GetGenericArguments()[0];
}
if (paramType.Name == "IExtendableCheckLink`1"
|| paramType.Name == "IExtendableCheckLink`2"
|| paramType.Name == "ICheck`1"
|| paramType.GetInterface("ICheck`1") != null
|| paramType.Name == "IStructCheck`1"
|| paramType.Name == "ICodeCheck`1")
{
result.entryPoint = paramType.Name == "IStructCheck`1" ? "ThatEnum" : "That";
var testedtype = paramType.GetGenericArguments()[0];
if (testedtype.IsGenericParameter)
{
testedtype = testedtype.BaseType;
}
result.CheckedType = testedtype;
// get other parameters
result.CheckParameters = new List<Type>(parameters.Length - 1);
for (var i = 1; i < parameters.Length; i++)
{
result.CheckParameters.Add(parameters[i].ParameterType);
}
}
else
{
// this is not an check implementation
return null;
}
// identify type subjected to test
}
else
{
// unexpected case: check is a static method which is not an extension method
return null;
}
}
else
{
result.entryPoint = "That";
if (method.DeclaringType == null)
{
return null;
}
// this is an instance method, tested type is part of type defintion
Type scanning = method.DeclaringType.GetInterface("ICheck`1");
if (scanning != null && scanning.IsGenericType)
{
// the type implements ICheck<T>
result.CheckedType = scanning.IsGenericType ? scanning.GetGenericArguments()[0] : null;
if (result != null && result.CheckedType.IsGenericType)
{
result.CheckedType = result.CheckedType.BaseType;
}
// get other parameters
result.CheckParameters = new List<Type>();
foreach (var t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// type does not implement ICheck<T>, we try to find a 'Value' property
var prop = method.DeclaringType.GetProperty("Value", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (prop != null)
{
result.CheckedType = prop.PropertyType;
// get other parameters
result.CheckParameters = new List<Type>();
foreach (var t in method.GetParameters())
{
result.CheckParameters.Add(t.ParameterType);
}
}
else
{
// not a check method
Debug.WriteLine(string.Format("Type {0} needs to implement a Value property (method {1})", method.DeclaringType.Name, method.Name));
}
}
#endif
}
return result;
}
protected void ScanMethod(MethodBase aMethod, bool aIsPlug, string sourceItem)
{
var xParams = aMethod.GetParameters();
var xParamTypes = new Type[xParams.Length];
// Dont use foreach, enum generaly keeps order but
// isn't guaranteed.
//string xMethodFullName = LabelName.GenerateFullName(aMethod);
for (int i = 0; i < xParams.Length; i++)
{
xParamTypes[i] = xParams[i].ParameterType;
Queue(xParamTypes[i], aMethod, "Parameter");
}
var xIsDynamicMethod = aMethod.DeclaringType == null;
// Queue Types directly related to method
if (!aIsPlug)
{
// Don't queue declaring types of plugs
if (!xIsDynamicMethod)
{
// dont queue declaring types of dynamic methods either, those dont have a declaring type
Queue(aMethod.DeclaringType, aMethod, "Declaring Type");
}
}
if (aMethod is SysReflection.MethodInfo)
{
Queue(((SysReflection.MethodInfo)aMethod).ReturnType, aMethod, "Return Type");
}
// Scan virtuals
#region Virtuals scan
if (!xIsDynamicMethod && aMethod.IsVirtual)
{
// For virtuals we need to climb up the type tree
// and find the top base method. We then add that top
// node to the mVirtuals list. We don't need to add the
// types becuase adding DeclaringType will already cause
// all ancestor types to be added.
var xVirtMethod = aMethod;
var xVirtType = aMethod.DeclaringType;
MethodBase xNewVirtMethod;
while (true)
{
xVirtType = xVirtType.BaseType;
if (xVirtType == null)
{
// We've reached object, can't go farther
xNewVirtMethod = null;
}
else
{
xNewVirtMethod = xVirtType.GetMethod(aMethod.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, xParamTypes, null);
if (xNewVirtMethod != null)
{
if (!xNewVirtMethod.IsVirtual)
{
// This can happen if a virtual "replaces" a non virtual
// above it that is not virtual.
xNewVirtMethod = null;
}
}
}
// We dont bother to add these to Queue, because we have to do a
// full downlevel scan if its a new base virtual anyways.
if (xNewVirtMethod == null)
{
// If its already in the list, we mark it null
// so we dont do a full downlevel scan.
if (mVirtuals.Contains(xVirtMethod))
{
xVirtMethod = null;
}
break;
}
xVirtMethod = xNewVirtMethod;
}
// New virtual base found, we need to downscan it
// If it was already in mVirtuals, then ScanType will take
// care of new additions.
if (xVirtMethod != null)
{
Queue(xVirtMethod, aMethod, "Virtual Base");
mVirtuals.Add(xVirtMethod);
// List changes as we go, cant be foreach
for (int i = 0; i < mItemsList.Count; i++)
{
if (mItemsList[i] is Type)
{
var xType = (Type)mItemsList[i];
if (xType.IsSubclassOf(xVirtMethod.DeclaringType))
{
var xNewMethod = xType.GetMethod(aMethod.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, xParamTypes, null);
if (xNewMethod != null)
{
// We need to check IsVirtual, a non virtual could
// "replace" a virtual above it?
if (xNewMethod.IsVirtual)
{
Queue(xNewMethod, aMethod, "Virtual Downscan");
}
}
}
}
}
}
}
#endregion
MethodBase xPlug = null;
// Plugs may use plugs, but plugs won't be plugged over themself
if (!aIsPlug && !xIsDynamicMethod)
{
// Check to see if method is plugged, if it is we don't scan body
xPlug = mPlugManager.ResolvePlug(aMethod, xParamTypes);
}
if (xPlug == null)
{
bool xNeedsPlug = false;
if ((aMethod.Attributes & MethodAttributes.PinvokeImpl) != 0)
{
// pinvoke methods dont have an embedded implementation
xNeedsPlug = true;
}
else
{
var xImplFlags = aMethod.GetMethodImplementationFlags();
// todo: prob even more
if ((xImplFlags & MethodImplAttributes.Native) != 0 ||
(xImplFlags & MethodImplAttributes.InternalCall) != 0)
{
// native implementations cannot be compiled
xNeedsPlug = true;
}
}
if (xNeedsPlug)
{
throw new Exception("Native code encountered, plug required. Please see https://github.com/CosmosOS/Cosmos/wiki/Plugs). " + LabelName.GenerateFullName(aMethod) + "." + Environment.NewLine + " Called from :" + Environment.NewLine + sourceItem);
}
//TODO: As we scan each method, we could update or put in a new list
// that has the resolved plug so we don't have to reresolve it again
// later for compilation.
// Scan the method body for more type and method refs
//TODO: Dont queue new items if they are plugged
// or do we need to queue them with a resolved ref in a new list?
InlineAttribute inl = null;
foreach (InlineAttribute inli in aMethod.GetCustomAttributes(typeof(InlineAttribute), false))
{
inl = inli;
}
if (inl != null)
return; // cancel inline
List<ILOpCode> xOpCodes;
xOpCodes = mReader.ProcessMethod(aMethod);
if (xOpCodes != null)
{
ProcessInstructions(xOpCodes);
foreach (var xOpCode in xOpCodes)
{
if (xOpCode is ILOpCodes.OpMethod)
{
Queue(((ILOpCodes.OpMethod)xOpCode).Value, aMethod, "Call", sourceItem);
}
else if (xOpCode is ILOpCodes.OpType)
{
Queue(((ILOpCodes.OpType)xOpCode).Value, aMethod, "OpCode Value");
}
else if (xOpCode is ILOpCodes.OpField)
{
var xOpField = (ILOpCodes.OpField)xOpCode;
//TODO: Need to do this? Will we get a ILOpCodes.OpType as well?
Queue(xOpField.Value.DeclaringType, aMethod, "OpCode Value");
if (xOpField.Value.IsStatic)
{
//TODO: Why do we add static fields, but not instance?
// AW: instance fields are "added" always, as part of a type, but for static fields, we need to emit a datamember
Queue(xOpField.Value, aMethod, "OpCode Value");
}
}
else if (xOpCode is ILOpCodes.OpToken)
{
var xTokenOp = (ILOpCodes.OpToken)xOpCode;
if (xTokenOp.ValueIsType)
{
Queue(xTokenOp.ValueType, aMethod, "OpCode Value");
}
if (xTokenOp.ValueIsField)
{
Queue(xTokenOp.ValueField.DeclaringType, aMethod, "OpCode Value");
if (xTokenOp.ValueField.IsStatic)
{
//TODO: Why do we add static fields, but not instance?
// AW: instance fields are "added" always, as part of a type, but for static fields, we need to emit a datamember
Queue(xTokenOp.ValueField, aMethod, "OpCode Value");
}
}
}
}
}
}
}
/// <summary>
/// Gets the instance of the attribute with given type, which decorates given method on given type.
/// </summary>
/// <param name="targetType">Type of the target type.</param>
/// <param name="method">The target method.</param>
/// <param name="attributeType">Type of the attribute, which applies interceptor to a method.</param>
/// <returns></returns>
private static Attribute GetAttribute(Type targetType, MethodBase method, Type attributeType)
{
var key = GetMethodSignature(method, attributeType);
if (SignatureCache.ContainsKey(key))
{
return SignatureCache[key];
}
var classAttributes = (from attr in targetType.GetCustomAttributes(!targetType.IsInterface)
where attr.GetType() == attributeType
select attr).ToList();
if (classAttributes.Any())
{
var attribute = (ClassInterceptAttribute)classAttributes.First();
if (MatchesClassAttribute(attribute, method))
{
AddToSignatureCache(key, attribute);
return attribute;
}
}
var attributes = (from attr in method.GetCustomAttributes(!targetType.IsInterface)
where attr.GetType() == attributeType
select attr).ToList();
if (attributes.Any())
{
var attribute = (Attribute)attributes.First();
AddToSignatureCache(key, attribute);
return attribute;
}
AddToSignatureCache(key, null);
return null;
}
//Tests whether the method is marked with the given attribute.
private bool MethodMarkedWith(MethodBase methodInfo, Type markingAttribute)
{
return methodInfo.GetCustomAttributes(markingAttribute,false).Length > 0;
}
public static bool Contains(MethodBase method)
{
return method.GetCustomAttributes(true).OfType<ScriptOnlyAttribute>().Any();
}
public CustomHandlerMethod(MethodBase aMethod, Operation anOper) : base(aMethod.GetCustomAttributes(false), aMethod.DeclaringType + "." + aMethod.Name, anOper)
{
base.ProcessAttrs();
}
/// <summary>
/// Returns a method signature display string. Used to display stack frames.
/// </summary>
/// <returns>Null if the method is a compiler generated method that shouldn't be displayed to the user.</returns>
internal virtual string FormatMethodSignature(MethodBase method)
{
// TODO: https://github.com/dotnet/roslyn/issues/5250
if (method.Name.IndexOfAny(s_generatedNameChars) >= 0 ||
method.DeclaringType.Name.IndexOfAny(s_generatedNameChars) >= 0 ||
method.GetCustomAttributes<DebuggerHiddenAttribute>().Any() ||
method.DeclaringType.GetTypeInfo().GetCustomAttributes<DebuggerHiddenAttribute>().Any())
{
return null;
}
return $"{method.DeclaringType.ToString()}.{method.Name}({string.Join(", ", method.GetParameters().Select(p => p.ToString()))})";
}
/// <summary>
/// Matches a method with the pointuct
/// </summary>
/// <param name="method">The method to match</param>
/// <param name="type"></param>
/// <returns>True if the pointcut matched the method, otherwise false</returns>
public bool IsAttributeMatch(MethodBase method, Type type)
{
Type signatureType = GetSignatureType();
if (signatureType == null)
return false;
if (method.GetCustomAttributes(signatureType, true).Length > 0)
return true;
else
return false;
}
public static bool IsConditionalMethodExcluded (MethodBase mb, Location loc)
{
object excluded = analyzed_method_excluded [mb];
if (excluded != null)
return excluded == TRUE ? true : false;
if (TypeManager.conditional_attribute_type == null)
return false;
ConditionalAttribute[] attrs = mb.GetCustomAttributes (TypeManager.conditional_attribute_type, true)
as ConditionalAttribute[];
if (attrs.Length == 0) {
analyzed_method_excluded.Add (mb, FALSE);
return false;
}
foreach (ConditionalAttribute a in attrs) {
if (loc.CompilationUnit.IsConditionalDefined (a.ConditionString)) {
analyzed_method_excluded.Add (mb, FALSE);
return false;
}
}
analyzed_method_excluded.Add (mb, TRUE);
return true;
}
private static void RunMethod(MethodBase specificTest, object test, FullRunDescription report, bool log)
{
try
{
specificTest.Invoke(test, new object[] { });
}
catch (Exception e)
{
if (specificTest.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false).Length == 0)
{
if (CheckContext.DefaulNegated == false)
{
return;
}
throw;
}
Type expectedType =
((ExpectedExceptionAttribute)
specificTest.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false)[0]).ExpectedException;
if (e.InnerException != null)
{
if (e.InnerException is FluentCheckException)
{
var fluExc = e.InnerException as FluentCheckException;
var desc = GetCheckAndType(fluExc);
if (desc != null)
{
var method = desc.Check;
var testedtype = desc.CheckedType;
desc.ErrorSampleMessage = fluExc.Message;
// are we building a report
if (log)
{
Log(
string.Format(
"Check.That({1} sut).{0} failure message\n****\n{2}\n****",
method.Name,
testedtype.Name,
fluExc.Message));
}
if (report != null)
{
report.AddEntry(desc);
}
if (CheckContext.DefaulNegated == false)
{
Log(string.Format("(Forced) Negated test '{0}' should have succeeded, but it failed (method {1}).", specificTest.Name, desc.Signature));
}
}
else
{
Log(string.Format("Failed to parse the method signature {0}", specificTest.Name));
}
return;
}
if (report != null)
{
Log(
string.Format(
"{0} did not generate a fluent check:\n{1}",
specificTest.Name,
e.InnerException.Message));
}
if (e.InnerException.GetType() != expectedType && expectedType != null)
{
throw;
}
}
else
{
if (report != null)
{
Log(string.Format("{0} failed to run:\n{1}", specificTest.Name, e));
}
throw;
}
}
}
public static string DocOneInfo(MethodBase info, string name, bool includeSelf) {
// Look for methods tagged with [Documentation("doc string for foo")]
object[] attrs = info.GetCustomAttributes(typeof(DocumentationAttribute), false);
if (attrs.Length > 0) {
Debug.Assert(attrs.Length == 1);
DocumentationAttribute doc = attrs[0] as DocumentationAttribute;
return doc.Documentation;
}
string defaultDoc = GetDefaultDocumentation(name);
if (defaultDoc != null) {
return defaultDoc;
}
return CreateAutoDoc(info, name, 0, includeSelf);
}
private bool IsPassContext (MethodBase method) {
object[] method_attrs = method.GetCustomAttributes (typeof (PassContextAttribute), true);
return (method_attrs != null && method_attrs.Length > 0);
}
/// <summary>
/// Gets a methods attribute.
/// </summary>
/// <param name="method">The method.</param>
/// <returns></returns>
private Attribute GetAttribute(MethodBase method)
{
var key = GetMethodSignature(method);
if(SignatureCache.ContainsKey(key)) {
return SignatureCache[key];
}
var attributes = from attr in method.GetCustomAttributes(false)
where attr.GetType().Equals(TargetAttribute)
select attr;
if(attributes.Any()) {
var attribute = (Attribute)attributes.First();
SignatureCache.Add(key, attribute);
return attribute;
}
return null;
}
private static MethodMapping CreateMethodMapping(TypeMapping type, MethodBase method, int index)
{
var display = method.GetCustomAttributes(false).OfType<DisplayAttribute>().SingleOrDefault();
return new MethodMapping
{
ID = Guid.NewGuid().ToString("N"),
Name = display == null ? method.IsConstructor ? "New" : method.Name : display.GetName(),
MethodName = method.Name,
Parameters = method.GetParameters(),
Index = index,
Type = type,
ReturnType = method is ConstructorInfo ? typeof(void) : ((MethodInfo)method).ReturnType,
UnderlineAction = method.IsConstructor ? RunningObjectsAction.Create : RunningObjectsAction.Execute,
Visible = !ScriptOnlyAttribute.Contains(method),
Method = method
};
}
