public ContractExtractor(ContractNodes contractNodes, AssemblyNode assembly, bool verbose)
{
this.visited_methods = new Dictionary <Method, Method> ();
this.contract_nodes = contractNodes;
this.assembly = assembly;
this.verbose = verbose;
}
public void Save()
{
foreach (NDOTreeNode trn in nodeCollection)
{
DatabaseNode dn = trn as DatabaseNode;
if (dn != null)
{
this.databaseNode = dn;
}
AssemblyNode an = trn as AssemblyNode;
if (an != null)
{
this.assemblyNode = an;
}
}
new MappingGenerator(fileName, databaseNode, assemblyNode).GenerateCode();
XmlDocument doc = new XmlDocument();
doc.Load(fileName);
XmlNode refNode = doc.SelectSingleNode("NDOMapping");
XmlNode comment = doc.CreateComment("NDO Class Generator file - this is not a valid mapping file!");
doc.InsertBefore(comment, refNode);
assemblyNode.Assembly.ToXml(doc);
XmlElement node = (XmlElement)doc.SelectSingleNode("NDOMapping/AssemblyElement");
node.SetAttribute("DbOwner", this.databaseNode.Database.OwnerName);
doc.Save(fileName);
}
private static AssemblyNode GetRuntimeAssembly()
{
AssemblyNode result = RuntimeAssemblyLocation.ParsedAssembly;
if (result != null)
{
return(result);
}
if (RuntimeAssemblyLocation.Location == null)
{
//This happens when there was no call to SetToXXX. Use the location of the assembly linked into the compiler.
RuntimeAssemblyLocation.Location = typeof(dummy).Module.Assembly.Location;
result = AssemblyNode.GetAssembly((RuntimeAssemblyLocation.Location));
}
else
{
result = AssemblyNode.GetAssembly(RuntimeAssemblyLocation.Location);
if (result == null)
{
//This happens when the location was set by a call to SetToXXX, but the runtime assembly is not actually deployed
//in the directory containing the target platform assemblies. This is really an error, but as a convenience during
//development of the compiler, the assembly linked into the compiler is used instead.
RuntimeAssemblyLocation.Location = typeof(dummy).Module.Assembly.Location;
result = AssemblyNode.GetAssembly((RuntimeAssemblyLocation.Location));
}
}
if (result == null)
{
result = new AssemblyNode();
result.Name = "Microsoft.SpecSharp.Runtime";
result.Version = Cci.TargetPlatform.TargetVersion;
}
Cci.TargetPlatform.AssemblyReferenceFor[Identifier.For(result.Name).UniqueIdKey] = new AssemblyReference(result);
return(result);
}
public void Test()
{
var gen = new XmlResultsGenerator(null,null,null, null, null);
var muSession = new MutationTestingSession();
var mutar = new MutationTarget(new MutationVariant());
var ass = new AssemblyNode("Assembly");
muSession.MutantsGrouped.Add(ass);
var nodeNamespace = new TypeNamespaceNode(ass, "Namespace");
ass.Children.Add(nodeNamespace);
var nodeType = new TypeNode(nodeNamespace, "Type");
nodeNamespace.Children.Add(nodeType);
var nodeMethod = new MethodNode(nodeType, "Method", null, true);
nodeType.Children.Add(nodeMethod);
var nodeGroup = new MutantGroup("Gr1", nodeMethod);
nodeMethod.Children.Add(nodeGroup);
var nodeMutant = new Mutant("m1", nodeGroup, mutar);
nodeGroup.Children.Add(nodeMutant);
XDocument generateResults = gen.GenerateResults(muSession, false, false, ProgressCounter.Inactive(), CancellationToken.None).Result;
Console.WriteLine(generateResults.ToString());
//gen.
}
private void mainTreeView_TreeNodePopulate(object sender, TreeViewEventArgs e)
{
TreeNode node = e.Node;
object obj = e.Node.Tag;
if (obj is AssemblyNode)
{
AssemblyNode asm = (AssemblyNode)obj;
foreach (NamespaceNode space in asm.Namespaces)
{
space.SortTypes();
TreeNode spaceNode = new TreeNode(space.Name);
spaceNode.ImageKey = "namespace";
spaceNode.SelectedImageKey = spaceNode.ImageKey;
spaceNode.Tag = space;
spaceNode.Nodes.Add(String.Empty);
node.Nodes.Add(spaceNode);
}
}
else if (obj is NamespaceNode)
{
NamespaceNode space = (NamespaceNode)obj;
foreach (TypeNode type in space.Types)
{
TreeNode typeNode = new TreeNode(type.Name);
typeNode.ImageKey = GetImageKey(type);
typeNode.SelectedImageKey = typeNode.ImageKey;
typeNode.Tag = type;
node.Nodes.Add(typeNode);
}
}
}
private void OnAssemblySelected(AssemblyNode assemblyNode, Action completeAction = null)
{
if (assemblyNode.Children.Count == 0)
{
Task loadingTask = assemblyNode.LoadItemsAsync(() => assemblyNode.IsExpanded = false);
loadingTask.ContinueWith(t =>
{
if (!t.IsCanceled && !t.IsFaulted)
{
if (completeAction != null)
{
completeAction();
}
}
else if (t.Exception.InnerExceptions.Count > 0)
{
// already shown an error window.
//this.ShowExceptionMessage(t.Exception.InnerExceptions);
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
else
{
if (completeAction != null)
{
completeAction();
}
}
}
private void CheckModule([NotNull] AssemblyNode module)
{
if (HasCheckOverloadAccepting(typeof(AssemblyNode)))
{
rule.Check(module);
}
}
public ClousotExtractor(ContractNodes contractNodes, AssemblyNode ultimateTargetAssembly,
AssemblyNode realAssembly, Action <System.CodeDom.Compiler.CompilerError> errorHandler)
: base(contractNodes, ultimateTargetAssembly, realAssembly)
{
Contract.Requires(contractNodes != null);
Contract.Requires(realAssembly != null);
}
// Parsing logic
public void LoadAssembly(string filePath)
{
//Console.WriteLine("loading {0}", filePath);
//AssemblyNode assembly = AssemblyNode.GetAssembly(filePath); // this causes mscorlib to be missing members
//AssemblyNode assembly = AssemblyNode.GetAssembly(filePath, cache); // this causes compact framework non-classes to register as classes
//AssemblyNode assembly = AssemblyNode.GetAssembly(filePath, cache, false, false, true, false); // this causes missing mscorlib members
//AssemblyNode assembly = AssemblyNode.GetAssembly(filePath, cache, false, false, false, false); // this causes non-classes to register as classes
//AssemblyNode assembly = AssemblyNode.GetAssembly(filePath, null, false, false, true, false); // this causes missing mscorlib members
AssemblyNode assembly = AssemblyNode.GetAssembly(filePath, null, false, false, false, false); // this causes non-classes to register as classes
if (assembly != null)
{
if (assembly.Name == "mscorlib")
{
ResetMscorlib(assembly);
}
// Console.WriteLine("assembly = {0}", assembly.Name);
resolver.Add(assembly);
//assembly.AssemblyReferenceResolutionAfterProbingFailed += unresolvedModuleHandler;
assemblies.Add(assembly);
//Console.WriteLine("{0} has {1} types", assembly.Name, assembly.ExportedTypes.Count);
//StoreTypes(assembly.Types);
}
}
public void WriteAssembly(AssemblyNode assemblyNode)
{
var controllers = assemblyNode.Controllers.OrderBy(x => x.Name).ToArray();
foreach (var controllerNode in controllers)
{
WriteController(controllerNode);
}
WriteViews(assemblyNode);
WriteEnums(assemblyNode);
var output = new StringBuilder();
foreach (var controllerNode in controllers)
{
output.AppendLine($"export * from \"./{StringHelpers.ToCamelCase(controllerNode.Name)}\";");
}
if (assemblyNode.Classes.Any(x => x.Value.Values != null))
{
output.AppendLine("export * from \"./enums\";");
}
output.AppendLine("export * from \"./views\";");
OutputModules.Add("services", output.ToString());
}
private void WriteViews(AssemblyNode assemblyNode)
{
StringBuilder body = new StringBuilder();
var dependencies = new Dependencies
{
PrefixModules = PrefixModules.Enums
};
var any = false;
foreach (var classNode in assemblyNode.Classes.Where(x => x.Value.Properties != null))
{
WriteTypeDefinition(classNode.Value, body, false, dependencies);
any = true;
}
var result = new StringBuilder();
if (dependencies.Enums)
{
result.AppendLine("import * as enums from \"./enums\";");
}
result.Append(body);
if (any)
{
OutputModules.Add("views", result.ToString());
}
}
public override void VisitAssemblyNode(AssemblyNode node)
{
if (node.DifferenceDecoration == DifferenceDecoration.NoDifferences)
{
return;
}
xmlWriter.WriteStartElement("Assembly");
xmlWriter.WriteAttributeString("Name", node.Name);
xmlWriter.WriteAttributeString("DiffType", node.DifferenceDecoration.ToString());
foreach (var module in node.Modules)
{
module.Accept(this);
}
xmlWriter.WriteStartElement("Ressources");
foreach (var resource in node.Resources)
{
resource.Accept(this);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
}
private void CheckTypes([NotNull] AssemblyNode module)
{
foreach (TypeNode type in module.Types)
{
CheckType(type);
}
}
private bool TryLoadContractNodes(ref AssemblyNode assembly)
{
ContractNodes nodes = null;
foreach (Module module in assembly.Modules)
{
IAssemblyResolver assemblyResolver = module.Definition.AssemblyResolver;
foreach (AssemblyNameReference reference in module.Definition.AssemblyReferences)
{
AssemblyDefinition def = assemblyResolver.Resolve(reference);
nodes = ContractNodes.GetContractNodes(new AssemblyNode(def), (s) => { });
if (nodes != null)
{
break;
}
}
}
if (nodes == null)
{
return(false);
}
var extractor = new ContractExtractor(nodes, assembly, true);
assembly = (AssemblyNode)extractor.Visit(assembly);
return(true);
}
//=====================================================================
/// <summary>
/// This is overridden to resolve unknown assembly references
/// </summary>
/// <param name="reference">The reference to resolve</param>
/// <param name="module">The module</param>
/// <returns>The assembly node if resolved or null if not resolved</returns>
public override AssemblyNode ResolveReference(
AssemblyReference reference, System.Compiler.Module module)
{
AssemblyNode node = base.ResolveReference(reference, module);
string name;
// Try the redirects if not found
if (node == null)
{
name = reference.StrongName;
foreach (BindingRedirectSettings brs in redirects)
{
if (brs.IsRedirectFor(name) && cache.ContainsKey(brs.StrongName))
{
ConsoleApplication.WriteMessage(LogLevel.Info,
"Using redirect '{0}' in place of '{1}'",
brs.StrongName, name);
node = cache[brs.StrongName];
cache.Add(name, node);
break;
}
}
}
return(node);
}
public static void init( )
{
// if ( allNamespaces != null ) return;
allNamespaces = new NamespaceList();
nsCached = new Dictionary <string, TypeNodeList>();
// Scan all assemblies referenced in parameters
// and take all namespaces from them.
// Put all these namespaces into the common list.
System.Collections.Specialized.StringCollection assemblies = CONTEXT.options.ReferencedAssemblies;
foreach (string assName in assemblies)
{
AssemblyNode assembly = AssemblyNode.GetAssembly(assName, true, false, true);
if (assembly == null && !CONTEXT.AnalysisOnly)
{
ERROR.UnresolvedReference(assName);
continue;
}
NamespaceList nss = assembly.GetNamespaceList();
for (int i = 0, n = nss.Length; i < n; i++)
{
allNamespaces.Add(nss[i]);
}
}
}
/// <summary>
/// This is used to load an assembly that will be parsed and documented
/// </summary>
/// <param name="filePath">The path of the documented assembly to load</param>
public void LoadAssembly(string filePath)
{
// This causes non-classes to register as classes
AssemblyNode assembly = AssemblyNode.GetAssembly(filePath, null, false,
(this.SourceCodeBasePath != null), false, false);
if (assembly != null)
{
// If generating reflection data for a framework, reset the core library if seen
if (assembly.Name == CoreSystemTypes.SystemAssembly.Name)
{
ResetMscorlib(assembly);
}
resolver.Add(assembly);
assemblies.Add(assembly);
if (this.SourceCodeBasePath != null)
{
if (!assembly.reader.PdbExists)
{
this.MessageLogger(LogLevel.Warn, "The program database (PDB) file associated with " +
$"'{filePath}' does not exist or could not be loaded. Source context information " +
"is unavailable.");
}
else
{
this.MessageLogger(LogLevel.Info, $"Found a current program database (PDB) file for '{filePath}'.");
}
}
}
}
public void Test()
{
var gen = new XmlResultsGenerator(null, null, null, null, null);
var muSession = new MutationTestingSession();
var mutar = new MutationTarget(new MutationVariant());
var ass = new AssemblyNode("Assembly");
muSession.MutantsGrouped.Add(ass);
var nodeNamespace = new TypeNamespaceNode(ass, "Namespace");
ass.Children.Add(nodeNamespace);
var nodeType = new TypeNode(nodeNamespace, "Type");
nodeNamespace.Children.Add(nodeType);
var nodeMethod = new MethodNode(nodeType, "Method", null, true);
nodeType.Children.Add(nodeMethod);
var nodeGroup = new MutantGroup("Gr1", nodeMethod);
nodeMethod.Children.Add(nodeGroup);
var nodeMutant = new Mutant("m1", nodeGroup, mutar);
nodeGroup.Children.Add(nodeMutant);
XDocument generateResults = gen.GenerateResults(muSession, false, false, ProgressCounter.Inactive(), CancellationToken.None).Result;
Console.WriteLine(generateResults.ToString());
//gen.
}
public MappingGenerator(string fileName, DatabaseNode databaseNode, AssemblyNode assemblyNode)
{
this.fileName = fileName;
this.databaseNode = databaseNode;
this.ass = assemblyNode.Assembly;
database = databaseNode.Database;
}
public AssemblyNode CreateAssemblyNode(IOldToNewTupleMap <string> assemblyMap)
{
var generationProjectInfoMap = new OldToNewTupleMap <GeneratedProjectOutputInfo>
(
new GeneratedProjectOutputInfo(assemblyMap.OldType),
new GeneratedProjectOutputInfo(assemblyMap.NewType)
);
Console.Write("Loading old assembly...");
var assemblyDecompilationResultOld = GetAssemblyDecompilationResult(
assemblyMap.OldType,
generationProjectInfoMap.OldType.OutputPath,
CancellationToken.None);
GlobalDecompilationResultsRepository.Instance.AddDecompilationResult(assemblyMap.OldType, assemblyDecompilationResultOld);
Console.WriteLine("done.");
Console.Write("Loading new assembly...");
var assemblyDecompilationResultNew = GetAssemblyDecompilationResult(
assemblyMap.NewType,
generationProjectInfoMap.NewType.OutputPath,
CancellationToken.None);
GlobalDecompilationResultsRepository.Instance.AddDecompilationResult(assemblyMap.NewType, assemblyDecompilationResultNew);
Console.WriteLine("done.");
return(AssemblyNode.Create(assemblyMap, generationProjectInfoMap));
}
private static AssemblyNode GetTaskAssembly(TypeNode type)
{
AssemblyNode taskAssembly = null;
// Check if the type's located in mscorlib
TypeNode taskTypeNode = GetTypeNode(FrameworkAssemblies.Mscorlib, TaskNamespace, TaskGenericType);
if (taskTypeNode != null)
{
taskAssembly = FrameworkAssemblies.Mscorlib;
}
else if (type.DeclaringModule.Name.Equals(TaskPortableAssembly))
{
// If the type is a type in the portable assembly, no need to loop through the assembly references
taskAssembly = type.DeclaringModule.ContainingAssembly;
}
else
{
AssemblyReference assemblyReference = type.DeclaringModule
.AssemblyReferences
.FirstOrDefault(reference => reference.Name.Equals(TaskPortableAssembly, StringComparison.Ordinal));
Contract.Assert(assemblyReference != null);
taskAssembly = assemblyReference.Assembly;
}
Contract.Assert(taskAssembly != null);
return(taskAssembly);
}
public ActionsGroupNode ReadController(Type type, AssemblyNode assemblyNode)
{
var name = type.Name.Replace("Controller", string.Empty);
name = NameCleaner.Replace(name, string.Empty);
var controller = new ActionsGroupNode(assemblyNode, name);
var routePrefixAttribute = type.GetTypeInfo().GetCustomAttribute <RouteAttribute>(false) ?? type.GetTypeInfo().GetCustomAttribute <RouteAttribute>();
string routePrefix = routePrefixAttribute != null ? routePrefixAttribute.Template : "todo";
controller.Documentation = documentation.GetDocumentation(type);
foreach (var methodInfo in type.GetMethods().Where(x => x.IsPublic))
{
if (methodInfo.GetCustomAttribute <NonActionAttribute>() != null)
{
continue;
}
if (methodInfo.IsSpecialName)
{
continue;
}
var action = ReadAction(routePrefix, methodInfo, controller);
if (action != null)
{
controller.Actions.Add(action);
}
}
return(controller);
}
public void Test1()
{
System.Action<CheckedNode, ICollection<MutationTarget>> typeNodeCreator = (parent, targets) =>
{
};
Func<MutationTarget, string> namespaceExtractor = target => target.NamespaceName;
var mt1 = new MutationTarget(null);
mt1.NamespaceName = "Root.NamespaceName1";
var mt2 = new MutationTarget(null);
mt2.NamespaceName = "Root.NamespaceName2";
var mt3 = new MutationTarget(null);
mt3.NamespaceName = "Another.NamespaceName3";
var mt4 = new MutationTarget(null);
mt4.NamespaceName = "Another.NamespaceName3";
var ass = new AssemblyNode("");
NamespaceGrouper<MutationTarget, CheckedNode>.
GroupTypes(ass, namespaceExtractor,
(parent, name) => new TypeNamespaceNode(parent, name), typeNodeCreator,
new List<MutationTarget> { mt1, mt2, mt3 });
ass.Children.Count.ShouldEqual(2);
ass.Children.Single(c => c.Name == "Root").Children.Count.ShouldEqual(2);
ass.Children.Single(c => c.Name == "Another.NamespaceName3").Children.Count.ShouldEqual(0);
}
/// <summary>
/// This is used to reset the target platform information if mscorlib is specified as one of the
/// reference assemblies or documented assemblies.
/// </summary>
/// <param name="assembly">The system assembly for the target platform (mscorlib)</param>
private static void ResetMscorlib(AssemblyNode assembly)
{
TargetPlatform.Clear();
CoreSystemTypes.Clear();
CoreSystemTypes.SystemAssembly = assembly;
CoreSystemTypes.Initialize(true, false);
}
private void btnOpen_Click(object sender, System.EventArgs e)
{
try
{
if (dlgOpenAssembly.ShowDialog(this) == DialogResult.OK)
{
Assembly asm = Assembly.LoadFrom(dlgOpenAssembly.FileName);
TreeNode node = new AssemblyNode(asm);
node.Nodes.Add(new TreeNode());
tvBrowser.Nodes.Add(node);
}
}
catch (Exception ex)
{
IUIService svc = (IUIService)this.GetService(typeof(IUIService));
if (svc != null)
{
svc.ShowError(ex);
}
else
{
throw ex;
}
}
}
private ClassNode ReadClass(Type parameterType, AssemblyNode assembly, ActionNode actionNode, Type[] parents)
{
var parameterTypeName = Regex.Replace(parameterType.Name, "`.*", "");
ClassNode classNode;
if (assembly.Classes.ContainsKey(parameterTypeName))
{
classNode = assembly.Classes[parameterTypeName];
}
else
{
classNode = new ClassNode
{
Version = actionNode.Version,
Documentation = documentation.GetDocumentation(parameterType),
KoName = parameterTypeName,
Name = Regex.Replace(parameterTypeName, @"View(Model)?$", string.Empty)
};
if (parameterType.GetTypeInfo().IsEnum)
{
var enumNames = parameterType.GetTypeInfo().GetEnumNames();
var enumValues = parameterType.GetTypeInfo().GetEnumValues();
classNode.Values = new List <EnumValueNode>();
for (var i = 0; i < enumValues.Length; i++)
{
var enumValue = new EnumValueNode
{
Name = enumNames[i],
Value = Convert.ToInt32(enumValues.GetValue(i)),
Documentation = documentation.GetDocumentation(parameterType, enumNames[i])
};
classNode.Values.Add(enumValue);
}
}
else
{
if (parents.All(x => x != parameterType))
{
classNode.Properties = ReadProperties(parameterType, parents, assembly, actionNode);
}
if (parameterType.GetTypeInfo().IsGenericTypeDefinition)
{
classNode.GenericParameters = parameterType.GetGenericArguments().Select(x => x.Name).ToList();
}
var jsonAttribute = parameterType.GetTypeInfo().GetCustomAttribute <JsonAttribute>();
if (jsonAttribute != null)
{
classNode.HasObservable = jsonAttribute.Observable;
}
}
assembly.Classes[classNode.KoName] = classNode;
}
return(classNode);
}
/// <summary>
/// This is used to reset the target platform information if mscorlib is specified as one of the
/// reference assemblies or documented assemblies.
/// </summary>
/// <param name="assembly">The system assembly for the target platform (mscorlib)</param>
private static void ResetMscorlib(AssemblyNode assembly)
{
TargetPlatform.Clear();
CoreSystemTypes.Clear();
CoreSystemTypes.SystemAssembly = assembly;
TargetPlatform.PlatformAssembliesLocation = Path.GetDirectoryName(assembly.Location);
CoreSystemTypes.Initialize(true, false);
}
public static AssemblyNode GetAssembly()
{
if (_assemblyNode == null)
{
_assemblyNode = AssemblyNode.GetAssembly(Assembly.GetExecutingAssembly().Location, true, true, true);
}
return(_assemblyNode);
}
private void AddJustAssemblyTab(AssemblyNode node)
{
var JustAssemblyTabItem = new AssemblyAttributeTabItem(node);
JustAssemblyTabItem.LoadContent();
this.AddNewTabItem(JustAssemblyTabItem);
}
public virtual void VisitAssembly(AssemblyNode node)
{
if (node == null)
{
return;
}
VisitModuleList(node.Modules);
}
public static bool IsSystemAssembly(this AssemblyNode assembly)
{
string assemblyFile = (assembly.Location ?? "").ToLower();
return(assemblyFile.Contains(":\\Program Files (x86)\\Microsoft ASP.NET\\ASP.NET MVC 3\\Assemblies".ToLower()) ||
assemblyFile.Contains(":\\Program Files (x86)\\Microsoft ASP.NET\\ASP.NET MVC 4\\Assemblies".ToLower()) ||
assemblyFile.Contains(":\\Program Files (x86)\\Microsoft ASP.NET\\ASP.NET Web Pages\\v1.0\\Assemblies".ToLower()) ||
assemblyFile.Contains(":\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework".ToLower()));
}
private ReturnNode ReadReturn(ContextualType responseType, AssemblyNode assembly, XElement?documentationNode, ActionNode actionNode)
{
var returnNode = new ReturnNode(ReadType(responseType, assembly, new Type[0], actionNode))
{
Documentation = documentation.ParseDocumentation(documentationNode),
};
return(returnNode);
}
public void DrawTree(AssemblyNode module)
{
var leftCol = leftTree.Items.SourceCollection as INotifyCollectionChanged;
leftCol.CollectionChanged += BuildLeftINodeList;
var topCol = topTree.Items.SourceCollection as INotifyCollectionChanged;
topCol.CollectionChanged += BuildTopINodeList;
leftTree.MouseMove += LeftTree_MouseMove;
topTree.MouseMove += TopTree_MouseMove;
Helper.FillTree(leftTree, module);
Helper.FillTree(topTree, module);
}
public AssemblyNode CreateAssemblyNode(IModuleInfo module,
CciMethodMatcher methodMatcher)
{
var matcher = methodMatcher.Join(new SolutionTypesManager.ProperlyNamedMatcher());
var assemblyNode = new AssemblyNode(module.Name);
assemblyNode.AssemblyPath = module.Module.Location.ToFilePathAbs();
System.Action<CheckedNode, ICollection<INamedTypeDefinition>> typeNodeCreator = (parent, leafTypes) =>
{
foreach (INamedTypeDefinition typeDefinition in leafTypes)
{
if (matcher.Matches(typeDefinition))
{
var type = new TypeNode(parent, typeDefinition.Name.Value);
foreach (var method in typeDefinition.Methods)
{
if (matcher.Matches(method))
{
type.Children.Add(new MethodNode(type, method.Name.Value, method, false));
return;
}
}
parent.Children.Add(type);
}
}
};
Func<INamedTypeDefinition, string> namespaceExtractor = typeDef =>
TypeHelper.GetDefiningNamespace(typeDef).Name.Value;
NamespaceGrouper<INamespaceTypeDefinition, CheckedNode>.
GroupTypes(assemblyNode,
namespaceExtractor,
(parent, name) => new TypeNamespaceNode(parent, name),
typeNodeCreator,
module.Module.GetAllTypes().ToList());
//remove empty amespaces.
//TODO to refactor...
List<TypeNamespaceNode> checkedNodes = assemblyNode.Children.OfType<TypeNamespaceNode>().ToList();
foreach (TypeNamespaceNode node in checkedNodes)
{
RemoveFromParentIfEmpty(node);
}
return assemblyNode;
}
public MetricsReader(string fileName)
{
loader = new CecilLoader(true) { IncludeInternalMembers = true };
namespaceMappings = new Dictionary<string, NamespaceNode>();
typeMappings = new Dictionary<ITypeDefinition, TypeNode>();
methodMappings = new Dictionary<IMethod, MethodNode>();
fieldMappings = new Dictionary<IField, FieldNode>();
cecilMappings = new Dictionary<MemberReference, IEntity>();
compilation = new SimpleCompilation(loader.LoadAssemblyFile(fileName));
// TODO load referenced assemblies into compilation.
Assembly = new AssemblyNode(compilation.MainAssembly.AssemblyName);
assemblyDefinition = loader.GetCecilObject(compilation.MainAssembly.UnresolvedAssembly);
foreach (var type in compilation.MainAssembly.GetAllTypeDefinitions()) {
ReadType(type);
foreach (IMethod method in type.Methods) {
ReadMethod(method);
}
foreach (IProperty property in type.Properties) {
if (property.CanGet)
ReadMethod(property.Getter);
if (property.CanSet)
ReadMethod(property.Setter);
}
foreach (IField field in type.Fields) {
ReadField(field);
}
}
foreach (var method in methodMappings.Values) {
ReadInstructions(method, method.Method, loader.GetCecilObject((IUnresolvedMethod)method.Method.UnresolvedMember));
}
Assembly.namespaces = namespaceMappings.Values;
}
public Mutant CreateEquivalentMutant(out AssemblyNode assemblyNode)
{
assemblyNode = new AssemblyNode("All modules");
var nsNode = new TypeNamespaceNode(assemblyNode, "");
assemblyNode.Children.Add(nsNode);
var typeNode = new TypeNode(nsNode, "");
nsNode.Children.Add(typeNode);
var methodNode = new MethodNode(typeNode, "", null, true);
typeNode.Children.Add(methodNode);
var group = new MutantGroup("Testing original program", methodNode);
var target = new MutationTarget(new MutationVariant())
{
Name = "Original program",
};
var mutant = new Mutant("0", group, target);
group.Children.Add(mutant);
methodNode.Children.Add(group);
group.UpdateDisplayedText();
return mutant;
}
/// <summary>
/// Provide a hook for derived classes to modify the initial
/// list of types.
/// </summary>
///
protected virtual void OnLoadNodes()
{
tvBrowser.Nodes.Clear();
foreach(Assembly assembly in this.assemblies)
{
TreeNode node = new AssemblyNode(assembly);
node.Nodes.Add(new TreeNode());
tvBrowser.Nodes.Add(node);
}
}
public virtual AssemblyNode VisitAssembly(AssemblyNode assembly){
if (assembly == null) return null;
this.VisitModule(assembly);
assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes);
assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes);
return assembly;
}
private void btnOpen_Click(object sender, System.EventArgs e)
{
try
{
if(dlgOpenAssembly.ShowDialog(this) == DialogResult.OK)
{
Assembly asm = Assembly.LoadFrom(dlgOpenAssembly.FileName);
TreeNode node = new AssemblyNode(asm);
node.Nodes.Add(new TreeNode());
tvBrowser.Nodes.Add(node);
}
}
catch(Exception ex)
{
IUIService svc = (IUIService)this.GetService(typeof(IUIService));
if (svc != null)
{
svc.ShowError(ex);
}
else
{
throw ex;
}
}
}
public virtual void VisitAssembly (AssemblyNode node)
{
if (node == null)
return;
VisitModuleList (node.Modules);
}
public virtual AssemblyNode VisitAssembly (AssemblyNode node)
{
if (node == null)
return null;
VisitModuleList (node.Modules);
return node;
}
private AssemblyNode BuildMutantsTree(string moduleName,
MultiDictionary<IMutationOperator, MutationTarget> mutationTargets)
{
var assemblyNode = new AssemblyNode(moduleName);
System.Action<CheckedNode, ICollection<MutationTarget>> typeNodeCreator = (parent, targets) =>
{
var typeNodes =
from t in targets
orderby t.TypeName
group t by t.TypeName
into byTypeGrouping
select new TypeNode(parent, byTypeGrouping.Key,
from gr in byTypeGrouping
group gr by gr.MethodRaw.Name.Value
into byMethodGrouping
orderby byMethodGrouping.Key
let md = byMethodGrouping.First().MethodRaw
select new MethodNode(md.Name.Value, md,
from gr in byMethodGrouping
group gr by gr.GroupName
into byGroupGrouping
orderby byGroupGrouping.Key
select GroupOrMutant(byGroupGrouping)
)
);
parent.Children.AddRange(typeNodes);
};
Func<MutationTarget, string> namespaceExtractor = target => target.NamespaceName;
NamespaceGrouper<MutationTarget, CheckedNode>.GroupTypes(assemblyNode,
namespaceExtractor,
(parent, name) => new TypeNamespaceNode(parent, name),
typeNodeCreator,
mutationTargets.Values.SelectMany(a => a).ToList());
foreach (var node in assemblyNode.Children.Where(n=>n.Children.Count == 0).ToList())
{
assemblyNode.Children.Remove(node);
}
return assemblyNode;
}
public override AssemblyNode VisitAssembly(AssemblyNode assembly) {
if (assembly == null) return null;
this.currentModule = this.currentAssembly = assembly;
assembly.Attributes = this.VisitAttributeList(assembly.Attributes, assembly);
assembly.ModuleAttributes = this.VisitModuleAttributes(assembly.ModuleAttributes);
assembly.Types = this.VisitTypeNodeList(assembly.Types);
return assembly;
}
public override Module VisitModule(Module module){
if (module == null) return null;
this.currentModule = module;
this.currentAssembly = module.ContainingAssembly;
return base.VisitModule(module);
}
public void Teardown()
{
MsCorLib = null;
JSTypes = null;
}
public override Module VisitModule(Module module) {
if (module == null) return null;
this.currentModule = module;
this.currentAssembly = module.ContainingAssembly;
module.Attributes = this.VisitModuleAttributes(module.Attributes);
module.Types = this.VisitTypeNodeList(module.Types);
return module;
}
public override AssemblyNode VisitAssembly(AssemblyNode assembly){
this.currentModule = this.currentAssembly = assembly;
return base.VisitAssembly(assembly);
}
public virtual AttributeNode VisitUnknownAssemblyAttribute(TypeNode attrType, AttributeNode attr, AssemblyNode target) {
return attr;
}
public override Compilation VisitCompilation(Compilation compilation) {
if (compilation == null) return null;
this.currentOptions = compilation.CompilerParameters as CompilerOptions;
Module module = this.currentModule = compilation.TargetModule;
if (module != null) {
AssemblyNode assem = module as AssemblyNode;
if (assem != null) {
this.currentAssembly = assem;
if (this.currentOptions.IsContractAssembly) { // handle compiler option /shadow:<assembly>
this.shadowedAssembly = AssemblyNode.GetAssembly(this.currentOptions.ShadowedAssembly);
if (this.shadowedAssembly == null) {
this.HandleError(compilation, Error.CannotLoadShadowedAssembly, this.currentOptions.ShadowedAssembly);
return compilation;
}
assem.Attributes.Add(ShadowedAssemblyAttribute());
this.isCompilingAContractAssembly = true;
}
assem.Attributes = this.VisitAttributeList(assem.Attributes, assem);
assem.ModuleAttributes = this.VisitModuleAttributes(assem.ModuleAttributes);
} else {
this.currentAssembly = module.ContainingAssembly;
module.Attributes = this.VisitModuleAttributes(module.Attributes);
}
}
return base.VisitCompilation(compilation);
}
public virtual AttributeNode VisitAssemblyAttribute(AttributeNode attr, AssemblyNode target) {
attr = this.VisitAttributeNode(attr);
if (attr == null) return null;
MemberBinding mb = attr.Constructor as MemberBinding;
if (mb == null) return null;
InstanceInitializer constr = mb.BoundMember as InstanceInitializer;
if (constr == null) return null;
TypeNode attrType = constr.DeclaringType;
if (this.currentOptions != null) {
if (attrType == SystemTypes.AssemblyCompanyAttribute)
this.currentOptions.TargetInformation.Company = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyConfigurationAttribute)
this.currentOptions.TargetInformation.Configuration = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyCopyrightAttribute)
this.currentOptions.TargetInformation.Copyright = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyCultureAttribute)
this.currentOptions.TargetInformation.Culture = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyDescriptionAttribute)
this.currentOptions.TargetInformation.Description = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyFileVersionAttribute)
this.currentOptions.TargetInformation.Version = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyInformationalVersionAttribute)
this.currentOptions.TargetInformation.ProductVersion = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyProductAttribute)
this.currentOptions.TargetInformation.Product = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyTitleAttribute)
this.currentOptions.TargetInformation.Title = this.GetStringParameter(attr.Expressions);
else if (attrType == SystemTypes.AssemblyTrademarkAttribute)
this.currentOptions.TargetInformation.Trademark = this.GetStringParameter(attr.Expressions);
}
if (attrType == SystemTypes.AssemblyFlagsAttribute) {
ExpressionList args = attr.Expressions;
AssemblyFlags flags = AssemblyFlags.None;
if (args != null && args.Count > 0) {
Literal flagsLit = args[0] as Literal;
if (flagsLit != null && this.currentAssembly != null) {
if (flagsLit.Value is int)
flags = (AssemblyFlags)(int)flagsLit.Value;
else if (flagsLit.Value is uint)
flags = (AssemblyFlags)(uint)flagsLit.Value;
}
}
this.currentAssembly.Flags = flags;
attr.IsPseudoAttribute = true;
return attr;
}
if (attrType == SystemTypes.AssemblyKeyFileAttribute) {
ExpressionList args = attr.Expressions;
if (args != null && args.Count > 0) {
Literal keyFilePathLit = args[0] as Literal;
if (keyFilePathLit != null && this.currentAssembly != null) {
string keyFilePath = keyFilePathLit.Value as string;
Document doc = attr.SourceContext.Document;
if (doc != null && doc.Name != null) {
string dir = Path.GetDirectoryName(doc.Name);
keyFilePath = PathWrapper.Combine(dir, keyFilePath);
}
if (keyFilePath != null && File.Exists(keyFilePath)) { //TODO: what about additional search paths
if (this.currentOptions != null)
this.currentOptions.AssemblyKeyFile = keyFilePath;
} else {
if (this.currentOptions != null)
this.currentOptions.AssemblyKeyFile = keyFilePathLit.Value as string;
}
//this.HandleError(attr, Error.UseSwitchInsteadOfAttribute, "keyfile", "AssemblyKeyFileAttribute");
}
}
}
if (attrType == SystemTypes.AssemblyKeyNameAttribute) {
ExpressionList args = attr.Expressions;
if (args != null && args.Count > 0) {
Literal keyNameLit = args[0] as Literal;
if (keyNameLit != null && this.currentAssembly != null) {
string keyName = keyNameLit.Value as string;
if (keyName != null) {
if (this.currentOptions != null)
this.currentOptions.AssemblyKeyName = keyName;
//this.HandleError(attr, Error.UseSwitchInsteadOfAttribute, "keyname", "AssemblyKeyNameAttribute");
}
}
}
return attr;
}
if (attrType == SystemTypes.AssemblyVersionAttribute || attrType == SystemTypes.SatelliteContractVersionAttribute) {
ExpressionList args = attr.Expressions;
string version = null;
if (args != null && args.Count > 0) {
Literal titleLit = args[0] as Literal;
if (titleLit != null && this.currentAssembly != null) {
version = titleLit.Value as String;
}
}
Version v = null;
if (version != null) v = this.ParseVersion(version, attrType != SystemTypes.SatelliteContractVersionAttribute);
if (v == null)
this.HandleError(mb, Error.CustomAttributeError, this.GetTypeName(attrType), version);
else if (attrType == SystemTypes.AssemblyVersionAttribute) {
target.Version = v;
attr.IsPseudoAttribute = true;
return attr;
}
return attr;
}
if (attrType == SystemTypes.AssemblyDelaySignAttribute) {
ExpressionList args = attr.Expressions;
if (args != null && args.Count > 0) {
Literal valueLit = args[0] as Literal;
if (valueLit != null && valueLit.Value is bool && this.currentAssembly != null && this.currentOptions != null && !this.currentOptions.DelaySign) {
this.currentOptions.DelaySign = (bool)valueLit.Value;
}
}
return attr;
}
if (attrType == SystemTypes.CLSCompliantAttribute) {
//TODO: enable CLS checking
}
return this.VisitUnknownAssemblyAttribute(attrType, attr, target);
}
public override AssemblyNode VisitAssembly(AssemblyNode assembly)
{
if (assembly == null) return null;
this.FindTypesToBeDuplicated(assembly.Types);
return base.VisitAssembly((AssemblyNode)assembly.Clone());
}
public void Setup(AssemblyNode mscorlib, AssemblyNode jsTypes, AssemblyNode rewriteAssembly)
{
NumWarnings = 0;
NumErrors = 0;
MsCorLib = mscorlib;
AssemblyDelaySignAttributeType = GetType(mscorlib, "System.Reflection", "AssemblyDelaySignAttribute");
VoidType = GetType(mscorlib, "System", "Void");
ObjectType = GetType(mscorlib, "System", "Object");
StringType = GetType(mscorlib, "System", "String");
IntType = GetType(mscorlib, "System", "Int32");
BooleanType = GetType(mscorlib, "System", "Boolean");
MethodBaseType = GetType(mscorlib, "System.Reflection", "MethodBase");
RuntimeTypeHandleType = GetType(mscorlib, "System", "RuntimeTypeHandle");
NullableTypeConstructor = GetType(mscorlib, "System", "Nullable`1");
CompilerGeneratedAttributeType = GetType
(mscorlib, "System.Runtime.CompilerServices", "CompilerGeneratedAttribute");
DllImportAttributeType = GetType(mscorlib, "System.Runtime.InteropServices", "DllImportAttribute");
TypeType = GetType(mscorlib, "System", "Type");
Type_GetMethodMethod = GetMethod(TypeType, "GetMethod", StringType, TypeType.GetArrayType(1));
Type_GetMemberMethod = GetMethod(TypeType, "GetMember", StringType);
Type_GetConstructorMethod = GetMethod(TypeType, "GetConstructor", TypeType.GetArrayType(1));
Type_GetTypeFromHandleMethod = GetMethod(TypeType, "GetTypeFromHandle", RuntimeTypeHandleType);
Type_GetGenericArgumentsMethod = GetMethod(TypeType, "GetGenericArguments");
Type_MakeArrayTypeMethod = GetMethod(TypeType, "MakeArrayType");
Type_MakeGenericTypeMethod = GetMethod(TypeType, "MakeGenericType", TypeType.GetArrayType(1));
InteropTypes = new InteropTypes(this);
InteropManager = new InteropManager(this);
IgnoreAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "IgnoreAttribute");
InteropAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "InteropAttribute");
NamingAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NamingAttribute");
ImportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportAttribute");
ImportKeyAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportKeyAttribute");
ExportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ExportAttribute");
NotExportedAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NotExportedAttribute");
InteropGeneratedAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "InteropGeneratedAttribute");
JSTypes = jsTypes;
JSContextType = GetType(jsTypes, Constants.JSTypesInteropNS, "JSContext");
InteropContextManagerType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropContextManager");
InteropContextManager_GetDatabaseMethod = GetMethod(InteropContextManagerType, "get_Database");
InteropContextManager_GetCurrentRuntimeMethod = GetMethod(InteropContextManagerType, "get_CurrentRuntime");
InteropContextManager_GetRuntimeForObjectMethod = GetMethod
(InteropContextManagerType, "GetRuntimeForObject", ObjectType);
InteropDatabaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropDatabase");
InteropDatabase_RegisterRootExpression = GetMethod(InteropDatabaseType, "RegisterRootExpression", StringType);
InteropDatabase_RegisterDelegateShimMethod = GetMethod
(InteropDatabaseType, "RegisterDelegateShim", TypeType);
InteropDatabase_RegisterTypeMethod = GetMethod
(InteropDatabaseType,
"RegisterType",
TypeType,
IntType,
StringType,
StringType,
IntType,
BooleanType,
BooleanType,
BooleanType);
InteropDatabase_RegisterExportMethod = GetMethod
(InteropDatabaseType, "RegisterExport", MethodBaseType, BooleanType, StringType);
SimpleMethodBaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodBase");
SimpleMethodInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodInfo");
SimpleMethodInfo_Ctor = GetConstructor
(SimpleMethodInfoType, BooleanType, StringType, TypeType, TypeType.GetArrayType(1), TypeType);
SimpleConstructorInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleConstructorInfo");
SimpleConstructorInfo_Ctor = GetConstructor(SimpleConstructorInfoType, TypeType, TypeType.GetArrayType(1));
RuntimeType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "Runtime");
Runtime_CompleteConstructionMethod = GetMethod
(RuntimeType, "CompleteConstruction", SimpleMethodBaseType, ObjectType, JSContextType);
Runtime_CallImportedMethodMethod = GetMethod
(RuntimeType, "CallImportedMethod", SimpleMethodBaseType, StringType, ObjectType.GetArrayType(1));
UniversalDelegateType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "UniversalDelegate");
UniversalDelegate_InvokeMethod = GetUniqueMethod(UniversalDelegateType, "Invoke");
MethodBase_GetGenericArgumentsMethod = GetMethod(MethodBaseType, "GetGenericArguments");
ModuleType = GetType(rewriteAssembly, "", "<Module>");
foreach (var member in ModuleType.Members)
{
var cctor = member as StaticInitializer;
if (cctor != null)
ModuleCCtorMethod = cctor;
}
}
public virtual Differences VisitAssembly(AssemblyNode/*!*/ assembly1, AssemblyNode assembly2) {
Differences differences = new Differences(assembly1, assembly2);
if (assembly1 == null || assembly2 == null){
if (assembly1 != assembly2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
AssemblyNode changes = (AssemblyNode)assembly2.Clone();
AssemblyNode deletions = (AssemblyNode)assembly2.Clone();
AssemblyNode insertions = (AssemblyNode)assembly2.Clone();
this.OriginalModule = assembly1;
this.NewModule = assembly2;
AssemblyReferenceList arChanges, arDeletions, arInsertions;
Differences diff = this.VisitAssemblyReferenceList(assembly1.AssemblyReferences, assembly2.AssemblyReferences, out arChanges, out arDeletions, out arInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.AssemblyReferences = arChanges;
deletions.AssemblyReferences = arDeletions;
insertions.AssemblyReferences = arInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
AttributeList attrChanges, attrDeletions, attrInsertions;
diff = this.VisitAttributeList(assembly1.Attributes, assembly2.Attributes, out attrChanges, out attrDeletions, out attrInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Attributes = attrChanges;
deletions.Attributes = attrDeletions;
insertions.Attributes = attrInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (assembly1.Culture == assembly2.Culture) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
TypeNodeList typeChanges, typeDeletions, typeInsertions;
diff = this.VisitTypeNodeList(assembly1.ExportedTypes, assembly2.ExportedTypes, out typeChanges, out typeDeletions, out typeInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Types = typeChanges;
deletions.Types = typeDeletions;
insertions.Types = typeInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (assembly1.Flags == assembly2.Flags) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (assembly1.Kind == assembly2.Kind) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
diff = this.VisitAttributeList(assembly1.ModuleAttributes, assembly2.ModuleAttributes, out attrChanges, out attrDeletions, out attrInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Attributes = attrChanges;
deletions.Attributes = attrDeletions;
insertions.Attributes = attrInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
ModuleReferenceList mrChanges, mrDeletions, mrInsertions;
diff = this.VisitModuleReferenceList(assembly1.ModuleReferences, assembly2.ModuleReferences, out mrChanges, out mrDeletions, out mrInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.ModuleReferences = mrChanges;
deletions.ModuleReferences = mrDeletions;
insertions.ModuleReferences = mrInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (assembly1.Name == assembly2.Name) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
SecurityAttributeList secChanges, secDeletions, secInsertions;
diff = this.VisitSecurityAttributeList(assembly1.SecurityAttributes, assembly2.SecurityAttributes, out secChanges, out secDeletions, out secInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.SecurityAttributes = secChanges;
deletions.SecurityAttributes = secDeletions;
insertions.SecurityAttributes = secInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitTypeNodeList(assembly1.Types, assembly2.Types, out typeChanges, out typeDeletions, out typeInsertions);
if (diff == null){Debug.Assert(false); return differences;}
changes.Types = typeChanges;
deletions.Types = typeDeletions;
insertions.Types = typeInsertions;
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (assembly1.Version == assembly2.Version) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
private TypeNode GetType(AssemblyNode assembly, string ns, string name)
{
var res = assembly.GetType(Identifier.For(ns), Identifier.For(name));
if (res == null)
{
Log(new InvalidInteropMessage(null, "can't load required type: " + ns + "." + name));
throw new ExitException();
}
return res;
}
public override AssemblyNode VisitAssembly(AssemblyNode assembly)
{
throw new ApplicationException("unimplemented");
}
public override Compilation VisitCompilation(Compilation compilation){
if (compilation == null || compilation.TargetModule == null) return null;
this.currentOptions = compilation.CompilerParameters as CompilerOptions;
this.currentModule = compilation.TargetModule;
this.currentAssembly = this.currentModule.ContainingAssembly;
return base.VisitCompilation(compilation);
}
private static TypeNode GetTypeNode(AssemblyNode assembly, string ns, string name)
{
Contract.Assert(assembly != null);
return assembly.GetType(Identifier.For(ns), Identifier.For(name));
}
public BaseQuery(AssemblyNode mainModule)
{
MainModule = mainModule;
}
public virtual AssemblyNode VisitAssembly(AssemblyNode assembly, AssemblyNode changes, AssemblyNode deletions, AssemblyNode insertions){
this.UpdateSourceContext(assembly, changes);
if (assembly == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
assembly.AssemblyReferences = this.VisitAssemblyReferenceList(assembly.AssemblyReferences, changes.AssemblyReferences, deletions.AssemblyReferences, insertions.AssemblyReferences);
assembly.Attributes = this.VisitAttributeList(assembly.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes);
assembly.Culture = changes.Culture;
assembly.ExportedTypes = this.VisitTypeReferenceList(assembly.ExportedTypes, changes.ExportedTypes, deletions.ExportedTypes, insertions.ExportedTypes);
assembly.Flags = changes.Flags;
assembly.Kind = changes.Kind;
assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes, changes.ModuleAttributes, deletions.ModuleAttributes, insertions.ModuleAttributes);
assembly.ModuleReferences = this.VisitModuleReferenceList(assembly.ModuleReferences, changes.ModuleReferences, deletions.ModuleReferences, insertions.ModuleReferences);
assembly.Name = changes.Name;
assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes, changes.SecurityAttributes, deletions.SecurityAttributes, insertions.SecurityAttributes);
assembly.Types = this.VisitTypeNodeList(assembly.Types, changes.Types, deletions.Types, insertions.Types);
assembly.Version = changes.Version;
}
}else if (deletions != null)
return null;
return assembly;
}
public virtual void VisitAssembly(AssemblyNode assembly)
{
if (assembly == null) return;
this.VisitModule(assembly);
this.VisitAttributeList(assembly.ModuleAttributes);
this.VisitSecurityAttributeList(assembly.SecurityAttributes);
}
