private void BuildType()

in tools/apiview/parsers/csharp-api-parser/CSharpAPIParser/TreeToken/CodeFileBuilder.cs [251:345]
86 lines of code
23 McCabe index (conditional complexity)

        private void BuildType(List<ReviewLine> reviewLines, INamedTypeSymbol namedType, bool inHiddenScope)
        {
            if (!IsAccessible(namedType))
            {
                return;
            }

            bool isHidden = IsHiddenFromIntellisense(namedType) || inHiddenScope;
            var reviewLine = new ReviewLine()
            {
                LineId = namedType.GetId(),
                IsHidden = isHidden
            };

            // Build documentation, attributes, visibility, and name
            BuildDocumentation(reviewLines, namedType, isHidden, namedType.GetId());
            BuildAttributes(reviewLines, namedType.GetAttributes(), isHidden, namedType.GetId());
            BuildVisibility(reviewLine.Tokens, namedType);

            switch (namedType.TypeKind)
            {
                case TypeKind.Class:
                    BuildClassModifiers(reviewLine.Tokens, namedType);
                    reviewLine.Tokens.Add(ReviewToken.CreateKeywordToken(SyntaxKind.ClassKeyword));
                    break;
                case TypeKind.Delegate:
                    reviewLine.Tokens.Add(ReviewToken.CreateKeywordToken(SyntaxKind.DelegateKeyword));
                    break;
                case TypeKind.Enum:
                    reviewLine.Tokens.Add(ReviewToken.CreateKeywordToken(SyntaxKind.EnumKeyword));
                    break;
                case TypeKind.Interface:
                    reviewLine.Tokens.Add(ReviewToken.CreateKeywordToken(SyntaxKind.InterfaceKeyword));
                    break;
                case TypeKind.Struct:
                    if (namedType.IsReadOnly)
                    {
                        reviewLine.Tokens.Add(ReviewToken.CreateKeywordToken(SyntaxKind.ReadOnlyKeyword));
                    }
                    reviewLine.Tokens.Add(ReviewToken.CreateKeywordToken(SyntaxKind.StructKeyword));
                    break;
            }

            DisplayName(reviewLine, namedType, namedType);

            // Add navigation short name and render classes to Type name token. Navigation tree is built dynamically based on these properties
            var typeToken = reviewLine.Tokens.FirstOrDefault(t => t.Kind == TokenKind.TypeName && string.IsNullOrEmpty(t.NavigateToId));
            if (typeToken != null)
            {
                typeToken.NavigationDisplayName = namedType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
                typeToken.RenderClasses.Add(namedType.TypeKind.ToString().ToLowerInvariant());
            }
            if (namedType.TypeKind == TypeKind.Delegate)
            {
                reviewLine.Tokens.Last().HasSuffixSpace = false;
                reviewLine.Tokens.Add(ReviewToken.CreatePunctuationToken(SyntaxKind.SemicolonToken));
                reviewLines.Add(reviewLine);
                return;
            }

            reviewLine.Tokens.Last().HasSuffixSpace = true;
            BuildBaseType(reviewLine, namedType);
            reviewLine.Tokens.Add(ReviewToken.CreatePunctuationToken(SyntaxKind.OpenBraceToken));
            foreach (var namedTypeSymbol in SymbolOrderProvider.OrderTypes(namedType.GetTypeMembers()))
            {
                BuildType(reviewLine.Children, namedTypeSymbol, isHidden);
            }

            foreach (var member in SymbolOrderProvider.OrderMembers(namedType.GetMembers()))
            {
                if (member.Kind == SymbolKind.NamedType || member.IsImplicitlyDeclared || !IsAccessible(member)) continue;
                if (member is IMethodSymbol method)
                {
                    if (method.MethodKind == MethodKind.PropertyGet ||
                        method.MethodKind == MethodKind.PropertySet ||
                        method.MethodKind == MethodKind.EventAdd ||
                        method.MethodKind == MethodKind.EventRemove ||
                        method.MethodKind == MethodKind.EventRaise)
                    {
                        continue;
                    }
                }
                BuildMember(reviewLine.Children, member, isHidden);
            }
            reviewLines.Add(reviewLine);
            reviewLines.Add(new ReviewLine()
            {
                Tokens = [
                    ReviewToken.CreateStringLiteralToken("}")
                ],
                IsHidden = isHidden,
                IsContextEndLine = true
            });
            reviewLines.Add(new ReviewLine() { IsHidden = isHidden, RelatedToLine = reviewLine.LineId });
        }