private IReadOnlyList GetPropertyInitializers()

in src/AutoRest.CSharp/Common/Output/Models/Types/ModelTypeProvider.cs [398:492]
77 lines of code
30 McCabe index (conditional complexity)

        private IReadOnlyList<ObjectPropertyInitializer> GetPropertyInitializers(IReadOnlyList<Parameter> parameters, bool isInitializer)
        {
            List<ObjectPropertyInitializer> defaultCtorInitializers = new();

            // only initialization ctor initializes the discriminator
            // and we should not initialize the discriminator again when the discriminator is inherited (it should show up in the ctor)
            // [TODO]: Consolidate property initializer generation between HLC and DPG
            if (!Configuration.Generation1ConvenienceClient && isInitializer && !IsDiscriminatorInheritedOnBase && Discriminator is { Value: { } discriminatorValue } && !IsUnknownDerivedType)
            {
                defaultCtorInitializers.Add(new ObjectPropertyInitializer(Discriminator.Property, discriminatorValue));
            }

            Dictionary<string, Parameter> parameterMap = parameters.ToDictionary(
                parameter => parameter.Name,
                parameter => parameter);

            foreach (var property in Properties)
            {
                // we do not need to add initialization for raw data field
                if (isInitializer && property == RawDataField)
                {
                    continue;
                }

                ReferenceOrConstant? initializationValue = null;
                Constant? defaultInitializationValue = null;

                var propertyType = property.Declaration.Type;
                if (parameterMap.TryGetValue(property.Declaration.Name.ToVariableName(), out var parameter) || IsStruct)
                {
                    // For structs all properties become required
                    Constant? defaultParameterValue = null;
                    if (property.InputModelProperty?.DefaultValue is { } defaultValueObject)
                    {
                        defaultParameterValue = BuilderHelpers.ParseConstant(defaultValueObject, propertyType);
                        defaultInitializationValue = defaultParameterValue;
                    }

                    var inputType = parameter?.Type ?? propertyType.InputType;
                    if (defaultParameterValue != null && !property.ValueType.CanBeInitializedInline(defaultParameterValue))
                    {
                        inputType = inputType.WithNullable(true);
                        defaultParameterValue = Constant.Default(inputType);
                    }

                    var validate = property.InputModelProperty?.Type is not InputNullableType && !inputType.IsValueType ? ValidationType.AssertNotNull : ValidationType.None;
                    var defaultCtorParameter = new Parameter(
                        property.Declaration.Name.ToVariableName(),
                        property.ParameterDescription,
                        inputType,
                        defaultParameterValue,
                        validate,
                        null
                    );

                    initializationValue = defaultCtorParameter;
                }
                else if (initializationValue == null && propertyType.IsCollection)
                {
                    if (propertyType.IsReadOnlyMemory)
                    {
                        initializationValue = propertyType.IsNullable ? null : Constant.FromExpression($"{propertyType}.{nameof(ReadOnlyMemory<object>.Empty)}", propertyType);
                    }
                    else
                    {
                        initializationValue = Constant.NewInstanceOf(propertyType.PropertyInitializationType);
                    }
                }
                // [TODO]: Consolidate property initializer generation between HLC and DPG
                else if (property.InputModelProperty?.ConstantValue is { } constant && !propertyType.IsNullable && Configuration.Generation1ConvenienceClient)
                {
                    initializationValue = BuilderHelpers.ParseConstant(constant.Value, propertyType);
                }

                if (initializationValue != null)
                {
                    defaultCtorInitializers.Add(new ObjectPropertyInitializer(property, initializationValue.Value, defaultInitializationValue));
                }
            }

            // [TODO]: Consolidate property initializer generation between HLC and DPG
            if (Configuration.Generation1ConvenienceClient && Discriminator is { } discriminator)
            {
                if (defaultCtorInitializers.All(i => i.Property != discriminator.Property) && parameterMap.TryGetValue(discriminator.Property.Declaration.Name.ToVariableName(), out var discriminatorParameter))
                {
                    defaultCtorInitializers.Add(new ObjectPropertyInitializer(discriminator.Property, discriminatorParameter, discriminator.Value));
                }
                else if (!_inputModel.IsUnknownDiscriminatorModel && discriminator.Value is { } value)
                {
                    defaultCtorInitializers.Add(new ObjectPropertyInitializer(discriminator.Property, value));
                }
            }

            return defaultCtorInitializers;
        }