Revert "Add .NET 11 runtime async/await interop"

This reverts commit fc762b1.

This commit contained some LLM-generated code.
A recent amendment to the Clojure Contributor Agreement forbids this.

Author: dmiller

Clojure/Clojure.Source/Clojure.Source.csproj

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

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) (if (:async m) {:rettag (:tag m) :async true} {:rettag (:tag m)}))))))
+								(with-meta (cons `fn fdecl) {:rettag (:tag m)})))))
 
 (. (var defn) (setMacro))       
 

Clojure/Clojure/CljCompiler/Ast/AwaitExpr.cs

@@ -23,11 +23,6 @@ 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;
@@ -112,18 +107,7 @@ 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);
 

Clojure/Clojure/CljCompiler/Ast/FnExpr.cs

@@ -114,10 +114,6 @@ internal static FnMethod Parse(FnExpr fn, ISeq form, object retTag)
                     SpanMap = (IPersistentMap)Compiler.SourceSpanVar.deref()
                 };
 
-#if NET11_0_OR_GREATER
-                method.IsAsync = fn.IsAsync;
-#endif
-
                 Var.pushThreadBindings(RT.mapUniqueKeys(
                     Compiler.MethodVar, method,
                     Compiler.LocalEnvVar, Compiler.LocalEnvVar.deref(),
@@ -152,10 +148,6 @@ internal static FnMethod Parse(FnExpr fn, ISeq form, object retTag)
                 //if (method._prim != null)
                 //    method._prim = method._prim.Replace('.', '/');
 
-#if NET11_0_OR_GREATER
-                if (method.IsAsync && method._prim != null)
-                    throw new ParseException("^:async cannot be combined with primitive type hints");
-#endif
 
                 // register 'this' as local 0  
                 Compiler.RegisterLocalThis(Symbol.intern(fn.ThisName ?? "fn__" + RT.nextID()), null, null);
@@ -341,24 +333,10 @@ private void DoEmitStatic(ObjExpr fn, TypeBuilder tb)
 
             string methodName = "invokeStatic";
 
-#if NET11_0_OR_GREATER
-            Type returnType = (IsAsync || HasAwait)
-                ? typeof(System.Threading.Tasks.Task<object>)
-                : ReturnType;
-#else
             Type returnType = ReturnType;
-#endif
 
             MethodBuilder baseMB = tb.DefineMethod(methodName, attribs, returnType, _argTypes);
 
-#if NET11_0_OR_GREATER
-            if (IsAsync || HasAwait)
-            {
-                baseMB.SetImplementationFlags(
-                    baseMB.GetMethodImplementationFlags() | (MethodImplAttributes)0x2000);
-            }
-#endif
-
             CljILGen baseIlg = new(baseMB.GetILGenerator());
 
             try
@@ -483,14 +461,6 @@ private void DoEmitPrim(ObjExpr fn, TypeBuilder tb)
 
         private void DoEmit(ObjExpr fn, TypeBuilder tb)
         {
-#if NET11_0_OR_GREATER
-            if (IsAsync || HasAwait)
-            {
-                DoEmitAsync(fn, tb);
-                return;
-            }
-#endif
-
             MethodAttributes attribs = MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual;
             MethodBuilder mb = tb.DefineMethod(MethodName, attribs, ReturnType, ArgTypes);
             SetCustomAttributes(mb);
@@ -518,61 +488,6 @@ private void DoEmit(ObjExpr fn, TypeBuilder tb)
                 tb.DefineMethodOverride(mb, ExplicitMethodInfo);
         }
 
-#if NET11_0_OR_GREATER
-        private void DoEmitAsync(ObjExpr fn, TypeBuilder tb)
-        {
-            // Generate the async implementation method: invokeAsync() -> Task<object>
-            // This method gets the 0x2000 async flag and contains the real body with await* calls.
-            Type asyncReturnType = typeof(System.Threading.Tasks.Task<object>);
-            MethodBuilder asyncMB = tb.DefineMethod(
-                MethodName + "Async",
-                MethodAttributes.Private,
-                asyncReturnType,
-                ArgTypes);
-
-            asyncMB.SetImplementationFlags(
-                asyncMB.GetMethodImplementationFlags() | (MethodImplAttributes)0x2000);
-
-            CljILGen asyncIlg = new(asyncMB.GetILGenerator());
-
-            try
-            {
-                Label loopLabel = asyncIlg.DefineLabel();
-                Var.pushThreadBindings(RT.map(Compiler.LoopLabelVar, loopLabel, Compiler.MethodVar, this));
-
-                GenContext.EmitDebugInfo(asyncIlg, SpanMap);
-
-                asyncIlg.MarkLabel(loopLabel);
-                Body.Emit(RHC.Return, fn, asyncIlg);
-                if (Body.HasNormalExit())
-                    asyncIlg.Emit(OpCodes.Ret);
-            }
-            finally
-            {
-                Var.popThreadBindings();
-            }
-
-            // Generate the IFn.invoke() override: invoke() -> object
-            // This wrapper calls invokeAsync() and returns the Task<object> as object.
-            MethodAttributes attribs = MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual;
-            MethodBuilder invokeMB = tb.DefineMethod(MethodName, attribs, typeof(object), ArgTypes);
-            SetCustomAttributes(invokeMB);
-
-            CljILGen invokeIlg = new(invokeMB.GetILGenerator());
-
-            // Load 'this' and all arguments, then call invokeAsync
-            invokeIlg.Emit(OpCodes.Ldarg_0);
-            for (int i = 0; i < ArgTypes.Length; i++)
-                invokeIlg.EmitLoadArg(i + 1);
-            invokeIlg.Emit(OpCodes.Call, asyncMB);
-            // Task<object> is already an object reference, no boxing needed
-            invokeIlg.Emit(OpCodes.Ret);
-
-            if (IsExplicit)
-                tb.DefineMethodOverride(invokeMB, ExplicitMethodInfo);
-        }
-#endif
-
         #endregion
     }
 }

Clojure/Clojure/CljCompiler/Ast/FnMethod.cs

@@ -42,11 +42,6 @@ public abstract class ObjMethod(ObjExpr fn, ObjMethod parent)
         public IPersistentMap SpanMap { get; protected set; }
         public bool UsesThis { get; set; }
 
-#if NET11_0_OR_GREATER
-        public bool HasAwait { get; set; }
-        public bool IsAsync { get; set; }
-#endif
-
         #endregion
 
         #region Data accessors
@@ -86,14 +81,6 @@ public virtual void Emit(ObjExpr fn, TypeBuilder tb)
         {
             MethodBuilder mb = tb.DefineMethod(MethodName, MethodAttributes.Public, ReturnType, ArgTypes);
 
-#if NET11_0_OR_GREATER
-            if (IsAsync || HasAwait)
-            {
-                mb.SetImplementationFlags(
-                    mb.GetMethodImplementationFlags() | (MethodImplAttributes)0x2000);
-            }
-#endif
-
             CljILGen ilg = new(mb.GetILGenerator());
             Label loopLabel = ilg.DefineLabel();