private static (TypeSpec Type, string Assembly) HandleGeneric(ConstructedGenericTypeSpec type, string assemblyName, Func <QualifiedType, QualifiedType> replaceTypeName)
{
var(unconstructed, replacementAssembly) = ApplyInner(type.UnconstructedType, assemblyName, replaceTypeName);
var newArguments = new TypeSpec[type.Arguments.Length];
var didChange = false;
for (var i = 0; i < type.Arguments.Length; i++)
{
// Generic type parameters do not inherit the assembly of the generic type.
var args = ApplyInner(type.Arguments[i], null, replaceTypeName);
if (args.Assembly is object)
{
newArguments[i] = new AssemblyQualifiedTypeSpec(args.Type, args.Assembly);
}
else
{
newArguments[i] = args.Type;
}
didChange |= !ReferenceEquals(newArguments[i], type.Arguments[i]);
}
if (ReferenceEquals(type.UnconstructedType, unconstructed) && !didChange)
{
return(type, replacementAssembly);
}
return(new ConstructedGenericTypeSpec((NamedTypeSpec)unconstructed, newArguments), replacementAssembly);
}
public GrainInterfaceType GetGrainInterfaceTypeByConvention(Type type)
{
var result = GrainInterfaceType.Create(_typeConverter.Format(type, input => input switch
{
AssemblyQualifiedTypeSpec asm => asm.Type, // drop outer assembly qualification
_ => input
}));
private static (TypeSpec Type, string Assembly) HandleAssembly(AssemblyQualifiedTypeSpec type, string assemblyName, Func <QualifiedType, QualifiedType> replaceTypeName)
{
var replacement = ApplyInner(type.Type, type.Assembly, replaceTypeName);
// Assembly name changes never bubble up past the assembly qualifier node.
if (string.IsNullOrWhiteSpace(replacement.Assembly))
{
// Remove the assembly qualification
return(replacement.Type, assemblyName);
}
else if (!string.Equals(replacement.Assembly, type.Assembly) || !ReferenceEquals(replacement.Type, type.Type))
{
// Update the assembly or the type.
return(new AssemblyQualifiedTypeSpec(replacement.Type, replacement.Assembly), assemblyName);
}
// No update.
return(type, assemblyName);
}
private static TypeSpec ParseInternal(ref ReadOnlySpan <char> input)
{
TypeSpec result;
char c;
BufferReader s = default;
s.Input = input;
// Read namespace and class name, including generic arity, which is a part of the class name.
NamedTypeSpec named = null;
while (true)
{
var typeName = ParseTypeName(ref s);
named = new NamedTypeSpec(named, typeName.ToString(), s.TotalGenericArity);
if (s.TryPeek(out c) && c == NestedTypeIndicator)
{
// Consume the nested type indicator, then loop to parse the nested type.
s.ConsumeCharacter(NestedTypeIndicator);
continue;
}
break;
}
// Parse generic type parameters
if (s.TotalGenericArity > 0 && s.TryPeek(out c) && c == ArrayStartIndicator)
{
s.ConsumeCharacter(ArrayStartIndicator);
var arguments = new TypeSpec[s.TotalGenericArity];
for (var i = 0; i < s.TotalGenericArity; i++)
{
if (i > 0)
{
s.ConsumeCharacter(ParameterSeparator);
}
// Parse the argument type
s.ConsumeCharacter(ArrayStartIndicator);
var remaining = s.Remaining;
arguments[i] = ParseInternal(ref remaining);
var consumed = s.Remaining.Length - remaining.Length;
s.Consume(consumed);
s.ConsumeCharacter(ArrayEndIndicator);
}
s.ConsumeCharacter(ArrayEndIndicator);
result = new ConstructedGenericTypeSpec(named, arguments);
}
else
{
// This is not a constructed generic type
result = named;
}
// Parse modifiers
bool hadModifier;
do
{
hadModifier = false;
if (!s.TryPeek(out c))
{
break;
}
switch (c)
{
case ArrayStartIndicator:
var dimensions = ParseArraySpecifier(ref s);
result = new ArrayTypeSpec(result, dimensions);
hadModifier = true;
break;
case PointerIndicator:
result = new PointerTypeSpec(result);
s.ConsumeCharacter(PointerIndicator);
hadModifier = true;
break;
case ReferenceIndicator:
result = new ReferenceTypeSpec(result);
s.ConsumeCharacter(ReferenceIndicator);
hadModifier = true;
break;
}
} while (hadModifier);
// Extract the assembly, if specified.
if (s.TryPeek(out c) && c == AssemblyIndicator)
{
s.ConsumeCharacter(AssemblyIndicator);
var assembly = ExtractAssemblySpec(ref s);
result = new AssemblyQualifiedTypeSpec(result, assembly.ToString());
}
input = s.Remaining;
return(result);
}
