diff --git a/src/Kiota.Builder/Export/PublicAPIExportService.cs b/src/Kiota.Builder/Export/PublicAPIExportService.cs index a3a912efb0..81c74117ec 100644 --- a/src/Kiota.Builder/Export/PublicAPIExportService.cs +++ b/src/Kiota.Builder/Export/PublicAPIExportService.cs @@ -116,7 +116,8 @@ private static ILanguageConventionService GetLanguageConventionServiceFromConfig { return generationConfiguration.Language switch { - GenerationLanguage.CSharp => new CSharpConventionService(), + GenerationLanguage.CSharp => new CSharpConventionService(false), + GenerationLanguage.CSharp13 => new CSharpConventionService(true), GenerationLanguage.Java => new JavaConventionService(), GenerationLanguage.TypeScript => new TypeScriptConventionService(), GenerationLanguage.PHP => new PhpConventionService(), diff --git a/src/Kiota.Builder/GenerationLanguage.cs b/src/Kiota.Builder/GenerationLanguage.cs index 99dfd831f2..4e47ea1c38 100644 --- a/src/Kiota.Builder/GenerationLanguage.cs +++ b/src/Kiota.Builder/GenerationLanguage.cs @@ -2,6 +2,7 @@ public enum GenerationLanguage { CSharp, + CSharp13, Java, TypeScript, PHP, diff --git a/src/Kiota.Builder/KiotaBuilder.cs b/src/Kiota.Builder/KiotaBuilder.cs index 8025360676..158d998950 100644 --- a/src/Kiota.Builder/KiotaBuilder.cs +++ b/src/Kiota.Builder/KiotaBuilder.cs @@ -1277,7 +1277,7 @@ private void AddErrorMappingToExecutorMethod(OpenApiUrlTreeNode currentNode, Ope { var suffix = $"{operationType}Response"; var modelType = CreateModelDeclarations(currentNode, schema, operation, parentClass, suffix); - if (modelType is not null && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.Go && modelType.Name.EndsWith(suffix, StringComparison.Ordinal)) + if (modelType is not null && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.CSharp13 or GenerationLanguage.Go && modelType.Name.EndsWith(suffix, StringComparison.Ordinal)) { //TODO remove for v2 var obsoleteTypeName = modelType.Name[..^suffix.Length] + "Response"; if (modelType is CodeType codeType && @@ -2530,7 +2530,7 @@ private void AddPropertyForQueryParameter(OpenApiUrlTreeNode node, OperationType if (!parameterClass.ContainsPropertyWithWireName(prop.WireName)) { - if (addBackwardCompatibleParameter && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.Go) + if (addBackwardCompatibleParameter && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.CSharp13 or GenerationLanguage.Go) { //TODO remove for v2 var modernProp = (CodeProperty)prop.Clone(); modernProp.Name = $"{prop.Name}As{modernProp.Type.Name.ToFirstCharacterUpperCase()}"; diff --git a/src/Kiota.Builder/Refiners/ILanguageRefiner.cs b/src/Kiota.Builder/Refiners/ILanguageRefiner.cs index 3573e98671..23477325ac 100644 --- a/src/Kiota.Builder/Refiners/ILanguageRefiner.cs +++ b/src/Kiota.Builder/Refiners/ILanguageRefiner.cs @@ -14,6 +14,7 @@ public static async Task RefineAsync(GenerationConfiguration config, CodeNamespa switch (config.Language) { case GenerationLanguage.CSharp: + case GenerationLanguage.CSharp13: await new CSharpRefiner(config).RefineAsync(generatedCode, cancellationToken).ConfigureAwait(false); break; case GenerationLanguage.TypeScript: diff --git a/src/Kiota.Builder/Writers/CLI/CliWriter.cs b/src/Kiota.Builder/Writers/CLI/CliWriter.cs index ce03c5c07a..3f7dd93855 100644 --- a/src/Kiota.Builder/Writers/CLI/CliWriter.cs +++ b/src/Kiota.Builder/Writers/CLI/CliWriter.cs @@ -3,9 +3,9 @@ namespace Kiota.Builder.Writers.Cli; class CliWriter : CSharpWriter { - public CliWriter(string rootPath, string clientNamespaceName) : base(rootPath, clientNamespaceName) + public CliWriter(string rootPath, string clientNamespaceName) : base(rootPath, clientNamespaceName, false) { - var conventionService = new CSharpConventionService(); + var conventionService = new CSharpConventionService(false); AddOrReplaceCodeElementWriter(new CodeClassDeclarationWriter(conventionService)); AddOrReplaceCodeElementWriter(new CodeBlockEndWriter(conventionService)); AddOrReplaceCodeElementWriter(new CodeEnumWriter(conventionService)); diff --git a/src/Kiota.Builder/Writers/CSharp/CSharpConventionService.cs b/src/Kiota.Builder/Writers/CSharp/CSharpConventionService.cs index 46a6fda2f0..3588e525cc 100644 --- a/src/Kiota.Builder/Writers/CSharp/CSharpConventionService.cs +++ b/src/Kiota.Builder/Writers/CSharp/CSharpConventionService.cs @@ -9,7 +9,7 @@ using static Kiota.Builder.CodeDOM.CodeTypeBase; namespace Kiota.Builder.Writers.CSharp; -public class CSharpConventionService : CommonLanguageConventionService +public class CSharpConventionService(bool useCSharp13 = false) : CommonLanguageConventionService { public override string StreamTypeName => "stream"; public override string VoidTypeName => "void"; @@ -23,6 +23,7 @@ public class CSharpConventionService : CommonLanguageConventionService public const string CS0618 = "CS0618"; public const string CS1591 = "CS1591"; + public bool UseCSharp13 => useCSharp13; public static void WriteNullableOpening(LanguageWriter writer) { @@ -41,6 +42,49 @@ public static void WriteNullableClosing(LanguageWriter writer) ArgumentNullException.ThrowIfNull(writer); writer.WriteLine("#endif", false); } + public static void WriteStartingBlock( + LanguageWriter writer, + string line + ) + { + ArgumentNullException.ThrowIfNull(writer); + writer.WriteLine(line); + writer.WriteLine("{"); + } + public void WriteNullableAware( + LanguageWriter writer, + bool includeNullableReferenceType, + Action nullableCallback, + Action nonNullableCallback) + { + ArgumentNullException.ThrowIfNull(nullableCallback); + ArgumentNullException.ThrowIfNull(nonNullableCallback); + + if (!UseCSharp13) + { + if (includeNullableReferenceType) + { + WriteNullableOpening(writer); + nullableCallback(writer); + WriteNullableMiddle(writer); + } + nonNullableCallback(writer); + + if (includeNullableReferenceType) + WriteNullableClosing(writer); + } + else + { + if (includeNullableReferenceType) + { + nullableCallback(writer); + } + else + { + nonNullableCallback(writer); + } + } + } public void WritePragmaDisable(LanguageWriter writer, string code) { ArgumentNullException.ThrowIfNull(writer); @@ -132,6 +176,8 @@ internal void AddParametersAssignment(LanguageWriter writer, CodeTypeBase pathPa { if (nameof(String).Equals(ct.Name, StringComparison.OrdinalIgnoreCase)) nullCheck = $"if (!string.IsNullOrWhiteSpace({identName})) "; + else if (UseCSharp13) + nullCheck = $"if ({identName} is not null) "; else nullCheck = $"if ({identName} != null) "; } diff --git a/src/Kiota.Builder/Writers/CSharp/CSharpWriter.cs b/src/Kiota.Builder/Writers/CSharp/CSharpWriter.cs index 287b4db588..59ca6ca57d 100644 --- a/src/Kiota.Builder/Writers/CSharp/CSharpWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CSharpWriter.cs @@ -3,10 +3,10 @@ namespace Kiota.Builder.Writers.CSharp; public class CSharpWriter : LanguageWriter { - public CSharpWriter(string rootPath, string clientNamespaceName) + public CSharpWriter(string rootPath, string clientNamespaceName, bool useCSharp13) { PathSegmenter = new CSharpPathSegmenter(rootPath, clientNamespaceName); - var conventionService = new CSharpConventionService(); + var conventionService = new CSharpConventionService(useCSharp13); AddOrReplaceCodeElementWriter(new CodeClassDeclarationWriter(conventionService)); AddOrReplaceCodeElementWriter(new CodeBlockEndWriter(conventionService)); AddOrReplaceCodeElementWriter(new CodeEnumWriter(conventionService)); diff --git a/src/Kiota.Builder/Writers/CSharp/CodeBlockEndWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodeBlockEndWriter.cs index eb4c37b125..012c4c79c4 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodeBlockEndWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodeBlockEndWriter.cs @@ -11,7 +11,10 @@ public override void WriteCodeElement(BlockEnd codeElement, LanguageWriter write writer.CloseBlock(); if (codeElement?.Parent is CodeClass codeClass && codeClass.Parent is CodeNamespace) { - writer.CloseBlock(); + if (!conventions.UseCSharp13) + { + writer.CloseBlock(); + } conventions.WritePragmaRestore(writer, CSharpConventionService.CS0618); } } diff --git a/src/Kiota.Builder/Writers/CSharp/CodeClassDeclarationWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodeClassDeclarationWriter.cs index b4cd43c2d1..4292188e26 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodeClassDeclarationWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodeClassDeclarationWriter.cs @@ -18,6 +18,10 @@ public override void WriteCodeElement(ClassDeclaration codeElement, LanguageWrit if (codeElement.Parent?.Parent is CodeNamespace) { writer.WriteLine(AutoGenerationHeader); + if (conventions.UseCSharp13) + { + writer.WriteLine(CSharpConventionService.NullableEnableDirective); + } conventions.WritePragmaDisable(writer, CSharpConventionService.CS0618); codeElement.Usings .Where(x => (x.Declaration?.IsExternal ?? true) || !x.Declaration.Name.Equals(codeElement.Name, StringComparison.OrdinalIgnoreCase)) // needed for circular requests patterns like message folder @@ -28,8 +32,11 @@ public override void WriteCodeElement(ClassDeclaration codeElement, LanguageWrit .OrderBy(static x => x, StringComparer.Ordinal) .ToList() .ForEach(x => writer.WriteLine(x)); - writer.WriteLine($"namespace {codeElement.Parent.Parent.Name}"); - writer.StartBlock(); + writer.WriteLine($"namespace {codeElement.Parent.Parent.Name}" + (conventions.UseCSharp13 ? ";" : string.Empty)); + if (!conventions.UseCSharp13) + { + writer.StartBlock(); + } } var derivedTypes = (codeElement.Inherits is null ? Enumerable.Empty() : new string?[] { conventions.GetTypeString(codeElement.Inherits, parentClass) }) diff --git a/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs index b2a97e360b..72794c6842 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs @@ -625,27 +625,23 @@ private void WriteMethodPrototype(CodeMethod code, CodeClass parentClass, Langua var baseSuffix = GetBaseSuffix(isConstructor, inherits, parentClass, code); var parameters = string.Join(", ", code.Parameters.OrderBy(x => x, parameterOrderComparer).Select(p => conventions.GetParameterSignature(p, code)).ToList()); var methodName = isConstructor ? parentClass.Name.ToFirstCharacterUpperCase() : code.Name.ToFirstCharacterUpperCase(); + var accessModifier = conventions.GetAccessModifier(code.Access); var includeNullableReferenceType = code.IsOfKind(CodeMethodKind.RequestExecutor, CodeMethodKind.RequestGenerator); - if (includeNullableReferenceType) - { - var completeReturnTypeWithNullable = isConstructor || string.IsNullOrEmpty(genericTypeSuffix) ? completeReturnType : $"{completeReturnType[..^2].TrimEnd('?')}?{genericTypeSuffix} "; - var nullableParameters = string.Join(", ", code.Parameters.Order(parameterOrderComparer) - .Select(p => p.IsOfKind(CodeParameterKind.RequestConfiguration) ? - GetParameterSignatureWithNullableRefType(p, code) : - conventions.GetParameterSignature(p, code)) - .ToList()); - CSharpConventionService.WriteNullableOpening(writer); - writer.WriteLine($"{conventions.GetAccessModifier(code.Access)} {staticModifier}{hideModifier}{completeReturnTypeWithNullable}{methodName}({nullableParameters}){baseSuffix}"); - writer.WriteLine("{"); - CSharpConventionService.WriteNullableMiddle(writer); - } - - writer.WriteLine($"{conventions.GetAccessModifier(code.Access)} {staticModifier}{hideModifier}{completeReturnType}{methodName}({parameters}){baseSuffix}"); - writer.WriteLine("{"); - - if (includeNullableReferenceType) - CSharpConventionService.WriteNullableClosing(writer); + var completeReturnTypeWithNullable = isConstructor || string.IsNullOrEmpty(genericTypeSuffix) ? completeReturnType : $"{completeReturnType[..^2].TrimEnd('?')}?{genericTypeSuffix} "; + var nullableParameters = string.Join(", ", code.Parameters.Order(parameterOrderComparer) + .Select(p => p.IsOfKind(CodeParameterKind.RequestConfiguration) ? + GetParameterSignatureWithNullableRefType(p, code) : + conventions.GetParameterSignature(p, code)) + .ToList()); + var nullableSignature = $"{accessModifier} {staticModifier}{hideModifier}{completeReturnTypeWithNullable}{methodName}({nullableParameters}){baseSuffix}"; + var nonNullableSignature = $"{accessModifier} {staticModifier}{hideModifier}{completeReturnType}{methodName}({parameters}){baseSuffix}"; + conventions.WriteNullableAware( + writer, + includeNullableReferenceType, + writer => CSharpConventionService.WriteStartingBlock(writer, nullableSignature), + writer => CSharpConventionService.WriteStartingBlock(writer, nonNullableSignature) + ); } private string GetParameterSignatureWithNullableRefType(CodeParameter parameter, CodeElement targetElement) diff --git a/src/Kiota.Builder/Writers/CSharp/CodePropertyWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodePropertyWriter.cs index 07d2272db5..6bf36994a2 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodePropertyWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodePropertyWriter.cs @@ -18,17 +18,12 @@ public override void WriteCodeElement(CodeProperty codeElement, LanguageWriter w CodePropertyKind.QueryParameter);// Other property types are appropriately constructor initialized conventions.WriteShortDescription(codeElement, writer); conventions.WriteDeprecationAttribute(codeElement, writer); - if (isNullableReferenceType) - { - CSharpConventionService.WriteNullableOpening(writer); - WritePropertyInternal(codeElement, writer, $"{propertyType}?"); - CSharpConventionService.WriteNullableMiddle(writer); - } - - WritePropertyInternal(codeElement, writer, propertyType);// Always write the normal way - - if (isNullableReferenceType) - CSharpConventionService.WriteNullableClosing(writer); + conventions.WriteNullableAware( + writer, + isNullableReferenceType, + writer => WritePropertyInternal(codeElement, writer, $"{propertyType}?"), + writer => WritePropertyInternal(codeElement, writer, propertyType) + ); } private void WritePropertyInternal(CodeProperty codeElement, LanguageWriter writer, string propertyType) @@ -38,10 +33,12 @@ private void WritePropertyInternal(CodeProperty codeElement, LanguageWriter writ var setterAccessModifier = codeElement.ReadOnly && codeElement.Access > AccessModifier.Private ? "private " : string.Empty; var simpleBody = $"get; {setterAccessModifier}set;"; var defaultValue = string.Empty; + var accessModifier = conventions.GetAccessModifier(codeElement.Access); + var codeElementNameFirstCharacterUpperCase = codeElement.Name.ToFirstCharacterUpperCase(); switch (codeElement.Kind) { case CodePropertyKind.RequestBuilder: - writer.WriteLine($"{conventions.GetAccessModifier(codeElement.Access)} {propertyType} {codeElement.Name.ToFirstCharacterUpperCase()}"); + writer.WriteLine($"{accessModifier} {propertyType} {codeElementNameFirstCharacterUpperCase}"); writer.StartBlock(); writer.Write("get => "); conventions.AddRequestBuilderBody(parentClass, propertyType, writer, includeIndent: false); @@ -52,7 +49,7 @@ private void WritePropertyInternal(CodeProperty codeElement, LanguageWriter writ var backingStoreKey = codeElement.WireName; var nullableOp = !codeElement.IsOfKind(CodePropertyKind.AdditionalData) ? "?" : string.Empty; var defaultPropertyValue = codeElement.IsOfKind(CodePropertyKind.AdditionalData) ? " ?? new Dictionary()" : string.Empty; - writer.WriteLine($"{conventions.GetAccessModifier(codeElement.Access)} {propertyType} {codeElement.Name.ToFirstCharacterUpperCase()}"); + writer.WriteLine($"{accessModifier} {propertyType} {codeElementNameFirstCharacterUpperCase}"); writer.StartBlock(); writer.WriteLine($"get {{ return {backingStoreProperty.Name.ToFirstCharacterUpperCase()}{nullableOp}.Get<{propertyType}>(\"{backingStoreKey}\"){defaultPropertyValue}; }}"); writer.WriteLine($"set {{ {backingStoreProperty.Name.ToFirstCharacterUpperCase()}{nullableOp}.Set(\"{backingStoreKey}\", value); }}"); @@ -60,9 +57,9 @@ private void WritePropertyInternal(CodeProperty codeElement, LanguageWriter writ break; case CodePropertyKind.ErrorMessageOverride when parentClass.IsErrorDefinition: if (parentClass.GetPrimaryMessageCodePath(static x => x.Name.ToFirstCharacterUpperCase(), static x => x.Name.ToFirstCharacterUpperCase(), "?.") is string primaryMessageCodePath && !string.IsNullOrEmpty(primaryMessageCodePath)) - writer.WriteLine($"public override {propertyType} {codeElement.Name.ToFirstCharacterUpperCase()} {{ get => {primaryMessageCodePath} ?? string.Empty; }}"); + writer.WriteLine($"public override {propertyType} {codeElementNameFirstCharacterUpperCase} {{ get => {primaryMessageCodePath} ?? string.Empty; }}"); else - writer.WriteLine($"public override {propertyType} {codeElement.Name.ToFirstCharacterUpperCase()} {{ get => base.Message; }}"); + writer.WriteLine($"public override {propertyType} {codeElementNameFirstCharacterUpperCase} {{ get => base.Message; }}"); break; case CodePropertyKind.QueryParameter when codeElement.IsNameEscaped: writer.WriteLine($"[QueryParameter(\"{codeElement.SerializationName}\")]"); @@ -71,7 +68,7 @@ private void WritePropertyInternal(CodeProperty codeElement, LanguageWriter writ defaultValue = $" = new {propertyType}();"; goto default; default: - writer.WriteLine($"{conventions.GetAccessModifier(codeElement.Access)} {propertyType} {codeElement.Name.ToFirstCharacterUpperCase()} {{ {simpleBody} }}{defaultValue}"); + writer.WriteLine($"{accessModifier} {propertyType} {codeElementNameFirstCharacterUpperCase} {{ {simpleBody} }}{defaultValue}"); break; } } diff --git a/src/Kiota.Builder/Writers/LanguageWriter.cs b/src/Kiota.Builder/Writers/LanguageWriter.cs index d181eb5ba1..bdd2c1a291 100644 --- a/src/Kiota.Builder/Writers/LanguageWriter.cs +++ b/src/Kiota.Builder/Writers/LanguageWriter.cs @@ -184,7 +184,8 @@ public static LanguageWriter GetLanguageWriter(GenerationLanguage language, stri { return language switch { - GenerationLanguage.CSharp => new CSharpWriter(outputPath, clientNamespaceName), + GenerationLanguage.CSharp => new CSharpWriter(outputPath, clientNamespaceName, false), + GenerationLanguage.CSharp13 => new CSharpWriter(outputPath, clientNamespaceName, true), GenerationLanguage.Java => new JavaWriter(outputPath, clientNamespaceName), GenerationLanguage.TypeScript => new TypeScriptWriter(outputPath, clientNamespaceName), GenerationLanguage.Ruby => new RubyWriter(outputPath, clientNamespaceName), diff --git a/tests/Kiota.Builder.IntegrationTests/GenerateSample.cs b/tests/Kiota.Builder.IntegrationTests/GenerateSample.cs index d79948aa93..54481d4102 100644 --- a/tests/Kiota.Builder.IntegrationTests/GenerateSample.cs +++ b/tests/Kiota.Builder.IntegrationTests/GenerateSample.cs @@ -17,12 +17,14 @@ public void Dispose() } private readonly HttpClient _httpClient = new(); [InlineData(GenerationLanguage.CSharp, false)] + [InlineData(GenerationLanguage.CSharp13, false)] [InlineData(GenerationLanguage.Java, false)] [InlineData(GenerationLanguage.TypeScript, false)] [InlineData(GenerationLanguage.Go, false)] [InlineData(GenerationLanguage.Dart, false)] [InlineData(GenerationLanguage.Ruby, false)] [InlineData(GenerationLanguage.CSharp, true)] + [InlineData(GenerationLanguage.CSharp13, true)] [InlineData(GenerationLanguage.Java, true)] [InlineData(GenerationLanguage.PHP, false)] [InlineData(GenerationLanguage.TypeScript, true)] @@ -45,12 +47,14 @@ public async Task GeneratesTodoAsync(GenerationLanguage language, bool backingSt await new KiotaBuilder(logger, configuration, _httpClient).GenerateClientAsync(new()); } [InlineData(GenerationLanguage.CSharp, false)] + [InlineData(GenerationLanguage.CSharp13, false)] [InlineData(GenerationLanguage.Java, false)] [InlineData(GenerationLanguage.TypeScript, false)] [InlineData(GenerationLanguage.Go, false)] [InlineData(GenerationLanguage.Dart, false)] [InlineData(GenerationLanguage.Ruby, false)] [InlineData(GenerationLanguage.CSharp, true)] + [InlineData(GenerationLanguage.CSharp13, true)] [InlineData(GenerationLanguage.Java, true)] [InlineData(GenerationLanguage.PHP, false)] [InlineData(GenerationLanguage.TypeScript, true)] @@ -73,12 +77,14 @@ public async Task GeneratesModelWithDictionaryAsync(GenerationLanguage language, await new KiotaBuilder(logger, configuration, _httpClient).GenerateClientAsync(new()); } [InlineData(GenerationLanguage.CSharp, false)] + [InlineData(GenerationLanguage.CSharp13, false)] [InlineData(GenerationLanguage.Java, false)] [InlineData(GenerationLanguage.TypeScript, false)] [InlineData(GenerationLanguage.Go, false)] [InlineData(GenerationLanguage.Dart, false)] [InlineData(GenerationLanguage.Ruby, false)] [InlineData(GenerationLanguage.CSharp, true)] + [InlineData(GenerationLanguage.CSharp13, true)] [InlineData(GenerationLanguage.Java, true)] [InlineData(GenerationLanguage.PHP, false)] [InlineData(GenerationLanguage.TypeScript, true)] @@ -101,6 +107,7 @@ public async Task GeneratesResponseWithMultipleReturnFormatsAsync(GenerationLang await new KiotaBuilder(logger, configuration, _httpClient).GenerateClientAsync(new()); } [InlineData(GenerationLanguage.CSharp)] + [InlineData(GenerationLanguage.CSharp13)] [InlineData(GenerationLanguage.Java)] [InlineData(GenerationLanguage.Go)] [InlineData(GenerationLanguage.Dart)] @@ -124,6 +131,7 @@ public async Task GeneratesErrorsInliningParentsAsync(GenerationLanguage languag await new KiotaBuilder(logger, configuration, _httpClient).GenerateClientAsync(new()); } [InlineData(GenerationLanguage.CSharp)] + [InlineData(GenerationLanguage.CSharp13)] [InlineData(GenerationLanguage.Java)] [InlineData(GenerationLanguage.Go)] [InlineData(GenerationLanguage.Dart)] @@ -174,6 +182,7 @@ public async Task GeneratesIdiomaticChildrenNamesAsync(GenerationLanguage langua Assert.DoesNotContain("_", fullText); } [InlineData(GenerationLanguage.CSharp)] + [InlineData(GenerationLanguage.CSharp13)] [InlineData(GenerationLanguage.Go)] [InlineData(GenerationLanguage.Dart)] [InlineData(GenerationLanguage.Java)] @@ -208,6 +217,7 @@ public async Task GeneratesUritemplateHintsAsync(GenerationLanguage language) switch (language) { case GenerationLanguage.CSharp: + case GenerationLanguage.CSharp13: Assert.Contains("[QueryParameter(\"startDateTime\")]", fullText); break; case GenerationLanguage.Dart: diff --git a/tests/Kiota.Builder.Tests/Export/PublicAPIExportServiceTests.cs b/tests/Kiota.Builder.Tests/Export/PublicAPIExportServiceTests.cs index 080e14f6a4..a5ee0d7ac1 100644 --- a/tests/Kiota.Builder.Tests/Export/PublicAPIExportServiceTests.cs +++ b/tests/Kiota.Builder.Tests/Export/PublicAPIExportServiceTests.cs @@ -76,6 +76,7 @@ public void Defensive() private static readonly Dictionary> Validators = new() { { GenerationLanguage.CSharp, ValidateExportCSharp }, + { GenerationLanguage.CSharp13, ValidateExportCSharp }, { GenerationLanguage.Go, ValidateExportGo }, { GenerationLanguage.Python, ValidateExportPython }, { GenerationLanguage.TypeScript, ValidateExportTypeScript }, @@ -85,6 +86,7 @@ public void Defensive() [Theory] [InlineData(GenerationLanguage.CSharp)] + [InlineData(GenerationLanguage.CSharp13)] [InlineData(GenerationLanguage.Go)] [InlineData(GenerationLanguage.Python)] [InlineData(GenerationLanguage.TypeScript)] diff --git a/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs b/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs index 7acf60fbb3..adce3c2f4b 100644 --- a/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs +++ b/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs @@ -583,6 +583,7 @@ public async Task DoesntConflictOnModelsNamespaceAsync() } [Theory] [InlineData(GenerationLanguage.CSharp)] + [InlineData(GenerationLanguage.CSharp13)] [InlineData(GenerationLanguage.Java)] [InlineData(GenerationLanguage.TypeScript)] [InlineData(GenerationLanguage.Python)] @@ -4755,6 +4756,7 @@ public void MapsQueryParameterArrayTypes() Assert.True(property.Type.AllTypes.First().IsExternal); } [InlineData(GenerationLanguage.CSharp)] + [InlineData(GenerationLanguage.CSharp13)] [InlineData(GenerationLanguage.Java)] [Theory] public void MapsEnumQueryParameterType(GenerationLanguage generationLanguage) @@ -4798,7 +4800,7 @@ public void MapsEnumQueryParameterType(GenerationLanguage generationLanguage) Assert.NotNull(queryParameters); var backwardCompatibleProperty = queryParameters.Properties.FirstOrDefault(static x => x.Name.Equals("query", StringComparison.OrdinalIgnoreCase)); Assert.NotNull(backwardCompatibleProperty); - if (generationLanguage is GenerationLanguage.CSharp) + if (generationLanguage is GenerationLanguage.CSharp or GenerationLanguage.CSharp13) { Assert.Equal("string", backwardCompatibleProperty.Type.Name); Assert.True(backwardCompatibleProperty.Type.AllTypes.First().IsExternal); diff --git a/tests/Kiota.Builder.Tests/Writers/CSharp/CSharpWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/CSharp/CSharpWriterTests.cs index 06dcbded3f..c65e6bbb7a 100644 --- a/tests/Kiota.Builder.Tests/Writers/CSharp/CSharpWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/CSharp/CSharpWriterTests.cs @@ -10,10 +10,10 @@ public class CSharpWriterTests [Fact] public void Instantiates() { - var writer = new CSharpWriter("./", "graph"); + var writer = new CSharpWriter("./", "graph", false); Assert.NotNull(writer); Assert.NotNull(writer.PathSegmenter); - Assert.Throws(() => new CSharpWriter(null, "graph")); - Assert.Throws(() => new CSharpWriter("./", null)); + Assert.Throws(() => new CSharpWriter(null, "graph", false)); + Assert.Throws(() => new CSharpWriter("./", null, false)); } }