Resolved merge conflict

Author: Ravi-Raghavan

.github/workflows/dotnet.yml

@@ -14,6 +14,11 @@ jobs:
     steps:
     - uses: actions/checkout@v3
 
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v3
+      with:
+          dotnet-version: 3.1.x
+      
     - name: Setup msbuild
       uses: microsoft/[email protected]  
 

src/MongoDB.Analyzer.Helpers/Builders/MqlGenerator.cs

@@ -14,12 +14,26 @@
 
 using MongoDB.Driver;
 using System.Linq;
-using MongoDB.Bson;
+using BsonDocumentCustom123 = MongoDB.Bson.BsonDocument;
+using BsonValueCustom123 = MongoDB.Bson.BsonValue;
+using BsonObjectIdCustom123 = MongoDB.Bson.BsonObjectId;
+using BsonTypeCustom123 = MongoDB.Bson.BsonType;
+using BsonTimeSpanCustom123 = MongoDB.Bson.Serialization.Options.TimeSpanUnits;
 
 namespace MongoDB.Analyzer.Helpers.Builders
 {
     public static class MqlGenerator
     {
+#pragma warning disable CS0169 // The field is never used
+#pragma warning disable IDE0051
+        private static readonly BsonDocumentCustom123 s_dummyRef1;
+        private static readonly BsonValueCustom123 s_dummyRef2;
+        private static readonly BsonObjectIdCustom123 s_dummyRef3;
+        private static readonly BsonTypeCustom123 s_dummyRef4;
+        private static readonly BsonTimeSpanCustom123 s_dummyRef5;
+#pragma warning restore IDE0051 // The field is never used
+#pragma warning restore CS0169
+
         private sealed class MqlGeneratorTemplateType
         {
             public int Field { get; set; }

src/MongoDB.Analyzer.Helpers/Linq/MqlGenerator.cs

@@ -15,12 +15,20 @@
 using System;
 using System.Linq;
 using MongoDB.Driver.Linq;
-using MongoDB.Bson;
+using BsonTypeCustom123 = MongoDB.Bson.BsonType;
+using BsonTimeSpanCustom123 = MongoDB.Bson.Serialization.Options.TimeSpanUnits;
 
 namespace MongoDB.Analyzer.Helpers.Linq
 {
     public static class MqlGenerator
     {
+#pragma warning disable CS0169 // The field is never used
+#pragma warning disable IDE0051
+        private static readonly BsonTypeCustom123 s_dummyRef1;
+        private static readonly BsonTimeSpanCustom123 s_dummyRef2;
+#pragma warning restore IDE0051 // The field is never used
+#pragma warning restore CS0169
+
         private sealed class MqlGeneratorTemplateType
         {
             public Tuple<int, int> Field { get; set; }

src/MongoDB.Analyzer/Core/Builders/BuildersAnalyzer.cs

@@ -83,16 +83,16 @@ private static AnalysisStats ReportMqlOrInvalidExpressions(MongoAnalysisContext
             }
             else if (mqlResult.Exception != null)
             {
-                var isDriverException = mqlResult.Exception.InnerException?.Source?.Contains("MongoDB.Driver") == true;
+                var isDriverOrBsonException = IsDriverOrBsonException(mqlResult);
 
-                if (isDriverException || settings.OutputInternalExceptions)
+                if (isDriverOrBsonException || settings.OutputInternalExceptions)
                 {
                     var diagnosticDescriptor = BuidersDiagnosticsRules.DiagnosticRuleNotSupportedBuilderExpression;
                     var decoratedMessage = DecorateMessage(mqlResult.Exception.InnerException?.Message ?? "Unsupported builders expression", driverVersion, context.Settings);
                     semanticContext.ReportDiagnostics(diagnosticDescriptor, decoratedMessage, locations);
                 }
 
-                if (!isDriverException)
+                if (!isDriverOrBsonException)
                 {
                     context.Logger.Log($"Exception while analyzing {analysisContext.Node}: {mqlResult.Exception.InnerException?.Message}");
                     internalExceptionsCount++;
@@ -107,6 +107,13 @@ private static AnalysisStats ReportMqlOrInvalidExpressions(MongoAnalysisContext
         return new AnalysisStats(mqlCount, internalExceptionsCount, driverExceptionsCount, compilationResult.MongoDBDriverVersion.ToString(3), null);
     }
 
+    private static bool IsDriverOrBsonException(MQLResult mqlResult)
+    {
+        var source = mqlResult.Exception.InnerException?.Source;
+        return source.IsNotEmpty() && (source.Contains("MongoDB.Driver") ||
+            source.Contains("MongoDB.Bson"));
+    }
+
     private static string DecorateMessage(string message, string driverVersion, MongoDBAnalyzerSettings settings) =>
         settings.OutputDriverVersion ? $"{message}_v{driverVersion}" : message;
 }

src/MongoDB.Analyzer/Core/Linq/LinqAnalyzer.cs

@@ -108,16 +108,16 @@ private static AnalysisStats ReportMqlOrInvalidExpressions(MongoAnalysisContext
             }
             else if (mqlResult.Exception != null)
             {
-                var isDriverException = mqlResult.Exception.InnerException?.Source?.Contains("MongoDB.Driver") == true;
+                var isDriverOrLinqException = IsDriverOrLinqException(mqlResult);
 
-                if (isDriverException || settings.OutputInternalExceptions)
+                if (isDriverOrLinqException || settings.OutputInternalExceptions)
                 {
                     var diagnosticDescriptor = LinqDiagnosticsRules.DiagnosticRuleNotSupportedLinqExpression;
                     var decoratedMessage = DecorateMessage(mqlResult.Exception.InnerException?.Message ?? "Unsupported LINQ expression", driverVersion, settings);
                     semanticContext.ReportDiagnostics(diagnosticDescriptor, decoratedMessage, locations);
                 }
 
-                if (!isDriverException)
+                if (!isDriverOrLinqException)
                 {
                     context.Logger.Log($"Exception while analyzing {analysisContext.Node}: {mqlResult.Exception.InnerException?.Message}");
                     internalExceptionsCount++;
@@ -132,6 +132,13 @@ private static AnalysisStats ReportMqlOrInvalidExpressions(MongoAnalysisContext
         return new AnalysisStats(mqlCount, internalExceptionsCount, driverExceptionsCount, compilationResult.MongoDBDriverVersion.ToString(3), null);
     }
 
+    private static bool IsDriverOrLinqException(MQLResult mqlResult)
+    {
+        var source = mqlResult.Exception.InnerException?.Source;
+        return source.IsNotEmpty() && (source.Contains("MongoDB.Driver") ||
+            source.Contains("MongoDB.Bson") || source.Contains("System.Linq"));
+    }
+
     private static string DecorateMessage(string message, string driverVersion, MongoDBAnalyzerSettings settings) =>
         settings.OutputDriverVersion ? $"{message}_v{driverVersion}" : message;
 }

src/MongoDB.Analyzer/Core/TypesGeneratorHelper.cs

@@ -22,7 +22,12 @@ internal static class TypesGeneratorHelper
         .AddUsings(
             Using("System"),
             Using("MongoDB.Bson"),
-            Using("MongoDB.Bson.Serialization.Attributes"));
+            Using("MongoDB.Bson.Serialization.Attributes"),
+            Using("BsonTimeSpanCustom123", "MongoDB.Bson.Serialization.Options.TimeSpanUnits"),
+            Using("BsonTypeCustom123", "MongoDB.Bson.BsonType"),
+            Using("BsonDocumentCustom123", "MongoDB.Bson.BsonDocument"),
+            Using("BsonValueCustom123", "MongoDB.Bson.BsonValue"),
+            Using("BsonObjectIdCustom123", "MongoDB.Bson.BsonObjectId"));
 
 
     private static readonly NamespaceDeclarationSyntax s_namespaceDeclarationSyntaxBuilders = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(MqlGeneratorSyntaxElements.Builders.MqlGeneratorNamespace));

src/MongoDB.Analyzer/Core/TypesProcessor.cs

@@ -16,6 +16,15 @@ namespace MongoDB.Analyzer.Core;
 
 internal sealed class TypesProcessor
 {
+    private static readonly Dictionary<string, string> s_knownBsonTypes = new()
+    {
+        { "MongoDB.Bson.BsonDocument", "BsonDocumentCustom123" },
+        { "MongoDB.Bson.BsonValue", "BsonValueCustom123" },
+        { "MongoDB.Bson.BsonObjectId", "BsonObjectIdCustom123" },
+        { "MongoDB.Bson.BsonType", "BsonTypeCustom123" },
+        { "MongoDB.Bson.Serialization.Options.TimeSpanUnits", "BsonTimeSpanCustom123" }
+    };
+
     private readonly Dictionary<string, (string NewName, MemberDeclarationSyntax NewDeclaration)> _processedTypes;
 
     private int _nextTypeId = 0;
@@ -27,57 +36,59 @@ public TypesProcessor()
         _processedTypes = new Dictionary<string, (string, MemberDeclarationSyntax)>();
     }
 
-    public string GetTypeSymbolToGeneratedTypeMapping(ITypeSymbol typeSymbol)
+    public string GetTypeSymbolToGeneratedTypeMapping(ITypeSymbol typeSymbol) => GetGeneratedTypeMapping(typeSymbol).RemappedName;
+
+    public string ProcessTypeSymbol(ITypeSymbol typeSymbol)
     {
-        if (typeSymbol == null)
+        var (remappedName, fullTypeName) = GetGeneratedTypeMapping(typeSymbol);
+        if (fullTypeName == null)
         {
             return null;
         }
 
-        var fullTypeName = GetFullName(typeSymbol);
-        if (typeSymbol.IsSupportedBsonType())
+        if (remappedName != null)
         {
-            return typeSymbol.Name;
+            return remappedName;
         }
 
-        if (_processedTypes.TryGetValue(fullTypeName, out var result))
-        {
-            return result.NewName;
-        }
+        remappedName = GetNewNameForSymbol(typeSymbol);
+        _processedTypes[fullTypeName] = (remappedName, null); // Cache the name, for self referencing types
 
-        return null;
+        var rewrittenDeclarationSyntax = GetSyntaxNodeFromSymbol(typeSymbol, remappedName);
+
+        var typeCode = rewrittenDeclarationSyntax.ToFullString();
+        var newTypeDeclaration = SyntaxFactory.ParseMemberDeclaration(typeCode);
+
+        remappedName = rewrittenDeclarationSyntax.Identifier.Text;
+        _processedTypes[fullTypeName] = (remappedName, newTypeDeclaration);
+
+        return remappedName;
     }
 
-    public string ProcessTypeSymbol(ITypeSymbol typeSymbol)
+    private (string RemappedName, string FullTypeName) GetGeneratedTypeMapping(ITypeSymbol typeSymbol)
     {
         if (typeSymbol == null)
         {
-            return null;
+            return default;
         }
 
         var fullTypeName = GetFullName(typeSymbol);
-        if (typeSymbol.IsSupportedBsonType())
+        if (s_knownBsonTypes.TryGetValue(fullTypeName, out var knowTypeName))
         {
-            return typeSymbol.Name;
+            return (knowTypeName, fullTypeName);
         }
 
-        if (_processedTypes.TryGetValue(fullTypeName, out var pair))
+        if (_processedTypes.TryGetValue(fullTypeName, out var result))
         {
-            return pair.NewName;
+            return (result.NewName, fullTypeName);
         }
 
-        var newTypeName = GetNewNameForSymbol(typeSymbol);
-        _processedTypes[fullTypeName] = (newTypeName, null); // Cache the name, for self referencing types
-
-        var rewrittenDeclarationSyntax = GetSyntaxNodeFromSymbol(typeSymbol, newTypeName);
-
-        var typeCode = rewrittenDeclarationSyntax.ToFullString();
-        var newTypeDeclaration = SyntaxFactory.ParseMemberDeclaration(typeCode);
-
-        newTypeName = rewrittenDeclarationSyntax.Identifier.Text;
-        _processedTypes[fullTypeName] = (newTypeName, newTypeDeclaration);
+        if (typeSymbol.IsSupportedSystemType())
+        {
+            return (fullTypeName, fullTypeName);
+        }
 
-        return newTypeName;
+        return (null, fullTypeName);
     }
 
     private BaseTypeDeclarationSyntax GetSyntaxNodeFromSymbol(ITypeSymbol typeSymbol, string newTypeName)
@@ -129,6 +140,12 @@ private TypeDeclarationSyntax GetSyntaxForClassOrStruct(ITypeSymbol typeSymbol,
             typeDeclaration = typeDeclaration.WithBaseList(GetBaseListSyntax(baseTypeNameGenerated));
         }
 
+        var bsonAttributeList = GenerateBsonAttributeList(typeSymbol);
+        if (bsonAttributeList != null && bsonAttributeList.Attributes.AnySafe())
+        {
+            typeDeclaration = typeDeclaration.AddAttributeLists(bsonAttributeList);
+        }
+
         return typeDeclaration;
     }
 
@@ -189,6 +206,12 @@ private void GenerateProperties(ITypeSymbol typeSymbol, List<MemberDeclarationSy
                 propertyDeclaration = propertyDeclaration.AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
             }
 
+            var bsonAttributeList = GenerateBsonAttributeList(propertySymbol);
+            if (bsonAttributeList != null && bsonAttributeList.Attributes.AnySafe())
+            {
+                propertyDeclaration = propertyDeclaration.AddAttributeLists(bsonAttributeList);
+            }
+
             members.Add(propertyDeclaration);
         }
     }
@@ -209,8 +232,13 @@ private void GenerateFields(ITypeSymbol typeSymbol, List<MemberDeclarationSyntax
 
             var variableDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(fieldSymbol.Name)));
 
+            var bsonAttributeList = GenerateBsonAttributeList(fieldSymbol);
+            var attributeLists = bsonAttributeList != null && bsonAttributeList.Attributes.AnySafe() ?
+                SyntaxFactory.List<AttributeListSyntax>(SyntaxFactory.SingletonSeparatedList<AttributeListSyntax>(bsonAttributeList)) :
+                SyntaxFactory.List<AttributeListSyntax>();
+
             var fieldDeclaration = SyntaxFactory.FieldDeclaration(
-                attributeLists: SyntaxFactory.List<AttributeListSyntax>(),
+                attributeLists: attributeLists,
                 modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)),
                 declaration: variableDeclaration);
 
@@ -246,19 +274,16 @@ private TypeSyntax CreateTypeSyntaxForSymbol(ITypeSymbol typeSymbol)
                 SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(new[] { underlyingTypeSyntax })));
 
             result = SyntaxFactory.QualifiedName(
-                    SyntaxFactory.QualifiedName(
                         SyntaxFactory.QualifiedName(
-                            SyntaxFactory.IdentifierName("System"),
-                            SyntaxFactory.IdentifierName("Collections")),
-                        SyntaxFactory.IdentifierName("Generic")),
-                    listSyntax);
+                            SyntaxFactory.QualifiedName(
+                                SyntaxFactory.IdentifierName("System"),
+                                SyntaxFactory.IdentifierName("Collections")),
+                            SyntaxFactory.IdentifierName("Generic")),
+                        listSyntax);
         }
         else
         {
-            var typeName = typeSymbol.SpecialType == SpecialType.None ?
-                ProcessTypeSymbol(typeSymbol) : typeSymbol.Name;
-
-            result = SyntaxFactory.ParseTypeName(typeName);
+            result = SyntaxFactory.ParseTypeName(ProcessTypeSymbol(typeSymbol));
         }
 
         return result;
@@ -275,4 +300,74 @@ TypeKind.Enum or
 
     private string GetFullName(ITypeSymbol typeSymbol) =>
         typeSymbol.ToDisplayString();
+
+    private AttributeListSyntax GenerateBsonAttributeList(ISymbol symbol)
+    {
+        var bsonAttributes = symbol.GetAttributes().Where(attribute => attribute.AttributeClass.IsSupportedBsonAttribute());
+        if (bsonAttributes.EmptyOrNull())
+        {
+            return null;
+        }
+
+        var generatedBsonAttributes = new List<AttributeSyntax>();
+        foreach (var bsonAttribute in bsonAttributes)
+        {
+            var bsonAttributeArgumentList = new List<AttributeArgumentSyntax>();
+
+            bsonAttributeArgumentList.AddRange(bsonAttribute.ConstructorArguments
+                .Select(bsonAttributeArgument => GenerateBsonAttributeArgument(bsonAttributeArgument, false, null)));
+
+            bsonAttributeArgumentList.AddRange(bsonAttribute.NamedArguments
+                .Select(bsonAttributeArgument => GenerateBsonAttributeArgument(bsonAttributeArgument.Value, true, bsonAttributeArgument.Key)));
+
+            var bsonAttributeSyntaxNode = SyntaxFactoryUtilities.GetAttribute(bsonAttribute.AttributeClass.Name, bsonAttributeArgumentList);
+            generatedBsonAttributes.Add(bsonAttributeSyntaxNode);
+        }
+
+        var bsonAttributeList = SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList<AttributeSyntax>(generatedBsonAttributes));
+        return bsonAttributeList;
+    }
+
+    private AttributeArgumentSyntax GenerateBsonAttributeArgument(TypedConstant argumentValue, bool isNamed, string argumentKey)
+    {
+        var expressionSyntax = GenerateExpressionFromBsonAttributeArgumentInfo(argumentValue);
+        var attributeArgument = isNamed ? SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(argumentKey)), null, expressionSyntax) :
+            SyntaxFactory.AttributeArgument(expressionSyntax);
+
+        return attributeArgument;
+    }
+
+    private ExpressionSyntax GenerateExpressionFromBsonAttributeArgumentInfo(TypedConstant attributeArgumentInfo) =>
+        attributeArgumentInfo.Kind switch
+        {
+            TypedConstantKind.Enum => HandleEnumInBsonAttributeArgument(attributeArgumentInfo.Value, attributeArgumentInfo.Type),
+            TypedConstantKind.Primitive => HandlePrimitiveInBsonAttributeArgument(attributeArgumentInfo.Value),
+            TypedConstantKind.Array => HandleArrayInBsonAttributeArgument(attributeArgumentInfo.Values, attributeArgumentInfo.Type as IArrayTypeSymbol),
+            TypedConstantKind.Type => HandleTypeInBsonAttributeArgument(attributeArgumentInfo.Value),
+            _ => null
+        };
+
+    private ExpressionSyntax HandleEnumInBsonAttributeArgument(object value, ITypeSymbol typeSymbol) =>
+        SyntaxFactoryUtilities.GetCastConstantExpression(ProcessTypeSymbol(typeSymbol), value);
+
+    private LiteralExpressionSyntax HandlePrimitiveInBsonAttributeArgument(object value) =>
+        SyntaxFactoryUtilities.GetConstantExpression(value);
+
+    private ExpressionSyntax HandleArrayInBsonAttributeArgument(ImmutableArray<TypedConstant> argumentValues, IArrayTypeSymbol arrayTypeSymbol)
+    {
+        var ranksList = SyntaxFactory.SeparatedList(
+                Enumerable.Range(0, arrayTypeSymbol.Rank)
+                .Select(_ => (ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()));
+
+        var arrayRankSpecifiers = SyntaxFactory.List(new[] { SyntaxFactory.ArrayRankSpecifier(ranksList) });
+        var arrayElementTypeName = ProcessTypeSymbol(arrayTypeSymbol.ElementType);
+
+        var arrayTypeSyntax = SyntaxFactory.ArrayType(SyntaxFactory.ParseTypeName(arrayElementTypeName), arrayRankSpecifiers);
+        var expressionList = argumentValues.Select(argumentValue => GenerateExpressionFromBsonAttributeArgumentInfo(argumentValue)).ToArray();
+
+        return SyntaxFactoryUtilities.GetArrayCreationExpression(arrayTypeSyntax, expressionList);
+    }
+
+    private ExpressionSyntax HandleTypeInBsonAttributeArgument(object argumentValue) =>
+        SyntaxFactory.TypeOfExpression(SyntaxFactory.ParseTypeName(ProcessTypeSymbol(argumentValue as INamedTypeSymbol)));
 }