private void ProcessType(bool? assemblyConfigureAwaitValue, TypeDefinition type)
{
if (type.IsCompilerGenerated() && type.IsIAsyncStateMachine())
{
return;
}
var configureAwaitValue = (bool?)type.GetConfigureAwaitAttribute()?.ConstructorArguments[0].Value;
configureAwaitValue = configureAwaitValue ?? assemblyConfigureAwaitValue;
foreach (var method in type.Methods)
{
var localConfigureAwaitValue = (bool?)method.GetConfigureAwaitAttribute()?.ConstructorArguments[0].Value;
var localConfigWasSet = localConfigureAwaitValue.HasValue;
localConfigureAwaitValue = localConfigureAwaitValue ?? configureAwaitValue;
if (localConfigureAwaitValue == null)
continue;
var asyncStateMachineType = method.GetAsyncStateMachineType();
if (asyncStateMachineType != null)
{
AddAwaitConfigToAsyncMethod(asyncStateMachineType, localConfigureAwaitValue.Value);
}
else if (localConfigWasSet)
{
LogWarning($"ConfigureAwaitAttribue applied to non-async method '{method.FullName}'.");
continue;
}
}
}
public void VisitType(TypeDefinition type)
{
if (type.TypeImplements("System.Collections.IEnumerator") && !type.IsCompilerGenerated())
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "checking {0}", type);
PropertyDefinition[] properties = type.Properties.GetProperties("Current");
bool found = false;
foreach (PropertyDefinition prop in properties)
{
if (prop.PropertyType.ToString() != "System.Object")
{
found = true;
break;
}
}
if (!found)
{
Log.DebugLine(this, "no strongly typed Current");
Reporter.TypeFailed(type, CheckID, string.Empty);
}
}
}
public static MethodDefinition GetOriginalCodeLocation(TypeDefinition type)
{
if (type != null && type.DeclaringType != null && type.IsCompilerGenerated()) {
MethodDefinition constructor = GetTypeConstructor(type);
return FindMethodUsageInType(type.DeclaringType, constructor);
}
return null;
}
public static bool IsCompilerGeneratedStateMachine(TypeDefinition type)
{
if (!(type.DeclaringType != null && type.IsCompilerGenerated()))
return false;
foreach (TypeReference i in type.Interfaces) {
if (i.Namespace == "System.Runtime.CompilerServices" && i.Name == "IAsyncStateMachine")
return true;
}
return false;
}
public static bool IsCompilerGeneratorEnumerator(TypeDefinition type)
{
if (!(type.DeclaringType != null && type.IsCompilerGenerated()))
return false;
foreach (TypeReference i in type.Interfaces) {
if (i.Namespace == "System.Collections" && i.Name == "IEnumerator")
return true;
}
return false;
}
public void VisitType(TypeDefinition type)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "checking {0}", type);
if (!type.IsCompilerGenerated())
{
if (DoBaseFailed(type) || DoInterfaceFailed(type))
{
Reporter.TypeFailed(type, CheckID, string.Empty);
}
}
}
/// <summary>
/// Given a compiler-generated type, returns the method where that type is used.
/// Used to detect the 'parent method' for a lambda/iterator/async state machine.
/// </summary>
public static MethodDefinition GetOriginalCodeLocation(TypeDefinition type)
{
if (type != null && type.DeclaringType != null && type.IsCompilerGenerated()) {
if (type.IsValueType) {
// Value types might not have any constructor; but they must be stored in a local var
// because 'initobj' (or 'call .ctor') expects a managed ref.
return FindVariableOfTypeUsageInType(type.DeclaringType, type);
} else {
MethodDefinition constructor = GetTypeConstructor(type);
if (constructor == null)
return null;
return FindMethodUsageInType(type.DeclaringType, constructor);
}
}
return null;
}
public void VisitType(TypeDefinition type)
{
DBC.Assert(m_state == State.Types, "state is {0}", m_state);
Log.DebugLine(this, "{0}", type.FullName);
if (!type.ExternallyVisible(Cache) && DoInstantiable(type) && DoValidType(type))
{
if (!type.IsCompilerGenerated())
{
var key = new AssemblyCache.TypeKey(type);
DBC.Assert(m_keys.IndexOf(key) < 0, "{0} is already in types", type.FullName);
Log.DebugLine(this, "adding {0}", type.FullName);
m_keys.Add(key);
}
}
}
public void VisitType(TypeDefinition type)
{
if (!type.IsCompilerGenerated())
{
if (!type.IsSubclassOf("System.Delegate", Cache) && !type.IsSubclassOf("System.MulticastDelegate", Cache))
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", type.FullName);
if (!type.IsValueType && !type.IsInterface && !type.IsBeforeFieldInit)
{
if (type.Name != "<Module>")
Reporter.TypeFailed(type, CheckID, string.Empty);
}
}
}
}
public void VisitType(TypeDefinition type)
{
if (type.IsValueType && !type.IsEnum && !type.IsCompilerGenerated())
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "checking {0}", type);
// Try to find Equals and GetHashCode.
var methods = new List<MethodInfo>();
methods.AddRange(Cache.FindMethods(type, "Equals"));
methods.AddRange(Cache.FindMethods(type, "GetHashCode"));
// Make sure we found the correct ones.
bool foundEquals = false;
for (int i = 0; i < methods.Count && !foundEquals; ++i)
if (methods[i].Method.Reuses("System.Boolean", "Equals", "System.Object"))
foundEquals = true;
bool foundHash = false;
for (int i = 0; i < methods.Count && !foundHash; ++i)
if (methods[i].Method.Reuses("System.Int32", "GetHashCode"))
foundHash = true;
// If not we have a problem.
if (!foundEquals && !foundHash)
{
string details = "Equals and GetHashCode are missing";
Log.DebugLine(this, details);
Reporter.TypeFailed(type, CheckID, details);
}
else if (!foundEquals)
{
string details = "Equals is missing";
Log.DebugLine(this, details);
Reporter.TypeFailed(type, CheckID, details);
}
else if (!foundHash)
{
string details = "GetHashCode is missing";
Log.DebugLine(this, details);
Reporter.TypeFailed(type, CheckID, details);
}
}
}
public void VisitType(TypeDefinition type)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "checking {0}", type);
if (!type.IsCompilerGenerated())
{
if (!type.IsAbstract)
// if (!type.IsAbstract && !type.FullName.Contains("PrivateImplementationDetails"))
{
if (type.BaseType != null && type.BaseType.FullName == "System.Object")
{
if (DoHasNoVirtuals(type) && DoAllFieldsAreStatic(type))
{
Log.DebugLine(this, "cab be made static");
Reporter.TypeFailed(type, CheckID, string.Empty);
}
}
}
}
}
public void VisitType(TypeDefinition candidate)
{
if (!candidate.IsAbstract && !candidate.ExternallyVisible(Cache) && candidate.IsClass && !candidate.IsSealed)
{
if (candidate.FullName != "<Module>" && !candidate.IsCompilerGenerated())
{
Log.DebugLine(this, "checking {0}", candidate);
foreach (TypeDefinition type in Cache.Types)
{
if (type.IsSubclassOf(candidate, Cache))
{
// Log.DebugLine(this, " is base class for {0} [{1}]", type, type.BaseType);
return;
}
// else
// Log.DebugLine(this, " not a base class for {0} [{1}]", type, type.BaseType);
}
// Log.DebugLine(this, " failed");
Reporter.TypeFailed(candidate, CheckID, string.Empty);
}
}
}
bool IsPotentialClosure(TypeDefinition potentialDisplayClass)
{
if (potentialDisplayClass == null || !potentialDisplayClass.IsCompilerGenerated())
return false;
// check that methodContainingType is within containingType
while (potentialDisplayClass != context.CurrentType) {
potentialDisplayClass = potentialDisplayClass.DeclaringType;
if (potentialDisplayClass == null)
return false;
}
return true;
}
public static bool IsCompilerGeneratorEnumerator(TypeDefinition type)
{
if (!(type.Name.StartsWith("<", StringComparison.Ordinal) && type.IsCompilerGenerated()))
return false;
foreach (TypeReference i in type.Interfaces) {
if (i.Namespace == "System.Collections" && i.Name == "IEnumerator")
return true;
}
return false;
}
private TypeActionAttribute GetTypeActionAttribute(TypeDefinition provider)
{
var attr = provider.GetCustomAttribute<TypeActionAttribute>();
if (attr != null) {
return attr;
}
switch (ImplicitImports) {
case ImplicitImportSetting.OnlyCompilerGenerated:
if (provider.IsCompilerGenerated()) {
goto case ImplicitImportSetting.ImplicitByDefault;
}
goto case ImplicitImportSetting.NoImplicit;
case ImplicitImportSetting.ImplicitByDefault:
return new NewTypeAttribute(true);
default:
case ImplicitImportSetting.NoImplicit:
return null;
}
}
