TemplateLauncher/RoslynCompiler: Support for Task and Task<T> interpolated objects

RoslynCompiler: fixed ILogger auto-add-namespace

Author: Drizin

README.md

@@ -609,20 +609,24 @@ It's possible to interpolate special symbols like `IF/ELSE/ENDIF` or `IIF` to ad
 **IF-ENDIF statements**
 
 ```cs
-using CodegenCS;                 // besides this...
-using static CodegenCS.Symbols;  // you also need this
-
-void RenderMyApiClient(bool injectHttpClient)
+class MyTemplate
 {
-    w.WriteLine($$"""
-        public class MyApiClient
-        {
-            public MyApiClient({{ IF(injectHttpClient) }}HttpClient httpClient{{ ENDIF }})
-            { {{ IF(injectHttpClient) }}
-                _httpClient = httpClient; {{ ENDIF }}
-            }
-        }
-        """);
+  void Main(ICodegenOutputFile writer)
+  {
+      RenderMyApiClient(writer, true);
+  }
+  void RenderMyApiClient(ICodegenOutputFile w, bool injectHttpClient)
+  {
+      w.WriteLine($$"""
+          public class MyApiClient
+          {
+              public MyApiClient({{ IF(injectHttpClient) }}HttpClient httpClient{{ ENDIF }})
+              { {{ IF(injectHttpClient) }}
+                  _httpClient = httpClient; {{ ENDIF }}
+              }
+          }
+          """);
+  }
 }
 ```
 
@@ -641,48 +645,83 @@ public class MyApiClient
 **IF-ELSE-ENDIF**
 
 ```cs
-w.WriteLine($$"""
-    public class MyApiClient
-    {
-        public void InvokeApi()
+class MyTemplate
+{
+  void Main(ICodegenOutputFile writer)
+  {
+      var settings = new MySettings() { SwallowExceptions = true };
+      RenderMyApiClient(writer, settings);
+  }
+  class MySettings
+  {
+    public bool SwallowExceptions;
+  }
+  void RenderMyApiClient(ICodegenOutputFile w, MySettings settings)
+  {
+    w.WriteLine($$"""
+        public class MyApiClient
         {
-            try
+            public void InvokeApi()
             {
-                restApi.Invoke();
-            }
-            catch (Exception ex)
-            { {{IF(settings.swallowExceptions) }}
-                Log.Error(ex); {{ ELSE }}
-                throw; {{ ENDIF }}
+                try
+                {
+                    restApi.Invoke();
+                }
+                catch (Exception ex)
+                { {{IF(settings.SwallowExceptions) }}
+                    Log.Error(ex); {{ ELSE }}
+                    throw; {{ ENDIF }}
+                }
             }
         }
-    }
-    """);
+        """);
+  }
+}
 ```
 
 **Nested IF statements**
 ```cs
-w.WriteLine($$"""
-    {{ IF(generateConstructor) }}public class MyApiClient
-    {
-        public MyApiClient({{ IF(injectHttpClient) }}HttpClient httpClient{{ ENDIF }})
-        { {{IF(injectHttpClient) }} 
-            _httpClient = httpClient; {{ ENDIF }}
-        }}
-    } {{ ENDIF }}
-    """);
+class MyTemplate
+{
+  void Main(ICodegenOutputFile writer)
+  {
+      RenderMyApiClient(writer, true, true);
+  }
+  void RenderMyApiClient(ICodegenOutputFile w, bool generateConstructor, bool injectHttpClient)
+  {
+    w.WriteLine($$"""
+        {{ IF(generateConstructor) }}public class MyApiClient
+        {
+            public MyApiClient({{ IF(injectHttpClient) }}HttpClient httpClient{{ ENDIF }})
+            { {{IF(injectHttpClient) }} 
+                _httpClient = httpClient; {{ ENDIF }}
+            }}
+        } {{ ENDIF }}
+        """);
+  }
+}
 ```
 
 **IIF (Immediate IF):**
 
 ```cs
-w.WriteLine($$"""
-    public class User
-    {
-        {{ IIF(isVisibilityPublic, $"public ") }}string FirstName { get; set; }
-        {{ IIF(isVisibilityPublic, $"public ", $"protected ") }}string FirstName { get; set; }
-    }
-    """);
+class MyTemplate
+{
+  void Main(ICodegenOutputFile writer)
+  {
+      RenderMyApiClient(writer, true);
+  }
+  void RenderMyApiClient(ICodegenOutputFile w, bool isVisibilityPublic)
+  {
+    w.WriteLine($$"""
+        public class User
+        {
+            {{ IIF(isVisibilityPublic, $"public ") }}string FirstName { get; set; }
+            {{ IIF(isVisibilityPublic, $"public ", $"protected ") }}string FirstName { get; set; }
+        }
+        """);
+  }
+}
 ```
 
 
@@ -998,7 +1037,21 @@ Generated 1 file: 'C:\Users\drizin\MyTemplate.generated.cs'
 Successfully executed template 'MyTemplate.cs'.
 ```
 
+## Async Support
 
+Templates can also be `async Task`, `async Task<FormattableString>` or `async Task<int>`:
+
+```cs
+class MyTemplate
+{
+    //Task<FormattableString> Main() => Task.FromResult((FormattableString)$"My first template");
+    async Task<FormattableString> Main(ILogger logger) 
+    {
+        await logger.WriteLineAsync($"Generating MyTemplate...");
+        return $"My first template";
+    }
+}
+```
 
 # Learn More
 

src/Tools/TemplateBuilder/RoslynCompiler.cs

@@ -45,6 +45,7 @@ public RoslynCompiler(TemplateBuilder builder, ILogger logger, List<string> extr
             AddAssembly("netstandard.dll");
 
             AddAssembly("System.Runtime.dll");
+            AddAssembly("System.Threading.dll");
             #endregion
 
             #region System.Linq
@@ -136,6 +137,7 @@ public RoslynCompiler(TemplateBuilder builder, ILogger logger, List<string> extr
             if (extraReferences != null)
                 extraReferences.ForEach(rfc => AddAssembly(MetadataReference.CreateFromFile(rfc)));
 
+            _namespaces.Clear(); // TODO: review why these namespaces don't make any difference here - only AddMissingUsing (applied directly to tree) matters
 
             _compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
                     .WithOverflowChecks(true)
@@ -320,13 +322,19 @@ void AddMissingUsings(List<SyntaxTree> trees)
                     )
                     AddMissingUsing(ref rootNode, "CodegenCS.Runtime");
                 if (Regex.IsMatch(templateSource, @"(?<!\.)\bILogger\b") && Regex.IsMatch(templateSource, @"\bWriteLine(\w*)Async\b"))
-                    AddMissingUsing(ref rootNode, "CodegenCS.Utils");
+                    AddMissingUsing(ref rootNode, "CodegenCS.Runtime");
                 if (Regex.IsMatch(templateSource, @"(?<!\.)\bIInputModel\b") 
                     || Regex.IsMatch(templateSource, @"(?<!\.)\bIJsonInputModel\b") 
                     || Regex.IsMatch(templateSource, @"(?<!\.)\bIValidatableJsonInputModel\b")
                     || Regex.IsMatch(templateSource, @"(?<!\.)\bIModelFactory\b")
                     )
                     AddMissingUsing(ref rootNode, "CodegenCS.Models");
+                
+                if (Regex.IsMatch(templateSource, @"(?<!\.)\bTask\b")) 
+                {
+                    AddMissingUsing(ref rootNode, "System.Threading");
+                    AddMissingUsing(ref rootNode, "System.Threading.Tasks");
+                }
 
                 if (Regex.IsMatch(templateSource, @"(?<!\.)\bConfigureCommand\b") || Regex.IsMatch(templateSource, @"(?<!\.)\bParseResult\b"))
                     AddMissingUsing(ref rootNode, "System.CommandLine"); // System.CommandLine.Command, System.CommandLine.ParseResult

src/Tools/TemplateLauncher/TemplateLauncher.cs

@@ -650,25 +650,62 @@ public async Task<int> ExecuteAsync(TemplateLauncherArgs _args, ParseResult pars
                     object[] entryPointMethodArgs = new object[argTypes.Length];
                     for (int i = 0; i < argTypes.Length; i++)
                         entryPointMethodArgs[i] = _ctx.DependencyContainer.Resolve(argTypes[i]);
-                    if (_entryPointMethod.ReturnType == typeof(FormattableString))
+
+                    Type returnType = _entryPointMethod.ReturnType;
+                    object result = _entryPointMethod.Invoke(instance, entryPointMethodArgs);
+                    Type[] genericTypes;
+                    
+                    // Tasks should be executed/awaited
+                    if (IsAssignableToType(returnType, typeof(Task)))
+                    {
+                        var task = (Task)result;
+                        await task;
+                        
+                        // and result should be unwrapped
+                        if (IsAssignableToGenericType(returnType, typeof(Task<>)) && (genericTypes = returnType.GetGenericArguments()) != null)
+                        {
+                            if (genericTypes[0]==typeof(FormattableString))
+                            {
+                                returnType = typeof(FormattableString);
+                                result = ((Task<FormattableString>)result).Result;
+                            }
+                            else if (genericTypes[0]==typeof(int))
+                            {
+                                returnType = typeof(int);
+                                result = ((Task<int>)result).Result;
+                            }
+                        }
+                        else
+                        {
+                            returnType = typeof(void);
+                        }
+                    }
+
+                    if (returnType == typeof(FormattableString))
                     {
-                        var fs = (FormattableString)_entryPointMethod.Invoke(instance, entryPointMethodArgs);
+                        var fs = (FormattableString)result;
                         _ctx.DefaultOutputFile.Write(fs);
                     }
-                    else if (_entryPointMethod.ReturnType == typeof(FormattableString))
+                    else if (returnType == typeof(string))
                     {
-                        var s = (string)_entryPointMethod.Invoke(instance, entryPointMethodArgs);
+                        var s = (string)result;
                         _ctx.DefaultOutputFile.Write(s);
                     }
-                    else
+                    else if (returnType == typeof(int))
                     {
-                        object result = _entryPointMethod.Invoke(instance, entryPointMethodArgs);
-                        if (_entryPointMethod.ReturnType == typeof(int) && ((int)result) != 0)
-                        {
+                    	if (((int)result) != 0)
+                    	{
                             await _logger.WriteLineErrorAsync(ConsoleColor.Red, $"\nExiting with non-zero result code from template ({(int)result}). Nothing saved.");
                             return (int)result;
                         }
                     }
+                    else if (returnType == typeof(void)) 
+                    {
+                        // a void method should write directly to output streams
+                    }
+                    else
+                        throw new NotImplementedException($"Unsupported Template Return Type {returnType.Name}");
+
                 }
                 #endregion
             }