Change order of check for generic instance in dependency build (#213)

josesimoes · web-flow · commit 6d029062cc65 · 2025-09-25T10:22:36.000+01:00
***NO_CI***
diff --git a/MetadataProcessor.Shared/nanoAssemblyBuilder.cs b/MetadataProcessor.Shared/nanoAssemblyBuilder.cs
@@ -631,15 +631,15 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
                     {
                         set.Add(fd.MetadataToken);
                     }
-                    else if (fd.FieldType.IsValueType &&
-                             !fd.FieldType.IsPrimitive)
+                    else if (fd.FieldType is GenericInstanceType)
                     {
                         set.Add(fd.FieldType.MetadataToken);
+                        set.Add(fd.FieldType.GetElementType().MetadataToken);
                     }
-                    else if (fd.FieldType is GenericInstanceType)
+                    else if (fd.FieldType.IsValueType &&
+                             !fd.FieldType.IsPrimitive)
                     {
                         set.Add(fd.FieldType.MetadataToken);
-                        set.Add(fd.FieldType.GetElementType().MetadataToken);
                     }
                     else if (fd.FieldType.IsArray)
                     {
@@ -759,15 +759,15 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
                         {
                             set.Add(parameterType.MetadataToken);
                         }
-                        else if (parameterType.IsValueType &&
-                                 !parameterType.IsPrimitive)
+                        else if (parameterType is GenericInstanceType)
                         {
                             set.Add(parameterType.MetadataToken);
+                            set.Add(parameterType.GetElementType().MetadataToken);
                         }
-                        else if (parameterType is GenericInstanceType)
+                        else if (parameterType.IsValueType &&
+                                 !parameterType.IsPrimitive)
                         {
                             set.Add(parameterType.MetadataToken);
-                            set.Add(parameterType.GetElementType().MetadataToken);
                         }
                         else if (parameterType is GenericParameter)
                         {
@@ -914,16 +914,16 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
                                         set.Add(elementType.MetadataToken);
                                     }
                                 }
-                                else if (returnType.MetadataType == MetadataType.Class
-                                    || (returnType.IsValueType && !returnType.IsPrimitive))
-                                {
-                                    set.Add(returnType.MetadataToken);
-                                }
                                 else if (returnType is GenericInstanceType genericInstanceType)
                                 {
                                     set.Add(genericInstanceType.MetadataToken);
                                     set.Add(genericInstanceType.ElementType.MetadataToken);
                                 }
+                                else if (returnType.MetadataType == MetadataType.Class
+                                    || (returnType.IsValueType && !returnType.IsPrimitive))
+                                {
+                                    set.Add(returnType.MetadataToken);
+                                }
 
                                 // capture any *parameter* types
                                 foreach (ParameterDefinition p in genericInstanceMethod.Parameters)
@@ -951,16 +951,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
                                             set.Add(elementType.MetadataToken);
                                         }
                                     }
-                                    else if (parameterType.MetadataType == MetadataType.Class
-                                        || (parameterType.IsValueType && !parameterType.IsPrimitive))
-                                    {
-                                        set.Add(parameterType.MetadataToken);
-                                    }
                                     else if (parameterType is GenericInstanceType genericInstanceType)
                                     {
                                         set.Add(genericInstanceType.MetadataToken);
                                         set.Add(genericInstanceType.ElementType.MetadataToken);
                                     }
+                                    else if (parameterType.MetadataType == MetadataType.Class
+                                        || (parameterType.IsValueType && !parameterType.IsPrimitive))
+                                    {
+                                        set.Add(parameterType.MetadataToken);
+                                    }
+
                                 }
 
                                 // after handling a GenericInstanceMethod, OK skip the other branches
@@ -1000,16 +1001,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
                                         set.Add(elementType.MetadataToken);
                                     }
                                 }
-                                else if (returnType.MetadataType == MetadataType.Class
-                                    || (returnType.IsValueType && !returnType.IsPrimitive))
-                                {
-                                    set.Add(returnType.MetadataToken);
-                                }
                                 else if (returnType is GenericInstanceType gitRt)
                                 {
                                     set.Add(gitRt.MetadataToken);
                                     set.Add(gitRt.ElementType.MetadataToken);
                                 }
+                                else if (returnType.MetadataType == MetadataType.Class
+                                    || (returnType.IsValueType && !returnType.IsPrimitive))
+                                {
+                                    set.Add(returnType.MetadataToken);
+                                }
+
 
                                 // capture any parameters
                                 foreach (ParameterDefinition p in ((MethodReference)i.Operand).Parameters)
@@ -1027,16 +1029,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
                                             set.Add(e.MetadataToken);
                                         }
                                     }
-                                    else if (typeReference.MetadataType == MetadataType.Class
-                                        || (typeReference.IsValueType && !typeReference.IsPrimitive))
-                                    {
-                                        set.Add(typeReference.MetadataToken);
-                                    }
                                     else if (typeReference is GenericInstanceType genericInstanceType)
                                     {
                                         set.Add(genericInstanceType.MetadataToken);
                                         set.Add(genericInstanceType.ElementType.MetadataToken);
                                     }
+                                    else if (typeReference.MetadataType == MetadataType.Class
+                                        || (typeReference.IsValueType && !typeReference.IsPrimitive))
+                                    {
+                                        set.Add(typeReference.MetadataToken);
+                                    }
+
                                 }
                             }
                             else if (i.Operand is MethodReference methodReference)
@@ -1201,16 +1204,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
 
                             set.Add(arr.ElementType.MetadataToken);
                         }
-                        else if (ret.MetadataType == MetadataType.Class
-                                 || (ret.IsValueType && !ret.IsPrimitive))
-                        {
-                            set.Add(ret.MetadataToken);
-                        }
                         else if (ret is GenericInstanceType genericInstanceType)
                         {
                             set.Add(genericInstanceType.MetadataToken);
                             set.Add(genericInstanceType.ElementType.MetadataToken);
                         }
+                        else if (ret.MetadataType == MetadataType.Class
+                                 || (ret.IsValueType && !ret.IsPrimitive))
+                        {
+                            set.Add(ret.MetadataToken);
+                        }
+
 
                         // pin each PARAMETER type as well
                         foreach (ParameterDefinition p in ms.Parameters)
@@ -1230,16 +1234,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)
 
                                 set.Add(ap.ElementType.MetadataToken);
                             }
-                            else if (parameterType.MetadataType == MetadataType.Class
-                                     || (parameterType.IsValueType && !parameterType.IsPrimitive))
-                            {
-                                set.Add(parameterType.MetadataToken);
-                            }
                             else if (parameterType is GenericInstanceType genericInstanceType)
                             {
                                 set.Add(genericInstanceType.MetadataToken);
                                 set.Add(genericInstanceType.ElementType.MetadataToken);
                             }
+                            else if (parameterType.MetadataType == MetadataType.Class
+                                     || (parameterType.IsValueType && !parameterType.IsPrimitive))
+                            {
+                                set.Add(parameterType.MetadataToken);
+                            }
+
                         }
 
                         // pin generic parameters, if any

Original file line number	Diff line number	Diff line change
`@@ -631,15 +631,15 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`631`	`631`	`{`
`632`	`632`	`set.Add(fd.MetadataToken);`
`633`	`633`	`}`
`634`		`- else if (fd.FieldType.IsValueType &&`
`635`		`- !fd.FieldType.IsPrimitive)`
	`634`	`+ else if (fd.FieldType is GenericInstanceType)`
`636`	`635`	`{`
`637`	`636`	`set.Add(fd.FieldType.MetadataToken);`
	`637`	`+ set.Add(fd.FieldType.GetElementType().MetadataToken);`
`638`	`638`	`}`
`639`		`- else if (fd.FieldType is GenericInstanceType)`
	`639`	`+ else if (fd.FieldType.IsValueType &&`
	`640`	`+ !fd.FieldType.IsPrimitive)`
`640`	`641`	`{`
`641`	`642`	`set.Add(fd.FieldType.MetadataToken);`
`642`		`- set.Add(fd.FieldType.GetElementType().MetadataToken);`
`643`	`643`	`}`
`644`	`644`	`else if (fd.FieldType.IsArray)`
`645`	`645`	`{`
`@@ -759,15 +759,15 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`759`	`759`	`{`
`760`	`760`	`set.Add(parameterType.MetadataToken);`
`761`	`761`	`}`
`762`		`- else if (parameterType.IsValueType &&`
`763`		`- !parameterType.IsPrimitive)`
	`762`	`+ else if (parameterType is GenericInstanceType)`
`764`	`763`	`{`
`765`	`764`	`set.Add(parameterType.MetadataToken);`
	`765`	`+ set.Add(parameterType.GetElementType().MetadataToken);`
`766`	`766`	`}`
`767`		`- else if (parameterType is GenericInstanceType)`
	`767`	`+ else if (parameterType.IsValueType &&`
	`768`	`+ !parameterType.IsPrimitive)`
`768`	`769`	`{`
`769`	`770`	`set.Add(parameterType.MetadataToken);`
`770`		`- set.Add(parameterType.GetElementType().MetadataToken);`
`771`	`771`	`}`
`772`	`772`	`else if (parameterType is GenericParameter)`
`773`	`773`	`{`
`@@ -914,16 +914,16 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`914`	`914`	`set.Add(elementType.MetadataToken);`
`915`	`915`	`}`
`916`	`916`	`}`
`917`		`- else if (returnType.MetadataType == MetadataType.Class`
`918`		`- \|\| (returnType.IsValueType && !returnType.IsPrimitive))`
`919`		`- {`
`920`		`- set.Add(returnType.MetadataToken);`
`921`		`- }`
`922`	`917`	`else if (returnType is GenericInstanceType genericInstanceType)`
`923`	`918`	`{`
`924`	`919`	`set.Add(genericInstanceType.MetadataToken);`
`925`	`920`	`set.Add(genericInstanceType.ElementType.MetadataToken);`
`926`	`921`	`}`
	`922`	`+ else if (returnType.MetadataType == MetadataType.Class`
	`923`	`+ \|\| (returnType.IsValueType && !returnType.IsPrimitive))`
	`924`	`+ {`
	`925`	`+ set.Add(returnType.MetadataToken);`
	`926`	`+ }`
`927`	`927`
`928`	`928`	`// capture any parameter types`
`929`	`929`	`foreach (ParameterDefinition p in genericInstanceMethod.Parameters)`
`@@ -951,16 +951,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`951`	`951`	`set.Add(elementType.MetadataToken);`
`952`	`952`	`}`
`953`	`953`	`}`
`954`		`- else if (parameterType.MetadataType == MetadataType.Class`
`955`		`- \|\| (parameterType.IsValueType && !parameterType.IsPrimitive))`
`956`		`- {`
`957`		`- set.Add(parameterType.MetadataToken);`
`958`		`- }`
`959`	`954`	`else if (parameterType is GenericInstanceType genericInstanceType)`
`960`	`955`	`{`
`961`	`956`	`set.Add(genericInstanceType.MetadataToken);`
`962`	`957`	`set.Add(genericInstanceType.ElementType.MetadataToken);`
`963`	`958`	`}`
	`959`	`+ else if (parameterType.MetadataType == MetadataType.Class`
	`960`	`+ \|\| (parameterType.IsValueType && !parameterType.IsPrimitive))`
	`961`	`+ {`
	`962`	`+ set.Add(parameterType.MetadataToken);`
	`963`	`+ }`
	`964`	`+`
`964`	`965`	`}`
`965`	`966`
`966`	`967`	`// after handling a GenericInstanceMethod, OK skip the other branches`
`@@ -1000,16 +1001,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`1000`	`1001`	`set.Add(elementType.MetadataToken);`
`1001`	`1002`	`}`
`1002`	`1003`	`}`
`1003`		`- else if (returnType.MetadataType == MetadataType.Class`
`1004`		`- \|\| (returnType.IsValueType && !returnType.IsPrimitive))`
`1005`		`- {`
`1006`		`- set.Add(returnType.MetadataToken);`
`1007`		`- }`
`1008`	`1004`	`else if (returnType is GenericInstanceType gitRt)`
`1009`	`1005`	`{`
`1010`	`1006`	`set.Add(gitRt.MetadataToken);`
`1011`	`1007`	`set.Add(gitRt.ElementType.MetadataToken);`
`1012`	`1008`	`}`
	`1009`	`+ else if (returnType.MetadataType == MetadataType.Class`
	`1010`	`+ \|\| (returnType.IsValueType && !returnType.IsPrimitive))`
	`1011`	`+ {`
	`1012`	`+ set.Add(returnType.MetadataToken);`
	`1013`	`+ }`
	`1014`	`+`
`1013`	`1015`
`1014`	`1016`	`// capture any parameters`
`1015`	`1017`	`foreach (ParameterDefinition p in ((MethodReference)i.Operand).Parameters)`
`@@ -1027,16 +1029,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`1027`	`1029`	`set.Add(e.MetadataToken);`
`1028`	`1030`	`}`
`1029`	`1031`	`}`
`1030`		`- else if (typeReference.MetadataType == MetadataType.Class`
`1031`		`- \|\| (typeReference.IsValueType && !typeReference.IsPrimitive))`
`1032`		`- {`
`1033`		`- set.Add(typeReference.MetadataToken);`
`1034`		`- }`
`1035`	`1032`	`else if (typeReference is GenericInstanceType genericInstanceType)`
`1036`	`1033`	`{`
`1037`	`1034`	`set.Add(genericInstanceType.MetadataToken);`
`1038`	`1035`	`set.Add(genericInstanceType.ElementType.MetadataToken);`
`1039`	`1036`	`}`
	`1037`	`+ else if (typeReference.MetadataType == MetadataType.Class`
	`1038`	`+ \|\| (typeReference.IsValueType && !typeReference.IsPrimitive))`
	`1039`	`+ {`
	`1040`	`+ set.Add(typeReference.MetadataToken);`
	`1041`	`+ }`
	`1042`	`+`
`1040`	`1043`	`}`
`1041`	`1044`	`}`
`1042`	`1045`	`else if (i.Operand is MethodReference methodReference)`
`@@ -1201,16 +1204,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`1201`	`1204`
`1202`	`1205`	`set.Add(arr.ElementType.MetadataToken);`
`1203`	`1206`	`}`
`1204`		`- else if (ret.MetadataType == MetadataType.Class`
`1205`		`- \|\| (ret.IsValueType && !ret.IsPrimitive))`
`1206`		`- {`
`1207`		`- set.Add(ret.MetadataToken);`
`1208`		`- }`
`1209`	`1207`	`else if (ret is GenericInstanceType genericInstanceType)`
`1210`	`1208`	`{`
`1211`	`1209`	`set.Add(genericInstanceType.MetadataToken);`
`1212`	`1210`	`set.Add(genericInstanceType.ElementType.MetadataToken);`
`1213`	`1211`	`}`
	`1212`	`+ else if (ret.MetadataType == MetadataType.Class`
	`1213`	`+ \|\| (ret.IsValueType && !ret.IsPrimitive))`
	`1214`	`+ {`
	`1215`	`+ set.Add(ret.MetadataToken);`
	`1216`	`+ }`
	`1217`	`+`
`1214`	`1218`
`1215`	`1219`	`// pin each PARAMETER type as well`
`1216`	`1220`	`foreach (ParameterDefinition p in ms.Parameters)`
`@@ -1230,16 +1234,17 @@ private HashSet<MetadataToken> BuildDependencyList(MetadataToken token)`
`1230`	`1234`
`1231`	`1235`	`set.Add(ap.ElementType.MetadataToken);`
`1232`	`1236`	`}`
`1233`		`- else if (parameterType.MetadataType == MetadataType.Class`
`1234`		`- \|\| (parameterType.IsValueType && !parameterType.IsPrimitive))`
`1235`		`- {`
`1236`		`- set.Add(parameterType.MetadataToken);`
`1237`		`- }`
`1238`	`1237`	`else if (parameterType is GenericInstanceType genericInstanceType)`
`1239`	`1238`	`{`
`1240`	`1239`	`set.Add(genericInstanceType.MetadataToken);`
`1241`	`1240`	`set.Add(genericInstanceType.ElementType.MetadataToken);`
`1242`	`1241`	`}`
	`1242`	`+ else if (parameterType.MetadataType == MetadataType.Class`
	`1243`	`+ \|\| (parameterType.IsValueType && !parameterType.IsPrimitive))`
	`1244`	`+ {`
	`1245`	`+ set.Add(parameterType.MetadataToken);`
	`1246`	`+ }`
	`1247`	`+`
`1243`	`1248`	`}`
`1244`	`1249`
`1245`	`1250`	`// pin generic parameters, if any`