public override Type Visit(Type type)
                {
                    if (type.TryGetCarriedType(out var carriedType))
                    {
                        if (!_parent.Entities.ContainsKey(type))
                        {
                            if (DataTypeHelpers.IsStructuralEntityDataTypeCached(carriedType))
                            {
                                var structuralType = (StructuralDataType)DataTypeHelpers.FromTypeCached(carriedType, allowCycles: true);
                                _parent.Entities[type] = structuralType;
                            }
                            else
                            {
                                //
                                // Non-generic record types or anonymous types (created by RuntimeCompiler) may contain entities,
                                // so we have to grab those as well.
                                //

                                if (!carriedType.IsGenericType && DataTypeHelpers.TryFromTypeCached(carriedType, allowCycles: true, out var result) && result.Kind == DataTypeKinds.Structural)
                                {
                                    var structuralType = (StructuralDataType)result;

                                    var runtimeCompilerTypes = StructuralDataTypeKinds.Anonymous | StructuralDataTypeKinds.Record;

                                    if ((runtimeCompilerTypes & structuralType.StructuralKind) != 0)
                                    {
                                        _parent.Entities[type] = structuralType;
                                    }
                                }
                            }
                        }

                        if (!_parent.Enumerations.ContainsKey(type))
                        {
                            if (DataTypeHelpers.IsEntityEnumDataTypeCached(carriedType))
                            {
                                var primitiveType = (PrimitiveDataType)DataTypeHelpers.FromTypeCached(carriedType, allowCycles: true);
                                Debug.Assert(primitiveType.PrimitiveKind == PrimitiveDataTypeKinds.EntityEnum);
                                _parent.Enumerations[type] = primitiveType;
                            }
                        }
                    }

                    return(base.Visit(type));
                }
        /// <summary>
        /// Creates a slim representation of a type constructor.
        /// </summary>
        /// <param name="originalConstructor">The original constructor.</param>
        /// <param name="declaringTypeSlim">The slim representation of the declaring type.</param>
        /// <param name="parameterTypeSlims">The slim representations of the constructor parameter types.</param>
        /// <returns>The slim representation of the constructor.</returns>
        protected override ConstructorInfoSlim GetConstructorCore(ConstructorInfo originalConstructor, TypeSlim declaringTypeSlim, ReadOnlyCollection <TypeSlim> parameterTypeSlims)
        {
            var slimConstructor = base.GetConstructorCore(originalConstructor, declaringTypeSlim, parameterTypeSlims);
            var parameters      = originalConstructor.GetParameters();

            DataTypeHelpers.TryFromTypeCached(originalConstructor.DeclaringType, allowCycles: true, out var res);

            if (res is StructuralDataType dataType)
            {
                var parameterMappings = EmptyReadOnlyCollection <string> .Instance;

                if (dataType.StructuralKind == StructuralDataTypeKinds.Entity)
                {
                    var mappings    = new List <string>(parameters.Length);
                    var mappedCount = 0;
                    for (var i = 0; i < parameters.Length; ++i)
                    {
                        var mapping = parameters[i].GetCustomAttribute <MappingAttribute>(inherit: false);

                        if (mapping != null)
                        {
                            mappedCount++;
                            mappings.Add(mapping.Uri);
                        }
                    }

                    if (mappedCount != parameters.Length)
                    {
                        throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "There are '{0}' parameters in the constructor of '{1}' that do not have a mapping attributes. In order for type '{1}' to be a valid data model entity type, all of its constructors' parameters should be annotated with mapping attributes.", parameters.Length - mappedCount, originalConstructor.DeclaringType.ToCSharpStringPretty()));
                    }

                    if (mappings.Count > 0 && mappings[0] != null)
                    {
                        parameterMappings = mappings.AsReadOnly();
                    }
                }

                return(new DataModelConstructorInfoSlim(slimConstructor.DeclaringType, slimConstructor.ParameterTypes, parameterMappings));
            }

            return(slimConstructor);
        }