private void CheckCallingBaseMethod(TypeReference type, MethodSignature methodSignature)
{
MethodDefinition method = type.GetMethod (methodSignature);
if (method == null)
return; // Perhaps should report that doesn't exist the method (only with ctor).
// is there any Call or Callvirt instructions in the method
if (OpCodeBitmask.Calls.Intersect (OpCodeEngine.GetBitmask (method))) {
// in this case we check further
foreach (Instruction instruction in method.Body.Instructions) {
if (instruction.OpCode.FlowControl != FlowControl.Call)
continue;
MethodReference operand = (MethodReference) instruction.Operand;
TypeReference tr = operand.DeclaringType;
if (methodSignature.Matches (operand) && type.Inherits (tr.Namespace, tr.Name))
return;
}
}
Runner.Report (method, Severity.High, Confidence.High);
}
private static bool DoesAllSignaturesMatchType (TypeReference type, IEnumerable<MethodSignature> signatures)
{
bool match = true;
foreach (MethodSignature signature in signatures) {
match &= (null != type.GetMethod (signature));
}
return match;
}
private bool CheckDelegate (TypeReference type)
{
MethodReference invoke = type.GetMethod (MethodSignatures.Invoke);
if (invoke == null)
return false;
// we cannot short-circuit since we would miss reporting some defects
bool valid = CheckReturnVoid (type, invoke);
valid &= CheckAmountOfParameters (type, invoke);
valid &= CheckParameterTypes (type, invoke);
IList<ParameterDefinition> pdc = invoke.Parameters;
if (pdc.Count > 0) {
valid &= CheckParameterName (type, pdc [0], "sender");
if (pdc.Count > 1)
valid &= CheckParameterName (type, pdc [1], "e");
}
return valid;
}
private void GetMethods (TypeReference type)
{
string full_name = type.GetFullName ();
args1 [0] = full_name;
AddMethod (type.GetMethod (MethodSignatures.Equals));
AddMethod (type.GetMethod ("Equals", "System.Boolean", args1));
AddMethod (type.GetMethod ("CompareTo", "System.Int32", args1)); // generic version
AddMethod (type.GetMethod (CompareTo)); // non-generic version
// Note that we don't want to use MethodSignatures for these
// because we don't want any weird overloads.
args2 [0] = full_name;
args2 [1] = full_name;
AddMethod (type.GetMethod ("op_Equality", "System.Boolean", args2));
AddMethod (type.GetMethod ("op_Inequality", "System.Boolean", args2));
AddMethod (type.GetMethod ("op_LessThan", "System.Boolean", args2));
AddMethod (type.GetMethod ("op_LessThanOrEqual", "System.Boolean", args2));
AddMethod (type.GetMethod ("op_GreaterThan", "System.Boolean", args2));
AddMethod (type.GetMethod ("op_GreaterThanOrEqual", "System.Boolean", args2));
clone.Method = type.GetMethod (MethodSignatures.Clone);
hash.Method = type.GetMethod (MethodSignatures.GetHashCode);
}
private RuleResult CheckDelegate (TypeReference type)
{
MethodDefinition method = type.GetMethod ("Invoke");
// MulticastDelegate inherits from Delegate without overriding Invoke
if ((method != null) && HasMoreParametersThanAllowed (method))
Runner.Report (type, Severity.Medium, Confidence.Normal, "This delegate contains a long parameter list.");
return Runner.CurrentRuleResult;
}
public static MethodReference?GetGetMethod(this TypeReference type, string property) =>
type.GetMethod("get_" + property);
private void CheckOperatorPair (KeyValuePair<MethodSignature, MethodSignature> pair,
TypeReference type, Severity severity)
{
MethodDefinition op = type.GetMethod (pair.Key);
if (op == null) { //first one not defined
pair = new KeyValuePair<MethodSignature, MethodSignature> (pair.Value, pair.Key); //reverse
op = type.GetMethod (pair.Key);
if (op == null)
return; //neither one is defined
} else {
if (type.HasMethod (pair.Value))
return; //both are defined
}
string s = string.Format (CultureInfo.InvariantCulture, Message, pair.Key.Name, pair.Value.Name);
Runner.Report (op, severity, Confidence.Total, s);
}
private static MethodDefinition GetNonAbstractMethod (TypeReference type, MethodSignature signature)
{
MethodDefinition method = type.GetMethod (signature);
if ((method == null) || method.IsAbstract)
return null;
return method;
}