BadInteropApiModelBuilder.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
 
using BadScript2.Interop.Generator.Model;
 
using Microsoft.CodeAnalysis;
 
namespace BadScript2.Interop.Generator.Interop;
 
public class BadInteropApiModelBuilder
{
    private static readonly DiagnosticDescriptor s_CanNotConvertTypeDiagnostic = new DiagnosticDescriptor(
        "BAS0001",
        "Can not convert type",
        "Can not convert type {0}",
        "BadScript2.Interop.Generator",
        DiagnosticSeverity.Error,
        true
    );
 
    private static readonly DiagnosticDescriptor s_CanNotStringifyDefaultValue = new DiagnosticDescriptor(
        "BAS0002",
        "Can not stringify default value",
        "Can not stringify default value {0}",
        "BadScript2.Interop.Generator",
        DiagnosticSeverity.Error,
        true
    );
 
    private readonly List<Diagnostic> m_Diagnostics = new List<Diagnostic>();
 
    private void AddDiagnostic(Diagnostic diagnostic)
    {
        m_Diagnostics.Add(diagnostic);
    }
 
    private IEnumerable<IMethodSymbol> FindMethods(INamedTypeSymbol api)
    {
        IEnumerable<IMethodSymbol> methods = api.GetMembers().Where(x => x is IMethodSymbol).Cast<IMethodSymbol>();
        foreach (IMethodSymbol method in methods)
        {
            AttributeData? attribute = method.GetInteropMethodAttribute();
            if (attribute != null)
            {
                yield return method;
            }
        }
    }
 
    public ApiModel GenerateModel(INamedTypeSymbol api)
    {
        IEnumerable<IMethodSymbol> methods = FindMethods(api);
        AttributeData? apiAttribute = api.GetInteropApiAttribute();
        if (apiAttribute == null)
        {
            throw new Exception("BadInteropApiAttribute not found");
        }
 
        string apiName = api.Name;
        bool constructorPrivate = false;
        if (apiAttribute.ConstructorArguments.Length > 0)
        {
            apiName = apiAttribute.ConstructorArguments[0].Value?.ToString() ?? apiName;
            bool? priv = apiAttribute.ConstructorArguments[1].Value as bool?;
            constructorPrivate = apiAttribute.ConstructorArguments.Length > 1 && priv != null && priv.Value;
        }
 
        MethodModel[] methodModels = GenerateMethodModels(methods).ToArray();
        Diagnostic[] diagnostics = Array.Empty<Diagnostic>();
        if (m_Diagnostics.Count != 0)
        {
            diagnostics = m_Diagnostics.ToArray();
            m_Diagnostics.Clear();
        }
 
        return new ApiModel(
            api.ContainingNamespace?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat.WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.Omitted))!,
            api.Name,
            methodModels,
            apiName,
            constructorPrivate,
            diagnostics
        );
    }
 
    private string EscapeDescription(string str)
    {
        return str.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n");
    }
 
    private IEnumerable<ParameterModel> GenerateParameterModel(IMethodSymbol method)
    {
        foreach (IParameterSymbol symbol in method.Parameters.Where(x => x.Ordinal >= 0).OrderBy(x => x.Ordinal))
        {
            //if parameter is first parameter and its of type BadScript2.Runtime.BadExecutionContext
            if (symbol.Ordinal == 0 && symbol.Type.ToDisplayString() == "BadScript2.Runtime.BadExecutionContext")
            {
                yield return new ParameterModel(true);
            }
            else
            {
                AttributeData? attribute = symbol.GetParameterAttribute();
                string? name = symbol.Name;
                string? description = null;
                bool isNullable = symbol.NullableAnnotation == NullableAnnotation.Annotated;
                string type = ConvertType(symbol.Type, true, symbol);
 
                if (attribute != null)
                {
                    ImmutableArray<TypedConstant> cargs = attribute.ConstructorArguments;
                    name = cargs.Length > 0 ? cargs[0].Value?.ToString() ?? name : name;
                    description = cargs.Length > 1 ? cargs[1].Value?.ToString() : null;
                    if (description != null)
                    {
                        description = EscapeDescription(description);
                    }
 
                    type = cargs.Length > 2 ? cargs[2].Value?.ToString() ?? type : type;
                }
 
                bool hasDefaultValue = symbol.HasExplicitDefaultValue;
                string? defaultValue = null;
                if (hasDefaultValue)
                {
                    defaultValue = StringifyDefaultValue(symbol.ExplicitDefaultValue, symbol);
                }
 
                bool isRestArgs = symbol.IsParams;
 
                yield return new ParameterModel(false, hasDefaultValue, defaultValue, name, description, type, symbol.Type.ToDisplayString(), isNullable, isRestArgs);
            }
        }
    }
 
    private string StringifyDefaultValue(object? obj, ISymbol symbol)
    {
        switch (obj)
        {
            case string str:
                return $"\"{str}\"";
            case char c:
                return $"'{c}'";
            case bool b:
                return b.ToString().ToLower();
            case float f:
                return $"{f}f";
            case double d:
                return $"{d}d";
            case decimal m:
                return $"{m}m";
            case int i:
                return i.ToString();
            case long l:
                return $"{l}L";
            case uint u:
                return $"{u}u";
            case ulong ul:
                return $"{ul}ul";
            case short s:
                return $"{s}s";
            case ushort us:
                return $"{us}us";
            case byte by:
                return $"{by}b";
            case sbyte sb:
                return $"{sb}sb";
            case Enum e:
                return $"{e.GetType().Name}.{e}";
            case Type t:
                return $"typeof({t.Name})";
            case null:
                return "null";
            default:
            {
                AddDiagnostic(symbol.CreateDiagnostic(s_CanNotStringifyDefaultValue, obj));
 
                return "null";
            }
        }
    }
 
    private IEnumerable<MethodModel> GenerateMethodModels(IEnumerable<IMethodSymbol> symbols)
    {
        foreach (IMethodSymbol symbol in symbols)
        {
            AttributeData? attribute = symbol.GetInteropMethodAttribute();
 
            if (attribute == null)
            {
                continue;
            }
 
            ImmutableArray<TypedConstant> cargs = attribute.ConstructorArguments;
 
            //The api name, if its not provided, use the method name
            string name = cargs.Length > 0 ? cargs[0].Value?.ToString() ?? symbol.Name : symbol.Name;
 
            //The description, if its not provided, use null
            string description = EscapeDescription(cargs.Length > 1 ? cargs[1].Value?.ToString() ?? string.Empty : string.Empty);
 
            //Check if the symbol is a void return
            bool isVoidReturn = symbol.ReturnsVoid;
            AttributeData? returnAttribute = symbol.GetReturnTypeAttribute();
            string returnDescription = string.Empty;
            bool allowNativeReturn = false;
            if (returnAttribute != null)
            {
                if (returnAttribute.ConstructorArguments.Length > 0)
                {
                    returnDescription = EscapeDescription(returnAttribute.ConstructorArguments[0].Value?.ToString() ?? string.Empty);
                }
 
                if (returnAttribute.ConstructorArguments.Length > 1)
                {
                    allowNativeReturn = (bool)returnAttribute.ConstructorArguments[1].Value!;
                }
            }
 
 
            //The return type, if its not provided, use the symbol's return type
            string returnType = isVoidReturn ? "any" : ConvertType(symbol.ReturnType, allowNativeReturn, symbol);
 
 
            MethodModel model = new MethodModel(
                symbol.Name,
                name,
                returnType,
                description,
                GenerateParameterModel(symbol).ToArray(),
                isVoidReturn,
                returnDescription,
                allowNativeReturn
            );
 
            yield return model;
        }
    }
 
    private string ConvertType(ITypeSymbol type, bool allowAny, ISymbol sourceSymbol)
    {
        if (type.NullableAnnotation == NullableAnnotation.Annotated)
        {
            //Unwrap nullable value types
            type = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
        }
 
        //If type is string, return "string"
        if (type.SpecialType == SpecialType.System_String)
        {
            return "string";
        }
 
        //if type is bool return "bool"
        if (type.SpecialType == SpecialType.System_Boolean)
        {
            return "bool";
        }
 
        //if type is numeric type return "num"
        if (type.SpecialType == SpecialType.System_Byte ||
            type.SpecialType == SpecialType.System_SByte ||
            type.SpecialType == SpecialType.System_Int16 ||
            type.SpecialType == SpecialType.System_UInt16 ||
            type.SpecialType == SpecialType.System_Int32 ||
            type.SpecialType == SpecialType.System_UInt32 ||
            type.SpecialType == SpecialType.System_Int64 ||
            type.SpecialType == SpecialType.System_UInt64 ||
            type.SpecialType == SpecialType.System_Single ||
            type.SpecialType == SpecialType.System_Double ||
            type.SpecialType == SpecialType.System_Decimal)
        {
            return "num";
        }
 
        //if type is array or list or ilist, return "array"
        if (type is IArrayTypeSymbol ||
            type.AllInterfaces.Any(x => x.ToDisplayString() == "System.Collections.Generic.IList<T>") ||
            type.AllInterfaces.Any(x => x.ToDisplayString() == "System.Collections.IList<T>"))
        {
            return "Array";
        }
 
        //if type is BadObject, return "any"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.BadObject")
        {
            return "any";
        }
 
        if (type.ToDisplayString() == "BadScript2.Interop.Common.Task.BadTask")
        {
            return "Task";
        }
 
        //If type is BadTable, return "Table"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.BadTable")
        {
            return "Table";
        }
 
        //If type is BadArray return "Array"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.BadArray")
        {
            return "Array";
        }
 
        //If type is BadFunction return "Function"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.Functions.BadFunction")
        {
            return "Function";
        }
 
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.Types.BadClassPrototype")
        {
            return "Type";
        }
 
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.Error.BadRuntimeError")
        {
            return "Error";
        }
 
        //If Type is IBadBoolean or BadBoolean return "bool"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.Native.IBadBoolean" || type.ToDisplayString() == "BadScript2.Runtime.Objects.Native.BadBoolean")
        {
            return "bool";
        }
 
        //If Type is IBadNumber or BadNumber return "num"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.Native.IBadNumber" || type.ToDisplayString() == "BadScript2.Runtime.Objects.Native.BadNumber")
        {
            return "num";
        }
 
        //If Type is IBadString or BadString return "string"
        if (type.ToDisplayString() == "BadScript2.Runtime.Objects.Native.IBadString" || type.ToDisplayString() == "BadScript2.Runtime.Objects.Native.BadString")
        {
            return "string";
        }
 
        //If Type is BadScope return "Scope"
        if (type.ToDisplayString() == "BadScript2.Runtime.BadScope")
        {
            return "Scope";
        }
 
        if (allowAny)
        {
            return "any";
        }
 
        AddDiagnostic(sourceSymbol.CreateDiagnostic(s_CanNotConvertTypeDiagnostic, type.ToDisplayString()));
 
        return "any";
    }
}