public static MemberDef FromJson(DeserializationDomain domain, Json.Expression member)
{
if (member is not Json.ArrayExpression info)
{
throw new BonsaiParseException("Expected a JSON array for a member definition.", member);
}
if (info.ElementCount < 1)
{
throw new BonsaiParseException("Expected at least 1 JSON array element for a member definition.", member);
}
var type = info.GetElement(0);
if (type.NodeType != Json.ExpressionType.String)
{
throw new BonsaiParseException("Expected a JSON string in 'node[0]' for the member type discriminator.", member);
}
var kind = (string)((Json.ConstantExpression)type).Value;
return(kind switch
{
Discriminators.MemberInfo.Constructor => GetConstructorDef(domain, info),
Discriminators.MemberInfo.Field => GetFieldDef(domain, info),
Discriminators.MemberInfo.Property => GetPropertyDef(domain, info),
Discriminators.MemberInfo.SimpleMethod => GetSimpleMethodDef(domain, info),
Discriminators.MemberInfo.OpenGenericMethod => GetOpenGenericMethodDef(domain, info),
Discriminators.MemberInfo.ClosedGenericMethod => GetClosedGenericMethodDef(info),
_ => throw new BonsaiParseException(string.Format(CultureInfo.InvariantCulture, "Unexpected member type discriminator '{0}'.", kind), member),
});
public static TypeDef FromJson(DeserializationDomain domain, Json.Expression expression)
{
if (expression is not Json.ArrayExpression type)
{
throw new BonsaiParseException("Expected a JSON array containing a type definition.", expression);
}
if (type.ElementCount == 0)
{
throw new BonsaiParseException("Expected at least one JSON array element containing a type discriminator.", expression);
}
var kind = type.GetElement(0);
if (kind.NodeType != Json.ExpressionType.String)
{
throw new BonsaiParseException("Expected a JSON string at 'node[0]' containing a type discriminator.", expression);
}
var typeDiscriminator = (string)((Json.ConstantExpression)kind).Value;
return(typeDiscriminator switch
{
Discriminators.Type.Simple => SimpleTypeDef.FromJson(type),
Discriminators.Type.Generic => GenericTypeDef.FromJson(type),
Discriminators.Type.Array => ArrayTypeDef.FromJson(type),
Discriminators.Type.Anonymous => AnonymousStructuralTypeDef.FromJson(type),
Discriminators.Type.Record => RecordStructuralTypeDef.FromJson(domain, type),
_ => throw new BonsaiParseException(string.Format(CultureInfo.InvariantCulture, "Unexpected type discriminator '{0}' at 'node[0]'.", typeDiscriminator), expression),
});
public override TypeSlim ToType(DeserializationDomain domain, TypeSlim[] genericArguments)
{
if (_type == null)
{
var def = domain.GetType(_genericTypeDefinition).ToType(domain, genericArguments);
GenericDefinitionTypeSlim genDef;
switch (def.Kind)
{
case TypeSlimKind.Simple:
var simple = (SimpleTypeSlim)def;
genDef = TypeSlim.GenericDefinition(simple.Assembly, simple.Name);
break;
default:
throw new InvalidOperationException("Expected either simple type slim discriminator for generic definition type.");
}
var n = _genericTypeArguments.Length;
var argsList = new TypeSlim[n];
for (var i = 0; i < n; i++)
{
var arg = _genericTypeArguments[i];
var argType = domain.GetType(arg).ToType(domain, genericArguments);
argsList[i] = argType;
}
var args = new TrueReadOnlyCollection <TypeSlim>(/* transfer ownership */ argsList);
_type = TypeSlim.Generic(genDef, args);
}
return(_type);
}
public override TypeSlim ToType(DeserializationDomain domain, params TypeSlim[] genericArguments)
{
if (_type == null)
{
_type = TypeSlim.Simple(domain.GetAssembly(_assembly), _typeName);
}
return(_type);
}
public DeserializationState(Json.Expression state, Version version)
{
_domain = new DeserializationDomain(state);
_params = new Stack <ParameterExpression[]>();
_globals = GetGlobals(state);
_labelTagets = GetLabelTargets(state);
Debug.Assert(_domain.SupportsVersion(version));
}
public override TypeSlim ToType(DeserializationDomain domain, TypeSlim[] genericArguments)
{
if (_type == null)
{
var elementType = domain.GetType(_elementType).ToType(domain, genericArguments);
_type = _rank == null?TypeSlim.Array(elementType) : TypeSlim.Array(elementType, _rank.Value);
}
return(_type);
}
public override TypeSlim ToType(DeserializationDomain domain, params TypeSlim[] genericArguments)
{
if (_type == null)
{
var refType = StructuralTypeSlimReference.Create(hasValueEqualitySemantics: true, Kind, _members.Length);
_type = refType;
foreach (var member in _members)
{
var newPropertyType = domain.GetType(member.Type).ToType(domain, genericArguments);
var newProperty = _type.GetProperty(member.Name, newPropertyType, s_emptyTypeList, member.CanWrite);
refType.AddProperty(newProperty);
}
refType.Freeze();
}
return(_type);
}
public static RecordStructuralTypeDef FromJson(DeserializationDomain domain, Json.ArrayExpression type)
{
if (domain.IsV08)
{
throw new NotSupportedException("Record types are only supported in Bonsai v0.9 or later.");
}
var count = type.ElementCount;
if (count is not 2 and not 3)
{
throw new BonsaiParseException("Expected 2 or 3 JSON array elements for a structural type definition.", type);
}
if (type.GetElement(1) is not Json.ArrayExpression membersJson)
{
throw new BonsaiParseException("Expected a JSON array in 'node[1]' for the structural type members.", type);
}
var membersCount = membersJson.ElementCount;
var members = new RecordStructuralTypeMember[membersCount];
for (var i = 0; i < membersCount; i++)
{
var memberJson = membersJson.GetElement(i);
var member = RecordStructuralTypeMember.FromJson(memberJson);
members[i] = member;
}
var hasValueEqualitySemantics = true;
if (count == 3)
{
var hasValueEqualitySemanticsExpr = type.GetElement(2);
if (hasValueEqualitySemanticsExpr.NodeType != Json.ExpressionType.Boolean)
{
throw new BonsaiParseException("Expected a JSON Boolean in 'node[2]' for the value equality semantics flag.", type);
}
hasValueEqualitySemantics = (bool)((Json.ConstantExpression)hasValueEqualitySemanticsExpr).Value;
}
return(new RecordStructuralTypeDef(hasValueEqualitySemantics, members));
}
public override MemberInfoSlim ToMember(DeserializationDomain domain)
{
// PERF: This is a heavy allocator; should we support caching the result?
var def = ((GenericDefinitionMethodInfoSlim)domain.GetMember(_genericMethodDefinition));
var count = _genericArguments.Length;
var argsList = new TypeSlim[count];
for (var i = 0; i < count; i++)
{
argsList[i] = domain.GetType(_genericArguments[i]).ToType(domain);
}
var args = new TrueReadOnlyCollection <TypeSlim>(/* transfer ownership */ argsList);
return(def.DeclaringType.GetGenericMethod(def, args));
}
public abstract MemberInfoSlim ToMember(DeserializationDomain domain);
public override TypeSlim ToType(DeserializationDomain domain, params TypeSlim[] genericArguments)
{
return(genericArguments[_index]);
}
public override MemberInfoSlim ToMember(DeserializationDomain domain) => Method;
public override MemberInfoSlim ToMember(DeserializationDomain domain) => _constructor;
public override MemberInfoSlim ToMember(DeserializationDomain domain) => _property;
public abstract TypeSlim ToType(DeserializationDomain domain, params TypeSlim[] genericArguments);
