Merge pull request #1831 from microsoft/bugfix/parse-node-type

bugfix/parse node type

CHANGELOG.md

@@ -9,10 +9,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+### Changed
+
+## [0.5.1] - 2022-09-09
+
+### Added
+
 - Exempts read only properties from being serialized and sent to the service. [#1828](https://github.com/microsoft/kiota/issues/1828)
 
 ### Changed
 
+- Fixed a regression where parse node parameter type for factories would be incorrect in Go, Ruby, Swift, Java and TypeScript.
+
 ## [0.5.0] - 2022-09-08
 
 ### Added

src/Kiota.Builder/Kiota.Builder.csproj

@@ -12,7 +12,7 @@
     <Title>Microsoft.OpenApi.Kiota.Builder</Title>
     <PackageId>Microsoft.OpenApi.Kiota.Builder</PackageId>
     <PackageOutputPath>./nupkg</PackageOutputPath>
-    <Version>0.5.0-preview</Version>
+    <Version>0.5.1-preview</Version>
     <PackageReleaseNotes>
       https://github.com/microsoft/kiota/releases
     </PackageReleaseNotes>

src/Kiota.Builder/Refiners/GoRefiner.cs

@@ -306,12 +306,16 @@ private static void CorrectMethodType(CodeMethod currentMethod) {
             if(rawUrlParam != null)
                 rawUrlParam.Type.IsNullable = false;
             currentMethod.Parameters.Where(x => x.IsOfKind(CodeParameterKind.RequestAdapter))
-                .Where(x => x.Type.Name.StartsWith("I", StringComparison.InvariantCultureIgnoreCase))
+                .Where(static x => x.Type.Name.StartsWith("I", StringComparison.InvariantCultureIgnoreCase))
                 .ToList()
-                .ForEach(x => x.Type.Name = x.Type.Name[1..]); // removing the "I"
+                .ForEach(static x => x.Type.Name = x.Type.Name[1..]); // removing the "I"
         } else if(currentMethod.IsOfKind(CodeMethodKind.IndexerBackwardCompatibility, CodeMethodKind.RequestBuilderWithParameters, CodeMethodKind.RequestBuilderBackwardCompatibility, CodeMethodKind.Factory)) {
             currentMethod.ReturnType.IsNullable = true;
-            currentMethod.Parameters.Where(x => x.IsOfKind(CodeParameterKind.ParseNode)).ToList().ForEach(x => x.Type.IsNullable = false);
+            if (currentMethod.Parameters.OfKind(CodeParameterKind.ParseNode) is CodeParameter parseNodeParam) {
+                parseNodeParam.Type.IsNullable = false;
+                parseNodeParam.Type.Name = parseNodeParam.Type.Name[1..];
+            }
+
             if(currentMethod.IsOfKind(CodeMethodKind.Factory))
                 currentMethod.ReturnType = new CodeType { Name = "Parsable", IsNullable = false, IsExternal = true };
         }

src/Kiota.Builder/Refiners/JavaRefiner.cs

@@ -199,7 +199,8 @@ private static void CorrectMethodType(CodeMethod currentMethod) {
             var urlTplParams = currentMethod.Parameters.FirstOrDefault(x => x.IsOfKind(CodeParameterKind.PathParameters));
             if(urlTplParams != null)
                 urlTplParams.Type.Name = "HashMap<String, Object>";
-        }
+        } else if(currentMethod.IsOfKind(CodeMethodKind.Factory) && currentMethod.Parameters.OfKind(CodeParameterKind.ParseNode) is CodeParameter parseNodeParam)
+            parseNodeParam.Type.Name = parseNodeParam.Type.Name[1..];
         CorrectDateTypes(currentMethod.Parent as CodeClass, DateTypesReplacements, currentMethod.Parameters
                                                 .Select(x => x.Type)
                                                 .Union(new CodeTypeBase[] { currentMethod.ReturnType})

src/Kiota.Builder/Refiners/PhpRefiner.cs

@@ -187,7 +187,7 @@ private static void CorrectMethodType(CodeMethod method)
                 method.ReturnType.Name = "array";
             }
             CorrectDateTypes(method.Parent as CodeClass, DateTypesReplacements, method.Parameters
-                .Select(x => x.Type)
+                .Select(static x => x.Type)
                 .Union(new CodeTypeBase[] { method.ReturnType})
                 .ToArray());
         }

src/Kiota.Builder/Refiners/PythonRefiner.cs

@@ -136,9 +136,9 @@ private static void CorrectMethodType(CodeMethod currentMethod) {
             currentMethod.ReturnType.Name = $"Dict[str, Callable[[ParseNode], None]]";
         else if(currentMethod.IsOfKind(CodeMethodKind.ClientConstructor, CodeMethodKind.Constructor, CodeMethodKind.Factory)) {
             currentMethod.Parameters.Where(x => x.IsOfKind(CodeParameterKind.RequestAdapter, CodeParameterKind.BackingStore, CodeParameterKind.ParseNode))
-                .Where(x => x.Type.Name.StartsWith("I", StringComparison.InvariantCultureIgnoreCase))
+                .Where(static x => x.Type.Name.StartsWith("I", StringComparison.InvariantCultureIgnoreCase))
                 .ToList()
-                .ForEach(x => x.Type.Name = x.Type.Name[1..]); // removing the "I"
+                .ForEach(static x => x.Type.Name = x.Type.Name[1..]); // removing the "I"
             var urlTplParams = currentMethod.Parameters.FirstOrDefault(x => x.IsOfKind(CodeParameterKind.PathParameters));
             if(urlTplParams != null &&
                 urlTplParams.Type is CodeType originalType) {

src/Kiota.Builder/Refiners/RubyRefiner.cs

@@ -45,6 +45,8 @@ public override void Refine(CodeNamespace generatedCode)
                                         new [] { "microsoft_kiota_abstractions.ParseNodeFactoryRegistry" });
         }
         private static void CorrectMethodType(CodeMethod currentMethod) {
+            if(currentMethod.IsOfKind(CodeMethodKind.Factory) && currentMethod.Parameters.OfKind(CodeParameterKind.ParseNode) is CodeParameter parseNodeParam)
+                parseNodeParam.Type.Name = parseNodeParam.Type.Name[1..];
             CorrectDateTypes(currentMethod.Parent as CodeClass, DateTypesReplacements, currentMethod.Parameters
                                         .Select(x => x.Type)
                                         .Union(new CodeTypeBase[] { currentMethod.ReturnType})

src/Kiota.Builder/Refiners/SwiftRefiner.cs

@@ -85,7 +85,10 @@ private static void CorrectMethodType(CodeMethod currentMethod) {
                 .ForEach(x => x.Type.Name = x.Type.Name[1..]); // removing the "I"
         } else if(currentMethod.IsOfKind(CodeMethodKind.IndexerBackwardCompatibility, CodeMethodKind.RequestBuilderWithParameters, CodeMethodKind.RequestBuilderBackwardCompatibility, CodeMethodKind.Factory)) {
             currentMethod.ReturnType.IsNullable = true;
-            currentMethod.Parameters.Where(x => x.IsOfKind(CodeParameterKind.ParseNode)).ToList().ForEach(x => x.Type.IsNullable = false);
+            if (currentMethod.Parameters.OfKind(CodeParameterKind.ParseNode) is CodeParameter parseNodeParam) {
+                parseNodeParam.Type.Name = parseNodeParam.Type.Name[1..];
+                parseNodeParam.Type.IsNullable = false;
+            }
             if(currentMethod.IsOfKind(CodeMethodKind.Factory))
                 currentMethod.ReturnType = new CodeType { Name = "Parsable", IsNullable = false, IsExternal = true };
         }

src/Kiota.Builder/Refiners/TypeScriptRefiner.cs

@@ -210,7 +210,8 @@ private static void CorrectMethodType(CodeMethod currentMethod) {
                 });
                 urlTplParams.Type = unionType;
             }
-        }
+        } else if(currentMethod.IsOfKind(CodeMethodKind.Factory) && currentMethod.Parameters.OfKind(CodeParameterKind.ParseNode) is CodeParameter parseNodeParam)
+            parseNodeParam.Type.Name = parseNodeParam.Type.Name[1..];
         CorrectDateTypes(currentMethod.Parent as CodeClass, DateTypesReplacements, currentMethod.Parameters
                                                 .Select(x => x.Type)
                                                 .Union(new CodeTypeBase[] { currentMethod.ReturnType})

src/kiota/kiota.csproj

@@ -14,7 +14,7 @@
     <Title>Microsoft.OpenApi.Kiota</Title>
     <PackageId>Microsoft.OpenApi.Kiota</PackageId>
     <PackageOutputPath>./nupkg</PackageOutputPath>
-    <Version>0.5.0-preview</Version>
+    <Version>0.5.1-preview</Version>
     <PackageReleaseNotes>
       https://github.com/microsoft/kiota/releases
     </PackageReleaseNotes>