public void VisitEnd(EndMethods end)
{
if (m_notSerializable && m_hasMethod)
{
Reporter.TypeFailed(end.Type, CheckID, string.Empty);
}
}
public void VisitEnd(EndMethods end)
{
if (m_names.Count >= 5)
{
m_names.Sort();
string details = "Names: " + string.Join(" ", m_names.ToArray());
Log.DebugLine(this, details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
public void VisitEnd(EndMethods end)
{
if (m_disposable)
{
string details = string.Empty;
if (!m_hasUnaryDispose) // DisposableRule will verify protected and virtual
details += "The type is unsealed, but does not have Dispose(bool)." + Environment.NewLine;
details = details.Trim();
if (details.Length > 0)
{
Log.DebugLine(this, "Details: {0}", details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
}
public void VisitEnd(EndMethods end)
{
if (m_foundEquals)
{
// for (int i = 0; i < end.Type.Interfaces.Count; ++i)
// {
// TypeReference t = end.Type.Interfaces[i];
// Log.DebugLine(this, "implements: {0}", t.FullName);
// }
if (!end.Type.TypeImplements("System.IEquatable"))
{
Log.DebugLine(this, "doesn't implement IEquatable");
Reporter.TypeFailed(end.Type, CheckID, string.Empty);
}
}
}
public void VisitEnds(EndMethods end)
{
m_table.Add(end.Type, m_current);
m_current = null;
}
public void VisitEnd(EndMethods end)
{
if (m_fields.Count > 0)
{
string details = "Fields: " + string.Join(" ", m_fields.ToArray());
Log.DebugLine(this, "{0}", details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
public void VisitEnd(EndMethods end)
{
string details = string.Empty;
foreach (Property prop in m_properties)
{
if (prop.HasTrivialGetter && prop.HasTrivialSetter)
{
foreach (EqualityMethod method in m_equalities)
{
if (method.ChecksSomething)
if (!method.ChecksField(prop.Field) && !method.ChecksProp(prop.Name))
details += string.Format("{0} does not check {1}", method.Name, prop.Name) + Environment.NewLine;
}
}
}
details = details.Trim();
if (details.Length > 0)
{
Log.DebugLine(this, "Details: {0}", details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
public void VisitEnd(EndMethods end)
{
string details = string.Empty;
if (m_disposeMethod != null && !m_hasBaseCall)
{
MethodDefinition pmethod = m_disposeMethod.GetBasestMethod(Cache);
if (pmethod != null && pmethod != m_disposeMethod && !pmethod.IsAbstract)
details += "Dispose(bool) does not call base.Dispose(bool)" + Environment.NewLine;
}
if (m_hasFinalizer)
details += "Type has a finalizer" + Environment.NewLine;
// if (m_disposable && end.Type.TypeImplements("System.IDisposable"))
// details += "Type re-implements IDisposable" + Environment.NewLine;
if (m_hasDispose)
details += "Type has a Dispose() method" + Environment.NewLine;
details = details.Trim();
if (details.Length > 0)
{
Log.DebugLine(this, "Details: {0}", details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
internal void Dispatch(EndMethods methods)
{
DoVisit(methods);
}
public void VisitEnd(EndMethods end)
{
if (m_needsCheck && m_table.Count >= 4)
{
float cohesion = DoGetCohesion();
string details = string.Format("Cohesion: {0:0.0}", cohesion);
Log.DebugLine(this, details);
if (cohesion < 0.5)
{
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
}
public void VisitEnd(EndMethods end)
{
Unused.Value = end;
foreach (KeyValuePair<int, List<CodeBlock>> entry in m_table)
{
Log.DebugLine(this, "there are {0} blocks of length {1}", entry.Value.Count, entry.Key);
while (entry.Value.Count > 1)
{
string details = string.Empty;
CodeBlock block = entry.Value[0];
for (int i = 1; i < entry.Value.Count;)
{
if (DoMatch(entry.Value[0], entry.Value[i], entry.Key))
{
details += entry.Value[i].Method.ToString() + " ";
DoSanitize(entry.Value[i].Method);
}
else
++i;
}
if (details.Length > 0)
{
details = "Match: " + details;
Log.DebugLine(this, details);
int offset = block.Instructions[block.Index].Untyped.Offset;
Reporter.MethodFailed(block.Method, CheckID, offset, details);
}
DoSanitize(block.Method);
}
}
}
public void VisitEnd(EndMethods end)
{
Log.DebugLine(this, " {0} types", m_types.Count);
if (m_types.Count >= m_maxTypes)
{
Log.TraceLine(this, "{0} references {1} types:", m_type.FullName, m_types.Count);
foreach (string type in m_types)
Log.TraceLine(this, " {0}", type);
string details = string.Format("references {0} types", m_types.Count);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
private void DoCheckMethods(AssemblyCache cache, string[] onlyType)
{
Profile.Start("CheckMethods");
foreach (KeyValuePair<TypeDefinition, List<MethodInfo>> entry in cache.TypeMethods)
{
if (DoNameNeedsCheck(entry.Key.FullName, onlyType))
{
BeginMethods begin = new BeginMethods(entry.Key);
m_checker.Dispatcher.Dispatch(begin);
foreach (MethodInfo method in entry.Value)
{
m_checker.Check(method);
}
EndMethods end = new EndMethods(entry.Key);
m_checker.Dispatcher.Dispatch(end);
}
}
Profile.Stop("CheckMethods");
}
public void VisitEnd(EndMethods end)
{
if (m_disposable)
{
string details = string.Empty;
if (m_noThrowMethods.Length > 0)
{
details += "Methods which don't throw ObjectDisposedException: " + Environment.NewLine;
details += m_noThrowMethods;
}
if (m_badDisposeNames.Count > 0)
{
details += "Unusual Dispose methods: ";
details += string.Join(" ", m_badDisposeNames.ToArray());
details += Environment.NewLine;
}
if (m_illegalDisposeNames.Count > 0)
{
details += "Bad method names: ";
details += string.Join(" ", m_illegalDisposeNames.ToArray());
details += Environment.NewLine;
}
if (m_hasVirtualDispose)
details += "Dispose() is virtual" + Environment.NewLine;
if (m_hasPublicDispose)
details += "Dispose(bool) is public." + Environment.NewLine;
if (m_hasNonProtectedDispose)
details += "The type is unsealed, but Dispose(bool) is not protected." + Environment.NewLine;
if (m_hasNonVirtualDispose)
details += "The type is unsealed, but Dispose(bool) is not virtual." + Environment.NewLine;
if (m_disposeThrows)
details += "A Dispose methods throws, but does not catch." + Environment.NewLine;
if (m_disposableFields.Count > 0)
{
StringBuilder builder = new StringBuilder();
builder.Append("Fields which are not disposed: ");
foreach (string field in m_disposableFields)
{
int i = field.LastIndexOf(':');
if (i >= 0)
builder.Append(field.Substring(i + 1));
else
builder.Append(field);
builder.Append(' ');
}
details += builder.ToString() + Environment.NewLine;
}
if (m_hasFinalizer && !m_supressWasCalled)
details += "GC.SuppressFinalize was not called" + Environment.NewLine;
if (m_hasNativeFields && m_type.IsValueType)
details += "The type is a value type, but has native fields." + Environment.NewLine;
if (m_hasNullCall)
details += "Dispose calls a method on a field which may be null (because the constructor may have thrown)." + Environment.NewLine;
details = details.Trim();
if (details.Length > 0)
{
Log.DebugLine(this, "Details: {0}", details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
}
public void VisitEnd(EndMethods end)
{
string details = string.Empty;
foreach (FieldDefinition field in m_fields)
{
Entry entry = m_table[field];
if (entry.FoundAdd && !entry.FoundRemove)
details = details + field.Name + " ";
}
if (details.Length > 0)
{
details = "Fields: " + details;
Log.DebugLine(this, "{0}", details);
Reporter.TypeFailed(end.Type, CheckID, details);
}
}
public void VisitEnd(EndMethods end)
{
if (m_needsCheck)
{
Log.DebugLine(this, "Initial partition:");
foreach (Partition p in m_partitions)
Log.DebugLine(this, "{0}", p);
Log.DebugLine(this, " ");
DoCoalesce();
DoClean();
Log.DebugLine(this, "Final partition:");
foreach (Partition p in m_partitions)
Log.DebugLine(this, "{0}", p);
List<Partition> bad = new List<Partition>();
foreach (Partition p in m_partitions)
{
if (p.Fields.Count >= 3 && p.Methods.Count >= 3 && !p.HasVirtual())
bad.Add(p);
}
if (bad.Count >= 2)
{
StringBuilder b = new StringBuilder();
foreach (Partition p in bad)
{
if (p == bad[bad.Count - 1])
b.Append(p.ToString());
else
b.AppendLine(p.ToString());
}
Reporter.TypeFailed(end.Type, CheckID, b.ToString());
}
}
}
