more YSLS changes.

- types will never be null, they will be any if it can't work it out
- created json now matches the newer schema
- variadics params now list their internal type and not array

Author: McJones

CHANGELOG.md

@@ -22,6 +22,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `YarnProjectImporter` now updates asset addresses and generates the C# variable storage class after the project import completes, rather than during the import.
 - Each assembly now gets it's own YSLS file when generating them.
   - renamed the test asmdef files from `YarnSpinnerTests.x` to `YarnSpinner.Unity.Tests.X` so that they are matched by the existing filters.
+- Generated YSLS file now matches the newer schema, see the YS core repo for details of this
 
 ### Removed
 

Editor/Analysis/Action.cs

@@ -107,7 +107,7 @@ public enum AsyncType
 
     static class ITypeSymbolExtension
     {
-        public static string? GetYarnTypeString(this ITypeSymbol typeSymbol)
+        public static string GetYarnTypeString(this ITypeSymbol typeSymbol)
         {
             return typeSymbol.SpecialType switch
             {
@@ -124,7 +124,7 @@ static class ITypeSymbolExtension
                 SpecialType.System_Single => "number",
                 SpecialType.System_Double => "number",
                 SpecialType.System_String => "string",
-                _ => null
+                _ => "any"
             };
         }
     }
@@ -140,7 +140,7 @@ public struct Parameter
 
         public AttributeData[]? Attributes;
 
-        public readonly string? YarnTypeString => Type.GetYarnTypeString();
+        public readonly string YarnTypeString => Type.GetYarnTypeString(); // this should change to support the subtypes through the same logic we use below, for now it's fine
     }
 
     public class Action
@@ -227,21 +227,21 @@ public Action(string name, ActionType type, IMethodSymbol methodSymbol)
         public List<Parameter> Parameters = new List<Parameter>();
 
         public string? ReturnDescription;
-        public string? YarnReturnTypeString => this.MethodSymbol.ReturnType.GetYarnTypeString();
+        public string YarnReturnTypeString => this.MethodSymbol.ReturnType.GetYarnTypeString();
 
         public string ToJSON()
         {
             var result = new Dictionary<string, object?>();
 
-            result["YarnName"] = this.Name;
-            result["DefinitionName"] = this.MethodName;
-            result["FileName"] = this.SourceFileName;
+            result["yarnName"] = this.Name;
+            result["definitionName"] = this.MethodName;
+            result["fileName"] = this.SourceFileName;
             if (!string.IsNullOrEmpty(this.Description))
             {
-                result["Documentation"] = this.Description;
+                result["documentation"] = this.Description;
             }
-            result["Language"] = "csharp";
-            result["Async"] = this.AsyncType != AsyncType.Sync;
+            result["language"] = "csharp";
+            result["async"] = this.AsyncType != AsyncType.Sync;
 
             if (this.Declaration != null)
             {
@@ -257,49 +257,48 @@ public string ToJSON()
                     {"line", location.EndLinePosition.Line},
                     {"character", location.EndLinePosition.Character},
                 };
-                result["Location"] = new Dictionary<string, Dictionary<string, int>>()
+                result["location"] = new Dictionary<string, Dictionary<string, int>>()
                 {
                     {"start", startPosition},
                     {"end", endPosition},
                 };
             }
 
-            result["Parameters"] = new List<Dictionary<string, object?>>(this.Parameters.Select(p =>
+            result["parameters"] = new List<Dictionary<string, object?>>(this.Parameters.Select(p =>
             {
                 var paramObject = new Dictionary<string, object?>();
 
-                paramObject["Name"] = p.Name;
+                paramObject["name"] = p.Name;
                 if (!string.IsNullOrEmpty(p.Description))
                 {
-                    paramObject["Documentation"] = p.Description;
+                    paramObject["documentation"] = p.Description;
                 }
                 if (!string.IsNullOrEmpty(p.DefaultValueString))
                 {
-                    paramObject["DefaultValue"] = p.DefaultValueString;
+                    paramObject["defaultValue"] = p.DefaultValueString;
                 }
-                paramObject["IsParamsArray"] = p.IsParamsArray;
+                paramObject["isParamsArray"] = p.IsParamsArray;
 
                 // there are two special cases for parameters
                 // if it is a subclass of UnityEngine.Component or MonoBehaviour we additionally add the subtype
                 // this is used by the editor later on to let the writer know WHERE the command will be going
                 // otherwise we just add the Yarn type of the parameter
                 if (p.Type.BaseType?.Name == "MonoBehaviour" || p.Type.BaseType?.Name == "Component")
                 {
-                    paramObject["Type"] = "instance";
-                    paramObject["SubType"] = p.Type.Name;
+                    paramObject["type"] = "instance";
+                    paramObject["subtype"] = p.Type.Name;
                 }
                 else
                 {
-                    // there is one special case of the regular types
-                    // if the parameter has the YarnNodeParameterAttribute on it then we want to say it's a node and not a string
+                    // there is one special case of the regular types which is if you are a string and attributed as a node parameter
                     var isANodeType = p.Attributes?.Count(a => a.AttributeClass?.Name == "YarnNodeParameterAttribute") > 0;
                     if (isANodeType && p.Type.SpecialType == SpecialType.System_String)
                     {
-                        paramObject["Type"] = "node";
+                        paramObject["type"] = "node";
                     }
                     else
                     {
-                        paramObject["Type"] = p.YarnTypeString;
+                        paramObject["type"] = p.YarnTypeString;
                     }
                 }
 
@@ -309,13 +308,13 @@ public string ToJSON()
             if (this.Type == ActionType.Function)
             {
                 var retvrn = new Dictionary<string, string>();
-                retvrn["Type"] = this.YarnReturnTypeString ?? "error";
+                retvrn["type"] = this.YarnReturnTypeString;
 
                 if (!string.IsNullOrWhiteSpace(this.ReturnDescription))
                 {
-                    retvrn["Description"] = this.ReturnDescription;
+                    retvrn["description"] = this.ReturnDescription;
                 }
-                result["Return"] = retvrn;
+                result["return"] = retvrn;
             }
 
             return Yarn.Unity.Editor.Json.Serialize(result);

Editor/Analysis/ActionsRegistrationGenerator~/ActionsGenerator.cs

@@ -288,8 +288,9 @@ public void Execute(GeneratorExecutionContext context)
                     IEnumerable<string> functionJSON = actions.Where(a => a.Type == ActionType.Function).Select(a => a.ToJSON());
 
                     var ysls = "{" +
-                    $@"""Commands"":[{string.Join(",", commandJSON)}]," +
-                    $@"""Functions"":[{string.Join(",", functionJSON)}]" +
+                    @"""version"":2," +
+                    $@"""commands"":[{string.Join(",", commandJSON)}]," +
+                    $@"""functions"":[{string.Join(",", functionJSON)}]" +
                     "}";
 
                     output.WriteLine($"Done.");

Editor/Analysis/Analyser.cs

@@ -896,12 +896,27 @@ private static List<Parameter> GetParams(IMethodSymbol symbol, XElement? documen
                     }
                 }
 
+                // ok here need to make some changes
+                // if p is variadic it will be array<T> and I need to get just the T
+                ITypeSymbol parameterType = param.Type;
+                if (param.IsParams)
+                {
+                    if (param.Type is IArrayTypeSymbol arrayTypeSymbol)
+                    {
+                        parameterType = arrayTypeSymbol.ElementType;
+                    }
+                    else
+                    {
+                        logger?.WriteLine($"\t{param.Name} is a variadic parameter but isn't an array");
+                    }
+                }
+
                 parameterDocumentation.TryGetValue(param.Name, out var paramDoc);
                 var p = new Parameter
                 {
                     Name = param.Name,
                     IsOptional = param.IsOptional,
-                    Type = param.Type,
+                    Type = parameterType,
                     Description = paramDoc,
                     IsParamsArray = param.IsParams,
                     Attributes = attributes.Count() == 0 ? null : attributes.ToArray(),