First Relation Compile time Error checking.

Author: Bobris

BTDB.SourceGenerator.Test/RelationTests.VerifyCannotUsePrimaryKeyTogetherWithInKeyValue.verified.txt

@@ -0,0 +1,23 @@
+{
+  Diagnostics: [
+    {
+      Location: /*
+
+            public interface IPersonTable : IRelation<Person>
+                             ^^^^^^^^^^^^
+            {
+*/
+ : (11,29)-(11,41),
+      Message: Cannot use PrimaryKey together with InKeyValue in Id,
+      Severity: Error,
+      Descriptor: {
+        Id: BTDB0002,
+        Title: Cannot use PrimaryKey together with InKeyValue in Id,
+        MessageFormat: Cannot use PrimaryKey together with InKeyValue in Id,
+        Category: BTDB,
+        DefaultSeverity: Error,
+        IsEnabledByDefault: true
+      }
+    }
+  ]
+}

BTDB.SourceGenerator.Test/RelationTests.VerifyRelationWithSecondaryKey#TestNamespace.IPersonTable.g.verified.cs

@@ -14,6 +14,8 @@
 //           PrimaryIndex: 3 InKeyValue
 // Field: LowerCaseName string reference computed
 //           SecondaryIndex LowerCaseName: 2 IncludePrimaryKeyOrder 1
+// Field: Description string reference
+//           PrimaryIndex: 4 InKeyValue
 
 namespace TestNamespace;
 [CompilerGenerated]

BTDB.SourceGenerator.Test/RelationTests.VerifyRelationWithSecondaryKey#TestNamespace.Person.g.verified.cs

@@ -23,6 +23,8 @@ static void GenGetter4(object @this, ref byte value)
     {
         Unsafe.As<byte, string>(ref value) = Getter4(Unsafe.As<global::TestNamespace.Person>(@this));
     }
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "<Description>k__BackingField")]
+    extern static ref string Field5(global::TestNamespace.Person @this);
     [ModuleInitializer]
     internal static unsafe void Register4BTDB()
     {
@@ -67,6 +69,12 @@ internal static unsafe void Register4BTDB()
                 Type = typeof(string),
                 PropRefGetter = &GenGetter4,
             },
+            new global::BTDB.Serialization.FieldMetadata
+            {
+                Name = "Description",
+                Type = typeof(string),
+                ByteOffset = global::BTDB.Serialization.RawData.CalcOffset(dummy, ref Field5(dummy)),
+            },
         };
         global::BTDB.Serialization.ReflectionMetadata.Register(metadata);
     }

BTDB.SourceGenerator.Test/RelationTests.cs

@@ -42,11 +42,33 @@ public class Person
                 [PrimaryKey(2)] [SecondaryKey("PersonId", Order = 1) public int PersonId { get; set; }
                 [PrimaryKey(3, true)] public string Name { get; set; } = null!;
                 [SecondaryKey("LowerCaseName", IncludePrimaryKeyOrder = 1, Order = 2)] public string LowerCaseName => Name.ToLower();
+                [InKeyValue(4)] public string Description { get; set; } = null!;
             }
 
             public interface IPersonTable : IRelation<Person>
             {
             }
             """);
     }
+
+    [Fact]
+    public Task VerifyCannotUsePrimaryKeyTogetherWithInKeyValue()
+    {
+        // language=cs
+        return VerifySourceGenerator(@"
+            using BTDB.ODBLayer;
+
+            namespace TestNamespace;
+
+            public class Person
+            {
+                [PrimaryKey(1)]
+                [InKeyValue(2)] public int Id { get; set; }
+            }
+
+            public interface IPersonTable : IRelation<Person>
+            {
+            }
+            ");
+    }
 }

BTDB.SourceGenerator/Main.cs

@@ -146,6 +146,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                                 semanticModel,
                                 [], []);
                             if (generationInfo is not { GenType: GenerationType.Class }) return null;
+                            var detectedError = DetectErrors(generationInfo.Fields.AsSpan(),
+                                ((InterfaceDeclarationSyntax)syntaxContext.Node).Identifier.GetLocation());
+                            if (detectedError != null)
+                                return detectedError;
                             return new(GenerationType.RelationIface, namespaceName, interfaceName,
                                 symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), persistedName, false,
                                 false, false,
@@ -258,6 +262,22 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         context.RegisterSourceOutput(gen.Collect(), GenerateCode!);
     }
 
+    GenerationInfo? DetectErrors(ReadOnlySpan<FieldsInfo> fields, Location location)
+    {
+        for (var i = 0; i < fields.Length; i++)
+        {
+            if (fields[i].Indexes.ToArray().Any(ii => ii.Name == null && ii.IncludePrimaryKeyOrder == 1))
+            {
+                return new(GenerationType.Error, null, "BTDB0002",
+                    "Cannot use PrimaryKey together with InKeyValue in " + fields[i].Name, null, false, false, false,
+                    [],
+                    [], [], [], [], [], [], [], location);
+            }
+        }
+
+        return null;
+    }
+
     static bool IsICovariantRelation(INamedTypeSymbol typeSymbol)
     {
         // Check if the type is BTDB.ODBLayer.ICovariantRelation<?>
@@ -511,6 +531,7 @@ static bool IsICovariantRelation(INamedTypeSymbol typeSymbol)
     static EquatableArray<IndexInfo> ExtractIndexInfo(ImmutableArray<AttributeData> attributeDatas)
     {
         var indexInfos = new List<IndexInfo>();
+        var hasBothPrimaryAndInKeyValue = 0;
         foreach (var attributeData in attributeDatas)
         {
             if (attributeData.AttributeClass?.Name == "PrimaryKeyAttribute")
@@ -519,6 +540,15 @@ static EquatableArray<IndexInfo> ExtractIndexInfo(ImmutableArray<AttributeData>
                 var inKeyValue = GetBoolArgForAttributeData(attributeData, 1) ?? false;
                 var primaryKeyAttribute = new IndexInfo(null, order, inKeyValue, 0);
                 indexInfos.Add(primaryKeyAttribute);
+                hasBothPrimaryAndInKeyValue |= 1;
+            }
+
+            if (attributeData.AttributeClass?.Name == "InKeyValueAttribute")
+            {
+                var order = GetUintArgForAttributeData(attributeData, 0) ?? 0;
+                var primaryKeyAttribute = new IndexInfo(null, order, true, 0);
+                indexInfos.Add(primaryKeyAttribute);
+                hasBothPrimaryAndInKeyValue |= 2;
             }
 
             if (attributeData.AttributeClass?.Name == "SecondaryKeyAttribute")
@@ -531,6 +561,11 @@ static EquatableArray<IndexInfo> ExtractIndexInfo(ImmutableArray<AttributeData>
             }
         }
 
+        if (hasBothPrimaryAndInKeyValue == 3)
+        {
+            indexInfos.Add(new(null, 0, false, 1));
+        }
+
         return new(indexInfos.ToArray());
     }