CecilSerializerContext.cs

Go to the documentation of this file.

// Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
// This file is distributed under GPL v3. See LICENSE.md for details.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using Mono.Cecil;
using Mono.Cecil.Cil;
using SiliconStudio.Core.Serialization.Serializers;

namespace SiliconStudio.AssemblyProcessor.Serializers
{
    internal class CecilSerializerContext
    {
        public CecilSerializerContext(AssemblyDefinition assembly)
        {
            Assembly = assembly;
            SerializableTypesProfiles = new Dictionary<string, ProfileInfo>();
            SerializableTypes = new ProfileInfo();
            SerializableTypesProfiles.Add("Default", SerializableTypes);
            ComplexTypes = new Dictionary<TypeDefinition, SerializableTypeInfo>();

            SiliconStudioCoreAssembly = assembly.Name.Name == "SiliconStudio.Core"
                ? assembly
                : assembly.MainModule.AssemblyResolver.Resolve("SiliconStudio.Core");
        }

        /// <summary>
        /// Gets the assembly being processed.
        /// </summary>
        /// <value>
        /// The assembly being processed.
        /// </value>
        public AssemblyDefinition Assembly { get; private set; }

        public AssemblyDefinition SiliconStudioCoreAssembly { get; private set; }

        /// <summary>
        /// Gets the list of serializable type grouped by profile.
        /// </summary>
        /// <value>
        /// The serializable types profiles.
        /// </value>
        public Dictionary<string, ProfileInfo> SerializableTypesProfiles { get; private set; }

        /// <summary>
        /// Gets the set of type that can be serialized (key) with their serializer name (string), corresponding to the "Default" profile.
        /// </summary>
        public ProfileInfo SerializableTypes { get; private set; }

        /// <summary>
        /// Gets the list of complex serializers to generate.
        /// </summary>
        /// <value>
        /// The list of complex serializers to generate.
        /// </value>
        public Dictionary<TypeDefinition, SerializableTypeInfo> ComplexTypes { get; private set; }

        /// <summary>
        /// Ensure the following type can be serialized. If not, try to register appropriate serializer.
        /// This method can be recursive.
        /// </summary>
        /// <param name="type">The type.</param>
        public SerializableTypeInfo GenerateSerializer(TypeReference type, bool force = true, string profile = "Default", bool generic = false)
        {
            var serializableTypes = GetSerializableTypes(profile);

            // Already handled?
            SerializableTypeInfo serializableTypeInfo;
            if (serializableTypes.TryGetSerializableTypeInfo(type, generic, out serializableTypeInfo))
                return serializableTypeInfo;

            // Try to get one without generic
            if (generic && serializableTypes.TryGetSerializableTypeInfo(type, false, out serializableTypeInfo))
                return serializableTypeInfo;

            // TDOO: Array, List, Generic types, etc... (equivalent of previous serializer factories)
            var arrayType = type as ArrayType;
            if (arrayType != null)
            {
                // Only proceed if element type is serializable (and in Default profile, otherwise ElementType is enough)
                if (GenerateSerializer(arrayType.ElementType, force, profile) != null)
                {
                    if (profile == "Default")
                    {
                        var arraySerializerType = SiliconStudioCoreAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.ArraySerializer`1");
                        var serializerType = new GenericInstanceType(arraySerializerType);
                        serializerType.GenericArguments.Add(arrayType.ElementType);
                        AddSerializableType(type, serializableTypeInfo = new SerializableTypeInfo(serializerType, true), profile);
                        return serializableTypeInfo;
                    }
                    else
                    {
                        // Fallback to default
                        return GenerateSerializer(type, force, "Default");
                    }
                }

                return null;
            }

            // Try to match with existing generic serializer (for List, Dictionary, etc...)
            var genericInstanceType = type as GenericInstanceType;
            if (genericInstanceType != null)
            {
                var elementType = genericInstanceType.ElementType;
                SerializableTypeInfo elementSerializableTypeInfo;
                if ((elementSerializableTypeInfo = GenerateSerializer(elementType, false, profile, true)) != null)
                {
                    switch (elementSerializableTypeInfo.Mode)
                    {
                        case DataSerializerGenericMode.Type:
                        {
                            var serializerType = new GenericInstanceType(elementSerializableTypeInfo.SerializerType);
                            serializerType.GenericArguments.Add(type);

                            AddSerializableType(type, serializableTypeInfo = new SerializableTypeInfo(serializerType, true) { ComplexSerializer = elementSerializableTypeInfo.ComplexSerializer }, profile);
                            break;
                        }
                        case DataSerializerGenericMode.TypeAndGenericArguments:
                        {
                            var serializerType = new GenericInstanceType(elementSerializableTypeInfo.SerializerType);
                            serializerType.GenericArguments.Add(type);
                            foreach (var genericArgument in genericInstanceType.GenericArguments)
                            {
                                // Generate serializer for each generic argument
                                //GenerateSerializer(genericArgument);
            
                                serializerType.GenericArguments.Add(genericArgument);
                            }

                            AddSerializableType(type, serializableTypeInfo = new SerializableTypeInfo(serializerType, true) { ComplexSerializer = elementSerializableTypeInfo.ComplexSerializer }, profile);
                            break;
                        }
                        case DataSerializerGenericMode.GenericArguments:
                        {
                            var serializerType = new GenericInstanceType(elementSerializableTypeInfo.SerializerType);
                            foreach (var genericArgument in genericInstanceType.GenericArguments)
                            {
                                // Generate serializer for each generic argument
                                //GenerateSerializer(genericArgument);
            
                                serializerType.GenericArguments.Add(genericArgument);
                            }

                            AddSerializableType(type, serializableTypeInfo = new SerializableTypeInfo(serializerType, true) { ComplexSerializer = elementSerializableTypeInfo.ComplexSerializer }, profile);
                            break;
                        }
                        default:
                            throw new NotImplementedException();
                    }
            
                    if (elementSerializableTypeInfo.ComplexSerializer)
                    {
                        ProcessComplexSerializerMembers(type, serializableTypeInfo);
                    }
                    return serializableTypeInfo;
                }
            }

            // Check complex type definitions
            if (profile == "Default" && (serializableTypeInfo = FindSerializerInfo(type, generic)) != null)
            {
                return serializableTypeInfo;
            }

            // Fallback to default
            if (profile != "Default")
                return GenerateSerializer(type, force, "Default", generic);

            // Part after that is only if a serializer is absolutely necessary. This is skipped when scanning normal assemblies type that might have nothing to do with serialization.
            if (!force)
                return null;
            
            // Non instantiable type? (object, interfaces, abstract classes)
            // Serializer can be null since they will be inherited anyway (handled through MemberSerializer)
            var resolvedType = type.Resolve();
            if (resolvedType.IsAbstract || resolvedType.IsAbstract || resolvedType.FullName == typeof(object).FullName)
            {
                AddSerializableType(type, serializableTypeInfo = new SerializableTypeInfo(null, true), profile);
                return serializableTypeInfo;
            }

            return null;
        }

        private void ProcessComplexSerializerMembers(TypeReference type, SerializableTypeInfo serializableTypeInfo, string profile = "Default")
        {
            // Process base type (for complex serializers)
            // If it's a closed type and there is a serializer, we'll serialize parent
            SerializableTypeInfo parentSerializableTypeInfo;
            var parentType = ResolveGenericsVisitor.Process(type, type.Resolve().BaseType);
            if (!parentType.ContainsGenericParameter() && (parentSerializableTypeInfo = GenerateSerializer(parentType, false, profile)) != null &&
                parentSerializableTypeInfo.SerializerType != null)
            {
                serializableTypeInfo.ComplexSerializerProcessParentType = true;
            }

            // Process members
            foreach (var serializableItem in ComplexClassSerializerGenerator.GetSerializableItems(type, true))
            {
                // Check that all closed types have a proper serializer
                if (!serializableItem.Type.ContainsGenericParameter() && GenerateSerializer(serializableItem.Type, profile: profile) == null
                    && !serializableItem.Attributes.Any(x => x.AttributeType.FullName == "SiliconStudio.Core.DataMemberCustomSerializerAttribute"))
                {
                    throw new InvalidOperationException(string.Format("Member {0} (type: {1}) doesn't seem to have a valid serializer.", serializableItem.MemberInfo, serializableItem.Type.ConvertCSharp()));
                }
            }
        }

        /// <summary>
        /// Finds the serializer information.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="generic">If set to true, when using <see cref="DataSerializerGenericMode.Type"/>, it will returns the generic version instead of actual type one.</param>
        /// <returns></returns>
        /// <exception cref="System.InvalidOperationException">Not sure how to process this inherited serializer</exception>
        internal SerializableTypeInfo FindSerializerInfo(TypeReference type, bool generic)
        {
            if (type == null || type.FullName == typeof(object).FullName || type.FullName == typeof(ValueType).FullName || type.IsGenericParameter)
                return null;

            var resolvedType = type.Resolve();

            // Nested type
            if (resolvedType.IsNested)
            {
                // Check public/private flags
                if (!resolvedType.IsNestedPublic && !resolvedType.IsNestedAssembly)
                    return null;
            }

            if (resolvedType.IsEnum)
            {
                // Enum
                // Let's generate a EnumSerializer
                var enumSerializerType = SiliconStudioCoreAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.EnumSerializer`1");
                var serializerType = new GenericInstanceType(enumSerializerType);
                serializerType.GenericArguments.Add(type);

                var serializableTypeInfo = new SerializableTypeInfo(serializerType, true, DataSerializerGenericMode.None);
                AddSerializableType(type, serializableTypeInfo);
                return serializableTypeInfo;
            }

            // 1. Check if there is a Serializable attribute
            // Note: Not anymore since we don't want all system types to have unknown complex serializers.
            //if (((resolvedType.Attributes & TypeAttributes.Serializable) == TypeAttributes.Serializable) || resolvedType.CustomAttributes.Any(x => x.AttributeType.FullName == typeof(SerializableAttribute).FullName))
            //{
            //    serializerInfo.Serializable = true;
            //    serializerInfo.ComplexSerializer = true;
            //    serializerInfo.ComplexSerializerName = SerializerTypeName(resolvedType);
            //    return serializerInfo;
            //}

            // 2.1. Check if there is DataSerializerAttribute on this type (if yes, it is serializable, but not a "complex type")
            var dataSerializerAttribute =
                resolvedType.CustomAttributes.FirstOrDefault(
                    x => x.AttributeType.FullName == "SiliconStudio.Core.Serialization.Serializers.DataSerializerAttribute");
            if (dataSerializerAttribute != null)
            {
                var modeField = dataSerializerAttribute.Fields.FirstOrDefault(x => x.Name == "Mode");
                var mode = (modeField.Name != null) ? (DataSerializerGenericMode)modeField.Argument.Value : DataSerializerGenericMode.None;

                // TODO: Replace with ResolveGenericsVisitor
                var dataSerializerType = ((TypeReference)dataSerializerAttribute.ConstructorArguments[0].Value);
                if (mode == DataSerializerGenericMode.Type || (mode == DataSerializerGenericMode.TypeAndGenericArguments && type is GenericInstanceType))
                {
                    var genericSerializableTypeInfo = new SerializableTypeInfo(dataSerializerType, true, mode) { Inherited = true };
                    AddSerializableType(type, genericSerializableTypeInfo);

                    var actualSerializerType = new GenericInstanceType(dataSerializerType);

                    // Add Type as generic arguments
                    actualSerializerType.GenericArguments.Add(type);

                    // If necessary, add generic arguments too
                    if (mode == DataSerializerGenericMode.TypeAndGenericArguments)
                    {
                        foreach (var genericArgument in ((GenericInstanceType)type).GenericArguments)
                        {
                            actualSerializerType.GenericArguments.Add(genericArgument);
                        }
                    }

                    // Special case for GenericMode == DataSerializerGenericMode.Type: we store actual serializer instantiation in SerializerType (alongside the generic version in GenericSerializerType).
                    var serializableTypeInfo = new SerializableTypeInfo(actualSerializerType, true);
                    AddSerializableType(type, serializableTypeInfo);

                    if (!generic)
                        return serializableTypeInfo;

                    return genericSerializableTypeInfo;
                }
                else
                {
                    var serializableTypeInfo = new SerializableTypeInfo(dataSerializerType, true, mode) { Inherited = false };
                    AddSerializableType(type, serializableTypeInfo);
                    return serializableTypeInfo;
                }
            }

            // 2.2. Check if SerializableExtendedAttribute is set on this class, or any of its base class with ApplyHierarchy
            var serializableExtendedAttribute =
                resolvedType.CustomAttributes.FirstOrDefault(
                    x => x.AttributeType.FullName == "SiliconStudio.Core.DataContractAttribute");
            if (dataSerializerAttribute == null && serializableExtendedAttribute != null)
            {
                // CHeck if ApplyHierarchy is active, otherwise it needs to be the exact type.
                var inherited = serializableExtendedAttribute.Properties.Where(x => x.Name == "Inherited")
                    .Select(x => (bool)x.Argument.Value)
                    .FirstOrDefault();

                var serializableTypeInfo = CreateComplexSerializer(type);
                serializableTypeInfo.Inherited = inherited;

                // Process members
                ProcessComplexSerializerMembers(type, serializableTypeInfo);

                return serializableTypeInfo;
            }

            // Check if parent type contains Inherited attribute
            var parentType = ResolveGenericsVisitor.Process(type, type.Resolve().BaseType);
            if (parentType != null)
            {
                // Generate serializer for parent type
                var parentSerializableInfoType = GenerateSerializer(parentType.Resolve(), false, generic: true);

                // If Inherited flag is on, we also generate a serializer for this type
                if (parentSerializableInfoType != null && parentSerializableInfoType.Inherited)
                {
                    if (parentSerializableInfoType.ComplexSerializer)
                    {
                        var serializableTypeInfo = CreateComplexSerializer(type);
                        serializableTypeInfo.Inherited = true;

                        // Process members
                        ProcessComplexSerializerMembers(type, serializableTypeInfo);

                        return serializableTypeInfo;
                    }
                    else if (parentSerializableInfoType.Mode == DataSerializerGenericMode.Type || parentSerializableInfoType.Mode == DataSerializerGenericMode.TypeAndGenericArguments)
                    {
                        // Register generic version
                        var genericSerializableTypeInfo = new SerializableTypeInfo(parentSerializableInfoType.SerializerType, true, parentSerializableInfoType.Mode);
                        AddSerializableType(type, genericSerializableTypeInfo);

                        if (!type.HasGenericParameters)
                        {
                            var actualSerializerType = new GenericInstanceType(parentSerializableInfoType.SerializerType);

                            // Add Type as generic arguments
                            actualSerializerType.GenericArguments.Add(type);

                            // If necessary, add generic arguments too
                            if (parentSerializableInfoType.Mode == DataSerializerGenericMode.TypeAndGenericArguments)
                            {
                                foreach (var genericArgument in ((GenericInstanceType)parentType).GenericArguments)
                                {
                                    actualSerializerType.GenericArguments.Add(genericArgument);
                                }
                            }

                            // Register actual type
                            var serializableTypeInfo = new SerializableTypeInfo(actualSerializerType, true);
                            AddSerializableType(type, serializableTypeInfo);

                            if (!generic)
                                return serializableTypeInfo;
                        }

                        return genericSerializableTypeInfo;
                    }
                    else
                    {
                        throw new InvalidOperationException("Not sure how to process this inherited serializer");
                    }
                }
            }

            return null;
        }

        private SerializableTypeInfo CreateComplexSerializer(TypeReference type)
        {
            // Create a fake TypeReference (even though it doesn't really exist yet, but at least ConvertCSharp to get its name will work).
            var dataSerializerType = new TypeReference("SiliconStudio.DataSerializers",
                ComplexClassSerializerGenerator.SerializerTypeName(type, false, true), type.Module, type.Scope);
            var mode = DataSerializerGenericMode.None;
            if (type.HasGenericParameters)
            {
                mode = DataSerializerGenericMode.GenericArguments;

                // Clone generic parameters
                foreach (var genericParameter in type.GenericParameters)
                {
                    var newGenericParameter = new GenericParameter(genericParameter.Name, dataSerializerType)
                    {
                        Attributes = genericParameter.Attributes
                    };

                    // Clone type constraints (others will be in Attributes)
                    foreach (var constraint in genericParameter.Constraints)
                        newGenericParameter.Constraints.Add(constraint);

                    dataSerializerType.GenericParameters.Add(newGenericParameter);
                }
            }

            var isLocal = type.Resolve().Module.Assembly == Assembly;
            var serializableTypeInfo = new SerializableTypeInfo(dataSerializerType, true, mode);
            serializableTypeInfo.Local = type.Resolve().Module.Assembly == Assembly;
            AddSerializableType(type, serializableTypeInfo);

            if (isLocal && type is TypeDefinition)
            {
                ComplexTypes.Add((TypeDefinition)type, serializableTypeInfo);
            }

            serializableTypeInfo.ComplexSerializer = true;

            return serializableTypeInfo;
        }

        public void AddSerializableType(TypeReference dataType, SerializableTypeInfo serializableTypeInfo, string profile = "Default")
        {
            SerializableTypeInfo currentValue;

            // Check if declaring type is generics
            var resolvedType = dataType.Resolve();
            if (resolvedType != null && resolvedType.DeclaringType != null && (resolvedType.HasGenericParameters || resolvedType.DeclaringType.HasGenericParameters))
                throw new NotSupportedException(String.Format("Serialization of nested types referencing parent's generic parameters is not currently supported. " +
                                                              "[Nested type={0} Parent={1}]", resolvedType.FullName, resolvedType.DeclaringType));

            var profileInfo = GetSerializableTypes(profile);

            if (profileInfo.TryGetSerializableTypeInfo(dataType, serializableTypeInfo.Mode != DataSerializerGenericMode.None, out currentValue))
            {
                // TODO: Doesn't work in some generic case
                if (//currentValue.SerializerType.ConvertCSharp() != serializableTypeInfo.SerializerType.ConvertCSharp() ||
                    currentValue.Mode != serializableTypeInfo.Mode)
                    throw new InvalidOperationException(string.Format("Incompatible serializer found for same type in different assemblies for {0}", dataType.ConvertCSharp()));
                return;
            }

            // Check that we don't simply try to add the same serializer than Default profile (optimized)
            SerializableTypeInfo defaultValue;
            if (profile != "Default" && SerializableTypes.TryGetSerializableTypeInfo(dataType, serializableTypeInfo.Mode != DataSerializerGenericMode.None, out defaultValue))
            {
                if (defaultValue.SerializerType.FullName == serializableTypeInfo.SerializerType.FullName)
                {
                    // Already added in default profile, early exit
                    return;
                }
            }

            profileInfo.AddSerializableTypeInfo(dataType, serializableTypeInfo);

            // Scan and add dependencies (stored in EnumerateGenericInstantiations() functions).
            if (serializableTypeInfo.Local && serializableTypeInfo.SerializerType != null)
            {
                var resolvedSerializerType = serializableTypeInfo.SerializerType.Resolve();
                if (resolvedSerializerType != null)
                {
                    var enumerateGenericInstantiationsMethod = resolvedSerializerType.Methods.FirstOrDefault(x => x.Name == "EnumerateGenericInstantiations");
                    if (enumerateGenericInstantiationsMethod != null)
                    {
                        // Detect all ldtoken (attributes would have been better, but unfortunately C# doesn't allow generics in attributes)
                        foreach (var inst in enumerateGenericInstantiationsMethod.Body.Instructions)
                        {
                            if (inst.OpCode.Code == Code.Ldtoken)
                            {
                                var type = (TypeReference)inst.Operand;

                                // Try to "close" generics type with serializer type as a context
                                var dependentType = ResolveGenericsVisitor.Process(serializableTypeInfo.SerializerType, type);
                                if (!dependentType.ContainsGenericParameter())
                                {
                                    // Import type so that it becomes local to the assembly
                                    // (otherwise SerializableTypeInfo.Local will be false and it won't be instantiated)
                                    var importedType = Assembly.MainModule.Import(dependentType);
                                    if (GenerateSerializer(importedType) == null)
                                    {
                                        throw new InvalidOperationException(string.Format("Could not find serializer for generic dependent type {0}", dependentType));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        private ProfileInfo GetSerializableTypes(string profile)
        {
            ProfileInfo profileInfo;
            if (!SerializableTypesProfiles.TryGetValue(profile, out profileInfo))
            {
                profileInfo = new ProfileInfo();
                SerializableTypesProfiles.Add(profile, profileInfo);
            }
            return profileInfo;
        }

        internal class SerializableTypeInfo
        {
            public TypeReference SerializerType { get; internal set; }
            public DataSerializerGenericMode Mode { get; internal set; }

            // True if type is created in current assembly
            public bool Local;

            // True if the serializer is defined manually by a hand-written DataSerializerGlobalAttribute in current assembly
            public bool ExistingLocal;

            /// <summary>
            /// True if serializer is inherited (i.e. DataSerializer(Inherited == true)).
            /// </summary>
            public bool Inherited;
            
            /// <summary>
            /// True if it's a complex serializer.
            /// </summary>
            public bool ComplexSerializer;

            /// <summary>
            /// True if it's a complex serializer and its base class should be serialized too.
            /// </summary>
            public bool ComplexSerializerProcessParentType;

            public SerializableTypeInfo(TypeReference serializerType, bool local, DataSerializerGenericMode mode = DataSerializerGenericMode.None)
            {
                SerializerType = serializerType;
                Mode = mode;
                Local = local;
            }
        }

        public class ProfileInfo
        {
            /// <summary>
            /// Serializable types (Mode is always None).
            /// </summary>
            public Dictionary<TypeReference, SerializableTypeInfo> SerializableTypes = new Dictionary<TypeReference, SerializableTypeInfo>(TypeReferenceEqualityComparer.Default);

            /// <summary>
            /// Generic serializable types.
            /// </summary>
            public Dictionary<TypeReference, SerializableTypeInfo> GenericSerializableTypes = new Dictionary<TypeReference, SerializableTypeInfo>(TypeReferenceEqualityComparer.Default);

            public bool TryGetSerializableTypeInfo(TypeReference type, bool generic, out SerializableTypeInfo result)
            {
                return generic
                    ? GenericSerializableTypes.TryGetValue(type, out result)
                    : SerializableTypes.TryGetValue(type, out result);
            }

            public void AddSerializableTypeInfo(TypeReference typeReference, SerializableTypeInfo serializableTypeInfo)
            {
                if (serializableTypeInfo.Mode != DataSerializerGenericMode.None)
                    GenericSerializableTypes.Add(typeReference, serializableTypeInfo);
                else
                    SerializableTypes.Add(typeReference, serializableTypeInfo);
            }
        }
    }
}