/// <summary>
/// Adds the methods of the given type to the method order as well
/// as recursively calling AddType on nested types within the given type.
/// Call this with every top-level type to be analyzed.
/// Internally called with nested types as well.
/// </summary>
public void AddType(Type type)
{
//TODO:0 HACK HACK HACK for the TechFest demo
// If it is a compiler generated class, we skip it
foreach (Attribute a in this.md.GetAttributes(type))
{
string fullname = md.FullName(md.AttributeType(a));
if (fullname == "System.CodeDom.Compiler.GeneratedCodeAttribute")
{
return;
}
if (fullname == "System.Diagnostics.Contracts.ContractClassForAttribute")
{
return;
}
}
foreach (Method method in md.Methods(type))
{
if (md.Name(method) == "ObjectInvariant")
{
// ignore contract helper method
continue;
}
this.AddMethod(method);
}
foreach (Type nested in md.NestedTypes(type))
{
this.AddType(nested);
}
}
public static bool TryGetMethodHashAttribute <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(
this IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> metaDataDecoder,
Method method,
out MethodHashAttribute mhAttr)
{
Contract.Requires(metaDataDecoder != null);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out mhAttr) != null);
#if false // dead code???
if (false && method.Equals(cache.One)) // problem: successive analyses are run in the same worker
{
mhAttr = cache.Two;
return(mhAttr != null);
}
#endif
mhAttr = null;
foreach (var attr in metaDataDecoder.GetAttributes(method))
{
var attrType = metaDataDecoder.AttributeType(attr);
if (metaDataDecoder.FullName(attrType) == NameFor.MethodHashAttribute)
{
mhAttr = MethodHashAttribute.FromDecoder(metaDataDecoder.PositionalArguments(attr));
if (mhAttr != null)
{
break;
}
}
}
cache = Pair.For <object, MethodHashAttribute>(method, mhAttr);
return(mhAttr != null);
}
private static bool TryAddAttribute(Set <String> mask, Attribute attrib,
IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder,
out string attribName)
{
Contract.Requires(mask != null);
Contract.Requires(mdDecoder != null);
attribName = null;
var attribType = mdDecoder.AttributeType(attrib);
if (mdDecoder.Name(attribType) == "SuppressMessageAttribute")
{
var args = mdDecoder.PositionalArguments(attrib);
Contract.Assume(args != null);
if (args.Count < 2)
{
return(false);
}
var name = (string)args[0];
if (name == "Microsoft.Contracts")
{
attribName = (string)args[1];
mask.Add(attribName);
return(true);
}
}
return(false);
}
public static MethodRegressionOutcomes GetOutcomes <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(Method method, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder)
{
if (mdDecoder.GetMethodHashAttributeFlags(method).HasFlag(MethodHashAttributeFlags.IgnoreRegression))
{
return(new IgnoreRegressionOutcomes());
}
var outcomes = new Set <string>();
foreach (Attribute attr in mdDecoder.GetAttributes(method))
{
var attrType = mdDecoder.AttributeType(attr);
if (mdDecoder.Name(attrType) != "RegressionOutcomeAttribute")
{
continue;
}
var posArgs = mdDecoder.PositionalArguments(attr);
if (posArgs.Count == 0)
{
var outcome = (ProofOutcome)(byte)GetNamedArgOrDefault <int, Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(mdDecoder, "Outcome", attr);
// at some places we have "this.x" instead of "x", both should be treated equal.
string msg = ((string)mdDecoder.NamedArgument("Message", attr)).Replace("this.", string.Empty);
int primaryOffset = GetNamedArgOrDefault <int, Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(mdDecoder, "PrimaryILOffset", attr);
int methodOffset = GetNamedArgOrDefault <int, Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(mdDecoder, "MethodILOffset", attr);
outcomes.Add(CanonicalFormat(outcome, msg, primaryOffset, methodOffset));
}
else
{
outcomes.Add((string)posArgs[0]);
}
}
return(new MethodRegressionOutcomes(outcomes));
}
public static AssemblyRegressionOutcomes GetOutcomes <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(Assembly assembly, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder)
{
Set <string> outcomes = new Set <string>();
foreach (Attribute attr in mdDecoder.GetAttributes(assembly))
{
Type attrType = mdDecoder.AttributeType(attr);
if (mdDecoder.Name(attrType) != "RegressionOutcomeAttribute")
{
continue;
}
string expectedString = (string)mdDecoder.PositionalArguments(attr)[0];
outcomes.Add(expectedString);
}
return(new AssemblyRegressionOutcomes(outcomes));
}
/// <summary>
/// Adds the methods of the given type to the method order as well
/// as recursively calling AddType on nested types within the given type (if necessary).
/// Call this with every top-level type to be analyzed.
/// Internally called with nested types as well.
/// </summary>
public virtual void AddType(Type type)
{
foreach (var a in this.md.GetAttributes(type))
{
var fullname = this.md.FullName(md.AttributeType(a));
if (fullname == "System.Diagnostics.Contracts.ContractClassForAttribute")
{
return;
}
}
foreach (var method in this.md.Methods(type).OrderBy(m => md.FullName(m)))
{
if (this.IsObjectInvariantMethod(method))
{
continue; // ignore contract helper method
}
if (this.md.IsConstructor(method))
{
continue; // added separately
}
this.AddMethod(method);
}
// add constructors so they have a chance to be analyzed first
foreach (var method in this.md.Methods(type))
{
if (this.md.IsConstructor(method) && !this.md.IsMethodHashAttributeConstructor(method))
{
this.AddMethod(method);
}
}
foreach (var nested in this.md.NestedTypes(type))
{
this.AddType(nested);
}
}
public static int GetReanalyisCountIfAny <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(Method method, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder)
{
if (mdDecoder.GetMethodHashAttributeFlags(method).HasFlag(MethodHashAttributeFlags.IgnoreRegression))
{
return(0);
}
foreach (Attribute attr in mdDecoder.GetAttributes(method))
{
Type attrType = mdDecoder.AttributeType(attr);
if (mdDecoder.Name(attrType) != "RegressionReanalysisCountAttribute")
{
continue;
}
var posArgs = mdDecoder.PositionalArguments(attr);
if (posArgs.Count != 0)
{
return((int)posArgs[0]);
}
}
return(0);
}
internal static bool IsMaskedInType(Type t,
IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder,
string maskingString)
{
Contract.Requires(mdDecoder != null);
Contract.Ensures(!Contract.Result <bool>() || maskingString != null);
if (maskingString == null)
{
return(false);
}
foreach (var attrib in mdDecoder.GetAttributes(t))
{
var attribType = mdDecoder.AttributeType(attrib);
if (mdDecoder.Name(attribType) == "SuppressMessageAttribute")
{
var args = mdDecoder.PositionalArguments(attrib);
Contract.Assume(args != null);
if (args.Count < 2)
{
return(false);
}
var name = (string)args[0];
if (name == "Microsoft.Contracts" && ((args[1] as string) == maskingString))
{
return(true);
}
}
}
return(false);
}
public static bool IsObjectInvariantMethod <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(
this IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> metaDataDecoder,
Method method)
{
Contract.Requires(metaDataDecoder != null);
if (metaDataDecoder.Name(method) == NameFor.ObjectInvariantMethodName)
{
return(true);
}
return(metaDataDecoder.GetAttributes(method).Any(attr => metaDataDecoder.Name(metaDataDecoder.AttributeType(attr)) == NameFor.ObjectInvariantMethodAttribute));
}