620 lines
35 KiB
C#
620 lines
35 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Microsoft.CodeAnalysis;
|
|
|
|
namespace Godot.SourceGenerators
|
|
{
|
|
internal static class MarshalUtils
|
|
{
|
|
public class TypeCache
|
|
{
|
|
public INamedTypeSymbol GodotObjectType { get; }
|
|
public INamedTypeSymbol GodotGenericDictionary { get; }
|
|
public INamedTypeSymbol GodotGenericArray { get; }
|
|
|
|
// ReSharper disable once InconsistentNaming
|
|
public INamedTypeSymbol IDictionary { get; }
|
|
|
|
// ReSharper disable once InconsistentNaming
|
|
public INamedTypeSymbol ICollection { get; }
|
|
public INamedTypeSymbol GenericIDictionary { get; }
|
|
public INamedTypeSymbol SystemGenericDictionary { get; }
|
|
public INamedTypeSymbol SystemGenericList { get; }
|
|
|
|
public TypeCache(GeneratorExecutionContext context)
|
|
{
|
|
INamedTypeSymbol GetTypeByMetadataNameOrThrow(string fullyQualifiedMetadataName)
|
|
{
|
|
return context.Compilation.GetTypeByMetadataName(fullyQualifiedMetadataName) ??
|
|
throw new InvalidOperationException("Type not found: " + fullyQualifiedMetadataName);
|
|
}
|
|
|
|
GodotObjectType = GetTypeByMetadataNameOrThrow("Godot.Object");
|
|
GodotGenericDictionary = GetTypeByMetadataNameOrThrow("Godot.Collections.Dictionary`2");
|
|
GodotGenericArray = GetTypeByMetadataNameOrThrow("Godot.Collections.Array`1");
|
|
IDictionary = GetTypeByMetadataNameOrThrow("System.Collections.IDictionary");
|
|
ICollection = GetTypeByMetadataNameOrThrow("System.Collections.ICollection");
|
|
GenericIDictionary = GetTypeByMetadataNameOrThrow("System.Collections.Generic.IDictionary`2");
|
|
SystemGenericDictionary = GetTypeByMetadataNameOrThrow("System.Collections.Generic.Dictionary`2");
|
|
SystemGenericList = GetTypeByMetadataNameOrThrow("System.Collections.Generic.List`1");
|
|
}
|
|
}
|
|
|
|
public static VariantType? ConvertMarshalTypeToVariantType(MarshalType marshalType)
|
|
=> marshalType switch
|
|
{
|
|
MarshalType.Boolean => VariantType.Bool,
|
|
MarshalType.Char => VariantType.Int,
|
|
MarshalType.SByte => VariantType.Int,
|
|
MarshalType.Int16 => VariantType.Int,
|
|
MarshalType.Int32 => VariantType.Int,
|
|
MarshalType.Int64 => VariantType.Int,
|
|
MarshalType.Byte => VariantType.Int,
|
|
MarshalType.UInt16 => VariantType.Int,
|
|
MarshalType.UInt32 => VariantType.Int,
|
|
MarshalType.UInt64 => VariantType.Int,
|
|
MarshalType.Single => VariantType.Float,
|
|
MarshalType.Double => VariantType.Float,
|
|
MarshalType.String => VariantType.String,
|
|
MarshalType.Vector2 => VariantType.Vector2,
|
|
MarshalType.Vector2i => VariantType.Vector2i,
|
|
MarshalType.Rect2 => VariantType.Rect2,
|
|
MarshalType.Rect2i => VariantType.Rect2i,
|
|
MarshalType.Transform2D => VariantType.Transform2d,
|
|
MarshalType.Vector3 => VariantType.Vector3,
|
|
MarshalType.Vector3i => VariantType.Vector3i,
|
|
MarshalType.Basis => VariantType.Basis,
|
|
MarshalType.Quaternion => VariantType.Quaternion,
|
|
MarshalType.Transform3D => VariantType.Transform3d,
|
|
MarshalType.Vector4 => VariantType.Vector4,
|
|
MarshalType.Vector4i => VariantType.Vector4i,
|
|
MarshalType.Projection => VariantType.Projection,
|
|
MarshalType.AABB => VariantType.Aabb,
|
|
MarshalType.Color => VariantType.Color,
|
|
MarshalType.Plane => VariantType.Plane,
|
|
MarshalType.Callable => VariantType.Callable,
|
|
MarshalType.SignalInfo => VariantType.Signal,
|
|
MarshalType.Enum => VariantType.Int,
|
|
MarshalType.ByteArray => VariantType.PackedByteArray,
|
|
MarshalType.Int32Array => VariantType.PackedInt32Array,
|
|
MarshalType.Int64Array => VariantType.PackedInt64Array,
|
|
MarshalType.Float32Array => VariantType.PackedFloat32Array,
|
|
MarshalType.Float64Array => VariantType.PackedFloat64Array,
|
|
MarshalType.StringArray => VariantType.PackedStringArray,
|
|
MarshalType.Vector2Array => VariantType.PackedVector2Array,
|
|
MarshalType.Vector3Array => VariantType.PackedVector3Array,
|
|
MarshalType.ColorArray => VariantType.PackedColorArray,
|
|
MarshalType.GodotObjectOrDerivedArray => VariantType.Array,
|
|
MarshalType.SystemArrayOfSupportedType => VariantType.Array,
|
|
MarshalType.GodotGenericDictionary => VariantType.Dictionary,
|
|
MarshalType.GodotGenericArray => VariantType.Array,
|
|
MarshalType.SystemGenericDictionary => VariantType.Dictionary,
|
|
MarshalType.SystemGenericList => VariantType.Array,
|
|
MarshalType.GenericIDictionary => VariantType.Dictionary,
|
|
MarshalType.GenericICollection => VariantType.Array,
|
|
MarshalType.GenericIEnumerable => VariantType.Array,
|
|
MarshalType.Variant => VariantType.Nil,
|
|
MarshalType.GodotObjectOrDerived => VariantType.Object,
|
|
MarshalType.StringName => VariantType.StringName,
|
|
MarshalType.NodePath => VariantType.NodePath,
|
|
MarshalType.RID => VariantType.Rid,
|
|
MarshalType.GodotDictionary => VariantType.Dictionary,
|
|
MarshalType.GodotArray => VariantType.Array,
|
|
MarshalType.IDictionary => VariantType.Dictionary,
|
|
MarshalType.ICollection => VariantType.Array,
|
|
MarshalType.IEnumerable => VariantType.Array,
|
|
_ => null
|
|
};
|
|
|
|
public static MarshalType? ConvertManagedTypeToMarshalType(ITypeSymbol type, TypeCache typeCache)
|
|
{
|
|
var specialType = type.SpecialType;
|
|
|
|
switch (specialType)
|
|
{
|
|
case SpecialType.System_Boolean:
|
|
return MarshalType.Boolean;
|
|
case SpecialType.System_Char:
|
|
return MarshalType.Char;
|
|
case SpecialType.System_SByte:
|
|
return MarshalType.SByte;
|
|
case SpecialType.System_Int16:
|
|
return MarshalType.Int16;
|
|
case SpecialType.System_Int32:
|
|
return MarshalType.Int32;
|
|
case SpecialType.System_Int64:
|
|
return MarshalType.Int64;
|
|
case SpecialType.System_Byte:
|
|
return MarshalType.Byte;
|
|
case SpecialType.System_UInt16:
|
|
return MarshalType.UInt16;
|
|
case SpecialType.System_UInt32:
|
|
return MarshalType.UInt32;
|
|
case SpecialType.System_UInt64:
|
|
return MarshalType.UInt64;
|
|
case SpecialType.System_Single:
|
|
return MarshalType.Single;
|
|
case SpecialType.System_Double:
|
|
return MarshalType.Double;
|
|
case SpecialType.System_String:
|
|
return MarshalType.String;
|
|
default:
|
|
{
|
|
var typeKind = type.TypeKind;
|
|
|
|
if (typeKind == TypeKind.Enum)
|
|
return MarshalType.Enum;
|
|
|
|
if (typeKind == TypeKind.Struct)
|
|
{
|
|
if (type.ContainingAssembly.Name == "GodotSharp" &&
|
|
type.ContainingNamespace.Name == "Godot")
|
|
{
|
|
return type switch
|
|
{
|
|
{ Name: "Vector2" } => MarshalType.Vector2,
|
|
{ Name: "Vector2i" } => MarshalType.Vector2i,
|
|
{ Name: "Rect2" } => MarshalType.Rect2,
|
|
{ Name: "Rect2i" } => MarshalType.Rect2i,
|
|
{ Name: "Transform2D" } => MarshalType.Transform2D,
|
|
{ Name: "Vector3" } => MarshalType.Vector3,
|
|
{ Name: "Vector3i" } => MarshalType.Vector3i,
|
|
{ Name: "Basis" } => MarshalType.Basis,
|
|
{ Name: "Quaternion" } => MarshalType.Quaternion,
|
|
{ Name: "Transform3D" } => MarshalType.Transform3D,
|
|
{ Name: "Vector4" } => MarshalType.Vector4,
|
|
{ Name: "Vector4i" } => MarshalType.Vector4i,
|
|
{ Name: "Projection" } => MarshalType.Projection,
|
|
{ Name: "AABB" } => MarshalType.AABB,
|
|
{ Name: "Color" } => MarshalType.Color,
|
|
{ Name: "Plane" } => MarshalType.Plane,
|
|
{ Name: "RID" } => MarshalType.RID,
|
|
{ Name: "Callable" } => MarshalType.Callable,
|
|
{ Name: "SignalInfo" } => MarshalType.SignalInfo,
|
|
{ Name: "Variant" } => MarshalType.Variant,
|
|
_ => null
|
|
};
|
|
}
|
|
}
|
|
else if (typeKind == TypeKind.Array)
|
|
{
|
|
var arrayType = (IArrayTypeSymbol)type;
|
|
var elementType = arrayType.ElementType;
|
|
|
|
switch (elementType.SpecialType)
|
|
{
|
|
case SpecialType.System_Byte:
|
|
return MarshalType.ByteArray;
|
|
case SpecialType.System_Int32:
|
|
return MarshalType.Int32Array;
|
|
case SpecialType.System_Int64:
|
|
return MarshalType.Int64Array;
|
|
case SpecialType.System_Single:
|
|
return MarshalType.Float32Array;
|
|
case SpecialType.System_Double:
|
|
return MarshalType.Float64Array;
|
|
case SpecialType.System_String:
|
|
return MarshalType.StringArray;
|
|
}
|
|
|
|
if (elementType.SimpleDerivesFrom(typeCache.GodotObjectType))
|
|
return MarshalType.GodotObjectOrDerivedArray;
|
|
|
|
if (elementType.ContainingAssembly.Name == "GodotSharp" &&
|
|
elementType.ContainingNamespace.Name == "Godot")
|
|
{
|
|
switch (elementType)
|
|
{
|
|
case { Name: "Vector2" }:
|
|
return MarshalType.Vector2Array;
|
|
case { Name: "Vector3" }:
|
|
return MarshalType.Vector3Array;
|
|
case { Name: "Color" }:
|
|
return MarshalType.ColorArray;
|
|
}
|
|
}
|
|
|
|
if (ConvertManagedTypeToMarshalType(elementType, typeCache) != null)
|
|
return MarshalType.SystemArrayOfSupportedType;
|
|
|
|
return null;
|
|
}
|
|
else if (type is INamedTypeSymbol { IsGenericType: true } genericType)
|
|
{
|
|
var genericTypeDef = genericType.ConstructedFrom;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(genericTypeDef, typeCache.GodotGenericDictionary))
|
|
return MarshalType.GodotGenericDictionary;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(genericTypeDef, typeCache.GodotGenericArray))
|
|
return MarshalType.GodotGenericArray;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(genericTypeDef, typeCache.SystemGenericDictionary))
|
|
return MarshalType.SystemGenericDictionary;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(genericTypeDef, typeCache.SystemGenericList))
|
|
return MarshalType.SystemGenericList;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(genericTypeDef, typeCache.GenericIDictionary))
|
|
return MarshalType.GenericIDictionary;
|
|
|
|
return genericTypeDef.SpecialType switch
|
|
{
|
|
SpecialType.System_Collections_Generic_ICollection_T => MarshalType.GenericICollection,
|
|
SpecialType.System_Collections_Generic_IEnumerable_T => MarshalType.GenericIEnumerable,
|
|
_ => null
|
|
};
|
|
}
|
|
else
|
|
{
|
|
if (type.SimpleDerivesFrom(typeCache.GodotObjectType))
|
|
return MarshalType.GodotObjectOrDerived;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(type, typeCache.IDictionary))
|
|
return MarshalType.IDictionary;
|
|
|
|
if (SymbolEqualityComparer.Default.Equals(type, typeCache.ICollection))
|
|
return MarshalType.ICollection;
|
|
|
|
if (specialType == SpecialType.System_Collections_IEnumerable)
|
|
return MarshalType.IEnumerable;
|
|
|
|
if (type.ContainingAssembly.Name == "GodotSharp")
|
|
{
|
|
switch (type.ContainingNamespace.Name)
|
|
{
|
|
case "Godot":
|
|
return type switch
|
|
{
|
|
{ Name: "StringName" } => MarshalType.StringName,
|
|
{ Name: "NodePath" } => MarshalType.NodePath,
|
|
_ => null
|
|
};
|
|
case "Collections"
|
|
when !(type is INamedTypeSymbol { IsGenericType: true }) &&
|
|
type.ContainingNamespace.FullQualifiedName() ==
|
|
"Godot.Collections":
|
|
return type switch
|
|
{
|
|
{ Name: "Dictionary" } => MarshalType.GodotDictionary,
|
|
{ Name: "Array" } => MarshalType.GodotArray,
|
|
_ => null
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static bool SimpleDerivesFrom(this ITypeSymbol? type, ITypeSymbol candidateBaseType)
|
|
{
|
|
while (type != null)
|
|
{
|
|
if (SymbolEqualityComparer.Default.Equals(type, candidateBaseType))
|
|
return true;
|
|
|
|
type = type.BaseType;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static ITypeSymbol? GetArrayElementType(ITypeSymbol typeSymbol)
|
|
{
|
|
if (typeSymbol.TypeKind == TypeKind.Array)
|
|
{
|
|
var arrayType = (IArrayTypeSymbol)typeSymbol;
|
|
return arrayType.ElementType;
|
|
}
|
|
|
|
if (typeSymbol is INamedTypeSymbol { IsGenericType: true } genericType)
|
|
return genericType.TypeArguments.FirstOrDefault();
|
|
|
|
return null;
|
|
}
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b)
|
|
=> source.Append(a).Append(b);
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b, string c)
|
|
=> source.Append(a).Append(b).Append(c);
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b,
|
|
string c, string d)
|
|
=> source.Append(a).Append(b).Append(c).Append(d);
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b,
|
|
string c, string d, string e)
|
|
=> source.Append(a).Append(b).Append(c).Append(d).Append(e);
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b,
|
|
string c, string d, string e, string f)
|
|
=> source.Append(a).Append(b).Append(c).Append(d).Append(e).Append(f);
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b,
|
|
string c, string d, string e, string f, string g)
|
|
=> source.Append(a).Append(b).Append(c).Append(d).Append(e).Append(f).Append(g);
|
|
|
|
private static StringBuilder Append(this StringBuilder source, string a, string b,
|
|
string c, string d, string e, string f, string g, string h)
|
|
=> source.Append(a).Append(b).Append(c).Append(d).Append(e).Append(f).Append(g).Append(h);
|
|
|
|
private const string VariantUtils = "global::Godot.NativeInterop.VariantUtils";
|
|
|
|
public static StringBuilder AppendVariantToManagedExpr(this StringBuilder source,
|
|
string inputExpr, ITypeSymbol typeSymbol, MarshalType marshalType)
|
|
{
|
|
return marshalType switch
|
|
{
|
|
MarshalType.Boolean =>
|
|
source.Append(VariantUtils, ".ConvertToBool(", inputExpr, ")"),
|
|
MarshalType.Char =>
|
|
source.Append("(char)", VariantUtils, ".ConvertToUInt16(", inputExpr, ")"),
|
|
MarshalType.SByte =>
|
|
source.Append(VariantUtils, ".ConvertToInt8(", inputExpr, ")"),
|
|
MarshalType.Int16 =>
|
|
source.Append(VariantUtils, ".ConvertToInt16(", inputExpr, ")"),
|
|
MarshalType.Int32 =>
|
|
source.Append(VariantUtils, ".ConvertToInt32(", inputExpr, ")"),
|
|
MarshalType.Int64 =>
|
|
source.Append(VariantUtils, ".ConvertToInt64(", inputExpr, ")"),
|
|
MarshalType.Byte =>
|
|
source.Append(VariantUtils, ".ConvertToUInt8(", inputExpr, ")"),
|
|
MarshalType.UInt16 =>
|
|
source.Append(VariantUtils, ".ConvertToUInt16(", inputExpr, ")"),
|
|
MarshalType.UInt32 =>
|
|
source.Append(VariantUtils, ".ConvertToUInt32(", inputExpr, ")"),
|
|
MarshalType.UInt64 =>
|
|
source.Append(VariantUtils, ".ConvertToUInt64(", inputExpr, ")"),
|
|
MarshalType.Single =>
|
|
source.Append(VariantUtils, ".ConvertToFloat32(", inputExpr, ")"),
|
|
MarshalType.Double =>
|
|
source.Append(VariantUtils, ".ConvertToFloat64(", inputExpr, ")"),
|
|
MarshalType.String =>
|
|
source.Append(VariantUtils, ".ConvertToStringObject(", inputExpr, ")"),
|
|
MarshalType.Vector2 =>
|
|
source.Append(VariantUtils, ".ConvertToVector2(", inputExpr, ")"),
|
|
MarshalType.Vector2i =>
|
|
source.Append(VariantUtils, ".ConvertToVector2i(", inputExpr, ")"),
|
|
MarshalType.Rect2 =>
|
|
source.Append(VariantUtils, ".ConvertToRect2(", inputExpr, ")"),
|
|
MarshalType.Rect2i =>
|
|
source.Append(VariantUtils, ".ConvertToRect2i(", inputExpr, ")"),
|
|
MarshalType.Transform2D =>
|
|
source.Append(VariantUtils, ".ConvertToTransform2D(", inputExpr, ")"),
|
|
MarshalType.Vector3 =>
|
|
source.Append(VariantUtils, ".ConvertToVector3(", inputExpr, ")"),
|
|
MarshalType.Vector3i =>
|
|
source.Append(VariantUtils, ".ConvertToVector3i(", inputExpr, ")"),
|
|
MarshalType.Basis =>
|
|
source.Append(VariantUtils, ".ConvertToBasis(", inputExpr, ")"),
|
|
MarshalType.Quaternion =>
|
|
source.Append(VariantUtils, ".ConvertToQuaternion(", inputExpr, ")"),
|
|
MarshalType.Transform3D =>
|
|
source.Append(VariantUtils, ".ConvertToTransform3D(", inputExpr, ")"),
|
|
MarshalType.Vector4 =>
|
|
source.Append(VariantUtils, ".ConvertToVector4(", inputExpr, ")"),
|
|
MarshalType.Vector4i =>
|
|
source.Append(VariantUtils, ".ConvertToVector4i(", inputExpr, ")"),
|
|
MarshalType.Projection =>
|
|
source.Append(VariantUtils, ".ConvertToProjection(", inputExpr, ")"),
|
|
MarshalType.AABB =>
|
|
source.Append(VariantUtils, ".ConvertToAABB(", inputExpr, ")"),
|
|
MarshalType.Color =>
|
|
source.Append(VariantUtils, ".ConvertToColor(", inputExpr, ")"),
|
|
MarshalType.Plane =>
|
|
source.Append(VariantUtils, ".ConvertToPlane(", inputExpr, ")"),
|
|
MarshalType.Callable =>
|
|
source.Append(VariantUtils, ".ConvertToCallableManaged(", inputExpr, ")"),
|
|
MarshalType.SignalInfo =>
|
|
source.Append(VariantUtils, ".ConvertToSignalInfo(", inputExpr, ")"),
|
|
MarshalType.Enum =>
|
|
source.Append("(", typeSymbol.FullQualifiedName(),
|
|
")", VariantUtils, ".ConvertToInt32(", inputExpr, ")"),
|
|
MarshalType.ByteArray =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedByteArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.Int32Array =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedInt32ArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.Int64Array =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedInt64ArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.Float32Array =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedFloat32ArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.Float64Array =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedFloat64ArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.StringArray =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedStringArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.Vector2Array =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedVector2ArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.Vector3Array =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedVector3ArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.ColorArray =>
|
|
source.Append(VariantUtils, ".ConvertAsPackedColorArrayToSystemArray(", inputExpr, ")"),
|
|
MarshalType.GodotObjectOrDerivedArray =>
|
|
source.Append(VariantUtils, ".ConvertToSystemArrayOfGodotObject<",
|
|
((IArrayTypeSymbol)typeSymbol).ElementType.FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.SystemArrayOfSupportedType =>
|
|
source.Append(VariantUtils, ".ConvertToSystemArrayOfSupportedType<",
|
|
((IArrayTypeSymbol)typeSymbol).ElementType.FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.GodotGenericDictionary =>
|
|
source.Append(VariantUtils, ".ConvertToGenericDictionaryObject<",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[0].FullQualifiedName(), ", ",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[1].FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.GodotGenericArray =>
|
|
source.Append(VariantUtils, ".ConvertToGenericArrayObject<",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[0].FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.SystemGenericDictionary =>
|
|
source.Append(VariantUtils, ".ConvertToSystemGenericDictionary<",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[0].FullQualifiedName(), ", ",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[1].FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.SystemGenericList =>
|
|
source.Append(VariantUtils, ".ConvertToSystemGenericList<",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[0].FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.GenericIDictionary =>
|
|
source.Append(VariantUtils, ".ConvertToGenericDictionaryObject<",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[0].FullQualifiedName(), ", ",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[1].FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.GenericICollection or MarshalType.GenericIEnumerable =>
|
|
source.Append(VariantUtils, ".ConvertToGenericArrayObject<",
|
|
((INamedTypeSymbol)typeSymbol).TypeArguments[0].FullQualifiedName(), ">(", inputExpr, ")"),
|
|
MarshalType.Variant =>
|
|
source.Append("global::Godot.Variant.CreateCopyingBorrowed(", inputExpr, ")"),
|
|
MarshalType.GodotObjectOrDerived =>
|
|
source.Append("(", typeSymbol.FullQualifiedName(),
|
|
")", VariantUtils, ".ConvertToGodotObject(", inputExpr, ")"),
|
|
MarshalType.StringName =>
|
|
source.Append(VariantUtils, ".ConvertToStringNameObject(", inputExpr, ")"),
|
|
MarshalType.NodePath =>
|
|
source.Append(VariantUtils, ".ConvertToNodePathObject(", inputExpr, ")"),
|
|
MarshalType.RID =>
|
|
source.Append(VariantUtils, ".ConvertToRID(", inputExpr, ")"),
|
|
MarshalType.GodotDictionary =>
|
|
source.Append(VariantUtils, ".ConvertToDictionaryObject(", inputExpr, ")"),
|
|
MarshalType.GodotArray =>
|
|
source.Append(VariantUtils, ".ConvertToArrayObject(", inputExpr, ")"),
|
|
MarshalType.IDictionary =>
|
|
source.Append(VariantUtils, ".ConvertToDictionaryObject(", inputExpr, ")"),
|
|
MarshalType.ICollection or MarshalType.IEnumerable =>
|
|
source.Append(VariantUtils, ".ConvertToArrayObject(", inputExpr, ")"),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(marshalType), marshalType,
|
|
"Received unexpected marshal type")
|
|
};
|
|
}
|
|
|
|
public static StringBuilder AppendManagedToVariantExpr(
|
|
this StringBuilder source, string inputExpr, MarshalType marshalType)
|
|
{
|
|
return marshalType switch
|
|
{
|
|
MarshalType.Boolean =>
|
|
source.Append(VariantUtils, ".CreateFromBool(", inputExpr, ")"),
|
|
MarshalType.Char =>
|
|
source.Append(VariantUtils, ".CreateFromInt((ushort)", inputExpr, ")"),
|
|
MarshalType.SByte =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.Int16 =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.Int32 =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.Int64 =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.Byte =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.UInt16 =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.UInt32 =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.UInt64 =>
|
|
source.Append(VariantUtils, ".CreateFromInt(", inputExpr, ")"),
|
|
MarshalType.Single =>
|
|
source.Append(VariantUtils, ".CreateFromFloat(", inputExpr, ")"),
|
|
MarshalType.Double =>
|
|
source.Append(VariantUtils, ".CreateFromFloat(", inputExpr, ")"),
|
|
MarshalType.String =>
|
|
source.Append(VariantUtils, ".CreateFromString(", inputExpr, ")"),
|
|
MarshalType.Vector2 =>
|
|
source.Append(VariantUtils, ".CreateFromVector2(", inputExpr, ")"),
|
|
MarshalType.Vector2i =>
|
|
source.Append(VariantUtils, ".CreateFromVector2i(", inputExpr, ")"),
|
|
MarshalType.Rect2 =>
|
|
source.Append(VariantUtils, ".CreateFromRect2(", inputExpr, ")"),
|
|
MarshalType.Rect2i =>
|
|
source.Append(VariantUtils, ".CreateFromRect2i(", inputExpr, ")"),
|
|
MarshalType.Transform2D =>
|
|
source.Append(VariantUtils, ".CreateFromTransform2D(", inputExpr, ")"),
|
|
MarshalType.Vector3 =>
|
|
source.Append(VariantUtils, ".CreateFromVector3(", inputExpr, ")"),
|
|
MarshalType.Vector3i =>
|
|
source.Append(VariantUtils, ".CreateFromVector3i(", inputExpr, ")"),
|
|
MarshalType.Basis =>
|
|
source.Append(VariantUtils, ".CreateFromBasis(", inputExpr, ")"),
|
|
MarshalType.Quaternion =>
|
|
source.Append(VariantUtils, ".CreateFromQuaternion(", inputExpr, ")"),
|
|
MarshalType.Transform3D =>
|
|
source.Append(VariantUtils, ".CreateFromTransform3D(", inputExpr, ")"),
|
|
MarshalType.Vector4 =>
|
|
source.Append(VariantUtils, ".CreateFromVector4(", inputExpr, ")"),
|
|
MarshalType.Vector4i =>
|
|
source.Append(VariantUtils, ".CreateFromVector4i(", inputExpr, ")"),
|
|
MarshalType.Projection =>
|
|
source.Append(VariantUtils, ".CreateFromProjection(", inputExpr, ")"),
|
|
MarshalType.AABB =>
|
|
source.Append(VariantUtils, ".CreateFromAABB(", inputExpr, ")"),
|
|
MarshalType.Color =>
|
|
source.Append(VariantUtils, ".CreateFromColor(", inputExpr, ")"),
|
|
MarshalType.Plane =>
|
|
source.Append(VariantUtils, ".CreateFromPlane(", inputExpr, ")"),
|
|
MarshalType.Callable =>
|
|
source.Append(VariantUtils, ".CreateFromCallable(", inputExpr, ")"),
|
|
MarshalType.SignalInfo =>
|
|
source.Append(VariantUtils, ".CreateFromSignalInfo(", inputExpr, ")"),
|
|
MarshalType.Enum =>
|
|
source.Append(VariantUtils, ".CreateFromInt((int)", inputExpr, ")"),
|
|
MarshalType.ByteArray =>
|
|
source.Append(VariantUtils, ".CreateFromPackedByteArray(", inputExpr, ")"),
|
|
MarshalType.Int32Array =>
|
|
source.Append(VariantUtils, ".CreateFromPackedInt32Array(", inputExpr, ")"),
|
|
MarshalType.Int64Array =>
|
|
source.Append(VariantUtils, ".CreateFromPackedInt64Array(", inputExpr, ")"),
|
|
MarshalType.Float32Array =>
|
|
source.Append(VariantUtils, ".CreateFromPackedFloat32Array(", inputExpr, ")"),
|
|
MarshalType.Float64Array =>
|
|
source.Append(VariantUtils, ".CreateFromPackedFloat64Array(", inputExpr, ")"),
|
|
MarshalType.StringArray =>
|
|
source.Append(VariantUtils, ".CreateFromPackedStringArray(", inputExpr, ")"),
|
|
MarshalType.Vector2Array =>
|
|
source.Append(VariantUtils, ".CreateFromPackedVector2Array(", inputExpr, ")"),
|
|
MarshalType.Vector3Array =>
|
|
source.Append(VariantUtils, ".CreateFromPackedVector3Array(", inputExpr, ")"),
|
|
MarshalType.ColorArray =>
|
|
source.Append(VariantUtils, ".CreateFromPackedColorArray(", inputExpr, ")"),
|
|
MarshalType.GodotObjectOrDerivedArray =>
|
|
source.Append(VariantUtils, ".CreateFromSystemArrayOfGodotObject(", inputExpr, ")"),
|
|
MarshalType.SystemArrayOfSupportedType =>
|
|
source.Append(VariantUtils, ".CreateFromSystemArrayOfSupportedType(", inputExpr, ")"),
|
|
MarshalType.GodotGenericDictionary =>
|
|
source.Append(VariantUtils, ".CreateFromDictionary(", inputExpr, ")"),
|
|
MarshalType.GodotGenericArray =>
|
|
source.Append(VariantUtils, ".CreateFromArray(", inputExpr, ")"),
|
|
MarshalType.SystemGenericDictionary =>
|
|
source.Append(VariantUtils, ".CreateFromSystemDictionary(", inputExpr, ")"),
|
|
MarshalType.SystemGenericList =>
|
|
source.Append(VariantUtils, ".CreateFromSystemICollection(", inputExpr, ")"),
|
|
MarshalType.GenericIDictionary =>
|
|
source.Append(VariantUtils, ".CreateFromSystemGenericIDictionary(", inputExpr, ")"),
|
|
MarshalType.GenericICollection =>
|
|
source.Append(VariantUtils, ".CreateFromSystemGenericICollection(", inputExpr, ")"),
|
|
MarshalType.GenericIEnumerable =>
|
|
source.Append(VariantUtils, ".CreateFromSystemGenericIEnumerable(", inputExpr, ")"),
|
|
MarshalType.Variant =>
|
|
source.Append(inputExpr, ".CopyNativeVariant()"),
|
|
MarshalType.GodotObjectOrDerived =>
|
|
source.Append(VariantUtils, ".CreateFromGodotObject(", inputExpr, ")"),
|
|
MarshalType.StringName =>
|
|
source.Append(VariantUtils, ".CreateFromStringName(", inputExpr, ")"),
|
|
MarshalType.NodePath =>
|
|
source.Append(VariantUtils, ".CreateFromNodePath(", inputExpr, ")"),
|
|
MarshalType.RID =>
|
|
source.Append(VariantUtils, ".CreateFromRID(", inputExpr, ")"),
|
|
MarshalType.GodotDictionary =>
|
|
source.Append(VariantUtils, ".CreateFromDictionary(", inputExpr, ")"),
|
|
MarshalType.GodotArray =>
|
|
source.Append(VariantUtils, ".CreateFromArray(", inputExpr, ")"),
|
|
MarshalType.IDictionary =>
|
|
source.Append(VariantUtils, ".CreateFromSystemIDictionary(", inputExpr, ")"),
|
|
MarshalType.ICollection =>
|
|
source.Append(VariantUtils, ".CreateFromSystemICollection(", inputExpr, ")"),
|
|
MarshalType.IEnumerable =>
|
|
source.Append(VariantUtils, ".CreateFromSystemIEnumerable(", inputExpr, ")"),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(marshalType), marshalType,
|
|
"Received unexpected marshal type")
|
|
};
|
|
}
|
|
}
|
|
}
|