static void AnalyzeParameterList(SyntaxNodeAnalysisContext nodeContext)
        {
            var node = nodeContext.Node as TypeParameterListSyntax;

            var member = node.Parent;
            if (member == null)
                return;

            var memberSymbol = nodeContext.SemanticModel.GetDeclaredSymbol(member);
            if (memberSymbol.IsAbstract || memberSymbol.IsVirtual || memberSymbol.IsOverride)
                return;
            if (memberSymbol.ExplicitInterfaceImplementations().Length > 0)
                return;
            
            var walker = new ReferenceFinder(nodeContext);
            walker.Visit(member);

            foreach (var param in node.Parameters)
            {
                var sym = nodeContext.SemanticModel.GetDeclaredSymbol(param);
                if (sym == null)
                    continue;
                if (!walker.UsedTypeParameters.Contains(sym)) {
                    var diagnostic = Diagnostic.Create(descriptor, param.Identifier.GetLocation(), sym.Name);
                    nodeContext.ReportDiagnostic(diagnostic);
                }

            }
        }
 public static bool DerivesFrom(this TypeDefinition typeDefinition, Type type)
 {
     if (!type.IsClass)
     {
         throw new InvalidOperationException("The <type> argument (" + type.Name + ") must be a class type.");
     }
     var referenceFinder = new ReferenceFinder(typeDefinition.Module);
     var baseTypeDefinition = referenceFinder.GetTypeReference(type);
     return typeDefinition.DerivesFrom(baseTypeDefinition);
 }
Пример #3
0
    public void Execute()
    {
        var msCoreReferenceFinder = new ReferenceFinder
            {
                ModuleDefinition = ModuleDefinition,
                AssemblyResolver = AssemblyResolver
            };
        msCoreReferenceFinder.Execute();

        var interceptorFinder = new InterceptorFinder
            {
                ModuleDefinition = ModuleDefinition
            };
        interceptorFinder.Execute();

        var methodProcessor = new MethodProcessor
            {
                referenceFinder = msCoreReferenceFinder,
                typeSystem = ModuleDefinition.TypeSystem, InterceptorFinder = interceptorFinder,
            };
        foreach (var typeDefinition in ModuleDefinition.GetTypes())
        {
            if (typeDefinition.ContainsTimeAttribute())
            {
                methodProcessor.Process(typeDefinition.Methods.Where(x => !x.IsAbstract));
                continue;
            }
            foreach (var method in typeDefinition.Methods)
            {
                if (method.IsAbstract)
                {
                    continue;
                }
                if (!method.ContainsTimeAttribute())
                {
                    continue;
                }
                methodProcessor.Process(method);
            }
        }
    }
Пример #4
0
 public MethodDecorator(ModuleDefinition moduleDefinition)
 {
     this._referenceFinder = new ReferenceFinder(moduleDefinition);
 }
        public void ChangeSavedOneToOneReferenceTest()
        {
            Key person1Key, person2Key;
            Key license1Key, license2Key;

            using (var populateSession = Domain.OpenSession())
                using (var transaction = populateSession.OpenTransaction()) {
                    var person = new Person()
                    {
                        DriverLicense = new DriverLicense()
                    };
                    person1Key  = person.Key;
                    license1Key = person.DriverLicense.Key;

                    person = new Person()
                    {
                        DriverLicense = new DriverLicense()
                    };
                    person2Key  = person.Key;
                    license2Key = person.DriverLicense.Key;
                    transaction.Complete();
                }

            using (var session = Domain.OpenSession(sessionConfiguration)) {
                var person1  = session.Query.Single <Person>(person1Key);
                var person2  = session.Query.Single <Person>(person2Key);
                var license1 = person1.DriverLicense;
                var license2 = person2.DriverLicense;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(person2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license2).Count(), Is.EqualTo(1));

                var newlicense = new DriverLicense();
                person1.DriverLicense = newlicense;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(person2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(license2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(newlicense).Count(), Is.EqualTo(1));

                var newPerson = new Person();
                license2.Person = newPerson;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(person2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(newPerson).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(license2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(newlicense).Count(), Is.EqualTo(1));

                person1.DriverLicense = null;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(newPerson).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(license2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(newlicense).Count(), Is.EqualTo(0));

                license2.Person = null;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(newPerson).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(license1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(license2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(newlicense).Count(), Is.EqualTo(0));
            }
        }
Пример #6
0
        public override void Run(RefactoringOptions options)
        {
            if (options.SelectedItem is LocalVariable || options.SelectedItem is IParameter)
            {
                var col = ReferenceFinder.FindReferences(options.SelectedItem);
                if (col == null)
                {
                    return;
                }
                TextEditorData             data   = options.GetTextEditorData();
                Mono.TextEditor.TextEditor editor = data.Parent;
                if (editor == null)
                {
                    MessageService.ShowCustomDialog(new RenameItemDialog(options, this));
                    return;
                }

                List <TextLink> links      = new List <TextLink> ();
                TextLink        link       = new TextLink("name");
                int             baseOffset = Int32.MaxValue;
                foreach (MemberReference r in col)
                {
                    baseOffset = Math.Min(baseOffset, data.Document.LocationToOffset(r.Line, r.Column));
                }
                foreach (MemberReference r in col)
                {
                    Segment segment = new Segment(data.Document.LocationToOffset(r.Line, r.Column) - baseOffset, r.Name.Length);
                    if (segment.Offset <= data.Caret.Offset - baseOffset && data.Caret.Offset - baseOffset <= segment.EndOffset)
                    {
                        link.Links.Insert(0, segment);
                    }
                    else
                    {
                        link.AddLink(segment);
                    }
                }

                links.Add(link);
                if (editor.CurrentMode is TextLinkEditMode)
                {
                    ((TextLinkEditMode)editor.CurrentMode).ExitTextLinkMode();
                }
                TextLinkEditMode tle = new TextLinkEditMode(editor, baseOffset, links);
                tle.SetCaretPosition  = false;
                tle.SelectPrimaryLink = true;
                if (tle.ShouldStartTextLinkMode)
                {
                    ModeHelpWindow helpWindow = new ModeHelpWindow();
                    helpWindow.TransientFor = IdeApp.Workbench.RootWindow;
                    helpWindow.TitleText    = options.SelectedItem is LocalVariable?GettextCatalog.GetString("<b>Local Variable -- Renaming</b>") : GettextCatalog.GetString("<b>Parameter -- Renaming</b>");

                    helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Key</b>"), GettextCatalog.GetString("<b>Behavior</b>")));
                    helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Return</b>"), GettextCatalog.GetString("<b>Accept</b> this refactoring.")));
                    helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Esc</b>"), GettextCatalog.GetString("<b>Cancel</b> this refactoring.")));
                    tle.HelpWindow = helpWindow;
                    tle.Cancel    += delegate {
                        editor.Document.Undo();
                    };
                    tle.OldMode = data.CurrentMode;
                    tle.StartMode();
                    data.CurrentMode = tle;
                }
            }
            else
            {
                MessageService.ShowCustomDialog(new RenameItemDialog(options, this));
            }
        }
    string GetReferences()
    {
        var referenceFinder = new ReferenceFinder(assemblyPath, projectPath);
        var builder = new StringBuilder();

        var assemblyNameReferences = ModuleDefinition.ReadModule(assemblyPath).AssemblyReferences;
        foreach (var assemblyNameReference in assemblyNameReferences)
        {
            builder.Append(referenceFinder.Resolve(assemblyNameReference));
            builder.Append(";");
        }
        builder.Append(referenceFinder.Resolve("System"));
        builder.Append(";");
        builder.Append(referenceFinder.Resolve("System.Core"));
        builder.Append(";");
        return builder.ToString();
    }
 public MethodDecorator(ModuleDefinition moduleDefinition)
 {
     this.referenceFinder = new ReferenceFinder(moduleDefinition);
 }
Пример #9
0
    public static void AddDebuggerDisplayAttributes(ModuleDefinition moduleDefinition, TypeDefinition type, ReferenceFinder referenceFinder)
    {
        if (type.IsEnum ||
            type.CustomAttributes.Any(c => c.AttributeType.Name == "CompilerGeneratedAttribute" || c.AttributeType.Name == "DebuggerDisplayAttribute"))
        {
            return;
        }

        var fields = type.Fields
                     .Where(f => f.IsPublic &&
                            !f.HasConstant &&
                            !f.IsStatic &&
                            CanPrint(f.FieldType))
                     .Cast <MemberReference>();
        var props = type.Properties
                    .Where(p =>
                           p.GetMethod != null &&
                           p.GetMethod.IsPublic &&
                           !p.GetMethod.IsStatic &&
                           !p.GetMethod.HasParameters &&
                           CanPrint(p.PropertyType))
                    .Cast <MemberReference>();

        var displayBits = fields.Concat(props)
                          .OrderBy(m => m, new DisplayAttributeOrderComparer())
                          .ToList();

        if (!displayBits.Any())
        {
            return;
        }

        AddSimpleDebuggerDisplayAttribute(moduleDefinition, type, referenceFinder);

        if (type.Methods.Any(m => m.Name == "DebuggerDisplay" && m.Parameters.Count == 0))
        {
            return;
        }

        var debuggerDisplayMethod = new MethodDefinition("DebuggerDisplay", MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.SpecialName, moduleDefinition.TypeSystem.String);
        var body = debuggerDisplayMethod.Body;

        var arrayVar = new VariableDefinition(moduleDefinition.TypeSystem.Object.MakeArrayType());

        body.Variables.Add(arrayVar);

        body.SimplifyMacros();
        var instructions = body.Instructions;

        instructions.Add(Instruction.Create(OpCodes.Ldstr, string.Join(" | ", displayBits.Select((m, i) => $"{DisplayName(m)} = \"{{{i}}}\""))));
        instructions.Add(Instruction.Create(OpCodes.Ldc_I4, displayBits.Count));
        instructions.Add(Instruction.Create(OpCodes.Newarr, moduleDefinition.TypeSystem.Object));
        instructions.Add(Instruction.Create(OpCodes.Stloc, arrayVar));

        for (var i = 0; i < displayBits.Count; i++)
        {
            instructions.Add(Instruction.Create(OpCodes.Ldloc, arrayVar));
            instructions.Add(Instruction.Create(OpCodes.Ldc_I4, i));
            instructions.Add(Instruction.Create(OpCodes.Ldarg_0));

            if (displayBits[i] is FieldDefinition field)
            {
                instructions.Add(Instruction.Create(OpCodes.Ldfld, field));
                if (!field.FieldType.IsRefType())
                {
                    instructions.Add(Instruction.Create(OpCodes.Box, field.FieldType));
                }
            }

            if (displayBits[i] is PropertyDefinition property)
            {
                instructions.Add(Instruction.Create(OpCodes.Call, property.GetMethod));
                if (!property.PropertyType.IsRefType())
                {
                    instructions.Add(Instruction.Create(OpCodes.Box, property.PropertyType));
                }
            }

            instructions.Add(Instruction.Create(OpCodes.Stelem_Ref));
        }

        instructions.Add(Instruction.Create(OpCodes.Ldloc, arrayVar));
        instructions.Add(Instruction.Create(OpCodes.Call, referenceFinder.StringFormat));
        instructions.Add(Instruction.Create(OpCodes.Ret));
        body.InitLocals = true;
        body.OptimizeMacros();

        type.Methods.Add(debuggerDisplayMethod);
    }
Пример #10
0
        public override void Run(RefactoringOptions options)
        {
            if (options.SelectedItem is IVariable)
            {
                var field = options.SelectedItem as IField;
                if (field != null && (field.Accessibility != Accessibility.Private || field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Parts.Count > 1))
                {
                    MessageService.ShowCustomDialog(new RenameItemDialog(options, this));
                    return;
                }

                var par = options.SelectedItem as IParameter;
                if (par != null && (par.Owner.Accessibility != Accessibility.Private || par.Owner.DeclaringTypeDefinition != null && par.Owner.DeclaringTypeDefinition.Parts.Count > 1))
                {
                    MessageService.ShowCustomDialog(new RenameItemDialog(options, this));
                    return;
                }

                var col = ReferenceFinder.FindReferences(options.SelectedItem, true);
                if (col == null)
                {
                    return;
                }
                var data = options.Document != null?options.GetTextEditorData() : IdeApp.Workbench.ActiveDocument.Editor;

                var editor = data.Parent;
                if (editor == null)
                {
                    MessageService.ShowCustomDialog(new RenameItemDialog(options, this));
                    return;
                }

                var links      = new List <TextLink> ();
                var link       = new TextLink("name");
                int baseOffset = Int32.MaxValue;
                foreach (var r in col)
                {
                    baseOffset = Math.Min(baseOffset, r.Offset);
                }
                foreach (MemberReference r in col)
                {
                    var segment = new TextSegment(r.Offset - baseOffset, r.Length);
                    if (segment.Offset <= data.Caret.Offset - baseOffset && data.Caret.Offset - baseOffset <= segment.EndOffset)
                    {
                        link.Links.Insert(0, segment);
                    }
                    else
                    {
                        link.AddLink(segment);
                    }
                }

                links.Add(link);
                if (editor.CurrentMode is TextLinkEditMode)
                {
                    ((TextLinkEditMode)editor.CurrentMode).ExitTextLinkMode();
                }
                TextLinkEditMode tle = new TextLinkEditMode(editor, baseOffset, links);
                tle.SetCaretPosition  = false;
                tle.SelectPrimaryLink = true;
                if (tle.ShouldStartTextLinkMode)
                {
                    var helpWindow = new TableLayoutModeHelpWindow();
                    helpWindow.TitleText = options.SelectedItem is IVariable?GettextCatalog.GetString("<b>Local Variable -- Renaming</b>") : GettextCatalog.GetString("<b>Parameter -- Renaming</b>");

                    helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Key</b>"), GettextCatalog.GetString("<b>Behavior</b>")));
                    helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Return</b>"), GettextCatalog.GetString("<b>Accept</b> this refactoring.")));
                    helpWindow.Items.Add(new KeyValuePair <string, string> (GettextCatalog.GetString("<b>Esc</b>"), GettextCatalog.GetString("<b>Cancel</b> this refactoring.")));
                    tle.HelpWindow = helpWindow;
                    tle.Cancel    += delegate {
                        if (tle.HasChangedText)
                        {
                            editor.Document.Undo();
                        }
                    };
                    tle.OldMode = data.CurrentMode;
                    tle.StartMode();
                    data.CurrentMode = tle;
                }
            }
            else
            {
                MessageService.ShowCustomDialog(new RenameItemDialog(options, this));
            }
        }
Пример #11
0
    static void AddIEnumerableTProxy(ModuleDefinition moduleDefinition, TypeDefinition type, GenericInstanceType enumerableT, ReferenceFinder referenceFinder)
    {
        var itemType  = enumerableT.GenericArguments[0];
        var itemArray = itemType.MakeArrayType();

        var           proxyType    = CreateProxy(moduleDefinition, type, referenceFinder);
        TypeReference proxyTypeRef = proxyType;

        if (type.HasGenericParameters)
        {
            proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(CloneGenericParameter).ToArray());
        }

        var field    = proxyType.Fields[0];
        var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef);

        var listCtor    = referenceFinder.ListCtor.MakeHostInstanceGeneric(itemType);
        var listToArray = referenceFinder.ListToArray.MakeHostInstanceGeneric(itemType);

        var getMethod = new MethodDefinition("get_Items", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, itemArray);

        getMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
        getMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
        getMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Newobj, listCtor));
        getMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Call, listToArray));
        getMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
        proxyType.Methods.Add(getMethod);

        var property = new PropertyDefinition("Items", PropertyAttributes.None, itemArray)
        {
            GetMethod = getMethod
        };
        var debuggerBrowsableAttribute = new CustomAttribute(referenceFinder.DebuggerBrowsableAttributeCtor);

        debuggerBrowsableAttribute.ConstructorArguments.Add(new CustomAttributeArgument(referenceFinder.DebuggerBrowsableStateType, (int)DebuggerBrowsableState.RootHidden));
        property.CustomAttributes.Add(debuggerBrowsableAttribute);
        proxyType.Properties.Add(property);

        AddDebuggerTypeProxyAttribute(type, proxyType, referenceFinder);
    }
Пример #12
0
    static TypeDefinition CreateProxy(ModuleDefinition moduleDefinition, TypeDefinition type, ReferenceFinder referenceFinder)
    {
        var proxyType = new TypeDefinition(
            null,
            $"<{type.Name.Split('`')[0]}>Proxy",
            TypeAttributes.NestedPrivate | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
            moduleDefinition.TypeSystem.Object);
        TypeReference proxyTypeRef = proxyType;

        type.NestedTypes.Add(proxyType);

        proxyType.CustomAttributes.Add(new CustomAttribute(referenceFinder.CompilerGeneratedAttributeCtor));

        if (type.HasGenericParameters)
        {
            foreach (var genericParameter in type.GenericParameters)
            {
                proxyType.GenericParameters.Add(new GenericParameter(genericParameter.Name, proxyType));
            }

            proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(CloneGenericParameter).ToArray());
        }

        var originalType = moduleDefinition.ImportReference(type);

        if (type.HasGenericParameters)
        {
            originalType = originalType.MakeGenericInstanceType(proxyType.GenericParameters.ToArray());
        }

        var field = new FieldDefinition("original", FieldAttributes.Private | FieldAttributes.InitOnly, originalType);

        proxyType.Fields.Add(field);
        var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef);

        var method = new MethodDefinition(
            ".ctor",
            MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
            moduleDefinition.TypeSystem.Void);

        method.Parameters.Add(new ParameterDefinition("original", ParameterAttributes.None, originalType));
        method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
        method.Body.Instructions.Add(Instruction.Create(OpCodes.Call, moduleDefinition.ImportReference(moduleDefinition.TypeSystem.Object.Resolve().Constructors().First())));
        method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
        method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
        method.Body.Instructions.Add(Instruction.Create(OpCodes.Stfld, fieldRef));
        method.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
        proxyType.Methods.Add(method);

        return(proxyType);
    }
Пример #13
0
        public void ClearEntitySetTest()
        {
            Key firstReferencingEntityKey, secondReferencingEntityKey;
            Key firstReferencedEntityKey, secondReferencedEntityKey;
            Key sharedReferencedEntityKey;

            using (var populateSession = Domain.OpenSession())
                using (var transaction = populateSession.OpenTransaction()) {
                    var firstReferencingEntity = new EntityWithManyReferences();
                    firstReferencingEntityKey = firstReferencingEntity.Key;

                    var secondReferencingEntity = new EntityWithManyReferences();
                    secondReferencingEntityKey = secondReferencingEntity.Key;

                    var firstReferencedEntity = new ReferencedEntity();
                    firstReferencedEntityKey = firstReferencedEntity.Key;
                    firstReferencingEntity.Entities.Add(firstReferencedEntity);

                    var secondReferencedEntity = new ReferencedEntity();
                    secondReferencedEntityKey = secondReferencedEntity.Key;
                    secondReferencingEntity.Entities.Add(secondReferencedEntity);

                    var sharedReferencedEntity = new ReferencedEntity();
                    sharedReferencedEntityKey = sharedReferencedEntity.Key;
                    firstReferencingEntity.Entities.Add(sharedReferencedEntity);
                    secondReferencingEntity.Entities.Add(sharedReferencedEntity);

                    transaction.Complete();
                }

            using (var session = Domain.OpenSession(sessionConfiguration)) {
                var firstReferencingEntity  = session.Query.Single <EntityWithManyReferences>(firstReferencingEntityKey);
                var firstReferencedEntity   = session.Query.Single <ReferencedEntity>(firstReferencedEntityKey);
                var secondReferencingEntity = session.Query.Single <EntityWithManyReferences>(secondReferencingEntityKey);
                var secondReferencedEntity  = session.Query.Single <ReferencedEntity>(secondReferencedEntityKey);
                var sharedReferencedEntity  = session.Query.Single <ReferencedEntity>(sharedReferencedEntityKey);

                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                var expectedAssociation = firstReferencingEntity.TypeInfo.Fields["Entities"].Associations.First();
                Assert.That(expectedAssociation.IsPaired, Is.False);
                Assert.That(expectedAssociation.TargetType, Is.EqualTo(firstReferencedEntity.TypeInfo));

                var references = ReferenceFinder.GetReferencesTo(firstReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == firstReferencedEntity && r.ReferencingEntity == firstReferencingEntity), Is.True);

                references = ReferenceFinder.GetReferencesTo(secondReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == secondReferencedEntity && r.ReferencingEntity == secondReferencingEntity), Is.True);

                references = ReferenceFinder.GetReferencesTo(sharedReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(2));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == sharedReferencedEntity && r.ReferencingEntity == firstReferencingEntity), Is.True);
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == sharedReferencedEntity && r.ReferencingEntity == secondReferencingEntity), Is.True);

                firstReferencingEntity.Entities.Clear();
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(2));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                references = ReferenceFinder.GetReferencesTo(firstReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(0));

                references = ReferenceFinder.GetReferencesTo(secondReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == secondReferencedEntity && r.ReferencingEntity == secondReferencingEntity), Is.True);

                references = ReferenceFinder.GetReferencesTo(sharedReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == sharedReferencedEntity && r.ReferencingEntity == firstReferencingEntity), Is.False);
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == sharedReferencedEntity && r.ReferencingEntity == secondReferencingEntity), Is.True);

                secondReferencingEntity.Entities.Clear();
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(4));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                references = ReferenceFinder.GetReferencesTo(firstReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(0));

                references = ReferenceFinder.GetReferencesTo(secondReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(0));

                references = ReferenceFinder.GetReferencesTo(sharedReferencedEntity).ToList();
                Assert.That(references.Count, Is.EqualTo(0));
            }
        }
Пример #14
0
        public override List <Change> PerformChanges(RefactoringOptions options, object prop)
        {
            List <Change>          result        = new List <Change> ();
            TextEditorData         data          = options.GetTextEditorData();
            MemberResolveResult    resolveResult = options.ResolveResult as MemberResolveResult;
            IProperty              property      = resolveResult.ResolvedMember as IProperty;
            INRefactoryASTProvider astProvider   = options.GetASTProvider();
            string backingStoreName = RetrieveBackingStore(options, astProvider, property);

            int    backinStoreStart;
            int    backinStoreEnd;
            IField backingStore = GetBackingStoreField(options, backingStoreName, out backinStoreStart, out backinStoreEnd);

            if (backingStore != null)
            {
                using (var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true)) {
                    foreach (MemberReference memberRef in ReferenceFinder.FindReferences(backingStore, monitor))
                    {
                        result.Add(new TextReplaceChange()
                        {
                            FileName     = memberRef.FileName,
                            Offset       = memberRef.Position,
                            RemovedChars = memberRef.Name.Length,
                            InsertedText = property.Name
                        });
                    }
                }

                result.RemoveAll(c => backinStoreStart <= ((TextReplaceChange)c).Offset && ((TextReplaceChange)c).Offset <= backinStoreEnd);
                result.Add(new TextReplaceChange()
                {
                    FileName     = options.Document.FileName,
                    Offset       = backinStoreStart,
                    RemovedChars = backinStoreEnd - backinStoreStart
                });
            }

            if (property.HasGet)
            {
                int startOffset = data.Document.LocationToOffset(property.GetRegion.Start.ToDocumentLocation(data.Document));
                int endOffset   = data.Document.LocationToOffset(property.GetRegion.End.ToDocumentLocation(data.Document));

                string text = astProvider.OutputNode(options.Dom, new PropertyGetRegion(null, null), options.GetIndent(property) + "\t").Trim();

                result.RemoveAll(c => startOffset <= ((TextReplaceChange)c).Offset && ((TextReplaceChange)c).Offset <= endOffset);
                result.Add(new TextReplaceChange()
                {
                    FileName     = options.Document.FileName,
                    Offset       = startOffset,
                    RemovedChars = endOffset - startOffset,
                    InsertedText = text
                });
            }

            int setStartOffset;
            int setEndOffset;
            PropertySetRegion setRegion = new PropertySetRegion(null, null);
            string            setText;

            if (property.HasSet)
            {
                setStartOffset = data.Document.LocationToOffset(property.SetRegion.Start.ToDocumentLocation(data.Document));
                setEndOffset   = data.Document.LocationToOffset(property.SetRegion.End.ToDocumentLocation(data.Document));
                setText        = astProvider.OutputNode(options.Dom, setRegion, options.GetIndent(property) + "\t").Trim();
            }
            else
            {
                setEndOffset       = setStartOffset = data.Document.LocationToOffset(property.GetRegion.End.ToDocumentLocation(data.Document));
                setRegion.Modifier = ICSharpCode.NRefactory.Ast.Modifiers.Private;
                setText            = Environment.NewLine + astProvider.OutputNode(options.Dom, setRegion, options.GetIndent(property) + "\t").TrimEnd();
            }
            result.RemoveAll(c => setStartOffset <= ((TextReplaceChange)c).Offset && ((TextReplaceChange)c).Offset <= setEndOffset);
            result.Add(new TextReplaceChange()
            {
                FileName     = options.Document.FileName,
                Offset       = setStartOffset,
                RemovedChars = setEndOffset - setStartOffset,
                InsertedText = setText
            });
            return(result);
        }
Пример #15
0
        public void AddEntityToEntitySetTest()
        {
            Key firstReferencingKey;
            Key secondReferencingKey;
            var firstList  = new List <Key>();
            var secondList = new List <Key>();

            using (var populateSession = Domain.OpenSession())
                using (var transaction = populateSession.OpenTransaction()) {
                    var referencedEntities = new List <ReferencedEntity>();
                    for (int i = 0; i < 10; i++)
                    {
                        referencedEntities.Add(new ReferencedEntity());
                    }

                    var referencingEntity = new EntityWithManyReferences();
                    firstReferencingKey = referencingEntity.Key;
                    foreach (var referencedEntity in referencedEntities.Take(5))
                    {
                        referencingEntity.Entities.Add(referencedEntity);
                        firstList.Add(referencedEntity.Key);
                    }

                    referencingEntity    = new EntityWithManyReferences();
                    secondReferencingKey = referencingEntity.Key;
                    foreach (var referencedEntity in referencedEntities.Skip(5))
                    {
                        referencingEntity.Entities.Add(referencedEntity);
                        secondList.Add(referencedEntity.Key);
                    }
                    transaction.Complete();
                }

            using (var session = Domain.OpenSession(sessionConfiguration)) {
                var firstReferencingEntity  = session.Query.Single <EntityWithManyReferences>(firstReferencingKey);
                var secondReferencingEntity = session.Query.Single <EntityWithManyReferences>(secondReferencingKey);

                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));

                var expectedAssociation = firstReferencingEntity.TypeInfo.Fields["Entities"].Associations.First();
                Assert.That(expectedAssociation.IsPaired, Is.False);
                Assert.That(expectedAssociation.TargetType, Is.EqualTo(Domain.Model.Types[typeof(ReferencedEntity)]));

                List <ReferenceInfo> references;
                foreach (var key in firstList)
                {
                    var referencedEntity = session.Query.Single <ReferencedEntity>(key);
                    references = ReferenceFinder.GetReferencesTo(referencedEntity).ToList();
                    Assert.That(references.Count, Is.EqualTo(1));
                    Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == referencedEntity && r.ReferencingEntity == firstReferencingEntity), Is.True);
                }

                foreach (var key in secondList)
                {
                    var referencedEntity = session.Query.Single <ReferencedEntity>(key);
                    references = ReferenceFinder.GetReferencesTo(referencedEntity).ToList();
                    Assert.That(references.Count, Is.EqualTo(1));
                    Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == referencedEntity && r.ReferencingEntity == secondReferencingEntity), Is.True);
                }

                var newReferencedEntity1 = new ReferencedEntity();
                var newReferencedEntity2 = new ReferencedEntity();
                var newReferencedEntity3 = new ReferencedEntity();
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(newReferencedEntity1).Count(), Is.EqualTo(0));
                firstReferencingEntity.Entities.Add(newReferencedEntity1);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(1));
                references = ReferenceFinder.GetReferencesTo(newReferencedEntity1).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == newReferencedEntity1 && r.ReferencingEntity == firstReferencingEntity), Is.True);

                secondReferencingEntity.Entities.Add(newReferencedEntity2);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(2));
                references = ReferenceFinder.GetReferencesTo(newReferencedEntity2).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == newReferencedEntity2 && r.ReferencingEntity == secondReferencingEntity), Is.True);

                firstReferencingEntity.Entities.Add(newReferencedEntity3);
                secondReferencingEntity.Entities.Add(newReferencedEntity3);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(4));
                references = ReferenceFinder.GetReferencesTo(newReferencedEntity3).ToList();
                Assert.That(references.Count, Is.EqualTo(2));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == newReferencedEntity3 && r.ReferencingEntity == firstReferencingEntity), Is.True);
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == newReferencedEntity3 && r.ReferencingEntity == secondReferencingEntity), Is.True);

                var entityFromFirstList = session.Query.Single <ReferencedEntity>(firstList[0]);
                references = ReferenceFinder.GetReferencesTo(entityFromFirstList).ToList();
                Assert.That(references.Count, Is.EqualTo(1));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == entityFromFirstList && r.ReferencingEntity == firstReferencingEntity), Is.True);
                secondReferencingEntity.Entities.Add(entityFromFirstList);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(5));
                references = ReferenceFinder.GetReferencesTo(entityFromFirstList).ToList();
                Assert.That(references.Count, Is.EqualTo(2));
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == entityFromFirstList && r.ReferencingEntity == firstReferencingEntity), Is.True);
                Assert.That(references.Any(r => r.Association == expectedAssociation && r.ReferencedEntity == entityFromFirstList && r.ReferencingEntity == secondReferencingEntity), Is.True);
            }
        }
        public void RemoveEntityToEntitySetTest()
        {
            Key tableWithItemsKey;
            Key item1Key, item2Key;
            Key book1Key, book2Key;
            Key author1Key, author2Key;

            using (var populateSession = Domain.OpenSession())
                using (var transaction = populateSession.OpenTransaction()) {
                    var tableWithItems = new TableOfContent();
                    tableWithItemsKey = tableWithItems.Key;
                    var item1 = new TableOfContentItem();
                    var item2 = new TableOfContentItem();
                    item1Key = item1.Key;
                    item2Key = item2.Key;
                    tableWithItems.Items.Add(item1);
                    tableWithItems.Items.Add(item2);

                    var book1 = new Book();
                    book1Key = book1.Key;
                    var book2 = new Book();
                    book2Key = book2.Key;

                    var author1 = new Author();
                    author1Key = author1.Key;
                    var author2 = new Author();
                    author2Key = author2.Key;

                    author1.Books.Add(book1);
                    author1.Books.Add(book2);
                    author2.Books.Add(book1);
                    author2.Books.Add(book2);

                    transaction.Complete();
                }

            using (var session = Domain.OpenSession(sessionConfiguration)) {
                var tableWithItems = session.Query.Single <TableOfContent>(tableWithItemsKey);
                var item1          = session.Query.Single <TableOfContentItem>(item1Key);
                var item2          = session.Query.Single <TableOfContentItem>(item2Key);
                var item3          = new TableOfContentItem();
                tableWithItems.Items.Add(item3);

                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(item1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(item2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(item3).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableWithItems).Count(), Is.EqualTo(3));

                tableWithItems.Items.Remove(item3);
                tableWithItems.Items.Remove(item2);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(item1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(item2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(item3).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableWithItems).Count(), Is.EqualTo(1));

                var oldBook1 = session.Query.Single <Book>(book1Key);
                var oldBook2 = session.Query.Single <Book>(book2Key);
                var newBook  = new Book();

                var oldAutor1 = session.Query.Single <Author>(author1Key);
                var oldAutor2 = session.Query.Single <Author>(author2Key);
                var newAuthor = new Author();

                newAuthor.Books.Add(oldBook1);
                newAuthor.Books.Add(oldBook2);
                newAuthor.Books.Add(newBook);

                newBook.Authors.Add(oldAutor1);
                newBook.Authors.Add(oldAutor2);

                Assert.That(ReferenceFinder.GetReferencesTo(oldBook1).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook2).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor1).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor2).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(newBook).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(newAuthor).Count(), Is.EqualTo(3));

                oldAutor1.Books.Remove(oldBook1);
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook1).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook2).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor1).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor2).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(newBook).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(newAuthor).Count(), Is.EqualTo(3));

                oldBook2.Authors.Remove(oldAutor2);
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook1).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook2).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor1).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor2).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(newBook).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(newAuthor).Count(), Is.EqualTo(3));

                oldAutor1.Books.Remove(newBook);
                newBook.Authors.Remove(oldAutor2);
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook1).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook2).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(newBook).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(newAuthor).Count(), Is.EqualTo(3));

                newBook.Authors.Remove(newAuthor);
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook1).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldBook2).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(oldAutor2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(newBook).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(newAuthor).Count(), Is.EqualTo(2));
            }
        }
        public void ChangeReferenceToSameObjectTest()
        {
            Key person1Key, person2Key;
            Key license1Key, license2Key;
            Key tableOfContentKey, item1Key, item2Key;

            using (var populateSession = Domain.OpenSession())
                using (var transaction = populateSession.OpenTransaction()) {
                    var person1 = new Person {
                        DriverLicense = new DriverLicense()
                    };
                    var person2 = new Person {
                        DriverLicense = new DriverLicense()
                    };
                    person1Key  = person1.Key;
                    person2Key  = person2.Key;
                    license1Key = person1.DriverLicense.Key;
                    license2Key = person2.DriverLicense.Key;

                    var tableOfContent = new TableOfContent();
                    tableOfContentKey = tableOfContent.Key;

                    var item1 = new TableOfContentItem();
                    item1Key = item1.Key;
                    tableOfContent.Items.Add(item1);

                    var item2 = new TableOfContentItem();
                    item2Key = item2.Key;
                    tableOfContent.Items.Add(item2);

                    transaction.Complete();
                }

            using (var session = Domain.OpenSession(sessionConfiguration)) {
                var person  = session.Query.Single <Person>(person1Key);
                var license = session.Query.Single <DriverLicense>(license1Key);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license).Count(), Is.EqualTo(1));
                person.DriverLicense = license;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license).Count(), Is.EqualTo(1));

                person  = session.Query.Single <Person>(person2Key);
                license = session.Query.Single <DriverLicense>(license2Key);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license).Count(), Is.EqualTo(1));

                license.Person = person;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(person).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(license).Count(), Is.EqualTo(1));

                var item1          = session.Query.Single <TableOfContentItem>(item1Key);
                var item2          = session.Query.Single <TableOfContentItem>(item2Key);
                var tableOfContent = session.Query.Single <TableOfContent>(tableOfContentKey);
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(item1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(item2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(2));

                item1.TableOfContent = tableOfContent;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(item1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(item2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(2));

                item2.TableOfContent = tableOfContent;
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(item1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(item2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(2));
            }
        }
Пример #18
0
        public static void FindDerivedClasses(ITypeDefinition cls)
        {
            var solution = IdeApp.ProjectOperations.CurrentSelectedSolution;

            if (solution == null)
            {
                return;
            }

            var sourceProject = TypeSystemService.GetProject(cls);

            if (sourceProject == null)
            {
                return;
            }

            var projects = ReferenceFinder.GetAllReferencingProjects(solution, sourceProject);

            ThreadPool.QueueUserWorkItem(delegate {
                using (var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true)) {
                    var cache = new Dictionary <string, TextEditorData> ();
                    Parallel.ForEach(projects, p => {
                        var comp = TypeSystemService.GetCompilation(p);
                        if (comp == null)
                        {
                            return;
                        }
                        var importedType = comp.Import(cls);
                        if (importedType == null)
                        {
                            return;
                        }
                        foreach (var type in comp.MainAssembly.GetAllTypeDefinitions())
                        {
                            if (!type.IsDerivedFrom(importedType))
                            {
                                continue;
                            }
                            TextEditorData textFile;
                            if (!cache.TryGetValue(type.Region.FileName, out textFile))
                            {
                                cache [type.Region.FileName] = textFile = TextFileProvider.Instance.GetTextEditorData(type.Region.FileName);
                            }
                            int position = textFile.LocationToOffset(type.Region.Begin);
                            string keyword;
                            switch (type.Kind)
                            {
                            case TypeKind.Interface:
                                keyword = "interface";
                                break;

                            case TypeKind.Struct:
                                keyword = "struct";
                                break;

                            case TypeKind.Delegate:
                                keyword = "delegate";
                                break;

                            case TypeKind.Enum:
                                keyword = "enum";
                                break;

                            default:
                                keyword = "class";
                                break;
                            }
                            while (position < textFile.Length - keyword.Length)
                            {
                                if (textFile.GetTextAt(position, keyword.Length) == keyword)
                                {
                                    position += keyword.Length;
                                    while (position < textFile.Length && textFile.GetCharAt(position) == ' ' || textFile.GetCharAt(position) == '\t')
                                    {
                                        position++;
                                    }
                                    break;
                                }
                                position++;
                            }
                            monitor.ReportResult(new MonoDevelop.Ide.FindInFiles.SearchResult(new FileProvider(type.Region.FileName, p), position, 0));
                        }
                    });
                    foreach (var tf in cache.Values)
                    {
                        if (tf.Parent == null)
                        {
                            tf.Dispose();
                        }
                    }
                }
            });
        }
Пример #19
0
    static void AddDebuggerTypeProxyAttribute(TypeDefinition type, TypeDefinition proxyType, ReferenceFinder referenceFinder)
    {
        var debuggerTypeProxyAttribute = new CustomAttribute(referenceFinder.DebuggerTypeProxyAttributeCtor);

        debuggerTypeProxyAttribute.ConstructorArguments.Add(new CustomAttributeArgument(referenceFinder.SystemType, proxyType));
        type.CustomAttributes.Add(debuggerTypeProxyAttribute);
    }
Пример #20
0
        private void ProcessItems(IList <Entity> entities)
        {
            if (entities.Count == 0)
            {
                return;
            }

            var entityType = entities[0].TypeInfo;
            var sequence   = entityType.GetRemovalAssociationSequence();

            if (sequence == null || sequence.Count == 0)
            {
                return;
            }

            ExecutePrefetchAction(entities);

            var referenceDescriptors = new List <ReferenceDescriptor>();

            foreach (var association in sequence)
            {
                if (association.OwnerType.UnderlyingType.IsAssignableFrom(entityType.UnderlyingType))
                {
                    foreach (var entity in entities)
                    {
                        var descriptor = new ReferenceDescriptor {
                            RemovingEntity = entity,
                            Processor      = GetProcessor(association.OnOwnerRemove.Value),
                            Association    = association,
                            References     = ReferenceFinder.GetReferencesFrom(entity, association),
                            IsOutgoing     = true
                        };
                        referenceDescriptors.Add(descriptor);
                    }
                }
                if (association.TargetType.UnderlyingType.IsAssignableFrom(entityType.UnderlyingType))
                {
                    foreach (var entity in entities)
                    {
                        var descriptor = new ReferenceDescriptor {
                            RemovingEntity = entity,
                            Processor      = GetProcessor(association.OnTargetRemove.Value),
                            Association    = association,
                            References     = ReferenceFinder.GetReferencesTo(entity, association),
                            IsOutgoing     = false
                        };
                        referenceDescriptors.Add(descriptor);
                    }
                }
            }

            if (Session.Handler.ExecutePrefetchTasks() == null)
            {
                Session.ExecuteUserDefinedDelayedQueries(false);
            }

            foreach (var container in referenceDescriptors)
            {
                var processor      = container.Processor;
                var association    = container.Association;
                var removingEntity = container.RemovingEntity;
                if (container.IsOutgoing)
                {
                    foreach (var reference in container.References.ToList())
                    {
                        processor.Process(Context, association, removingEntity, reference.ReferencedEntity, removingEntity, reference.ReferencedEntity);
                    }
                }
                else
                {
                    foreach (var reference in container.References.ToList())
                    {
                        processor.Process(Context, association, removingEntity, reference.ReferencingEntity, reference.ReferencingEntity, removingEntity);
                    }
                }
            }
        }
Пример #21
0
    public static void AddDebuggerTypeProxyAttributes(ModuleDefinition moduleDefinition, TypeDefinition type, ReferenceFinder referenceFinder)
    {
        if (type.CustomAttributes.Any(c => c.AttributeType.Name == "CompilerGeneratedAttribute" || c.AttributeType.Name == "DebuggerTypeProxyAttribute"))
        {
            return;
        }

        if (type.CustomAttributes.All(c => c.AttributeType.Name != "DebuggerEnumerableTypeAttribute"))
        {
            return;
        }

        var collectionT = type.Interfaces.FirstOrDefault(i => i.InterfaceType.Name == "ICollection`1");

        if (collectionT != null)
        {
            AddICollectionTProxy(moduleDefinition, type, (GenericInstanceType)collectionT.InterfaceType, referenceFinder);
            return;
        }

        var enumerableT = type.Interfaces.FirstOrDefault(i => i.InterfaceType.Name == "IEnumerable`1");

        if (enumerableT != null)
        {
            AddIEnumerableTProxy(moduleDefinition, type, (GenericInstanceType)enumerableT.InterfaceType, referenceFinder);
        }
    }
Пример #22
0
    static void AddSimpleDebuggerDisplayAttribute(ModuleDefinition moduleDefinition, TypeDefinition type, ReferenceFinder referenceFinder)
    {
        var debuggerDisplay = new CustomAttribute(referenceFinder.DebuggerDisplayAttributeCtor);

        debuggerDisplay.ConstructorArguments.Add(new CustomAttributeArgument(moduleDefinition.TypeSystem.String, "{DebuggerDisplay(),nq}"));
        type.CustomAttributes.Add(debuggerDisplay);
    }
Пример #23
0
        public override void Run(RefactoringOptions options)
        {
            if (options.SelectedItem is IVariable)
            {
                var field = options.SelectedItem as IField;
                if (field != null && (field.Accessibility != Accessibility.Private || field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Parts.Count > 1))
                {
                    using (var dlg = new RenameItemDialog(options, this))
                        MessageService.ShowCustomDialog(dlg);
                    return;
                }

                var par = options.SelectedItem as IParameter;
                if (par != null && par.Owner != null && (par.Owner.Accessibility != Accessibility.Private || par.Owner.DeclaringTypeDefinition != null && par.Owner.DeclaringTypeDefinition.Parts.Count > 1))
                {
                    using (var dlg = new RenameItemDialog(options, this))
                        MessageService.ShowCustomDialog(dlg);
                    return;
                }

                var col = ReferenceFinder.FindReferences(options.SelectedItem, true);
                if (col == null)
                {
                    return;
                }
                var data = options.Document != null?options.GetTextEditorData() : IdeApp.Workbench.ActiveDocument.Editor;

                var editor = data.Parent;
                if (editor == null)
                {
                    using (var dlg = new RenameItemDialog(options, this))
                        MessageService.ShowCustomDialog(dlg);
                    return;
                }

                var links      = new List <TextLink> ();
                var link       = new TextLink("name");
                int baseOffset = Int32.MaxValue;
                foreach (var r in col)
                {
                    baseOffset = Math.Min(baseOffset, r.Offset);
                }
                foreach (MemberReference r in col)
                {
                    var segment = new TextSegment(r.Offset - baseOffset, r.Length);
                    if (segment.Offset <= data.Caret.Offset - baseOffset && data.Caret.Offset - baseOffset <= segment.EndOffset)
                    {
                        link.Links.Insert(0, segment);
                    }
                    else
                    {
                        link.AddLink(segment);
                    }
                }

                links.Add(link);
                if (editor.CurrentMode is TextLinkEditMode)
                {
                    ((TextLinkEditMode)editor.CurrentMode).ExitTextLinkMode();
                }
                TextLinkEditMode tle = new TextLinkEditMode(editor, baseOffset, links);
                tle.SetCaretPosition  = false;
                tle.SelectPrimaryLink = true;
                if (tle.ShouldStartTextLinkMode)
                {
                    tle.Cancel += delegate {
                        if (tle.HasChangedText)
                        {
                            editor.Document.Undo();
                        }
                    };
                    tle.OldMode = data.CurrentMode;
                    tle.StartMode();
                    data.CurrentMode = tle;
                }
            }
            else
            {
                using (var dlg = new RenameItemDialog(options, this))
                    MessageService.ShowCustomDialog(dlg);
            }
        }
Пример #24
0
        public override List <Change> PerformChanges(RefactoringOptions options, object prop)
        {
            RenameProperties properties       = (RenameProperties)prop;
            List <Change>    result           = new List <Change> ();
            IEnumerable <MemberReference> col = null;

            using (var monitor = new MessageDialogProgressMonitor(true, false, false, true)) {
                col = ReferenceFinder.FindReferences(options.SelectedItem, properties.IncludeOverloads, monitor);
                if (col == null)
                {
                    return(result);
                }

                if (properties.RenameFile && options.SelectedItem is IType)
                {
                    var cls         = ((IType)options.SelectedItem).GetDefinition();
                    int currentPart = 1;
                    HashSet <string> alreadyRenamed = new HashSet <string> ();
                    foreach (var part in cls.Parts)
                    {
                        if (alreadyRenamed.Contains(part.Region.FileName))
                        {
                            continue;
                        }
                        alreadyRenamed.Add(part.Region.FileName);

                        string oldFileName = System.IO.Path.GetFileNameWithoutExtension(part.Region.FileName);
                        string newFileName;
                        if (oldFileName.ToUpper() == properties.NewName.ToUpper() || oldFileName.ToUpper().EndsWith("." + properties.NewName.ToUpper()))
                        {
                            continue;
                        }
                        int idx = oldFileName.IndexOf(cls.Name);
                        if (idx >= 0)
                        {
                            newFileName = oldFileName.Substring(0, idx) + properties.NewName + oldFileName.Substring(idx + cls.Name.Length);
                        }
                        else
                        {
                            newFileName = currentPart != 1 ? properties.NewName + currentPart : properties.NewName;
                            currentPart++;
                        }

                        int t = 0;
                        while (System.IO.File.Exists(GetFullFileName(newFileName, part.Region.FileName, t)))
                        {
                            t++;
                        }
                        result.Add(new RenameFileChange(part.Region.FileName, GetFullFileName(newFileName, part.Region.FileName, t)));
                    }
                }

                foreach (var memberRef in col)
                {
                    TextReplaceChange change = new TextReplaceChange();
                    change.FileName     = memberRef.FileName;
                    change.Offset       = memberRef.Offset;
                    change.RemovedChars = memberRef.Length;
                    change.InsertedText = properties.NewName;
                    change.Description  = string.Format(GettextCatalog.GetString("Replace '{0}' with '{1}'"), memberRef.GetName(), properties.NewName);
                    result.Add(change);
                }
            }
            return(result);
        }
Пример #25
0
    private void DecorateByType(MethodDecorator.Fody.MethodDecorator decorator)
    {
        var referenceFinder       = new ReferenceFinder(this.ModuleDefinition);
        var markerTypeDefinitions = this.FindMarkerTypes();

        // Look for rules in the assembly and module.
        var assemblyRules = FindAspectRules(this.ModuleDefinition.Assembly.CustomAttributes);
        var moduleRules   = FindAspectRules(this.ModuleDefinition.CustomAttributes);

        // Read the top-level and nested types from this module
        foreach (var type in this.ModuleDefinition.Types.SelectMany(x => GetAllTypes(x)))
        {
            // Look for rules on the type and marker attributes
            var classRules = FindByMarkerType(markerTypeDefinitions, type.CustomAttributes)
                             .Concat(FindAspectRules(type.CustomAttributes, true));

            // Loop through all methods in this type
            foreach (var method in type.Methods.Where(x => x.HasBody))
            {
                // Find any rules applied to the method.
                var methodRules = FindByMarkerType(markerTypeDefinitions, method.CustomAttributes)
                                  .Concat(FindAspectRules(method.CustomAttributes, true));

                // Join together all the rules and give them an ordering number starting at 0 for
                // the highest level (assembly) to N as a lowest level (last attribute on the method)
                var allRules = assemblyRules
                               .Concat(moduleRules)
                               .Concat(classRules)
                               .Concat(methodRules)
                               .Select((Rule, ScopeOrdering) => new { Rule, ScopeOrdering });

                var orderedList = allRules
                                  .Where(x => x.Rule.Match(type, method))
                                  .OrderByDescending(x => x.Rule.AspectPriority)
                                  .ThenByDescending(x => x.ScopeOrdering)
                                  .GroupBy(x => x.Rule.MethodDecoratorAttribute.AttributeType);

                // Group the rules by the aspect type
                foreach (var aspectSet in orderedList)
                {
                    // Sort the rules in priority order (so that attributes applied to the
                    // method take precedence over the type, module then assembly)
                    // Then pick out the first rule - this tells us whether to include
                    // or exclude.

                    var rule = aspectSet
                               .OrderBy(x => x.Rule.AttributePriority)
                               .ThenByDescending(x => x.ScopeOrdering)
                               .Select(x => x.Rule)
                               .FirstOrDefault();

                    // If we have a rule and it isn't an exclusion, apply the method decoration.
                    if (rule != null && !rule.AttributeExclude)
                    {
                        decorator.Decorate(
                            type,
                            method,
                            rule.MethodDecoratorAttribute,
                            rule.ExplicitMatch);
                    }
                }
            }
        }
    }
Пример #26
0
    private IEnumerable<string> GetCopyLocal()
    {
        var referenceFinder = new ReferenceFinder(assemblyPath, projectPath);

        var assemblyNameReferences = ModuleDefinition.ReadModule(assemblyPath).AssemblyReferences;
        foreach (var assemblyNameReference in assemblyNameReferences)
        {
            if (!assemblyNameReference.FullName.Contains("PreEmbed"))
            {
                yield return referenceFinder.Resolve(assemblyNameReference);
            }
        }
    }
Пример #27
0
        public static MethodReference GetGetMethod(this PropertyDefinition property, TypeReference targetType)
        {
            MethodReference method = property.GetMethod;

            if (method.DeclaringType.HasGenericParameters)
            {
                var genericInstanceType = property.DeclaringType.GetGenericInstanceType(targetType);
                method = new MethodReference(method.Name, method.ReturnType.IsGenericParameter ? method.ReturnType : ReferenceFinder.ImportCustom(method.ReturnType))
                {
                    DeclaringType = ReferenceFinder.ImportCustom(genericInstanceType),
                    HasThis       = true
                };
            }
            return(method);
        }
Пример #28
0
    static void AddICollectionTProxy(ModuleDefinition moduleDefinition, TypeDefinition type, GenericInstanceType collectionT, ReferenceFinder referenceFinder)
    {
        var itemType  = collectionT.GenericArguments[0];
        var itemArray = itemType.MakeArrayType();

        var           proxyType    = CreateProxy(moduleDefinition, type, referenceFinder);
        TypeReference proxyTypeRef = proxyType;

        if (type.HasGenericParameters)
        {
            proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(CloneGenericParameter).ToArray());
        }

        var field    = proxyType.Fields[0];
        var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef);

        var             countProperty = type.Properties.First(p => p.Name == "Count" || p.Name == "System.Collections.ICollection.Count");
        MethodReference countMethod   = countProperty.GetMethod;
        MethodReference copyToMethod  = type.Methods.First(p => p.Name == "CopyTo" || p.Name == "System.Collections.ICollection.CopyTo");

        if (type.HasGenericParameters)
        {
            countMethod  = countMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(CloneGenericParameter).ToArray());
            copyToMethod = copyToMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(CloneGenericParameter).ToArray());
        }

        var getMethod     = new MethodDefinition("get_Items", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, itemArray);
        var getMethodBody = getMethod.Body;

        var localItems = new VariableDefinition(itemArray);

        getMethodBody.Variables.Add(localItems);

        getMethodBody.SimplifyMacros();
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, countMethod));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Newarr, itemType));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Stloc, localItems));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldlen));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Conv_I4));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, copyToMethod));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
        getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ret));
        getMethodBody.InitLocals = true;
        getMethodBody.OptimizeMacros();

        proxyType.Methods.Add(getMethod);

        var property = new PropertyDefinition("Items", PropertyAttributes.None, itemArray)
        {
            GetMethod = getMethod
        };
        var debuggerBrowsableAttribute = new CustomAttribute(referenceFinder.DebuggerBrowsableAttributeCtor);

        debuggerBrowsableAttribute.ConstructorArguments.Add(new CustomAttributeArgument(referenceFinder.DebuggerBrowsableStateType, (int)DebuggerBrowsableState.RootHidden));
        property.CustomAttributes.Add(debuggerBrowsableAttribute);
        proxyType.Properties.Add(property);

        AddDebuggerTypeProxyAttribute(type, proxyType, referenceFinder);
    }
        public void InitializeOneToManyReferenceFieldTest()
        {
            using (var session = Domain.OpenSession(sessionConfiguration)) {
                var tableOfContent      = new TableOfContent();
                var tableOfContentItem1 = new TableOfContentItem();
                var tableOfContentItem2 = new TableOfContentItem();
                var tableOfContentItem3 = new TableOfContentItem();
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContent.Items.Add(tableOfContentItem1);
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContent.Items.Add(tableOfContentItem2);
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContent.Items.Add(tableOfContentItem3);
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(1));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContent      = new TableOfContent();
                tableOfContentItem1 = new TableOfContentItem();
                tableOfContentItem2 = new TableOfContentItem();
                tableOfContentItem3 = new TableOfContentItem();
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContentItem1.TableOfContent = tableOfContent;
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(0));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContentItem2.TableOfContent = tableOfContent;
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(2));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));

                tableOfContentItem3.TableOfContent = tableOfContent;
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContent).Count(), Is.EqualTo(3));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem1).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem2).Count(), Is.EqualTo(1));
                Assert.That(ReferenceFinder.GetReferencesTo(tableOfContentItem3).Count(), Is.EqualTo(1));
                Assert.That(session.NonPairedReferencesRegistry.AddedReferencesCount, Is.EqualTo(0));
                Assert.That(session.NonPairedReferencesRegistry.RemovedReferencesCount, Is.EqualTo(0));
            }
        }