Add .NET 11 runtime async/await interop

Adds first-class async/await support for ClojureCLR targeting .NET 11's
runtime async feature. The compiler emits MethodImplAttributes.Async (0x2000)
and calls AsyncHelpers.Await — the runtime handles suspension, resumption,
and local hoisting. No state machine generation needed.

Compiler changes:
- New AwaitExpr AST node with await* special form
- ^:async metadata on defn sets the async flag on generated methods
- FnMethod emits invokeAsync() with 0x2000 flag, invoke() delegates to it
- Compile-time validation: await outside ^:async fn, await in catch/finally
- ^:async + primitive type hints rejected at compile time

Async interface support for gen-class and proxy:
- Methods returning Task/Task<T>/ValueTask/ValueTask<T> get 0x2000 flag
- Stubs await the IFn result and cast to the interface return type
- Enables implementing IAsyncDisposable, custom async interfaces, etc.

New Clojure namespace clojure.async.task:
- t/await — macro expanding to await* special form
- t/async — immediately-invoked async lambda block
- t/await-all — parallel await via Task.WhenAll
- t/->task, t/task? — helpers

All async code is gated behind #if NET11_0_OR_GREATER. Existing targets
(net6.0 through net10.0, net462, net481) are unaffected.

Includes 14 NUnit tests covering: basic async defn, args, closures across
await, chaining, void Task, async blocks, Task<T>, compile errors (outside
async, in catch, prim hints), C# interop, deftype async interface.

Author: Dangercoder

Clojure/Clojure.Source/Clojure.Source.csproj

@@ -153,6 +153,9 @@
     <EmbeddedResource Include="clojure\core\server.clj">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </EmbeddedResource>
+    <EmbeddedResource Include="clojure\async\task.clj">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </EmbeddedResource>
   </ItemGroup>
 
 </Project>

Clojure/Clojure.Source/clojure/async/task.clj

@@ -0,0 +1,49 @@
+(ns clojure.async.task
+  "Task-based async/await interop for .NET 11+ runtime async.
+   Requires .NET 11 Preview 1 or later."
+  (:refer-clojure :exclude [await]))
+
+(defmacro await
+  "Suspends the current ^:async function until the given Task completes.
+   Returns the task's result value. Only valid inside a ^:async defn
+   or an (async ...) block.
+
+   Usage:
+     (t/await (.ReadAllTextAsync System.IO.File path))
+     (t/await some-task)"
+  [task-expr]
+  `(await* ~task-expr))
+
+(defmacro async
+  "Executes body in an async context, returning a Task<object>.
+   The body may use (t/await ...) to suspend on Tasks.
+
+   Usage:
+     (t/async
+       (let [data (t/await (fetch url))]
+         (process data)))"
+  [& body]
+  `((^:async fn* [] ~@body)))
+
+(defmacro await-all
+  "Awaits multiple tasks in parallel. Returns a vector of results.
+
+   Usage:
+     (let [[a b c] (t/await-all (task1) (task2) (task3))]
+       ...)"
+  [& task-exprs]
+  (let [tasks-sym (gensym "tasks")]
+    `(let [~tasks-sym (into-array System.Threading.Tasks.Task [~@task-exprs])]
+       (await* (System.Threading.Tasks.Task/WhenAll ~tasks-sym))
+       (mapv (fn [t#] (.Result ^|System.Threading.Tasks.Task`1[System.Object]| t#)) ~tasks-sym))))
+
+(defn ->task
+  "Wraps a value in a completed Task<object>.
+   Uses an immediately-invoked async fn to wrap the value."
+  [value]
+  ((^:async fn* [] value)))
+
+(defn task?
+  "Returns true if x is a Task."
+  [x]
+  (instance? System.Threading.Tasks.Task x))

Clojure/Clojure.Source/clojure/core.clj

@@ -333,7 +333,7 @@
 		        ;;todo - restore propagation of fn name
 				;;must figure out how to convey primitive hints to self calls first
 								;;(cons `fn fdecl)
-								(with-meta (cons `fn fdecl) {:rettag (:tag m)})))))
+								(with-meta (cons `fn fdecl) (if (:async m) {:rettag (:tag m) :async true} {:rettag (:tag m)}))))))
 
 (. (var defn) (setMacro))       
 

Clojure/Clojure/CljCompiler/Ast/AwaitExpr.cs

@@ -0,0 +1,178 @@
+/**
+ *   Copyright (c) Rich Hickey. All rights reserved.
+ *   The use and distribution terms for this software are covered by the
+ *   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+ *   which can be found in the file epl-v10.html at the root of this distribution.
+ *   By using this software in any fashion, you are agreeing to be bound by
+ * 	 the terms of this license.
+ *   You must not remove this notice, or any other, from this software.
+ **/
+
+#if NET11_0_OR_GREATER
+
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Threading.Tasks;
+using clojure.lang.CljCompiler.Context;
+
+namespace clojure.lang.CljCompiler.Ast
+{
+    public class AwaitExpr : Expr
+    {
+        #region Data
+
+        readonly Expr _taskExpr;
+        public Expr TaskExpr => _taskExpr;
+
+        readonly Type _resultType;
+        readonly MethodInfo _awaitMethod;
+
+        #endregion
+
+        #region Ctors
+
+        public AwaitExpr(Expr taskExpr, Type resultType, MethodInfo awaitMethod)
+        {
+            _taskExpr = taskExpr;
+            _resultType = resultType;
+            _awaitMethod = awaitMethod;
+        }
+
+        #endregion
+
+        #region Type mangling
+
+        public bool HasClrType => true;
+
+        public Type ClrType => _resultType == typeof(void) ? typeof(object) : _resultType;
+
+        #endregion
+
+        #region Parsing
+
+        public sealed class Parser : IParser
+        {
+            public Expr Parse(ParserContext pcon, object frm)
+            {
+                ISeq form = (ISeq)frm;
+
+                if (!Compiler.RuntimeAsyncAvailable)
+                    throw new ParseException(
+                        "(await* ...) requires .NET 11+ with runtime async support");
+
+                if (!Compiler.AsyncMethodCache.IsSupported)
+                    throw new ParseException(
+                        "(await* ...) requires System.Runtime.CompilerServices.AsyncHelpers");
+
+                if (RT.count(form) != 2)
+                    throw new ParseException(
+                        "Wrong number of arguments to await*, expected: (await* expr)");
+
+                ObjMethod method = (ObjMethod)Compiler.MethodVar.deref();
+
+                if (method == null)
+                    throw new ParseException(
+                        "(await* ...) must appear inside a function body");
+
+                if (Compiler.InCatchFinallyVar.deref() is not null)
+                    throw new ParseException(
+                        "(await* ...) cannot appear inside a catch, finally, or fault handler");
+
+                if (!method.IsAsync)
+                    throw new ParseException(
+                        "(await* ...) can only be used inside a ^:async function or (async ...) block");
+
+                if (pcon.Rhc == RHC.Eval)
+                    return Compiler.Analyze(pcon,
+                        RT.list(RT.list(Compiler.FnOnceSym, PersistentVector.EMPTY, form)),
+                        "await__" + RT.nextID());
+
+                Expr taskExpr = Compiler.Analyze(
+                    pcon.SetRhc(RHC.Expression).SetAssign(false),
+                    RT.second(form));
+
+                Type taskType;
+                if (taskExpr.HasClrType)
+                {
+                    taskType = taskExpr.ClrType;
+
+                    bool isTaskType =
+                        taskType == typeof(Task)
+                        || taskType == typeof(ValueTask)
+                        || (taskType.IsGenericType &&
+                            (taskType.GetGenericTypeDefinition() == typeof(Task<>)
+                             || taskType.GetGenericTypeDefinition() == typeof(ValueTask<>)));
+
+                    if (!isTaskType)
+                    {
+                        if (taskType == typeof(object))
+                            taskType = typeof(Task<object>);
+                        else
+                            throw new ParseException(
+                                $"(await* ...) requires a Task, Task<T>, ValueTask, or ValueTask<T>, got: {taskType.FullName}");
+                    }
+                }
+                else
+                {
+                    taskType = typeof(Task<object>);
+                }
+
+                MethodInfo awaitMethod =
+                    Compiler.AsyncMethodCache.ResolveAwaitMethod(taskType, out Type resultType);
+
+                if (awaitMethod == null)
+                    throw new ParseException(
+                        "Failed to resolve AsyncHelpers.Await method for type: " + taskType.FullName);
+
+                method.HasAwait = true;
+
+                return new AwaitExpr(taskExpr, resultType, awaitMethod);
+            }
+        }
+
+        #endregion
+
+        #region eval
+
+        public object Eval()
+        {
+            throw new InvalidOperationException("Can't eval await*");
+        }
+
+        #endregion
+
+        #region Code generation
+
+        public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
+        {
+            _taskExpr.Emit(RHC.Expression, objx, ilg);
+
+            if (_taskExpr.HasClrType && _taskExpr.ClrType == typeof(object))
+            {
+                ilg.Emit(OpCodes.Castclass, typeof(Task<object>));
+            }
+
+            ilg.Emit(OpCodes.Call, _awaitMethod);
+
+            if (_resultType != typeof(void))
+            {
+                if (rhc == RHC.Statement)
+                    ilg.Emit(OpCodes.Pop);
+                else if (_resultType.IsValueType)
+                    ilg.Emit(OpCodes.Box, _resultType);
+            }
+            else
+            {
+                if (rhc != RHC.Statement)
+                    ilg.Emit(OpCodes.Ldnull);
+            }
+        }
+
+        public bool HasNormalExit() => true;
+
+        #endregion
+    }
+}
+
+#endif

Clojure/Clojure/CljCompiler/Ast/FnExpr.cs

@@ -23,6 +23,11 @@ public class FnExpr(object tag) : ObjExpr(tag)
 
         static readonly Keyword KW_ONCE = Keyword.intern(null, "once");
 
+#if NET11_0_OR_GREATER
+        static readonly Keyword KW_ASYNC = Keyword.intern(null, "async");
+        public bool IsAsync { get; private set; }
+#endif
+
         FnMethod _variadicMethod = null;
         public FnMethod VariadicMethod => _variadicMethod;
         bool IsVariadic => _variadicMethod is not null;
@@ -107,7 +112,18 @@ public static Expr Parse(ParserContext pcon, ISeq form, string name)
             if (((IMeta)form.first()).meta() is not null)
             {
                 fn.OnceOnly = RT.booleanCast(RT.get(RT.meta(form.first()), KW_ONCE));
+#if NET11_0_OR_GREATER
+                fn.IsAsync = RT.booleanCast(RT.get(RT.meta(form.first()), KW_ASYNC));
+#endif
+            }
+
+#if NET11_0_OR_GREATER
+            // Also check metadata on the form itself (propagated by defn -> fn macro)
+            if (!fn.IsAsync && RT.meta(form) is IPersistentMap formMeta)
+            {
+                fn.IsAsync = RT.booleanCast(RT.get(formMeta, KW_ASYNC));
             }
+#endif
 
             fn.ComputeNames(form, name);