public override void Process()

in SharpGen/Transform/InterfaceTransform.cs [123:185]
45 lines of code
11 McCabe index (conditional complexity)

        public override void Process(CsInterface interfaceType)
        {
            if (interfaceType.IsFullyMapped)
                return;

            // Set IsFullyMapped to avoid recursive mapping
            interfaceType.IsFullyMapped = true;

            var cppInterface = (CppInterface)interfaceType.CppElement;
            
            var baseType = TypeRegistry.FindBoundType(cppInterface.Base);
            if (baseType != null)
            {
                interfaceType.Base = (CsInterface)baseType;

                // Process base if it's not mapped already
                if (!interfaceType.Base.IsFullyMapped)
                    Process(interfaceType.Base);
            }
            else
            {
                if (!interfaceType.IsCallback)
                    interfaceType.Base = CppObjectType;
            }

            // Handle Methods
            var methods = interfaceType.MethodList;
            List<CsMethod> specialOverloads = new();
            foreach (var cSharpMethod in methods)
            {
                MethodTransformer.Process(cSharpMethod);

                // Add specialized method overloads
                specialOverloads.AddRange(GenerateSpecialOverloads(cSharpMethod));
            }

            foreach (var overload in specialOverloads)
            {
                interfaceType.Add(overload);
                MethodTransform.CreateNativeInteropSignatures(interopSignatureTransform, overload);
            }

            MoveMethodsToInnerInterfaces(interfaceType);

            // If interfaceType is DualCallback, then need to generate a default implementation
            if (interfaceType.IsDualCallback)
            {
                var nativeCallback = CreateNativeCallbackType(interfaceType);
                interfaceType.Parent.Add(nativeCallback);
                CreateProperties(nativeCallback.Methods);
            }
            else if (!interfaceType.IsCallback && interfaceType.Base is {IsDualCallback: true})
            {
                interfaceType.Base = interfaceType.Base.GetNativeImplementationOrThis();
            }

            // N.B. Implicit dependency on CreateNativeCallbackType having already executed.
            //      Otherwise Native type gets ICallbackable instead of CppObject as a base.
            if (interfaceType.IsCallback)
                interfaceType.Base ??= DefaultCallbackable;

            CreateProperties(methods);
        }