using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Operations;
using UnitTestSharp;

namespace Vellum.Generator.UnitTests
{
    public class SaveMethodsTests : TestFixture
    {
        public const string Header = "// <auto-generated/>\r\n" +
            "// The generic methods Vellum.Generator found saving their type parameters, so their callers are " +
            "checked.\r\n";

        /// <summary>
        /// Returns the attributes <paramref name="run"/> generated, one per line.
        /// </summary>
        public static string[] Lines(VellumRun run)
        {
            return run.SaveMethodsFile.Split(new[] { "\r\n" }, System.StringSplitOptions.RemoveEmptyEntries)
                .Where(line => !line.StartsWith("//", System.StringComparison.Ordinal))
                .ToArray();
        }

        public static string Attribute(string methodId, int typeParameter)
        {
            return "[assembly: global::Vellum.RegisterSaveMethod(\"" + methodId +
                "\", typeof(global::Vellum.SaveMethodParameter" + typeParameter + "))]";
        }

        public const string Marker0 = SaveTemplateTests.Marker0;

        public const string Marker1 = "global::Vellum.SaveMethodParameter1";

        public const string ToNodeId = "M:Vellum.SaveSession.ToNode``1(``0)";

        /// <summary>
        /// Returns what each call in <paramref name="source"/> hands on, as "callers => callees : arguments".
        /// </summary>
        public static List<string> Edges(string source)
        {
            CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
            SyntaxTree tree = compilation.SyntaxTrees[0];
            SemanticModel model = compilation.GetSemanticModel(tree);
            var returnMe = new List<string>();
            foreach (InvocationExpressionSyntax call in tree.GetRoot().DescendantNodes()
                .OfType<InvocationExpressionSyntax>())
            {
                foreach (SaveEdge edge in SaveMethods.EdgesOf(model, call, CancellationToken.None))
                {
                    string arguments = string.Join(", ", edge.Arguments.Items.Select(
                        argument => argument == null ? "null"
                            : argument.HasUnspellable ? "unspellable" : argument.ToSource()));
                    returnMe.Add(string.Join("|", edge.CallerIds.Items) + " => " +
                        string.Join("|", edge.CalleeIds.Items) + " : " + arguments);
                }
            }

            return returnMe;
        }

        public class MightHoldEdgesTests : TestFixture
        {
            /// <summary>
            /// Returns whether each method declared in <paramref name="source"/> might hold edges.
            /// </summary>
            public static List<bool> Might(string source)
            {
                SyntaxTree tree = CSharpSyntaxTree.ParseText(source);
                return tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>()
                    .Select(method => SaveMethods.MightHoldEdges(method, CancellationToken.None))
                    .ToList();
            }

            public void GenericMethod_Might()
            {
                CheckEqual(new[] { true }, Might("class C { void M<T>(T value) { Save(value); } }"));
            }

            public void PlainMethod_Mightnt()
            {
                CheckEqual(new[] { false }, Might("class C { void M(int value) { Save(value); } }"));
            }

            public void MethodOfAGenericClass_Might()
            {
                CheckEqual(new[] { true }, Might("class C<T> { void M(T value) { Save(value); } }"));
            }

            public void MethodOfAGenericStructRecordOrInterface_Might()
            {
                CheckEqual(new[] { true }, Might("struct S<T> { void M(T value) { Save(value); } }"));
                CheckEqual(new[] { true }, Might("record R<T> { void M(T value) { Save(value); } }"));
                CheckEqual(new[] { true }, Might("interface I<T> { void M(T value) { Save(value); } }"));
            }

            public void MethodOfATypeNestedInAGenericOne_Might()
            {
                CheckEqual(new[] { true },
                    Might("class Outer<T> { class Inner { void M(int value) { Save(value); } } }"));
            }

            public void MethodOfAGenericTypeNestedInAPlainOne_Might()
            {
                CheckEqual(new[] { true },
                    Might("class Outer { class Inner<T> { void M(T value) { Save(value); } } }"));
            }

            public void MethodInANamespaceOfPlainTypes_Mightnt()
            {
                CheckEqual(new[] { false },
                    Might("namespace N { class Outer { class Inner { void M() { Save(1); } } } }"));
            }

            public void MethodNamingNothing_Mightnt()
            {
                CheckEqual(new[] { false }, Might("class C<T> { void M<U>(T first, U second) { } }"));
                CheckEqual(new[] { false }, Might("class C<T> { int M(T first) => 1; }"));
                CheckEqual(new[] { false }, Might("abstract class C<T> { public abstract void M(T first); }"));
            }

            public void MethodNamingAProperty_Might()
            {
                CheckEqual(new[] { true }, Might("class C<T> { int M(C<T> other) { return other.Count; } }"));
                CheckEqual(new[] { true }, Might("class C<T> { int M(C<T> other) => other[0]; }"));
                CheckEqual(new[] { true }, Might("class C<T> { int M(C<T> other) => other?[0] ?? 0; }"));
                CheckEqual(new[] { true }, Might("class C<T> { int M() => this[0]; }"));
            }

            public void CallInALambdaOrLocalFunction_Counts()
            {
                CheckEqual(new[] { true },
                    Might("class C<T> { void M(T value) { System.Action act = () => Save(value); } }"));
                CheckEqual(new[] { true }, Might("class C<T> { void M(T value) { void L() { Save(value); } } }"));
            }

            public void ExpressionBodiedCall_Counts()
            {
                CheckEqual(new[] { true }, Might("class C<T> { int M(T value) => Save(value); }"));
            }

            public void LocalFunction_Mightnt()
            {
                CSharpSyntaxNode local = CSharpSyntaxTree.ParseText("class C<T> { void M() { void L<U>() { } } }")
                    .GetRoot().DescendantNodes().OfType<LocalFunctionStatementSyntax>().Single();

                CheckFalse(SaveMethods.MightHoldEdges(local, CancellationToken.None));
            }

            public void NodeThatIsNotAMethod_Mightnt()
            {
                CSharpSyntaxNode node = CSharpSyntaxTree.ParseText("class C<T> { int field; C() { } }").GetRoot()
                    .DescendantNodes().OfType<ConstructorDeclarationSyntax>().Single();

                CheckFalse(SaveMethods.MightHoldEdges(node, CancellationToken.None));
                CheckFalse(SaveMethods.MightHoldEdges(node.Parent, CancellationToken.None));
            }

            /// <summary>
            /// Returns whether each accessor, and each expression-bodied property or indexer, in
            /// <paramref name="source"/> might hold edges.
            /// </summary>
            public static List<bool> MightAccessors(string source)
            {
                return CSharpSyntaxTree.ParseText(source).GetRoot().DescendantNodes()
                    .Where(node => node is AccessorDeclarationSyntax || node is ArrowExpressionClauseSyntax)
                    .Select(node => SaveMethods.MightHoldEdges(node, CancellationToken.None))
                    .ToList();
            }

            public void AccessorOfAGenericClass_Might()
            {
                CheckEqual(new[] { true, true }, MightAccessors(
                    "class C<T> { T P { get { return Save(1); } set { Save(value); } } }"));
                CheckEqual(new[] { true, true }, MightAccessors(
                    "class C<T> { T this[int i] { get { return Save(i); } set { Save(value); } } }"));
                CheckEqual(new[] { true, true }, MightAccessors(
                    "class C<T> { event System.Action E { add { Save(1); } remove { Save(1); } } }"));
            }

            public void ExpressionBodiedPropertyOrIndexerOfAGenericClass_Might()
            {
                CheckEqual(new[] { true }, MightAccessors("class C<T> { int P => Save(1); }"));
                CheckEqual(new[] { true }, MightAccessors("class C<T> { int this[int i] => Save(i); }"));
            }

            public void AccessorOfAPlainClass_Mightnt()
            {
                CheckEqual(new[] { false, false }, MightAccessors(
                    "class C { int P { get { return Save(1); } set { Save(value); } } }"));
                CheckEqual(new[] { false }, MightAccessors("class C { int P => Save(1); }"));
            }

            public void AccessorWithNoBody_Mightnt()
            {
                CheckEqual(new[] { false, false }, MightAccessors("class C<T> { T P { get; set; } }"));
                CheckEqual(new[] { false }, MightAccessors("interface I<T> { T P { get; } }"));
            }

            public void AccessorNamingNothing_Mightnt()
            {
                CheckEqual(new[] { false }, MightAccessors("class C<T> { int P { get { return 1; } } }"));
                CheckEqual(new[] { false }, MightAccessors("class C<T> { int P => 1; }"));
            }

            public void ExpressionBodyOfAnAccessor_BelongsToTheAccessor()
            {
                CheckEqual(new[] { true, false }, MightAccessors("class C<T> { int P { get => Save(1); } }"));
            }

            public void ExpressionBodyOfAMethod_IsNotAnAccessor()
            {
                CheckEqual(new[] { false }, MightAccessors("class C<T> { int M() => Save(1); }"));
            }
        }

        public class EdgesOfTests : TestFixture
        {
            public const string SaverPrefix = "public class Store { public SaveSession Session; ";

            public void TypedToNodeOfTheParameter_HandsItOn()
            {
                CheckEqual(new[] { "M:Store.Put``1(``0) => " + ToNodeId + " : " + Marker0 },
                    Edges(SaverPrefix + "public void Put<T>(T value) { Session.ToNode(value); } }"));
            }

            public void TypeArgumentSpelled_HandsItOn()
            {
                CheckEqual(new[] { "M:Store.Put``1(``0) => " + ToNodeId + " : " + Marker0 },
                    Edges(SaverPrefix + "public void Put<T>(T value) { Session.ToNode<T>(value); } }"));
            }

            public void TypeofOfTheParameter_HandsItOn()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0) => M:Vellum.SaveSession.ToNode(System.Object,System.Type) : " + Marker0,
                }, Edges(SaverPrefix + "public void Put<T>(T value) { Session.ToNode(value, typeof(T)); } }"));
            }

            public void StaticCallee_HasNoReceiver()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0) => M:Vellum.SavedValue.ToNode(System.Object,System.Type) : " + Marker0,
                }, Edges("public class Store { public void Put<T>(T value) { " +
                    "SavedValue.ToNode(value, typeof(T)); } }"));
            }

            public void SecondTypeParameter_IsItsOwnStandIn()
            {
                CheckEqual(new[] { "M:Store.Pair``2(``0,``1) => " + ToNodeId + " : " + Marker1 },
                    Edges(SaverPrefix + "public void Pair<TKey, T>(TKey key, T value) { Session.ToNode(value); } }"));
            }

            public void ParameterInsideAGenericType_IsKeptInside()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(System.Collections.Generic.List{``0}) => " + ToNodeId +
                        " : global::System.Collections.Generic.List<" + Marker0 + ">",
                }, Edges(SaverPrefix + "public void Put<T>(List<T> value) { Session.ToNode(value); } }"));
            }

            public void ParameterInsideArrays_IsKeptInside()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0[0:,0:][]) => " + ToNodeId + " : " + Marker0 + "[][,]",
                }, Edges(SaverPrefix + "public void Put<T>(T[][,] value) { Session.ToNode(value); } }"));
            }

            public void ParameterNextToAClosedType_KeepsTheClosedType()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(System.Collections.Generic.Dictionary{``0,System.String}) => " + ToNodeId +
                        " : global::System.Collections.Generic.Dictionary<" + Marker0 + ", global::System.String>",
                }, Edges(SaverPrefix + "public void Put<T>(Dictionary<T, string> value) { Session.ToNode(value); } }"));
            }

            public void ParameterInsideATypeNestedInAGenericOne_IsKeptInside()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(Outer{System.Int32}.Inner{``0}) => " + ToNodeId +
                        " : global::Outer<global::System.Int32>.Inner<" + Marker0 + ">",
                }, Edges("public class Outer<X> { public class Inner<Y> { } }\n" + SaverPrefix +
                    "public void Put<T>(Outer<int>.Inner<T> value) { Session.ToNode(value); } }"));
            }

            public void CalleeGivenTwoTypeArguments_HandsOnEach()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0) => M:Saver.Pair``2(``0,``1) : global::System.Int32, " + Marker0,
                }, Edges("public class Saver { public void Pair<A, B>(A a, B b) { } }\n" +
                    "public class Store { public Saver Saver; " +
                    "public void Put<T>(T value) { Saver.Pair(5, value); } }"));
            }

            public void ClosedTypesOnly_HandOnNothing()
            {
                CheckEqual(0, Edges(SaverPrefix + "public void Put<T>(T value) { Session.ToNode(5); " +
                    "Session.ToNode<string>(\"text\"); } }").Count);
            }

            public void CallOutsideAGenericMethod_HandsOnNothing()
            {
                CheckEqual(0, Edges(SaverPrefix + "public void Put(int value) { Session.ToNode(value); } }").Count);
            }

            public const string ClassMarker0 = "global::Vellum.SaveClassParameter<global::Vellum.SaveMethodParameter0>";

            public const string ClassMarker1 = "global::Vellum.SaveClassParameter<global::Vellum.SaveMethodParameter1>";

            public void ParameterOfTheClass_IsHandedOn()
            {
                CheckEqual(new[] { "M:Store`1.Put``1(`0) => " + ToNodeId + " : " + ClassMarker0 },
                    Edges("public class Store<TValue> { public SaveSession Session; " +
                        "public void Put<T>(TValue value) { Session.ToNode(value); } }"));
            }

            public void ParameterOfAnOuterClass_IsNumberedBeforeThoseOfTheInnerOne()
            {
                CheckEqual(new[]
                {
                    "M:Outer`1.Inner`1.Keep(`0) => " + ToNodeId + " : " + ClassMarker0,
                    "M:Outer`1.Inner`1.Put(`1) => " + ToNodeId + " : " + ClassMarker1,
                }, Edges("public class Outer<A> { public class Inner<B> { public SaveSession Session; " +
                    "public void Keep(A value) { Session.ToNode(value); } " +
                    "public void Put(B value) { Session.ToNode(value); } } }"));
            }

            public void ParameterOfAnInnerClassOfAPlainOne_IsNumberedFromZero()
            {
                CheckEqual(new[] { "M:Outer.Inner`1.Put(`0) => " + ToNodeId + " : " + ClassMarker0 },
                    Edges("public class Outer { public class Inner<B> { public SaveSession Session; " +
                        "public void Put(B value) { Session.ToNode(value); } } }"));
            }

            public void ClassAndMethodParametersTogether_AreEachSpelledByTheirOwnStandIn()
            {
                CheckEqual(new[]
                {
                    "M:Store`1.Put``1(`0,``0) => " + ToNodeId + " : global::System.Collections.Generic.Dictionary<" +
                        ClassMarker0 + ", " + Marker0 + ">",
                }, Edges("public class Store<TValue> { public SaveSession Session; " +
                    "public void Put<T>(TValue key, T value) { " +
                    "Session.ToNode(new Dictionary<TValue, T>()); } }"));
            }

            public void ParameterOfTheClassInsideAType_IsKeptInside()
            {
                CheckEqual(new[]
                {
                    "M:Store`1.Put(System.Collections.Generic.List{`0}) => " + ToNodeId +
                        " : global::System.Collections.Generic.List<" + ClassMarker0 + ">",
                }, Edges("public class Store<TValue> { public SaveSession Session; " +
                    "public void Put(List<TValue> value) { Session.ToNode(value); } }"));
            }

            public void ParameterOfTheClassNextToAnUnspellableType_IsUnspellable()
            {
                CheckEqual(new[] { "M:Store`1.Put(`0) => " + ToNodeId + " : unspellable" },
                    Edges("public class Store<TValue> { private class Hidden { } public SaveSession Session; " +
                        "public void Put(TValue value) { Session.ToNode(new Dictionary<TValue, Hidden>()); } }"));
            }

            public void ParameterOfTheClassInAMethodOfAPrivateClass_HandsOnNothing()
            {
                CheckEqual(0, Edges("public class Outer { private class Store<T> { public SaveSession Session; " +
                    "public void Put(T value) { Session.ToNode(value); } } }").Count);
            }

            public void ClassParameterOfAnImplementedInterface_IsRegisteredForTheClassOnly()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs",
                    "public interface IStore<X> { void Put(X value); }\n" +
                    "public class Store<T> : IStore<T> { public SaveSession Session; " +
                    "public void Put(T value) { Session.ToNode(value); } }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                InvocationExpressionSyntax call = tree.GetRoot().DescendantNodes()
                    .OfType<InvocationExpressionSyntax>().Single();

                SaveEdge edge = SaveMethods.EdgesOf(compilation.GetSemanticModel(tree), call,
                    CancellationToken.None).Single();

                CheckEqual(new[] { "M:Store`1.Put(`0)", "M:IStore`1.Put(`0)" }, edge.CallerIds.Items);
                CheckEqual(1, edge.OwnCallerCount);
            }

            public void CallerThatIsOnlyAnInterfaceImplementation_HasNoOwnCaller()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs",
                    "public interface IStore { void Put<T>(T value); }\n" +
                    "public class Store : IStore { public SaveSession Session; " +
                    "void IStore.Put<T>(T value) { Session.ToNode(value); } }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                InvocationExpressionSyntax call = tree.GetRoot().DescendantNodes()
                    .OfType<InvocationExpressionSyntax>().Single();

                SaveEdge edge = SaveMethods.EdgesOf(compilation.GetSemanticModel(tree), call,
                    CancellationToken.None).Single();

                CheckEqual(new[] { "M:IStore.Put``1(``0)" }, edge.CallerIds.Items);
                CheckEqual(0, edge.OwnCallerCount);
            }

            public void TypeAnAttributeCantSpell_IsLeftOutOfTheArguments()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0) => M:Saver.Pair``2(``0,``1) : null, " + Marker0,
                }, Edges("public class Saver { public void Pair<A, B>(A a, B b) { } }\n" +
                    "public class Store\n{\n    private class Hidden { }\n    public Saver Saver;\n" +
                    "    public void Put<T>(T value) { Saver.Pair(new Hidden(), value); }\n}"));
            }

            public void ArgumentThatIsntALiteralTypeof_IsLeftOutOfTheArguments()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(System.Type) => M:Saver.Both(System.Type,System.Type) : null, " + Marker0,
                }, Edges("public class Saver { public void Both(System.Type first, System.Type second) { } }\n" +
                    "public class Store { public Saver Saver; " +
                    "public void Put<T>(System.Type other) { Saver.Both(other, typeof(T)); } }"));
            }

            public void NonTypeArguments_AreNotHandedOn()
            {
                CheckEqual(0, Edges("public class Saver { public void Note(string text) { } }\n" +
                    "public class Store { public Saver Saver; public void Put<T>(T value) { Saver.Note(\"x\"); } }")
                    .Count);
            }

            public void ParameterOfALocalFunction_IsNotTheMethodsToHandOn()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0) => M:Saver.Pair``2(``0,``1) : " + Marker0 + ", null",
                }, Edges("public class Saver { public void Pair<A, B>(A a, B b) { } }\n" +
                    "public class Store { public Saver Saver; " +
                    "public void Put<T>(T value) { void Inner<U>(U other) { Saver.Pair(value, other); } } }"));
            }

            public void CallerInsideALocalFunction_IsTheOuterMethod()
            {
                CheckEqual(new[] { "M:Store.Put``1(``0) => " + ToNodeId + " : " + Marker0 },
                    Edges(SaverPrefix + "public void Put<T>(T value) { void Inner() { Session.ToNode(value); } } }"));
            }

            public void CallerThatIsALocalFunction_HandsOnNothing()
            {
                CheckEqual(0, Edges(SaverPrefix + "public void Put() { void Inner<T>(T value) " +
                    "{ Session.ToNode(value); } } }").Count);
            }

            public void CallerInALambda_IsTheEnclosingMethod()
            {
                CheckEqual(new[] { "M:Store.Put``1(``0) => " + ToNodeId + " : " + Marker0 },
                    Edges(SaverPrefix + "public void Put<T>(T value) " +
                        "{ System.Action act = () => Session.ToNode(value); } }"));
            }

            public void CallerThatImplementsAnInterface_IsRegisteredUnderBoth()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0)|M:IStore.Put``1(``0) => " + ToNodeId + " : " + Marker0,
                }, Edges("public interface IStore { void Put<T>(T value); }\n" +
                    SaverPrefix.Replace("Store", "Store : IStore") +
                    "public void Put<T>(T value) { Session.ToNode(value); } }"));
            }

            public void CallerThatExplicitlyImplementsAnInterface_IsRegisteredUnderTheInterfaceOnly()
            {
                CheckEqual(new[] { "M:IStore.Put``1(``0) => " + ToNodeId + " : " + Marker0 },
                    Edges("public interface IStore { void Put<T>(T value); }\n" +
                        SaverPrefix.Replace("Store", "Store : IStore") +
                        "void IStore.Put<T>(T value) { Session.ToNode(value); } }"));
            }

            public void CallerInAPrivateType_HandsOnNothing()
            {
                CheckEqual(0, Edges("public class Outer { private class Store { public SaveSession Session; " +
                    "public void Put<T>(T value) { Session.ToNode(value); } } }").Count);
            }

            public void CalleeCalledThroughAnInterface_IsNamedByItsInterfaceToo()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(Bag,``0) => M:Bag.Add``1(``0)|M:IBag.Add``1(``0) : " + Marker0,
                }, Edges("public interface IBag { void Add<T>(T value); }\n" +
                        "public class Bag : IBag { public void Add<T>(T value) { } }\n" +
                        "public class Store { public void Put<T>(Bag bag, T value) { bag.Add(value); } }"));
            }

            public void NestingPastTheLimit_IsUnspellable()
            {
                string type = string.Concat(Enumerable.Repeat("List<", SaveTemplate.MaxDepth + 1)) + "T" +
                    new string('>', SaveTemplate.MaxDepth + 1);

                CheckEqual(new[] { "M:Store.Put``1(" + string.Concat(Enumerable.Repeat(
                        "System.Collections.Generic.List{", SaveTemplate.MaxDepth + 1)) + "``0" +
                        new string('}', SaveTemplate.MaxDepth + 1) + ") => " + ToNodeId + " : unspellable" },
                    Edges(SaverPrefix + "public void Put<T>(" + type + " value) { Session.ToNode(value); } }"));
            }

            public void TypeAnAttributeCantSpellAroundAParameter_IsUnspellable()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(System.Collections.Generic.List{``0}) => " + ToNodeId + " : unspellable",
                }, Edges("public class Store { private class Hidden { } public SaveSession Session; " +
                    "public void Put<T>(List<T> value) { Session.ToNode(new Dictionary<T, Hidden>()); } }"));
            }

            public void CallThatIsntAnInvocation_HandsOnNothing()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", "public class Plain { int x; }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];

                CheckEqual(0, SaveMethods.EdgesOf(compilation.GetSemanticModel(tree), tree.GetRoot(),
                    CancellationToken.None).Length);
            }
        }

        public class SolveTests : TestFixture
        {
            public const string TooDeep = "nests more than 32 types deep";

            public static SaveTemplate Parameter(int number)
            {
                return SaveTemplate.OfParameter(number);
            }

            public static SaveTemplate Closed(string name)
            {
                return SaveTemplateTests.Concrete("global::" + name);
            }

            public static SaveRegistration Seed(string id, SaveTemplate template)
            {
                return new SaveRegistration(id, template);
            }

            public static SaveEdge Edge(string caller, string callee, params SaveTemplate[] arguments)
            {
                return new SaveEdge(SaveEdgeTests.Ids(caller), SaveEdgeTests.Ids(callee),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(arguments)));
            }

            public static List<string> Solved(SaveRegistration[] seeds, SaveEdge[] edges,
                List<KeyValuePair<string, string>> dropped = null)
            {
                return SaveMethods.Solve(seeds, edges, dropped ?? new List<KeyValuePair<string, string>>())
                    .Select(registration => registration.Id + "=" + registration.Template.ToSource()).ToList();
            }

            public void NoEdges_AddNothing()
            {
                CheckEqual(0, Solved(new[] { Seed("A", Parameter(0)) }, new SaveEdge[0]).Count);
            }

            public void CalleeNothingRegistered_AddsNothing()
            {
                CheckEqual(0, Solved(new[] { Seed("A", Parameter(0)) }, new[] { Edge("C", "B", Parameter(0)) }).Count);
            }

            public void RegisteredCallee_RegistersTheCaller()
            {
                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("A", Parameter(0)) }, new[] { Edge("C", "A", Parameter(0)) }));
            }

            public void TemplateOfTheCallee_IsFilledFromWhatTheCallerHandsOn()
            {
                SaveTemplate handed = SaveTemplateTests.Concrete("global::Pair<{0}, {1}>", Parameter(0), Closed("S"));

                CheckEqual(new[]
                {
                    "C=global::System.Collections.Generic.List<global::Pair<" + SaveTemplateTests.Marker0 +
                        ", global::S>>",
                }, Solved(new[] { Seed("A", SaveTemplateTests.ListOf(Parameter(0))) },
                    new[] { Edge("C", "A", handed) }));
            }

            public void SecondTypeParameter_TakesTheSecondArgument()
            {
                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("A", Parameter(1)) }, new[] { Edge("C", "A", Closed("S"), Parameter(0)) }));
            }

            public void ArgumentThatCantBeSpelled_AddsNothing()
            {
                CheckEqual(0, Solved(new[] { Seed("A", Parameter(0)) }, new[] { Edge("C", "A", (SaveTemplate)null) })
                    .Count);
            }

            public void ClosedArgument_AddsNothing()
            {
                CheckEqual(0, Solved(new[] { Seed("A", Parameter(0)) }, new[] { Edge("C", "A", Closed("S")) }).Count);
            }

            public void TemplateNamingAParameterTheEdgeLacks_AddsNothing()
            {
                CheckEqual(0, Solved(new[] { Seed("A", Parameter(3)) }, new[] { Edge("C", "A", Parameter(0)) }).Count);
            }

            public void EveryCallerId_IsRegistered()
            {
                var edge = new SaveEdge(SaveEdgeTests.Ids("C", "IC"), SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(Parameter(0))));

                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0, "IC=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }));
            }

            public void EveryCalleeId_IsLookedUp()
            {
                var edge = new SaveEdge(SaveEdgeTests.Ids("C"), SaveEdgeTests.Ids("Other", "A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(Parameter(0))));

                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }));
            }

            public void ChainOfCallers_IsFollowedInAnyOrder()
            {
                CheckEqual(new[]
                {
                    "B=" + SaveTemplateTests.Marker0, "C=" + SaveTemplateTests.Marker0,
                    "D=" + SaveTemplateTests.Marker0,
                }, Solved(new[] { Seed("A", Parameter(0)) },
                    new[] { Edge("D", "C", Parameter(0)), Edge("C", "B", Parameter(0)), Edge("B", "A", Parameter(0)) })
                    .OrderBy(line => line, System.StringComparer.Ordinal).ToList());
            }

            public void MethodsThatCallEachOther_EachGetRegisteredOnce()
            {
                CheckEqual(new[] { "A=" + SaveTemplateTests.Marker0, "B=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("Saver", Parameter(0)) },
                        new[]
                        {
                            Edge("A", "Saver", Parameter(0)), Edge("A", "B", Parameter(0)),
                            Edge("B", "A", Parameter(0)),
                        }).OrderBy(line => line, System.StringComparer.Ordinal).ToList());
            }

            public void TemplateAlreadyKnown_IsNotRegisteredAgain()
            {
                CheckEqual(0, Solved(new[] { Seed("A", Parameter(0)), Seed("C", Parameter(0)) },
                    new[] { Edge("C", "A", Parameter(0)) }).Count);
            }

            public void MethodHandingAGrowingTypeToItself_StopsWhereTheTypeGetsTooDeep()
            {
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("G", Parameter(0)) },
                    new[] { Edge("G", "G", SaveTemplateTests.ListOf(Parameter(0))) }, dropped);

                CheckEqual(SaveTemplate.MaxDepth - 1, solved.Count);
                CheckEqual(new[] { new KeyValuePair<string, string>("G", TooDeep) }, dropped);
            }

            public void UnspellableArgumentTheCalleeSaves_IsDroppedAndNotRegistered()
            {
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("A", Parameter(0)) },
                    new[] { Edge("C", "A", SaveTemplate.Unspellable) }, dropped);

                CheckEqual(0, solved.Count);
                CheckEqual(new[] { new KeyValuePair<string, string>("C", SaveMethods.UnspellableReason) }, dropped);
            }

            public void UnspellableArgumentInsideTheTemplate_IsDropped()
            {
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("A", SaveTemplateTests.ListOf(Parameter(0))) },
                    new[] { Edge("C", "A", SaveTemplate.Unspellable) }, dropped);

                CheckEqual(0, solved.Count);
                CheckEqual(1, dropped.Count);
            }

            public void UnspellableArgumentTheCalleeDoesntSave_LeavesTheRestRegistered()
            {
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("A", Parameter(1)) },
                    new[] { Edge("C", "A", SaveTemplate.Unspellable, Parameter(0)) }, dropped);

                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0 }, solved);
                CheckEqual(0, dropped.Count);
            }

            public static SaveEdge WithClassArguments(string[] callers, int own,
                EquatableArray<EquatableArray<int>> maps, string[] callees,
                EquatableArray<EquatableArray<SaveTemplate>> classArguments, params SaveTemplate[] arguments)
            {
                return new SaveEdge(SaveEdgeTests.Ids(callers), own, maps, SaveEdgeTests.Ids(callees), classArguments,
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(arguments)));
            }

            public void CalleeClassArgument_FillsTheCalleesClassParameter()
            {
                SaveEdge edge = WithClassArguments(new[] { "C" }, 1, default, new[] { "A" },
                    SaveEdgeTests.ClassArguments(new[] { Parameter(0) }));

                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("A", SaveTemplate.OfClassParameter(0)) }, new[] { edge }));
            }

            public void CalleeClassArgumentMadeOfSeveralParts_IsFilledInPlace()
            {
                SaveEdge edge = WithClassArguments(new[] { "C" }, 1, default, new[] { "A" },
                    SaveEdgeTests.ClassArguments(new[] { SaveTemplateTests.ListOf(Parameter(0)), Closed("S") }));

                CheckEqual(new[]
                {
                    "C=global::System.Collections.Generic.Dictionary<global::System.Collections.Generic.List<" +
                        SaveTemplateTests.Marker0 + ">, global::S>",
                }, Solved(new[]
                {
                    Seed("A", SaveTemplateTests.Concrete("global::System.Collections.Generic.Dictionary<{0}, {1}>",
                        SaveTemplate.OfClassParameter(0), SaveTemplate.OfClassParameter(1))),
                }, new[] { edge }));
            }

            public void EachCalleeIsFilledFromItsOwnClassArguments()
            {
                SaveEdge edge = WithClassArguments(new[] { "C" }, 1, default, new[] { "A", "IA" },
                    SaveEdgeTests.ClassArguments(new[] { Parameter(0) }, new[] { Parameter(1) }));

                CheckEqual(new[] { "C=" + SaveMethodsTests.Marker1 },
                    Solved(new[] { Seed("IA", SaveTemplate.OfClassParameter(0)) }, new[] { edge }));
            }

            public void CalleeWithNoClassArguments_LeavesItsClassParameterUnfilled()
            {
                SaveEdge edge = WithClassArguments(new[] { "C" }, 1, default, new[] { "A" }, default, Parameter(0));

                CheckEqual(0, Solved(new[] { Seed("A", SaveTemplate.OfClassParameter(0)) }, new[] { edge }).Count);
            }

            public void ClassArgumentThatCantBeSpelled_DropsTheCaller()
            {
                SaveEdge edge = WithClassArguments(new[] { "C" }, 1, default, new[] { "A" },
                    SaveEdgeTests.ClassArguments(new[] { SaveTemplate.Unspellable }));
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("A", SaveTemplate.OfClassParameter(0)) },
                    new[] { edge }, dropped);

                CheckEqual(0, solved.Count);
                CheckEqual(new[] { new KeyValuePair<string, string>("C", SaveMethods.UnspellableReason) }, dropped);
            }

            public void ClassTemplateUnderAnInterface_IsRenumberedByThatInterface()
            {
                SaveEdge edge = WithClassArguments(new[] { "C", "IC" }, 1,
                    SaveEdgeTests.Maps(new int[0], new[] { -1, 0 }), new[] { "A" },
                    SaveEdgeTests.ClassArguments(new[] { SaveTemplate.OfClassParameter(1) }));

                CheckEqual(new[]
                {
                    "C=" + SaveTemplate.OfClassParameter(1).ToSource(),
                    "IC=" + SaveTemplate.OfClassParameter(0).ToSource(),
                }, Solved(new[] { Seed("A", SaveTemplate.OfClassParameter(0)) }, new[] { edge }));
            }

            public void ClassTemplateUnderAnInterfaceThatDoesntTakeTheParameter_DropsThatIdAlone()
            {
                SaveEdge edge = WithClassArguments(new[] { "C", "IC1", "IC2" }, 1,
                    SaveEdgeTests.Maps(new int[0], new[] { -1 }, new[] { 0 }), new[] { "A" },
                    SaveEdgeTests.ClassArguments(new[] { SaveTemplate.OfClassParameter(0) }));
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("A", SaveTemplate.OfClassParameter(0)) },
                    new[] { edge }, dropped);

                CheckEqual(new[]
                {
                    "C=" + SaveTemplate.OfClassParameter(0).ToSource(),
                    "IC2=" + SaveTemplate.OfClassParameter(0).ToSource(),
                }, solved);
                CheckEqual(new[] { new KeyValuePair<string, string>("IC1", SaveMethods.InheritedReason) }, dropped);
            }

            public void ClassTemplateUnderAnInterfaceWithNoMap_IsDroppedWithTheInheritedReason()
            {
                var dropped = new List<KeyValuePair<string, string>>();
                var edge = new SaveEdge(SaveEdgeTests.Ids("C", "IC"), 1, SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(
                        SaveTemplate.OfClassParameter(0))));

                Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }, dropped);

                CheckEqual(new[] { new KeyValuePair<string, string>("IC", SaveMethods.InheritedReason) }, dropped);
            }

            public void MixedTemplateUnderAnInterface_RenumbersTheClassPartAndKeepsTheMethodPart()
            {
                SaveTemplate pair = SaveTemplateTests.Concrete("global::Pair<{0}, {1}>",
                    SaveTemplate.OfClassParameter(1), Parameter(0));
                SaveEdge edge = WithClassArguments(new[] { "C", "IC" }, 1,
                    SaveEdgeTests.Maps(new int[0], new[] { -1, 0 }), new[] { "A" }, default, pair);

                CheckEqual(new[]
                {
                    "C=global::Pair<" + SaveTemplate.OfClassParameter(1).ToSource() + ", " + SaveTemplateTests.Marker0 +
                        ">",
                    "IC=global::Pair<" + SaveTemplate.OfClassParameter(0).ToSource() + ", " +
                        SaveTemplateTests.Marker0 + ">",
                }, Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }));
            }

            public void MethodTemplateUnderAnInterface_NeedsNoMap()
            {
                var edge = new SaveEdge(SaveEdgeTests.Ids("C", "IC"), 1, SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(Parameter(0))));
                var dropped = new List<KeyValuePair<string, string>>();

                List<string> solved = Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }, dropped);

                CheckEqual(2, solved.Count);
                CheckEqual(0, dropped.Count);
            }

            public void ClassTemplate_IsRegisteredUnderTheCallersOwnIdOnly()
            {
                var edge = new SaveEdge(SaveEdgeTests.Ids("C", "IC"), 1, SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(
                        SaveTemplate.OfClassParameter(0))));

                CheckEqual(new[] { "C=" + EdgesOfTests.ClassMarker0 },
                    Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }));
            }

            public void ClassTemplateOfACallerWithNoOwnId_IsRegisteredNowhere()
            {
                var edge = new SaveEdge(SaveEdgeTests.Ids("IC"), 0, SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(
                        SaveTemplate.OfClassParameter(0))));

                CheckEqual(0, Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }).Count);
            }

            public void MethodTemplate_IsRegisteredUnderEveryCallerId()
            {
                var edge = new SaveEdge(SaveEdgeTests.Ids("C", "IC"), 1, SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(
                        Parameter(0))));

                CheckEqual(new[] { "C=" + SaveTemplateTests.Marker0, "IC=" + SaveTemplateTests.Marker0 },
                    Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }));
            }

            public void TemplateMixingClassAndMethodParameters_IsRegisteredUnderTheOwnIdOnly()
            {
                SaveTemplate pair = SaveTemplateTests.Concrete("global::Pair<{0}, {1}>",
                    SaveTemplate.OfClassParameter(0), Parameter(0));
                var edge = new SaveEdge(SaveEdgeTests.Ids("C", "IC"), 1, SaveEdgeTests.Ids("A"),
                    new EquatableArray<SaveTemplate>(System.Collections.Immutable.ImmutableArray.Create(pair)));

                CheckEqual(1, Solved(new[] { Seed("A", Parameter(0)) }, new[] { edge }).Count);
            }

            public void CalleeTemplateOfAClassParameter_IsNotComposedYet()
            {
                CheckEqual(0, Solved(new[] { Seed("A", SaveTemplate.OfClassParameter(0)) },
                    new[] { Edge("C", "A", Parameter(0)) }).Count);
            }

            public void ParameterPastTheNinth_IsRegisteredByItsDigits()
            {
                CheckEqual(new[]
                {
                    "C=global::Vellum.SaveMethodParameter<global::Vellum.SaveMethodParameter1, " +
                        "global::Vellum.SaveMethodParameter2>",
                }, Solved(new[] { Seed("A", Parameter(0)) }, new[] { Edge("C", "A", Parameter(12)) }));
            }
        }

        public class VellumsOwnRegistrationsTests : TestFixture
        {
            public void EachOne_NamesAMethodThatExists()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", ""));
                var missing = new List<string>();
                foreach (SaveRegistration seed in SaveMethods.SeedsOf(compilation).Items)
                {
                    if (seed.Id.StartsWith("M:Vellum.", System.StringComparison.Ordinal)
                        && DocumentationCommentId.GetFirstSymbolForDeclarationId(seed.Id, compilation) == null)
                    {
                        missing.Add(seed.Id);
                    }
                }

                CheckEqual(0, missing.Count);
            }

            public void EachOne_IsRegisteredOnceForEachTypeItSaves()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", ""));
                var seen = new HashSet<string>();
                foreach (SaveRegistration seed in SaveMethods.SeedsOf(compilation).Items)
                {
                    CheckTrue(seen.Add(seed.Id + "=" + seed.Template.ToSource()));
                }
            }
        }

        public class SeedsOfTests : TestFixture
        {
            public static List<string> Seeds(string source)
            {
                return SaveMethods.SeedsOf(VellumRun.Compile(("Source.cs", source))).Items
                    .Where(seed => !seed.Id.StartsWith("M:Vellum.", System.StringComparison.Ordinal))
                    .Select(seed => seed.Id + "=" + seed.Template.ToSource()).ToList();
            }

            public void Registrations_AreSortedByIdThenType()
            {
                CheckEqual(new[]
                {
                    "M:A.Put``1(``0)=global::System.Collections.Generic.List<" + SaveTemplateTests.Marker0 + ">",
                    "M:A.Put``1(``0)=" + SaveTemplateTests.Marker0,
                    "M:B.Put``1(``0)=" + SaveTemplateTests.Marker0,
                }, Seeds(@"
[assembly: RegisterSaveMethod(""M:B.Put``1(``0)"", typeof(SaveMethodParameter0))]
[assembly: RegisterSaveMethod(""M:A.Put``1(``0)"", typeof(SaveMethodParameter0))]
[assembly: RegisterSaveMethod(""M:A.Put``1(``0)"", typeof(List<SaveMethodParameter0>))]"));
            }

            public void RegistrationOfATypeThatCantBeSpelled_IsLeftOut()
            {
                CheckEqual(0, Seeds(@"
public class Outer { private class Hidden { } }
[assembly: RegisterSaveMethod(""M:A.Put``1(``0)"", typeof(Missing))]").Count);
            }

            public void RegistrationInAReference_IsIncluded()
            {
                CSharpCompilation compilation = VellumRun.Compile(new[] { SavedTypeAnalyzerTests.StoreLibrary },
                    ("Source.cs", ""));

                CheckTrue(SaveMethods.SeedsOf(compilation).Items.Any(
                    seed => seed.Id == "M:IStore.Put``1(System.String,``0)"));
            }

            public void SameCompilation_GivesEqualSeeds()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", "public class Plain { }"));

                CheckEqual(SaveMethods.SeedsOf(compilation), SaveMethods.SeedsOf(compilation));
            }
        }

        public class AttributesTests : TestFixture
        {
            public void EachRegistration_IsAnAttributeSpellingItsTemplate()
            {
                var registrations = new[]
                {
                    new SaveRegistration("M:A.Put``1(``0)", SaveTemplateTests.ListOf(SaveTemplate.OfParameter(0))),
                };

                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(\"M:A.Put``1(``0)\", typeof(global::System." +
                        "Collections.Generic.List<global::Vellum.SaveMethodParameter0>))]",
                }, SaveMethods.Attributes(registrations));
            }
        }

        public class PipelineTests : TestFixture
        {
            public const string Store = "public class Store { public SaveSession Session; " +
                "public void Put<T>(T value) { Session.ToNode(value); } }\n";

            public void WrapperOfASavingMethod_IsRegistered()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front { public Store Store; public void Save<T>(T value) { Store.Put(value); } }");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[]
                {
                    Attribute("M:Front.Save``1(``0)", 0), Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void WrapperOfAWrapper_IsRegistered()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front { public Store Store; public void Save<T>(T value) { Store.Put(value); } }
public class Back { public Front Front; public void Keep<T>(T value) { Front.Save(value); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Back.Keep``1(``0)", 0), Attribute("M:Front.Save``1(``0)", 0),
                    Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void MethodOfAGenericClass_IsRegisteredByItsClassParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public void Put(T value) { Session.ToNode(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(\"M:Store`1.Put(`0)\", typeof(global::Vellum." +
                        "SaveClassParameter<global::Vellum.SaveMethodParameter0>))]",
                }, Lines(run));
            }

            public const string ClassStandIn0 =
                "typeof(global::Vellum.SaveClassParameter<global::Vellum.SaveMethodParameter0>)";

            public const string ClassStandIn1 =
                "typeof(global::Vellum.SaveClassParameter<global::Vellum.SaveMethodParameter1>)";

            public static string ClassAttribute(string id, string standIn)
            {
                return "[assembly: global::Vellum.RegisterSaveMethod(\"" + id + "\", " + standIn + ")]";
            }

            public void ClassParameterTemplate_IsRegisteredUnderAnInterfaceByTheInterfacesNumber()
            {
                VellumRun run = VellumRun.Of(@"
public interface IStore<X> { void Put(X value); }
public class Store<T> : IStore<T>
{
    public SaveSession Session;
    public void Put(T value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    ClassAttribute("M:IStore`1.Put(`0)", ClassStandIn0),
                    ClassAttribute("M:Store`1.Put(`0)", ClassStandIn0),
                }, Lines(run));
                CheckEqual(0, run.Reported.Count);
            }

            public void InterfaceThatTakesTheClassesParametersInAnotherOrder_IsRegisteredWithItsOwnNumbers()
            {
                VellumRun run = VellumRun.Of(@"
public interface IBag<X> { void Put(X value); }
public class Pair<A, B> : IBag<B>
{
    public SaveSession Session;
    public void Put(B value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    ClassAttribute("M:IBag`1.Put(`0)", ClassStandIn0),
                    ClassAttribute("M:Pair`2.Put(`1)", ClassStandIn1),
                }, Lines(run));
            }

            public void InterfaceInsideATypeNestedInAGenericOne_IsRegisteredWithItsOwnNumbers()
            {
                VellumRun run = VellumRun.Of(@"
public interface IBag<X> { void Put(X value); }
public class Outer<A>
{
    public class Inner<B> : IBag<B>
    {
        public SaveSession Session;
        public void Put(B value) { Session.ToNode(value); }
    }
}");

                CheckEqual(new[]
                {
                    ClassAttribute("M:IBag`1.Put(`0)", ClassStandIn0),
                    ClassAttribute("M:Outer`1.Inner`1.Put(`1)", ClassStandIn1),
                }, Lines(run));
            }

            public void InterfaceThatTakesTheSameParameterTwice_IsRegisteredWithItsFirstNumber()
            {
                VellumRun run = VellumRun.Of(@"
public interface IBag<X, Y> { void Put(X value); }
public class Twin<A> : IBag<A, A>
{
    public SaveSession Session;
    public void Put(A value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    ClassAttribute("M:IBag`2.Put(`0)", ClassStandIn0),
                    ClassAttribute("M:Twin`1.Put(`0)", ClassStandIn0),
                }, Lines(run));
            }

            public void InterfaceThatTakesTheParameterInsideAnotherType_IsNotRegisteredAndWarns()
            {
                VellumRun run = VellumRun.Of(@"
public interface IBag<X> { void Put(X value); }
public class Wrap<A> : IBag<List<A>>
{
    public SaveSession Session;
    public void Put(List<A> value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(" +
                        "\"M:Wrap`1.Put(System.Collections.Generic.List{`0})\", " +
                        "typeof(global::System.Collections.Generic.List<global::Vellum.SaveClassParameter<" +
                        "global::Vellum.SaveMethodParameter0>>))]",
                }, Lines(run));
                CheckEqual(new[] { "VEL0016" }, run.Reported);
            }

            public void MethodImplementingAnInterfaceExplicitly_IsRegisteredUnderTheInterfaceOnly()
            {
                VellumRun run = VellumRun.Of(@"
public interface IBag<X> { void Put(X value); }
public class Pair<A, B> : IBag<B>
{
    public SaveSession Session;
    void IBag<B>.Put(B value) { Session.ToNode(value); }
}");

                CheckEqual(new[] { ClassAttribute("M:IBag`1.Put(`0)", ClassStandIn0) }, Lines(run));
            }

            public void CallThroughTheInterface_IsCheckedWithTheInterfacesArgument()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public interface IBag<X> { void Put(string key, X value); }
public class Pair<A, B> : IBag<B>
{
    public SaveSession Session;
    public void Put(string key, B value) { Session.ToNode(value); }
}");

                VellumRun run = VellumRun.Of(library, @"
public class User
{
    public void Run(IBag<System.Collections.ObjectModel.Collection<int>> bad, IBag<int> good,
        Pair<object, int> fine, Pair<int, object> alsoBad)
    {
        bad.Put(""bag"", null);
        good.Put(""fine"", 1);
        fine.Put(""fine"", 1);
        alsoBad.Put(""other"", null);
    }
}");

                CheckEqual(new[] { "VEL0004:bad.Put(\"bag\", null)", "VEL0004:alsoBad.Put(\"other\", null)" },
                    run.Compiled);
            }

            public void MethodThatCallsAMemberOfAGenericClass_IsRegisteredByTheMethodsParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public void Put(string key, T value) { Session.ToNode(value); }
}
public class Front
{
    public void Save<U>(U value) { new Store<U>().Put(""k"", value); }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Save``1(``0)", 0),
                    ClassAttribute("M:Store`1.Put(System.String,`0)", ClassStandIn0),
                }, Lines(run));
            }

            public void MethodOfAGenericClassThatCallsAMemberOfAnother_IsRegisteredByItsClassParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public void Put(string key, T value) { Session.ToNode(value); }
}
public class Holder<U>
{
    public Store<U> Inner = new Store<U>();
    public void Hold(U value) { Inner.Put(""k"", value); }
}");

                CheckEqual(new[]
                {
                    ClassAttribute("M:Holder`1.Hold(`0)", ClassStandIn0),
                    ClassAttribute("M:Store`1.Put(System.String,`0)", ClassStandIn0),
                }, Lines(run));
            }

            public void ClassArgumentBuiltFromTheCallersParameter_IsSpelledInTheTemplate()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public void Put(string key, T value) { Session.ToNode(value); }
}
public class Holder<U>
{
    public Store<List<U>> Inner = new Store<List<U>>();
    public void Hold(U value) { Inner.Put(""k"", null); }
}");

                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(\"M:Holder`1.Hold(`0)\", typeof(global::System." +
                        "Collections.Generic.List<global::Vellum.SaveClassParameter<" +
                        "global::Vellum.SaveMethodParameter0>>))]",
                    ClassAttribute("M:Store`1.Put(System.String,`0)", ClassStandIn0),
                }, Lines(run));
            }

            public void StaticMemberOfAGenericClass_IsHandedOnToo()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public static SaveSession Session;
    public static void Make(T value) { Session.ToNode(value); }
}
public class Front { public void Use<U>(U value) { Store<U>.Make(value); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Use``1(``0)", 0),
                    ClassAttribute("M:Store`1.Make(`0)", ClassStandIn0),
                }, Lines(run));
            }

            public void MethodThatCallsAnotherOfItsOwnClass_IsRegisteredToo()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    void Keep(T value) { Session.ToNode(value); }
    public void Put(T value) { Keep(value); }
}");

                CheckEqual(new[]
                {
                    ClassAttribute("M:Store`1.Keep(`0)", ClassStandIn0),
                    ClassAttribute("M:Store`1.Put(`0)", ClassStandIn0),
                }, Lines(run));
            }

            public void CallThroughAChainOfGenericClasses_IsCheckedForSaveableTypes()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public class Store<T>
{
    public SaveSession Session;
    public void Put(string key, T value) { Session.ToNode(value); }
}
public class Holder<U>
{
    public Store<U> Inner = new Store<U>();
    public void Hold(string key, U value) { Inner.Put(key, value); }
}");

                VellumRun run = VellumRun.Of(library, @"
public class User
{
    public void Run(Holder<System.Collections.ObjectModel.Collection<int>> bad, Holder<int> good)
    {
        bad.Hold(""bag"", null);
        good.Hold(""fine"", 1);
    }
}");

                CheckEqual(new[] { "VEL0004:bad.Hold(\"bag\", null)" }, run.Compiled);
            }

            public void ClassArgumentOfACallThatIsClosed_HandsOnNothing()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public void Put(T value) { Session.ToNode(value); }
}
public class Front { public void Save<U>(U value) { new Store<int>().Put(1); } }");

                CheckEqual(new[] { ClassAttribute("M:Store`1.Put(`0)", ClassStandIn0) }, Lines(run));
            }

            public void MethodParameterTemplate_IsStillRegisteredUnderAnInterfaceOfAGenericClass()
            {
                VellumRun run = VellumRun.Of(@"
public interface IStore<X> { void Put<T>(T value); }
public class Store<A> : IStore<A>
{
    public SaveSession Session;
    public void Put<T>(T value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    Attribute("M:IStore`1.Put``1(``0)", 0),
                    Attribute("M:Store`1.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void CallThroughAGenericClassesRegisteredMethod_IsCheckedForSaveableTypes()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public class Store<T>
{
    public SaveSession Session;
    public void Put(string key, T value) { Session.ToNode(value); }
}");

                VellumRun run = VellumRun.Of(library, @"
public class User
{
    public void Run(Store<System.Collections.ObjectModel.Collection<int>> bad, Store<int> good)
    {
        bad.Put(""bag"", null);
        good.Put(""fine"", 1);
    }
}");

                CheckEqual(new[] { "VEL0004:bad.Put(\"bag\", null)" }, run.Compiled);
            }

            public void ClassAndMethodParametersTogether_AreBothCheckedAtTheCall()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public class Store<T>
{
    public SaveSession Session;
    public void Put<U>(string key, U value) { Session.ToNode(new Dictionary<T, U>()); }
}");

                VellumRun run = VellumRun.Of(library, @"
public class User
{
    public void Run(Store<int> ints, Store<object> objects)
    {
        ints.Put(""fine"", 1);
        ints.Put(""second"", new object());
        objects.Put(""first"", 1);
    }
}");

                CheckEqual(new[] { "VEL0004:ints.Put(\"second\", new object())", "VEL0004:objects.Put(\"first\", 1)" },
                    run.Compiled);
            }

            public void MethodsThatCallEachOther_AreRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void A<T>(T value, int count) { if (count > 0) { B(value, count - 1); } Session.ToNode(value); }
    public void B<T>(T value, int count) { A(value, count); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[]
                {
                    Attribute("M:Store.A``1(``0,System.Int32)", 0), Attribute("M:Store.B``1(``0,System.Int32)", 0),
                }, Lines(run));
            }

            public void WrapperSavingATypeBuiltFromItsParameter_SpellsThatType()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front { public Store Store; public void Save<T>(T value) { Store.Put(new List<T>()); } }");

                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(\"M:Front.Save``1(``0)\", typeof(global::System." +
                        "Collections.Generic.List<global::Vellum.SaveMethodParameter0>))]",
                    Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void WrapperSavingItsSecondParameter_NamesTheSecondStandIn()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front { public Store Store; public void Save<TKey, T>(TKey key, T value) { Store.Put(value); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Save``2(``0,``1)", 1), Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void MethodThatDoesntSave_IsNotRegistered()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front { public Store Store; public void Note<T>(T value) { Other(value); } void Other<T>(T value) { } }");

                CheckEqual(new[] { Attribute("M:Store.Put``1(``0)", 0) }, Lines(run));
            }

            public void RequireOfTheParameter_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store { public T Load<T>(SaveReader reader) { return reader.Require<T>(""key""); } }");

                CheckEqual(new[] { Attribute("M:Store.Load``1(Vellum.SaveReader)", 0) }, Lines(run));
            }

            public void TryReadOfTheParameter_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public bool Load<T>(SaveReader reader, out T value) { return reader.TryRead(""key"", out value); }
}");

                CheckEqual(new[] { Attribute("M:Store.Load``1(Vellum.SaveReader,``0@)", 0) }, Lines(run));
            }

            public void TypeofFromNode_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public T Read<T>(SaveNode node) { return (T)Session.FromNode(node, typeof(T)); }
}");

                CheckEqual(new[] { Attribute("M:Store.Read``1(Vellum.SaveNode)", 0) }, Lines(run));
            }

            public void SavedItemsOfTheParameter_AreRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveNode Put<T>(IEnumerable<T> items, SaveSession session) { return SavedItems.ToNode(items, session); }
    public T[] Get<T>(SaveNode node, SaveSession session) { return SavedItems.FromNode<T>(node, session); }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Store.Get``1(Vellum.SaveNode,Vellum.SaveSession)", 0),
                    Attribute("M:Store.Put``1(System.Collections.Generic.IEnumerable{``0},Vellum.SaveSession)", 0),
                }, Lines(run));
            }

            public void SavedEntriesOfTheParameters_RegisterBoth()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveNode Put<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> entries, SaveSession session)
    {
        return SavedEntries.ToNode(entries, session);
    }
}");

                string id = "M:Store.Put``2(System.Collections.Generic.IEnumerable" +
                    "{System.Collections.Generic.KeyValuePair{``0,``1}},Vellum.SaveSession)";
                CheckEqual(new[] { Attribute(id, 0), Attribute(id, 1) }, Lines(run));
            }

            public void SavedEntriesWithOneParameterClosed_RegistersTheOpenOne()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveNode Put<TValue>(IEnumerable<KeyValuePair<string, TValue>> entries, SaveSession session)
    {
        return SavedEntries.ToNode(entries, session);
    }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Store.Put``1(System.Collections.Generic.IEnumerable" +
                        "{System.Collections.Generic.KeyValuePair{System.String,``0}},Vellum.SaveSession)", 0),
                }, Lines(run));
            }

            public void WrapperThroughAnInterface_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public interface IStore { void Put<T>(T value); }
public class Store : IStore { public SaveSession Session; public void Put<T>(T value) { Session.ToNode(value); } }
public class Front { public IStore Store; public void Save<T>(T value) { Store.Put(value); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Save``1(``0)", 0), Attribute("M:IStore.Put``1(``0)", 0),
                    Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void WrapperInAReference_IsRegisteredForItsCallers()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Store +
                    "public class Front { public Store Store; public void Save<T>(T value) { Store.Put(value); } }");

                VellumRun run = VellumRun.Of(library, @"
public class Back { public Front Front; public void Keep<T>(T value) { Front.Save(value); } }");

                CheckEqual(new[] { Attribute("M:Back.Keep``1(``0)", 0) }, Lines(run));
            }

            public void CallThroughAWrapper_IsCheckedForSaveableTypes()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Store +
                    "public class Front { public Store Store; public void Save<T>(T value) { Store.Put(value); } }");

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Front front, " +
                    "System.Collections.ObjectModel.Collection<int> bag) { front.Save(bag); } }");

                CheckEqual(new[] { "VEL0004:front.Save(bag)" }, run.Compiled);
            }

            public void CallThroughAWrapperOfAGenericType_IsCheckedInsideThatType()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Store +
                    "public class Front { public Store Store; " +
                    "public void Save<T>(T value) { Store.Put(new List<T>()); } }");

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Front front) " +
                    "{ front.Save(5); front.Save(new object()); } }");

                CheckEqual(new[] { "VEL0004:front.Save(new object())" }, run.Compiled);
            }

            public void CallOnAnOverrideInAPlainClass_IsCheckedByTheBaseClassesRegistration()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public class Base<T>
{
    public SaveSession Session;
    public virtual void Put(T value) { Session.ToNode(value); }
}");

                VellumRun run = VellumRun.Of(library, "public class Derived : Base<System.Collections.ObjectModel." +
                    "Collection<int>> { public override void Put(System.Collections.ObjectModel.Collection<int> " +
                    "value) { } }\npublic class User { public void Run(Derived derived, " +
                    "System.Collections.ObjectModel.Collection<int> bag) { derived.Put(bag); } }");

                CheckEqual(new[] { "VEL0004:derived.Put(bag)" }, run.Compiled);
            }

            public void WrapperSavingAPrivateTypeAroundItsParameter_WarnsAndIsNotRegistered()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front
{
    private class Hidden { }
    public Store Store;
    public void Save<T>(T value) { Store.Put(new Dictionary<T, Hidden>()); }
}");

                CheckEqual(new[] { Attribute("M:Store.Put``1(``0)", 0) }, Lines(run));
                CheckEqual(new[] { "VEL0016" }, run.Reported);
            }

            public void WrapperSavingAClosedPrivateType_IsQuiet()
            {
                VellumRun run = VellumRun.Of(Store + @"
public class Front
{
    private class Hidden { }
    public Store Store;
    public void Save<T>(T value) { Store.Put(new Hidden()); }
}");

                CheckEqual(new[] { Attribute("M:Store.Put``1(``0)", 0) }, Lines(run));
                CheckEqual(0, run.Reported.Count);
            }

            public void MethodHandingAGrowingTypeToItself_StopsAndWarns()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Grow<T>(T value) { Session.ToNode(value); Grow(new List<T>()); }
}");

                CheckEqual(SaveTemplate.MaxDepth, Lines(run).Length);
                CheckEqual(new[] { "VEL0016" }, run.Reported);
            }

            public void TypeParameterPastTheNinth_IsRegisteredByItsDigits()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Many<A, B, C, D, E, F, G, H, I, J, K, T>(T value) { Session.ToNode(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(0, run.Reported.Count);
                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(\"M:Store.Many``12(``11)\", typeof(global::Vellum." +
                        "SaveMethodParameter<global::Vellum.SaveMethodParameter1, " +
                        "global::Vellum.SaveMethodParameter1>))]",
                }, Lines(run));
            }

            public void CallThroughAMethodWithManyTypeParameters_IsCheckedForSaveableTypes()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public class Store
{
    public SaveSession Session;
    public void Many<A, B, C, D, E, F, G, H, I, J, K, T>(T value) { Session.ToNode(value); }
}");

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Store store, " +
                    "System.Collections.ObjectModel.Collection<int> bag) " +
                    "{ store.Many<int, int, int, int, int, int, int, int, int, int, int, " +
                    "System.Collections.ObjectModel.Collection<int>>(bag); } }");

                CheckEqual(1, run.Compiled.Count);
                CheckTrue(run.Compiled[0].StartsWith("VEL0004:", System.StringComparison.Ordinal));
            }
        }

        public class CalleeClassArgumentsTests : TestFixture
        {
            /// <summary>
            /// Returns the edges for the calls in <paramref name="source"/>.
            /// </summary>
            public static List<SaveEdge> Collected(string source)
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SemanticModel model = compilation.GetSemanticModel(tree);
                var returnMe = new List<SaveEdge>();
                foreach (InvocationExpressionSyntax call in tree.GetRoot().DescendantNodes()
                    .OfType<InvocationExpressionSyntax>())
                {
                    returnMe.AddRange(SaveMethods.EdgesOf(model, call, CancellationToken.None));
                }

                return returnMe;
            }

            public static string Spell(SaveTemplate template)
            {
                return template == null ? "null" : template.HasUnspellable ? "unspellable" : template.ToSource();
            }

            /// <summary>
            /// Returns each callee of the edge, as "id&lt;its class arguments&gt;".
            /// </summary>
            public static string[] Callees(SaveEdge edge)
            {
                return edge.CalleeIds.Items.Select((id, index) => id + "<" + string.Join(", ",
                    edge.CalleeClassArguments.Items[index].Items.Select(Spell)) + ">").ToArray();
            }

            public const string Store = "public class Store<T> { public void Put(T value) { } " +
                "public static void Make(T value) { } }\n";

            public void CallOnAGenericClassOfTheCallersParameter_HandsOnTheClassArgument()
            {
                SaveEdge edge = Collected(Store + "public class Front { public void Save<U>(U value) " +
                    "{ new Store<U>().Put(value); } }").Single();

                CheckEqual(new[] { "M:Store`1.Put(`0)<" + Marker0 + ">" }, Callees(edge));
                CheckEqual(0, edge.Arguments.Items.Length);
            }

            public void ClassArgumentMadeFromTheCallersParameter_KeepsTheType()
            {
                SaveEdge edge = Collected(Store + "public class Front { public void Save<U>(U value) " +
                    "{ new Store<List<U>>().Put(null); } }").Single();

                CheckEqual(new[] { "M:Store`1.Put(`0)<global::System.Collections.Generic.List<" + Marker0 + ">>" },
                    Callees(edge));
            }

            public void ClassArgumentOfTheCallersOwnClass_IsAClassParameter()
            {
                SaveEdge edge = Collected(Store + "public class Front<U> { public void Save(U value) " +
                    "{ new Store<U>().Put(value); } }").Single();

                CheckEqual(new[] { "M:Store`1.Put(`0)<" + EdgesOfTests.ClassMarker0 + ">" }, Callees(edge));
            }

            public void ClassArgumentThatIsClosed_HandsOnNothing()
            {
                CheckEqual(0, Collected(Store + "public class Front { public void Save<U>(U value) " +
                    "{ new Store<int>().Put(1); } }").Count);
            }

            public void ClosedClassArgumentNextToAParameter_IsKeptAsWritten()
            {
                SaveEdge edge = Collected("public class Two<A, B> { public void Put(A first, B second) { } }\n" +
                    "public class Front { public void Save<U>(U value) { new Two<int, U>().Put(1, value); } }")
                    .Single();

                CheckEqual(new[] { "M:Two`2.Put(`0,`1)<global::System.Int32, " + Marker0 + ">" }, Callees(edge));
            }

            public void ClassArgumentThatCantBeSpelled_IsUnspellable()
            {
                SaveEdge edge = Collected(Store + "public class Front { private class Hidden { } " +
                    "public void Save<U>(U value) { new Store<Dictionary<U, Hidden>>().Put(null); } }").Single();

                CheckEqual(new[] { "M:Store`1.Put(`0)<unspellable>" }, Callees(edge));
            }

            public void ClosedClassArgumentThatCantBeSpelled_HandsOnNothing()
            {
                CheckEqual(0, Collected(Store + "public class Front { private class Hidden { } " +
                    "public void Save<U>(U value) { new Store<Hidden>().Put(null); } }").Count);
            }

            public void StaticMemberOfAGenericClass_HasItsClassArgument()
            {
                SaveEdge edge = Collected(Store + "public class Front { public void Save<U>(U value) " +
                    "{ Store<U>.Make(value); } }").Single();

                CheckEqual(new[] { "M:Store`1.Make(`0)<" + Marker0 + ">" }, Callees(edge));
            }

            public void NestedGenericClass_ListsTheOuterTypesArgumentFirst()
            {
                SaveEdge edge = Collected(
                    "public class Outer<A> { public class Inner<B> { public void Put(B v) { } } }\n" +
                    "public class Front { public void Save<U>(U value) " +
                    "{ new Outer<int>.Inner<U>().Put(value); } }").Single();

                CheckEqual(new[] { "M:Outer`1.Inner`1.Put(`1)<global::System.Int32, " + Marker0 + ">" }, Callees(edge));
            }

            public void GenericMethodOfAGenericClass_HasBothKindsOfArguments()
            {
                SaveEdge edge = Collected("public class Store<T> { public void Put<V>(T first, V second) { } }\n" +
                    "public class Front { public void Save<U>(U value) { new Store<U>().Put(value, 1); } }")
                    .Single();

                CheckEqual(new[] { "M:Store`1.Put``1(`0,``0)<" + Marker0 + ">" }, Callees(edge));
                CheckEqual(new[] { "global::System.Int32" }, edge.Arguments.Items.Select(Spell).ToArray());
            }

            public void CalleeSeenThroughABaseClass_HasTheBaseClassesArgument()
            {
                SaveEdge edge = Collected("public class Base<T> { public virtual void Put(T value) { } }\n" +
                    "public class Derived<U> : Base<List<U>> { public override void Put(List<U> value) { } }\n" +
                    "public class Front { public void Save<W>(Derived<W> derived) { derived.Put(null); } }").Single();

                CheckEqual(new[]
                {
                    "M:Derived`1.Put(System.Collections.Generic.List{`0})<" + Marker0 + ">",
                    "M:Base`1.Put(`0)<global::System.Collections.Generic.List<" + Marker0 + ">>",
                }, Callees(edge));
            }

            public void CalleeSeenThroughAnInterface_HasTheInterfacesArgument()
            {
                SaveEdge edge = Collected("public interface IBag<X> { void Put(X value); }\n" +
                    "public class Pair<A, B> : IBag<B> { public void Put(B value) { } }\n" +
                    "public class Front { public void Save<W>(Pair<int, W> pair) { pair.Put(default(W)); } }")
                    .Single();

                CheckEqual(new[]
                {
                    "M:Pair`2.Put(`1)<global::System.Int32, " + Marker0 + ">",
                    "M:IBag`1.Put(`0)<" + Marker0 + ">",
                }, Callees(edge));
            }

            public void CallerNumbersItsInterfacesParameters()
            {
                SaveEdge edge = Collected("public interface IBag<X> { void Put(X value); }\n" +
                    "public class Pair<A, B> : IBag<B> { public SaveSession Session; " +
                    "public void Put(B value) { Session.ToNode(value); } }").Single();

                CheckEqual(new[] { "M:Pair`2.Put(`1)", "M:IBag`1.Put(`0)" }, edge.CallerIds.Items);
                CheckEqual(0, edge.CallerClassMaps.Items[0].Items.Length);
                CheckEqual(new[] { -1, 0 }, edge.CallerClassMaps.Items[1].Items);
            }

            public void CallerNumbersAnInterfaceThatTakesAParameterTwice_ByTheFirst()
            {
                SaveEdge edge = Collected("public interface IBag<X, Y> { void Put(X value); }\n" +
                    "public class Twin<A> : IBag<A, A> { public SaveSession Session; " +
                    "public void Put(A value) { Session.ToNode(value); } }").Single();

                CheckEqual(new[] { 0 }, edge.CallerClassMaps.Items[1].Items);
            }

            public void CallerNumbersAnInterfaceThatHidesTheParameter_AsNone()
            {
                SaveEdge edge = Collected("public interface IBag<X> { void Put(X value); }\n" +
                    "public class Wrap<A> : IBag<List<A>> { public SaveSession Session; " +
                    "public void Put(List<A> value) { Session.ToNode(value); } }").Single();

                CheckEqual(new[] { -1 }, edge.CallerClassMaps.Items[1].Items);
            }

            public void CallerNumbersAnInterfaceOfANestedType_AcrossTheOuterTypesToo()
            {
                SaveEdge edge = Collected("public interface IBag<X> { void Put(X value); }\n" +
                    "public class Outer<A> { public class Inner<B> : IBag<B> { public SaveSession Session; " +
                    "public void Put(B value) { Session.ToNode(value); } } }").Single();

                CheckEqual(new[] { -1, 0 }, edge.CallerClassMaps.Items[1].Items);
            }

            public void CallerWithNoOwnIdStillNumbersItsInterface()
            {
                SaveEdge edge = Collected("public interface IBag<X> { void Put(X value); }\n" +
                    "public class Pair<A, B> : IBag<B> { public SaveSession Session; " +
                    "void IBag<B>.Put(B value) { Session.ToNode(value); } }").Single();

                CheckEqual(new[] { "M:IBag`1.Put(`0)" }, edge.CallerIds.Items);
                CheckEqual(0, edge.OwnCallerCount);
                CheckEqual(new[] { -1, 0 }, edge.CallerClassMaps.Items[0].Items);
            }
        }

        public class EdgesOfMemberTests : TestFixture
        {
            /// <summary>
            /// Returns the edges of the method called <paramref name="name"/> in <paramref name="source"/>, as
            /// "callers => callees : arguments".
            /// </summary>
            public static List<string> Of(string source, string name)
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SyntaxNode method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>()
                    .Single(declaration => declaration.Identifier.ValueText == name);

                return SaveMethods.EdgesOfMember(compilation.GetSemanticModel(tree), method, CancellationToken.None)
                    .Select(Describe).ToList();
            }

            public static string Describe(SaveEdge edge)
            {
                string arguments = string.Join(", ", edge.Arguments.Items.Select(
                    argument => argument == null ? "null"
                        : argument.HasUnspellable ? "unspellable" : argument.ToSource()));
                return string.Join("|", edge.CallerIds.Items) + " => " + string.Join("|", edge.CalleeIds.Items) +
                    " : " + arguments;
            }

            public const string Saver = "public class Store { public SaveSession Session; ";

            public void CallsInTheBody_AreEachCollected()
            {
                CheckEqual(new[]
                {
                    "M:Store.Put``1(``0) => " + ToNodeId + " : " + Marker0,
                    "M:Store.Put``1(``0) => M:Vellum.SavedValue.ToNode(System.Object,System.Type) : " + Marker0,
                }, Of(Saver + "public void Put<T>(T value) { Session.ToNode(value); " +
                    "SavedValue.ToNode(value, typeof(T)); } }", "Put"));
            }

            public void CallRepeated_IsCollectedOnce()
            {
                CheckEqual(1, Of(Saver + "public void Put<T>(T value) { Session.ToNode(value); " +
                    "Session.ToNode(value); Session.ToNode(value); } }", "Put").Count);
            }

            public void CallsInALambdaAndALocalFunction_BelongToTheMethod()
            {
                CheckEqual(new[] { "M:Store.Put``1(``0) => " + ToNodeId + " : " + Marker0 },
                    Of(Saver + "public void Put<T>(T value) { System.Action act = () => Session.ToNode(value); " +
                        "void Inner() { Session.ToNode(value); } } }", "Put"));
            }

            public void CallsInANestedLambda_AreFound()
            {
                CheckEqual(1, Of(Saver + "public void Put<T>(T value) { System.Func<System.Action> make = " +
                    "() => () => Session.ToNode(value); } }", "Put").Count);
            }

            public void MethodWithoutABody_HasNoEdges()
            {
                CheckEqual(0, Of("public abstract class Store { public abstract void Put<T>(T value); }",
                    "Put").Count);
            }

            public void ExpressionBodiedMethod_IsWalked()
            {
                CheckEqual(1, Of(Saver + "public SaveNode Put<T>(T value) => Session.ToNode(value); }", "Put").Count);
            }

            public void MethodThatHandsNothingOn_HasNoEdges()
            {
                CheckEqual(0, Of(Saver + "public void Put<T>(T value) { Session.ToNode(5); } }", "Put").Count);
            }

            public void NodeThatIsNotAMethod_HasNoEdges()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", "public class Plain { int x; }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];

                CheckEqual(0, SaveMethods.EdgesOfMember(compilation.GetSemanticModel(tree), tree.GetRoot(),
                    CancellationToken.None).Length);
            }

            public void MethodOfAGenericClass_HandsOnTheClassParameter()
            {
                CheckEqual(new[]
                {
                    "M:Store`1.Put(`0) => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0,
                }, Of("public class Store<T> { public SaveSession Session; " +
                    "public void Put(T value) { Session.ToNode(value); } }", "Put"));
            }
        }

        public const string Store = @"
public class Store<T>
{
    int slot;
    public int Count { get { return 0; } set { } }
    public string Name { get; set; }
    public int this[int index] { get { return 0; } set { } }
    public ref int Slot { get { return ref slot; } }
    public static int Shared { get; set; }
    public event System.Action Changed { add { } remove { } }
}
";

        /// <summary>
        /// Returns each operation in <paramref name="usage"/>, written inside a method of a class using
        /// <see cref="Store"/>, that calls a method.
        /// </summary>
        public static List<IOperation> Uses(string usage)
        {
            CSharpCompilation compilation = VellumRun.Compile(("Source.cs", Store +
                "public class Use { public static int Take(int value) { return value; } " +
                "public void M<U>(Store<U> store) { " + usage + " } }"));
            SyntaxTree tree = compilation.SyntaxTrees[0];
            SyntaxNode method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>()
                .Single(declaration => declaration.Identifier.ValueText == "M");
            IOperation body = compilation.GetSemanticModel(tree).GetOperation(method);

            return body.DescendantsAndSelf().Where(operation => SaveMethods.Called(operation).Count > 0).ToList();
        }

        public class CalledTests : TestFixture
        {
            public static string[] Names(string usage)
            {
                return Uses(usage).SelectMany(operation => SaveMethods.Called(operation))
                    .Select(method => method.Name).ToArray();
            }

            public void Invocation_IsItsMethod()
            {
                CheckEqual(new[] { "Take" }, Names("Take(1);"));
            }

            public void PropertyRead_IsTheGetter()
            {
                CheckEqual(new[] { "get_Count" }, Names("int x = store.Count;"));
            }

            public void PropertyWrite_IsTheSetter()
            {
                CheckEqual(new[] { "set_Count" }, Names("store.Count = 1;"));
            }

            public void CompoundAssignment_IsBoth()
            {
                CheckEqual(new[] { "get_Count", "set_Count" }, Names("store.Count += 1;"));
            }

            public void CoalesceAssignment_IsBoth()
            {
                CheckEqual(new[] { "get_Name", "set_Name" }, Names("store.Name ??= \"\";"));
            }

            public void IncrementAndDecrement_AreBoth()
            {
                CheckEqual(new[] { "get_Count", "set_Count" }, Names("store.Count++;"));
                CheckEqual(new[] { "get_Count", "set_Count" }, Names("--store.Count;"));
            }

            public void ObjectInitializer_IsTheSetter()
            {
                CheckEqual(new[] { ".ctor", "set_Count" }, Names("var other = new Store<U> { Count = 1 };"));
            }

            public void PropertyOnTheRightOfAnAssignment_IsTheGetter()
            {
                CheckEqual(new[] { "set_Name", "get_Name" }, Names("store.Name = store.Name;"));
            }

            public void PropertyPassedToACall_IsTheGetter()
            {
                CheckEqual(new[] { "Take", "get_Count" }, Names("Take(store.Count);"));
            }

            public void Indexer_IsItsAccessorsByUse()
            {
                CheckEqual(new[] { "set_Item", "get_Item" }, Names("store[0] = store[1];"));
            }

            public void StaticProperty_IsItsAccessors()
            {
                CheckEqual(new[] { "set_Shared" }, Names("Store<U>.Shared = 1;"));
            }

            public void PropertyReturningByReference_IsAlwaysTheGetter()
            {
                CheckEqual(new[] { "get_Slot" }, Names("store.Slot = 1;"));
                CheckEqual(new[] { "get_Slot" }, Names("store.Slot += 1;"));
                CheckEqual(new[] { "get_Slot" }, Names("store.Slot++;"));
            }

            public void EventSubscription_IsTheAccessor()
            {
                CheckEqual(new[] { "add_Changed" }, Names("store.Changed += () => { };"));
                CheckEqual(new[] { "remove_Changed" }, Names("store.Changed -= () => { };"));
            }

            public void OperationThatCallsNothing_IsNone()
            {
                CheckEqual(0, Names("int x = 1 + 2;").Length);
            }

            public void AssigningAGetOnlyPropertyInAConstructor_IsNone()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs",
                    "public class Holder { public int Read { get; } public Holder() { Read = 1; } }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                IOperation body = compilation.GetSemanticModel(tree).GetOperation(
                    tree.GetRoot().DescendantNodes().OfType<ConstructorDeclarationSyntax>().Single());

                CheckEqual(0, body.DescendantsAndSelf().SelectMany(operation => SaveMethods.Called(operation))
                    .Count(method => method.AssociatedSymbol != null));
            }
        }

        public class ReceiverOfTests : TestFixture
        {
            public static string[] Receivers(string usage)
            {
                return Uses(usage).Select(operation => SaveMethods.ReceiverOf(operation)?.ToDisplayString() ?? "none")
                    .ToArray();
            }

            public void Invocation_IsItsInstanceType()
            {
                CheckEqual(new[] { "Store<U>" }, Receivers("store.ToString();"));
            }

            public void StaticCall_HasNone()
            {
                CheckEqual(new[] { "none" }, Receivers("Take(1);"));
            }

            public void PropertyReference_IsItsInstanceType()
            {
                CheckEqual(new[] { "Store<U>" }, Receivers("int x = store.Count;"));
            }

            public void StaticPropertyReference_HasNone()
            {
                CheckEqual(new[] { "none" }, Receivers("int x = Store<U>.Shared;"));
            }

            public void EventSubscription_IsItsInstanceType()
            {
                CheckEqual(new[] { "Store<U>" }, Receivers("store.Changed += () => { };"));
            }
        }

        public class AccessorEdgesTests : TestFixture
        {
            public static List<string> Of(string source, string name)
            {
                return EdgesOfMemberTests.Of(Store + "public class Use { public void M<U>(Store<U> store) { " +
                    source + " } }", name);
            }

            public static List<string> Reached(string usage)
            {
                return Of(usage, "M");
            }

            public void PropertyRead_HandsOnToTheGetter()
            {
                CheckEqual(new[] { "M:Use.M``1(Store{``0}) => M:Store`1.get_Count : " },
                    Reached("int x = store.Count;"));
            }

            public void PropertyWrite_HandsOnToTheSetter()
            {
                CheckEqual(new[] { "M:Use.M``1(Store{``0}) => M:Store`1.set_Count(System.Int32) : " },
                    Reached("store.Count = 1;"));
            }

            public void CompoundAssignment_HandsOnToBoth()
            {
                CheckEqual(new[]
                    { "M:Use.M``1(Store{``0}) => M:Store`1.get_Count|M:Store`1.set_Count(System.Int32) : " },
                    Reached("store.Count += 1;"));
            }

            public void Indexer_HandsOnToItsAccessor()
            {
                CheckEqual(new[] { "M:Use.M``1(Store{``0}) => M:Store`1.set_Item(System.Int32,System.Int32) : " },
                    Reached("store[0] = 1;"));
            }

            public void EventSubscription_HandsOnToItsAccessor()
            {
                CheckEqual(new[] { "M:Use.M``1(Store{``0}) => M:Store`1.add_Changed(System.Action) : " },
                    Reached("store.Changed += () => { };"));
            }

            public void FieldLikeEvent_HandsOnToItsAccessor()
            {
                CheckEqual(new[] { "M:Use.M``1(Fields{``0}) => M:Fields`1.add_Raised(System.Action) : " },
                    EdgesOfMemberTests.Of("public class Fields<T> { public event System.Action Raised; }\n" +
                        "public class Use { public void M<U>(Fields<U> fields) { fields.Raised += () => { }; } }",
                        "M"));
            }

            public void StaticProperty_HandsOnToItsAccessor()
            {
                CheckEqual(new[] { "M:Use.M``1(Store{``0}) => M:Store`1.set_Shared(System.Int32) : " },
                    Reached("Store<U>.Shared = 1;"));
            }

            public void PropertyOfAClosedType_HandsOnNothing()
            {
                CheckEqual(0, EdgesOfMemberTests.Of(Store + "public class Use { public void M(Store<int> store) " +
                    "{ store.Count = 1; } }", "M").Count);
            }

            public void ClassArgumentOfTheCallersParameter_IsKeptForTheAccessor()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", Store +
                    "public class Use { public void M<U>(Store<List<U>> store) { store.Count = 1; } }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SyntaxNode access = tree.GetRoot().DescendantNodes().OfType<MemberAccessExpressionSyntax>().Single();

                SaveEdge edge = SaveMethods.EdgesOf(compilation.GetSemanticModel(tree), access, CancellationToken.None)
                    .Single();

                CheckEqual(new[]
                    { "M:Store`1.set_Count(System.Int32)<global::System.Collections.Generic.List<" + Marker0 + ">>" },
                    CalleeClassArgumentsTests.Callees(edge));
            }
        }

        public class AccessorCallerEdgesTests : TestFixture
        {
            public const string Holder = "public class Holder<T> { public SaveSession Session; T stored; ";

            public static List<string> OfAccessor(string source, string keyword)
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SyntaxNode accessor = tree.GetRoot().DescendantNodes().OfType<AccessorDeclarationSyntax>()
                    .Last(declaration => declaration.Keyword.ValueText == keyword);

                return SaveMethods.EdgesOfMember(compilation.GetSemanticModel(tree), accessor, CancellationToken.None)
                    .Select(EdgesOfMemberTests.Describe).ToList();
            }

            public static List<string> OfExpressionBody(string source)
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SyntaxNode body = tree.GetRoot().DescendantNodes().OfType<ArrowExpressionClauseSyntax>().Single();

                return SaveMethods.EdgesOfMember(compilation.GetSemanticModel(tree), body, CancellationToken.None)
                    .Select(EdgesOfMemberTests.Describe).ToList();
            }

            public void Setter_HandsOnTheClassParameter()
            {
                CheckEqual(new[] { "M:Holder`1.set_Value(`0) => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0 },
                    OfAccessor(Holder + "public T Value { set { Session.ToNode(value); } } }", "set"));
            }

            public void Getter_HandsOnTheClassParameter()
            {
                CheckEqual(new[] { "M:Holder`1.get_Value => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0 },
                    OfAccessor(Holder + "public T Value { get { Session.ToNode(stored); return stored; } } }",
                        "get"));
            }

            public void ExpressionBodiedAccessor_IsWalked()
            {
                CheckEqual(new[] { "M:Holder`1.get_Node => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0 },
                    OfAccessor(Holder + "public SaveNode Node { get => Session.ToNode(stored); } }", "get"));
            }

            public void ExpressionBodiedProperty_IsWalkedAsItsGetter()
            {
                CheckEqual(new[] { "M:Holder`1.get_Node => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0 },
                    OfExpressionBody(Holder + "public SaveNode Node => Session.ToNode(stored); }"));
            }

            public void ExpressionBodiedIndexer_IsWalkedAsItsGetter()
            {
                CheckEqual(new[]
                {
                    "M:Holder`1.get_Item(System.Int32) => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0,
                }, OfExpressionBody(Holder + "public SaveNode this[int index] => Session.ToNode(stored); }"));
            }

            public void IndexerSetter_IsNamedByItsArguments()
            {
                CheckEqual(new[]
                {
                    "M:Holder`1.set_Item(System.Int32,`0) => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0,
                }, OfAccessor(Holder + "public T this[int index] { set { Session.ToNode(value); } } }", "set"));
            }

            public void EventAccessors_AreEachNamed()
            {
                string source = Holder + "public event System.Action Changed " +
                    "{ add { Session.ToNode(stored); } remove { Session.ToNode(stored); } } }";

                CheckEqual(new[]
                {
                    "M:Holder`1.add_Changed(System.Action) => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0,
                }, OfAccessor(source, "add"));
                CheckEqual(new[]
                {
                    "M:Holder`1.remove_Changed(System.Action) => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0,
                }, OfAccessor(source, "remove"));
            }

            public void AccessorWithoutABody_HasNoEdges()
            {
                CheckEqual(0, OfAccessor(Holder + "public T Value { get; set; } }", "get").Count);
            }

            public void AccessorImplementingAnInterface_IsAlsoNamedByTheInterface()
            {
                CheckEqual(new[]
                {
                    "M:Holder`1.set_Value(`0)|M:IHold`1.set_Value(`0) => " + ToNodeId + " : " +
                        EdgesOfTests.ClassMarker0,
                }, OfAccessor("public interface IHold<X> { X Value { set; } }\n" +
                    "public class Holder<T> : IHold<T> { public SaveSession Session; " +
                    "public T Value { set { Session.ToNode(value); } } }", "set"));
            }
        }

        public class AccessorPipelineTests : TestFixture
        {
            public const string Bag = "System.Collections.ObjectModel.Collection<int>";

            public static string Class0(string id)
            {
                return PipelineTests.ClassAttribute(id, PipelineTests.ClassStandIn0);
            }

            public void SetterOfAGenericClass_IsRegisteredByItsClassParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public T Value { set { Session.ToNode(value); } }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Class0("M:Store`1.set_Value(`0)") }, Lines(run));
            }

            public void GetterThatSavesWhatItReturns_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    T stored;
    public T Value { get { Session.ToNode(stored); return stored; } }
}");

                CheckEqual(new[] { Class0("M:Store`1.get_Value") }, Lines(run));
            }

            public void ExpressionBodiedAccessors_AreRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    T stored;
    public SaveNode Node => Session.ToNode(stored);
    public SaveNode Other { get => Session.ToNode(stored); set => Session.ToNode(stored); }
}");

                CheckEqual(new[]
                {
                    Class0("M:Store`1.get_Node"), Class0("M:Store`1.get_Other"), Class0("M:Store`1.set_Other(" +
                        "Vellum.SaveNode)"),
                }, Lines(run));
            }

            public void IndexerAccessors_AreRegisteredWithTheirArguments()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public T this[int index] { set { Session.ToNode(value); } }
}");

                CheckEqual(new[] { Class0("M:Store`1.set_Item(System.Int32,`0)") }, Lines(run));
            }

            public void EventAccessors_AreRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    T stored;
    public event System.Action Changed { add { Session.ToNode(stored); } remove { Session.ToNode(stored); } }
}");

                CheckEqual(new[]
                {
                    Class0("M:Store`1.add_Changed(System.Action)"), Class0("M:Store`1.remove_Changed(System.Action)"),
                }, Lines(run));
            }

            public void PropertyImplementingAnInterface_IsRegisteredUnderTheInterfaceToo()
            {
                VellumRun run = VellumRun.Of(@"
public interface IHold<X> { X Value { set; } }
public class Store<T> : IHold<T>
{
    public SaveSession Session;
    public T Value { set { Session.ToNode(value); } }
}");

                CheckEqual(new[]
                {
                    Class0("M:IHold`1.set_Value(`0)"), Class0("M:Store`1.set_Value(`0)"),
                }, Lines(run));
            }

            public void ExplicitPropertyImplementation_IsRegisteredUnderTheInterfaceOnly()
            {
                VellumRun run = VellumRun.Of(@"
public interface IHold<X> { X Value { set; } }
public class Store<T> : IHold<T>
{
    public SaveSession Session;
    T IHold<T>.Value { set { Session.ToNode(value); } }
}");

                CheckEqual(new[] { Class0("M:IHold`1.set_Value(`0)") }, Lines(run));
            }

            public const string Reading = @"
public class Reading<T>
{
    public SaveSession Session;
    T stored;
    public int Count { get { Session.ToNode(stored); return 0; } set { } }
}
";

            public const string Writing = @"
public class Writing<T>
{
    public SaveSession Session;
    T stored;
    public int Count { get { return 0; } set { Session.ToNode(stored); } }
}
";

            public void WrapperReadingAGetterThatSaves_IsRegistered()
            {
                VellumRun run = VellumRun.Of(Reading + Writing + @"
public class Front { public int Run<U>(Reading<U> reading) { return reading.Count; } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Run``1(Reading{``0})", 0), Class0("M:Reading`1.get_Count"),
                    Class0("M:Writing`1.set_Count(System.Int32)"),
                }, Lines(run));
            }

            public void WrapperWritingAGetterThatSaves_IsNotRegistered()
            {
                VellumRun run = VellumRun.Of(Reading + @"
public class Front { public void Run<U>(Reading<U> reading) { reading.Count = 1; } }");

                CheckEqual(new[] { Class0("M:Reading`1.get_Count") }, Lines(run));
            }

            public void WrapperWritingASetterThatSaves_IsRegistered()
            {
                VellumRun run = VellumRun.Of(Writing + @"
public class Front { public void Run<U>(Writing<U> writing) { writing.Count = 1; } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Run``1(Writing{``0})", 0), Class0("M:Writing`1.set_Count(System.Int32)"),
                }, Lines(run));
            }

            public void WrapperReadingASetterThatSaves_IsNotRegistered()
            {
                VellumRun run = VellumRun.Of(Writing + @"
public class Front { public int Run<U>(Writing<U> writing) { return writing.Count; } }");

                CheckEqual(new[] { Class0("M:Writing`1.set_Count(System.Int32)") }, Lines(run));
            }

            public void WrapperUpdatingAPropertyInPlace_IsRegisteredByEitherAccessor()
            {
                VellumRun run = VellumRun.Of(Reading + Writing + @"
public class Front
{
    public void Compound<U>(Reading<U> reading) { reading.Count += 1; }
    public void Increment<U>(Writing<U> writing) { writing.Count++; }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Compound``1(Reading{``0})", 0),
                    Attribute("M:Front.Increment``1(Writing{``0})", 0), Class0("M:Reading`1.get_Count"),
                    Class0("M:Writing`1.set_Count(System.Int32)"),
                }, Lines(run));
            }

            public void WrapperSettingAnIndexerOrSubscribingToAnEvent_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    T stored;
    public int this[int index] { set { Session.ToNode(stored); } }
    public event System.Action Changed { add { Session.ToNode(stored); } remove { } }
}
public class Front
{
    public void Index<U>(Store<U> store) { store[0] = 1; }
    public void Subscribe<U>(Store<U> store) { store.Changed += () => { }; }
    public void Unsubscribe<U>(Store<U> store) { store.Changed -= () => { }; }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Index``1(Store{``0})", 0), Attribute("M:Front.Subscribe``1(Store{``0})", 0),
                    Class0("M:Store`1.add_Changed(System.Action)"),
                    Class0("M:Store`1.set_Item(System.Int32,System.Int32)"),
                }, Lines(run));
            }

            public void WrapperThroughAnInterfacesProperty_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public interface IHold<X> { X Value { set; } }
public class Store<T> : IHold<T>
{
    public SaveSession Session;
    public T Value { set { Session.ToNode(value); } }
}
public class Front { public void Run<U>(IHold<U> hold, U item) { hold.Value = item; } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Run``1(IHold{``0},``0)", 0), Class0("M:IHold`1.set_Value(`0)"),
                    Class0("M:Store`1.set_Value(`0)"),
                }, Lines(run));
            }

            public void PropertyWrappingAnotherProperty_IsRegisteredByItsClassParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public SaveSession Session;
    public T Value { set { Session.ToNode(value); } }
}
public class Front<U>
{
    Store<U> store = new Store<U>();
    public U Value { set { store.Value = value; } }
}");

                CheckEqual(new[] { Class0("M:Front`1.set_Value(`0)"), Class0("M:Store`1.set_Value(`0)") }, Lines(run));
            }

            public void StaticPropertyOfAGenericClass_IsRegisteredAndWrapped()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<T>
{
    public static SaveSession Session;
    public static T Shared { set { Session.ToNode(value); } }
}
public class Front { public void Run<U>(U item) { Store<U>.Shared = item; } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Run``1(``0)", 0), Class0("M:Store`1.set_Shared(`0)"),
                }, Lines(run));
            }

            public const string Setting = @"
public class Setting<T>
{
    public SaveSession Session;
    public T Value { get { return default(T); } set { Session.ToNode(value); } }
    public T this[int index] { set { Session.ToNode(value); } }
    public event System.Action<T> Changed { add { Session.ToNode(default(T)); } remove { } }
}
";

            public static VellumRun Use(string body)
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Setting);

                return VellumRun.Of(library, "public class User { public void Run(Setting<" + Bag + "> setting, " +
                    Bag + " bag) { " + body + " } }");
            }

            public void SettingAPropertyToAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:setting.Value" }, Use("setting.Value = bag;").Compiled);
            }

            public void ReadingASetterThatSaves_IsQuiet()
            {
                CheckEqual(0, Use(Bag + " x = setting.Value;").Compiled.Count);
            }

            public void SettingAnIndexerToAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:setting[0]" }, Use("setting[0] = bag;").Compiled);
            }

            public void SubscribingToAnEventOfAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:setting.Changed += item => { }" },
                    Use("setting.Changed += item => { };").Compiled);
            }

            public void UnsubscribingFromAnEvent_IsQuietWhenOnlyTheAddingAccessorSaves()
            {
                CheckEqual(0, Use("setting.Changed -= item => { };").Compiled.Count);
            }

            public void SettingAPropertyToASaveableType_IsQuiet()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Setting);

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Setting<int> setting) " +
                    "{ setting.Value = 1; setting[0] = 2; setting.Changed += item => { }; } }");

                CheckEqual(0, run.Compiled.Count);
            }

            public void SettingAnOverriddenProperty_IsReportedByTheBaseRegistration()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public class Base<T>
{
    public SaveSession Session;
    public virtual T Value { set { Session.ToNode(value); } }
}");

                VellumRun run = VellumRun.Of(library, "public class Derived : Base<" + Bag + "> " +
                    "{ public override " + Bag + " Value { set { } } }\n" +
                    "public class User { public void Run(Derived derived, " + Bag + " bag) { derived.Value = bag; } }");

                CheckEqual(new[] { "VEL0004:derived.Value" }, run.Compiled);
            }

            public void SettingAPropertyThroughAnInterface_IsReported()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", @"
public interface IHold<X> { X Value { set; } }
public class Store<T> : IHold<T>
{
    public SaveSession Session;
    public T Value { set { Session.ToNode(value); } }
}");

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(IHold<" + Bag +
                    "> hold, " + Bag + " bag) { hold.Value = bag; } }");

                CheckEqual(new[] { "VEL0004:hold.Value" }, run.Compiled);
            }

            public void WrapperPropertyInAReference_IsCheckedForSaveableTypes()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Setting +
                    "public class Front<U> { public Setting<U> Inner = new Setting<U>(); " +
                    "public U Value { set { Inner.Value = value; } } }");

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Front<" + Bag +
                    "> front, " + Bag + " bag) { front.Value = bag; } }");

                CheckEqual(new[] { "VEL0004:front.Value" }, run.Compiled);
            }
        }

        public class ConstructorCalledTests : TestFixture
        {
            public void ObjectCreation_IsItsConstructor()
            {
                CheckEqual(new[] { ".ctor" }, CalledTests.Names("var other = new Store<U>();"));
            }

            public void TargetTypedCreation_IsItsConstructor()
            {
                CheckEqual(new[] { ".ctor" }, CalledTests.Names("Store<U> other = new();"));
            }

            public void CreationOfAnAnonymousType_IsNone()
            {
                CheckEqual(0, CalledTests.Names("var other = new { Count = 1 };").Length);
            }

            public void CreationHasNoReceiver()
            {
                CheckEqual(new[] { "none" }, ReceiverOfTests.Receivers("var other = new Store<U>();"));
            }
        }

        public class ConstructorMightHoldEdgesTests : TestFixture
        {
            public static List<bool> Might<NodeType>(string source) where NodeType : SyntaxNode
            {
                return CSharpSyntaxTree.ParseText(source).GetRoot().DescendantNodes().OfType<NodeType>()
                    .Select(node => SaveMethods.MightHoldEdges(node, CancellationToken.None)).ToList();
            }

            public void ConstructorOfAGenericClass_Might()
            {
                CheckEqual(new[] { true }, Might<ConstructorDeclarationSyntax>(
                    "class C<T> { C(T value) { Save(value); } }"));
            }

            public void ConstructorNamingOnlyInItsInitializer_Might()
            {
                CheckEqual(new[] { true }, Might<ConstructorDeclarationSyntax>(
                    "class C<T> : B<T> { C(T value) : base(value) { } }"));
            }

            public void ConstructorOfAPlainClass_Mightnt()
            {
                CheckEqual(new[] { false }, Might<ConstructorDeclarationSyntax>(
                    "class C { C(int value) { Save(value); } }"));
            }

            public void ConstructorNamingNothing_Mightnt()
            {
                CheckEqual(new[] { false }, Might<ConstructorDeclarationSyntax>("class C<T> { C(T value) { } }"));
            }

            public void StaticConstructor_Mightnt()
            {
                CheckEqual(new[] { false }, Might<ConstructorDeclarationSyntax>(
                    "class C<T> { static C() { Save(1); } }"));
            }

            public void InitializerOfAnInstanceFieldOrProperty_Might()
            {
                CheckEqual(new[] { true }, Might<EqualsValueClauseSyntax>("class C<T> { int x = Save(1); }"));
                CheckEqual(new[] { true }, Might<EqualsValueClauseSyntax>("class C<T> { int P { get; } = Save(1); }"));
                CheckEqual(new[] { true, true }, Might<EqualsValueClauseSyntax>(
                    "class C<T> { int x = Save(1), y = Save(2); }"));
            }

            public void InitializerOfAStaticFieldOrProperty_Mightnt()
            {
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>("class C<T> { static int x = Save(1); }"));
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>(
                    "class C<T> { static int P { get; } = Save(1); }"));
            }

            public void InitializerOfAConstantOrALocalOrAParameter_Mightnt()
            {
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>("class C<T> { const int x = 1; }"));
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>(
                    "class C<T> { void M() { int x = Save(1); } }"));
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>("class C<T> { void M(int x = 1) { } }"));
            }

            public void InitializerInAPlainClass_Mightnt()
            {
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>("class C { int x = Save(1); }"));
            }

            public void InitializerNamingNothing_Mightnt()
            {
                CheckEqual(new[] { false }, Might<EqualsValueClauseSyntax>("class C<T> { int x = 1; }"));
            }

            public void TypeWithAPrimaryConstructorHandingArgumentsToItsBase_Might()
            {
                CheckEqual(new[] { true }, Might<ClassDeclarationSyntax>("class C<T>(T value) : B<T>(value) { }"));
            }

            public void TypeWithAPrimaryConstructorAndNoBaseArguments_Mightnt()
            {
                CheckEqual(new[] { false }, Might<ClassDeclarationSyntax>("class C<T>(T value) : B<T> { }"));
                CheckEqual(new[] { false }, Might<ClassDeclarationSyntax>("class C<T>(T value) { }"));
            }

            public void TypeWithNoPrimaryConstructor_Mightnt()
            {
                CheckEqual(new[] { false }, Might<ClassDeclarationSyntax>("class C<T> : B<T> { }"));
            }

            public void PrimaryConstructorOfAPlainType_Mightnt()
            {
                CheckEqual(new[] { false }, Might<ClassDeclarationSyntax>("class C(int value) : B(value) { }"));
            }

            public void PrimaryConstructorOfARecord_Might()
            {
                CheckEqual(new[] { true }, Might<RecordDeclarationSyntax>("record R<T>(T value) : B<T>(value);"));
            }

            public void PrimaryConstructorOfAStruct_Mightnt()
            {
                CheckEqual(new[] { false }, Might<StructDeclarationSyntax>("struct S<T>(T value) { int x = 1; }"));
            }
        }

        public class ConstructorEdgesTests : TestFixture
        {
            public const string Holder = "public class Holder<T> { public static SaveSession Session; ";

            public static readonly string Saves = " => " + ToNodeId + " : " + EdgesOfTests.ClassMarker0;

            /// <summary>
            /// Returns the edges of the last node of the kind in <paramref name="source"/>.
            /// </summary>
            public static List<string> Of<NodeType>(string source) where NodeType : SyntaxNode
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SyntaxNode node = tree.GetRoot().DescendantNodes().OfType<NodeType>().Last();

                return SaveMethods.EdgesOfMember(compilation.GetSemanticModel(tree), node, CancellationToken.None)
                    .Select(EdgesOfMemberTests.Describe).ToList();
            }

            public void Constructor_HandsOnTheClassParameter()
            {
                CheckEqual(new[] { "M:Holder`1.#ctor(`0)" + Saves }, Of<ConstructorDeclarationSyntax>(
                    Holder + "public Holder(T value) { Session.ToNode(value); } }"));
            }

            public void BaseInitializer_HandsOnToTheBaseConstructor()
            {
                CheckEqual(new[] { "M:Derived`1.#ctor(`0) => M:Base`1.#ctor(`0) : " }, Of<ConstructorDeclarationSyntax>(
                    "public class Base<T> { public Base(T value) { } }\n" +
                    "public class Derived<T> : Base<T> { public Derived(T value) : base(value) { } }"));
            }

            public void ThisInitializer_HandsOnToTheOtherConstructor()
            {
                CheckEqual(new[] { "M:Pair`1.#ctor => M:Pair`1.#ctor(`0) : " }, Of<ConstructorDeclarationSyntax>(
                    "public class Pair<T> { public Pair(T value) { } public Pair() : this(default(T)) { } }"));
            }

            public void ConstructorOfAPlainClass_HandsOnNothing()
            {
                CheckEqual(0, Of<ConstructorDeclarationSyntax>(
                    "public class Plain { public static SaveSession Session; public Plain(int value) " +
                    "{ Session.ToNode(value); } }").Count);
            }

            public void FieldInitializer_BelongsToEveryInstanceConstructor()
            {
                CheckEqual(new[] { "M:Holder`1.#ctor" + Saves, "M:Holder`1.#ctor(System.Int32)" + Saves },
                    Of<EqualsValueClauseSyntax>(Holder + "SaveNode node = Session.ToNode(default(T)); " +
                        "public Holder() { } public Holder(int size) { } }"));
            }

            public void FieldInitializerOfAClassWithNoConstructor_BelongsToTheImplicitOne()
            {
                CheckEqual(new[] { "M:Holder`1.#ctor" + Saves }, Of<EqualsValueClauseSyntax>(
                    Holder + "SaveNode node = Session.ToNode(default(T)); }"));
            }

            public void PropertyInitializer_BelongsToTheConstructors()
            {
                CheckEqual(new[] { "M:Holder`1.#ctor" + Saves }, Of<EqualsValueClauseSyntax>(
                    Holder + "public SaveNode Node { get; } = Session.ToNode(default(T)); }"));
            }

            public void StaticFieldInitializer_HasNoEdges()
            {
                CheckEqual(0, Of<EqualsValueClauseSyntax>(
                    Holder + "static SaveNode node = Session.ToNode(default(T)); }").Count);
            }

            public void LocalVariableInitializer_HasNoEdges()
            {
                CheckEqual(0, Of<EqualsValueClauseSyntax>(
                    Holder + "public void M() { SaveNode node = Session.ToNode(default(T)); } }").Count);
            }

            public void RecordInitializer_SkipsTheCopyConstructor()
            {
                CheckEqual(new[] { "M:Rec`1.#ctor(`0)" + Saves }, Of<EqualsValueClauseSyntax>(
                    "public record Rec<T>(T Item) { static SaveSession Session; " +
                    "SaveNode node = Session.ToNode(default(T)); }"));
            }

            public void PrimaryConstructor_HandsOnToTheBaseConstructor()
            {
                CheckEqual(new[] { "M:Derived`1.#ctor(`0) => M:Base`1.#ctor(`0) : " }, Of<ClassDeclarationSyntax>(
                    "public class Base<T> { public Base(T value) { } }\n" +
                    "public class Derived<T>(T value) : Base<T>(value) { }"));
            }

            public void InitializerOfAPrimaryConstructorType_BelongsToThePrimaryConstructor()
            {
                CheckEqual(new[] { "M:Primary`1.#ctor(`0)" + Saves }, Of<EqualsValueClauseSyntax>(
                    "public class Primary<T>(T value) { static SaveSession Session; " +
                    "SaveNode node = Session.ToNode(value); }"));
            }

            public void CreationInABody_HandsOnToTheConstructor()
            {
                CheckEqual(new[] { "M:Use.M``1(``0) => M:Holder`1.#ctor(`0) : " }, Of<MethodDeclarationSyntax>(
                    Holder + "public Holder(T value) { } }\n" +
                    "public class Use { public void M<U>(U value) { new Holder<U>(value); } }"));
            }

            public void CreationOfTheImplicitConstructor_HandsOnToIt()
            {
                CheckEqual(new[] { "M:Use.M``1(``0) => M:Holder`1.#ctor : " }, Of<MethodDeclarationSyntax>(
                    "public class Holder<T> { }\n" +
                    "public class Use { public void M<U>(U value) { new Holder<U>(); } }"));
            }

            public void CreationOfAClosedType_HandsOnNothing()
            {
                CheckEqual(0, Of<MethodDeclarationSyntax>(
                    "public class Holder<T> { }\n" +
                    "public class Use { public void M<U>(U value) { new Holder<int>(); } }").Count);
            }

            public void CreationOfAnAnonymousType_HandsOnNothing()
            {
                CheckEqual(0, Of<MethodDeclarationSyntax>(
                    "public class Use { public void M<U>(U value) { var anonymous = new { value }; } }").Count);
            }
        }

        public class ConstructorPipelineTests : TestFixture
        {
            public static string Class0(string id)
            {
                return AccessorPipelineTests.Class0(id);
            }

            public void ConstructorOfAGenericClass_IsRegisteredByItsClassParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Class0("M:Holder`1.#ctor(`0)") }, Lines(run));
            }

            public void InitializerOfAClassWithNoConstructor_RegistersTheImplicitOne()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    static SaveSession Session;
    SaveNode node = Session.ToNode(default(T));
}");

                CheckEqual(new[] { Class0("M:Holder`1.#ctor") }, Lines(run));
            }

            public void InitializerOfAClassWithConstructors_RegistersEachOfThem()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    static SaveSession Session;
    SaveNode node = Session.ToNode(default(T));
    public Holder() { }
    public Holder(int size) { }
    static Holder() { }
}");

                CheckEqual(new[] { Class0("M:Holder`1.#ctor"), Class0("M:Holder`1.#ctor(System.Int32)") }, Lines(run));
            }

            public void StaticInitializer_RegistersNothing()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    static SaveSession Session;
    static SaveNode node = Session.ToNode(default(T));
}");

                CheckEqual(0, Lines(run).Length);
            }

            public void PrimaryConstructorWithAnInitializer_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>(T value)
{
    static SaveSession Session;
    SaveNode node = Session.ToNode(value);
}");

                CheckEqual(new[] { Class0("M:Holder`1.#ctor(`0)") }, Lines(run));
            }

            public void RecordInitializer_RegistersThePrimaryConstructorOnly()
            {
                VellumRun run = VellumRun.Of(@"
public record Rec<T>(T Item)
{
    static SaveSession Session;
    SaveNode node = Session.ToNode(default(T));
}");

                CheckEqual(new[] { Class0("M:Rec`1.#ctor(`0)") }, Lines(run));
            }

            public void ConstructorHandingItsParameterToABaseConstructor_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}
public class Derived<U> : Holder<U> { public Derived(U value) : base(value) { } }");

                CheckEqual(new[] { Class0("M:Derived`1.#ctor(`0)"), Class0("M:Holder`1.#ctor(`0)") }, Lines(run));
            }

            public void ConstructorHandingAWrappedParameterToABaseConstructor_IsRegisteredByTheWrapper()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}
public class Derived<U> : Holder<List<U>> { public Derived(List<U> value) : base(value) { } }");

                CheckEqual(new[]
                {
                    PipelineTests.ClassAttribute("M:Derived`1.#ctor(System.Collections.Generic.List{`0})",
                        "typeof(global::System.Collections.Generic.List<global::Vellum.SaveClassParameter<" +
                        "global::Vellum.SaveMethodParameter0>>)"),
                    Class0("M:Holder`1.#ctor(`0)"),
                }, Lines(run));
            }

            public void PrimaryConstructorHandingItsParameterToABase_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}
public class Derived<U>(U value) : Holder<U>(value) { }");

                CheckEqual(new[] { Class0("M:Derived`1.#ctor(`0)"), Class0("M:Holder`1.#ctor(`0)") }, Lines(run));
            }

            public void WrapperCreatingTheClass_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}
public class Front { public Holder<U> Make<U>(U value) { return new Holder<U>(value); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Make``1(``0)", 0), Class0("M:Holder`1.#ctor(`0)"),
                }, Lines(run));
            }

            public void WrapperCreatingTheImplicitConstructor_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    static SaveSession Session;
    SaveNode node = Session.ToNode(default(T));
}
public class Front { public Holder<U> Make<U>() { return new Holder<U>(); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Make``1", 0), Class0("M:Holder`1.#ctor"),
                }, Lines(run));
            }

            public void WrapperUsingATargetTypedCreation_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}
public class Front { public Holder<U> Make<U>(U value) { Holder<U> holder = new(value); return holder; } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Make``1(``0)", 0), Class0("M:Holder`1.#ctor(`0)"),
                }, Lines(run));
            }

            public const string Holding = @"
public class Holder<T>
{
    public SaveSession Session;
    public Holder(T value) { Session.ToNode(value); }
}
public class Initialized<T>
{
    static SaveSession Session;
    SaveNode node = Session.ToNode(default(T));
}
";

            public static VellumRun Use(string declarations)
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Holding);

                return VellumRun.Of(library, declarations);
            }

            public const string Bag = AccessorPipelineTests.Bag;

            public void CreatingAClassWithAnUnsaveableArgument_IsReported()
            {
                VellumRun run = Use("public class User { public void Run(" + Bag + " bag) " +
                    "{ new Holder<" + Bag + ">(bag); } }");

                CheckEqual(new[] { "VEL0004:new Holder<" + Bag + ">(bag)" }, run.Compiled);
            }

            public void CreatingAClassWithASaveableArgument_IsQuiet()
            {
                CheckEqual(0, Use("public class User { public void Run() { new Holder<int>(1); } }").Compiled.Count);
            }

            public void CreatingWithATargetTypedCreation_IsReported()
            {
                VellumRun run = Use("public class User { public void Run(" + Bag + " bag) " +
                    "{ Holder<" + Bag + "> holder = new(bag); } }");

                CheckEqual(new[] { "VEL0004:new(bag)" }, run.Compiled);
            }

            public void CreatingAClassWhoseInitializerSaves_IsReported()
            {
                VellumRun run = Use("public class User { public void Run() { new Initialized<" + Bag + ">(); } }");

                CheckEqual(new[] { "VEL0004:new Initialized<" + Bag + ">()" }, run.Compiled);
            }

            public void BaseInitializerOfAnUnsaveableArgument_IsReported()
            {
                VellumRun run = Use("public class Mine : Holder<" + Bag + "> { public Mine(" + Bag +
                    " bag) : base(bag) { } }");

                CheckEqual(new[] { "VEL0004:: base(bag)" }, run.Compiled);
            }

            public void PrimaryConstructorBaseCallOfAnUnsaveableArgument_IsReported()
            {
                VellumRun run = Use("public class Mine(" + Bag + " bag) : Holder<" + Bag + ">(bag) { }");

                CheckEqual(new[] { "VEL0004:Holder<" + Bag + ">(bag)" }, run.Compiled);
            }

            public void CreatingAWrappingClass_IsReportedAtTheCreation()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Holding +
                    "public class Front<U> { public Holder<U> Inner; " +
                    "public Front(U value) { Inner = new Holder<U>(value); } }");

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(" + Bag +
                    " bag) { new Front<" + Bag + ">(bag); } }");

                CheckEqual(new[] { "VEL0004:new Front<" + Bag + ">(bag)" }, run.Compiled);
            }
        }

        public class UseKindsTests : TestFixture
        {
            public void ListsEveryKindOfOperationThatRunsAMethod()
            {
                CheckEqual(new[]
                {
                    "Binary", "CompoundAssignment", "Conversion", "DeconstructionAssignment", "Decrement",
                    "EventAssignment", "Increment", "Invocation", "Loop", "MethodReference", "ObjectCreation",
                    "PropertyReference", "Unary",
                }, SaveMethods.UseKinds.Select(kind => kind.ToString()).OrderBy(
                    name => name, System.StringComparer.Ordinal).ToArray());
            }
        }

        public class OtherUsesCalledTests : TestFixture
        {
            public const string Vec = @"
public class Vec<T> : System.Collections.Generic.IEnumerable<int>
{
    public static Vec<T> operator +(Vec<T> first, Vec<T> second) { return first; }
    public static Vec<T> operator -(Vec<T> value) { return value; }
    public static Vec<T> operator ++(Vec<T> value) { return value; }
    public static implicit operator int(Vec<T> value) { return 0; }
    public static explicit operator Vec<T>(int value) { return null; }
    public void Add(int item) { }
    public void Deconstruct(out int first, out int second) { first = 0; second = 0; }
    public System.Collections.Generic.IEnumerator<int> GetEnumerator() { yield break; }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}
public class Disposing<T> : System.IDisposable { public void Dispose() { } }
";

            public static string[] Names(string usage)
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", Vec +
                    "public class Use { public static void Helper<V>(V value) { } " +
                    "public void M<U>(Vec<U> first, Vec<U> second) { " + usage + " } }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                SyntaxNode method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>()
                    .Single(declaration => declaration.Identifier.ValueText == "M");
                IOperation body = compilation.GetSemanticModel(tree).GetOperation(method);

                return body.DescendantsAndSelf().SelectMany(operation => SaveMethods.Called(operation))
                    .Select(called => called.Name).ToArray();
            }

            public void BinaryOperator_IsItsMethod()
            {
                CheckEqual(new[] { "op_Addition" }, Names("var sum = first + second;"));
            }

            public void UnaryOperator_IsItsMethod()
            {
                CheckEqual(new[] { "op_UnaryNegation" }, Names("var negated = -first;"));
            }

            public void CompoundAssignmentOperator_IsItsMethod()
            {
                CheckEqual(new[] { "op_Addition" }, Names("first += second;"));
            }

            public void IncrementOperator_IsItsMethod()
            {
                CheckEqual(new[] { "op_Increment" }, Names("first++;"));
            }

            public void ImplicitAndExplicitConversions_AreTheirMethods()
            {
                CheckEqual(new[] { "op_Implicit" }, Names("int number = first;"));
                CheckEqual(new[] { "op_Explicit" }, Names("var made = (Vec<U>)1;"));
            }

            public void BuiltInOperatorsAndConversions_CallNothing()
            {
                CheckEqual(new string[0], Names("int sum = 1 + 2;"));
                CheckEqual(new string[0], Names("int sum = 1; long wide = sum;"));
                CheckEqual(new string[0], Names("int sum = 1; sum++;"));
                CheckEqual(new string[0], Names("int sum = 1; sum += 3;"));
                CheckEqual(new string[0], Names("int sum = 1; var negated = -sum;"));
            }

            public void MethodGroup_IsItsMethod()
            {
                CheckEqual(new[] { "Add" }, Names("System.Action<int> add = first.Add;"));
                CheckEqual(new[] { "Helper" }, Names("System.Action<U> help = Helper;"));
            }

            public void Foreach_IsItsIteratorMethods()
            {
                CheckEqual(new[] { "GetEnumerator", "MoveNext", "get_Current", "Dispose" },
                    Names("foreach (int item in first) { }"));
            }

            public void ForeachOverAnArray_CallsNothing()
            {
                CheckEqual(new string[0], Names("foreach (int item in new int[1]) { }"));
            }

            public void CollectionInitializer_IsTheAddMethods()
            {
                CheckEqual(new[] { ".ctor", "Add", "Add" }, Names("var made = new Vec<U> { 1, 2 };"));
            }

            public void Deconstruction_IsTheDeconstructMethod()
            {
                CheckEqual(new[] { "Deconstruct" }, Names("int one; int two; (one, two) = first;"));
                CheckEqual(new[] { "Deconstruct" }, Names("var (one, two) = first;"));
            }

            public void DeconstructionIntoPropertiesOfAGenericClass_IsTheSetters()
            {
                CheckEqual(new[] { "set_Count", "set_Count" },
                    CalledTests.Names("(store.Count, store.Count) = (1, 2);"));
                CheckEqual(new[] { "set_Count", "set_Name" },
                    CalledTests.Names("(store.Count, store.Name) = (1, \"\");"));
            }

            public void NestedDeconstructionIntoProperties_IsTheSetters()
            {
                CheckEqual(new[] { "set_Count", "set_Name", "set_Count" },
                    CalledTests.Names("((store.Count, store.Name), store.Count) = ((1, \"\"), 2);"));
            }

            public void TupleOnTheRightOfAnAssignment_ReadsItsProperties()
            {
                CheckEqual(new[] { "get_Count", "get_Name" },
                    CalledTests.Names("var pair = (store.Count, store.Name);"));
            }

            public void PropertyPattern_ReadsTheProperty()
            {
                CheckEqual(new[] { "get_Count" }, CalledTests.Names("bool one = store is { Count: 1 };"));
            }

            public void Await_CallsNothing()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs",
                    "public class Use { public async System.Threading.Tasks.Task M(System.Threading.Tasks.Task task) " +
                    "{ await task; } }"));
                SyntaxTree tree = compilation.SyntaxTrees[0];
                IOperation body = compilation.GetSemanticModel(tree).GetOperation(
                    tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single());

                CheckEqual(0, body.DescendantsAndSelf().SelectMany(operation => SaveMethods.Called(operation)).Count());
            }

            public void Using_CallsOnlyTheConstructor()
            {
                CheckEqual(new[] { ".ctor" }, Names("using (var scope = new Disposing<U>()) { }"));
            }
        }

        public class OperatorEdgesTests : TestFixture
        {
            public const string Holder = "public class Holder<T> { public static SaveSession Session; ";

            public void OperatorOfAGenericClass_HandsOnTheClassParameter()
            {
                CheckEqual(new[]
                {
                    "M:Holder`1.op_Addition(Holder{`0},`0)" + ConstructorEdgesTests.Saves,
                }, ConstructorEdgesTests.Of<OperatorDeclarationSyntax>(Holder +
                    "public static Holder<T> operator +(Holder<T> first, T second) " +
                    "{ Session.ToNode(second); return first; } }"));
            }

            public void ConversionOfAGenericClass_HandsOnTheClassParameter()
            {
                CheckEqual(new[]
                {
                    "M:Holder`1.op_Implicit(`0)~Holder{`0}" + ConstructorEdgesTests.Saves,
                }, ConstructorEdgesTests.Of<ConversionOperatorDeclarationSyntax>(Holder +
                    "public static implicit operator Holder<T>(T value) { Session.ToNode(value); return null; } }"));
            }

            public void OperatorDeclarations_Might()
            {
                CheckEqual(new[] { true }, ConstructorMightHoldEdgesTests.Might<OperatorDeclarationSyntax>(
                    "class C<T> { static C<T> operator +(C<T> a, C<T> b) { return Save(a); } }"));
                CheckEqual(new[] { true }, ConstructorMightHoldEdgesTests.Might<ConversionOperatorDeclarationSyntax>(
                    "class C<T> { static implicit operator C<T>(T a) { return Save(a); } }"));
                CheckEqual(new[] { false }, ConstructorMightHoldEdgesTests.Might<OperatorDeclarationSyntax>(
                    "class C { static C operator +(C a, C b) { return Save(a); } }"));
            }
        }

        public class OtherUsesPipelineTests : TestFixture
        {
            public static string Class0(string id)
            {
                return AccessorPipelineTests.Class0(id);
            }

            public const string Saving = @"
public class Holder<T>
{
    public static SaveSession Session;
    public static Holder<T> operator +(Holder<T> first, T second) { Session.ToNode(second); return first; }
    public static Holder<T> operator ++(Holder<T> value) { Session.ToNode(default(T)); return value; }
    public static implicit operator Holder<T>(T value) { Session.ToNode(value); return null; }
    public void Put(T value) { Session.ToNode(value); }
    public void Deconstruct(out T first, out T second)
    {
        first = default(T);
        second = default(T);
        Session.ToNode(first);
    }
    public System.Collections.Generic.IEnumerator<T> GetEnumerator() { Session.ToNode(default(T)); yield break; }
}
";

            public static string[] Registered(string front)
            {
                return Lines(VellumRun.Of(Saving + front)).Where(line => line.Contains("Front.")).ToArray();
            }

            public void OperatorsOfAGenericClass_AreRegistered()
            {
                CheckEqual(new[]
                {
                    Class0("M:Holder`1.op_Addition(Holder{`0},`0)"), Class0("M:Holder`1.op_Implicit(`0)~Holder{`0}"),
                    Class0("M:Holder`1.op_Increment(Holder{`0})"),
                }, Lines(VellumRun.Of(Saving)).Where(line => line.Contains("op_")).ToArray());
            }

            public void WrapperUsingABinaryOperator_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Add``1(Holder{``0},``0)", 0) }, Registered(
                    "public class Front { public Holder<U> Add<U>(Holder<U> first, U second) " +
                    "{ return first + second; } }"));
            }

            public void WrapperUsingACompoundOperator_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Add``1(Holder{``0},``0)", 0) }, Registered(
                    "public class Front { public void Add<U>(Holder<U> first, U second) { first += second; } }"));
            }

            public void WrapperUsingAnIncrement_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Bump``1(Holder{``0})", 0) }, Registered(
                    "public class Front { public void Bump<U>(Holder<U> value) { value++; } }"));
            }

            public void WrapperUsingAConversion_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Make``1(``0)", 0) }, Registered(
                    "public class Front { public Holder<U> Make<U>(U value) " +
                    "{ Holder<U> made = value; return made; } }"));
            }

            public void WrapperUsingAMethodGroup_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Pass``1(Holder{``0})", 0) }, Registered(
                    "public class Front { public System.Action<U> Pass<U>(Holder<U> holder) { return holder.Put; } }"));
            }

            public void WrapperUsingAGenericMethodGroup_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Store { public SaveSession Session; public void Put<T>(T value) { Session.ToNode(value); } }
public class Front { public System.Action<U> Pass<U>(Store store) { return store.Put; } }");

                CheckEqual(new[]
                {
                    Attribute("M:Front.Pass``1(Store)", 0), Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void WrapperUsingAForeach_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Walk``1(Holder{``0})", 0) }, Registered(
                    "public class Front { public void Walk<U>(Holder<U> holder) { foreach (U item in holder) { } } }"));
            }

            public void WrapperUsingADeconstruction_IsRegistered()
            {
                CheckEqual(new[] { Attribute("M:Front.Split``1(Holder{``0})", 0) }, Registered(
                    "public class Front { public void Split<U>(Holder<U> holder) " +
                    "{ U one; U two; (one, two) = holder; } }"));
            }

            public const string Library = @"
public class Holder<T>
{
    public static SaveSession Session;
    public static Holder<T> operator +(Holder<T> first, T second) { Session.ToNode(second); return first; }
    public static implicit operator Holder<T>(T value) { Session.ToNode(value); return null; }
    public void Put(T value) { Session.ToNode(value); }
    public void Deconstruct(out T first, out T second)
    {
        first = default(T);
        second = default(T);
        Session.ToNode(first);
    }
    public System.Collections.Generic.IEnumerator<T> GetEnumerator() { Session.ToNode(default(T)); yield break; }
}
";

            public static string[] Compiled(string usage)
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Library);

                string bag = ConstructorPipelineTests.Bag;

                return VellumRun.Of(library, "public class User { public void Run(Holder<" + bag + "> holder, " +
                    bag + " bag) { " + usage + " } }").Compiled.ToArray();
            }

            public void BinaryOperatorOnAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:holder + bag" }, Compiled("var sum = holder + bag;"));
            }

            public void ConversionOfAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:bag" }, Compiled("Holder<" + ConstructorPipelineTests.Bag +
                    "> made = bag;"));
            }

            public void MethodGroupOfAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:holder.Put" }, Compiled("System.Action<" + ConstructorPipelineTests.Bag +
                    "> put = holder.Put;"));
            }

            public void ForeachOverAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:foreach (var item in holder) { }" }, Compiled(
                    "foreach (var item in holder) { }"));
            }

            public void DeconstructionOfAnUnsaveableType_IsReported()
            {
                CheckEqual(new[] { "VEL0004:(one, two) = holder" }, Compiled(
                    ConstructorPipelineTests.Bag + " one; " + ConstructorPipelineTests.Bag + " two; " +
                    "(one, two) = holder;"));
            }

            public void SaveableUsesOfEveryKind_AreQuiet()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Library);

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Holder<int> holder) " +
                    "{ var sum = holder + 1; Holder<int> made = 1; System.Action<int> put = holder.Put; " +
                    "foreach (var item in holder) { } int one; int two; (one, two) = holder; } }");

                CheckEqual(0, run.Compiled.Count);
            }
        }

        public class OverridePipelineTests : TestFixture
        {
            public static string Class0(string id)
            {
                return AccessorPipelineTests.Class0(id);
            }

            public void OverrideOfAGenericMethod_IsRegisteredUnderTheBaseMethodToo()
            {
                VellumRun run = VellumRun.Of(@"
public class Base { public virtual void Put<T>(T value) { } }
public class Store : Base
{
    public SaveSession Session;
    public override void Put<T>(T value) { Session.ToNode(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[]
                {
                    Attribute("M:Base.Put``1(``0)", 0), Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void OverrideOfAnAbstractMethod_IsRegisteredUnderTheBaseMethod()
            {
                VellumRun run = VellumRun.Of(@"
public abstract class Base { public abstract void Put<T>(T value); }
public class Store : Base
{
    public SaveSession Session;
    public override void Put<T>(T value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Base.Put``1(``0)", 0), Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void OverrideThroughSeveralLevels_IsRegisteredUnderEachBase()
            {
                VellumRun run = VellumRun.Of(@"
public class Base { public virtual void Put<T>(T value) { } }
public class Middle : Base { public override void Put<T>(T value) { } }
public class Store : Middle
{
    public SaveSession Session;
    public override void Put<T>(T value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    Attribute("M:Base.Put``1(``0)", 0), Attribute("M:Middle.Put``1(``0)", 0),
                    Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public void OverrideThatSavesNothing_RegistersNothing()
            {
                VellumRun run = VellumRun.Of(@"
public class Base { public virtual void Put<T>(T value) { } }
public class Store : Base { public override void Put<T>(T value) { } }");

                CheckEqual(0, Lines(run).Length);
            }

            public void OverrideInAGenericClass_IsRegisteredUnderTheBaseByItsClassParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Base<T> { public virtual void Put(T value) { } }
public class Store<U> : Base<U>
{
    public SaveSession Session;
    public override void Put(U value) { Session.ToNode(value); }
}");

                CheckEqual(new[] { Class0("M:Base`1.Put(`0)"), Class0("M:Store`1.Put(`0)") }, Lines(run));
            }

            public void OverrideOfABaseThatReordersTheParameters_IsRenumberedForTheBase()
            {
                VellumRun run = VellumRun.Of(@"
public class Base<A, B> { public virtual void Put(B value) { } }
public class Store<X, Y> : Base<Y, X>
{
    public SaveSession Session;
    public override void Put(X value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    PipelineTests.ClassAttribute("M:Base`2.Put(`1)", PipelineTests.ClassStandIn1),
                    PipelineTests.ClassAttribute("M:Store`2.Put(`0)", PipelineTests.ClassStandIn0),
                }, Lines(run));
            }

            public void OverrideOfABaseThatHidesTheParameter_WarnsAndIsRegisteredOnlyForItself()
            {
                VellumRun run = VellumRun.Of(@"
public class Base<T> { public virtual void Put(T value) { } }
public class Store<U> : Base<List<U>>
{
    public SaveSession Session;
    public override void Put(List<U> value) { Session.ToNode(value); }
}");

                CheckEqual(new[]
                {
                    PipelineTests.ClassAttribute("M:Store`1.Put(System.Collections.Generic.List{`0})",
                        "typeof(global::System.Collections.Generic.List<global::Vellum.SaveClassParameter<" +
                        "global::Vellum.SaveMethodParameter0>>)"),
                }, Lines(run).Where(line => line.Contains("M:Store")).ToArray());
                CheckEqual(new[] { "VEL0016" }, run.Reported);
            }

            public void OverrideInAConverter_IsNotRegisteredUnderTheConvertersBase()
            {
                VellumRun run = VellumRun.Of(@"
public class ListBox<T> : SaveConverter<List<T>>
{
    public override SaveNode Write(List<T> value, SaveSession session) { session.ToNode(value[0]); return null; }
    public override List<T> Read(SaveNode node, SaveSession session) { return null; }
}");

                CheckEqual(new[]
                {
                    PipelineTests.ClassAttribute(
                        "M:ListBox`1.Write(System.Collections.Generic.List{`0},Vellum.SaveSession)",
                        PipelineTests.ClassStandIn0),
                }, Lines(run));
                CheckFalse(run.Reported.Contains("VEL0016"));
            }

            public void OverriddenProperty_IsRegisteredUnderTheBaseAccessor()
            {
                VellumRun run = VellumRun.Of(@"
public class Base<T> { public virtual T Value { set { } } }
public class Store<U> : Base<U>
{
    public SaveSession Session;
    public override U Value { set { Session.ToNode(value); } }
}");

                CheckEqual(new[] { Class0("M:Base`1.set_Value(`0)"), Class0("M:Store`1.set_Value(`0)") }, Lines(run));
            }

            public void WrapperCallingThroughTheBase_IsRegistered()
            {
                VellumRun run = VellumRun.Of(@"
public class Base { public virtual void Put<T>(T value) { } }
public class Store : Base
{
    public SaveSession Session;
    public override void Put<T>(T value) { Session.ToNode(value); }
}
public class Front { public void Save<U>(Base store, U value) { store.Put(value); } }");

                CheckEqual(new[]
                {
                    Attribute("M:Base.Put``1(``0)", 0), Attribute("M:Front.Save``1(Base,``0)", 0),
                    Attribute("M:Store.Put``1(``0)", 0),
                }, Lines(run));
            }

            public const string Library = @"
public abstract class Base<T> { public abstract void Put(T value); }
public class Store<T> : Base<T>
{
    public SaveSession Session;
    public override void Put(T value) { Session.ToNode(value); }
}
";

            public void CallThroughTheBaseClass_IsCheckedForSaveableTypes()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Library);

                VellumRun run = VellumRun.Of(library, "public class User { public void Run(Base<" +
                    ConstructorPipelineTests.Bag + "> store, " + ConstructorPipelineTests.Bag +
                    " bag) { store.Put(bag); } }");

                CheckEqual(new[] { "VEL0004:store.Put(bag)" }, run.Compiled);
            }

            public void CallThroughTheBaseClassWithASaveableType_IsQuiet()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Library);

                VellumRun run = VellumRun.Of(library,
                    "public class User { public void Run(Base<int> store) { store.Put(1); } }");

                CheckEqual(0, run.Compiled.Count);
            }

            public void CallThroughAnotherOverrideOfTheBase_IsCheckedToo()
            {
                MetadataReference library = VellumRun.CompileLibrary("Saver", Library);

                VellumRun run = VellumRun.Of(library, "public class Other : Base<" + ConstructorPipelineTests.Bag +
                    "> { public override void Put(" + ConstructorPipelineTests.Bag + " value) { } }\n" +
                    "public class User { public void Run(Base<" + ConstructorPipelineTests.Bag + "> other, " +
                    ConstructorPipelineTests.Bag + " bag) { other.Put(bag); } }");

                CheckEqual(new[] { "VEL0004:other.Put(bag)" }, run.Compiled);
            }
        }

        public class FindTests : TestFixture
        {
            public void ImplicitImplementation_NamesTheClassAndTheInterface()
            {
                VellumRun run = VellumRun.Of(@"
public interface IStore { void Put<T>(T value); }
public class Store : IStore
{
    public SaveSession Session;
    public void Put<T>(T value) { Session.ToNode(value, typeof(T)); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(Header + Attribute("M:IStore.Put``1(``0)", 0) + "\r\n" +
                    Attribute("M:Store.Put``1(``0)", 0) + "\r\n", run.SaveMethodsFile);
            }

            public void ExplicitImplementation_NamesOnlyTheInterface()
            {
                VellumRun run = VellumRun.Of(@"
public interface IStore { void Put<T>(T value); }
public class Store : IStore
{
    public SaveSession Session;
    void IStore.Put<T>(T value) { Session.ToNode(value, typeof(T)); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:IStore.Put``1(``0)", 0) }, Lines(run));
            }

            public void TypedToNode_NamesTheMethod()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Put<T>(T value) { Session.ToNode(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:Store.Put``1(``0)", 0) }, Lines(run));
            }

            public void TypedToNodeWithTheTypeArgumentSpelled_NamesTheMethod()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Pair<TKey, T>(TKey key, T value) { Session.ToNode<T>(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:Store.Pair``2(``0,``1)", 1) }, Lines(run));
            }

            public void TypedToNodeOfAnotherType_NamesNothing()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Concrete<T>(T value) { Session.ToNode(5); Session.ToNode<string>(""text""); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual("", run.SaveMethodsFile);
            }

            public void TypedToNodeOfTheClassParameter_NamesTheMethodByThatParameter()
            {
                VellumRun run = VellumRun.Of(@"
public class Store<TValue>
{
    public SaveSession Session;
    public void Concrete(TValue value) { Session.ToNode(5); }
    public void OfTheClass(TValue value) { Session.ToNode(value); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[]
                {
                    "[assembly: global::Vellum.RegisterSaveMethod(\"M:Store`1.OfTheClass(`0)\", " +
                        "typeof(global::Vellum.SaveClassParameter<global::Vellum.SaveMethodParameter0>))]",
                }, Lines(run));
            }

            public void TypedFromNode_NamesTheMethod()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public T Read<T>(SaveNode node) { return Session.FromNode<T>(node); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:Store.Read``1(Vellum.SaveNode)", 0) }, Lines(run));
            }

            public void SavedValue_SavesToo()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public void Put<T>(T value) { SavedValue.ToNode(value, typeof(T)); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:Store.Put``1(``0)", 0) }, Lines(run));
            }

            public void TypeParameter_IsNamedByItsPosition()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Pair<TKey, T>(TKey key, T value) { Session.ToNode(value, typeof(T)); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:Store.Pair``2(``0,``1)", 1) }, Lines(run));
            }

            public void GenericAndNestedTypes_AreNamedByTheirIds()
            {
                VellumRun run = VellumRun.Of(@"
namespace Saving
{
    public interface IKeyed<TKey> { void Put<T>(TKey key, T value); }
    public class Outer<X, Y>
    {
        public class Store : IKeyed<int>
        {
            public SaveSession Session;
            public void Put<T>(int key, T value) { Session.ToNode(value, typeof(T)); }
        }
    }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[]
                {
                    Attribute("M:Saving.IKeyed`1.Put``1(`0,``0)", 0),
                    Attribute("M:Saving.Outer`2.Store.Put``1(System.Int32,``0)", 0),
                }, Lines(run));
            }

            public void MethodSavingTwice_IsNamedOnce()
            {
                VellumRun run = VellumRun.Of(@"
public class Store
{
    public SaveSession Session;
    public void Put<T>(T value) { Session.ToNode(value, typeof(T)); Session.ToNode(value, typeof(T)); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual(new[] { Attribute("M:Store.Put``1(``0)", 0) }, Lines(run));
            }

            public void TypeAnAssemblyAttributeCantSee_IsNotNamed()
            {
                VellumRun run = VellumRun.Of(@"
public class Outer
{
    private class Store
    {
        public void Put<T>(SaveSession session, T value) { session.ToNode(value, typeof(T)); }
    }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual("", run.SaveMethodsFile);
            }

            public void OtherSaves_NameNothing()
            {
                VellumRun run = VellumRun.Of(@"
public class Own { public SaveNode ToNode(object value, System.Type type) { return SaveNode.Null; } }
public class Store<TValue>
{
    public SaveSession Session;
    public Own Own;
    public void Concrete<T>(int value) { Session.ToNode(value, typeof(int)); }
    public void NotVellums<T>(T value) { Own.ToNode(value, typeof(T)); }
    public void Local() { void Put<T>(T value) { Session.ToNode(value, typeof(T)); } Put(1); }
}");

                CheckEqual(0, run.Compiled.Count);
                CheckEqual("", run.SaveMethodsFile);
            }
        }
    }
}