Fixed and finished adding LPArray generator

Author: dahall

CodeGen/Generator/TypeDeclSyntaxExt.cs

@@ -19,14 +19,15 @@ public static bool NameEquals(this ArgumentSyntax arg, string name) =>
 	public static void Remove(this List<ParameterSyntax> values, string name)
 	{
 		var idx = values.FindIndex(t => t.Identifier.Text == name);
-		if (idx < 0) throw new AmbiguousMatchException("The specified item was not found in the list.");
-		values.RemoveAt(idx);
+		if (idx >= 0)
+			values.RemoveAt(idx);
 	}
 
 	public static void Replace<T>(this List<T> values, T match, T replacement) where T : SyntaxNode
 	{
 		var idx = values.FindIndex(t => t.IsEquivalentTo(match));
-		values[idx] = idx >= 0 ? replacement : throw new AmbiguousMatchException("The specified item was not found in the list.");
+		if (idx >= 0)
+			values[idx] = replacement;
 	}
 
 	public static bool IsPartial(this TypeDeclarationSyntax tds) =>

CodeGen/Generator/VanaraAttributeGenerator.cs

@@ -41,6 +41,8 @@
 
 using Microsoft.CodeAnalysis.CSharp;
 using System.Collections.Immutable;
+using System.ComponentModel;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Xml;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -78,11 +80,11 @@ internal enum SizeParamType
 	static string UniqueName(string n) => $"{n}{uid++}";
 
 	static readonly MethAttrHandler[] methodAttributes = [
-		new("System.Runtime.InteropServices.MarshalAsAttribute", IsParamWithArgs, BuildMarshalAsMethod, ParentForExtMethod, GetParamMeth), // IUnknown, Interface, LPArray
-		new("Vanara.PInvoke.IgnoreAttribute", IsParamInNotNewMethod, BuildIgnoreMethod, ParentForExtMethod, GetParamMeth),
-		new("Vanara.PInvoke.SizeDefAttribute", IsParamInNotNewMethod, BuildSizeDefMethod, ParentForExtMethod, GetParamMeth),
-		new("Vanara.PInvoke.AddAsCtorAttribute", IsParamInNotNewStaticMethod, DummyBuilder, GetParamType, GetParamMeth),
-		new("Vanara.PInvoke.AddAsMemberAttribute", IsParamInNotNewStaticMethod, DummyBuilder, GetParamType, GetParamMeth),
+		new("System.Runtime.InteropServices.MarshalAsAttribute", IsParamInNestedType, BuildMarshalAsMethod, ParentForExtMethod, GetParamMeth), // IUnknown, Interface, LPArray
+		new("Vanara.PInvoke.IgnoreAttribute", IsParamInMethod, BuildIgnoreMethod, ParentForExtMethod, GetParamMeth),
+		new("Vanara.PInvoke.SizeDefAttribute", IsParamInMethod, BuildSizeDefMethod, ParentForExtMethod, GetParamMeth),
+		new("Vanara.PInvoke.AddAsCtorAttribute", IsParamInStaticMethod, DummyBuilder, GetParamType, GetParamMeth),
+		new("Vanara.PInvoke.AddAsMemberAttribute", IsParamInStaticMethod, DummyBuilder, GetParamType, GetParamMeth),
 		//("Vanara.PInvoke.SuppressAutoGenAttribute", static (n, t) => n is MethodDeclarationSyntax),
 	];
 
@@ -98,7 +100,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 	{
 		// Process each attribute in the methodAttributes array
 		var attributeProviders = methodAttributes
-			.Select(attr => context.SyntaxProvider.ForAttributeWithMetadataName(attr.AttrName, (n, t) => attr.Validator(n, t) && NoSuppress(attr.meth((ParameterSyntax)n)), (ctx, _) => ((ParameterSyntax)ctx.TargetNode, ctx.Attributes)).Collect())
+			.Select(attr => context.SyntaxProvider.ForAttributeWithMetadataName(attr.AttrName, (n, t) => attr.Validator(n, t), (ctx, _) => ((ParameterSyntax)ctx.TargetNode, ctx.Attributes)).Collect())
 			.ToArray();
 
 		// Process type-level methodAttributes (those without method transforms)
@@ -128,8 +130,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 			GenerateCode(spc, value.Left.Left.Left.Left.Left.Left.Left.Left, value.Left.Left.Left.Left.Left.Left.Left.Right,
 			value.Right.AddRange(value.Left.Right).AddRange(value.Left.Left.Right).AddRange(value.Left.Left.Left.Right).AddRange(value.Left.Left.Left.Left.Right),
 			value.Left.Left.Left.Left.Left.Right.AddRange(value.Left.Left.Left.Left.Left.Left.Right)));
-
-		static bool NoSuppress(MethodDeclarationSyntax ms) => !ms.Modifiers.Any(SyntaxKind.NewKeyword) && !ms.AttributeLists.SelectMany(al => al.Attributes).Any(a => a.Name.ToString().Contains("SuppressAutoGen"));
 	}
 
 	private static void GenerateCode(SourceProductionContext context, Compilation compilation, ImmutableArray<AdditionalText> addtlFiles, ImmutableArray<(ParameterSyntax paramNode, ImmutableArray<AttributeData> attrDatas)> paramNodes,
@@ -187,7 +187,7 @@ private static void GenerateCode(SourceProductionContext context, Compilation co
 				continue;
 
 			// Add distinct using directives from 'usings' to the compilation unit
-			usings = [.. usings.DistinctBy(u => u.Name?.ToString())];
+			usings = [.. usings.DistinctBy(u => u.Alias?.ToString() ?? u.Name?.ToString())];
 
 			// Build new syntax tree, starting with nsDecl, adding any containing types with their modifiers, and finally the typeDecl with the new values from methLookup.Values
 			SyntaxNode topDecl = typeDecl.WithMembers(List<MemberDeclarationSyntax>(methLookup.Values.Select(bb => bb.ToMethod())));
@@ -581,6 +581,7 @@ private static void BuildMarshalAsMethod(SourceProductionContext context, Compil
 			UnmanagedType.IUnknown => decl.WithType(ParseTypeName(genericType + (decl.Type is not null && decl.Type.ToString().EndsWith("?") ? "?" : "")))
 				.WithoutAttribute("MarshalAs"),
 			UnmanagedType.Interface => decl.WithoutAttribute("MarshalAs"),
+			UnmanagedType.LPArray when modAttr is ModType.In => decl.WithoutAttribute("MarshalAs"),
 			_ => decl.WithoutTrivia()
 		};
 		tmpbuilder.parameters.Replace(decl, newParam);
@@ -598,7 +599,16 @@ private static void BuildMarshalAsMethod(SourceProductionContext context, Compil
 		// Create the invocation expression capturing the return value if the return type is not `void`
 		tmpbuilder.statements.invokeArgs = [.. tmpbuilder.statements.invokeArgs.Select(a => a switch
 			{
-				var a1 when a1.NameEquals(refParamName) => Argument(ParseExpression($"typeof({(unmanagedType == UnmanagedType.IUnknown ? genericType : decl.Type!.ToString().TrimEnd('?'))}).GUID")),
+				var a1 when a1.NameEquals(refParamName) => unmanagedType switch
+				{
+					UnmanagedType.IUnknown => Argument(ParseExpression($"typeof({genericType}).GUID")),
+					UnmanagedType.Interface => Argument(ParseExpression($"typeof({decl.Type!.ToString().TrimEnd('?')}).GUID")),
+					UnmanagedType.LPArray when modAttr is ModType.In && methodDecl.ParameterList.Parameters.FirstOrDefault(p => p.Identifier.Text == refParamName) is ParameterSyntax refParam =>
+						paramTypeIsNullable
+						? Argument(ParseExpression($"({refParam.Type})Convert.ChangeType({decl.Identifier.Text}?.Length ?? 0, typeof({refParam.Type}))"))
+						: Argument(ParseExpression($"({refParam.Type})Convert.ChangeType({decl.Identifier.Text}.Length, typeof({refParam.Type}))")),
+					_ => a1,
+				},
 				var a1 when a1.Expression is IdentifierNameSyntax ins && ins.Identifier.Text == decl.Identifier.Text => isOutParam
 					? Argument(null, MethodBodyBuilder.outToken, DeclarationExpression(IdentifierName("var"), SingleVariableDesignation(Identifier(altArg))))
 					: Argument(IdentifierName(ins.Identifier.Text)),
@@ -624,16 +634,22 @@ var a1 when a1.NameEquals(refParamName) => Argument(ParseExpression($"typeof({(u
 		// Process the xml docs for the method
 		if (tmpbuilder.docs is not null)
 		{
-			// Get the xml node for the IID parameter docs
-			XmlNode? iidNode = tmpbuilder.docs.SelectSingleNode($"//param[@name='{refParamName}']");
-			if (iidNode is not null)
+			// Get the xml node for the ref parameter docs
+			XmlNode? refNode = tmpbuilder.docs.SelectSingleNode($"//param[@name='{refParamName}']");
+			if (refNode is not null)
 			{
-				// Add the IID parameter docs to the method docs as the value of the typeParam tag
+				// Add the ref parameter docs to the method docs as the value of the typeParam tag
 				if (unmanagedType == UnmanagedType.IUnknown)
-					tmpbuilder.docs.InsertTypeParamDocAfter(genericType, iidNode.InnerXml);
+					tmpbuilder.docs.InsertTypeParamDocAfter(genericType, refNode.InnerXml);
 
-				// Remove the IID parameter docs
-				iidNode.ParentNode?.RemoveChild(iidNode);
+				// Remove the ref parameter docs
+				refNode.ParentNode?.RemoveChild(refNode);
+
+				// Remove the "<paramref name="refParamName"/>" tags from the entire document
+				XmlElement replElem = tmpbuilder.docs.CreateElement("c");
+				replElem.InnerText = refParamName;
+				foreach (var n in tmpbuilder.docs.SelectNodes($"//paramref[@name='{refParamName}']").Cast<XmlElement>().Where(n => n.ParentNode is not null))
+					n.ParentNode?.ReplaceChild(replElem, n);
 			}
 		}
 
@@ -676,25 +692,36 @@ bool ValidateAttr(out string refParamName, out UnmanagedType unmanagedType)
 						break;
 
 					case UnmanagedType.LPArray:
-					//refindex = GetIndex("SizeParamIndex");
-					//if (refindex == -1 || modAttr != ModType.In)
-					//	return false;
-					//break;
+						refindex = GetIndex("SizeParamIndex");
+						if (refindex == -1 || modAttr != ModType.In)
+							return false;
+						break;
+
 					default:
 						return false;
 				}
 			}
 
-			// If there's an refindex, then make sure it points to a valid Guid parameter
+			// If there's an refindex, then make sure it points to a valid parameter
 			if (refindex >= 0)
 			{
 				var iidParam = methodDecl.ParameterList.Parameters[refindex];
 				var paramType = iidParam.Type?.ToString();
-				var hasInModifier = iidParam.Modifiers.Any(SyntaxKind.InKeyword);
-				var hasStructAttribute = !hasInModifier && iidParam.AttributeLists
-					.SelectMany(al => al.Attributes)
-					.Any(attr => attr.Name.ToFullString() == "MarshalAs" && attr.ArgumentList?.Arguments.FirstOrDefault()?.ToString() == "UnmanagedType.Struct");
-				if ((paramType == "System.Guid" || paramType == "Guid") && (hasInModifier || hasStructAttribute))
+				// For interfaces, confirm param type is Guid
+				if (unmanagedType is UnmanagedType.IUnknown or UnmanagedType.Interface)
+				{
+					var hasInModifier = iidParam.Modifiers.Any(SyntaxKind.InKeyword);
+					var hasStructAttribute = !hasInModifier && iidParam.AttributeLists
+						.SelectMany(al => al.Attributes)
+						.Any(attr => attr.Name.ToFullString() == "MarshalAs" && attr.ArgumentList?.Arguments.FirstOrDefault()?.ToString() == "UnmanagedType.Struct");
+					if ((paramType == "System.Guid" || paramType == "Guid") && (hasInModifier || hasStructAttribute))
+					{
+						refParamName = iidParam.Identifier.Text;
+						return true;
+					}
+				}
+				// For LPArray, type is integral so pass along
+				else if (unmanagedType == UnmanagedType.LPArray)
 				{
 					refParamName = iidParam.Identifier.Text;
 					return true;
@@ -715,18 +742,27 @@ int GetIndex(string attrNamedArg)
 
 	private static TypeDeclarationSyntax GetParamType(SourceProductionContext context, ParameterSyntax decl) => GetFirstTypeParent(context, decl);
 
-	private static bool IsParamInNotNewStaticMethod(SyntaxNode syntaxNode, CancellationToken cancellationToken) =>
-		syntaxNode is ParameterSyntax ps && ps.Parent?.Parent is MethodDeclarationSyntax ms && !ms.Modifiers.Any(SyntaxKind.NewKeyword) && ms.Modifiers.Any(SyntaxKind.StaticKeyword);
+	// Confirm param is in a method is not new or unsafe and does not have SuppressAutoGen attribute
+	private static bool IsParamInMethod(SyntaxNode syntaxNode, CancellationToken cancellationToken, out MethodDeclarationSyntax? ms)
+	{
+		ms = syntaxNode is ParameterSyntax ps && ps.Parent?.Parent is MethodDeclarationSyntax mds
+			&& !mds.Modifiers.Any(SyntaxKind.UnsafeKeyword) && !mds.Modifiers.Any(SyntaxKind.NewKeyword)
+			&& !mds.AttributeLists.SelectMany(al => al.Attributes).Any(a => a.Name.ToString().Contains("SuppressAutoGen")) ? mds : null;
+		return ms is not null;
+	}
+
+	private static bool IsParamInMethod(SyntaxNode syntaxNode, CancellationToken cancellationToken) => IsParamInMethod(syntaxNode, cancellationToken, out _);
 
-	private static bool IsParamInNotNewMethod(SyntaxNode syntaxNode, CancellationToken cancellationToken) =>
-		syntaxNode is ParameterSyntax ps && ps.Parent?.Parent is MethodDeclarationSyntax ms && !ms.Modifiers.Any(SyntaxKind.NewKeyword);
+	private static bool IsParamInStaticMethod(SyntaxNode syntaxNode, CancellationToken cancellationToken) =>
+		IsParamInMethod(syntaxNode, cancellationToken, out var ms) && ms!.Modifiers.Any(SyntaxKind.StaticKeyword);
 
-	private static bool IsParamWithArgs(SyntaxNode syntaxNode, CancellationToken cancellationToken) => syntaxNode is ParameterSyntax ps &&
-		ps.Parent?.Parent is MethodDeclarationSyntax ms && !ms.Modifiers.Any(SyntaxKind.NewKeyword) &&
-		(ms?.Parent is ClassDeclarationSyntax cs && cs.IsPartial() || ms?.Parent is InterfaceDeclarationSyntax && ms?.Parent?.Parent is ClassDeclarationSyntax ccs && ccs.IsPartial());
+	private static bool IsParamInNestedType(SyntaxNode syntaxNode, CancellationToken cancellationToken) =>
+		IsParamInMethod(syntaxNode, cancellationToken, out var ms) &&
+		((ms?.Parent is ClassDeclarationSyntax cs && cs.IsPartial() && ms.Modifiers.Any(SyntaxKind.StaticKeyword) && ms.Modifiers.Any(SyntaxKind.ExternKeyword)) ||
+		(ms?.Parent is InterfaceDeclarationSyntax && ms?.Parent?.Parent is ClassDeclarationSyntax ccs && ccs.IsPartial()));
 
 	private static bool IsPartialType(SyntaxNode syntaxNode, CancellationToken cancellationToken) => syntaxNode is TypeDeclarationSyntax tds && tds.IsPartial();
-	
+
 	private static TypeDeclarationSyntax ParentForExtMethod(SourceProductionContext context, ParameterSyntax decl)
 	{
 		var parentClass = decl.Parent?.Parent?.Parent is ClassDeclarationSyntax cs ? cs : (decl.Parent?.Parent?.Parent is InterfaceDeclarationSyntax && decl.Parent?.Parent?.Parent?.Parent is ClassDeclarationSyntax ccs ? ccs : null);

PInvoke/ComCtl32/CommCtrl.ImageList.cs

@@ -2550,7 +2550,7 @@ public partial class SafeHIMAGELIST
 	{
 		/// <summary>Gets the IImageList interface for this handle.</summary>
 		/// <value>The interface.</value>
-		public IImageList Interface => HIMAGELIST_QueryInterface<IImageList>(handle);
+		public IImageList Interface => HIMAGELIST_QueryInterface<IImageList>(handle)!;
 
 		/// <summary>Gets a safe HIMAGELIST handle from an <see cref="IImageList"/> instance.</summary>
 		/// <param name="iil">An IImageList object.</param>

PInvoke/CoreAudio/AudioClient.cs

@@ -158,6 +158,9 @@ public interface IAcousticEchoCancellationControl
 	public interface IAudioAmbisonicsControl
 	{
 		/// <summary>Undocumented</summary>
+		/// <param name="pAmbisonicsParams"></param>
+		/// <param name="cbAmbisonicsParams"></param>
+		/// <returns></returns>
 		[PreserveSig]
 		HRESULT SetData([In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] AMBISONICS_PARAMS[] pAmbisonicsParams,
 			uint cbAmbisonicsParams);

PInvoke/Cryptography/Crypt32/Wincrypt.OID.cs

@@ -68,7 +68,7 @@ public delegate bool PFN_CRYPT_ENUM_OID_FUNC(CertEncodingType dwEncodingType, [M
 	[return: MarshalAs(UnmanagedType.Bool)]
 	public delegate bool PFN_CRYPT_ENUM_OID_INFO(PCCRYPT_OID_INFO pInfo, [In, Out, Optional] IntPtr pvArg);
 
-	/// <summary>Flags for <see cref="CryptInstallOIDFunctionAddress"/>.</summary>
+	/// <summary>Flags for <see cref="CryptInstallOIDFunctionAddress(HINSTANCE, CertEncodingType, string, uint, CRYPT_OID_FUNC_ENTRY[], CryptInstallOIDFuncFlags)"/>.</summary>
 	[PInvokeData("wincrypt.h", MSDNShortId = "934e8278-0e0b-4402-a2b6-ff1e913d54c9")]
 	[Flags]
 	public enum CryptInstallOIDFuncFlags

PInvoke/Cryptography/Crypt32/Wincrypt.Verification.cs

@@ -250,7 +250,7 @@ public enum CertChainStrongSignFlags
 		CERT_CHAIN_STRONG_SIGN_DISABLE_END_CHECK_FLAG = 0x00000001,
 	}
 
-	/// <summary>Flags used by <see cref="CertCreateCTLEntryFromCertificateContextProperties"/>.</summary>
+	/// <summary>Flags used by <see cref="CertCreateCTLEntryFromCertificateContextProperties(PCCERT_CONTEXT, uint, CRYPT_ATTRIBUTE[], CertCreateCTLEntryFlags, IntPtr, IntPtr, ref uint)"/>.</summary>
 	[PInvokeData("wincrypt.h", MSDNShortId = "90ac512f-3cbe-4543-9b34-8e384f730cfe")]
 	[Flags]
 	public enum CertCreateCTLEntryFlags
@@ -305,7 +305,7 @@ public enum CryptMsgEncodeFlags
 		CMSG_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG = 0x2,
 	}
 
-	/// <summary>Flags for <see cref="CryptMsgGetAndVerifySigner"/>.</summary>
+	/// <summary>Flags for <see cref="CryptMsgGetAndVerifySigner(HCRYPTMSG, uint, HCERTSTORE[], CryptMsgSignerFlags, out SafePCCERT_CONTEXT, ref uint)"/>.</summary>
 	[PInvokeData("wincrypt.h", MSDNShortId = "380c9cf3-27a2-4354-b1c8-97cec33f4e44")]
 	[Flags]
 	public enum CryptMsgSignerFlags

PInvoke/DXCore/DXCore.cs

@@ -2301,65 +2301,6 @@ public interface IDXCoreAdapterList
 		bool IsAdapterPreferenceSupported(DXCoreAdapterPreference preference);
 	}
 
-	/// <summary>
-	/// Generates a list of adapter objects representing the current adapter state of the system, and meeting the criteria specified. For
-	/// programming guidance, and code examples, see <c>Using DXCore to enumerate adapters</c>.
-	/// </summary>
-	/// <typeparam name="T">The type of the interface that you wish to be returned in ppvAdapterList. This is expected to be IDXCoreAdapterList.</typeparam>
-	/// <param name="factory">The <see cref="IDXCoreAdapterFactory"/> instance.</param>
-	/// <param name="filterAttributes">
-	/// An array of adapter attribute GUIDs. For a list of attribute GUIDs, see DXCore adapter attribute GUIDs. At least one GUID must be
-	/// provided. In the case that more than one GUID is provided in the array, only adapters that meet all of the requested attributes will
-	/// be included in the returned list.
-	/// </param>
-	/// <param name="ppvAdapterList">
-	/// The address of a pointer to an interface with the IID specified in the riid parameter. Upon successful return, *ppvAdapterList (the
-	/// dereferenced address) contains a pointer to the adapter list created.
-	/// </param>
-	/// <returns>
-	/// <para>Type: <b><c>HRESULT</c></b></para>
-	/// <para>If the function succeeds, it returns <b>S_OK</b>. Otherwise, it returns an <c><b>HRESULT</b></c><c>error code</c>.</para>
-	/// <list type="table">
-	/// <listheader>
-	/// <description>Return value</description>
-	/// <description>Description</description>
-	/// </listheader>
-	/// <item>
-	/// <description>E_INVALIDARG</description>
-	/// <description>
-	/// <code>nullptr</code>
-	/// was provided for <c>filterAttributes</c>, or 0 was provided for <c>numAttributes</c>.
-	/// </description>
-	/// </item>
-	/// <item>
-	/// <description>E_NOINTERFACE</description>
-	/// <description>An invalid value was provided for <c>riid</c>.</description>
-	/// </item>
-	/// <item>
-	/// <description>E_POINTER</description>
-	/// <description>
-	/// <code>nullptr</code>
-	/// was provided for <c>ppvAdapterList</c>.
-	/// </description>
-	/// </item>
-	/// </list>
-	/// </returns>
-	/// <remarks>
-	/// Even if no adapters are found, as long as the arguments are valid, <b>CreateAdapterList</b> creates a valid
-	/// <c>IDXCoreAdapterList</c> object, and returns <b>S_OK</b>. Once generated, the adapters in this specific list won't change. But the
-	/// list will be considered stale if one of the adapters later becomes invalid, or if a new adapter arrives that meets the provided
-	/// filter criteria. The list returned by <b>CreateAdapterList</b> is not ordered in any particular way, but the ordering of a list is
-	/// consistent across multiple calls, and even across operating system restarts. The ordering may change upon system configuration
-	/// changes, including the addition or removal of an adapter, or a driver update on an existing adapter. You can register for these
-	/// changes with <c>IDXCoreAdapterFactory::RegisterEventNotification</c> using the notification type <b>DXCoreNotificationType.AdapterListStale</b>.
-	/// </remarks>
-	public static HRESULT CreateAdapterList<T>(this IDXCoreAdapterFactory factory, Guid[] filterAttributes, out T? ppvAdapterList) where T : class
-	{
-		var hr = factory.CreateAdapterList(filterAttributes.Length, filterAttributes, typeof(T).GUID, out var ppv);
-		ppvAdapterList = (T?)ppv;
-		return hr;
-	}
-
 	/// <summary>
 	/// Creates a DXCore adapter factory, which you can use to generate further DXCore objects. For programming guidance, and code examples,
 	/// see Using DXCore to enumerate adapters.