public (SourceText?source, IReadOnlyList <Diagnostic> diagnostics) CreateImplementation(INamedTypeSymbol namedTypeSymbol)
{
// If we've got any symbols errors from just instantiating it, we're going to have a bad time. Give up now.
if (this.symbolsDiagnosticReporter.HasErrors)
{
return(null, Array.Empty <Diagnostic>());
}
var diagnosticReporter = new DiagnosticReporter();
var analyzer = new RoslynTypeAnalyzer(this.compilation, namedTypeSymbol, this.wellKnownSymbols, this.attributeInstantiator, diagnosticReporter);
var typeModel = analyzer.Analyze();
var generator = new ImplementationGenerator(typeModel, this.emitter, diagnosticReporter);
var emittedType = generator.Generate();
// If there are symbols diagnostic errors, we have to fail this type.
// However, we'll then clear the symbols diagnostics, so we can move onto the next type
// (which might succeed).
// We'll report the symbols diagnostics in one go at the end. We might well end up with duplicates
// (WellKnownSymbols will keep reporting the same diagnostics), so use a HashSet.
this.symbolsDiagnostics.UnionWith(this.symbolsDiagnosticReporter.Diagnostics);
bool hasSymbolsErrors = this.symbolsDiagnosticReporter.HasErrors;
this.symbolsDiagnosticReporter.Clear();
return(hasSymbolsErrors || diagnosticReporter.HasErrors
? null
: emittedType.SourceText, diagnosticReporter.Diagnostics);
}
public WellKnownSymbols(Compilation compilation, DiagnosticReporter diagnosticReporter)
{
this.compilation = compilation;
this.diagnosticReporter = diagnosticReporter;
var restEaseAssembly = GetReferencedAssemblies(compilation.Assembly)
.FirstOrDefault(x => x.Name == "RestEase");
if (restEaseAssembly == null)
{
this.diagnosticReporter.ReportCouldNotFindRestEaseAssembly();
}
else
{
var versionRangeAttribute = typeof(WellKnownSymbols).Assembly.GetCustomAttribute <AllowedRestEaseVersionRangeAttribute>();
var(minInclusive, maxExclusive) = (new Version(versionRangeAttribute.MinVersionInclusive), new Version(versionRangeAttribute.MaxVersionExclusive));
var restEaseVersion = restEaseAssembly.Identity.Version;
if (restEaseVersion < minInclusive)
{
this.diagnosticReporter.ReportRestEaseVersionTooOld(restEaseVersion, minInclusive, maxExclusive);
}
else if (restEaseVersion >= maxExclusive)
{
this.diagnosticReporter.ReportRestEaseVersionTooNew(restEaseVersion, minInclusive, maxExclusive);
}
else
{
this.restEaseAssembly = restEaseAssembly;
}
}
}
public ProjectFileLoaderRegistry(Workspace workspace, DiagnosticReporter diagnosticReporter)
{
_workspace = workspace;
_diagnosticReporter = diagnosticReporter;
_extensionToLanguageMap = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_dataGuard = new NonReentrantLock();
}
public Type BuildEmitImplementation(Type interfaceType)
{
var analyzer = new ReflectionTypeAnalyzer(interfaceType);
var typeModel = analyzer.Analyze();
var diagnosticReporter = new DiagnosticReporter(typeModel);
var generator = new ImplementationGenerator(typeModel, this.emitter, diagnosticReporter);
return(generator.Generate().Type);
}
internal DiagnosticSuppressorBenchmark()
{
analyzer = new DiagnosticReporter();
suppressor = new TDiagnosticSuppressor();
analyzers = ImmutableArray.Create <DiagnosticAnalyzer>(analyzer, suppressor);
source = null !;
compilation = null !;
syntaxTree = null !;
}
public RoslynImplementationFactory(Compilation compilation)
{
this.compilation = compilation;
this.symbolsDiagnosticReporter = new DiagnosticReporter();
this.wellKnownSymbols = new WellKnownSymbols(compilation, this.symbolsDiagnosticReporter);
this.attributeInstantiator = new AttributeInstantiator(this.wellKnownSymbols);
this.emitter = new Emitter(this.wellKnownSymbols);
// Catch any symbols errors from just instantiating WellKnownSymbols
this.symbolsDiagnostics.UnionWith(this.symbolsDiagnosticReporter.Diagnostics);
}
public WellKnownSymbols(Compilation compilation, DiagnosticReporter diagnosticReporter)
{
this.compilation = compilation;
this.diagnosticReporter = diagnosticReporter;
this.restEaseAssembly = GetReferencedAssemblies(compilation.Assembly)
.FirstOrDefault(x => x.Name == "RestEase");
if (this.restEaseAssembly == null)
{
this.diagnosticReporter.ReportCouldNotFindRestEaseAssembly();
}
}
public ActionResult Diagnostics()
{
if (Request.IsLocal)
{
var verifier = new DiagnosticReporter();
return(Content(verifier.GetVerificationReport(), "text/plain", Encoding.UTF8));
}
else
{
return(Content("You can only run the diagnostics locally to the server"));
}
}
public ActionResult Diagnostics()
{
if (Url.IsLocalUrl(Request.GetEncodedUrl()))
{
var verifier = new DiagnosticReporter(HttpContext.RequestServices.GetService <IHostingEnvironment>());
return(Content(verifier.GetVerificationReport(HttpContext.RequestServices), "text/plain", Encoding.UTF8));
}
else
{
return(Content("You can only run the diagnostics locally to the server"));
}
}
public RoslynTypeAnalyzer(
Compilation compilation,
INamedTypeSymbol namedTypeSymbol,
WellKnownSymbols wellKnownSymbols,
AttributeInstantiator attributeInstantiator,
DiagnosticReporter diagnosticReporter)
{
this.compilation = compilation;
this.namedTypeSymbol = namedTypeSymbol;
this.wellKnownSymbols = wellKnownSymbols;
this.attributeInstantiator = attributeInstantiator;
this.diagnosticReporter = diagnosticReporter;
}
internal CandidateInterfacesProcessor(
Compilation compilation,
List <InterfaceDeclarationSyntax> interfaceDeclarationSyntaxList,
INamedTypeSymbol interfaceAttributeSymbol,
INamedTypeSymbol methodAttributeSymbol,
DiagnosticReporter diagnosticReporter)
{
_compilation = compilation;
_interfaceDeclarationSyntaxList = interfaceDeclarationSyntaxList;
_interfaceAttributeSymbol = interfaceAttributeSymbol;
_methodAttributeSymbol = methodAttributeSymbol;
_diagnosticReporter = diagnosticReporter;
}
private Attribute?ParseRequestAttributeSubclass(
AttributeData attributeData,
ISymbol declaringSymbol,
DiagnosticReporter diagnosticReporter,
Func <RequestAttributeBase> parameterlessCtor,
Func <string, RequestAttributeBase> pathCtor)
{
RequestAttributeBase?attribute = null;
if (attributeData.ConstructorArguments.Length == 0)
{
attribute = parameterlessCtor();
}
else if (attributeData.ConstructorArguments.Length == 1 &&
attributeData.ConstructorArguments[0].Type?.SpecialType == SpecialType.System_String)
{
attribute = pathCtor((string)attributeData.ConstructorArguments[0].Value !);
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
if (namedArgument.Key == nameof(RequestAttributeBase.Path) &&
namedArgument.Value.Type?.SpecialType == SpecialType.System_String)
{
attribute.Path = (string?)namedArgument.Value.Value;
}
else
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
public void Execute(GeneratorExecutionContext context)
{
if (!(context.SyntaxReceiver is SyntaxReceiver syntaxReceiver))
{
return;
}
var interfaceAttributeSymbol =
context.Compilation.GetTypeByMetadataName(typeof(BlazorJSInteropSourceAttribute).FullName);
var methodAttributeSymbol =
context.Compilation.GetTypeByMetadataName(typeof(BlazorJSInteropMethodAttribute).FullName);
var diagnosticReporter = new DiagnosticReporter(context);
var candidateInterfacesProcessor = new CandidateInterfacesProcessor(
context.Compilation,
syntaxReceiver.CandidateInterfaces,
interfaceAttributeSymbol,
methodAttributeSymbol,
diagnosticReporter);
var validInterfaceInfoList = candidateInterfacesProcessor.GetValidInterfaceInfoList();
if (diagnosticReporter.HasReported)
{
return;
}
var sourceCodeBuilder = new SourceCodeBuilder(methodAttributeSymbol);
foreach (var validInterfaceInfo in validInterfaceInfoList)
{
var sourceCode = sourceCodeBuilder.BuildSourceCode(validInterfaceInfo);
context.AddSource($"{validInterfaceInfo.InterfaceNamespace}.{validInterfaceInfo.InterfaceName}",
SourceText.From(sourceCode, Encoding.UTF8));
}
}
private Attribute?ParseAllowAnyStatusCodeAttribute(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
AllowAnyStatusCodeAttribute?attribute = null;
if (attributeData.ConstructorArguments.Length == 0)
{
attribute = new AllowAnyStatusCodeAttribute();
}
else if (attributeData.ConstructorArguments.Length == 1 &&
attributeData.ConstructorArguments[0].Type?.SpecialType == SpecialType.System_Boolean)
{
attribute = new AllowAnyStatusCodeAttribute((bool)attributeData.ConstructorArguments[0].Value !);
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
if (namedArgument.Key == nameof(AllowAnyStatusCodeAttribute.AllowAnyStatusCode) &&
namedArgument.Value.Type?.SpecialType == SpecialType.System_Boolean)
{
attribute.AllowAnyStatusCode = (bool)namedArgument.Value.Value !;
}
else
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
public Attribute?Instantiate(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
var attributeClass = attributeData.AttributeClass;
if (attributeClass == null)
{
return(null);
}
if (this.lookup.TryGetValue(attributeClass, out var parser))
{
return(parser(attributeData, declaringSymbol, diagnosticReporter));
}
return(null);
}
public IEnumerable <(Attribute attribute, AttributeData attributeData, ISymbol declaringSymbol)> Instantiate(ISymbol symbol, DiagnosticReporter diagnosticReporter)
{
return(symbol.GetAttributes()
.Select(x => (this.Instantiate(x, symbol, diagnosticReporter), x, symbol))
.Where(x => x.Item1 != null) !);
}
private Attribute?ParseQueryMapAttribute(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
QueryMapAttribute?attribute = null;
if (attributeData.ConstructorArguments.Length == 0)
{
attribute = new QueryMapAttribute();
}
else if (attributeData.ConstructorArguments.Length == 1 &&
SymbolEqualityComparer.Default.Equals(attributeData.ConstructorArguments[0].Type, this.wellKnownSymbols.QuerySerializationMethod))
{
attribute = new QueryMapAttribute((QuerySerializationMethod)attributeData.ConstructorArguments[0].Value !);
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
if (namedArgument.Key == nameof(QueryMapAttribute.SerializationMethod) &&
SymbolEqualityComparer.Default.Equals(namedArgument.Value.Type, this.wellKnownSymbols.QueryMapAttribute))
{
attribute.SerializationMethod = (QuerySerializationMethod)namedArgument.Value.Value !;
}
else
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
private Attribute?ParseHttpRequestMessagePropertyAttribute(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
HttpRequestMessagePropertyAttribute?attribute = null;
if (attributeData.ConstructorArguments.Length == 0)
{
attribute = new HttpRequestMessagePropertyAttribute();
}
else if (attributeData.ConstructorArguments.Length == 1 &&
attributeData.ConstructorArguments[0].Type?.SpecialType == SpecialType.System_String)
{
attribute = new HttpRequestMessagePropertyAttribute((string)attributeData.ConstructorArguments[0].Value !);
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
if (namedArgument.Key == nameof(HttpRequestMessagePropertyAttribute.Key) &&
namedArgument.Value.Type?.SpecialType == SpecialType.System_String)
{
attribute.Key = (string?)namedArgument.Value.Value;
}
else
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
private Attribute?ParseRawQueryStringAttribute(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
RawQueryStringAttribute?attribute = null;
if (attributeData.ConstructorArguments.Length == 0)
{
attribute = new RawQueryStringAttribute();
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
private Attribute?ParsePathAttribute(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
PathAttribute?attribute = null;
if (attributeData.ConstructorArguments.Length == 0)
{
attribute = new PathAttribute();
}
else if (attributeData.ConstructorArguments.Length == 1)
{
if (attributeData.ConstructorArguments[0].Type?.SpecialType == SpecialType.System_String)
{
attribute = new PathAttribute((string)attributeData.ConstructorArguments[0].Value !);
}
else if (SymbolEqualityComparer.Default.Equals(attributeData.ConstructorArguments[0].Type, this.wellKnownSymbols.PathSerializationMethod))
{
attribute = new PathAttribute((PathSerializationMethod)attributeData.ConstructorArguments[0].Value !);
}
}
else if (attributeData.ConstructorArguments.Length == 2)
{
if (attributeData.ConstructorArguments[0].Type?.SpecialType == SpecialType.System_String &&
SymbolEqualityComparer.Default.Equals(attributeData.ConstructorArguments[1].Type, this.wellKnownSymbols.PathSerializationMethod))
{
attribute = new PathAttribute((string)attributeData.ConstructorArguments[0].Value !, (PathSerializationMethod)attributeData.ConstructorArguments[1].Value !);
}
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
if (namedArgument.Key == nameof(PathAttribute.Name) &&
namedArgument.Value.Type?.SpecialType == SpecialType.System_String)
{
attribute.Name = (string?)namedArgument.Value.Value;
}
else if (namedArgument.Key == nameof(PathAttribute.SerializationMethod) &&
SymbolEqualityComparer.Default.Equals(namedArgument.Value.Type, this.wellKnownSymbols.PathSerializationMethod))
{
attribute.SerializationMethod = (PathSerializationMethod)namedArgument.Value.Value !;
}
else if (namedArgument.Key == nameof(PathAttribute.Format) &&
namedArgument.Value.Type?.SpecialType == SpecialType.System_String)
{
attribute.Format = (string?)namedArgument.Value.Value;
}
else if (namedArgument.Key == nameof(PathAttribute.UrlEncode) &&
namedArgument.Value.Type?.SpecialType == SpecialType.System_Boolean)
{
attribute.UrlEncode = (bool)namedArgument.Value.Value !;
}
else
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
private Attribute?ParseBasePathAttribute(AttributeData attributeData, ISymbol declaringSymbol, DiagnosticReporter diagnosticReporter)
{
BasePathAttribute?attribute = null;
if (attributeData.ConstructorArguments.Length == 1 &&
attributeData.ConstructorArguments[0].Type?.SpecialType == SpecialType.System_String)
{
attribute = new BasePathAttribute((string)attributeData.ConstructorArguments[0].Value !);
}
if (attribute != null)
{
foreach (var namedArgument in attributeData.NamedArguments)
{
diagnosticReporter.ReportAttributePropertyNotRecognised(attributeData, namedArgument, declaringSymbol);
}
}
else
{
diagnosticReporter.ReportAttributeConstructorNotRecognised(attributeData, declaringSymbol);
}
return(attribute);
}
public void Execute(GeneratorExecutionContext context)
{
try
{
var diagnosticReporter = new DiagnosticReporter(
context
);
var needToStoreGeneratedSources = context.AnalyzerConfigOptions.GlobalOptions.TryGetValue(
$"build_property.Dpdt_Generator_GeneratedSourceFolder",
out var generatedSourceFolder
);
var generatedSourceFolderFullPath =
Path.GetFullPath(
generatedSourceFolder ?? "Dpdt.Pregenerated"
);
var typeInfoContainer = new GeneratorTypeInfoContainer(
ref context,
needToStoreGeneratedSources,
generatedSourceFolderFullPath
);
var internalGenerator = new DpdtInternalGenerator(
diagnosticReporter
);
if (needToStoreGeneratedSources)
{
if (Directory.Exists(generatedSourceFolderFullPath))
{
Directory.Delete(generatedSourceFolderFullPath, true);
}
Directory.CreateDirectory(generatedSourceFolderFullPath);
}
internalGenerator.Execute(
typeInfoContainer,
null
);
diagnosticReporter.ReportWarning(
"Dpdt generator successfully finished its work",
$"Dpdt generator successfully finished its work, {typeInfoContainer.UnitsGenerated} compilation unit(s) generated."
);
}
catch (Exception excp)
{
context.ReportDiagnostic(
Diagnostic.Create(
new DiagnosticDescriptor(
id: "DPDTINJECT100",
title: "Couldn't generate a binding boilerplate code",
messageFormat: "Couldn't generate a binding boilerplate code '{0}' {1}",
category: "DpDtInject",
DiagnosticSeverity.Error,
isEnabledByDefault: true
),
Location.None,
excp.Message,
excp.StackTrace
)
);
}
}
public ImplementationGenerator(TypeModel typeModel, Emitter emitter, DiagnosticReporter diagnosticReporter)
{
this.typeModel = typeModel;
this.emitter = emitter;
this.diagnostics = diagnosticReporter;
}
public void Execute(GeneratorExecutionContext context)
{
try
{
if (!(context.SyntaxReceiver is ClusterCandidateSyntaxReceiver receiver))
{
return;
}
var doBeautify = true;
var beautifyExists = context.AnalyzerConfigOptions.GlobalOptions.TryGetValue(
$"build_property.Dpdt_Generator_Beautify",
out var beautify
);
if (beautifyExists)
{
if (bool.TryParse(beautify?.ToLower() ?? "false", out var parsed))
{
doBeautify = parsed;
}
}
var diagnosticReporter = new DiagnosticReporter(
context
);
var sw = Stopwatch.StartNew();
var typeInfoContainer = new GeneratorTypeInfoContainer(
ref context,
receiver.CandidateClasses
);
var internalGenerator = new DpdtInternalGenerator(
diagnosticReporter,
doBeautify
);
internalGenerator.Execute(
typeInfoContainer
);
diagnosticReporter.ReportWarning(
"Dpdt generator successfully finished its work",
$"Dpdt generator successfully finished its work, {typeInfoContainer.UnitsGenerated} compilation unit(s) generated, taken {sw.Elapsed}."
);
}
catch (Exception excp)
{
Logging.LogGen(excp);
context.ReportDiagnostic(
Diagnostic.Create(
new DiagnosticDescriptor(
id: "DPDTINJECT100",
title: "Couldn't generate a binding boilerplate code",
messageFormat: "Couldn't generate a binding boilerplate code '{0}' {1}",
category: "DpDtInject",
DiagnosticSeverity.Error,
isEnabledByDefault: true
),
Location.None,
excp.Message,
excp.StackTrace
)
);
}
}
public static ParsedCommandLine parseConfigFile(string configFileName, CompilerOptions optionsToExtend,
DirectoryStructureHost system, DiagnosticReporter reportDiagnostic, DiagnosticReporter reportWatchDiagnostic)
{
string configFileText = null;
try
{
configFileText = System.IO.File.ReadAllText(configFileName);
}
catch (Exception e)
{
throw (new Exception("Cannot_read_file_0_Colon_1", e));
//const error = createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, configFileName, e.message);
//reportWatchDiagnostic(error);
//system.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
//return;
}
if (null == configFileText)
{
throw (new Exception("File_0_not_found"));
//const error = createCompilerDiagnostic(Diagnostics.File_0_not_found, configFileName);
//reportDiagnostics([error], reportDiagnostic);
//system.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
//return;
}
var result = parseJsonText(configFileName, configFileText);
//reportDiagnostics(result.parseDiagnostics, reportDiagnostic);
//const cwd = system.getCurrentDirectory();
//var configParseResult = new ParsedCommandLine();
var configParseResult = parseJsonSourceFileConfigFileContent(result, system, System.IO.Path.GetDirectoryName(configFileName), optionsToExtend, configFileName);
//reportDiagnostics(configParseResult.errors, reportDiagnostic);
return(configParseResult);
}
public void Execute(GeneratorExecutionContext context)
{
var diagnosticReporter = new DiagnosticReporter(context);
try
{
// retrieve the populated receiver
if (!(context.SyntaxContextReceiver is SyntaxReceiver receiver))
{
return;
}
// If no project directory was detected then skip the generator.
// This is most likely to happen when the project is empty and doesn't have any classes in it yet.
if (string.IsNullOrEmpty(receiver.ProjectDirectory))
{
return;
}
var semanticModelProvider = new SemanticModelProvider(context);
if (receiver.StartupClasses.Count > 1)
{
foreach (var startup in receiver.StartupClasses)
{
// If there are more than one startup class, report them as errors
diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.MultipleStartupNotAllowed,
Location.Create(startup.SyntaxTree, startup.Span),
startup.SyntaxTree.FilePath));
}
}
var configureMethodModel = semanticModelProvider.GetConfigureMethodModel(receiver.StartupClasses.FirstOrDefault());
var annotationReport = new AnnotationReport();
var templateFinder = new CloudFormationTemplateFinder(_fileManager, _directoryManager);
foreach (var lambdaMethod in receiver.LambdaMethods)
{
var lambdaMethodModel = semanticModelProvider.GetMethodSemanticModel(lambdaMethod);
// Check for necessary references
if (lambdaMethodModel.HasAttribute(context, TypeFullNames.RestApiAttribute) ||
lambdaMethodModel.HasAttribute(context, TypeFullNames.HttpApiAttribute))
{
// Check for arbitrary type from "Amazon.Lambda.APIGatewayEvents"
if (context.Compilation.ReferencedAssemblyNames.FirstOrDefault(x => x.Name == "Amazon.Lambda.APIGatewayEvents") == null)
{
diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.MissingDependencies,
lambdaMethod.GetLocation(),
"Amazon.Lambda.APIGatewayEvents"));
}
}
var model = LambdaFunctionModelBuilder.Build(lambdaMethodModel, configureMethodModel, context);
// If there are more than one event, report them as errors
if (model.LambdaMethod.Events.Count > 1)
{
foreach (var attribute in lambdaMethodModel.GetAttributes().Where(attribute => TypeFullNames.Events.Contains(attribute.AttributeClass.ToDisplayString())))
{
diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.MultipleEventsNotSupported,
Location.Create(attribute.ApplicationSyntaxReference.SyntaxTree, attribute.ApplicationSyntaxReference.Span),
DiagnosticSeverity.Error));
}
// Skip multi-event lambda method from processing and check remaining lambda methods for diagnostics
continue;
}
var template = new LambdaFunctionTemplate(model);
var sourceText = template.TransformText().ToEnvironmentLineEndings();
context.AddSource($"{model.GeneratedMethod.ContainingType.Name}.g.cs", SourceText.From(sourceText, Encoding.UTF8, SourceHashAlgorithm.Sha256));
// report every generated file to build output
diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.CodeGeneration, Location.None, $"{model.GeneratedMethod.ContainingType.Name}.g.cs", sourceText));
annotationReport.LambdaFunctions.Add(model);
}
// 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.
if (receiver.LambdaMethods.Any() || templateFinder.DoesCloudFormationTemplateExist(receiver.ProjectDirectory))
{
annotationReport.CloudFormationTemplatePath = templateFinder.FindCloudFormationTemplate(receiver.ProjectDirectory);
annotationReport.ProjectRootDirectory = receiver.ProjectDirectory;
var cloudFormationJsonWriter = new CloudFormationJsonWriter(_fileManager, _directoryManager, _jsonWriter, diagnosticReporter);
cloudFormationJsonWriter.ApplyReport(annotationReport);
}
}
catch (Exception e)
{
// this is a generator failure, report this as error
diagnosticReporter.Report(Diagnostic.Create(DiagnosticDescriptors.UnhandledException, Location.None, e.PrettyPrint()));
#if DEBUG
throw;
#endif
}
}
