TypeState CreateTypeStateCore(DmdType type)
        {
            var typeExpression = GetTypeExpression(type);

            if (HasNoChildren(type) || type.IsFunctionPointer)
            {
                return(new TypeState(type, typeExpression));
            }

            MemberValueNodeInfoCollection instanceMembers, staticMembers;

            TupleField[] tupleFields;

            Debug.Assert(!type.IsByRef);
            if (type.TypeSignatureKind == DmdTypeSignatureKind.Type || type.TypeSignatureKind == DmdTypeSignatureKind.GenericInstance)
            {
                tupleFields = TryCreateTupleFields(type) ?? Array.Empty <TupleField>();

                var  instanceMembersList = new List <MemberValueNodeInfo>();
                var  staticMembersList   = new List <MemberValueNodeInfo>();
                bool instanceHasHideRoot = false;
                bool staticHasHideRoot   = false;

                byte    inheritanceLevel;
                DmdType currentType;

                inheritanceLevel = 0;
                currentType      = type;
                foreach (var field in type.Fields)
                {
                    var declType = field.DeclaringType;
                    while (declType != currentType)
                    {
                        Debug.Assert((object)currentType.BaseType != null);
                        currentType = currentType.BaseType;
                        if (inheritanceLevel != byte.MaxValue)
                        {
                            inheritanceLevel++;
                        }
                    }

                    var nodeInfo = new MemberValueNodeInfo(field, inheritanceLevel);
                    if (field.IsStatic)
                    {
                        staticHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
                        staticMembersList.Add(nodeInfo);
                    }
                    else
                    {
                        instanceHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
                        instanceMembersList.Add(nodeInfo);
                    }
                }

                inheritanceLevel = 0;
                currentType      = type;
                foreach (var property in type.Properties)
                {
                    if (property.GetMethodSignature().GetParameterTypes().Count != 0)
                    {
                        continue;
                    }
                    var declType = property.DeclaringType;
                    while (declType != currentType)
                    {
                        Debug.Assert((object)currentType.BaseType != null);
                        currentType = currentType.BaseType;
                        if (inheritanceLevel != byte.MaxValue)
                        {
                            inheritanceLevel++;
                        }
                    }
                    var getter = property.GetGetMethod(DmdGetAccessorOptions.All);
                    if ((object)getter == null || getter.GetMethodSignature().GetParameterTypes().Count != 0)
                    {
                        continue;
                    }
                    var nodeInfo = new MemberValueNodeInfo(property, inheritanceLevel);
                    if (getter.IsStatic)
                    {
                        staticHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
                        staticMembersList.Add(nodeInfo);
                    }
                    else
                    {
                        instanceHasHideRoot |= nodeInfo.HasDebuggerBrowsableState_RootHidden;
                        instanceMembersList.Add(nodeInfo);
                    }
                }

                var instanceMembersArray = InitializeOverloadedMembers(instanceMembersList.ToArray());
                var staticMembersArray   = InitializeOverloadedMembers(staticMembersList.ToArray());

                instanceMembers = instanceMembersList.Count == 0 ? MemberValueNodeInfoCollection.Empty : new MemberValueNodeInfoCollection(instanceMembersArray, instanceHasHideRoot);
                staticMembers   = staticMembersList.Count == 0 ? MemberValueNodeInfoCollection.Empty : new MemberValueNodeInfoCollection(staticMembersArray, staticHasHideRoot);

                Array.Sort(instanceMembers.Members, MemberValueNodeInfoEqualityComparer.Instance);
                Array.Sort(staticMembers.Members, MemberValueNodeInfoEqualityComparer.Instance);
                var output = ObjectCache.AllocDotNetTextOutput();
                UpdateNames(instanceMembers.Members, output);
                UpdateNames(staticMembers.Members, output);
                ObjectCache.Free(ref output);
            }
            else
            {
                staticMembers = instanceMembers = MemberValueNodeInfoCollection.Empty;
                tupleFields   = Array.Empty <TupleField>();
            }

            return(new TypeState(type, typeExpression, instanceMembers, staticMembers, tupleFields));
        }