Silly fixes: fix #2298, fix #2238, fix #2128

Author: Perksey

src/Core/Silk.NET.BuildTools/Common/Functions/Function.cs

@@ -101,6 +101,11 @@ public class Function : IEquatable<Function>, IProfileConstituent
         /// members.
         /// </summary>
         public bool IsReadOnly { get; set; }
+        
+        /// <summary>
+        /// Whether this method is an override.
+        /// </summary>
+        public bool IsOverride { get; set; }
 
         /// <summary>
         /// Prefix to invocations of this function e.g. "@this->". May be null.
@@ -212,6 +217,11 @@ private void GetDeclarationString(StringBuilder sb,
                 sb.Append("unsafe ");
             }
 
+            if (IsOverride)
+            {
+                sb.Append("override ");
+            }
+
             if (partial)
             {
                 sb.Append("partial ");

src/Core/Silk.NET.BuildTools/Common/Utilities.cs

@@ -625,21 +625,31 @@ public static string ToNativeName(this Decl decl)
         }
 
         public static bool IsProbablyABitmask(this Enums.Enum @enum)
-            => @enum.Tokens.Count > 1 && // there is more than one token
-               // at least approx 50% of the tokens have only one bit set
-               @enum.Tokens.Count(x => BitOperations.PopCount(ParseToken(x.Value, @enum)) == 1)
-               >= MathF.Floor(@enum.Tokens.Count / 2f) &&
-               // it's not sequential (1, 2, 3)
-               !@enum.IsSequential();
-
-        private static bool IsSequential(this Enums.Enum @enum)
+        {
+            var parsed = @enum.Tokens.Select(x => ParseToken(x.Value, @enum)).ToArray();
+            var popcnt1Cnt = parsed.Count(x => BitOperations.PopCount(x) == 1);
+            // there is more than one token
+            return @enum.Tokens.Count > 1 &&
+                // at least approx 50% of the tokens have only one bit set
+                popcnt1Cnt >= MathF.Floor(@enum.Tokens.Count / 2f) &&
+                // it's not sequential (1, 2, 3)
+                !parsed.IsSeeminglySequential() ||
+                // alternatively, all items that are not MaxValue or 0 have popcnt == 1
+                // https://github.com/dotnet/Silk.NET/issues/2238
+                parsed.Count(x => x is not 0 and not 0x7FFFFFFF) == popcnt1Cnt &&
+                // and there are more than two items with popcnt == 1
+                popcnt1Cnt > 2;
+        }
+
+        // renamed from IsSequential as suggested by this comment:
+        // https://discord.com/channels/521092042781229087/587346162802229298/1284528132807987212
+        private static bool IsSeeminglySequential(this ulong[] @enum)
         {
             const int maxMisses = 1;
             var misses = 0;
-            for (var i = 0; i < @enum.Tokens.Count; i++)
+            for (var i = 0; i < @enum.Length; i++)
             {
-                if (ParseToken(@enum.Tokens[i].Value, @enum) != (ulong)(i - misses) &&
-                    ParseToken(@enum.Tokens[i].Value, @enum) != (ulong)((i - misses) + 1))
+                if (@enum[i] != (ulong)(i - misses) && @enum[i] != (ulong)(i - misses + 1))
                 {
                     misses++;
                 }

src/Core/Silk.NET.BuildTools/Converters/Readers/VulkanReader.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 using Silk.NET.BuildTools.Common;
 using Silk.NET.BuildTools.Common.Enums;
 using Silk.NET.BuildTools.Common.Functions;
@@ -148,6 +149,14 @@ IReadOnlyList<Struct> GetAllAliasesFromName(string? api, string structName)
                     continue;
                 }
 
+                var toString = new Function
+                {
+                    Accessibility = Accessibility.Public,
+                    IsOverride = true,
+                    ReturnType = new Type { Name = "string" },
+                    Name = "ToString"
+                };
+
                 var @struct = new Struct
                 {
                     Fields = s.Members.Select
@@ -179,6 +188,10 @@ IReadOnlyList<Struct> GetAllAliasesFromName(string? api, string structName)
                             }.WithFixedFieldFixup09072020()
                         )
                         .ToList(),
+                    Functions = new List<ImplementedFunction>
+                    {
+                        new(toString, new StringBuilder("return Handle.ToString();"), toString, false)
+                    },
                     Name = Naming.TranslateLite(TrimName(s.Name, task), prefix),
                     NativeName = s.Name,
                     ProfileName = s.Api

src/Core/Silk.NET.BuildTools/Cpp/Clang.cs

@@ -679,7 +679,7 @@ Type GetType(ClangSharp.Type type, out Count count, ref FlowDirection flow, out
                 if (type is ArrayType arrayType)
                 {
                     ret = GetType(arrayType.ElementType, out var currentCount, ref flow, out _);
-                    ret.IndirectionLevels++;
+                    ret.IndirectionLevels++; // TODO this is wrong for >2 dims!
                     var asize = arrayType.Handle.ArraySize;
                     if (asize != -1)
                     {
@@ -812,7 +812,13 @@ Type GetType(ClangSharp.Type type, out Count count, ref FlowDirection flow, out
                     }
                     else
                     {
-                        ret = new Type { Name = elaboratedType.NamedType.AsString };
+                        var name = elaboratedType.NamedType.AsString;
+                        if (name.LastIndexOf("::", StringComparison.Ordinal) is not -1 and var v)
+                        {
+                            name = name[(v + 2)..];
+                        }
+
+                        ret = new Type { Name = name };
                     }
                 }
                 else if (type is FunctionType functionType)

src/Core/Silk.NET.Core/Loader/DefaultPathResolver.cs

@@ -33,6 +33,7 @@ public class DefaultPathResolver : PathResolver
         /// - <see cref="MainModuleDirectoryResolver" />
         /// - <see cref="RuntimesFolderResolver" />
         /// - <see cref="NativePackageResolver" />
+        /// - <see cref="SilkDirectoryResolver"/>
         /// </summary>
         public DefaultPathResolver() => Resolvers = new()
         {
@@ -42,7 +43,8 @@ public class DefaultPathResolver : PathResolver
             BaseDirectoryResolver,
             MainModuleDirectoryResolver,
             RuntimesFolderResolver,
-            NativePackageResolver
+            NativePackageResolver,
+            SilkDirectoryResolver
         };
 
         /// <summary>
@@ -96,6 +98,44 @@ public class DefaultPathResolver : PathResolver
             return Enumerable.Empty<string>();
         };
 
+        /// <summary>
+        /// A resolver that returns a path to a file in Silk.NET's <see cref="Assembly.Location"/> and/or
+        /// <see cref="Assembly.CodeBase"/> directory with the given name.
+        /// </summary>
+        public static readonly Func<string, IEnumerable<string>> SilkDirectoryResolver = name =>
+        {
+            try
+            {
+                var asmLocation = typeof(DefaultPathResolver).Assembly.Location;
+                // check that name doesn't have a directory name, we only want raw filenames so that the Path.Combine
+                // doesn't blow up.
+                if (!string.IsNullOrWhiteSpace(Path.GetDirectoryName(name)) && !string.IsNullOrWhiteSpace(asmLocation) && File.Exists(asmLocation))
+                {
+                    asmLocation = Path.GetDirectoryName(asmLocation);
+                    if (asmLocation is not null)
+                    {
+                        return Enumerable.Repeat(Path.Combine(asmLocation, name), 1);
+                    }
+                }
+
+                asmLocation = typeof(DefaultPathResolver).Assembly.CodeBase;
+                if (!string.IsNullOrWhiteSpace(Path.GetDirectoryName(name)) && !string.IsNullOrWhiteSpace(asmLocation) && File.Exists(asmLocation))
+                {
+                    asmLocation = Path.GetDirectoryName(asmLocation);
+                    if (asmLocation is not null)
+                    {
+                        return Enumerable.Repeat(Path.Combine(asmLocation, name), 1);
+                    }
+                }
+            }
+            catch
+            {
+                // not supported on the WASI-SDK
+            }
+
+            return Enumerable.Empty<string>();
+        };
+
         /// <summary>
         /// A resolver that, given an absolute or relative path, searches for a "runtimes" folder in the directory
         /// represented by the given name for a file matching the given path's file name in one of the applicable