#1571 Add annotations support for executable assemblies

Libraries/Libraries.sln

@@ -130,6 +130,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Amazon.Lambda.LexV2Events",
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CustomRuntimeAspNetCoreMinimalApiCustomSerializerTest", "test\Amazon.Lambda.RuntimeSupport.Tests\CustomRuntimeAspNetCoreMinimalApiCustomSerializerTest\CustomRuntimeAspNetCoreMinimalApiCustomSerializerTest.csproj", "{0BD83939-458C-4EF5-8663-7098AD1200F2}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestExecutableServerlessApp", "test\TestExecutableServerlessApp\TestExecutableServerlessApp.csproj", "{DD378063-C54A-44C7-9A6F-32A6A1AE94B3}"
+EndProject
 Global
 	GlobalSection(SharedMSBuildProjectFiles) = preSolution
 		test\EventsTests.Shared\EventsTests.Shared.projitems*{44e9d925-b61d-4234-97b7-61424c963ba6}*SharedItemsImports = 5
@@ -353,6 +355,10 @@ Global
 		{0BD83939-458C-4EF5-8663-7098AD1200F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0BD83939-458C-4EF5-8663-7098AD1200F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0BD83939-458C-4EF5-8663-7098AD1200F2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DD378063-C54A-44C7-9A6F-32A6A1AE94B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DD378063-C54A-44C7-9A6F-32A6A1AE94B3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DD378063-C54A-44C7-9A6F-32A6A1AE94B3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DD378063-C54A-44C7-9A6F-32A6A1AE94B3}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -415,6 +421,7 @@ Global
 		{BF85932E-2DFF-41CD-8090-A672468B8FBB} = {AAB54E74-20B1-42ED-BC3D-CE9F7BC7FD12}
 		{3C6AABF5-0372-41E0-874F-DF18ECCC7FB6} = {AAB54E74-20B1-42ED-BC3D-CE9F7BC7FD12}
 		{0BD83939-458C-4EF5-8663-7098AD1200F2} = {B5BD0336-7D08-492C-8489-42C987E29B39}
+		{DD378063-C54A-44C7-9A6F-32A6A1AE94B3} = {1DE4EE60-45BA-4EF7-BE00-B9EB861E4C69}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {503678A4-B8D1-4486-8915-405A3E9CF0EB}

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Amazon.Lambda.Annotations.SourceGenerator.csproj

@@ -56,6 +56,10 @@
       <Generator>TextTemplatingFilePreprocessor</Generator>
       <LastGenOutput>NoEventMethodBody.cs</LastGenOutput>
     </None>
+    <None Update="Templates\ExecutableAssembly.tt">
+      <Generator>TextTemplatingFilePreprocessor</Generator>
+      <LastGenOutput>ExecutableAssembly.cs</LastGenOutput>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -84,6 +88,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>NoEventMethodBody.tt</DependentUpon>
     </Compile>
+    <Compile Update="Templates\ExecutableAssembly.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>ExecutableAssembly.tt</DependentUpon>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Diagnostics/DiagnosticDescriptors.cs

@@ -45,6 +45,13 @@ public static class DiagnosticDescriptors
             DiagnosticSeverity.Error,
             isEnabledByDefault: true);
 
+        public static readonly DiagnosticDescriptor MainMethodExists = new DiagnosticDescriptor(id: "AWSLambda0104",
+            title: "static Main method exists",
+            messageFormat: "Failed to generate Main method for LambdaGenerateMainAttribute because project already contains Main method. Existing Main methods must be removed when using LambdaGenerateMainAttribute  attribute.",
+            category: "AWSLambdaCSharpGenerator",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
+
         public static readonly DiagnosticDescriptor HttpResultsOnNonApiFunction = new DiagnosticDescriptor(id: "AWSLambda0105",
             title: $"Invalid return type {nameof(IHttpResult)}",
             messageFormat: $"{nameof(IHttpResult)} is not a valid return type for LambdaFunctions without {nameof(HttpApiAttribute)} or {nameof(RestApiAttribute)} attributes",

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Generator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using Amazon.Lambda.Annotations.SourceGenerator.Diagnostics;
@@ -15,9 +16,12 @@
 
 namespace Amazon.Lambda.Annotations.SourceGenerator
 {
+    using System.Collections.Generic;
+
     [Generator]
     public class Generator : ISourceGenerator
     {
+        private const string DEFAULT_LAMBDA_SERIALIZER = "Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer";
         private readonly IFileManager _fileManager = new FileManager();
         private readonly IDirectoryManager _directoryManager = new DirectoryManager();
 
@@ -80,13 +84,29 @@ public void Execute(GeneratorExecutionContext context)
                     }
                 }
 
+                var isExecutable = false;
+
+                var assemblyAttributes = context.Compilation.Assembly.GetAttributes();
+
+                // Let's find the AssemblyTitleAttribute
+                var generateMainAttribute = assemblyAttributes
+                    .FirstOrDefault(attr => attr.AttributeClass.Name == nameof(LambdaGenerateMainAttribute));
+
+                if (generateMainAttribute != null)
+                {
+                    isExecutable = true;
+                }
+
                 var configureMethodModel = semanticModelProvider.GetConfigureMethodModel(receiver.StartupClasses.FirstOrDefault());
 
                 var annotationReport = new AnnotationReport();
 
                 var templateHandler = new CloudFormationTemplateHandler(_fileManager, _directoryManager);
 
                 bool foundFatalError = false;
+
+                var lambdaModels = new List<LambdaFunctionModel>();
+
                 foreach (var lambdaMethod in receiver.LambdaMethods)
                 {
                     var lambdaMethodModel = semanticModelProvider.GetMethodSemanticModel(lambdaMethod);
@@ -115,8 +135,10 @@ public void Execute(GeneratorExecutionContext context)
                             continue;
                         }
                     }
+
+                    var serializerString = GetSerializerAttribute(context, lambdaMethodModel);
 
-                    var model = LambdaFunctionModelBuilder.Build(lambdaMethodModel, configureMethodModel, context);
+                    var model = LambdaFunctionModelBuilder.Build(lambdaMethodModel, configureMethodModel, context, isExecutable, serializerString);
 
                     // If there are more than one event, report them as errors
                     if (model.LambdaMethod.Events.Count > 1)
@@ -175,9 +197,27 @@ public void Execute(GeneratorExecutionContext context)
                     // report every generated file to build output
                     diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.CodeGeneration, Location.None, $"{model.GeneratedMethod.ContainingType.Name}.g.cs", sourceText));
 
+                    lambdaModels.Add(model);
                     annotationReport.LambdaFunctions.Add(model);
                 }
 
+                if (isExecutable)
+                {
+                    var executableAssembly = GenerateExecutableAssemblySource(
+                        context,
+                        diagnosticReporter,
+                        receiver,
+                        lambdaModels);
+
+                    if (executableAssembly == null)
+                    {
+                        foundFatalError = true;
+                        return;
+                    }
+
+                    context.AddSource("Program.g.cs", SourceText.From(executableAssembly.TransformText().ToEnvironmentLineEndings(), Encoding.UTF8, SourceHashAlgorithm.Sha256));
+                }
+
                 // Run the CloudFormation sync if any LambdaMethods exists. Also run if no LambdaMethods exists but there is a
                 // CloudFormation template in case orphaned functions in the template need to be removed.
                 // Both checks are required because if there is no template but there are LambdaMethods the CF template the template will be created.
@@ -212,11 +252,89 @@ public void Execute(GeneratorExecutionContext context)
             }
         }
 
+        private static ExecutableAssembly GenerateExecutableAssemblySource(
+            GeneratorExecutionContext context,
+            DiagnosticReporter diagnosticReporter,
+            SyntaxReceiver receiver,
+            List<LambdaFunctionModel> lambdaModels)
+        {
+            // Check 'Amazon.Lambda.RuntimeSupport' is referenced
+            if (context.Compilation.ReferencedAssemblyNames.FirstOrDefault(x => x.Name == "Amazon.Lambda.RuntimeSupport") == null)
+            {
+                diagnosticReporter.Report(
+                    Diagnostic.Create(
+                        DiagnosticDescriptors.MissingDependencies,
+                        Location.None,
+                        "Amazon.Lambda.RuntimeSupport"));
+
+                return null;
+            }
+
+            foreach (var methodDeclaration in receiver.MethodDeclarations)
+            {
+                var model = context.Compilation.GetSemanticModel(methodDeclaration.SyntaxTree);
+                var symbol = model.GetDeclaredSymbol(methodDeclaration) as IMethodSymbol;
+
+                // Check to see if a static main method exists in the same namespace that has 0 or 1 parameters
+                if (symbol.Name != "Main" || !symbol.IsStatic || symbol.ContainingNamespace.Name != lambdaModels[0].LambdaMethod.ContainingAssembly || (symbol.Parameters.Length > 1)) 
+                    continue;
+
+                diagnosticReporter.Report(
+                    Diagnostic.Create(
+                        DiagnosticDescriptors.MainMethodExists,
+                        Location.None));
+
+                return null;
+            }
+
+            return new ExecutableAssembly(
+                lambdaModels,
+                lambdaModels[0].LambdaMethod.ContainingNamespace);
+        }
+
         private bool HasSerializerAttribute(GeneratorExecutionContext context, IMethodSymbol methodModel)
         {
             return methodModel.ContainingAssembly.HasAttribute(context, TypeFullNames.LambdaSerializerAttribute);
         }
 
+        private string GetSerializerAttribute(GeneratorExecutionContext context, IMethodSymbol methodModel)
+        {
+            var serializerString = DEFAULT_LAMBDA_SERIALIZER;
+
+            ISymbol symbol = null;
+
+            // First check if method has the Lambda Serializer.
+            if (methodModel.HasAttribute(
+                    context,
+                    TypeFullNames.LambdaSerializerAttribute))
+            {
+                symbol = methodModel;
+            }
+            // Then check assembly
+            else if (methodModel.ContainingAssembly.HasAttribute(
+                    context,
+                    TypeFullNames.LambdaSerializerAttribute))
+            {
+                symbol = methodModel.ContainingAssembly;
+            }
+            // Else return the default serializer.
+            else
+            {
+                return serializerString;
+            }
+
+            var attribute = symbol.GetAttributes().FirstOrDefault(attr => attr.AttributeClass.Name == TypeFullNames.LambdaSerializerAttributeWithoutNamespace);
+
+            var serializerValue = attribute.ConstructorArguments.FirstOrDefault(kvp => kvp.Type.Name == nameof(Type)).Value;
+
+            if (serializerValue != null)
+            {
+                serializerString = serializerValue.ToString();
+            }
+
+            return serializerString;
+        }
+
         public void Initialize(GeneratorInitializationContext context)
         {
             // Register a syntax receiver that will be created for each generation pass

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/GeneratedMethodModelBuilder.cs

@@ -37,7 +37,9 @@ private static IList<string> BuildUsings(LambdaMethodModel lambdaMethodModel,
                 "System",
                 "System.Linq",
                 "System.Collections.Generic",
-                "System.Text"
+                "System.Text",
+                "System.Threading.Tasks",
+                "System.IO"
             };
 
             if (configureMethodSymbol != null)

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/ILambdaFunctionSerializable.cs

@@ -14,6 +14,13 @@ public interface ILambdaFunctionSerializable
         /// </para>
         /// </summary>
         string Handler { get; }
+
+        /// <summary>
+        /// <para>
+        /// The original method name.
+        /// </para>
+        /// </summary>
+        string MethodName { get; }
 
         /// <summary>
         /// The name of the CloudFormation resource that is associated with the Lambda function.
@@ -34,6 +41,11 @@ public interface ILambdaFunctionSerializable
         /// The IAM Role assumed by the Lambda function during its execution.
         /// </summary>
         string Role { get; }
+
+        /// <summary>
+        /// Gets or sets if the output is an executable.
+        /// </summary>
+        bool IsExecutable { get; }
 
         /// <summary>
         /// Resource based policies that grants permissions to access other AWS resources.

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/LambdaFunctionModel.cs

@@ -26,13 +26,24 @@ public class LambdaFunctionModel : ILambdaFunctionSerializable
         /// </summary>
         public TypeModel StartupType { get; set; }
 
+        /// <summary>
+        /// The original method name.
+        /// </summary>
+        public string MethodName => LambdaMethod.Name;
+
         /// <summary>
         /// Gets or sets fully qualified name of the serializer used for serialization or deserialization.
         /// </summary>
-        public string Serializer { get; set; }
+        public string Serializer { get; set; } =
+            "Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer";
+
+        /// <summary>
+        /// Gets or sets if the output is an executable.
+        /// </summary>
+        public bool IsExecutable { get; set; }
 
         /// <inheritdoc />
-        public string Handler => $"{LambdaMethod.ContainingAssembly}::{GeneratedMethod.ContainingType.FullName}::{LambdaMethod.Name}";
+        public string Handler => IsExecutable ? LambdaMethod.ContainingAssembly : $"{LambdaMethod.ContainingAssembly}::{GeneratedMethod.ContainingType.FullName}::{LambdaMethod.Name}";
 
         /// <inheritdoc />
         public string ResourceName => LambdaMethod.LambdaFunctionAttribute.Data.ResourceName ??

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/Models/LambdaFunctionModelBuilder.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using System.Reflection;
 using Microsoft.CodeAnalysis;
 
 namespace Amazon.Lambda.Annotations.SourceGenerator.Models
@@ -8,19 +9,20 @@ namespace Amazon.Lambda.Annotations.SourceGenerator.Models
     /// </summary>
     public static class LambdaFunctionModelBuilder
     {
-        public static LambdaFunctionModel Build(IMethodSymbol lambdaMethodSymbol, IMethodSymbol configureMethodSymbol, GeneratorExecutionContext context)
+        public static LambdaFunctionModel Build(IMethodSymbol lambdaMethodSymbol, IMethodSymbol configureMethodSymbol, GeneratorExecutionContext context, bool isExecutable, string serializer)
         {
             var lambdaMethod = LambdaMethodModelBuilder.Build(lambdaMethodSymbol, configureMethodSymbol, context);
             var generatedMethod = GeneratedMethodModelBuilder.Build(lambdaMethodSymbol, configureMethodSymbol, lambdaMethod, context);
             var model = new LambdaFunctionModel()
             {
                 GeneratedMethod = generatedMethod,
                 LambdaMethod = lambdaMethod,
-                Serializer = "System.Text.Json.JsonSerializer", // TODO: replace serializer with assembly serializer
+                Serializer = serializer,
                 StartupType = configureMethodSymbol != null ? TypeModelBuilder.Build(configureMethodSymbol.ContainingType, context) : null,
                 SourceGeneratorVersion = context.Compilation
                     .ReferencedAssemblyNames.FirstOrDefault(x => string.Equals(x.Name, "Amazon.Lambda.Annotations"))
-                    ?.Version.ToString()
+                    ?.Version.ToString(),
+                IsExecutable = isExecutable 
             };
 
             return model;

Libraries/src/Amazon.Lambda.Annotations.SourceGenerator/SyntaxReceiver.cs

@@ -7,11 +7,15 @@
 
 namespace Amazon.Lambda.Annotations.SourceGenerator
 {
+    using Microsoft.CodeAnalysis.CSharp;
+
     internal class SyntaxReceiver : ISyntaxContextReceiver
     {
         public List<MethodDeclarationSyntax> LambdaMethods { get; } = new List<MethodDeclarationSyntax>();
 
         public List<ClassDeclarationSyntax> StartupClasses { get; private set; } = new List<ClassDeclarationSyntax>();
+
+        public List<MethodDeclarationSyntax> MethodDeclarations { get; } = new List<MethodDeclarationSyntax>();
 
         /// <summary>
         /// Path to the directory containing the .csproj file
@@ -50,7 +54,9 @@ public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
             if (context.Node is MethodDeclarationSyntax methodDeclarationSyntax && methodDeclarationSyntax.AttributeLists.Count > 0)
             {
                 // Get the symbol being declared by the method, and keep it if its annotated
-                var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclarationSyntax);
+                var methodSymbol = ModelExtensions.GetDeclaredSymbol(
+                    context.SemanticModel,
+                    methodDeclarationSyntax);
                 if (methodSymbol.GetAttributes().Any(attr => attr.AttributeClass.Name == nameof(LambdaFunctionAttribute)))
                 {
                     LambdaMethods.Add(methodDeclarationSyntax);
@@ -62,11 +68,23 @@ public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
             {
                 // Get the symbol being declared by the class, and keep it if its annotated
                 var methodSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclarationSyntax);
+
                 if (methodSymbol.GetAttributes().Any(attr => attr.AttributeClass.Name == nameof(LambdaStartupAttribute)))
                 {
                     StartupClasses.Add(classDeclarationSyntax);
                 }
             }
+
+            if (context.Node is MethodDeclarationSyntax methodDeclaration)
+            {
+                var model = context.SemanticModel.GetDeclaredSymbol(
+                    methodDeclaration);
+
+                if (model.Name == "Main" && model.IsStatic)
+                {
+                    MethodDeclarations.Add(methodDeclaration);   
+                }
+            }
         }
     }
 }