Mosa.Compiler.Framework.MosaTypeLayout.GetFieldSize C# (CSharp) Method

        public int GetFieldSize(MosaField field)
        {
            var size = 0;

            //FIXME: This is not thread safe!
            if (fieldSizes.TryGetValue(field, out size))
            {
                return size;
            }
            else
            {
                ResolveType(field.DeclaringType);
            }

            // If the field is another struct, we have to dig down and compute its size too.
            if (field.FieldType.IsValueType)
            {
                size = GetTypeSize(field.FieldType);
            }
            else
            {
                size = GetMemorySize(field.FieldType);
            }

            fieldSizes.Add(field, size);

            return size;
        }

        public static void UpdateTree(TreeView treeView, TypeSystem typeSystem, MosaTypeLayout typeLayout, bool showSizes)
        {
            treeView.BeginUpdate();
            treeView.Nodes.Clear();

            foreach (var module in typeSystem.Modules)
            {
                TreeNode moduleNode = new TreeNode(module.Name);
                treeView.Nodes.Add(moduleNode);

                foreach (MosaType type in module.Types.Values)
                {
                    TreeNode typeNode = new TreeNode(type.FullName);
                    moduleNode.Nodes.Add(typeNode);

                    if (type.BaseType != null)
                    {
                        TreeNode baseTypeNode = new TreeNode("Base Type: " + type.BaseType.FullName);
                        typeNode.Nodes.Add(baseTypeNode);
                    }

                    if (type.DeclaringType != null)
                    {
                        TreeNode baseTypeNode = new TreeNode("Enclosing Type: " + type.DeclaringType.FullName);
                        typeNode.Nodes.Add(baseTypeNode);
                    }

                    if (type.Interfaces.Count != 0)
                    {
                        TreeNode interfacesNodes = new TreeNode("Interfaces");
                        typeNode.Nodes.Add(interfacesNodes);

                        foreach (MosaType interfaceType in type.Interfaces)
                        {
                            TreeNode interfaceNode = new TreeNode(interfaceType.FullName);
                            interfacesNodes.Nodes.Add(interfaceNode);
                        }
                    }

                    if (type.Fields.Count != 0)
                    {
                        TreeNode fieldsNode = new TreeNode("Fields");
                        if (showSizes)
                            fieldsNode.Text = fieldsNode.Text + " (Count: " + type.Fields.Count.ToString() + " - Size: " + typeLayout.GetTypeSize(type).ToString() + ")";

                        typeNode.Nodes.Add(fieldsNode);

                        foreach (MosaField field in type.Fields)
                        {
                            TreeNode fieldNode = new TreeNode(field.ShortName);
                            fieldsNode.Nodes.Add(fieldNode);

                            if (field.IsStatic)
                                fieldNode.Text = fieldNode.Text + " [Static]";

                            if (showSizes)
                            {
                                fieldNode.Text = fieldNode.Text + " (Size: " + typeLayout.GetFieldSize(field).ToString();

                                if (!field.IsStatic)
                                    fieldNode.Text = fieldNode.Text + " - Offset: " + typeLayout.GetFieldOffset(field).ToString();

                                fieldNode.Text = fieldNode.Text + ")";
                            }
                        }
                    }

                    if (type.Methods.Count != 0)
                    {
                        TreeNode methodsNode = new TreeNode("Methods");
                        typeNode.Nodes.Add(methodsNode);

                        foreach (MosaMethod method in type.Methods)
                        {
                            TreeNode methodNode = new ViewNode<MosaMethod>(method, method.ShortName);
                            methodsNode.Nodes.Add(methodNode);

                            if (method.IsStatic)
                                methodNode.Text = methodNode.Text + " [Static]";

                            if (method.IsAbstract)
                                methodNode.Text = methodNode.Text + " [Abstract]";

                            if (method.IsNewSlot)
                                methodNode.Text = methodNode.Text + " [NewSlot]";

                            if (method.IsVirtual)
                                methodNode.Text = methodNode.Text + " [Virtual]";

                            if (method.IsFinal)
                                methodNode.Text = methodNode.Text + " [Final]";

                            if (method.IsSpecialName)
                                methodNode.Text = methodNode.Text + " [SpecialName]";

                            if (method.IsRTSpecialName)
                                methodNode.Text = methodNode.Text + " [RTSpecialName]";

                            if (method.GenericArguments.Count != 0)
                            {
                                TreeNode genericParameterNodes = new TreeNode("Generic Arguments Types");
                                methodNode.Nodes.Add(genericParameterNodes);

                                foreach (var genericParameter in method.GenericArguments)
                                {
                                    TreeNode GenericParameterNode = new TreeNode(genericParameter.Name);
                                    genericParameterNodes.Nodes.Add(GenericParameterNode);
                                }
                            }
                        }
                    }

                    if (typeLayout.GetMethodTable(type) != null)
                    {
                        TreeNode methodTableNode = new TreeNode("Method Table");
                        typeNode.Nodes.Add(methodTableNode);

                        foreach (MosaMethod method in typeLayout.GetMethodTable(type))
                        {
                            TreeNode methodNode = new ViewNode<MosaMethod>(method, method.ShortName);
                            methodTableNode.Nodes.Add(methodNode);
                        }
                    }
                }
            }

            treeView.EndUpdate();
        }