public Name GetCodeIdentifier(Field field)
{
if (_fieldNameMap.TryGetValue(field, out var name))
{
return(name);
}
var def = field.DeclaringType;
if (def == null)
{
// Method parameters are internally represented with the same class "Field".
// They do not have a declaring type. Anyway, they don't suffer from the field-name-equals-nested-type-name problem.
return(new Name(SyntaxHelpers.MakeCamel(field.Name)));
}
var typeNames = new HashSet <Name>(def.NestedTypes.Select(t => MakeTypeName(t)));
typeNames.Add(MakeTypeName(def));
foreach (var member in def.Fields)
{
var memberName = new Name(SyntaxHelpers.MakeCamel(member.Name));
while (typeNames.Contains(memberName))
{
memberName = new Name(string.Format(PropertyNamedLikeTypeRenameFormat, memberName.ToString()));
}
_fieldNameMap.Add(member, memberName);
}
return(_fieldNameMap[field]);
}
public TypeSyntax Type <T>(Nullability nullability)
{
return((NullableEnable && !typeof(T).IsValueType && nullability != Nullability.NonNullable) ||
(typeof(T).IsValueType && nullability == Nullability.NullableRefAndValue) ?
NullableType(SyntaxHelpers.NonNullableType <T>()) :
SyntaxHelpers.NonNullableType <T>());
}
public Name MakeTypeName(TypeDefinition def, NameUsage usage = NameUsage.Default)
{
if (def.Tag == TypeTag.Group)
{
return(new Name(SyntaxHelpers.MakeAllLower(def.Name)));
}
else
{
string name;
switch (usage)
{
case NameUsage.Default:
if (def.Tag == TypeTag.Interface)
{
goto case NameUsage.Interface;
}
switch (def.SpecialName)
{
case SpecialName.NothingSpecial:
name = def.Name;
break;
case SpecialName.MethodParamsStruct:
name = MakeParamsStructName(def.UsingMethod);
break;
case SpecialName.MethodResultStruct:
name = MakeResultStructName(def.UsingMethod);
break;
default:
throw new NotImplementedException();
}
break;
case NameUsage.Namespace:
name = def.Name;
break;
case NameUsage.Interface:
name = "I" + def.Name;
break;
case NameUsage.Proxy:
name = string.Format(ProxyClassFormat, def.Name);
break;
case NameUsage.Skeleton:
name = string.Format(SkeletonClassFormat, def.Name);
break;
default:
throw new NotImplementedException();
}
return(new Name(name));
}
}
MemberDeclarationSyntax MakeUnionContentField()
{
return(FieldDeclaration(
VariableDeclaration(SyntaxHelpers.Type <object>())
.WithVariables(
SingletonSeparatedList <VariableDeclaratorSyntax>(
VariableDeclarator(_names.UnionContentField.Identifier))))
.AddModifiers(Private));
}
public string GetCodeIdentifier(TypeDefinition def)
{
string id = def.CsName ?? def.Name;
if (def.Tag == TypeTag.Group) // special treatment for groups: Need to disambiguate between
{ // the field name (use original name) and its type (make it start with a lower-case letter)
id = IdentifierRenamer.ToNonKeyword(SyntaxHelpers.MakeLowerCamel(id));
}
return(id);
}
public static NameSyntax NamespaceName(string[] @namespace)
{
NameSyntax ident = null;
if (@namespace != null)
{
ident = IdentifierName(SyntaxHelpers.MakeUpperCamel(@namespace[0]));
foreach (string name in @namespace.Skip(1))
{
var temp = IdentifierName(SyntaxHelpers.MakeUpperCamel(name));
ident = QualifiedName(ident, temp);
}
}
return(ident);
}
string GetCodeIdentifierLowerCamel(Field field) => field.CsName ?? IdentifierRenamer.ToNonKeyword(SyntaxHelpers.MakeLowerCamel(field.Name));
string GetCodeIdentifierUpperCamel(Field field) => field.CsName ?? SyntaxHelpers.MakeUpperCamel(field.Name);
public Name GetCodeIdentifier(Method method)
{
return(new Name(method.CsName ?? IdentifierRenamer.ToNonKeyword(SyntaxHelpers.MakeUpperCamel(method.Name))));
}
public Name GetCodeIdentifier(Method method)
{
return(new Name(SyntaxHelpers.MakeCamel(method.Name)));
}
public TypeSyntax MakeTypeSyntax(Model.Type type, TypeDefinition scope, TypeUsage usage)
{
switch (type.Tag)
{
case TypeTag.AnyEnum:
return(MaybeNullableValueType(SyntaxHelpers.Type <ushort>(), usage));
case TypeTag.CapabilityPointer:
if (type.Parameter != null)
{
return(GetQName(type, scope));
}
else
{
return(SyntaxHelpers.Type <Capnp.Rpc.BareProxy>());
}
case TypeTag.AnyPointer:
case TypeTag.StructPointer:
switch (usage)
{
case TypeUsage.Reader:
return(SyntaxHelpers.Type <Capnp.DeserializerState>());
case TypeUsage.Writer:
return(SyntaxHelpers.Type <Capnp.DynamicSerializerState>());
case TypeUsage.DomainClass:
case TypeUsage.DomainClassNullable:
if (type.Parameter != null)
{
return(GetQName(type, scope));
}
else
{
return(SyntaxHelpers.Type <object>());
}
default:
throw new NotImplementedException();
}
case TypeTag.Bool:
return(MaybeNullableValueType(SyntaxHelpers.Type <bool>(), usage));
case TypeTag.Data:
switch (usage)
{
case TypeUsage.Reader:
case TypeUsage.DomainClass:
case TypeUsage.DomainClassNullable:
return(SyntaxHelpers.Type <IReadOnlyList <byte> >());
case TypeUsage.Writer:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <byte> >());
default:
throw new NotImplementedException();
}
case TypeTag.Enum:
return(MaybeNullableValueType(GetQName(type, scope), usage));
case TypeTag.Interface:
return(GetQName(type, scope));
case TypeTag.Struct:
case TypeTag.Group:
switch (usage)
{
case TypeUsage.Writer:
return(QualifiedName(GetQName(type, scope), WriterStruct.IdentifierName));
case TypeUsage.Reader:
return(QualifiedName(GetQName(type, scope), ReaderStruct.IdentifierName));
case TypeUsage.DomainClass:
case TypeUsage.DomainClassNullable:
return(GetQName(type, scope));
default:
throw new NotImplementedException();
}
case TypeTag.F32:
return(MaybeNullableValueType(SyntaxHelpers.Type <float>(), usage));
case TypeTag.F64:
return(MaybeNullableValueType(SyntaxHelpers.Type <double>(), usage));
case TypeTag.List when type.ElementType.Tag == TypeTag.Void && usage != TypeUsage.Writer:
return(MaybeNullableValueType(SyntaxHelpers.Type <int>(), usage));
case TypeTag.List:
switch (usage)
{
case TypeUsage.Writer:
return(MakeListSerializerSyntax(type.ElementType, scope));
case TypeUsage.Reader:
return(GenericName(Identifier("IReadOnlyList"))
.AddTypeArgumentListArguments(MakeTypeSyntax(type.ElementType, scope, TypeUsage.Reader)));
case TypeUsage.DomainClass:
case TypeUsage.DomainClassNullable:
return(GenericName(Identifier("IReadOnlyList"))
.AddTypeArgumentListArguments(MakeTypeSyntax(type.ElementType, scope, TypeUsage.DomainClass)));
default:
throw new NotImplementedException();
}
case TypeTag.ListPointer:
switch (usage)
{
case TypeUsage.Writer:
return(SyntaxHelpers.Type <Capnp.SerializerState>());
case TypeUsage.Reader:
return(SyntaxHelpers.Type <IReadOnlyList <Capnp.DeserializerState> >());
case TypeUsage.DomainClass:
case TypeUsage.DomainClassNullable:
return(SyntaxHelpers.Type <IReadOnlyList <object> >());
default:
throw new NotImplementedException();
}
case TypeTag.S16:
return(MaybeNullableValueType(SyntaxHelpers.Type <short>(), usage));
case TypeTag.S32:
return(MaybeNullableValueType(SyntaxHelpers.Type <int>(), usage));
case TypeTag.S64:
return(MaybeNullableValueType(SyntaxHelpers.Type <long>(), usage));
case TypeTag.S8:
return(MaybeNullableValueType(SyntaxHelpers.Type <sbyte>(), usage));
case TypeTag.Text:
return(SyntaxHelpers.Type <string>());
case TypeTag.U16:
return(MaybeNullableValueType(SyntaxHelpers.Type <ushort>(), usage));
case TypeTag.U32:
return(MaybeNullableValueType(SyntaxHelpers.Type <uint>(), usage));
case TypeTag.U64:
return(MaybeNullableValueType(SyntaxHelpers.Type <ulong>(), usage));
case TypeTag.U8:
return(MaybeNullableValueType(SyntaxHelpers.Type <byte>(), usage));
case TypeTag.Void:
return(PredefinedType(Token(SyntaxKind.VoidKeyword)));
default:
throw new NotImplementedException("Unexpected type tag, don't know how to deal with this");
}
}
public TypeSyntax MakeListSerializerSyntax(Model.Type elementType, TypeDefinition scope)
{
switch (elementType.Tag)
{
case TypeTag.AnyPointer:
case TypeTag.StructPointer:
case TypeTag.ListPointer:
return(SyntaxHelpers.Type <Capnp.ListOfPointersSerializer <Capnp.DynamicSerializerState> >());
case TypeTag.CapabilityPointer:
return(SyntaxHelpers.Type <Capnp.ListOfCapsSerializer <Capnp.Rpc.BareProxy> >());
case TypeTag.Data:
return(SyntaxHelpers.Type <Capnp.ListOfPointersSerializer <
Capnp.ListOfPrimitivesSerializer <byte> > >());
case TypeTag.Enum:
return(GenericName("ListOfPrimitivesSerializer")
.AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)));
case TypeTag.Group:
case TypeTag.Struct:
return(GenericName("ListOfStructsSerializer")
.AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)));
case TypeTag.Interface:
return(GenericName("ListOfCapsSerializer")
.AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)));
case TypeTag.List:
return(GenericName("ListOfPointersSerializer")
.AddTypeArgumentListArguments(MakeTypeSyntax(elementType, scope, TypeUsage.Writer)));
case TypeTag.Text:
return(SyntaxHelpers.Type <Capnp.ListOfTextSerializer>());
case TypeTag.Void:
return(SyntaxHelpers.Type <Capnp.ListOfEmptySerializer>());
case TypeTag.Bool:
return(SyntaxHelpers.Type <Capnp.ListOfBitsSerializer>());
case TypeTag.F32:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <float> >());
case TypeTag.F64:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <double> >());
case TypeTag.S8:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <sbyte> >());
case TypeTag.U8:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <byte> >());
case TypeTag.S16:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <short> >());
case TypeTag.U16:
case TypeTag.AnyEnum:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <ushort> >());
case TypeTag.S32:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <int> >());
case TypeTag.U32:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <uint> >());
case TypeTag.S64:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <long> >());
case TypeTag.U64:
return(SyntaxHelpers.Type <Capnp.ListOfPrimitivesSerializer <ulong> >());
default:
throw new NotImplementedException("Unexpected type tag, don't know how to deal with this");
}
}
