Remove obsolete generation

Author: CorruptComputer

ReQuesty.Builder/Configuration/GenerationConfiguration.cs

@@ -61,14 +61,6 @@ public bool UsesBackingStore
     {
         get; set;
     }
-    public bool ExcludeBackwardCompatible
-    {
-        get; set;
-    }
-    public bool IncludeBackwardCompatible
-    {
-        get => !ExcludeBackwardCompatible;
-    }
     public bool IncludeAdditionalData { get; set; } = true;
     public HashSet<string> Serializers
     {
@@ -141,7 +133,6 @@ public object Clone()
     {
         return new GenerationConfiguration
         {
-            ExcludeBackwardCompatible = ExcludeBackwardCompatible,
             OpenAPIFilePath = OpenAPIFilePath,
             OutputPath = OutputPath,
             ClientClassName = ClientClassName,

ReQuesty.Builder/Lock/ReQuestyLock.cs

@@ -116,7 +116,6 @@ public void UpdateGenerationConfigurationFromLock(GenerationConfiguration config
         }
 
         config.UsesBackingStore = UsesBackingStore;
-        config.ExcludeBackwardCompatible = ExcludeBackwardCompatible;
         config.IncludeAdditionalData = IncludeAdditionalData;
         config.Serializers = Serializers.ToHashSet(StringComparer.OrdinalIgnoreCase);
         config.Deserializers = Deserializers.ToHashSet(StringComparer.OrdinalIgnoreCase);
@@ -145,7 +144,6 @@ public ReQuestyLock(GenerationConfiguration config)
         TypeAccessModifier = config.TypeAccessModifier.ToString();
         ClientNamespaceName = config.ClientNamespaceName;
         UsesBackingStore = config.UsesBackingStore;
-        ExcludeBackwardCompatible = config.ExcludeBackwardCompatible;
         IncludeAdditionalData = config.IncludeAdditionalData;
         Serializers = config.Serializers.ToHashSet(StringComparer.OrdinalIgnoreCase);
         Deserializers = config.Deserializers.ToHashSet(StringComparer.OrdinalIgnoreCase);

ReQuesty.Builder/ReQuestyBuilder.cs

@@ -685,7 +685,7 @@ public async Task ApplyLanguageRefinementAsync(GenerationConfiguration config, C
 
     public async Task CreateLanguageSourceFilesAsync(GenerationLanguage language, CodeNamespace generatedCode, CancellationToken cancellationToken)
     {
-        LanguageWriter languageWriter = LanguageWriter.GetLanguageWriter(language, config.OutputPath, config.ClientNamespaceName, config.UsesBackingStore, config.ExcludeBackwardCompatible);
+        LanguageWriter languageWriter = LanguageWriter.GetLanguageWriter(language, config.OutputPath, config.ClientNamespaceName, config.UsesBackingStore);
         Stopwatch stopwatch = new();
         stopwatch.Start();
         CodeRenderer codeRenderer = CodeRenderer.GetCodeRender(config);
@@ -1375,52 +1375,11 @@ private void AddErrorMappingToExecutorMethod(OpenApiUrlTreeNode currentNode, Ope
         {
             string suffix = $"{operationType.Method.ToLowerInvariant().ToFirstCharacterUpperCase()}Response";
             CodeTypeBase? modelType = CreateModelDeclarations(currentNode, schema, operation, parentClass, suffix);
-            if (modelType is not null && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp && modelType.Name.EndsWith(suffix, StringComparison.Ordinal))
-            { //TODO remove for v2
-                string obsoleteTypeName = modelType.Name[..^suffix.Length] + "Response";
-                if (modelType is CodeType codeType &&
-                    codeType.TypeDefinition is CodeClass codeClass)
-                {
-                    CodeClass obsoleteClassDefinition = new()
-                    {
-                        Kind = CodeClassKind.Model,
-                        Name = obsoleteTypeName,
-                        Deprecation = new("This class is obsolete. Use {TypeName} instead.", IsDeprecated: true, TypeReferences: new() { { "TypeName", codeType } }),
-                        Documentation = (CodeDocumentation)codeClass.Documentation.Clone()
-                    };
-                    CodeMethod originalFactoryMethod = codeClass.Methods.First(static x => x.Kind is CodeMethodKind.Factory);
-                    CodeMethod obsoleteFactoryMethod = (CodeMethod)originalFactoryMethod.Clone();
-                    obsoleteFactoryMethod.ReturnType = new CodeType { Name = obsoleteTypeName, TypeDefinition = obsoleteClassDefinition };
-                    obsoleteClassDefinition.AddMethod(obsoleteFactoryMethod);
-                    obsoleteClassDefinition.StartBlock.Inherits = (CodeType)codeType.Clone();
-                    CodeClass obsoleteClass = codeClass.Parent switch
-                    {
-                        CodeClass modelParentClass => modelParentClass.AddInnerClass(obsoleteClassDefinition).First(),
-                        CodeNamespace modelParentNamespace => modelParentNamespace.AddClass(obsoleteClassDefinition).First(),
-                        _ => throw new InvalidOperationException("Could not find a valid parent for the obsolete class")
-                    };
-                    return (modelType, new CodeType
-                    {
-                        TypeDefinition = obsoleteClass,
-                    });
-                }
-                else if (modelType is CodeComposedTypeBase codeComposedTypeBase)
-                {
-                    CodeComposedTypeBase obsoleteComposedType = codeComposedTypeBase switch
-                    {
-                        CodeUnionType u => (CodeComposedTypeBase)u.Clone(),
-                        CodeIntersectionType i => (CodeComposedTypeBase)i.Clone(),
-                        _ => throw new InvalidOperationException("Could not create an obsolete composed type"),
-                    };
-                    obsoleteComposedType.Name = obsoleteTypeName;
-                    obsoleteComposedType.Deprecation = new("This class is obsolete. Use {TypeName} instead.", IsDeprecated: true, TypeReferences: new() { { "TypeName", modelType } });
-                    return (modelType, obsoleteComposedType);
-                }
-            }
-            else if (modelType is null)
+            if (modelType is null)
             {
                 return (GetExecutorMethodDefaultReturnType(operation), null);
             }
+
             return (modelType, null);
         }
         else
@@ -1516,16 +1475,6 @@ private void CreateOperationMethods(OpenApiUrlTreeNode currentNode, NetHttpMetho
             };
             executorMethod.AddParameter(cancellationParam);// Add cancellation token parameter
 
-            if (returnTypes.Item2 is not null && config.IncludeBackwardCompatible)
-            { //TODO remove for v2
-                CodeMethod additionalExecutorMethod = (CodeMethod)executorMethod.Clone();
-                additionalExecutorMethod.ReturnType = returnTypes.Item2;
-                additionalExecutorMethod.OriginalMethod = executorMethod;
-                string newName = $"{executorMethod.Name}As{executorMethod.ReturnType.Name.ToFirstCharacterUpperCase()}";
-                additionalExecutorMethod.Deprecation = new("This method is obsolete. Use {TypeName} instead.", IsDeprecated: true, TypeReferences: new() { { "TypeName", new CodeType { TypeDefinition = executorMethod, IsExternal = false } } });
-                parentClass.RenameChildElement(executorMethod.Name, newName);
-                parentClass.AddMethod(additionalExecutorMethod);
-            }
             logger.LogTrace("Creating method {Name} of {Type}", executorMethod.Name, executorMethod.ReturnType);
 
             CodeMethod generatorMethod = new()
@@ -2736,7 +2685,6 @@ internal static void AddSerializationMembers(CodeClass model, bool includeAdditi
     private void AddPropertyForQueryParameter(OpenApiUrlTreeNode node, NetHttpMethod operationType, IOpenApiParameter parameter, CodeClass parameterClass)
     {
         CodeType? resultType = default;
-        bool addBackwardCompatibleParameter = false;
 
         if (parameter.Schema is not null && (parameter.Schema.IsEnum() || (parameter.Schema.IsArray() && parameter.Schema.Items.IsEnum())))
         {
@@ -2760,7 +2708,6 @@ private void AddPropertyForQueryParameter(OpenApiUrlTreeNode node, NetHttpMethod
                     TypeDefinition = enumDeclaration,
                     IsNullable = !parameter.Schema.IsArray()
                 };
-                addBackwardCompatibleParameter = true;
             }
         }
         resultType ??= GetPrimitiveType(parameter.Schema) ?? new CodeType()
@@ -2796,20 +2743,7 @@ private void AddPropertyForQueryParameter(OpenApiUrlTreeNode node, NetHttpMethod
 
         if (!parameterClass.ContainsPropertyWithWireName(prop.WireName))
         {
-            if (addBackwardCompatibleParameter && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp)
-            { //TODO remove for v2
-                CodeProperty modernProp = (CodeProperty)prop.Clone();
-                modernProp.Name = $"{prop.Name}As{modernProp.Type.Name.ToFirstCharacterUpperCase()}";
-                modernProp.SerializationName = prop.WireName;
-                prop.Deprecation = new("This property is deprecated, use {TypeName} instead", IsDeprecated: true, TypeReferences: new() { { "TypeName", new CodeType { TypeDefinition = modernProp, IsExternal = false } } });
-                prop.Type = GetDefaultQueryParameterType();
-                prop.Type.CollectionKind = modernProp.Type.CollectionKind;
-                parameterClass.AddProperty(modernProp, prop);
-            }
-            else
-            {
-                parameterClass.AddProperty(prop);
-            }
+            parameterClass.AddProperty(prop);
         }
         else
         {

ReQuesty.Builder/Refiners/CSharpRefiner.cs

@@ -42,9 +42,7 @@ public override Task RefineAsync(CodeNamespace generatedCode, CancellationToken
                 {
                     Name = "DefaultQueryParameters",
                     IsExternal = true,
-                },
-                !_configuration.ExcludeBackwardCompatible,//TODO remove the condition for v2
-                !_configuration.ExcludeBackwardCompatible);
+                });
             AddDefaultImports(generatedCode, defaultUsingEvaluators);
             MoveClassesWithNamespaceNamesUnderNamespace(generatedCode);
             ConvertUnionTypesToWrapper(generatedCode,

ReQuesty.Builder/Refiners/CommonLanguageRefiner.cs

@@ -1652,19 +1652,14 @@ protected static void RemoveUntypedNodeTypeValues(CodeElement currentElement)
         }
         CrawlTree(currentElement, RemoveUntypedNodeTypeValues);
     }
-    protected static void RemoveRequestConfigurationClasses(CodeElement currentElement, CodeUsing? configurationParameterTypeUsing = null, CodeType? defaultValueForGenericTypeParam = null, bool keepRequestConfigurationClass = false, bool addDeprecation = false, CodeUsing? usingForDefaultGenericParameter = null)
+
+    protected static void RemoveRequestConfigurationClasses(CodeElement currentElement, CodeUsing? configurationParameterTypeUsing = null, CodeType? defaultValueForGenericTypeParam = null, CodeUsing? usingForDefaultGenericParameter = null)
     {
-        if (currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestConfiguration) &&
-            currentClass.Parent is CodeClass parentClass)
+        if (currentElement is CodeClass currentClass
+            && currentClass.IsOfKind(CodeClassKind.RequestConfiguration)
+            && currentClass.Parent is CodeClass parentClass)
         {
-            if (addDeprecation && keepRequestConfigurationClass)
-            {
-                currentClass.Deprecation = new DeprecationInformation("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.");
-            }
-            else if (!keepRequestConfigurationClass)
-            {
-                parentClass.RemoveChildElement(currentClass);
-            }
+            parentClass.RemoveChildElement(currentClass);
 
             CodeParameter[] configurationParameters = parentClass.Methods
                                                     .SelectMany(static x => x.Parameters)
@@ -1684,11 +1679,7 @@ protected static void RemoveRequestConfigurationClasses(CodeElement currentEleme
                     Name = configurationParameterTypeUsing.Name,
                     IsExternal = true,
                 };
-                if (addDeprecation && keepRequestConfigurationClass)
-                {
-                    currentClass.RemovePropertiesOfKind(CodePropertyKind.Headers, CodePropertyKind.Options, CodePropertyKind.QueryParameters);
-                    currentClass.StartBlock.Inherits = GetGenericTypeForRequestConfiguration(configurationParameterType, genericTypeParamValue);
-                }
+
                 foreach (CodeParameter? configurationParameter in configurationParameters)
                 {
                     CodeType newType = GetGenericTypeForRequestConfiguration(configurationParameterType, genericTypeParamValue);
@@ -1698,8 +1689,9 @@ protected static void RemoveRequestConfigurationClasses(CodeElement currentEleme
             }
         }
 
-        CrawlTree(currentElement, x => RemoveRequestConfigurationClasses(x, configurationParameterTypeUsing, defaultValueForGenericTypeParam, keepRequestConfigurationClass, addDeprecation, usingForDefaultGenericParameter));
+        CrawlTree(currentElement, x => RemoveRequestConfigurationClasses(x, configurationParameterTypeUsing, defaultValueForGenericTypeParam, usingForDefaultGenericParameter));
     }
+
     private static CodeType GetGenericTypeForRequestConfiguration(CodeType configurationParameterType, CodeType genericTypeParamValue)
     {
         CodeType newType = (CodeType)configurationParameterType.Clone();

ReQuesty.Builder/WorkspaceManagement/ApiClientConfiguration.cs

@@ -40,13 +40,6 @@ public bool IncludeAdditionalData
         get; set;
     }
     /// <summary>
-    /// Whether backward compatible code was excluded for this client.
-    /// </summary>
-    public bool ExcludeBackwardCompatible
-    {
-        get; set;
-    }
-    /// <summary>
     /// The OpenAPI validation rules to disable during the generation.
     /// </summary>
     public HashSet<string> DisabledValidationRules { get; set; } = new(StringComparer.OrdinalIgnoreCase);
@@ -68,7 +61,6 @@ public ApiClientConfiguration(GenerationConfiguration config) : base(config)
         TypeAccessModifier = config.TypeAccessModifier.ToString();
         ClientNamespaceName = config.ClientNamespaceName;
         UsesBackingStore = config.UsesBackingStore;
-        ExcludeBackwardCompatible = config.ExcludeBackwardCompatible;
         IncludeAdditionalData = config.IncludeAdditionalData;
         StructuredMimeTypes = config.StructuredMimeTypes.ToList();
         DisabledValidationRules = config.DisabledValidationRules.ToHashSet(StringComparer.OrdinalIgnoreCase);
@@ -95,7 +87,6 @@ public void UpdateGenerationConfigurationFromApiClientConfiguration(GenerationCo
         }
 
         config.UsesBackingStore = UsesBackingStore;
-        config.ExcludeBackwardCompatible = ExcludeBackwardCompatible;
         config.IncludeAdditionalData = IncludeAdditionalData;
         config.StructuredMimeTypes = new(StructuredMimeTypes);
         config.DisabledValidationRules = DisabledValidationRules.ToHashSet(StringComparer.OrdinalIgnoreCase);
@@ -112,7 +103,6 @@ public object Clone()
             ClientNamespaceName = ClientNamespaceName,
             UsesBackingStore = UsesBackingStore,
             IncludeAdditionalData = IncludeAdditionalData,
-            ExcludeBackwardCompatible = ExcludeBackwardCompatible,
             DisabledValidationRules = new(DisabledValidationRules, StringComparer.OrdinalIgnoreCase),
         };
         CloneBase(result);

ReQuesty.Builder/WorkspaceManagement/ApiClientConfigurationComparer.cs

@@ -25,11 +25,6 @@ public override bool Equals(ApiClientConfiguration? x, ApiClientConfiguration? y
             return object.Equals(x, y);
         }
 
-        if (x.ExcludeBackwardCompatible != y.ExcludeBackwardCompatible)
-        {
-            return false;
-        }
-
         if (x.UsesBackingStore != y.UsesBackingStore)
         {
             return false;
@@ -73,7 +68,6 @@ public override int GetHashCode([DisallowNull] ApiClientConfiguration obj)
         hash.Add(obj.ClientNamespaceName, _stringComparer);
         hash.Add(obj.Language, _stringComparer);
         hash.Add(obj.TypeAccessModifier, _stringComparer);
-        hash.Add(obj.ExcludeBackwardCompatible);
         hash.Add(obj.UsesBackingStore);
         hash.Add(obj.IncludeAdditionalData);
         hash.Add(obj.StructuredMimeTypes, _stringIEnumerableDeepComparer);

ReQuesty.Builder/Writers/LanguageWriter.cs

@@ -177,7 +177,7 @@ protected void AddOrReplaceCodeElementWriter<T>(ICodeElementWriter<T> writer) wh
         }
     }
     private readonly Dictionary<Type, object> Writers = []; // we have to type as object because dotnet doesn't have type capture i.e eq for `? extends CodeElement`
-    public static LanguageWriter GetLanguageWriter(GenerationLanguage language, string outputPath, string clientNamespaceName, bool usesBackingStore = false, bool excludeBackwardCompatible = false)
+    public static LanguageWriter GetLanguageWriter(GenerationLanguage language, string outputPath, string clientNamespaceName, bool usesBackingStore = false)
     {
         return language switch
         {

ReQuesty/Consts/CommandLineOptions.cs

@@ -33,9 +33,6 @@ public static class CommandLineOptions
     public const string DisableValidationRulesOption = "--disable-validation-rules";
     public const string DisableValidationRulesShortOption = "--dvr";
 
-    public const string ExcludeBackwardCompatibleOption = "--exclude-backward-compatible";
-    public const string ExcludeBackwardCompatibleShortOption = "--ebc";
-
     public const string ExcludePathOption = "--exclude-path";
     public const string ExcludePathShortOption = "-e";
 

ReQuesty/Handlers/ReQuestyGenerateCommandHandler.cs

@@ -21,7 +21,6 @@ public override async Task<int> InvokeAsync(ParseResult context, CancellationTok
         string? openapi = context.GetValue<string?>(CommandLineOptions.DescriptionOption);
         string? manifest = context.GetValue<string?>(CommandLineOptions.ManifestOption);
         bool backingStore = context.GetValue<bool>(CommandLineOptions.BackingStoreOption);
-        bool excludeBackwardCompatible = context.GetValue<bool>(CommandLineOptions.ExcludeBackwardCompatibleOption);
         bool clearCache = context.GetValue<bool>(CommandLineOptions.ClearCacheOption);
         bool disableSSLValidation = context.GetValue<bool>(CommandLineOptions.DisableSSLValidationOption);
         bool includeAdditionalData = context.GetValue<bool>(CommandLineOptions.AdditionalDataOption);
@@ -48,7 +47,6 @@ public override async Task<int> InvokeAsync(ParseResult context, CancellationTok
         AssignIfNotNullOrEmpty(namespaceName, (c, s) => c.ClientNamespaceName = s);
         Configuration.Generation.TypeAccessModifier = typeAccessModifier;
         Configuration.Generation.UsesBackingStore = backingStore;
-        Configuration.Generation.ExcludeBackwardCompatible = excludeBackwardCompatible;
         Configuration.Generation.IncludeAdditionalData = includeAdditionalData;
         Configuration.Generation.Language = GenerationLanguage.CSharp;