generated ysls now also records if the methods have errors.

McJones · McJones · commit 717d81056327 · 2026-01-23T16:42:45.000+11:00
Intention is that then the editor can know that a command/function exists but is currently in a state that isn't safe to be called.
The location values generated should still be valid allowing jumping to the right file and position to fix it.
diff --git a/Editor/Analysis/Action.cs b/Editor/Analysis/Action.cs
@@ -229,6 +229,8 @@ public Action(string name, ActionType type, IMethodSymbol methodSymbol)
         public string? ReturnDescription;
         public string YarnReturnTypeString => this.MethodSymbol.ReturnType.GetYarnTypeString();
 
+        public bool ContainsErrors = false;
+
         public string ToJSON()
         {
             var result = new Dictionary<string, object?>();
@@ -243,6 +245,8 @@ public string ToJSON()
             result["language"] = "csharp";
             result["async"] = this.AsyncType != AsyncType.Sync;
 
+            result["containsErrors"] = this.ContainsErrors;
+
             if (this.Declaration != null)
             {
                 var location = this.Declaration.GetLocation().GetLineSpan();
@@ -487,6 +491,8 @@ private IEnumerable<Diagnostic> ValidateFunction(Compilation compilation, ILogge
                 yield return Diagnostic.Create(Diagnostics.YS1006YarnFunctionsMustBeStatic, identifierLocation);
             }
 
+            logger?.Inc();
+            logger?.WriteLine($"Validating {identifier} as a function");
             var paramDiags = ValidateParameters(compilation, logger);
             foreach (var p in paramDiags)
             {
@@ -496,6 +502,7 @@ private IEnumerable<Diagnostic> ValidateFunction(Compilation compilation, ILogge
             // Functions must return a number, string, or bool
             var returnTypeSymbol = this.MethodSymbol.ReturnType;
 
+            logger?.Dec();
             switch (returnTypeSymbol.SpecialType)
             {
                 case SpecialType.System_Boolean:
@@ -522,33 +529,32 @@ private IEnumerable<Diagnostic> ValidateFunction(Compilation compilation, ILogge
         // validates the parameters are correct
         private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? logger)
         {
+            logger?.Inc();
             List<Diagnostic> diagnostics = new List<Diagnostic>();
             ParameterListSyntax? parameterList = null;
-            Location? actionLocation = null;
             string? identifier = null;
             
             if (this.MethodDeclarationSyntax is MethodDeclarationSyntax methodDeclaration)
             {
                 identifier = methodDeclaration.Identifier.ToString();
-                logger?.WriteLine($"Validating {identifier} as a method");
+                logger?.WriteLine($"identified {identifier} as a method");
                 parameterList = methodDeclaration.ParameterList;
-                actionLocation = methodDeclaration.GetLocation();
             }
             else if (this.MethodDeclarationSyntax is LocalFunctionStatementSyntax localFunctionStatement)
             {
                 identifier = localFunctionStatement.Identifier.ToString();
-                logger?.WriteLine($"Validating {identifier} as a local function");
+                logger?.WriteLine($"identified {identifier} as a local function");
                 parameterList = localFunctionStatement.ParameterList;
-                actionLocation = localFunctionStatement.GetLocation();
             }
             else if(this.MethodDeclarationSyntax is LambdaExpressionSyntax lambdaExpression)
             {
-                logger?.WriteLine("The action is a lambda.");
-                actionLocation = lambdaExpression.GetLocation();
+                logger?.WriteLine("identifed the action as a lambda.");
+                var actionLocation = lambdaExpression.GetLocation();
 
                 if (lambdaExpression is SimpleLambdaExpressionSyntax)
                 {
                     logger?.WriteLine("The action is a simple lambda, validations do not apply here, skipping this action.");
+                    logger?.Dec();
                     diagnostics.Add(Diagnostic.Create(Diagnostics.YS1012ActionIsALambda, actionLocation));
                     return diagnostics;
                 }
@@ -567,15 +573,18 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo
             if (parameterList == null || parameterList.Parameters.Count() == 0)
             {
                 logger?.WriteLine($"{identifier} has no parameters, ignoring");
+                logger?.Dec();
                 return diagnostics;
             }
 
             logger?.WriteLine($"Will be checking {parameterList.Parameters.Count()} parameters");
             foreach (var parameter in parameterList.Parameters)
             {
+                logger?.Inc();
                 if (parameter.Type == null)
                 {
                     logger?.WriteLine($"{parameter.ToFullString()} has no type, ignoring validation?");
+                    logger?.Dec();
                     continue;
                 }
 
@@ -588,13 +597,15 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo
                 if (typeInfo == null)
                 {
                     logger?.WriteLine($"Unable to determine typeinfo of {parameterName} ignoring validation?");
+                    logger?.Dec();
                     continue;
                 }
 
                 var symbol = model.GetDeclaredSymbol(parameter);
                 if (symbol == null)
                 {
                     logger?.WriteLine($"Unable to determine the declared symbol for {parameterName}, skipping validation");
+                    logger?.Dec();
                     continue;
                 }
 
@@ -603,7 +614,6 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo
                     if (symbol.Type is IArrayTypeSymbol arrayTypeSymbol)
                     {
                         var subtype = arrayTypeSymbol.ElementType;
-                        logger?.WriteLine($"{parameterName} is a params array made up of {subtype}:_{subtype.Name}_:-{subtype.GetYarnTypeString()}-");
                         if (subtype.GetYarnTypeString() == "any")
                         {
                             logger?.WriteLine($"{parameterName} is a parameter array of non Yarn compatible types!");
@@ -621,7 +631,6 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo
                     }
                 }
 
-
                 foreach (var attribute in symbol.GetAttributes())
                 {
                     // this attribute is an enum parameter
@@ -642,15 +651,19 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo
                         }
                     }
                 }
+                logger?.Dec();
             }
 
+            logger?.Dec();
             return diagnostics;
         }
 
         private IEnumerable<Diagnostic> ValidateCommand(Compilation compilation, ILogger? logger)
         {
+            logger?.Inc();
             if (MethodSymbol == null)
             {
+                logger?.Dec();
                 throw new NullReferenceException("Method symbol is null");
             }
 
@@ -705,9 +718,12 @@ private IEnumerable<Diagnostic> ValidateCommand(Compilation compilation, ILogger
             }
             else
             {
+                logger?.Dec();
                 throw new InvalidOperationException($"Expected decl for {this.Name} ({this.SourceFileName}) was of unexpected type {this.MethodDeclarationSyntax?.GetType().Name ?? "null"}");
             }
 
+            logger?.WriteLine($"Validating {identifier} as a command");
+
             var paramDiags = ValidateParameters(compilation, logger);
             foreach (var p in paramDiags)
             {
@@ -719,6 +735,7 @@ private IEnumerable<Diagnostic> ValidateCommand(Compilation compilation, ILogger
             var typeIsKnownInvalid = knownInvalidCommandReturnTypes.Contains(returnTypeSymbol);
 
             var returnTypeIsValid = typeIsKnownValid && !typeIsKnownInvalid;
+            logger?.Dec();
 
             if (returnTypeIsValid == false)
             {
diff --git a/Editor/Analysis/ActionsRegistrationGenerator~/ActionsGenerator.cs b/Editor/Analysis/ActionsRegistrationGenerator~/ActionsGenerator.cs
@@ -210,7 +210,6 @@ public void Execute(GeneratorExecutionContext context)
                 return;
             }
 
-            HashSet<string> removals = new HashSet<string>();
             // validating and logging all the actions
             foreach (var action in actions)
             {
@@ -224,7 +223,11 @@ public void Execute(GeneratorExecutionContext context)
                 foreach (var diagnostic in diagnostics)
                 {
                     context.ReportDiagnostic(diagnostic);
-                    output.WriteLine($"Skipping '{action.Name}' ({action.MethodName}): {diagnostic}");
+                    if (diagnostic.Severity == DiagnosticSeverity.Warning || diagnostic.Severity == DiagnosticSeverity.Error)
+                    {
+                        output.WriteLine($"Flagging '{action.Name}' ({action.MethodName}): {diagnostic}");
+                        action.ContainsErrors = true;
+                    }
                 }
 
                 if (diagnostics.Count > 0)
@@ -250,17 +253,14 @@ public void Execute(GeneratorExecutionContext context)
                         action.Declaration?.GetLocation(),
                         action.Name
                     ));
-                    output.WriteLine($"Action {action.MethodIdentifierName} will be skipped due to it's name {action.Name}");
-                    removals.Add(action.Name);
+                    action.ContainsErrors = true;
+                    output.WriteLine($"Action {action.MethodIdentifierName} will be flagged due to it's name {action.Name}");
                     continue;
                 }
 
                 output.WriteLine($"Action {action.Name}: {action.SourceFileName}:{action.Declaration?.GetLocation()?.GetLineSpan().StartLinePosition.Line} ({action.Type})");
             }
 
-            // removing any actions that failed validation
-            actions = actions.Where(x => !removals.Contains(x.Name)).ToList();
-
             output.Write($"Generating source code...");
 
             var source = Analyser.GenerateRegistrationFileSource(actions);
diff --git a/Editor/Analysis/Analyser.cs b/Editor/Analysis/Analyser.cs
@@ -121,7 +121,10 @@ static string GetLocationOfAssemblyWithType(string typeName)
 
             foreach (var action in output)
             {
-                action.Validate(compilation, logger);
+                if (action.Validate(compilation, logger).Any(d => d.Severity == DiagnosticSeverity.Warning || d.Severity == DiagnosticSeverity.Error))
+                {
+                    action.ContainsErrors = true;
+                }
             }
 
             return output;
diff --git a/Editor/Analysis/ILogger.cs b/Editor/Analysis/ILogger.cs
@@ -16,11 +16,16 @@ public interface ILogger : IDisposable
         void Write(object obj);
         void WriteLine(object obj);
         void WriteException(System.Exception ex, string? message = null);
+
+        void Inc();
+        void Dec();
+        void SetDepth(int depth);
     }
 
     public class FileLogger : ILogger
     {
         System.IO.TextWriter writer;
+        private int depth = 0;
 
         public FileLogger(System.IO.TextWriter writer)
         {
@@ -35,24 +40,40 @@ public void Dispose()
 
         public void Write(object text)
         {
-            writer.Write(text);
+            var tabs = new String('\t', depth);
+            writer.Write(tabs + text);
         }
 
         public void WriteLine(object text)
         {
-            writer.WriteLine(text);
+            var tabs = new String('\t', depth);
+            writer.WriteLine(tabs + text);
         }
         public void WriteException(System.Exception ex, string? message)
         {
+            var tabs = new String('\t', depth);
             if (message == null)
             {
-                writer.WriteLine($"Exception: {ex.Message}");
+                writer.WriteLine($"{tabs}Exception: {ex.Message}");
             }
             else
             {
-                writer.WriteLine($"{message}: {ex.Message}");
+                writer.WriteLine($"{tabs}{message}: {ex.Message}");
             }
         }
+
+        public void Inc()
+        {
+            depth +=1 ;
+        }
+        public void Dec()
+        {
+            depth = Math.Max(depth - 1, 0);
+        }
+        public void SetDepth(int depth)
+        {
+            this.depth = Math.Max(depth, 0);
+        }
     }
 
     public class UnityLogger : ILogger
@@ -66,8 +87,9 @@ public void Write(object text)
 
         public void WriteLine(object text)
         {
+            var tabs = new String('\t', depth);
 #if UNITY_EDITOR
-            Debug.LogWarning(text.ToString());
+            Debug.LogWarning(tabs + text.ToString());
 #endif
         }
 
@@ -77,6 +99,20 @@ public void WriteException(System.Exception ex, string? message = null)
             Debug.LogException(ex);
 #endif
         }
+
+        private int depth = 0;
+        public void Inc()
+        {
+            depth +=1 ;
+        }
+        public void Dec()
+        {
+            depth = Math.Max(depth - 1, 0);
+        }
+        public void SetDepth(int depth)
+        {
+            this.depth = Math.Max(depth, 0);
+        }
     }
 
     public class NullLogger : ILogger
@@ -88,5 +124,9 @@ public void Write(object text) { }
         public void WriteLine(object text) { }
 
         public void WriteException(System.Exception ex, string? message = null) { }
+
+        public void Inc(){}
+        public void Dec(){}
+        public void SetDepth(int depth) {}
     }
 }
diff --git a/SourceGenerator/YarnSpinner.Unity.SourceCodeGenerator.dll b/SourceGenerator/YarnSpinner.Unity.SourceCodeGenerator.dll

Original file line number	Diff line number	Diff line change
`@@ -229,6 +229,8 @@ public Action(string name, ActionType type, IMethodSymbol methodSymbol)`
`229`	`229`	`public string? ReturnDescription;`
`230`	`230`	`public string YarnReturnTypeString => this.MethodSymbol.ReturnType.GetYarnTypeString();`
`231`	`231`
	`232`	`+ public bool ContainsErrors = false;`
	`233`	`+`
`232`	`234`	`public string ToJSON()`
`233`	`235`	`{`
`234`	`236`	`var result = new Dictionary<string, object?>();`
`@@ -243,6 +245,8 @@ public string ToJSON()`
`243`	`245`	`result["language"] = "csharp";`
`244`	`246`	`result["async"] = this.AsyncType != AsyncType.Sync;`
`245`	`247`
	`248`	`+ result["containsErrors"] = this.ContainsErrors;`
	`249`	`+`
`246`	`250`	`if (this.Declaration != null)`
`247`	`251`	`{`
`248`	`252`	`var location = this.Declaration.GetLocation().GetLineSpan();`
`@@ -487,6 +491,8 @@ private IEnumerable<Diagnostic> ValidateFunction(Compilation compilation, ILogge`
`487`	`491`	`yield return Diagnostic.Create(Diagnostics.YS1006YarnFunctionsMustBeStatic, identifierLocation);`
`488`	`492`	`}`
`489`	`493`
	`494`	`+ logger?.Inc();`
	`495`	`+ logger?.WriteLine($"Validating {identifier} as a function");`
`490`	`496`	`var paramDiags = ValidateParameters(compilation, logger);`
`491`	`497`	`foreach (var p in paramDiags)`
`492`	`498`	`{`
`@@ -496,6 +502,7 @@ private IEnumerable<Diagnostic> ValidateFunction(Compilation compilation, ILogge`
`496`	`502`	`// Functions must return a number, string, or bool`
`497`	`503`	`var returnTypeSymbol = this.MethodSymbol.ReturnType;`
`498`	`504`
	`505`	`+ logger?.Dec();`
`499`	`506`	`switch (returnTypeSymbol.SpecialType)`
`500`	`507`	`{`
`501`	`508`	`case SpecialType.System_Boolean:`
`@@ -522,33 +529,32 @@ private IEnumerable<Diagnostic> ValidateFunction(Compilation compilation, ILogge`
`522`	`529`	`// validates the parameters are correct`
`523`	`530`	`private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? logger)`
`524`	`531`	`{`
	`532`	`+ logger?.Inc();`
`525`	`533`	`List<Diagnostic> diagnostics = new List<Diagnostic>();`
`526`	`534`	`ParameterListSyntax? parameterList = null;`
`527`		`- Location? actionLocation = null;`
`528`	`535`	`string? identifier = null;`
`529`	`536`
`530`	`537`	`if (this.MethodDeclarationSyntax is MethodDeclarationSyntax methodDeclaration)`
`531`	`538`	`{`
`532`	`539`	`identifier = methodDeclaration.Identifier.ToString();`
`533`		`- logger?.WriteLine($"Validating {identifier} as a method");`
	`540`	`+ logger?.WriteLine($"identified {identifier} as a method");`
`534`	`541`	`parameterList = methodDeclaration.ParameterList;`
`535`		`- actionLocation = methodDeclaration.GetLocation();`
`536`	`542`	`}`
`537`	`543`	`else if (this.MethodDeclarationSyntax is LocalFunctionStatementSyntax localFunctionStatement)`
`538`	`544`	`{`
`539`	`545`	`identifier = localFunctionStatement.Identifier.ToString();`
`540`		`- logger?.WriteLine($"Validating {identifier} as a local function");`
	`546`	`+ logger?.WriteLine($"identified {identifier} as a local function");`
`541`	`547`	`parameterList = localFunctionStatement.ParameterList;`
`542`		`- actionLocation = localFunctionStatement.GetLocation();`
`543`	`548`	`}`
`544`	`549`	`else if(this.MethodDeclarationSyntax is LambdaExpressionSyntax lambdaExpression)`
`545`	`550`	`{`
`546`		`- logger?.WriteLine("The action is a lambda.");`
`547`		`- actionLocation = lambdaExpression.GetLocation();`
	`551`	`+ logger?.WriteLine("identifed the action as a lambda.");`
	`552`	`+ var actionLocation = lambdaExpression.GetLocation();`
`548`	`553`
`549`	`554`	`if (lambdaExpression is SimpleLambdaExpressionSyntax)`
`550`	`555`	`{`
`551`	`556`	`logger?.WriteLine("The action is a simple lambda, validations do not apply here, skipping this action.");`
	`557`	`+ logger?.Dec();`
`552`	`558`	`diagnostics.Add(Diagnostic.Create(Diagnostics.YS1012ActionIsALambda, actionLocation));`
`553`	`559`	`return diagnostics;`
`554`	`560`	`}`
`@@ -567,15 +573,18 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo`
`567`	`573`	`if (parameterList == null \|\| parameterList.Parameters.Count() == 0)`
`568`	`574`	`{`
`569`	`575`	`logger?.WriteLine($"{identifier} has no parameters, ignoring");`
	`576`	`+ logger?.Dec();`
`570`	`577`	`return diagnostics;`
`571`	`578`	`}`
`572`	`579`
`573`	`580`	`logger?.WriteLine($"Will be checking {parameterList.Parameters.Count()} parameters");`
`574`	`581`	`foreach (var parameter in parameterList.Parameters)`
`575`	`582`	`{`
	`583`	`+ logger?.Inc();`
`576`	`584`	`if (parameter.Type == null)`
`577`	`585`	`{`
`578`	`586`	`logger?.WriteLine($"{parameter.ToFullString()} has no type, ignoring validation?");`
	`587`	`+ logger?.Dec();`
`579`	`588`	`continue;`
`580`	`589`	`}`
`581`	`590`
`@@ -588,13 +597,15 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo`
`588`	`597`	`if (typeInfo == null)`
`589`	`598`	`{`
`590`	`599`	`logger?.WriteLine($"Unable to determine typeinfo of {parameterName} ignoring validation?");`
	`600`	`+ logger?.Dec();`
`591`	`601`	`continue;`
`592`	`602`	`}`
`593`	`603`
`594`	`604`	`var symbol = model.GetDeclaredSymbol(parameter);`
`595`	`605`	`if (symbol == null)`
`596`	`606`	`{`
`597`	`607`	`logger?.WriteLine($"Unable to determine the declared symbol for {parameterName}, skipping validation");`
	`608`	`+ logger?.Dec();`
`598`	`609`	`continue;`
`599`	`610`	`}`
`600`	`611`
`@@ -603,7 +614,6 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo`
`603`	`614`	`if (symbol.Type is IArrayTypeSymbol arrayTypeSymbol)`
`604`	`615`	`{`
`605`	`616`	`var subtype = arrayTypeSymbol.ElementType;`
`606`		`- logger?.WriteLine($"{parameterName} is a params array made up of {subtype}:_{subtype.Name}_:-{subtype.GetYarnTypeString()}-");`
`607`	`617`	`if (subtype.GetYarnTypeString() == "any")`
`608`	`618`	`{`
`609`	`619`	`logger?.WriteLine($"{parameterName} is a parameter array of non Yarn compatible types!");`
`@@ -621,7 +631,6 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo`
`621`	`631`	`}`
`622`	`632`	`}`
`623`	`633`
`624`		`-`
`625`	`634`	`foreach (var attribute in symbol.GetAttributes())`
`626`	`635`	`{`
`627`	`636`	`// this attribute is an enum parameter`
`@@ -642,15 +651,19 @@ private List<Diagnostic> ValidateParameters(Compilation compilation, ILogger? lo`
`642`	`651`	`}`
`643`	`652`	`}`
`644`	`653`	`}`
	`654`	`+ logger?.Dec();`
`645`	`655`	`}`
`646`	`656`
	`657`	`+ logger?.Dec();`
`647`	`658`	`return diagnostics;`
`648`	`659`	`}`
`649`	`660`
`650`	`661`	`private IEnumerable<Diagnostic> ValidateCommand(Compilation compilation, ILogger? logger)`
`651`	`662`	`{`
	`663`	`+ logger?.Inc();`
`652`	`664`	`if (MethodSymbol == null)`
`653`	`665`	`{`
	`666`	`+ logger?.Dec();`
`654`	`667`	`throw new NullReferenceException("Method symbol is null");`
`655`	`668`	`}`
`656`	`669`
`@@ -705,9 +718,12 @@ private IEnumerable<Diagnostic> ValidateCommand(Compilation compilation, ILogger`
`705`	`718`	`}`
`706`	`719`	`else`
`707`	`720`	`{`
	`721`	`+ logger?.Dec();`
`708`	`722`	`throw new InvalidOperationException($"Expected decl for {this.Name} ({this.SourceFileName}) was of unexpected type {this.MethodDeclarationSyntax?.GetType().Name ?? "null"}");`
`709`	`723`	`}`
`710`	`724`
	`725`	`+ logger?.WriteLine($"Validating {identifier} as a command");`
	`726`	`+`
`711`	`727`	`var paramDiags = ValidateParameters(compilation, logger);`
`712`	`728`	`foreach (var p in paramDiags)`
`713`	`729`	`{`
`@@ -719,6 +735,7 @@ private IEnumerable<Diagnostic> ValidateCommand(Compilation compilation, ILogger`
`719`	`735`	`var typeIsKnownInvalid = knownInvalidCommandReturnTypes.Contains(returnTypeSymbol);`
`720`	`736`
`721`	`737`	`var returnTypeIsValid = typeIsKnownValid && !typeIsKnownInvalid;`
	`738`	`+ logger?.Dec();`
`722`	`739`
`723`	`740`	`if (returnTypeIsValid == false)`
`724`	`741`	`{`
Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,6 @@ public void Execute(GeneratorExecutionContext context)`
`210`	`210`	`return;`
`211`	`211`	`}`
`212`	`212`
`213`		`- HashSet<string> removals = new HashSet<string>();`
`214`	`213`	`// validating and logging all the actions`
`215`	`214`	`foreach (var action in actions)`
`216`	`215`	`{`
`@@ -224,7 +223,11 @@ public void Execute(GeneratorExecutionContext context)`
`224`	`223`	`foreach (var diagnostic in diagnostics)`
`225`	`224`	`{`
`226`	`225`	`context.ReportDiagnostic(diagnostic);`
`227`		`- output.WriteLine($"Skipping '{action.Name}' ({action.MethodName}): {diagnostic}");`
	`226`	`+ if (diagnostic.Severity == DiagnosticSeverity.Warning \|\| diagnostic.Severity == DiagnosticSeverity.Error)`
	`227`	`+ {`
	`228`	`+ output.WriteLine($"Flagging '{action.Name}' ({action.MethodName}): {diagnostic}");`
	`229`	`+ action.ContainsErrors = true;`
	`230`	`+ }`
`228`	`231`	`}`
`229`	`232`
`230`	`233`	`if (diagnostics.Count > 0)`
`@@ -250,17 +253,14 @@ public void Execute(GeneratorExecutionContext context)`
`250`	`253`	`action.Declaration?.GetLocation(),`
`251`	`254`	`action.Name`
`252`	`255`	`));`
`253`		`- output.WriteLine($"Action {action.MethodIdentifierName} will be skipped due to it's name {action.Name}");`
`254`		`- removals.Add(action.Name);`
	`256`	`+ action.ContainsErrors = true;`
	`257`	`+ output.WriteLine($"Action {action.MethodIdentifierName} will be flagged due to it's name {action.Name}");`
`255`	`258`	`continue;`
`256`	`259`	`}`
`257`	`260`
`258`	`261`	`output.WriteLine($"Action {action.Name}: {action.SourceFileName}:{action.Declaration?.GetLocation()?.GetLineSpan().StartLinePosition.Line} ({action.Type})");`
`259`	`262`	`}`
`260`	`263`
`261`		`- // removing any actions that failed validation`
`262`		`- actions = actions.Where(x => !removals.Contains(x.Name)).ToList();`
`263`		`-`
`264`	`264`	`output.Write($"Generating source code...");`
`265`	`265`
`266`	`266`	`var source = Analyser.GenerateRegistrationFileSource(actions);`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,10 @@ static string GetLocationOfAssemblyWithType(string typeName)`
`121`	`121`
`122`	`122`	`foreach (var action in output)`
`123`	`123`	`{`
`124`		`- action.Validate(compilation, logger);`
	`124`	`+ if (action.Validate(compilation, logger).Any(d => d.Severity == DiagnosticSeverity.Warning \|\| d.Severity == DiagnosticSeverity.Error))`
	`125`	`+ {`
	`126`	`+ action.ContainsErrors = true;`
	`127`	`+ }`
`125`	`128`	`}`
`126`	`129`
`127`	`130`	`return output;`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,16 @@ public interface ILogger : IDisposable`
`16`	`16`	`void Write(object obj);`
`17`	`17`	`void WriteLine(object obj);`
`18`	`18`	`void WriteException(System.Exception ex, string? message = null);`
	`19`	`+`
	`20`	`+ void Inc();`
	`21`	`+ void Dec();`
	`22`	`+ void SetDepth(int depth);`
`19`	`23`	`}`
`20`	`24`
`21`	`25`	`public class FileLogger : ILogger`
`22`	`26`	`{`
`23`	`27`	`System.IO.TextWriter writer;`
	`28`	`+ private int depth = 0;`
`24`	`29`
`25`	`30`	`public FileLogger(System.IO.TextWriter writer)`
`26`	`31`	`{`
`@@ -35,24 +40,40 @@ public void Dispose()`
`35`	`40`
`36`	`41`	`public void Write(object text)`
`37`	`42`	`{`
`38`		`- writer.Write(text);`
	`43`	`+ var tabs = new String('\t', depth);`
	`44`	`+ writer.Write(tabs + text);`
`39`	`45`	`}`
`40`	`46`
`41`	`47`	`public void WriteLine(object text)`
`42`	`48`	`{`
`43`		`- writer.WriteLine(text);`
	`49`	`+ var tabs = new String('\t', depth);`
	`50`	`+ writer.WriteLine(tabs + text);`
`44`	`51`	`}`
`45`	`52`	`public void WriteException(System.Exception ex, string? message)`
`46`	`53`	`{`
	`54`	`+ var tabs = new String('\t', depth);`
`47`	`55`	`if (message == null)`
`48`	`56`	`{`
`49`		`- writer.WriteLine($"Exception: {ex.Message}");`
	`57`	`+ writer.WriteLine($"{tabs}Exception: {ex.Message}");`
`50`	`58`	`}`
`51`	`59`	`else`
`52`	`60`	`{`
`53`		`- writer.WriteLine($"{message}: {ex.Message}");`
	`61`	`+ writer.WriteLine($"{tabs}{message}: {ex.Message}");`
`54`	`62`	`}`
`55`	`63`	`}`
	`64`	`+`
	`65`	`+ public void Inc()`
	`66`	`+ {`
	`67`	`+ depth +=1 ;`
	`68`	`+ }`
	`69`	`+ public void Dec()`
	`70`	`+ {`
	`71`	`+ depth = Math.Max(depth - 1, 0);`
	`72`	`+ }`
	`73`	`+ public void SetDepth(int depth)`
	`74`	`+ {`
	`75`	`+ this.depth = Math.Max(depth, 0);`
	`76`	`+ }`
`56`	`77`	`}`
`57`	`78`
`58`	`79`	`public class UnityLogger : ILogger`
`@@ -66,8 +87,9 @@ public void Write(object text)`
`66`	`87`
`67`	`88`	`public void WriteLine(object text)`
`68`	`89`	`{`
	`90`	`+ var tabs = new String('\t', depth);`
`69`	`91`	`#if UNITY_EDITOR`
`70`		`- Debug.LogWarning(text.ToString());`
	`92`	`+ Debug.LogWarning(tabs + text.ToString());`
`71`	`93`	`#endif`
`72`	`94`	`}`
`73`	`95`
`@@ -77,6 +99,20 @@ public void WriteException(System.Exception ex, string? message = null)`
`77`	`99`	`Debug.LogException(ex);`
`78`	`100`	`#endif`
`79`	`101`	`}`
	`102`	`+`
	`103`	`+ private int depth = 0;`
	`104`	`+ public void Inc()`
	`105`	`+ {`
	`106`	`+ depth +=1 ;`
	`107`	`+ }`
	`108`	`+ public void Dec()`
	`109`	`+ {`
	`110`	`+ depth = Math.Max(depth - 1, 0);`
	`111`	`+ }`
	`112`	`+ public void SetDepth(int depth)`
	`113`	`+ {`
	`114`	`+ this.depth = Math.Max(depth, 0);`
	`115`	`+ }`
`80`	`116`	`}`
`81`	`117`
`82`	`118`	`public class NullLogger : ILogger`
`@@ -88,5 +124,9 @@ public void Write(object text) { }`
`88`	`124`	`public void WriteLine(object text) { }`
`89`	`125`
`90`	`126`	`public void WriteException(System.Exception ex, string? message = null) { }`
	`127`	`+`
	`128`	`+ public void Inc(){}`
	`129`	`+ public void Dec(){}`
	`130`	`+ public void SetDepth(int depth) {}`
`91`	`131`	`}`
`92`	`132`	`}`