/// <summary>
/// Performs class hierarchy checking.
/// </summary>
/// <param name="type">Specified type for checking.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData sharedData)
{
try
{
if (type == null)
{
return;
}
var baseType = type.BaseType;
if (baseType == null || sharedData.UsedTypes.Contains(baseType.AssemblyQualifiedName()))
{
sharedData.AddToUsedTypes(type.AssemblyQualifiedName());
return;
}
IMetadataScope forwardedFrom;
var baseTypeDef = baseType.Resolve(out forwardedFrom);
sharedData.RemoveFromCandidates(forwardedFrom);
if (baseTypeDef != null)
{
sharedData.RemoveFromCandidates(baseTypeDef.Scope);
}
Check(baseTypeDef, sharedData);
sharedData.AddToUsedTypes(type.AssemblyQualifiedName());
}
catch (Exception ex)
{
throw Error.CheckType(type.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckTypeHierarchyException, type.AssemblyQualifiedName()), ex);
}
}
/// <summary>
/// Check arguments of custom attribute.
/// </summary>
/// <param name="attributeArgs">The list of custom attribute arguments (types).</param>
private void CheckCustomAttributes(IEnumerable <CustomAttributeArgument> attributeArgs)
{
IMetadataScope forwardedFrom;
foreach (CustomAttributeArgument customAttributeArgument in attributeArgs)
{
TypeDefinition typeDefinition = customAttributeArgument.Value is TypeReference
? (customAttributeArgument.Value as TypeReference).Resolve(out forwardedFrom)
: customAttributeArgument.Type.Resolve(out forwardedFrom);
_sharedData.RemoveFromCandidates(forwardedFrom);
if (typeDefinition != null && !_sharedData.IsUsedTypeExists(typeDefinition.AssemblyQualifiedName()))
{
_sharedData.RemoveFromCandidates(typeDefinition.Scope);
if (!_sharedData.HasCandidateReferences)
{
return;
}
_sharedData.AddToUsedTypes(typeDefinition.AssemblyQualifiedName());
_interfaceCheckHelper.Check(typeDefinition, _sharedData);
}
}
}
/// <summary>
/// Performs checking of type's interfaces.
/// </summary>
/// <param name="type">Specified type for checking.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData sharedData)
{
try
{
IMetadataScope forwardedFrom;
foreach (TypeReference interfaceRef in type.GetInterfaces())
{
var interfaceDef = interfaceRef.Resolve(out forwardedFrom);
sharedData.RemoveFromCandidates(forwardedFrom);
if (interfaceDef != null)
{
if (interfaceDef.IsImport)
{
_importedCheckHelper.Check(interfaceDef, sharedData);
}
else
{
sharedData.RemoveFromCandidates(interfaceDef.Scope);
}
sharedData.AddToUsedTypes(interfaceDef.AssemblyQualifiedName());
}
if (!sharedData.HasCandidateReferences)
{
return;
}
}
}
catch (Exception ex)
{
throw Error.CheckType(type.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckTypeInterfacesException, type.AssemblyQualifiedName()), ex);
}
}
public void Analyze(AssemblyDefinition assemblyDefinition, ModuleDefinition moduleDefinition, TypeDefinition typeDefinition)
{
var attr = typeDefinition.GetAttribute <NodeLayoutHandlerAttribute>();
var targetType = ((TypeReference)attr.ConstructorArguments[0].Value).Resolve();
handlers[targetType.AssemblyQualifiedName()] = new SerializableType(typeDefinition.AssemblyQualifiedName());
}
public void Analyze(AssemblyDefinition assemblyDefinition, ModuleDefinition moduleDefinition, TypeDefinition typeDefinition)
{
foreach (var fd in filterData)
{
if (fd.filter.IsValid(typeDefinition))
{
fd.filteredTypes.Add(new SerializableType(typeDefinition.AssemblyQualifiedName()));
updateCacheForAssembly = true;
}
}
}
public void Analyze(AssemblyDefinition assemblyDefinition, ModuleDefinition moduleDefinition, TypeDefinition typeDefinition, MethodDefinition methodDefinition)
{
var attr = methodDefinition.GetAttribute <ActionAttribute>();
if (attr.ConstructorArguments.Count < 2)
{
return;
}
TypeDefinition actionTypeDef = ((TypeReference)attr.ConstructorArguments[0].Value).Resolve();
string identifier = (string)attr.ConstructorArguments[1].Value;
TypeDefinition configTypeDef = attr.ConstructorArguments.Count >= 3 ? ((TypeReference)attr.ConstructorArguments[2].Value).Resolve() : null;
string displayName = attr.ConstructorArguments.Count >= 4 ? (string)attr.ConstructorArguments[3].Value : null;
string subIdentifier = attr.ConstructorArguments.Count == 5 ? (string)attr.ConstructorArguments[4].Value : string.Empty;
if (string.IsNullOrEmpty(subIdentifier))
{
subIdentifier = ActionSchema.DefaultSubIdentifier;
}
var actionTypeQualifiedName = actionTypeDef.FullName + ", " + actionTypeDef.Module.Assembly.FullName;
var configTypeQualifiedName = configTypeDef == null ? null : configTypeDef.FullName + ", " + configTypeDef.Module.Assembly.FullName;
var configType = new SerializableType(configTypeQualifiedName);
var method = new SerializableMethod(typeDefinition.AssemblyQualifiedName(), methodDefinition.Name);
var actionMethod = new ActionSchema.Action.Variant
{
config = configType,
call = method
};
if (!actions.TryGetValue(identifier, out ActionSchema.Action action))
{
action = new ActionSchema.Action
{
identifier = identifier,
displayName = displayName,
action = new SerializableType(actionTypeQualifiedName)
};
actions[identifier] = action;
}
Debug.Log(method.Value);
if (action.variants.ContainsKey(subIdentifier))
{
Debug.LogError($"Duplicate Sub-Identifiers found for identifier '{identifier}': '{subIdentifier}'");
}
action.variants[subIdentifier] = actionMethod;
}
/// <summary>
/// Performs type's attributes checking.
/// </summary>
/// <param name="type">The specified type.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData sharedData)
{
try
{
_sharedData = sharedData;
foreach (var checkAction in _checkActionList)
{
checkAction(type);
if (!_sharedData.HasCandidateReferences)
{
return;
}
}
}
catch (Exception ex)
{
throw Error.CheckType(type.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckTypeAttributesException, type.AssemblyQualifiedName()), ex);
}
}
public void Analyze(AssemblyDefinition assemblyDefinition, ModuleDefinition moduleDefinition, TypeDefinition typeDefinition, MethodDefinition methodDefinition)
{
var attr = methodDefinition.GetAttribute <FieldOperationAttribute>();
if (attr.ConstructorArguments.Count != 5)
{
return;
}
string identifier = (string)attr.ConstructorArguments[0].Value;
TypeDefinition configTypeDef = ((TypeReference)attr.ConstructorArguments[1].Value).Resolve();
string displayName = (string)attr.ConstructorArguments[2].Value;
string subIdentifier = (string)attr.ConstructorArguments[3].Value;
TypeDefinition outputTypeRef = ((TypeReference)attr.ConstructorArguments[4].Value).Resolve();
var outputTypeQualifiedName = outputTypeRef.AssemblyQualifiedName();
var configTypeQualifiedName = configTypeDef?.AssemblyQualifiedName();
var configType = new SerializableType(configTypeQualifiedName);
var outputType = new SerializableType(outputTypeQualifiedName);
var method = new SerializableMethod(typeDefinition.AssemblyQualifiedName(), methodDefinition.Name);
var opCall = new FieldOperationSchema.Operation.Variant
{
displayName = displayName,
configType = configType,
method = method,
outputType = outputType
};
if (!operations.TryGetValue(identifier, out FieldOperationSchema.Operation op))
{
op = new FieldOperationSchema.Operation
{
identifier = identifier
};
operations[identifier] = op;
}
if (op.callVariants.ContainsKey(subIdentifier))
{
Debug.LogError($"Duplicate Sub-Identifiers found for identifier '{identifier}': '{subIdentifier}'");
}
op.callVariants[subIdentifier] = opCall;
}
public void Analyze(AssemblyDefinition assemblyDefinition, ModuleDefinition moduleDefinition, TypeDefinition typeDefinition)
{
var attr = typeDefinition.GetAttribute <ActionArgumentAttribute>();
var delegateTypeReference = assemblyDefinition.MainModule.ImportReference(typeof(Delegate));
var multicastDelegateTypeReference = assemblyDefinition.MainModule.ImportReference(typeof(MulticastDelegate));
var actionDelegateTypeDefinition = ((TypeReference)attr.ConstructorArguments[0].Value).Resolve();
var delegateType = new SerializableType(actionDelegateTypeDefinition.AssemblyQualifiedName());
var parameterName = (string)attr.ConstructorArguments[1].Value;
var field = typeDefinition.Fields[0];
if (actionDelegateTypeDefinition.BaseType.FullName != delegateTypeReference.FullName && actionDelegateTypeDefinition.BaseType.FullName != multicastDelegateTypeReference.FullName)
{
Debug.LogError("Not Delegate");
return;
}
var parameter = actionDelegateTypeDefinition.Methods.First(m => m.Name == "Invoke").Parameters.FirstOrDefault(parameter => parameter.Name == parameterName);
if (parameter == null || parameter.ParameterType.FullName != field.FieldType.FullName)
{
Debug.LogError("Unknown parameter");
return;
}
if (!data.TryGetValue(delegateType.AssemblyQualifiedName, out Dictionary <string, ActionArgumentComponentSchema.ActionArgumentComponent> argumentComponents))
{
argumentComponents = new Dictionary <string, ActionArgumentComponentSchema.ActionArgumentComponent>();
data[delegateType.AssemblyQualifiedName] = argumentComponents;
}
argumentComponents[parameterName] = new ActionArgumentComponentSchema.ActionArgumentComponent
{
delegateType = delegateType,
componentType = new SerializableType(typeDefinition.AssemblyQualifiedName()),
parameterName = parameterName,
fieldName = field.Name,
singletonTarget = parameter.CustomAttributes.Any(a => a.AttributeType.FullName == typeof(SingletonArgumentAttribute).FullName)
};
}
public static bool IsValid(this TypeFilter filter, TypeDefinition definition)
{
return(filter.IsValid(Type.GetType(definition.AssemblyQualifiedName())));
}
