Significant overhaul of RegFree and manifests

Will open up, but many UI controls broken.

Author: johnml1135

.gitignore

@@ -165,3 +165,4 @@ __pycache__/
 .venv/
 venv/
 *.egg-info/
+CrashLog.txt

Build/RegFree.targets

@@ -46,12 +46,14 @@
 		<DependentAssemblies Include="$(OutDir)Views.X.manifest" />
 	</ItemGroup>
 	<ItemGroup Condition="'@(NativeComDlls)' == ''">
-		<NativeComDlls Include="$(OutDir)*.dll" />
+		<!-- Explicitly list known native COM servers instead of wildcard inclusion -->
+		<NativeComDlls Include="$(OutDir)GraphiteEngine.dll" />
+		<NativeComDlls Include="$(OutDir)UniscribeEngine.dll" />
 	</ItemGroup>
 	<ItemGroup>
 		<NativeComDlls Remove="$(OutDir)*.resources.dll" />
 		<NativeComDlls Remove="$(OutDir)*.ni.dll" />
-		<!-- Exclude DLLs that have their own manifests -->
+		<!-- Exclude DLLs that have their own manifests (redundant if not in include, but safe) -->
 		<NativeComDlls Remove="$(OutDir)Views.dll" />
 		<!-- FwKernel.dll is covered by FwKernel.X.manifest, but we need to ensure that manifest is populated.
 		     For now, we assume it is or will be fixed. -->
@@ -61,18 +63,54 @@
 		<Fragments Include="$(DistFilesDir)/*.fragment.manifest" />
 	</ItemGroup>
 	<ItemGroup Condition="'@(ManagedComAssemblies)' == ''">
-		<ManagedComAssemblies Include="$(OutDir)*.dll" />
+		<!-- Explicitly list managed assemblies that expose COM types -->
+		<ManagedComAssemblies Include="$(OutDir)FwUtils.dll" />
+		<ManagedComAssemblies Include="$(OutDir)SimpleRootSite.dll" />
+		<ManagedComAssemblies Include="$(OutDir)ManagedVwDrawRootBuffered.dll" />
+		<ManagedComAssemblies Include="$(OutDir)ManagedLgIcuCollator.dll" />
+		<ManagedComAssemblies Include="$(OutDir)ManagedVwWindow.dll" />
 	</ItemGroup>
 	<ItemGroup>
 		<ManagedComAssemblies Remove="$(OutDir)*.resources.dll" />
 		<ManagedComAssemblies Remove="$(OutDir)*.ni.dll" />
+		<!-- Exclude native DLLs that are handled separately -->
+		<ManagedComAssemblies Remove="$(OutDir)FwKernel.dll" />
+		<ManagedComAssemblies Remove="$(OutDir)Views.dll" />
+		<!-- Exclude 3rd party DLLs that cause manifest issues and don't need RegFree COM -->
+		<ManagedComAssemblies Remove="$(OutDir)DotNetZip.dll" />
 	</ItemGroup>
-	<Target Name="CreateManifest" Condition="'$(OS)'=='Windows_NT'">
+
+	<!-- Ensure we don't process managed assemblies as native type libraries in the main manifest -->
+	<ItemGroup>
+		<NativeComDlls Remove="@(ManagedComAssemblies)" />
+	</ItemGroup>
+
+	<!-- Phase 1: Generate individual manifests for managed assemblies -->
+	<Target Name="CreateComponentManifests"
+			Inputs="%(ManagedComAssemblies.Identity)"
+			Outputs="$(OutDir)%(ManagedComAssemblies.Filename).manifest">
+		<Message Text="Generating component manifest for %(ManagedComAssemblies.Filename) with Platform=$(Platform)" Importance="high" />
+		<RegFree
+			Executable="%(ManagedComAssemblies.Identity)"
+			Output="$(OutDir)%(ManagedComAssemblies.Filename).manifest"
+			ManagedAssemblies="%(ManagedComAssemblies.Identity)"
+			Platform="$(Platform)"
+			Condition="'$(OS)'=='Windows_NT'"
+		/>
+	</Target>
+
+	<Target Name="CreateManifest" Condition="'$(OS)'=='Windows_NT'" DependsOnTargets="CreateComponentManifests">
+		<ItemGroup>
+			<ManagedComponentManifests Include="@(ManagedComAssemblies -> '$(OutDir)%(Filename).manifest')" />
+			<ManagedComponentManifests Remove="@(ManagedComponentManifests)" Condition="!Exists('%(ManagedComponentManifests.Identity)')" />
+			<!-- Add the generated component manifests as dependencies -->
+			<DependentAssemblies Include="@(ManagedComponentManifests)" />
+		</ItemGroup>
 		<RegFree
 			Executable="$(Executable)"
 			DependentAssemblies="@(DependentAssemblies)"
 			Dlls="@(NativeComDlls)"
-			ManagedAssemblies="@(ManagedComAssemblies)"
+			ManagedAssemblies=""
 			AsIs="@(Fragments)"
 			Platform="$(Platform)"
 		/>

Build/Src/FwBuildTasks/FwBuildTasksTests/RegFreeCreatorTests.cs

@@ -0,0 +1,98 @@
+// Copyright (c) 2025 SIL International
+// This software is licensed under the LGPL, version 2.1 or later
+// (http://www.gnu.org/licenses/lgpl-2.1.html)
+
+using System;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Xml;
+using FwBuildTasks;
+using Microsoft.Build.Utilities;
+using Microsoft.CSharp;
+using NUnit.Framework;
+using SIL.FieldWorks.Build.Tasks;
+using SIL.TestUtilities;
+
+namespace SIL.FieldWorks.Build.Tasks.FwBuildTasksTests
+{
+	[TestFixture]
+	public sealed class RegFreeCreatorTests
+	{
+		private const string AsmNamespace = "urn:schemas-microsoft-com:asm.v1";
+
+		[Test]
+		public void ProcessManagedAssembly_NestsClrClassUnderFile()
+		{
+			var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
+			Directory.CreateDirectory(tempDir);
+			var assemblyPath = Path.Combine(tempDir, "SampleComClass.dll");
+
+			try
+			{
+				CompileComVisibleAssembly(assemblyPath);
+
+				var doc = new XmlDocument();
+				var root = doc.CreateElement("assembly", AsmNamespace);
+				doc.AppendChild(root);
+				var logger = new TaskLoggingHelper(new TestBuildEngine(), nameof(RegFreeCreatorTests));
+				var creator = new RegFreeCreator(doc, logger);
+
+				var foundClrClass = creator.ProcessManagedAssembly(root, assemblyPath);
+				Assert.That(foundClrClass, Is.True, "Test assembly should produce clrClass entries.");
+
+				var ns = new XmlNamespaceManager(doc.NameTable);
+				ns.AddNamespace("asmv1", AsmNamespace);
+				var fileNode = root.SelectSingleNode("asmv1:file", ns);
+				Assert.That(fileNode, Is.Not.Null, "Managed manifest entries must create a file node.");
+
+				var nestedClrClass = fileNode.SelectSingleNode("asmv1:clrClass", ns);
+				Assert.That(nestedClrClass, Is.Not.Null, "clrClass should live under its file element.");
+
+				var orphanClrClass = root.SelectSingleNode("asmv1:clrClass", ns);
+				Assert.That(orphanClrClass, Is.Null, "clrClass elements must not be direct children of the assembly root.");
+			}
+			finally
+			{
+				if (Directory.Exists(tempDir))
+				{
+					Directory.Delete(tempDir, true);
+				}
+			}
+		}
+
+		private static void CompileComVisibleAssembly(string outputPath)
+		{
+			const string source = @"using System.Runtime.InteropServices;
+[assembly: ComVisible(true)]
+[assembly: Guid(""3D757DD4-8985-4CA6-B2C4-FA2B950C9F6D"")]
+namespace RegFreeCreatorTestAssembly
+{
+	[ComVisible(true)]
+	[Guid(""3EF2F542-4954-4B13-8B8D-A68E4D50D7A3"")]
+	[ProgId(""RegFreeCreator.SampleClass"")]
+	public class SampleComClass
+	{
+	}
+}";
+
+			var provider = new CSharpCodeProvider();
+			var parameters = new CompilerParameters
+			{
+				GenerateExecutable = false,
+				OutputAssembly = outputPath,
+				CompilerOptions = "/target:library"
+			};
+			parameters.ReferencedAssemblies.Add(typeof(object).Assembly.Location);
+			parameters.ReferencedAssemblies.Add(typeof(GuidAttribute).Assembly.Location);
+
+			var results = provider.CompileAssemblyFromSource(parameters, source);
+			if (results.Errors.HasErrors)
+			{
+				var message = string.Join(Environment.NewLine, results.Errors.Cast<CompilerError>().Select(e => e.ToString()));
+				throw new InvalidOperationException($"Failed to compile COM-visible test assembly:{Environment.NewLine}{message}");
+			}
+		}
+	}
+}

Build/Src/FwBuildTasks/RegFree.cs

@@ -15,6 +15,7 @@
 // </remarks>
 // ---------------------------------------------------------------------------------------------
 using System;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Diagnostics;
 using System.IO;
@@ -103,6 +104,15 @@ public RegFree()
 		/// ------------------------------------------------------------------------------------
 		public ITaskItem[] NoTypeLib { get; set; }
 
+		/// ------------------------------------------------------------------------------------
+		/// <summary>
+		/// Gets or sets the CLSIDs to exclude from the manifest.
+		/// This is useful when a CLSID is defined in a TypeLib but implemented in a managed assembly
+		/// that provides its own manifest entry.
+		/// </summary>
+		/// ------------------------------------------------------------------------------------
+		public ITaskItem[] ExcludedClsids { get; set; }
+
 		/// ------------------------------------------------------------------------------------
 		/// <summary>
 		/// Gets or sets manifest fragment files that will be included in the resulting manifest
@@ -153,16 +163,20 @@ public override bool Execute()
 				Path.GetFileName(Executable)
 			);
 
-			StringCollection dllPaths = GetFilesFrom(Dlls);
-			if (dllPaths.Count == 0)
+			var itemsToProcess = new List<ITaskItem>(Dlls);
+			if (itemsToProcess.Count == 0)
 			{
 				string ext = Path.GetExtension(Executable);
 				if (
 					ext != null
 					&& ext.Equals(".dll", StringComparison.InvariantCultureIgnoreCase)
+					&& (ManagedAssemblies == null || !ManagedAssemblies.Any(m => m.ItemSpec.Equals(Executable, StringComparison.OrdinalIgnoreCase)))
 				)
-					dllPaths.Add(Executable);
+				{
+					itemsToProcess.Add(new TaskItem(Executable));
+				}
 			}
+
 			string manifestFile = string.IsNullOrEmpty(Output)
 				? Executable + ".manifest"
 				: Output;
@@ -192,14 +206,19 @@ public override bool Execute()
 
 				// Process all DLLs using direct type library parsing (no registry redirection needed)
 				var creator = new RegFreeCreator(doc, Log);
-				var filesToRemove = dllPaths
-					.Cast<string>()
-					.Where(fileName => !File.Exists(fileName))
-					.ToList();
-				foreach (var file in filesToRemove)
-					dllPaths.Remove(file);
+				if (ExcludedClsids != null)
+				{
+					creator.AddExcludedClsids(GetFilesFrom(ExcludedClsids));
+				}
+
+				// Remove non-existing files from the list
+				itemsToProcess.RemoveAll(item => !File.Exists(item.ItemSpec));
 
 				string assemblyName = Path.GetFileNameWithoutExtension(manifestFile);
+				if (assemblyName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
+				{
+					assemblyName = Path.GetFileNameWithoutExtension(assemblyName);
+				}
 				Debug.Assert(assemblyName != null);
 				// The C++ test programs won't run if an assemblyIdentity element exists.
 				//if (assemblyName.StartsWith("test"))
@@ -214,33 +233,65 @@ public override bool Execute()
 					// just ignore
 				}
 				if (string.IsNullOrEmpty(assemblyVersion))
+				{
 					assemblyVersion = "1.0.0.0";
+				}
+				else
+				{
+					// Ensure version has 4 parts for manifest compliance (Major.Minor.Build.Revision)
+					// Some assemblies might have 3-part versions (e.g. 1.1.0) which are invalid in manifests.
+					// We also strip any non-numeric suffix if present, though FileVersion is usually clean.
+					var parts = assemblyVersion.Split('.');
+					if (parts.Length != 4)
+					{
+						var newParts = new string[4];
+						for (int i = 0; i < 4; i++)
+						{
+							// Simple parsing to ensure we only get numbers
+							string part = "0";
+							if (i < parts.Length)
+							{
+								// Take only the leading digits
+								var digits = new string(parts[i].TakeWhile(char.IsDigit).ToArray());
+								if (!string.IsNullOrEmpty(digits))
+									part = digits;
+							}
+							newParts[i] = part;
+						}
+						assemblyVersion = string.Join(".", newParts);
+					}
+				}
 
 				XmlElement root = creator.CreateExeInfo(assemblyName, assemblyVersion, Platform);
 
-				foreach (string fileName in dllPaths)
+				foreach (string fileName in GetFilesFrom(ManagedAssemblies))
 				{
-					if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
-						continue;
-
 					Log.LogMessage(
 						MessageImportance.Low,
-						"\tProcessing library {0}",
+						"\tProcessing managed assembly {0}",
 						Path.GetFileName(fileName)
 					);
-
-					// Process type library directly (no registry redirection needed)
-					creator.ProcessTypeLibrary(root, fileName);
+					creator.ProcessManagedAssembly(root, fileName);
 				}
 
-				foreach (string fileName in GetFilesFrom(ManagedAssemblies))
+				foreach (var item in itemsToProcess)
 				{
+					string fileName = item.ItemSpec;
+					if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
+						continue;
+
+					string server = item.GetMetadata("Server");
+					if (string.IsNullOrEmpty(server))
+						server = null;
+
 					Log.LogMessage(
 						MessageImportance.Low,
-						"\tProcessing managed assembly {0}",
+						"\tProcessing library {0}",
 						Path.GetFileName(fileName)
 					);
-					creator.ProcessManagedAssembly(root, fileName);
+
+					// Process type library directly (no registry redirection needed)
+					creator.ProcessTypeLibrary(root, fileName, server);
 				}
 
 				// Process classes and interfaces from HKCR (where COM is already registered)
@@ -277,6 +328,18 @@ public override bool Execute()
 					creator.AddDependentAssembly(root, assemblyFileName);
 				}
 
+				if (!HasRegFreeContent(doc))
+				{
+					Log.LogMessage(
+						MessageImportance.Low,
+						"\tNo registration-free content found for {0}; manifest will not be emitted.",
+						Path.GetFileName(manifestFile)
+					);
+					if (File.Exists(manifestFile))
+						File.Delete(manifestFile);
+					return true;
+				}
+
 				var settings = new XmlWriterSettings
 				{
 					OmitXmlDeclaration = false,
@@ -301,9 +364,25 @@ public override bool Execute()
 			return true;
 		}
 
-		private static StringCollection GetFilesFrom(ITaskItem[] source)
+		private static bool HasRegFreeContent(XmlDocument doc)
+		{
+			if (doc.DocumentElement == null)
+				return false;
+
+			var namespaceManager = new XmlNamespaceManager(doc.NameTable);
+			namespaceManager.AddNamespace("asmv1", "urn:schemas-microsoft-com:asm.v1");
+
+			bool HasNode(string xpath) => doc.SelectSingleNode(xpath, namespaceManager) != null;
+
+			return HasNode("//asmv1:clrClass")
+				|| HasNode("//asmv1:comClass")
+				|| HasNode("//asmv1:typelib")
+				|| HasNode("//asmv1:dependentAssembly");
+		}
+
+		private static List<string> GetFilesFrom(ITaskItem[] source)
 		{
-			var result = new StringCollection();
+			var result = new List<string>();
 			if (source == null)
 				return result;
 			foreach (var item in source)