public void WhenFields()
{
var code = @"public class ClassT { public int x, y; }";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.Empty(types["ClassT"].Interfaces);
}
public void WhenOutGenericInterfaceInClassBSyncMethod()
{
var code = @"
using Norns.Destiny.Attributes;
public class B
{
[Charon]
public interface IJitDB<out T> where T : class
{
T A();
}
public class A
{
[Charon]
public interface IJitDA<out T> where T : class
{
T A();
}
}
}";
var typeName = "IJitDB`1";
var instance = SkuldTest.GenerateProxy(code, typeName, new Type[] { typeof(DataBase) });
Assert.Null(instance.A());
typeName = "IJitDA`1";
var instance2 = SkuldTest.GenerateProxy(code, typeName, new Type[] { typeof(DataBase) });
Assert.Null(instance2.A());
}
public void WhenIsAnonymousType()
{
var code = "public static class StaticClass { void A() { var a = new {}; var b = new { A = 9}; } } ";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.False(types["StaticClass"].IsAnonymousType);
}
public void IsGenericTypeWhenIA()
{
var code = @"public class PublicClass
{ } public class IA<out T> where T : PublicClass, new()
{
public T A() => new IA<PublicClass>();
}
";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code, false);
var iaTypeDefinition = types["Norns.Destiny.UT.AOT.Generated.IA<T>"];
Assert.True(iaTypeDefinition.IsGenericType);
Assert.Single(iaTypeDefinition.TypeArguments);
Assert.Single(iaTypeDefinition.TypeParameters);
var tp = iaTypeDefinition.TypeParameters.First();
Assert.Equal(0, tp.Ordinal);
Assert.Equal("T", tp.Name);
Assert.Equal(RefKindInfo.Out, tp.RefKind);
Assert.True(tp.HasConstructorConstraint);
Assert.False(tp.HasReferenceTypeConstraint);
Assert.False(tp.HasValueTypeConstraint);
Assert.Single(tp.ConstraintTypes);
var tpc = tp.ConstraintTypes.First();
Assert.Equal("PublicClass", tpc.Name);
}
public void WhenNameAndNamespace()
{
var code = "public class ADD { } ";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.Equal("Norns.Destiny.UT.AOT.Generated", types["ADD"].Namespace);
}
public void AccessibilityWhenNestedClass()
{
var code = @"public abstract class AbstractPublicClass
{
private class PrivateClass
{ }
private protected class ProtectedPrivateClass
{ }
protected class ProtectedClass
{ }
internal class InternalClass
{ }
protected internal class ProtectedInternalClass
{ }
public class PublicClass
{ }
}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.Equal(AccessibilityInfo.Private, types["PrivateClass"].Accessibility);
Assert.Equal(AccessibilityInfo.Protected, types["ProtectedClass"].Accessibility);
Assert.Equal(AccessibilityInfo.Internal, types["InternalClass"].Accessibility);
Assert.Equal(AccessibilityInfo.ProtectedOrInternal, types["ProtectedInternalClass"].Accessibility);
Assert.Equal(AccessibilityInfo.ProtectedAndInternal, types["ProtectedPrivateClass"].Accessibility);
Assert.Equal(AccessibilityInfo.Public, types["PublicClass"].Accessibility);
}
public void AccessibilityWhenNormalClass()
{
var code = "public class PublicClass {} internal class InternalClass{}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.Equal(AccessibilityInfo.Internal, types["InternalClass"].Accessibility);
Assert.Equal(AccessibilityInfo.Public, types["PublicClass"].Accessibility);
}
public void WhenIsSealed()
{
var code = "public sealed class SealedClass { } public class NonSealedClass { }";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.True(types["SealedClass"].IsSealed);
Assert.False(types["NonSealedClass"].IsSealed);
}
public void WhenIsValueType()
{
var code = "public struct MyStruct { } public class ClassT { }";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.True(types["MyStruct"].IsValueType);
Assert.False(types["ClassT"].IsValueType);
}
public void WhenIsAbstract()
{
var code = "public abstract class AbstractClass { } public class NonAbstractClass { }";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.True(types["AbstractClass"].IsAbstract);
Assert.False(types["NonAbstractClass"].IsAbstract);
}
public void WhenIsStatic()
{
var code = "public static class StaticClass {} class NonStaticClass{}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.True(types["StaticClass"].IsStatic);
Assert.False(types["NonStaticClass"].IsStatic);
}
public async Task WhenSimpleInterfaceAndSomeMethods()
{
var code = @"
using System.Collections.Generic;
using System.Threading.Tasks;
using Norns.Destiny.Attributes;
[Charon]
public interface IJitC
{
int AddOne(int v);
void AddVoid();
Task AddTask(int v);
Task<int> AddVTask(int v);
ValueTask<int> AddValueTask(int v);
ValueTask<T> AddValueTask<T>(T v);
ValueTask<Task<T>> AddValueTask<T, V>(T v, V v1) where T : struct where V : class, IJitC;
IEnumerable<T> AddValue1<T, V>(T v, ref V v1);
IEnumerable<T> AddValue2<T, V>(T v, in V v1);
IEnumerable<T> AddValue3<T, V>(T v, out V v1);
public int A() => 3;
int PA { get; set; }
int PD { set; }
string this[int v, string s] { get; set; }
}";
var typeName = "IJitC";
var instance = SkuldTest.GenerateProxy(code, typeName);
Assert.Equal(5, instance.AddOne(33));
instance.AddVoid();
await instance.AddTask(66);
Assert.Equal(0, await instance.AddVTask(44));
Assert.Equal(0, await instance.AddValueTask(11));
Assert.Null(await instance.AddValueTask(this));
Assert.Null(await instance.AddValueTask(new A(), instance));
Assert.Equal(-5, instance.PA);
instance.PD = 55;
Assert.Null(instance[3, ""]);
var c = instance;
Assert.Null(instance.AddValue1(new A(), ref c));
//Assert.Null(instance.AddValue2(new A(), in c));
Assert.Null(instance.AddValue3(new A(), out c));
Assert.Equal(8, instance.A());
}
public void WhenBaseType()
{
var code = @"public class ClassT { } public struct A {} interface IB {}
public class C : ClassT {}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.Equal(nameof(Object), types["ClassT"].BaseType.Name);
Assert.Equal("ClassT", types["C"].BaseType.Name);
Assert.Equal("ValueType", types["A"].BaseType.Name);
Assert.Null(types["IB"].BaseType);
}
public void WhenInterfaces()
{
var code = @"public class ClassT { } public struct A {} interface IB {}
public class C : IB {}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.Empty(types["ClassT"].Interfaces);
Assert.Single(types["C"].Interfaces);
Assert.Equal("IB", types["C"].Interfaces.First().Name);
Assert.Empty(types["A"].Interfaces);
Assert.Empty(types["IB"].Interfaces);
Assert.True(types["IB"].IsInterface);
}
public void WhenIsGenericType()
{
var code = @"public class ClassT { }
public class GenericClass<T> where T : ClassT, new()
{
public T A() => default;
}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
Assert.True(types["GenericClass"].IsGenericType);
Assert.True(types["GenericClass"].IsClass);
Assert.False(types["ClassT"].IsGenericType);
}
public void WhenOutGenericInterfaceSyncMethod()
{
var code = @"
using Norns.Destiny.Attributes;
[Charon]
public interface IJitD<out T> where T : class
{
T A();
}";
var typeName = "IJitD`1";
var instance = SkuldTest.GenerateProxy(code, typeName, new Type[] { typeof(DataBase) });
Assert.Null(instance.A());
instance = VerthandiTest.GenerateProxy <IJitD <DataBase> >(typeof(IJitD <>));
Assert.Null(instance.A());
}
public void WhenInheritInterface()
{
var code = @"
using Norns.Destiny.Attributes;
public interface ITest
{
long GiveFive();
}
[Charon]
public interface IJitD : ITest
{
}";
var typeName = "IJitD";
var instance = SkuldTest.GenerateProxy(code, typeName);
Assert.Equal(1, instance.GiveFive());
}
public void WhenInGenericInterfaceSyncMethod()
{
var code = @"
using Norns.Destiny.Attributes;
using Norns.Skuld.Loom;
using Norns.Skuld.AOP;
[Charon]
public interface IJitDIn<in T, V, R> where T : SourceGeneratorBase
{
AopSourceGenerator A();
}
";
var typeName = "IJitDIn`3";
var instance = SkuldTest.GenerateProxy(code, typeName, new Type[] { typeof(SourceGeneratorBase), typeof(int), typeof(long?) });
Assert.Null(instance.A());
}
public void WhenAttribute()
{
var code = @"
using Xunit;
[Collection(""a"")]
public class PublicClass
{ }
}";
var attrs = SkuldTest.SimpleGenerateTypeSymbolInfos(code).First().Value.Attributes;
Assert.Single(attrs);
var a = attrs.First();
Assert.Equal(@"Xunit.CollectionAttribute(""a"")", a.FullName);
Assert.Equal(@"Xunit.CollectionAttribute", a.AttributeType.FullName);
Assert.Single(a.ConstructorArguments);
var ca = a.ConstructorArguments.First();
Assert.Equal("a", ca.Value);
}
public void WhenNestedAbstractClassSyncMethod()
{
var code = @"
using Norns.Destiny.Attributes;
using Norns.Skuld.Loom;
using Norns.Skuld.AOP;
public class B
{
public class A
{
[Charon]
public abstract class JitCClassA<T, V, R> where T : class
{
public abstract (T, V, R) A();
}
}
[Charon]
public abstract class JitCClassB<T, V, R> where T : class
{
public abstract (T, V, R) A();
}
}
";
var typeName = "JitCClassB`3";
var instance = SkuldTest.GenerateProxy(code, typeName, new Type[] { typeof(Data), typeof(long), typeof(short) });
var r = instance.A();
Assert.Null(r.Item1);
Assert.Equal(0L, r.Item2);
Assert.Equal(0, r.Item3);
typeName = "JitCClassA`3";
var instance1 = SkuldTest.GenerateProxy(code, typeName, new Type[] { typeof(Data), typeof(long), typeof(int) });
var r1 = instance1.A();
Assert.Null(r1.Item1);
Assert.Equal(0L, r1.Item2);
Assert.Equal(0, r1.Item3);
}
public void MethodWhenHasReturnValue()
{
var code = @"
using System.Threading.Tasks;
public interface IC
{
int AddOne(int v);
void AddVoid(int v);
Task AddTask(int v);
Task<int> AddVTask(int v);
ValueTask<int> AddValueTask(int v);
}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
var ms = types["IC"].Members
.Select(i => i as IMethodSymbolInfo)
.Where(i => i != null)
.ToDictionary(i => i.FullName, i => i);
var m = ms["Norns.Destiny.UT.AOT.Generated.IC.AddOne(int)"];
Assert.True(m.HasReturnValue);
Assert.False(m.IsAsync);
m = ms["Norns.Destiny.UT.AOT.Generated.IC.AddVoid(int)"];
Assert.False(m.HasReturnValue);
Assert.False(m.IsAsync);
m = ms["Norns.Destiny.UT.AOT.Generated.IC.AddTask(int)"];
Assert.False(m.HasReturnValue);
Assert.True(m.IsAsync);
m = ms["Norns.Destiny.UT.AOT.Generated.IC.AddVTask(int)"];
Assert.True(m.HasReturnValue);
Assert.True(m.IsAsync);
m = ms["Norns.Destiny.UT.AOT.Generated.IC.AddValueTask(int)"];
Assert.True(m.HasReturnValue);
Assert.True(m.IsAsync);
}
public void WhenStructFields()
{
var code = @"public unsafe struct StructFieldTest
{
internal fixed char name[30];
}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
var fields = types["StructFieldTest"].Members
.Select(i => i as IFieldSymbolInfo)
.Where(i => i != null)
.ToDictionary(i => i.Name, i => i);
Assert.Single(fields);
var f = fields["name"];
Assert.False(f.HasConstantValue);
Assert.False(f.IsConst);
Assert.False(f.IsReadOnly);
Assert.False(f.IsVolatile);
Assert.True(f.IsFixedSizeBuffer);
Assert.False(f.IsStatic);
Assert.Equal(AccessibilityInfo.Internal, f.Accessibility);
}
private static void CompareType(Type type)
{
var aot = SkuldTest.GetTypeByMetadataName(type.FullName);
var jit = type.GetSymbolInfo();
Assert.NotEqual(aot.Origin, jit.Origin);
Assert.Equal(aot.Name, jit.Name);
Assert.Equal(aot.FullName, jit.FullName);
Assert.Equal(aot.Namespace, jit.Namespace);
Assert.Equal(aot.IsAbstract, jit.IsAbstract);
Assert.Equal(aot.IsSealed, jit.IsSealed);
Assert.Equal(aot.IsValueType, jit.IsValueType);
Assert.Equal(aot.IsGenericType, jit.IsGenericType);
Assert.Equal(aot.IsAnonymousType, jit.IsAnonymousType);
Assert.Equal(aot.IsClass, jit.IsClass);
Assert.Equal(aot.IsInterface, jit.IsInterface);
Assert.Equal(aot.IsStatic, jit.IsStatic);
Assert.Equal(aot.Accessibility, jit.Accessibility);
Assert.Equal(aot.GenericDefinitionName, jit.GenericDefinitionName);
Assert.Equal(aot.TypeArguments.IsEmpty, jit.TypeArguments.IsEmpty);
Assert.Equal(aot.TypeParameters.IsEmpty, jit.TypeParameters.IsEmpty);
Assert.Equal(aot.BaseType, jit.BaseType);
Assert.Equal(aot.Interfaces.Count, jit.Interfaces.Count);
}
public string Generate(string code)
{
var collector = new DefaultImplementNotationGeneratorCollector();
return(SkuldTest.GenerateCode($"namespace Norns.Destiny.UT.AOT.Generated {{ {code} }}", collector));
}
public void WhenClassFields()
{
var code = @"public class FieldTest
{
public const int A = 3;
internal static readonly string B = ""3"";
protected volatile string C;
protected internal long D;
private protected long E;
private long F;
}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
var fields = types["FieldTest"].Members
.Select(i => i as IFieldSymbolInfo)
.Where(i => i != null)
.ToDictionary(i => i.Name, i => i);
Assert.Equal(6, fields.Count);
var f = fields["A"];
Assert.Equal(3, f.ConstantValue);
Assert.True(f.IsConst);
Assert.False(f.IsReadOnly);
Assert.False(f.IsVolatile);
Assert.False(f.IsFixedSizeBuffer);
Assert.True(f.HasConstantValue);
Assert.True(f.IsStatic);
Assert.Equal(AccessibilityInfo.Public, f.Accessibility);
f = fields["B"];
Assert.False(f.HasConstantValue);
Assert.False(f.IsConst);
Assert.True(f.IsReadOnly);
Assert.False(f.IsVolatile);
Assert.False(f.IsFixedSizeBuffer);
Assert.True(f.IsStatic);
Assert.Equal(AccessibilityInfo.Internal, f.Accessibility);
f = fields["C"];
Assert.False(f.HasConstantValue);
Assert.False(f.IsConst);
Assert.False(f.IsReadOnly);
Assert.True(f.IsVolatile);
Assert.False(f.IsFixedSizeBuffer);
Assert.False(f.IsStatic);
Assert.Equal(AccessibilityInfo.Protected, f.Accessibility);
f = fields["D"];
Assert.False(f.HasConstantValue);
Assert.False(f.IsConst);
Assert.False(f.IsReadOnly);
Assert.False(f.IsVolatile);
Assert.False(f.IsFixedSizeBuffer);
Assert.False(f.IsStatic);
Assert.Equal(AccessibilityInfo.ProtectedOrInternal, f.Accessibility);
f = fields["E"];
Assert.False(f.HasConstantValue);
Assert.False(f.IsConst);
Assert.False(f.IsReadOnly);
Assert.False(f.IsVolatile);
Assert.False(f.IsFixedSizeBuffer);
Assert.False(f.IsStatic);
Assert.Equal(AccessibilityInfo.ProtectedAndInternal, f.Accessibility);
f = fields["F"];
Assert.False(f.HasConstantValue);
Assert.False(f.IsConst);
Assert.False(f.IsReadOnly);
Assert.False(f.IsVolatile);
Assert.False(f.IsFixedSizeBuffer);
Assert.False(f.IsStatic);
Assert.Equal(AccessibilityInfo.Private, f.Accessibility);
}
public void WhenMethods()
{
var code = @"
public static class Sta
{
public static int A(this int d) => d;
}
public abstract class A
{
private void PrivateM()
{
}
internal int InternalM()
{
return default;
}
protected virtual (int v, long s) ProtectedM()
{
return default;
}
protected internal abstract string PIS();
protected private string PPS()
{
return default;
}
public T GetT<T>() where T : class
{
return default;
}
public Task GetTask()
{
return default;
}
public override string ToString()
{
return base.ToString();
}
}
public class B : A
{
protected sealed override (int v, long s) ProtectedM()
{
return base.ProtectedM();
}
protected internal override string PIS()
{
return default;
}
public new Task GetTask()
{
return default;
}
}";
var types = SkuldTest.SimpleGenerateTypeSymbolInfos(code);
var ms = types["A"].Members
.Select(i => i as IMethodSymbolInfo)
.Where(i => i != null)
.ToDictionary(i => i.FullName, i => i);
var m = ms["Norns.Destiny.UT.AOT.Generated.A.PrivateM()"];
Assert.Equal(AccessibilityInfo.Private, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("void", m.ReturnType.FullName);
m = ms["Norns.Destiny.UT.AOT.Generated.A.InternalM()"];
Assert.Equal(AccessibilityInfo.Internal, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("int", m.ReturnType.FullName);
m = ms["Norns.Destiny.UT.AOT.Generated.A.ProtectedM()"];
Assert.Equal(AccessibilityInfo.Protected, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.True(m.IsVirtual);
Assert.Equal("ValueTuple", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.A.PIS()"];
Assert.Equal(AccessibilityInfo.ProtectedOrInternal, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.True(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("String", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.A.PPS()"];
Assert.Equal(AccessibilityInfo.ProtectedAndInternal, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("String", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.A.ToString()"];
Assert.Equal(AccessibilityInfo.Public, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.True(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("String", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.A.GetTask()"];
Assert.Equal(AccessibilityInfo.Public, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("Task", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.A.GetT<T>()"];
Assert.Equal(AccessibilityInfo.Public, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.True(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("T", m.ReturnType.Name);
Assert.Single(m.TypeParameters);
Assert.True(m.TypeParameters.First().HasReferenceTypeConstraint);
ms = types["B"].Members
.Select(i => i as IMethodSymbolInfo)
.Where(i => i != null)
.ToDictionary(i => i.FullName, i => i);
m = ms["Norns.Destiny.UT.AOT.Generated.B.ProtectedM()"];
Assert.Equal(AccessibilityInfo.Protected, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.True(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.True(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("ValueTuple", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.B.PIS()"];
Assert.Equal(AccessibilityInfo.ProtectedOrInternal, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.True(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("String", m.ReturnType.Name);
m = ms["Norns.Destiny.UT.AOT.Generated.B.GetTask()"];
Assert.Equal(AccessibilityInfo.Public, m.Accessibility);
Assert.Empty(m.Parameters);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.False(m.IsExtensionMethod);
Assert.False(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("Task", m.ReturnType.Name);
ms = types["Sta"].Members
.Select(i => i as IMethodSymbolInfo)
.Where(i => i != null)
.ToDictionary(i => i.FullName, i => i);
m = ms["Norns.Destiny.UT.AOT.Generated.Sta.A(int)"];
Assert.Equal(AccessibilityInfo.Public, m.Accessibility);
Assert.Empty(m.TypeParameters);
Assert.False(m.IsGenericMethod);
Assert.True(m.IsExtensionMethod);
Assert.True(m.IsStatic);
Assert.False(m.IsSealed);
Assert.False(m.IsAbstract);
Assert.False(m.IsOverride);
Assert.False(m.IsVirtual);
Assert.Equal("Int32", m.ReturnType.Name);
Assert.Single(m.Parameters);
Assert.Equal("d", m.Parameters.First().Name);
}
public async Task WhenAbstractClassAndSomeMethods()
{
var code = @"
using System.Collections.Generic;
using System.Threading.Tasks;
using Norns.Destiny.Attributes;
[Charon]
public abstract class JitCClass
{
public abstract int AddOne(int v);
public abstract void AddVoid();
public abstract Task AddTask(int v);
public abstract Task<int> AddVTask(int v);
public abstract ValueTask<int> AddValueTask(int v);
public abstract ValueTask<T> AddValueTask<T>(T v);
public abstract ValueTask<Task<T>> AddValueTask<T, V>(T v, V v1) where T : struct where V : JitCClass;
public abstract IEnumerable<T> AddValue1<T, V>(T v, ref V v1);
public abstract IEnumerable<T> AddValue2<T, V>(T v, in V v1);
public abstract IEnumerable<T> AddValue3<T, V>(T v, out V v1);
public int A() => 3;
public virtual int B() => 3;
public virtual int PA { get; set; }
public virtual int PD { protected get; set; }
public abstract string this[int v, string s] { get; set; }
}
";
var typeName = "JitCClass";
var instance = SkuldTest.GenerateProxy(code, typeName);
Assert.Equal(5, instance.AddOne(33));
instance.AddVoid();
await instance.AddTask(66);
Assert.Equal(0, await instance.AddVTask(44));
Assert.Equal(0, await instance.AddValueTask(11));
Assert.Null(await instance.AddValueTask(this));
Assert.Null(await instance.AddValueTask(new A(), instance));
Assert.Equal(-5, instance.PA);
instance.PD = 55;
Assert.Null(instance[3, ""]);
var c = instance;
Assert.Null(instance.AddValue1(new A(), ref c));
//Assert.Null(instance.AddValue2(new A(), in c));
Assert.Null(instance.AddValue3(new A(), out c));
Assert.Equal(3, instance.A());
Assert.Equal(8, instance.B());
}
