Save progress, as I am deleting the progress

generator.json

@@ -12,7 +12,7 @@
  },
  "InputSourceRoot": "eng/submodules/terrafx.interop.windows/sources/Interop/Windows",
  "InputTestRoot": "eng/submodules/terrafx.interop.windows/tests/Interop/Windows",
- "OutputSourceRoot": "sources/Windows",
+ "OutputSourceRoot": "sources/Win32/Win32",
  "OutputTestRoot": "tests/Windows",
  "DefaultLicenseHeader": "eng/silktouch/header.txt",
  "Solution": "Silk.NET.sln",

sources/Core/Core/Abstractions/BreakneckLock.cs

@@ -0,0 +1,195 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Sourced from https://github.com/john-h-k/SpinLockSlim under the MIT license
+
+// MIT License
+//
+// Copyright (c) 2019 John Kelly
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+// ReSharper disable RedundantAssignment
+
+namespace Silk.NET.Core;
+
+/// <summary>
+/// Provided a lightweight spin lock for synchronization in high performance
+/// scenarios with a low hold time
+/// </summary>
+/// <remarks>
+/// This lock is very performant, but it is very dangerous (hence breakneck).
+/// It's recommended to use the framework-provided locks where possible.
+/// </remarks>
+public struct BreakneckLock
+{
+ private static int True => 1;
+ private static int False => 0;
+
+ private const MethodImplOptions MaxOpt = (MethodImplOptions)768;
+
+ private volatile int _acquired; // either 1 or 0
+
+ /// <summary>
+ /// Creates a new <see cref="BreakneckLock"/>
+ /// </summary>
+ /// <returns>A new <see cref="BreakneckLock"/></returns>
+ [MethodImpl(MaxOpt)]
+ public static BreakneckLock Create() => new();
+
+ /// <summary>
+ /// Returns <c>true</c> if the lock is acquired, else <c>false</c>
+ /// </summary>
+#pragma warning disable 420 // Unsafe.As<,> doesn't read the reference so the lack of volatility is not an issue, but we do need to treat the returned reference as volatile
+ public bool IsAcquired => Volatile.Read(ref Unsafe.As<int, bool>(ref _acquired));
+#pragma warning restore 420
+
+ /// <summary>
+ /// Enter the lock. If this method returns, <paramref name="taken"/>
+ /// will be <c>true</c>. If an exception occurs, <paramref name="taken"/> will indicate
+ /// whether the lock was taken and needs to be released using <see cref="Exit()"/>.
+ /// This method may never exit
+ /// </summary>
+ /// <param name="taken">A reference to a bool that indicates whether the lock is taken. Must
+ /// be <c>false</c> when passed, else the internal state or return state may be corrupted.
+ /// If the method returns, this is guaranteed to be <c>true</c></param>
+ [MethodImpl(MaxOpt)]
+ public void Enter(ref bool taken)
+ {
+ // while acquired == 1, loop, then when it == 0, exit and set it to 1
+ while (!TryAcquire())
+ {
+ // NOP
+ }
+
+ taken = true;
+ }
+
+ /// <summary>
+ /// Enter the lock if it not acquired, else, do not. <paramref name="taken"/> will be
+ /// <c>true</c> if the lock was taken, else <c>false</c>. If <paramref name="taken"/> is
+ /// <c>true</c>, <see cref="Exit()"/> must be called to release it, else, it must not be called
+ /// </summary>
+ /// <param name="taken">A reference to a bool that indicates whether the lock is taken. Must
+ /// be <c>false</c> when passed, else the internal state or return state may be corrupted</param>
+ [MethodImpl(MaxOpt)]
+ public void TryEnter(ref bool taken)
+ {
+ taken = TryAcquire();
+ }
+
+ /// <summary>
+ /// Try to safely enter the lock a certain number of times (<paramref name="iterations"/>).
+ /// <paramref name="taken"/> will be <c>true</c> if the lock was taken, else <c>false</c>.
+ /// If <paramref name="taken"/> is <c>true</c>, <see cref="Exit()"/> must be called to release
+ /// it, else, it must not be called
+ /// </summary>
+ /// <param name="taken">A reference to a bool that indicates whether the lock is taken. Must
+ /// be <c>false</c> when passed, else the internal state or return state may be corrupted</param>
+ /// <param name="iterations">The number of attempts to acquire the lock before returning
+ /// without the lock</param>
+ [MethodImpl(MaxOpt)]
+ public void TryEnter(ref bool taken, uint iterations)
+ {
+ // if it acquired == 0, change it to 1 and return true, else return false
+ while (!TryAcquire())
+ {
+ if (unchecked(iterations--) == 0) // postfix decrement, so no issue if iterations == 0 at first
+ {
+ return;
+ }
+ }
+
+ taken = true;
+ }
+
+ /// <summary>
+ /// Try to safely enter the lock for a certain <see cref="TimeSpan"/> (<paramref name="timeout"/>).
+ /// <paramref name="taken"/> will be <c>true</c> if the lock was taken, else <c>false</c>.
+ /// If <paramref name="taken"/> is <c>true</c>, <see cref="Exit()"/> must be called to release
+ /// it, else, it must not be called
+ /// </summary>
+ /// <param name="taken">A reference to a bool that indicates whether the lock is taken. Must
+ /// be <c>false</c> when passed, else the internal state or return state may be corrupted</param>
+ /// <param name="timeout">The <see cref="TimeSpan"/> to attempt to acquire the lock for before
+ /// returning without the lock. A negative <see cref="TimeSpan"/>will cause undefined behaviour</param>
+ [MethodImpl(MaxOpt)]
+ public void TryEnter(ref bool taken, TimeSpan timeout)
+ {
+ long start = Stopwatch.GetTimestamp();
+ long end = unchecked((long)timeout.TotalMilliseconds * Stopwatch.Frequency + start);
+
+ // if it acquired == 0, change it to 1 and return true, else return false
+ while (!TryAcquire())
+ {
+ if (Stopwatch.GetTimestamp() >= end)
+ {
+ return;
+ }
+ }
+
+ taken = true;
+ }
+
+ /// <summary>
+ /// Exit the lock. This method is dangerous and must be called only once the caller is sure they have
+ /// ownership of the lock.
+ /// </summary>
+ [MethodImpl(MaxOpt)]
+ public void Exit()
+ {
+ // release the lock - int32 write will always be atomic
+ _acquired = False;
+ }
+
+ /// <summary>
+ /// Exit the lock with an optional post-release memory barrier. This method is dangerous and must be called only
+ /// once the caller is sure they have ownership of the lock.
+ /// </summary>
+ /// <param name="insertMemBarrier">Whether a memory barrier should be inserted after the release</param>
+ [MethodImpl(MaxOpt)]
+ public void Exit(bool insertMemBarrier)
+ {
+ Exit();
+
+ if (insertMemBarrier)
+ Thread.MemoryBarrier();
+ }
+
+ /// <summary>
+ /// Exit the lock with a post-release memory barrier. This method is dangerous and must be called only once the
+ /// caller is sure they have ownership of the lock.
+ /// </summary>
+ [MethodImpl(MaxOpt)]
+ public void ExitWithBarrier()
+ {
+ Exit();
+ Thread.MemoryBarrier();
+ }
+
+ [MethodImpl(MaxOpt)]
+ private bool TryAcquire()
+ {
+ // if it acquired == 0, change it to 1 and return true, else return false
+ return Interlocked.CompareExchange(ref _acquired, True, False) == False;
+ }
+}

sources/SilkTouch/SilkTouch/Mods/Common/IMod.cs

@@ -16,53 +16,8 @@ namespace Silk.NET.SilkTouch.Mods;
 public interface IMod
 {
  /// <summary>
- /// Runs before SilkTouch does anything with the given job name and job configuration.
+ /// Initializes the mod.
  /// </summary>
- /// <param name="key">The job name (corresponds to the configuration key for mod configs).</param>
- /// <param name="config">The job config.</param>
- /// <returns>An asynchronous task.</returns>
- Task BeforeJobAsync(string key, SilkTouchConfiguration config) => Task.CompletedTask;
-
- /// <summary>
- /// Runs before SilkTouch invokes ClangSharp with the given parsed response files. Gives each mod an opportunity to
- /// modify the generator configuration.
- /// </summary>
- /// <param name="key">The job name (corresponds to the configuration key for mod configs).</param>
- /// <param name="rsps">The read response files.</param>
- /// <returns>
- /// The modified response files to be passed into either the next mod or ClangSharp if this is the last mod.
- /// </returns>
- Task<List<ResponseFile>> BeforeScrapeAsync(string key, List<ResponseFile> rsps) =>
- Task.FromResult(rsps);
-
- /// <summary>
- /// Runs after SilkTouch has invoked ClangSharp which generated the given syntax nodes. Gives each mod an
- /// opportunity to mutate the syntax tree.
- /// </summary>
- /// <param name="key">The job name (corresponds to the configuration key for mod configs).</param>
- /// <param name="syntax">The generated output from ClangSharp (or the previous mod).</param>
- /// <returns>
- /// The modified syntax nodes to be either passed to the next mod or output from the generator if this is the last
- /// mod.
- /// </returns>
- Task<GeneratedSyntax> AfterScrapeAsync(string key, GeneratedSyntax syntax) =>
- Task.FromResult(syntax);
-
- /// <summary>
- /// Runs before SilkTouch is going to output the MSBuild workspace. The generated documents have already been added,
- /// so this gives the opportunity for the mod to modify the workspace further.
- /// </summary>
- /// <param name="key">The job name (corresponds to the configuration key for mod configs).</param>
- /// <param name="workspace">The generated output from scraping.</param>
- /// <returns>The modified MSBuild solution either to be output or passed to the next mod if applicable.</returns>
- Task<GeneratorWorkspace> BeforeOutputAsync(string key, GeneratorWorkspace workspace) =>
- Task.FromResult(workspace);
-
- /// <summary>
- /// Runs after all generation activities have completed. Gives each mod an opportunity to clean up its state for
- /// this job.
- /// </summary>
- /// <param name="key">The job name (corresponds to the configuration key for mod configs).</param>
- /// <returns>An asynchronous task.</returns>
- Task AfterJobAsync(string key) => Task.CompletedTask;
+ /// <param name="context"></param>
+ void Initialize(IModContext context);
 }

sources/SilkTouch/SilkTouch/Mods/Common/IModContext.cs

@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+namespace Silk.NET.SilkTouch.Mods;
+
+/// <summary>
+/// An interface into the mod pipeline for mod execution.
+/// </summary>
+public interface IModContext
+{
+ /// <summary>
+ /// The current job key.
+ /// </summary>
+ string JobKey { get; }
+
+ /// <summary>
+ /// Denotes this mod as producing artifacts of the given type.
+ /// </summary>
+ /// <param name="allowedModes">The modes allowed to be used for this artifact.</param>
+ /// <typeparam name="T">The type of the artifacts.</typeparam>
+ /// <remarks>
+ /// This method should be used if <see cref="AddArtifacts{T}"/> is not called prior to the enumeration of artifacts
+ /// added using <see cref="AddArtifacts{T}"/>. <see cref="AddArtifacts{T}"/> does enact the behaviour of this
+ /// function implicitly provided that it is called before <see cref="IMod.Initialize"/> exits.
+ /// </remarks>
+ void ProducesArtifacts<T>(
+ ModArtifactAccess allowedModes =
+ ModArtifactAccess.Exclusive | ModArtifactAccess.Shared | ModArtifactAccess.Take
+ );
+
+ /// <summary>
+ /// Denotes this mod as receiving artifacts of the given type.
+ /// </summary>
+ /// <param name="accessMode">The mode with which the artifacts shall be accessed.</param>
+ /// <typeparam name="T">The type of the artifacts.</typeparam>
+ /// <remarks>
+ /// This method should be used if <see cref="GetArtifacts{T}"/> is not called prior to the enumeration of artifacts
+ /// added using <see cref="AddArtifacts{T}"/>. <see cref="GetArtifacts{T}"/> does enact the behaviour of this
+ /// function implicitly provided that it is called before <see cref="IMod.Initialize"/> exits.
+ /// </remarks>
+ void ReceivesArtifacts<T>(ModArtifactAccess accessMode);
+
+ /// <summary>
+ /// Gets the artifacts of the given type from previous mods in the pipeline.
+ /// </summary>
+ /// <typeparam name="T">The type of the artifacts.</typeparam>
+ /// <returns>The artifacts.</returns>
+ /// <remarks>
+ /// This should be called within <see cref="IMod.Initialize"/>, but should be enumerated as part of the evaluation
+ /// of <see cref="AddArtifacts{T}"/>. Calling this and using the result either in a LINQ method chain or async
+ /// generator (i.e. <c>yield</c>) should be sufficient. If this is not achievable, use
+ /// <see cref="ReceivesArtifacts{T}"/>.
+ /// </remarks>
+ IAsyncEnumerable<T> GetArtifacts<T>(ModArtifactAccess accessMode);
+
+ /// <summary>
+ /// Adds the given artifacts to the pipeline.
+ /// </summary>
+ /// <param name="artifacts">The artifacts</param>
+ /// <param name="allowedModes">
+ /// The allowable modes with which the artifacts can be accessed. This is used to determine the concurrent flow of
+ /// artifacts through the pipeline. Generally this is expected to be consistent for any given artifact type, and
+ /// should reflect whether the artifact is stateful or not (i.e. stateful/mutable artifacts should use
+ /// <see cref="ModArtifactAccess.Exclusive"/> or <see cref="ModArtifactAccess.Take"/>, whereas immutable artifacts
+ /// should use <see cref="ModArtifactAccess.Shared"/> or <see cref="ModArtifactAccess.Take"/>). This is simply used
+ /// for validation of calls to <see cref="GetArtifacts{T}"/>/<see cref="ReceivesArtifacts{T}"/>.
+ /// </param>
+ /// <typeparam name="T">The type of the artifacts.</typeparam>
+ void AddArtifacts<T>(
+ IAsyncEnumerable<T> artifacts,
+ ModArtifactAccess allowedModes =
+ ModArtifactAccess.Exclusive | ModArtifactAccess.Shared | ModArtifactAccess.Take
+ );
+}

sources/SilkTouch/SilkTouch/Mods/Common/IModLoader.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Extensions.Configuration;
+
+namespace Silk.NET.SilkTouch.Mods;
+
+public interface IModLoader
+{
+ bool TryLoadMod(string identifier, [NotNullWhen(true)] out IMod? mod);
+}