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))); }