SeparatedSyntaxList <EnumMemberDeclarationSyntax> CreateValues() { return(SF.SeparatedList(Type.Members.Select(GetMemberDeclaration))); EnumMemberDeclarationSyntax GetMemberDeclaration(EnumMember member) { EnumMemberDeclarationSyntax declaration = SF.EnumMemberDeclaration ( SF.List(new[] { SF.AttributeList(SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("JsiiEnumMember"), SF.ParseAttributeArgumentList($"(\"{member.Name}\")") ) })) }), Symbols.GetNameSyntaxToken(Type, member), null ); if (member.Docs != null) { DocCommentGeneratorBase <EnumMember> generator = new EnumMemberDocCommentGenerator(member); SyntaxTriviaList trivia = SF.TriviaList(generator.CreateDocComment()); declaration = declaration.WithLeadingTrivia(trivia); } return(declaration); } }
private async Task <Document> AddAnnotation(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var highlightedNode = root.FindToken(diagnostic.Location.SourceSpan.Start).Parent; var methodDeclaration = CodeFixUtil.GetParentNode(highlightedNode, typeof(MethodDeclarationSyntax)) as MethodDeclarationSyntax; var attributesList = methodDeclaration.AttributeLists[0] as AttributeListSyntax; if (methodDeclaration == null) { return(document); } var annotationValidate = SF.AttributeList() .AddAttributes(SF.Attribute(SF.IdentifierName("ValidateAntiForgeryToken"))) .WithLeadingTrivia(CodeFixUtil.KeepLastLine(attributesList.GetLeadingTrivia())); var nodes = new List <SyntaxNode>(); nodes.Add(annotationValidate); var newRoot = root.InsertNodesAfter(attributesList, nodes); return(document.WithSyntaxRoot(newRoot)); }
public static (List <AttributeListSyntax>, List <MemberDeclarationSyntax>) GenerateSyntax( Assembly targetAssembly, List <GrainInterfaceDescription> grainInterfaces, List <GrainClassDescription> grainClasses, SerializationTypeDescriptions typeDescriptions) { var attributes = new List <AttributeListSyntax>(); var members = new List <MemberDeclarationSyntax>(); var className = CodeGeneratorCommon.ClassPrefix + Guid.NewGuid().ToString("N").Substring(0, 10) + ClassSuffix; // Generate a class for populating the metadata. var classSyntax = SF.ClassDeclaration(className) .AddBaseListTypes( SF.SimpleBaseType(typeof(IFeaturePopulator <GrainInterfaceFeature>).GetTypeSyntax()), SF.SimpleBaseType(typeof(IFeaturePopulator <GrainClassFeature>).GetTypeSyntax()), SF.SimpleBaseType(typeof(IFeaturePopulator <SerializerFeature>).GetTypeSyntax())) .AddModifiers(SF.Token(SyntaxKind.InternalKeyword), SF.Token(SyntaxKind.SealedKeyword)) .AddMembers(GeneratePopulateMethod(grainInterfaces), GeneratePopulateMethod(grainClasses), GeneratePopulateMethod(typeDescriptions)) .AddAttributeLists(SF.AttributeList(SF.SingletonSeparatedList(CodeGeneratorCommon.GetGeneratedCodeAttributeSyntax()))); var namespaceSyntax = SF.NamespaceDeclaration(NamespaceName.ToIdentifierName()).AddMembers(classSyntax); members.Add(namespaceSyntax); // Generate an assembly-level attribute with an instance of that class. var attribute = SF.AttributeList( SF.AttributeTargetSpecifier(SF.Token(SyntaxKind.AssemblyKeyword)), SF.SingletonSeparatedList( SF.Attribute(typeof(FeaturePopulatorAttribute).GetNameSyntax()) .AddArgumentListArguments(SF.AttributeArgument(SF.TypeOfExpression(SF.ParseTypeName(NamespaceName + "." + className)))))); attributes.Add(attribute); return(attributes, members); }
protected override MemberDeclarationSyntax CreateType() { return(SF.ClassDeclaration ( SF.List <AttributeListSyntax>(new [] { SF.AttributeList(SF.SeparatedList(new [] { SF.Attribute(SF.ParseName("JsiiByValue")) })) }), SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)), Symbols.GetInterfaceDefaultNameSyntaxToken(Type), null, SF.BaseList(SF.SeparatedList(CreateBaseTypes())), SF.List <TypeParameterConstraintClauseSyntax>(), SF.List(CreateMembers()) )); IEnumerable <BaseTypeSyntax> CreateBaseTypes() { yield return(SF.SimpleBaseType(Symbols.GetNameSyntax(Type, disambiguate: true))); } IEnumerable <MemberDeclarationSyntax> CreateMembers() { return(CreateProperties()); } }
public static AttributeListSyntax GenAttribute(string name) { return(SF.AttributeList( SF.SingletonSeparatedList( SF.Attribute( SF.IdentifierName(name))))); }
SyntaxList <AttributeListSyntax> CreateAttributes() { TypeOfExpressionSyntax typeOfExpression = SF.TypeOfExpression(Symbols.GetNameSyntax(Type)); SyntaxToken fullyQualifiedNameLiteral = SF.Literal(Type.FullyQualifiedName); return(SF.List(GetAttributeLists())); IEnumerable <AttributeListSyntax> GetAttributeLists() { yield return(SF.AttributeList(SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("JsiiEnum"), SF.ParseAttributeArgumentList($"(nativeType: {typeOfExpression}, fullyQualifiedName: {fullyQualifiedNameLiteral})") ) }))); if (Type.Docs?.Stability == Stability.Deprecated) { var argument = Type.Docs?.Deprecated != null?SF.Literal(Type.Docs?.Deprecated).ToString() : ""; yield return(SF.AttributeList(SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("System.Obsolete"), SF.ParseAttributeArgumentList($"({argument})") ) }))); } } }
/// <summary> /// Generates the class for the provided grain types. /// </summary> /// <param name="grainType"> /// The grain interface type. /// </param> /// <returns> /// The generated class. /// </returns> internal static TypeDeclarationSyntax GenerateClass(Type grainType) { var baseTypes = new List <BaseTypeSyntax> { SF.SimpleBaseType(typeof(IGrainMethodInvoker).GetTypeSyntax()) }; var grainTypeInfo = grainType.GetTypeInfo(); var genericTypes = grainTypeInfo.IsGenericTypeDefinition ? grainTypeInfo.GetGenericArguments() .Select(_ => SF.TypeParameter(_.ToString())) .ToArray() : new TypeParameterSyntax[0]; // Create the special method invoker marker attribute. var interfaceId = GrainInterfaceUtils.GetGrainInterfaceId(grainType); var interfaceIdArgument = SF.LiteralExpression(SyntaxKind.NumericLiteralExpression, SF.Literal(interfaceId)); var grainTypeArgument = SF.TypeOfExpression(grainType.GetTypeSyntax(includeGenericParameters: false)); var attributes = new List <AttributeSyntax> { CodeGeneratorCommon.GetGeneratedCodeAttributeSyntax(), SF.Attribute(typeof(MethodInvokerAttribute).GetNameSyntax()) .AddArgumentListArguments( SF.AttributeArgument(grainType.GetParseableName().GetLiteralExpression()), SF.AttributeArgument(interfaceIdArgument), SF.AttributeArgument(grainTypeArgument)), #if !NETSTANDARD SF.Attribute(typeof(ExcludeFromCodeCoverageAttribute).GetNameSyntax()) #endif }; var members = new List <MemberDeclarationSyntax> { GenerateInvokeMethod(grainType), GenerateInterfaceIdProperty(grainType) }; // If this is an IGrainExtension, make the generated class implement IGrainExtensionMethodInvoker. if (typeof(IGrainExtension).IsAssignableFrom(grainType)) { baseTypes.Add(SF.SimpleBaseType(typeof(IGrainExtensionMethodInvoker).GetTypeSyntax())); members.Add(GenerateExtensionInvokeMethod(grainType)); } var classDeclaration = SF.ClassDeclaration( CodeGeneratorCommon.ClassPrefix + TypeUtils.GetSuitableClassName(grainType) + ClassSuffix) .AddModifiers(SF.Token(SyntaxKind.InternalKeyword)) .AddBaseListTypes(baseTypes.ToArray()) .AddConstraintClauses(grainType.GetTypeConstraintSyntax()) .AddMembers(members.ToArray()) .AddAttributeLists(SF.AttributeList().AddAttributes(attributes.ToArray())); if (genericTypes.Length > 0) { classDeclaration = classDeclaration.AddTypeParameterListParameters(genericTypes); } return(classDeclaration); }
/// <summary> /// Returns syntax for the deserializer method. /// </summary> /// <param name="type">The type.</param> /// <param name="fields">The fields.</param> /// <returns>Syntax for the deserializer method.</returns> private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> deserializeInner = () => SerializationManager.DeserializeInner(default(Type), default(IDeserializationContext)); var contextParameter = SF.IdentifierName("context"); var resultDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))); var resultVariable = SF.IdentifierName("result"); var body = new List <StatementSyntax> { resultDeclaration }; // Value types cannot be referenced, only copied, so there is no need to box & record instances of value types. if (!type.GetTypeInfo().IsValueType) { // Record the result for cyclic deserialization. Expression <Action <IDeserializationContext> > recordObject = ctx => ctx.RecordObject(default(object)); var currentSerializationContext = contextParameter; body.Add( SF.ExpressionStatement( recordObject.Invoke(currentSerializationContext) .AddArgumentListArguments(SF.Argument(resultVariable)))); } // Deserialize all fields. foreach (var field in fields) { var deserialized = deserializeInner.Invoke() .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(field.Type)), SF.Argument(contextParameter)); body.Add( SF.ExpressionStatement( field.GetSetter( resultVariable, SF.CastExpression(field.Type, deserialized)))); } body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), resultVariable))); return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()), SF.Parameter(SF.Identifier("context")).WithType(typeof(IDeserializationContext).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax())))); }
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> deserializeInner = () => SerializationManager.DeserializeInner(default(Type), default(BinaryTokenStreamReader)); var streamParameter = SF.IdentifierName("stream"); var resultDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))); var resultVariable = SF.IdentifierName("result"); var boxedResultVariable = resultVariable; var body = new List <StatementSyntax> { resultDeclaration }; if (type.IsValueType) { // For value types, we need to box the result for reflection-based setters to work. body.Add(SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(object).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("boxedResult").WithInitializer(SF.EqualsValueClause(resultVariable))))); boxedResultVariable = SF.IdentifierName("boxedResult"); } // Deserialize all fields. foreach (var field in fields) { var deserialized = deserializeInner.Invoke() .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(field.Type)), SF.Argument(streamParameter)); body.Add( SF.ExpressionStatement( field.GetSetter( resultVariable, SF.CastExpression(field.Type, deserialized), boxedResultVariable))); } body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), boxedResultVariable))); return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()), SF.Parameter(SF.Identifier("stream")).WithType(typeof(BinaryTokenStreamReader).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax())))); }
public static AttributeListSyntax GenAttributeList(KeyValuePair <string, string>[] names) { var list = new List <AttributeSyntax>(); foreach (var name in names) { list.Add(GenAttribute(name.Key, name.Value)); } return(SF.AttributeList(SF.SeparatedList(list))); }
private static AttributeListSyntax AttributeList(params AttributeSyntax[] attributes) { SeparatedSyntaxList <AttributeSyntax> separatedList = SF.SeparatedList <AttributeSyntax>(); foreach (var attributeSyntax in attributes) { separatedList = separatedList.Add(attributeSyntax); } return(SF.AttributeList(separatedList)); }
protected override MemberDeclarationSyntax CreateType() { return(SF.ClassDeclaration ( CreateAttributes(), SF.TokenList( SF.Token(SyntaxKind.InternalKeyword), SF.Token(SyntaxKind.SealedKeyword)), GetProxyTypeNameSyntax(), null, CreateBaseList(), SF.List <TypeParameterConstraintClauseSyntax>(), SF.List(CreateMembers()) )); SyntaxList <AttributeListSyntax> CreateAttributes() { var typeOfExpression = SF.TypeOfExpression(Symbols.GetNameSyntax(Type)); var fullyQualifiedNameLiteral = SF.Literal(Type.FullyQualifiedName); return(SF.List(new[] { SF.AttributeList(SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("JsiiTypeProxy"), SF.ParseAttributeArgumentList($"({typeOfExpression}, {fullyQualifiedNameLiteral})") ) })) })); } BaseListSyntax CreateBaseList() { return(SF.BaseList(SF.SeparatedList(GetBaseTypes()))); IEnumerable <BaseTypeSyntax> GetBaseTypes() { if (Type is InterfaceType) { yield return(SF.SimpleBaseType(SF.ParseTypeName("DeputyBase"))); } Namespaces.Add(Type); yield return(SF.SimpleBaseType(Symbols.GetNameSyntax(Type, disambiguate: true))); } } IEnumerable <MemberDeclarationSyntax> CreateMembers() { return(CreateConstructors() .Concat(CreateProperties()) .Concat(CreateMethods())); } }
public static AttributeListSyntax GenAttribute(string name, string args) { return(SF.AttributeList( SF.SingletonSeparatedList( SF.Attribute( SF.IdentifierName(name)).WithArgumentList( SF.AttributeArgumentList( SF.SingletonSeparatedList( SF.AttributeArgument( SF.ParseExpression(args)))))))); }
AttributeListSyntax FindInList(AttributeListSyntax originalAttributeList, bool add) { if (found) { return(originalAttributeList); } List <AttributeSyntax> attributes = new List <AttributeSyntax>(); foreach (var attribute in originalAttributeList.Attributes) { if (found) { attributes.Add(attribute); continue; } var p = semanticModel.GetSymbolInfo(attribute); if (p.Symbol.ContainingType.Equals(mocklisSymbols.GeneratedCodeAttribute)) { found = true; attributes.Add(typesForSymbols.GeneratedCodeAttribute()); } else if (add && p.Symbol.ContainingType.Equals(mocklisSymbols.MocklisClassAttribute)) { found = true; attributes.Add(attribute); attributes.Add(typesForSymbols.GeneratedCodeAttribute()); } else { attributes.Add(attribute); } } if (found) { var newAttributeList = F.AttributeList(F.SeparatedList(attributes)); if (originalAttributeList.HasLeadingTrivia) { newAttributeList = newAttributeList.WithLeadingTrivia(originalAttributeList.GetLeadingTrivia()); } if (originalAttributeList.HasTrailingTrivia) { newAttributeList = newAttributeList.WithTrailingTrivia(originalAttributeList.GetTrailingTrivia()); } return(newAttributeList); } return(found ? F.AttributeList(F.SeparatedList(attributes)) : originalAttributeList); }
/// <summary> /// Generates the class for the provided grain types. /// </summary> /// <param name="grainType"> /// The grain interface type. /// </param> /// <param name="onEncounteredType"> /// The callback which is invoked when a type is encountered. /// </param> /// <returns> /// The generated class. /// </returns> internal static TypeDeclarationSyntax GenerateClass(Type grainType, Action <Type> onEncounteredType) { var grainTypeInfo = grainType.GetTypeInfo(); var genericTypes = grainTypeInfo.IsGenericTypeDefinition ? grainTypeInfo.GetGenericArguments() .Select(_ => SF.TypeParameter(_.ToString())) .ToArray() : new TypeParameterSyntax[0]; // Create the special marker attribute. var markerAttribute = SF.Attribute(typeof(GrainReferenceAttribute).GetNameSyntax()) .AddArgumentListArguments( SF.AttributeArgument( SF.TypeOfExpression(grainType.GetTypeSyntax(includeGenericParameters: false)))); var attributes = SF.AttributeList() .AddAttributes( CodeGeneratorCommon.GetGeneratedCodeAttributeSyntax(), SF.Attribute(typeof(SerializableAttribute).GetNameSyntax()), #if !NETSTANDARD_TODO //ExcludeFromCodeCoverageAttribute became an internal class in netstandard SF.Attribute(typeof(ExcludeFromCodeCoverageAttribute).GetNameSyntax()), #endif markerAttribute); var className = CodeGeneratorCommon.ClassPrefix + TypeUtils.GetSuitableClassName(grainType) + ClassSuffix; var classDeclaration = SF.ClassDeclaration(className) .AddModifiers(SF.Token(SyntaxKind.InternalKeyword)) .AddBaseListTypes( SF.SimpleBaseType(typeof(GrainReference).GetTypeSyntax()), SF.SimpleBaseType(grainType.GetTypeSyntax())) .AddConstraintClauses(grainType.GetTypeConstraintSyntax()) .AddMembers(GenerateConstructors(className)) .AddMembers( GenerateInterfaceIdProperty(grainType), GenerateInterfaceNameProperty(grainType), GenerateIsCompatibleMethod(grainType), GenerateGetMethodNameMethod(grainType)) .AddMembers(GenerateInvokeMethods(grainType, onEncounteredType)) .AddAttributeLists(attributes); if (genericTypes.Length > 0) { classDeclaration = classDeclaration.AddTypeParameterListParameters(genericTypes); } return(classDeclaration); }
public static CompilationUnitSyntax AddGeneratedCodeAttribute(GeneratedSyntax generatedSyntax) { var codeGenTargetAttributes = SF.AttributeList() .AddAttributes( generatedSyntax.SourceAssemblies.Select( asm => SF.Attribute(typeof(OrleansCodeGenerationTargetAttribute).GetNameSyntax()) .AddArgumentListArguments( SF.AttributeArgument(asm.GetName().FullName.GetLiteralExpression()))).ToArray()) .WithTarget(SF.AttributeTargetSpecifier(SF.Token(SyntaxKind.AssemblyKeyword))); return(generatedSyntax.Syntax.AddAttributeLists(codeGenTargetAttributes)); }
SyntaxList <AttributeListSyntax> CreateAttributes() { TypeOfExpressionSyntax typeOfExpression = SF.TypeOfExpression(Symbols.GetNameSyntax(Type)); SyntaxToken fullyQualifiedNameLiteral = SF.Literal(Type.FullyQualifiedName); return(SF.List(new[] { SF.AttributeList(SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("JsiiEnum"), SF.ParseAttributeArgumentList($"({typeOfExpression}, {fullyQualifiedNameLiteral})") ) })) })); }
SyntaxList <AttributeListSyntax> GetAttributeLists() { return(SF.List(GetAttributeLists())); IEnumerable <AttributeListSyntax> GetAttributeLists() { SyntaxToken nameLiteral = SF.Literal(Method.Name); SyntaxToken trueLiteral = SF.Token(SyntaxKind.TrueKeyword); string argumentList = $"name: {nameLiteral}"; if (Method.Returns != null) { SyntaxToken returnsJsonLiteral = Method.Returns == null? SF.Token(SyntaxKind.NullKeyword) : SF.Literal(JsonConvert.SerializeObject(Method.Returns, SerializerSettings)); argumentList += $", returnsJson: {returnsJsonLiteral}"; } if (Method.Parameters != null && Method.Parameters.Length > 0) { SyntaxToken parametersJsonLiteral = Method.GetParametersJsonSyntaxToken(); argumentList += $", parametersJson: {parametersJsonLiteral}"; } if (Method.IsAsync) { argumentList += $", isAsync: {trueLiteral}"; } if (Method.Overrides != null) { argumentList += $", isOverride: {trueLiteral}"; } yield return(SF.AttributeList(SF.SingletonSeparatedList(SF.Attribute( SF.ParseName("JsiiMethod"), SF.ParseAttributeArgumentList($"({argumentList})") )))); if (Method.Docs?.Stability == Stability.Deprecated) { var argument = Method.Docs?.Deprecated != null?SF.Literal(Method.Docs?.Deprecated).ToString() : ""; yield return(SF.AttributeList(SF.SingletonSeparatedList(SF.Attribute( SF.ParseName("System.Obsolete"), SF.ParseAttributeArgumentList($"({argument})") )))); } } }
/// <summary> /// Generates the class for the provided grain types. /// </summary> /// <param name="type">The grain interface type.</param> /// <param name="onEncounteredType"> /// The callback invoked when a type is encountered. /// </param> /// <returns> /// The generated class. /// </returns> internal static TypeDeclarationSyntax GenerateClass(Type type, Action <Type> onEncounteredType) { var typeInfo = type.GetTypeInfo(); var genericTypes = typeInfo.IsGenericTypeDefinition ? typeInfo.GetGenericArguments().Select(_ => SF.TypeParameter(_.ToString())).ToArray() : new TypeParameterSyntax[0]; var attributes = new List <AttributeSyntax> { CodeGeneratorCommon.GetGeneratedCodeAttributeSyntax(), #if !NETSTANDARD SF.Attribute(typeof(ExcludeFromCodeCoverageAttribute).GetNameSyntax()), #endif SF.Attribute(typeof(SerializerAttribute).GetNameSyntax()) .AddArgumentListArguments( SF.AttributeArgument(SF.TypeOfExpression(type.GetTypeSyntax(includeGenericParameters: false)))) }; var className = CodeGeneratorCommon.ClassPrefix + type.GetParseableName(GeneratedTypeNameOptions); var fields = GetFields(type); // Mark each field type for generation foreach (var field in fields) { var fieldType = field.FieldInfo.FieldType; onEncounteredType(fieldType); } var members = new List <MemberDeclarationSyntax>(GenerateStaticFields(fields)) { GenerateDeepCopierMethod(type, fields), GenerateSerializerMethod(type, fields), GenerateDeserializerMethod(type, fields), }; var classDeclaration = SF.ClassDeclaration(className) .AddModifiers(SF.Token(SyntaxKind.InternalKeyword)) .AddAttributeLists(SF.AttributeList().AddAttributes(attributes.ToArray())) .AddMembers(members.ToArray()) .AddConstraintClauses(type.GetTypeConstraintSyntax()); if (genericTypes.Length > 0) { classDeclaration = classDeclaration.AddTypeParameterListParameters(genericTypes); } return(classDeclaration); }
protected override MemberDeclarationSyntax CreateType() { return(SF.InterfaceDeclaration ( CreateAttributes(), SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)), Symbols.GetNameSyntaxToken(Type), null, CreateBaseList(), SF.List <TypeParameterConstraintClauseSyntax>(), SF.List(CreateMembers()) )); SyntaxList <AttributeListSyntax> CreateAttributes() { TypeOfExpressionSyntax typeOfExpression = SF.TypeOfExpression(Symbols.GetNameSyntax(Type)); SyntaxToken fullyQualifiedNameLiteral = SF.Literal(Type.FullyQualifiedName); return(SF.List(new[] { SF.AttributeList(SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("JsiiInterface"), SF.ParseAttributeArgumentList($"({typeOfExpression}, {fullyQualifiedNameLiteral})") ) })) })); } BaseListSyntax CreateBaseList() { IEnumerable <BaseTypeSyntax> baseTypes = GetBaseTypes(); return(baseTypes?.Any() == true?SF.BaseList(SF.SeparatedList(baseTypes)) : null); IEnumerable <BaseTypeSyntax> GetBaseTypes() { foreach (TypeReference interfaceReference in Type.Interfaces ?? Enumerable.Empty <TypeReference>()) { Namespaces.Add(interfaceReference); yield return(SF.SimpleBaseType(Symbols.GetTypeSyntax(interfaceReference))); } } } IEnumerable <MemberDeclarationSyntax> CreateMembers() { return(CreateProperties().Concat(CreateMethods())); } }
public static SyntaxList <AttributeListSyntax> GenerateStructLayoutAttributes() { return(SF.SingletonList( SF.AttributeList( SF.SingletonSeparatedList( SF.Attribute(SF.IdentifierName("StructLayout")) .WithArgumentList( SF.AttributeArgumentList( SF.SingletonSeparatedList( SF.AttributeArgument( SF.MemberAccessExpression( SK.SimpleMemberAccessExpression, SF.IdentifierName("LayoutKind"), SF.IdentifierName("Explicit")))))))))); }
private SyntaxList <AttributeListSyntax> CreateSerializationAttribute(SymbolData symbol) { string requiredValueName; if (symbol.IsRequired) { requiredValueName = (symbol.isNullable) ? "AllowNull" : "Always"; } else { requiredValueName = "Default"; } Func <string, string, string, AttributeArgumentSyntax> createAttr = (lhs, expr, name) => { // lhs = expr.name return(SF.AttributeArgument( SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(expr), SF.Token(SyntaxKind.DotToken), SF.IdentifierName(name))) .WithNameEquals( SF.NameEquals(SF.IdentifierName(lhs)))); }; var attributes = SF.SeparatedList(new[] { // Required = Required.[requiredValueName] createAttr("Required", "Required", requiredValueName), }); if (requiredValueName == "Default" && !symbol.isNullable) { // NullValueHandling = NullValueHandling.Ignore attributes = attributes.Add( createAttr("NullValueHandling", "NullValueHandling", "Ignore")); } return(SF.SingletonList( SF.AttributeList( SF.SingletonSeparatedList( SF.Attribute(SF.IdentifierName("JsonProperty")) .WithArgumentList( SF.AttributeArgumentList(attributes)))))); }
SeparatedSyntaxList <EnumMemberDeclarationSyntax> CreateValues() { return(SF.SeparatedList(Type.Members.Select(GetMemberDeclaration))); EnumMemberDeclarationSyntax GetMemberDeclaration(EnumMember member) { EnumMemberDeclarationSyntax declaration = SF.EnumMemberDeclaration ( SF.List(GetAttributeLists()), Symbols.GetNameSyntaxToken(Type, member), null ); if (member.Docs != null) { DocCommentGeneratorBase <EnumMember> generator = new EnumMemberDocCommentGenerator(member); SyntaxTriviaList trivia = SF.TriviaList(generator.CreateDocComment()); declaration = declaration.WithLeadingTrivia(trivia); } return(declaration); IEnumerable <AttributeListSyntax> GetAttributeLists() { yield return(SF.AttributeList(SF.SingletonSeparatedList( SF.Attribute( SF.ParseName("JsiiEnumMember"), SF.ParseAttributeArgumentList($"(name: \"{member.Name}\")") ) ))); if (member.Docs?.Stability == Stability.Deprecated) { var argument = member.Docs?.Deprecated != null?SF.Literal(member.Docs?.Deprecated).ToString() : ""; yield return(SF.AttributeList(SF.SingletonSeparatedList( SF.Attribute( SF.ParseName("System.Obsolete"), SF.ParseAttributeArgumentList($"({argument})") ) ))); } } } }
/// <summary> /// Yields the CompiledHandlebars Class Declaration ClassDeclaration /// public static class CompiledHandlebarsTemplate<TViewModel> {} /// </summary> internal static ClassDeclarationSyntax CompiledHandlebarsClassDeclaration(string templateName, string attribute) { return (SF.ClassDeclaration( new SyntaxList <AttributeListSyntax>().Add( SF.AttributeList(new SeparatedSyntaxList <AttributeSyntax>().Add( SF.Attribute(SF.ParseName(attribute))) )), SF.TokenList( SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)), SF.Identifier(templateName), default(TypeParameterListSyntax), default(BaseListSyntax), default(SyntaxList <TypeParameterConstraintClauseSyntax>), default(SyntaxList <MemberDeclarationSyntax>) )); }
private static MemberDeclarationSyntax GenerateSerializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> serializeInner = () => SerializationManager.SerializeInner(default(object), default(ISerializationContext), default(Type)); var contextParameter = SF.IdentifierName("context"); var body = new List <StatementSyntax> { SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("input") .WithInitializer( SF.EqualsValueClause( SF.CastExpression(type.GetTypeSyntax(), SF.IdentifierName("untypedInput")))))) }; var inputExpression = SF.IdentifierName("input"); // Serialize all members. foreach (var field in fields) { body.Add( SF.ExpressionStatement( serializeInner.Invoke() .AddArgumentListArguments( SF.Argument(field.GetGetter(inputExpression, forceAvoidCopy: true)), SF.Argument(contextParameter), SF.Argument(SF.TypeOfExpression(field.FieldInfo.FieldType.GetTypeSyntax()))))); } return (SF.MethodDeclaration(typeof(void).GetTypeSyntax(), "Serializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("untypedInput")).WithType(typeof(object).GetTypeSyntax()), SF.Parameter(SF.Identifier("context")).WithType(typeof(ISerializationContext).GetTypeSyntax()), SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(SerializerMethodAttribute).GetNameSyntax())))); }
private SyntaxList <MemberDeclarationSyntax> GenerateProperties(List <Property> props) { return(SF.List(props.Select(p => { //return (MemberDeclarationSyntax)SF.PropertyDeclaration( // SF.PredefinedType( // SF.Token(SyntaxKind.StringKeyword)), // SF.Identifier(p.CleanName)) // .WithAttributeLists( // SF.SingletonList( // SF.AttributeList( // GenerateAttributes(p.Attributes)))) // .WithModifiers( // SF.TokenList( // SF.Token(SyntaxKind.PublicKeyword))) // .WithAccessorList( // SF.AccessorList( // SF.List( // new AccessorDeclarationSyntax[]{ // SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) // .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)), // SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) // .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)) // }))); return (MemberDeclarationSyntax)p.ToDeclarationSyntax() .WithAttributeLists( SF.SingletonList( SF.AttributeList( GenerateAttributes(p.XmlAttributes)))) .WithModifiers( SF.TokenList( SF.Token(SyntaxKind.PublicKeyword))) .WithAccessorList( SF.AccessorList( SF.List( new AccessorDeclarationSyntax[] { SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)), SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)) }))); }).ToList())); }
SyntaxList <AttributeListSyntax> GetAttributeLists() { return(SF.List(new[] { SF.AttributeList(SF.SeparatedList(GetAttributes())) })); IEnumerable <AttributeSyntax> GetAttributes() { SyntaxToken nameLiteral = SF.Literal(Property.Name); SyntaxToken typeJsonLiteral = SF.Literal(JsonConvert.SerializeObject(Property.Type)); SyntaxToken trueLiteral = SF.Token(SyntaxKind.TrueKeyword); string argumentList = IsOverride ? $"({nameLiteral}, {typeJsonLiteral}, {trueLiteral})" : $"({nameLiteral}, {typeJsonLiteral})"; yield return(SF.Attribute( SF.ParseName("JsiiProperty"), SF.ParseAttributeArgumentList(argumentList) )); } }
SyntaxList <AttributeListSyntax> GetAttributeLists() { return(SF.List(GetAttributesLists())); IEnumerable <AttributeListSyntax> GetAttributesLists() { SyntaxToken nameLiteral = SF.Literal(Property.Name); SyntaxToken typeJsonLiteral = SF.Literal(JsonConvert.SerializeObject(Property.Type, SerializerSettings)); SyntaxToken trueLiteral = SF.Token(SyntaxKind.TrueKeyword); string argumentList = $"name: {nameLiteral}, typeJson: {typeJsonLiteral}"; if (Property.IsOptional) { argumentList += $", isOptional: {trueLiteral}"; } if (IsOverride) { argumentList += $", isOverride: {trueLiteral}"; } yield return(SF.AttributeList(SF.SingletonSeparatedList(SF.Attribute( SF.ParseName("JsiiProperty"), SF.ParseAttributeArgumentList($"({argumentList})") )))); if (Property.Docs?.Stability == Stability.Deprecated) { var argument = Property.Docs?.Deprecated != null?SF.Literal(Property.Docs?.Deprecated).ToString() : ""; yield return(SF.AttributeList(SF.SingletonSeparatedList(SF.Attribute( SF.ParseName("System.Obsolete"), SF.ParseAttributeArgumentList($"({argument})") )))); } } }
private ClassDeclarationSyntax CreateClass(SymbolData symbol) { var className = symbol.Name.ToClassName(); var node = SF.ClassDeclaration(className) .AddModifiers(SF.Token(SyntaxKind.PublicKeyword)); if (_options.IsJsonSerializable) { node = node.WithAttributeLists( SF.SingletonList( SF.AttributeList( SF.SingletonSeparatedList( SF.Attribute(SF.IdentifierName("JsonObject")))))); } if (!string.IsNullOrEmpty(symbol.Summary)) { var comment = new DocumentComment() { Summary = symbol.Summary }; node = node.WithLeadingTrivia(comment.ConstructTriviaList()); } var props = new List <MemberDeclarationSyntax>(); foreach (var member in symbol.Members) { props.Add(ConstructImpl(member) as MemberDeclarationSyntax); if (member.TypeName == "object") { var childSymbol = member.CreateInstanceSymbol(); props.Add(CreateProperty(childSymbol)); } } return(node.AddMembers(props.ToArray())); }
SyntaxList <AttributeListSyntax> GetAttributeLists() { return(SF.List(new[] { SF.AttributeList(SF.SeparatedList(GetAttributes())) })); IEnumerable <AttributeSyntax> GetAttributes() { SyntaxToken nameLiteral = SF.Literal(Method.Name); SyntaxToken returnsJsonLiteral = Method.Returns == null? SF.Token(SyntaxKind.NullKeyword) : SF.Literal(JsonConvert.SerializeObject(Method.Returns)); SyntaxToken parametersJsonLiteral = Method.GetParametersJsonSyntaxToken(); SyntaxToken trueLiteral = SF.Token(SyntaxKind.TrueKeyword); string argumentList = IsOverride ? $"({nameLiteral}, {returnsJsonLiteral}, {parametersJsonLiteral}, {trueLiteral})" : $"({nameLiteral}, {returnsJsonLiteral}, {parametersJsonLiteral})"; yield return(SF.Attribute( SF.ParseName("JsiiMethod"), SF.ParseAttributeArgumentList(argumentList) )); } }