Fix code generation bugs in refined reference/attribute handling

Transformations/CodeGen.history

@@ -12,4 +12,5 @@ component NMF-CodeGen.nuspec from CodeGen/Properties/AssemblyInfo.cs
 patch (2.0.457): Start using EtiCat
 patch: Add support for .NET 10
 patch: improve code generation for child elements
-patch: update system dependencies
+patch: update system dependencies
+patch: fix code generation for refined references and attributes

Transformations/CodeGen/ClassGenerator.cs

@@ -369,6 +369,8 @@ private bool AreConflicting(CodeTypeMember member, CodeTypeMember current)
 
             if (member is CodeMemberMethod memberMethod && current is CodeMemberMethod currentMethod)
             {
+                if (!SamePrivateImplementationType(memberMethod.PrivateImplementationType, currentMethod.PrivateImplementationType)) return false;
+
                 if (memberMethod.Parameters.Count != currentMethod.Parameters.Count) return false;
                 if (memberMethod.TypeParameters.Count != currentMethod.TypeParameters.Count) return false;
 
@@ -377,9 +379,35 @@ private bool AreConflicting(CodeTypeMember member, CodeTypeMember current)
                     if (memberMethod.Parameters[i].Type.BaseType != currentMethod.Parameters[i].Type.BaseType) return false;
                 }
             }
+
+            if (member is CodeMemberProperty memberProperty && current is CodeMemberProperty currentProperty)
+            {
+                if (!SamePrivateImplementationType(memberProperty.PrivateImplementationType, currentProperty.PrivateImplementationType)) return false;
+            }
+
+            if (member is CodeMemberEvent memberEvent && current is CodeMemberEvent currentEvent)
+            {
+                if (!SamePrivateImplementationType(memberEvent.PrivateImplementationType, currentEvent.PrivateImplementationType)) return false;
+            }
+
             return true;
         }
 
+        /// <summary>
+        /// Determines whether two (possibly absent) private implementation types refer to the same interface
+        /// </summary>
+        /// <remarks>
+        /// Explicit interface implementations may legitimately share a member name (e.g. a redefined/refined
+        /// reference implemented for two different base interfaces), so members must only be considered
+        /// conflicting when they target the same private implementation type.
+        /// </remarks>
+        private static bool SamePrivateImplementationType(CodeTypeReference left, CodeTypeReference right)
+        {
+            if (left == null && right == null) return true;
+            if (left == null || right == null) return false;
+            return left.BaseType == right.BaseType;
+        }
+
         /// <summary>
         /// Generates the interface members for the given type
         /// </summary>

Transformations/Models.MetaTransformation/Meta/Class2Type.cs

@@ -1032,17 +1032,21 @@ protected virtual CodeMemberMethod CreateSetFeature(IClass input, CodeTypeDeclar
                 setFeature.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "feature"));
                 setFeature.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "value"));
                 var thisRef = new CodeThisReferenceExpression();
-                AddReferencesOfClass(input, generatedType, (m, f, p, _) => AddSetFeature(m, f, p, context, true, thisRef), setFeature, false, context);
-                AddAttributesOfClass(input, generatedType, (m, f, p, _) => AddSetFeature(m, f, p, context, false, thisRef), setFeature, context);
+                // References/attributes that themselves refine a base feature share its external name with the
+                // case AddRefinedReferencesOfClass/AddRefinedAttributesOfClass generates below. Skip them here so
+                // that the refined case - which correctly dispatches to whichever implementation applies - is the
+                // one that is actually reached, instead of being shadowed by this simpler, non-dispatching case.
+                AddReferencesOfClass(input, generatedType, (m, f, p, _) => f.Refines != null ? m : AddSetFeature(m, f, p, context, true, thisRef), setFeature, false, context);
+                AddAttributesOfClass(input, generatedType, (m, f, p, _) => f.Refines != null ? m : AddSetFeature(m, f, p, context, false, thisRef), setFeature, context);
                 var type2Type = Rule<Type2Type>();
                 AddRefinedReferencesOfClass(input, generatedType, (m, f, p, _) =>
                 {
-                    var type = context.Trace.ResolveIn(type2Type, f.Type);
+                    var type = context.Trace.ResolveIn(type2Type, f.DeclaringType);
                     return AddSetFeature(m, f, p, context, true, new CodeCastExpression(type.GetReferenceForType(), thisRef));
                 }, setFeature, false, context);
                 AddRefinedAttributesOfClass(input, generatedType, (m, f, p, _) =>
                 {
-                    var type = context.Trace.ResolveIn(type2Type, f.Type);
+                    var type = context.Trace.ResolveIn(type2Type, f.DeclaringType);
                     return AddSetFeature(m, f, p, context, false, new CodeCastExpression(type.GetReferenceForType(), thisRef));
                 }, setFeature, context);
                 if (setFeature.Statements.Count == 0)
@@ -1235,7 +1239,8 @@ private static CodeMemberMethod AddToExpressionForFeature(CodeMemberMethod metho
             {
                 if (feature.UpperBound == 1)
                 {
-                    var propTypeRef = new CodeTypeReference(feature.Name.ToPascalCase() + "Proxy");
+                    // Must match the name Feature2Proxy assigns to the generated proxy nested type.
+                    var propTypeRef = new CodeTypeReference((feature.Parent as IType).Name.ToPascalCase() + feature.Name.ToPascalCase() + "Proxy");
                     var ifStmt = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(parameterName),
                         CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(property.Name.ToUpperInvariant())));
                     CodeExpression proxyExpression = new CodeObjectCreateExpression(propTypeRef, new CodeThisReferenceExpression());

Transformations/Models.MetaTransformation/Meta/Feature2Proxy.cs

@@ -19,7 +19,12 @@ public class Feature2Proxy : TransformationRule<ITypedElement, CodeTypeDeclarati
             /// <inheritdoc />
             public override void Transform(ITypedElement feature, CodeTypeDeclaration generatedType, ITransformationContext context)
             {
-                generatedType.Name = feature.Name.ToPascalCase() + "Proxy";
+                var declaringType = context.Trace.ResolveIn(Rule<Type2Type>(), feature.Parent as IType).GetReferenceForType();
+
+                // Qualified with the declaring type's name: a reference that refines/redefines a base feature
+                // keeps the same feature name, so an unqualified name would collide with the base feature's own proxy.
+                // Class2Type.AddToExpressionForFeature constructs this same name independently and must stay in sync.
+                generatedType.Name = (feature.Parent as IType).Name.ToPascalCase() + feature.Name.ToPascalCase() + "Proxy";
                 generatedType.Attributes = MemberAttributes.Private | MemberAttributes.Final;
                 generatedType.TypeAttributes = System.Reflection.TypeAttributes.NestedPrivate | System.Reflection.TypeAttributes.Sealed;
                 generatedType.WriteDocumentation(string.Format("Represents a proxy to represent an incremental access to the {0} property", feature.Name));
@@ -31,7 +36,6 @@ public override void Transform(ITypedElement feature, CodeTypeDeclaration genera
                     type = new CodeTypeReference(typeof(System.Nullable<>).Name, type);
                 }
 
-                var declaringType = context.Trace.ResolveIn(Rule<Type2Type>(), feature.Parent as IType).GetReferenceForType();
                 generatedType.BaseTypes.Add(new CodeTypeReference("ModelPropertyChange", declaringType, type));
 
                 var modelElementRef = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ModelElement");

Transformations/Models.MetaTransformation/Meta/Meta2ClassesTransformation.cs

@@ -159,8 +159,10 @@ private static CodeTypeReference CreateReferenceForDeclaration(bool implementati
         private static CodeTypeReference CreateReferenceForMappedType(bool implementation, MappedType mappedType)
         {
             var reference = new CodeTypeReference();
-            if (mappedType.SystemType.IsValueType || mappedType.SystemType == typeof(string))
+            if (mappedType.SystemType.IsValueType || mappedType.SystemType == typeof(string) || mappedType.SystemType == typeof(System.Type))
             {
+                // System.Type must always be fully qualified: NMF.Models.Meta (a namespace imported into every
+                // generated file) also declares a class named "Type", so a bare "Type" reference is ambiguous.
                 reference.BaseType = mappedType.SystemType.FullName;
             }
             else

Transformations/Models.MetaTransformation/Meta/RefinedAttributeCollectionClassGenerator.cs

@@ -30,7 +30,9 @@ public class RefinedAttributeCollectionClassGenerator : TransformationRule<IClas
             /// <returns>The uninitialized code type declaration</returns>
             public override CodeTypeDeclaration CreateOutput(IClass scope, IAttribute attribute, ITransformationContext context)
             {
-                return CodeDomHelper.CreateTypeDeclarationWithReference(scope.Name.ToPascalCase() + attribute.Name.ToPascalCase() + "Collection", false);
+                // "Refined" disambiguates this from Class2Children's own nested "{scope}ChildrenCollection" type,
+                // which it would otherwise collide with whenever a metamodel names an attribute "Children".
+                return CodeDomHelper.CreateTypeDeclarationWithReference(scope.Name.ToPascalCase() + "Refined" + attribute.Name.ToPascalCase() + "Collection", false);
             }
 
             private readonly CodeFieldReferenceExpression parentRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_parent");

Transformations/Models.MetaTransformation/Meta/RefinedReferenceCollectionClassGenerator.cs

@@ -31,7 +31,9 @@ public class RefinedReferenceCollectionClassGenerator : TransformationRule<IClas
             /// <returns>The newly created code type declaration</returns>
             public override CodeTypeDeclaration CreateOutput(IClass scope, IReference reference, ITransformationContext context)
             {
-                return CodeDomHelper.CreateTypeDeclarationWithReference(scope.Name.ToPascalCase() + reference.Name.ToPascalCase() + "Collection", false);
+                // "Refined" disambiguates this from Class2Children's own nested "{scope}ChildrenCollection" type,
+                // which it would otherwise collide with whenever a metamodel names a reference "Children".
+                return CodeDomHelper.CreateTypeDeclarationWithReference(scope.Name.ToPascalCase() + "Refined" + reference.Name.ToPascalCase() + "Collection", false);
             }
 
             private readonly CodeFieldReferenceExpression parentRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_parent");

Transformations/Tests/CodeGenerationTests/CodeGenerationTests.csproj

@@ -67,6 +67,9 @@
     <Compile Update="References\railway.cs">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Compile>
+    <Compile Update="References\Refines.cs">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Compile>
     <Compile Update="References\Relational.cs">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Compile>
@@ -130,6 +133,9 @@
     <None Update="Persons.ecore">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="Refines.ecore">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
     <None Update="railway.ecore">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>

Transformations/Tests/CodeGenerationTests/ModelTests.cs

@@ -83,6 +83,12 @@ public void NameClashesResolvedSuccessfully()
             GenerateAndAssertEcore("NameClashes.ecore");
         }
 
+        [TestMethod]
+        public void RefinesModelGeneratedSuccessfully()
+        {
+            GenerateAndAssertEcore("Refines.ecore");
+        }
+
         [TestMethod]
         public void DefaultValueExampleGeneratesAndInstanceCanBeLoaded()
         {