public void RecursivelyCreatesUsingStatementForEachTypeInUnionReference()
{
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference(union: new UnionTypeReference(new TypeReference[] {
new TypeReference(collection: new CollectionTypeReference(
CollectionKind.Array,
new TypeReference(collection: new CollectionTypeReference(
CollectionKind.Array,
new TypeReference(primitive: PrimitiveType.Json)
))
)),
new TypeReference(primitive: PrimitiveType.Date),
})));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;",
"using Newtonsoft.Json.Linq;",
"using System;"
);
}
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));
}
public void CreatesUsingStatementForType()
{
EnumType type = new EnumType
(
"myEnumFqn",
"myModule",
"myEnum",
"myNamespace",
new EnumMember[] { }
);
Symbols.MapNamespace("myNamespace", "MyNamespace");
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(type);
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;",
"using MyNamespace;"
);
}
public NamespaceSet(ISymbolMap symbols, NameSyntax currentNamespace)
{
_symbols = symbols ?? throw new ArgumentNullException(nameof(symbols));
_currentNamespace = currentNamespace ?? throw new ArgumentNullException(nameof(currentNamespace));
_referencedNamespaces = new HashSet <NameSyntax>
(
new[] { SF.ParseName("Amazon.JSII.Runtime.Deputy") },
new DelegateComparer <NameSyntax, string>(nameSyntax => nameSyntax.ToString())
);
}
protected override SyntaxNode addModules(SyntaxNode root, IEnumerable <string> modules)
{
var compilationUnit = (CompilationUnitSyntax)root;
return(compilationUnit
.WithUsings(CSharp.List(
compilationUnit.Usings.Union(
modules
.Select(module => CSharp.UsingDirective(
CSharp.ParseName(module)))))));
}
public static void MapTypeToNamespace(this ISymbolMap symbols, string fullyQualifiedName, string frameworkNamespace)
{
symbols
.GetNamespace(Arg.Is <string>(n => n == fullyQualifiedName))
.Returns(frameworkNamespace);
symbols
.GetNamespaceSyntaxToken(Arg.Is <string>(n => n == fullyQualifiedName))
.Returns(SF.ParseToken(frameworkNamespace));
symbols
.GetNamespaceSyntax(Arg.Is <string>(n => n == fullyQualifiedName))
.Returns(SF.ParseName(frameworkNamespace));
}
public static void MapNamespace(this ISymbolMap symbols, string jsiiNamespace, string frameworkNamespace)
{
symbols
.GetNamespace(Arg.Is <Type>(t => t.QualifiedNamespace == jsiiNamespace))
.Returns(frameworkNamespace);
symbols
.GetNamespaceSyntaxToken(Arg.Is <Type>(t => t.QualifiedNamespace == jsiiNamespace))
.Returns(SF.ParseToken(frameworkNamespace));
symbols
.GetNamespaceSyntax(Arg.Is <Type>(t => t.QualifiedNamespace == jsiiNamespace))
.Returns(SF.ParseName(frameworkNamespace));
}
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));
}
private static CompilationUnitSyntax GenerateRootUnit(ClassDeclMeta classmeta)
{
return(SF.CompilationUnit()
.AddUsings(
SF.UsingDirective(SF.ParseName("MongoDB.Client.Bson.Reader")),
SF.UsingDirective(SF.ParseName("MongoDB.Client.Bson.Writer")),
SF.UsingDirective(SF.ParseName("MongoDB.Client.Bson.Serialization")),
SF.UsingDirective(SF.ParseName("MongoDB.Client.Bson.Document")),
SF.UsingDirective(SF.ParseName("System")),
SF.UsingDirective(SF.ParseName("System.Collections.Generic")),
SF.UsingDirective(SF.ParseName("System.Buffers.Binary")),
SF.UsingDirective(SF.ParseName(classmeta.StringNamespace))));
// .AddMembers(SF.NamespaceDeclaration(SF.ParseName("MongoDB.Client.Bson.Serialization.Generated")));
}
public void CreatesUsingStatementForJsonReference()
{
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference(primitive: PrimitiveType.Json));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;",
"using Newtonsoft.Json.Linq;"
);
}
public static void MapPropertyName(this ISymbolMap symbols, string ownerFullyQualifiedName, string jsiiName, string frameworkName)
{
symbols.GetName(
Arg.Is <Type>(t => t.FullyQualifiedName == ownerFullyQualifiedName),
Arg.Is <Property>(p => p.Name == jsiiName)
).Returns(frameworkName);
symbols.GetNameSyntaxToken(
Arg.Is <Type>(t => t.FullyQualifiedName == ownerFullyQualifiedName),
Arg.Is <Property>(p => p.Name == jsiiName)
).Returns(SF.ParseToken(frameworkName));
symbols.GetNameSyntax(
Arg.Is <Type>(t => t.FullyQualifiedName == ownerFullyQualifiedName),
Arg.Is <Property>(p => p.Name == jsiiName)
).Returns(SF.ParseName(frameworkName));
}
public void DoesNotCreateUsingStatementForCurrentNamespace()
{
Symbols.MapTypeToNamespace("myFqn", "MyCurrentNamespace");
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference("myFqn"));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;"
);
}
public static void MapAssemblyName(this ISymbolMap symbols, string jsiiName, string frameworkName)
{
symbols
.GetName(Arg.Is <Assembly>(a => a.Name == jsiiName))
.Returns(frameworkName);
symbols
.GetNameSyntaxToken(Arg.Is <Assembly>(a => a.Name == jsiiName))
.Returns(SF.ParseToken(frameworkName));
symbols
.GetNameSyntax(Arg.Is <Assembly>(a => a.Name == jsiiName))
.Returns(SF.ParseName(frameworkName));
symbols
.GetAssemblyName(Arg.Is <string>(n => n == jsiiName))
.Returns(frameworkName);
}
public void SortsUsingStatementsAlphaNumerically()
{
Symbols.MapTypeToNamespace("myFqn", "AAA");
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference("myFqn"));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using AAA;",
"using Amazon.JSII.Runtime.Deputy;"
);
}
public void DoesNotCreateUsingStatementForArrayReference()
{
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference(collection: new CollectionTypeReference(
CollectionKind.Array,
new TypeReference(primitive: PrimitiveType.String)
)));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;"
);
}
public void DoesNotCreateUsingStatementForSystemPrimitive()
{
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference(primitive: PrimitiveType.Any));
namespaces.Add(new TypeReference(primitive: PrimitiveType.Boolean));
namespaces.Add(new TypeReference(primitive: PrimitiveType.Number));
namespaces.Add(new TypeReference(primitive: PrimitiveType.String));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;"
);
}
public void CreatesUsingStatementForMapReference()
{
NamespaceSet namespaces = new NamespaceSet(Symbols, SF.ParseName("MyCurrentNamespace"));
namespaces.Add(new TypeReference(collection: new CollectionTypeReference(
kind: CollectionKind.Map,
elementType: new TypeReference(primitive: PrimitiveType.String)
)));
SyntaxList <UsingDirectiveSyntax> usings = namespaces.GetUsings();
AssertUsings
(
usings,
"using Amazon.JSII.Runtime.Deputy;",
"using System.Collections.Generic;"
);
}
public static void MapTypeToPackage(this ISymbolMap symbols, string fullyQualifiedName, string package)
{
symbols
.GetPackage(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName))
.Returns(package);
symbols
.GetPackage(Arg.Is <string>(n => n == fullyQualifiedName))
.Returns(package);
symbols
.GetPackageSyntaxToken(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName))
.Returns(SF.ParseToken(package));
symbols
.GetPackageSyntaxToken(Arg.Is <string>(n => n == fullyQualifiedName))
.Returns(SF.ParseToken(package));
symbols
.GetPackageSyntax(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName))
.Returns(SF.ParseName(package));
symbols
.GetPackageSyntax(Arg.Is <string>(n => n == fullyQualifiedName))
.Returns(SF.ParseName(package));
}
private SyntaxNode AddFlagAttributeCSharp(Document document, SyntaxNode root, SyntaxNode statement)
{
var generator = SyntaxGenerator.GetGenerator(document);
var flagsAttribute = CSharpSyntaxFactory.Attribute(CSharpSyntaxFactory.ParseName("Flags"));
var newStatement = generator.AddAttributes(statement, flagsAttribute);
var newRoot = root.ReplaceNode(statement, newStatement);
var compilationUnit = (CSharpCompilationUnitSyntax)newRoot;
var usingSystemDirective = CSharpSyntaxFactory.UsingDirective(CSharpSyntaxFactory.ParseName("System"));
var usingDirectives = compilationUnit.Usings.Select(u => u.Name.GetText().ToString());
if (usingDirectives.All(u => u != usingSystemDirective.Name.GetText().ToString()))
{
newRoot = generator.AddNamespaceImports(compilationUnit, usingSystemDirective);
}
return(newRoot);
}
protected override SyntaxNode addModules(SyntaxNode root, IEnumerable <string> modules)
{
var compilationUnit = root.AncestorsAndSelf()
.Where(a => a is CompilationUnitSyntax)
.Select(a => a as CompilationUnitSyntax)
.FirstOrDefault()
?? CSharp.CompilationUnit()
.WithMembers(CSharp.List(new[] {
(MemberDeclarationSyntax)root
}));
return(compilationUnit
.WithUsings(CSharp.List(
compilationUnit.Usings.Union(
modules
.Select(module => CSharp
.UsingDirective(CSharp
.ParseName(module))
.WithTrailingTrivia(CSharp.EndOfLine(string.Empty))))))
?? root);
}
public void Add(TypeReference typeReference)
{
if (typeReference.FullyQualifiedName != null)
{
_referencedNamespaces.Add(_symbols.GetNamespaceSyntax(typeReference.FullyQualifiedName));
return;
}
switch (typeReference.Primitive)
{
case PrimitiveType.Date:
_referencedNamespaces.Add(SF.ParseName("System"));
return;
case PrimitiveType.Json:
_referencedNamespaces.Add(SF.ParseName("Newtonsoft.Json.Linq"));
return;
}
if (typeReference.Collection != null)
{
switch (typeReference.Collection.Kind)
{
case CollectionKind.Map:
_referencedNamespaces.Add(SF.ParseName("System.Collections.Generic"));
break;
}
Add(typeReference.Collection.ElementType);
return;
}
if (typeReference.Union != null)
{
foreach (TypeReference partialTypeReference in typeReference.Union.Types)
{
Add(partialTypeReference);
}
}
}
/// <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 static GeneratedSyntax GenerateForAssemblies(List <Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet <Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = CodeGeneratorCommon.GetTypesWithImplementations(
typeof(MethodInvokerAttribute),
typeof(GrainReferenceAttribute),
typeof(GrainStateAttribute),
typeof(SerializerAttribute));
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet <Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List <MemberDeclarationSyntax>();
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet <Type>();
foreach (var type in assemblies.SelectMany(_ => _.GetTypes()))
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
if (!type.IsNested && !type.IsGenericParameter && type.IsSerializable)
{
// If a type was encountered which can be accessed, process it for serialization.
var isAccessibleForSerialization =
!TypeUtilities.IsTypeIsInaccessibleForSerialization(type, module, targetAssembly);
if (isAccessibleForSerialization)
{
includedTypes.Add(type);
SerializerGenerationManager.RecordTypeToGenerate(type);
}
}
// Collect the types which require code generation.
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("Will generate code for: {0}", type.GetParseableName());
}
includedTypes.Add(type);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// 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>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
Action <Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
var isAccessibleForSerialization =
!TypeUtilities.IsTypeIsInaccessibleForSerialization(encounteredType, module, targetAssembly);
if (isAccessibleForSerialization)
{
SerializerGenerationManager.RecordTypeToGenerate(encounteredType);
}
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (SerializerGenerationManager.GetNextTypeToProcess(out toGen))
{
// Filter types which are inaccessible by the serialzation module/assembly.
var skipSerialzerGeneration =
toGen.GetAllFields()
.Any(
field =>
TypeUtilities.IsTypeIsInaccessibleForSerialization(
field.FieldType,
module,
targetAssembly));
if (skipSerialzerGeneration)
{
continue;
}
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
});
}
/// <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 static GeneratedSyntax GenerateForAssemblies(List <Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet <Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = GetTypesWithGeneratedSupportClasses();
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet <Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List <MemberDeclarationSyntax>();
// If any KnownAssemblies have been specified, include them during code generation.
var knownAssemblies =
assemblies.SelectMany(_ => _.GetCustomAttributes <KnownAssemblyAttribute>())
.Select(_ => _.Assembly)
.Distinct()
.ToSet();
if (knownAssemblies.Count > 0)
{
knownAssemblies.UnionWith(assemblies);
assemblies = knownAssemblies.ToList();
}
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet <Type>();
for (var i = 0; i < assemblies.Count; i++)
{
var assembly = assemblies[i];
foreach (var attribute in assembly.GetCustomAttributes <KnownTypeAttribute>())
{
ConsiderType(attribute.Type, runtime, targetAssembly, includedTypes);
}
foreach (var type in assembly.DefinedTypes)
{
ConsiderType(type, runtime, targetAssembly, includedTypes);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// 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>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
Action <Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
SerializerGenerationManager.RecordTypeToGenerate(encounteredType, module, targetAssembly);
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
GrainInterfaceData.ValidateInterfaceRules(type);
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (SerializerGenerationManager.GetNextTypeToProcess(out toGen))
{
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
});
}
/// <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 CompilationUnitBuilder Using(IEnumerable <string> usings) => new CompilationUnitBuilder(_usings.AddRange(usings.Select(u => SF.UsingDirective(SF.ParseName(u)))), _namespaces);
private static NamespaceDeclarationSyntax GenerateNamespace(ClassDeclMeta classmeta)
{
return(SF.NamespaceDeclaration(SF.ParseName("MongoDB.Client.Bson.Serialization.Generated")));
}
public static void MapParameterName(this ISymbolMap symbols, string jsiiName, string frameworkName)
{
symbols.GetName(Arg.Is <Parameter>(t => t.Name == jsiiName)).Returns(frameworkName);
symbols.GetNameSyntaxToken(Arg.Is <Parameter>(t => t.Name == jsiiName)).Returns(SF.ParseToken(frameworkName));
symbols.GetNameSyntax(Arg.Is <Parameter>(t => t.Name == jsiiName)).Returns(SF.ParseName(frameworkName));
}
public NamespaceDeclarationSyntax Build() => SF.NamespaceDeclaration(SF.ParseName(_name)).AddMembers(_types.Select(t => t.Build()).ToArray());