Merge branch 'mongodb:main' into VS-153

Ravi-Raghavan · web-flow · commit b24567b1e269 · 2024-07-17T10:06:02.000-04:00
diff --git a/src/MongoDB.Analyzer/Core/Builders/AnalysisCodeGenerator.cs b/src/MongoDB.Analyzer/Core/Builders/AnalysisCodeGenerator.cs
@@ -69,16 +69,20 @@ public static CompilationResult Compile(MongoAnalysisContext context, Expression
     private static SyntaxTree GenerateMqlGeneratorSyntaxTree(ExpressionsAnalysis builderExpressionAnalysis)
     {
         var testCodeBuilder = new BuildersMqlGeneratorTemplateBuilder(s_mqlGeneratorSyntaxElements);
+        var generatedMqlMethodDeclarations = new List<MethodDeclarationSyntax>(builderExpressionAnalysis.AnalysisNodeContexts.Length);
 
         foreach (var builderContext in builderExpressionAnalysis.AnalysisNodeContexts)
         {
             var analysisNode = builderContext.Node;
-
-            builderContext.EvaluationMethodName = testCodeBuilder.AddBuildersExpression(
+            var (generatedMqlMethodName, generatedMqlMethodDeclaration) = testCodeBuilder.GenerateMqlGeneratorMethod(
                 analysisNode.ArgumentTypeName,
                 analysisNode.RewrittenExpression);
+
+            builderContext.EvaluationMethodName = generatedMqlMethodName;
+            generatedMqlMethodDeclarations.Add(generatedMqlMethodDeclaration);
         }
 
+        testCodeBuilder.AddMqlGeneratorMethods(generatedMqlMethodDeclarations.ToArray());
         return testCodeBuilder.GenerateSyntaxTree();
     } 
 }
diff --git a/src/MongoDB.Analyzer/Core/Builders/BuildersMqlGeneratorTemplateBuilder.cs b/src/MongoDB.Analyzer/Core/Builders/BuildersMqlGeneratorTemplateBuilder.cs
@@ -38,22 +38,8 @@ public BuildersMqlGeneratorTemplateBuilder(SyntaxElements syntaxElements)
         _mqlGeneratorDeclarationSyntaxNew = _syntaxElements.ClassDeclarationSyntax;
     }
 
-    public string AddBuildersExpression(string typeArgumentName, SyntaxNode buildersExpression)
-    {
-        var newMethodDeclaration = _syntaxElements.TestMethodNode.ReplaceNodes(_syntaxElements.NodesToReplace, (n, _) =>
-        n switch
-        {
-            _ when n == _syntaxElements.BuilderDefinitionNode => buildersExpression,
-            _ when n == _syntaxElements.CollectionTypeNode => SyntaxFactory.IdentifierName(typeArgumentName),
-            _ => throw new Exception($"Unrecognized node {n}")
-        });
-
-        var newMqlGeneratorMethodName = $"{_syntaxElements.TestMethodNode.Identifier.Value}_{_nextTestMethodIndex++}";
-        newMethodDeclaration = newMethodDeclaration.WithIdentifier(SyntaxFactory.Identifier(newMqlGeneratorMethodName));
-
-        _mqlGeneratorDeclarationSyntaxNew = _mqlGeneratorDeclarationSyntaxNew.AddMembers(newMethodDeclaration);
-        return newMqlGeneratorMethodName;
-    }
+    public void AddMqlGeneratorMethods(MemberDeclarationSyntax[] methodDeclarations) =>
+        _mqlGeneratorDeclarationSyntaxNew = _mqlGeneratorDeclarationSyntaxNew.AddMembers(methodDeclarations);
 
     public static SyntaxElements CreateSyntaxElements(SyntaxTree mqlGeneratorSyntaxTree)
     {
@@ -67,6 +53,22 @@ public static SyntaxElements CreateSyntaxElements(SyntaxTree mqlGeneratorSyntaxT
         return new SyntaxElements(root, classDeclarationSyntax, mainTestMethodNode, builderDefinitionNode, collectionTypeNode);
     }
 
+    public (string newMethodName, MethodDeclarationSyntax newMethodDeclaration) GenerateMqlGeneratorMethod(string typeArgumentName, SyntaxNode buildersExpression)
+    {
+        var newMethodDeclaration = _syntaxElements.TestMethodNode.ReplaceNodes(_syntaxElements.NodesToReplace, (n, _) =>
+            n switch
+            {
+                _ when n == _syntaxElements.BuilderDefinitionNode => buildersExpression,
+                _ when n == _syntaxElements.CollectionTypeNode => SyntaxFactory.IdentifierName(typeArgumentName),
+                _ => throw new Exception($"Unrecognized node {n}")
+            });
+
+        var newMqlGeneratorMethodName = $"{_syntaxElements.TestMethodNode.Identifier.Value}_{_nextTestMethodIndex++}";
+        newMethodDeclaration = newMethodDeclaration.WithIdentifier(SyntaxFactory.Identifier(newMqlGeneratorMethodName));
+
+        return (newMqlGeneratorMethodName, newMethodDeclaration);
+    }
+
     public SyntaxTree GenerateSyntaxTree() =>
         _syntaxElements.Root.ReplaceNode(_syntaxElements.ClassDeclarationSyntax, _mqlGeneratorDeclarationSyntaxNew).SyntaxTree;
 }
diff --git a/src/MongoDB.Analyzer/Core/Linq/AnalysisCodeGenerator.cs b/src/MongoDB.Analyzer/Core/Linq/AnalysisCodeGenerator.cs
@@ -73,16 +73,20 @@ public static CompilationResult Compile(MongoAnalysisContext context, Expression
     private static SyntaxTree GenerateMqlGeneratorSyntaxTree(ExpressionsAnalysis linqExpressionAnalysis)
     {
         var testCodeBuilder = new LinqMqlGeneratorTemplateBuilder(s_mqlGeneratorSyntaxElements);
+        var generatedMqlMethodDeclarations = new List<MethodDeclarationSyntax>(linqExpressionAnalysis.AnalysisNodeContexts.Length);
 
         foreach (var linqContext in linqExpressionAnalysis.AnalysisNodeContexts)
         {
             var analysisNode = linqContext.Node;
-
-            linqContext.EvaluationMethodName = testCodeBuilder.AddLinqExpression(
+            var (generatedMqlMethodName, generatedMqlMethodDeclaration) = testCodeBuilder.GenerateMqlGeneratorMethod(
                 analysisNode.ArgumentTypeName,
                 analysisNode.RewrittenExpression);
+
+            linqContext.EvaluationMethodName = generatedMqlMethodName;
+            generatedMqlMethodDeclarations.Add(generatedMqlMethodDeclaration);
         }
 
+        testCodeBuilder.AddMqlGeneratorMethods(generatedMqlMethodDeclarations.ToArray());
         return testCodeBuilder.GenerateSyntaxTree();
     }
 }
diff --git a/src/MongoDB.Analyzer/Core/Linq/LinqMqlGeneratorTemplateBuilder.cs b/src/MongoDB.Analyzer/Core/Linq/LinqMqlGeneratorTemplateBuilder.cs
@@ -38,23 +38,8 @@ public LinqMqlGeneratorTemplateBuilder(SyntaxElements syntaxElements)
         _mqlGeneratorDeclarationSyntaxNew = _syntaxElements.ClassDeclarationSyntax;
     }
 
-    public string AddLinqExpression(string collectionTypeName, SyntaxNode linqExpression)
-    {
-        var newMethodDeclaration = _syntaxElements.TestMethodNode.ReplaceNodes(_syntaxElements.NodesToReplace, (n, _) =>
-            n.Kind() switch
-            {
-                _ when n == _syntaxElements.LinqExpressionNode => linqExpression,
-                _ when n == _syntaxElements.QueryableTypeNode => SyntaxFactory.IdentifierName(collectionTypeName),
-                _ => throw new Exception($"Unrecognized node {n}")
-            });
-
-        var newMqlGeneratorMethodName = $"{_syntaxElements.TestMethodNode.Identifier.Value}_{ _nextTestMethodIndex++}";
-        newMethodDeclaration = newMethodDeclaration.WithIdentifier(SyntaxFactory.Identifier(newMqlGeneratorMethodName));
-
-        _mqlGeneratorDeclarationSyntaxNew = _mqlGeneratorDeclarationSyntaxNew.AddMembers(newMethodDeclaration);
-
-        return newMqlGeneratorMethodName;
-    }
+    public void AddMqlGeneratorMethods(MemberDeclarationSyntax[] methodDeclarations) =>
+        _mqlGeneratorDeclarationSyntaxNew = _mqlGeneratorDeclarationSyntaxNew.AddMembers(methodDeclarations);
 
     public static SyntaxElements CreateSyntaxElements(SyntaxTree mqlGeneratorSyntaxTree)
     {
@@ -68,6 +53,22 @@ public static SyntaxElements CreateSyntaxElements(SyntaxTree mqlGeneratorSyntaxT
         return new SyntaxElements(root, classDeclarationSyntax, mainTestMethodNode, linqExpressionNode, queryableTypeNode);
     }
 
+    public (string newMethodName, MethodDeclarationSyntax newMethodDeclaration) GenerateMqlGeneratorMethod(string collectionTypeName, SyntaxNode linqExpression)
+    {
+        var newMethodDeclaration = _syntaxElements.TestMethodNode.ReplaceNodes(_syntaxElements.NodesToReplace, (n, _) =>
+            n.Kind() switch
+            {
+                _ when n == _syntaxElements.LinqExpressionNode => linqExpression,
+                _ when n == _syntaxElements.QueryableTypeNode => SyntaxFactory.IdentifierName(collectionTypeName),
+                _ => throw new Exception($"Unrecognized node {n}")
+            });
+
+        var newMqlGeneratorMethodName = $"{_syntaxElements.TestMethodNode.Identifier.Value}_{_nextTestMethodIndex++}";
+        newMethodDeclaration = newMethodDeclaration.WithIdentifier(SyntaxFactory.Identifier(newMqlGeneratorMethodName));
+
+        return (newMqlGeneratorMethodName, newMethodDeclaration);
+    }
+
     public SyntaxTree GenerateSyntaxTree() =>
          _syntaxElements.Root.ReplaceNode(_syntaxElements.ClassDeclarationSyntax, _mqlGeneratorDeclarationSyntaxNew).SyntaxTree;
 }
diff --git a/src/MongoDB.Analyzer/Core/Poco/AnalysisCodeGenerator.cs b/src/MongoDB.Analyzer/Core/Poco/AnalysisCodeGenerator.cs
@@ -60,12 +60,16 @@ public static CompilationResult Compile(MongoAnalysisContext context, Expression
     public static SyntaxTree GenerateJsonGeneratorSyntaxTree(ExpressionsAnalysis pocoExpressionAnalysis)
     {
         var testCodeBuilder = new PocoJsonGeneratorTemplateBuilder(s_jsonGeneratorSyntaxElements);
+        var generatedJsonMethodDeclarations = new List<MethodDeclarationSyntax>(pocoExpressionAnalysis.AnalysisNodeContexts.Length);
 
         foreach (var pocoContext in pocoExpressionAnalysis.AnalysisNodeContexts)
         {
-            pocoContext.EvaluationMethodName = testCodeBuilder.AddPoco(pocoContext.Node.RewrittenExpression as ClassDeclarationSyntax);
+            var (generatedJsonMethodName, generatedJsonMethodDeclaration) = testCodeBuilder.GenerateJsonGeneratorMethod(pocoContext.Node.RewrittenExpression as ClassDeclarationSyntax);
+            pocoContext.EvaluationMethodName = generatedJsonMethodName;
+            generatedJsonMethodDeclarations.Add(generatedJsonMethodDeclaration);
         }
 
+        testCodeBuilder.AddJsonGeneratorMethods(generatedJsonMethodDeclarations.ToArray());
         return testCodeBuilder.GenerateSyntaxTree();
     }
 }
diff --git a/src/MongoDB.Analyzer/Core/Poco/PocoJsonGeneratorTemplateBuilder.cs b/src/MongoDB.Analyzer/Core/Poco/PocoJsonGeneratorTemplateBuilder.cs
@@ -37,15 +37,8 @@ public PocoJsonGeneratorTemplateBuilder(SyntaxElements syntaxElements)
         _jsonGeneratorDeclarationSyntaxNew = _syntaxElements.ClassDeclarationSyntax;
     }
 
-    public string AddPoco(ClassDeclarationSyntax poco)
-    {
-        var newMethodDeclaration = _syntaxElements.TestMethodNode.ReplaceNode(_syntaxElements.PredefinedTypeNode, SyntaxFactory.IdentifierName(poco.Identifier.ValueText));
-        var newJsonGeneratorMethodName = $"{_syntaxElements.TestMethodNode.Identifier.Value}_{_nextTestMethodIndex++}";
-        newMethodDeclaration = newMethodDeclaration.WithIdentifier(SyntaxFactory.Identifier(newJsonGeneratorMethodName));
-
-        _jsonGeneratorDeclarationSyntaxNew = _jsonGeneratorDeclarationSyntaxNew.AddMembers(newMethodDeclaration);
-        return newJsonGeneratorMethodName;
-    }
+    public void AddJsonGeneratorMethods(MemberDeclarationSyntax[] methodDeclarations) =>
+        _jsonGeneratorDeclarationSyntaxNew = _jsonGeneratorDeclarationSyntaxNew.AddMembers(methodDeclarations);
 
     public static SyntaxElements CreateSyntaxElements(SyntaxTree jsonGeneratorSyntaxTree)
     {
@@ -59,6 +52,14 @@ public static SyntaxElements CreateSyntaxElements(SyntaxTree jsonGeneratorSyntax
         return new(root, classDeclarationSyntax, mainTestMethodNode, predefinedType);
     }
 
+    public (string newMethodName, MethodDeclarationSyntax newMethodDeclaration) GenerateJsonGeneratorMethod(ClassDeclarationSyntax poco)
+    {
+        var newMethodDeclaration = _syntaxElements.TestMethodNode.ReplaceNode(_syntaxElements.PredefinedTypeNode, SyntaxFactory.IdentifierName(poco.Identifier.ValueText));
+        var newJsonGeneratorMethodName = $"{_syntaxElements.TestMethodNode.Identifier.Value}_{_nextTestMethodIndex++}";
+        newMethodDeclaration = newMethodDeclaration.WithIdentifier(SyntaxFactory.Identifier(newJsonGeneratorMethodName));
+        return (newJsonGeneratorMethodName, newMethodDeclaration);
+    }
+
     public SyntaxTree GenerateSyntaxTree() =>
         _syntaxElements.Root.ReplaceNode(_syntaxElements.ClassDeclarationSyntax, _jsonGeneratorDeclarationSyntaxNew).SyntaxTree;
 }

Original file line number	Diff line number	Diff line change
`@@ -69,16 +69,20 @@ public static CompilationResult Compile(MongoAnalysisContext context, Expression`
`69`	`69`	`private static SyntaxTree GenerateMqlGeneratorSyntaxTree(ExpressionsAnalysis builderExpressionAnalysis)`
`70`	`70`	`{`
`71`	`71`	`var testCodeBuilder = new BuildersMqlGeneratorTemplateBuilder(s_mqlGeneratorSyntaxElements);`
	`72`	`+ var generatedMqlMethodDeclarations = new List<MethodDeclarationSyntax>(builderExpressionAnalysis.AnalysisNodeContexts.Length);`
`72`	`73`
`73`	`74`	`foreach (var builderContext in builderExpressionAnalysis.AnalysisNodeContexts)`
`74`	`75`	`{`
`75`	`76`	`var analysisNode = builderContext.Node;`
`76`		`-`
`77`		`- builderContext.EvaluationMethodName = testCodeBuilder.AddBuildersExpression(`
	`77`	`+ var (generatedMqlMethodName, generatedMqlMethodDeclaration) = testCodeBuilder.GenerateMqlGeneratorMethod(`
`78`	`78`	`analysisNode.ArgumentTypeName,`
`79`	`79`	`analysisNode.RewrittenExpression);`
	`80`	`+`
	`81`	`+ builderContext.EvaluationMethodName = generatedMqlMethodName;`
	`82`	`+ generatedMqlMethodDeclarations.Add(generatedMqlMethodDeclaration);`
`80`	`83`	`}`
`81`	`84`
	`85`	`+ testCodeBuilder.AddMqlGeneratorMethods(generatedMqlMethodDeclarations.ToArray());`
`82`	`86`	`return testCodeBuilder.GenerateSyntaxTree();`
`83`	`87`	`}`
`84`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,16 +73,20 @@ public static CompilationResult Compile(MongoAnalysisContext context, Expression`
`73`	`73`	`private static SyntaxTree GenerateMqlGeneratorSyntaxTree(ExpressionsAnalysis linqExpressionAnalysis)`
`74`	`74`	`{`
`75`	`75`	`var testCodeBuilder = new LinqMqlGeneratorTemplateBuilder(s_mqlGeneratorSyntaxElements);`
	`76`	`+ var generatedMqlMethodDeclarations = new List<MethodDeclarationSyntax>(linqExpressionAnalysis.AnalysisNodeContexts.Length);`
`76`	`77`
`77`	`78`	`foreach (var linqContext in linqExpressionAnalysis.AnalysisNodeContexts)`
`78`	`79`	`{`
`79`	`80`	`var analysisNode = linqContext.Node;`
`80`		`-`
`81`		`- linqContext.EvaluationMethodName = testCodeBuilder.AddLinqExpression(`
	`81`	`+ var (generatedMqlMethodName, generatedMqlMethodDeclaration) = testCodeBuilder.GenerateMqlGeneratorMethod(`
`82`	`82`	`analysisNode.ArgumentTypeName,`
`83`	`83`	`analysisNode.RewrittenExpression);`
	`84`	`+`
	`85`	`+ linqContext.EvaluationMethodName = generatedMqlMethodName;`
	`86`	`+ generatedMqlMethodDeclarations.Add(generatedMqlMethodDeclaration);`
`84`	`87`	`}`
`85`	`88`
	`89`	`+ testCodeBuilder.AddMqlGeneratorMethods(generatedMqlMethodDeclarations.ToArray());`
`86`	`90`	`return testCodeBuilder.GenerateSyntaxTree();`
`87`	`91`	`}`
`88`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,12 +60,16 @@ public static CompilationResult Compile(MongoAnalysisContext context, Expression`
`60`	`60`	`public static SyntaxTree GenerateJsonGeneratorSyntaxTree(ExpressionsAnalysis pocoExpressionAnalysis)`
`61`	`61`	`{`
`62`	`62`	`var testCodeBuilder = new PocoJsonGeneratorTemplateBuilder(s_jsonGeneratorSyntaxElements);`
	`63`	`+ var generatedJsonMethodDeclarations = new List<MethodDeclarationSyntax>(pocoExpressionAnalysis.AnalysisNodeContexts.Length);`
`63`	`64`
`64`	`65`	`foreach (var pocoContext in pocoExpressionAnalysis.AnalysisNodeContexts)`
`65`	`66`	`{`
`66`		`- pocoContext.EvaluationMethodName = testCodeBuilder.AddPoco(pocoContext.Node.RewrittenExpression as ClassDeclarationSyntax);`
	`67`	`+ var (generatedJsonMethodName, generatedJsonMethodDeclaration) = testCodeBuilder.GenerateJsonGeneratorMethod(pocoContext.Node.RewrittenExpression as ClassDeclarationSyntax);`
	`68`	`+ pocoContext.EvaluationMethodName = generatedJsonMethodName;`
	`69`	`+ generatedJsonMethodDeclarations.Add(generatedJsonMethodDeclaration);`
`67`	`70`	`}`
`68`	`71`
	`72`	`+ testCodeBuilder.AddJsonGeneratorMethods(generatedJsonMethodDeclarations.ToArray());`
`69`	`73`	`return testCodeBuilder.GenerateSyntaxTree();`
`70`	`74`	`}`
`71`	`75`	`}`