public override void ProcessType(TypeDefinition type)
{
if (!type.Inherits ("Android.App.Application"))
return;
ProcessAttributeProvider (type);
}
private void CheckCallingBaseMethod (TypeDefinition type, MethodSignature methodSignature)
{
MethodDefinition method = type.GetMethod (methodSignature);
if (method == null)
return; // Perhaps should report that doesn't exist the method (only with ctor).
foreach (Instruction instruction in method.Body.Instructions) {
if (instruction.OpCode.FlowControl == FlowControl.Call) {
MethodReference operand = (MethodReference) instruction.Operand;
if (methodSignature.Matches (operand) && type.Inherits (operand.DeclaringType.ToString ()))
return;
}
}
Runner.Report (method, Severity.High, Confidence.High, String.Format ("The method {0} isn't calling its base method.", method));
}
static bool IsImplementor(TypeDefinition type)
{
return type.Name.EndsWith ("Implementor") && type.Inherits ("Java.Lang.Object");
}
static bool IsTypeConverter(TypeDefinition type)
{
return type.Inherits ("System.ComponentModel", "TypeConverter");
}
static bool IsWebServiceClient (TypeDefinition type)
{
return type.Inherits ("System.Web.Services.Protocols", "SoapHttpClientProtocol");
}
public RuleResult CheckType(TypeDefinition type)
{
if (type.IsEnum || type.IsInterface || !type.HasFields)
return RuleResult.DoesNotApply;
Log.WriteLine (this);
Log.WriteLine (this, "----------------------------------");
bool isWinFormControl = usesWinForms && type.Inherits ("System.Windows.Forms", "Control");
// All fields start out as always null and unused.
foreach (FieldDefinition field in type.Fields) {
if (field.IsPrivate && !field.FieldType.IsValueType)
if (!isWinFormControl || field.Name != "components") // the winforms designer seems to like to leave this null
nullFields.Add (field);
}
CheckMethods (type);
if (type.HasNestedTypes) {
foreach (TypeDefinition nested in type.NestedTypes)
CheckMethods (nested);
}
// Report a defect if:
// 1) The field is explicitly set to null and not used (if
// if is implicitly set to null and not used AvoidUnusedPrivateFieldsRule
// will catch it).
setFields.IntersectWith (nullFields);
setFields.ExceptWith (usedFields);
if (setFields.Count > 0) {
foreach (FieldDefinition field in setFields) {
Log.WriteLine (this, "{0} is always null", field.Name);
Runner.Report (field, Severity.Medium, Confidence.High);
}
}
// 2) The field is always null and used somewhere.
nullFields.IntersectWith (usedFields);
if (nullFields.Count > 0) {
foreach (FieldDefinition field in nullFields) {
Log.WriteLine (this, "{0} is always null", field.Name);
Runner.Report (field, Severity.Medium, Confidence.High);
}
}
nullFields.Clear ();
setFields.Clear ();
usedFields.Clear ();
return Runner.CurrentRuleResult;
}
public RuleResult CheckType (TypeDefinition type)
{
// rule apply only to type that inherits from System.Exception
if (!type.Inherits (Exception))
return RuleResult.DoesNotApply;
// rule applies, only Success or Failure from the point on
// check if the type implements all the needed exception constructors
bool empty_ctor = false; // MyException ()
bool string_ctor = false; // MyException (string message)
bool inner_exception_ctor = false; // MyException (string message, Exception innerException)
bool serialization_ctor = false; // MyException (SerializationInfo info, StreamingContext context)
foreach (MethodDefinition ctor in type.GetConstructors ()) {
// skip cctor
if (ctor.IsStatic)
continue;
if (!ctor.HasParameters) {
// there can be only one so only it's visibility matters
empty_ctor = ctor.IsPublic;
continue;
}
switch (ctor.Parameters.Count) {
case 1:
string_ctor |= CheckForStringConstructor (ctor);
break;
case 2:
if (ctor.IsPublic) {
if (!inner_exception_ctor) {
inner_exception_ctor = CheckForInnerExceptionConstructor (ctor);
if (inner_exception_ctor)
break;
}
string_ctor |= CheckForStringConstructor (ctor);
} else {
serialization_ctor |= CheckForSerializationConstructor (ctor);
}
break;
default:
inner_exception_ctor |= CheckForInnerExceptionConstructor (ctor);
break;
}
}
if (!empty_ctor) {
string s = String.Format (MissingConstructor, "public", type.Name, "()");
Runner.Report (type, Severity.High, Confidence.Total, s);
}
if (!string_ctor) {
string s = String.Format (MissingConstructor, "public", type.Name, "(string message)");
Runner.Report (type, Severity.High, Confidence.Total, s);
}
if (!inner_exception_ctor) {
string s = String.Format (MissingConstructor, "public", type.Name,
"(string message, Exception innerException)");
Runner.Report (type, Severity.High, Confidence.Total, s);
}
if (!serialization_ctor) {
string s = String.Format (MissingConstructor, (type.IsSealed) ? "private" : "protected",
type.Name, "(SerializationInfo info, StreamingContext context)");
Runner.Report (type, Severity.High, Confidence.Total, s);
}
return Runner.CurrentRuleResult;
}
public RuleResult CheckType (TypeDefinition type)
{
if (!type.IsClass || !type.HasMethods || !type.Inherits ("System.Windows.FrameworkElement"))
return RuleResult.DoesNotApply;
var arrangeOverride = type.GetMethod (arrangeSignature);
var measureOverride = type.GetMethod (measureSignature);
// The class doesn't have either method.
if (arrangeOverride == null && measureOverride == null)
return RuleResult.DoesNotApply;
// Only ArrangeOverride provided.
if (arrangeOverride != null && measureOverride == null)
Runner.Report (arrangeOverride, Severity.High, Confidence.Total);
// Only MeasureOverride provided.
if (measureOverride != null && arrangeOverride == null)
Runner.Report (measureOverride, Severity.High, Confidence.Total);
return Runner.CurrentRuleResult;
}
