public static void MapTypeName(this ISymbolMap symbols, string fullyQualifiedName, string frameworkName, TypeKind kind)
{
var proxyName = $"{frameworkName}Proxy";
switch (kind)
{
case TypeKind.Interface:
var defaultName = frameworkName;
symbols
.GetInterfaceProxyName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(proxyName);
symbols
.GetInterfaceDefaultName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(defaultName);
symbols
.GetInterfaceProxyNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(proxyName));
symbols
.GetInterfaceDefaultNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(defaultName));
symbols
.GetInterfaceProxyNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(proxyName));
symbols
.GetInterfaceDefaultNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(defaultName));
frameworkName = $"I{frameworkName}";
break;
case TypeKind.Class:
symbols
.GetAbstractClassProxyName(Arg.Is <ClassType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(proxyName);
break;
}
symbols
.GetName(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(frameworkName);
symbols
.GetName(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(frameworkName);
symbols
.GetNameSyntaxToken(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(frameworkName));
symbols
.GetNameSyntaxToken(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(frameworkName));
symbols
.GetNameSyntax(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(frameworkName));
symbols
.GetNameSyntax(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(frameworkName));
symbols
.GetTypeSyntax(Arg.Is <TypeReference>(t => t.FullyQualifiedName == fullyQualifiedName), false)
.Returns(SF.ParseTypeName(frameworkName));
}
private static SyntaxNode Normalize(SyntaxNode root, IEnumerable <SyntaxNode> members, Scope scope)
{
var appClass = root
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.Where(@class => @class.Identifier.ToString() == "testclass")
.FirstOrDefault();
if (appClass == null)
{
appClass = CSharp.ClassDeclaration("testclass");
}
return(CSharp.CompilationUnit()
.WithMembers(CSharp.List(new[] { (MemberDeclarationSyntax)
appClass
.WithMembers(CSharp.List(
members.Select(
member => {
var method = member as MethodDeclarationSyntax;
if (method == null)
{
return member;
}
return method.WithParameterList(
method
.ParameterList
.AddParameters(CSharp.Parameter(
CSharp.ParseToken("result"))
.WithType(CSharp.ParseTypeName("Dictionary<string, object>"))));
}))) })));
}
private SyntaxNode typeExtension(SyntaxNode node, SyntacticalExtension <SyntaxNode> extension)
{
return(CSharp.ClassDeclaration(extension.Identifier)
.WithMembers(CSharp.List <MemberDeclarationSyntax>(new[] {
CSharp.MethodDeclaration(CSharp.ParseTypeName("int"), "myMethod")
.WithBody((BlockSyntax)extension.Body)
})));
}
public GeneratorTestBase()
{
Symbols = Substitute.For <ISymbolMap>();
Namespaces = Substitute.For <INamespaceSet>();
Symbols
.GetTypeSyntax(Arg.Is <TypeReference>(t => t.Primitive == PrimitiveType.String && t.IsOptional != true))
.Returns(SF.ParseTypeName("string"));
}
public override TypeArgumentListSyntax GetInterfaceParameters()
{
var genericsParameters = new SeparatedSyntaxList <TypeSyntax>();
for (var index = 0; index < ClassSymbol.TypeArguments.Length; index++)
{
genericsParameters = genericsParameters.Add(SF.ParseTypeName(ClassSymbol.TypeArguments[index].ToString()));
}
return(SF.TypeArgumentList().AddArguments(SF.GenericName(ClassDecl.FullName).WithTypeArgumentList(SF.TypeArgumentList(genericsParameters))));
}
public SeparatedSyntaxList <TypeSyntax> GetGenericParametersList()
{
var genericsParameters = new SeparatedSyntaxList <TypeSyntax>();
for (var index = 0; index < classDecl.ClassSymbol.TypeArguments.Length; index++)
{
genericsParameters = genericsParameters.Add(SF.ParseTypeName(classDecl.ClassSymbol.TypeArguments[index].Name));
}
return(genericsParameters);
}
public static void MapTypeName(this ISymbolMap symbols, string fullyQualifiedName, string frameworkName, TypeKind kind)
{
if (kind == TypeKind.Interface)
{
string proxyName = $"{frameworkName}Proxy";
string defaultName = frameworkName;
symbols
.GetInterfaceProxyName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(proxyName);
symbols
.GetInterfaceDefaultName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(defaultName);
symbols
.GetInterfaceProxyNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(proxyName));
symbols
.GetInterfaceDefaultNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(defaultName));
symbols
.GetInterfaceProxyNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(proxyName));
symbols
.GetInterfaceDefaultNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(defaultName));
frameworkName = $"I{frameworkName}";
}
symbols
.GetName(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(frameworkName);
symbols
.GetName(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(frameworkName);
symbols
.GetNameSyntaxToken(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(frameworkName));
symbols
.GetNameSyntaxToken(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseToken(frameworkName));
symbols
.GetNameSyntax(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(frameworkName));
symbols
.GetNameSyntax(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
.Returns(SF.ParseName(frameworkName));
symbols
.GetTypeSyntax(Arg.Is <TypeReference>(t => t.FullyQualifiedName == fullyQualifiedName))
.Returns(SF.ParseTypeName(frameworkName));
}
public override ClassDeclarationSyntax Apply(ClassDeclarationSyntax node, INamedTypeSymbol symbol, CancellationToken cancellationToken)
{
return(node.AddMembers(
F.PropertyDeclaration(
F.ParseTypeName(node.Identifier.Text), name
).WithAccessorList(
F.AccessorList().AddAccessors(F.AccessorDeclaration(K.GetAccessorDeclaration))
).WithModifiers(
F.TokenList(F.Token(K.PublicKeyword), F.Token(K.StaticKeyword))
).WithInitializer(
F.EqualsValueClause(F.ObjectCreationExpression(F.ParseTypeName(node.Identifier.Text)))
).NormalizeWhitespace()
));
}
private SyntaxNode memberExtension(SyntaxNode node, SyntacticalExtension <SyntaxNode> extension)
{
var memberDecl = node as MethodDeclarationSyntax;
Assert.IsNotNull(memberDecl);
return(memberDecl
.WithReturnType(CSharp.ParseTypeName("int"))
.WithIdentifier(CSharp.ParseToken("anotherName"))
.WithParameterList(CSharp.ParameterList())
.WithBody(memberDecl.Body
.AddStatements(new[] {
CSharp.ParseStatement("var myFoo = 5;"),
CSharp.ParseStatement("bar(myFoo);")
})));
}
public static TypeSyntax GetCsTypeSyntax(this SemanticModel vbSemanticModel, ITypeSymbol typeSymbol, VisualBasicSyntaxNode contextNode)
{
if (typeSymbol.IsNullable())
{
return(SyntaxFactory.NullableType(GetCsTypeSyntax(vbSemanticModel, typeSymbol.GetNullableUnderlyingType(), contextNode)));
}
var predefined = typeSymbol.SpecialType.GetPredefinedKeywordKind();
if (predefined != Microsoft.CodeAnalysis.CSharp.SyntaxKind.None)
{
return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(predefined)));
}
var typeName = typeSymbol.ToMinimalCSharpDisplayString(vbSemanticModel, contextNode.SpanStart);
return(SyntaxFactory.ParseTypeName(typeName));
}
string Render(Docs docs, params Parameter[] parameters)
{
Method method = new Method(
parameters: parameters,
docs: docs,
name: "method"
);
MethodDocCommentGenerator generator = new MethodDocCommentGenerator(method, Symbols);
SyntaxTrivia docComment = generator.CreateDocComment();
SyntaxTree tree = SF.SyntaxTree(
SF.MethodDeclaration(SF.ParseTypeName("void"), "Method")
.WithLeadingTrivia(generator.CreateDocComment())
.NormalizeWhitespace(elasticTrivia: true)
);
return(tree.ToString());
}
string Render(Docs docs)
{
Property property = new Property(
"myProp",
new TypeReference(primitive: PrimitiveType.String),
false,
false,
false,
docs
);
PropertyDocCommentGenerator generator = new PropertyDocCommentGenerator(property);
SyntaxTrivia docComment = generator.CreateDocComment();
SyntaxTree tree = SF.SyntaxTree(
SF.PropertyDeclaration(SF.ParseTypeName("string"), "MyProp")
.WithLeadingTrivia(generator.CreateDocComment())
.NormalizeWhitespace(elasticTrivia: true)
);
return(tree.ToString());
}
public TypeSyntax GetTypeSyntax(TypeReference typeReference)
{
bool isOptional = (typeReference ?? throw new ArgumentNullException(nameof(typeReference))).IsOptional == true;
if (typeReference.Primitive != null)
{
switch (typeReference.Primitive.Value)
{
case PrimitiveType.Any:
return(SF.ParseTypeName("object"));
case PrimitiveType.Boolean:
return(SF.ParseTypeName(isOptional ? "bool?" : "bool"));
case PrimitiveType.Date:
return(SF.ParseTypeName(isOptional ? "DateTime?" : "DateTime"));
case PrimitiveType.Json:
return(SF.ParseTypeName("JObject"));
case PrimitiveType.Number:
return(SF.ParseTypeName(isOptional ? "double?" : "double"));
case PrimitiveType.String:
return(SF.ParseTypeName("string"));
default:
throw new ArgumentException($"Unexpected primitive type {typeReference.Primitive.Value}", nameof(typeReference));
}
}
if (typeReference.Collection != null)
{
TypeSyntax elementType = GetTypeSyntax(typeReference.Collection.ElementType);
switch (typeReference.Collection.Kind)
{
case CollectionKind.Array:
return(SF.ArrayType(
elementType,
SF.List(new[] { SF.ArrayRankSpecifier() })
));
case CollectionKind.Map:
return(SF.ParseTypeName($"IDictionary<string, {elementType}>"));
default:
throw new ArgumentException($"Unexpected collection type {typeReference.Collection.Kind}", nameof(typeReference));
}
}
if (typeReference.Union != null)
{
return(SF.ParseTypeName("object"));
}
if (typeReference.FullyQualifiedName != null)
{
Type type = GetTypeFromFullyQualifiedName(typeReference.FullyQualifiedName);
return(SF.ParseTypeName(GetName(type)));
}
throw new ArgumentException("Invalid type reference", nameof(typeReference));
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private GeneratedSyntax GenerateForAssemblies(Assembly targetAssembly, bool runtime)
{
var grainInterfaces = new List <GrainInterfaceDescription>();
var grainClasses = new List <GrainClassDescription>();
var serializationTypes = new SerializationTypeDescriptions();
var members = new List <MemberDeclarationSyntax>();
// Expand the list of included assemblies and types.
var(includedTypes, assemblies) = this.GetIncludedTypes(targetAssembly, runtime);
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
var serializerNamespaceMembers = new List <MemberDeclarationSyntax>();
var serializerNamespaceName = $"{SerializerNamespacePrefix}{targetAssembly?.GetName().Name.GetHashCode():X}";
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List <MemberDeclarationSyntax>();
var namespaceName = group.Key;
foreach (var type in group)
{
// Skip generated classes.
if (type.GetCustomAttribute <GeneratedCodeAttribute>() != null)
{
continue;
}
// Every type which is encountered must be considered for serialization.
void OnEncounteredType(Type encounteredType)
{
// If a type was encountered which can be accessed, process it for serialization.
this.typeCollector.RecordEncounteredType(type);
this.serializerGenerationManager.RecordTypeToGenerate(encounteredType, targetAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceUtils.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
GrainInterfaceUtils.ValidateInterfaceRules(type);
var referenceTypeName = GrainReferenceGenerator.GetGeneratedClassName(type);
var invokerTypeName = GrainMethodInvokerGenerator.GetGeneratedClassName(type);
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, referenceTypeName, OnEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type, invokerTypeName));
var genericTypeSuffix = GetGenericTypeSuffix(type.GetGenericArguments().Length);
grainInterfaces.Add(
new GrainInterfaceDescription
{
Interface = type.GetTypeSyntax(includeGenericParameters: false),
Reference = SF.ParseTypeName(namespaceName + '.' + referenceTypeName + genericTypeSuffix),
Invoker = SF.ParseTypeName(namespaceName + '.' + invokerTypeName + genericTypeSuffix),
InterfaceId = GrainInterfaceUtils.GetGrainInterfaceId(type)
});
}
if (TypeUtils.IsConcreteGrainClass(type))
{
grainClasses.Add(
new GrainClassDescription
{
ClassType = type.GetTypeSyntax(includeGenericParameters: false)
});
}
// Generate serializers.
var first = true;
while (this.serializerGenerationManager.GetNextTypeToProcess(out var toGen))
{
if (first)
{
Logger.Info("ClientGenerator - Generating serializer classes for types:");
first = false;
}
Logger.Info(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.GetTypeInfo().Assembly.GetName());
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating serializer for type {0}",
toGen.GetParseableName());
}
var generatedSerializerName = SerializerGenerator.GetGeneratedClassName(toGen);
serializerNamespaceMembers.Add(SerializerGenerator.GenerateClass(generatedSerializerName, toGen, OnEncounteredType));
var qualifiedSerializerName = serializerNamespaceName + '.' + generatedSerializerName + GetGenericTypeSuffix(toGen.GetGenericArguments().Length);
serializationTypes.SerializerTypes.Add(
new SerializerTypeDescription
{
Serializer = SF.ParseTypeName(qualifiedSerializerName),
Target = toGen.GetTypeSyntax(includeGenericParameters: false)
});
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", namespaceName);
}
continue;
}
members.Add(CreateNamespace(namespaceName, namespaceMembers));
}
// Add all generated serializers to their own namespace.
members.Add(CreateNamespace(serializerNamespaceName, serializerNamespaceMembers));
// Add serialization metadata for the types which were encountered.
this.AddSerializationTypes(serializationTypes, targetAssembly);
// Generate metadata directives for all of the relevant types.
var(attributeDeclarations, memberDeclarations) = FeaturePopulatorGenerator.GenerateSyntax(targetAssembly, grainInterfaces, grainClasses, serializationTypes);
members.AddRange(memberDeclarations);
var compilationUnit = SF.CompilationUnit().AddAttributeLists(attributeDeclarations.ToArray()).AddMembers(members.ToArray());
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = compilationUnit
});
string GetGenericTypeSuffix(int numParams)
{
if (numParams == 0)
{
return(string.Empty);
}
return('<' + new string(',', numParams - 1) + '>');
}
NamespaceDeclarationSyntax CreateNamespace(string namespaceName, IEnumerable <MemberDeclarationSyntax> namespaceMembers)
{
return
(SF.NamespaceDeclaration(SF.ParseName(namespaceName))
.AddUsings(
TypeUtils.GetNamespaces(typeof(GrainExtensions), typeof(IntrospectionExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
}
public override TypeSyntax GetTryParseMethodOutParameter()
{
return(SF.ParseTypeName(ClassSymbol.ToString()));
}
public override TypeArgumentListSyntax GetInterfaceParameters()
{
return(SF.TypeArgumentList().AddArguments(SF.ParseTypeName(ClassDecl.FullName)));
}