public ExpressionSyntax AddExplicitConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeConversionKind conversionKind, bool addParenthesisIfNeeded = false, bool isConst = false, ITypeSymbol forceTargetType = null) { var typeInfo = ModelExtensions.GetTypeInfo(_semanticModel, vbNode); var vbType = typeInfo.Type; var vbConvertedType = forceTargetType ?? typeInfo.ConvertedType; if (isConst && _expressionEvaluator.GetConstantOrNull(vbNode, vbConvertedType, csNode) is ExpressionSyntax constLiteral) { return(constLiteral); } switch (conversionKind) { case TypeConversionKind.Unknown: case TypeConversionKind.Identity: return(addParenthesisIfNeeded ? VbSyntaxNodeExtensions.ParenthesizeIfPrecedenceCouldChange(vbNode, csNode) : csNode); case TypeConversionKind.DestructiveCast: case TypeConversionKind.NonDestructiveCast: return(CreateCast(csNode, vbConvertedType)); case TypeConversionKind.Conversion: return(AddExplicitConvertTo(vbNode, csNode, vbType, vbConvertedType));; case TypeConversionKind.NullableBool: return(SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, csNode, LiteralConversions.GetLiteralExpression(true))); case TypeConversionKind.StringToCharArray: var memberAccessExpressionSyntax = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, csNode, SyntaxFactory.IdentifierName(nameof(string.ToCharArray))); return(SyntaxFactory.InvocationExpression(memberAccessExpressionSyntax, SyntaxFactory.ArgumentList())); default: throw new ArgumentOutOfRangeException(); } }
public bool TryConvertToNullOrEmptyCheck(VBSyntax.BinaryExpressionSyntax node, ExpressionSyntax lhs, ExpressionSyntax rhs, out CSharpSyntaxNode visitBinaryExpression) { bool lhsEmpty = IsNothingOrEmpty(node.Left); bool rhsEmpty = IsNothingOrEmpty(node.Right); if (lhsEmpty || rhsEmpty) { var arg = lhsEmpty ? rhs : lhs; var nullOrEmpty = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("string"), SyntaxFactory.IdentifierName("IsNullOrEmpty")), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(arg) }))); { visitBinaryExpression = NegateIfNeeded(node, nullOrEmpty); return(true); } } visitBinaryExpression = null; return(false); }
private MemberDeclarationSyntax TypedMockProviderField() { return(F.FieldDeclaration(F.VariableDeclaration(TypesForSymbols.TypedMockProvider()).WithVariables( F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(MockProviderName)) .WithInitializer(F.EqualsValueClause(F.ObjectCreationExpression(TypesForSymbols.TypedMockProvider()) .WithArgumentList(F.ArgumentList()))))) ).WithModifiers(F.TokenList(F.Token(SyntaxKind.PrivateKeyword), F.Token(SyntaxKind.ReadOnlyKeyword)))); }
protected override ExpressionSyntax ExplicitInterfaceMemberMemberMockInstance() { return(F.InvocationExpression(F.GenericName(MemberMockName).WithTypeArgumentList(TypeArgumentList())).WithArgumentList(F.ArgumentList())); }
public static InvocationExpressionSyntax OptionalGetValueOrDefault(ExpressionSyntax optionalOfTExpression, ExpressionSyntax defaultValue) { return(SF.InvocationExpression( SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, optionalOfTExpression, SF.IdentifierName(nameof(Option <int> .ValueOr))), SF.ArgumentList(SF.SingletonSeparatedList(SF.Argument(defaultValue))))); }
/// <summary> /// Create a new <see cref="ExpressionSyntax"/> that invokes the <see cref="method"/>. /// </summary> /// <param name="moduleType">The module type.</param> /// <param name="method">The method to invoke.</param> /// <returns>The <see cref="ExpressionSyntax"/>.</returns> private ExpressionSyntax InvokeCommand(Type moduleType, MethodInfo method) { var moduleSyntaxType = S.ParseTypeName(moduleType.FullName.Replace('+', '.')); var listSyntax = S.ArgumentList(); var constructor = moduleType.GetConstructors().FirstOrDefault(); if (constructor != null) { listSyntax = listSyntax.AddArguments(constructor.GetParameters().Select(p => S.Argument(GetValueFactory(p))).ToArray()); } var moduleInstance = S.ObjectCreationExpression(moduleSyntaxType).WithArgumentList(listSyntax); var contextProperty = moduleType .GetProperties() .FirstOrDefault(p => p.GetCustomAttributes <ModuleContextAttribute>().Any()); if (contextProperty != null) { var contextInstance = S.ObjectCreationExpression(ModuleContextType) .WithInitializer( S.InitializerExpression( SyntaxKind.ObjectInitializerExpression, S.SingletonSeparatedList <ExpressionSyntax>( S.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, S.IdentifierName(nameof(ModuleContext.Context)), S.IdentifierName(ArgumentContext) )))); moduleInstance = moduleInstance.WithInitializer( S.InitializerExpression( SyntaxKind.ObjectInitializerExpression, S.SingletonSeparatedList <ExpressionSyntax>( S.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, S.IdentifierName(contextProperty.Name), contextInstance )))); } ExpressionSyntax invoke = S.InvocationExpression( S.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, moduleInstance, S.IdentifierName(method.Name) ), S.ArgumentList().AddArguments(method.GetParameters().Select(p => S.Argument(GetValueFactory(p))).ToArray()) ); if (method.ReturnType == typeof(Task) || method.ReturnType == typeof(ValueTask)) { invoke = S.AwaitExpression(invoke); } else if (method.ReturnType != typeof(void)) { throw new InvalidOperationException($"The return type {method.ReturnType.Name} is not supported."); } return(invoke); }
IEnumerable <MemberDeclarationSyntax> CreateConstructors() { SyntaxToken typeName = Symbols.GetNameSyntaxToken(Type); if (Type.Initializer != null) { yield return(SF.ConstructorDeclaration ( SF.List <AttributeListSyntax>(), SF.TokenList(SF.Token( Type.IsAbstract || Type.Initializer.IsProtected ? SyntaxKind.ProtectedKeyword : SyntaxKind.PublicKeyword )), typeName, Type.Initializer.GetParameterListSyntax(Namespaces, Symbols), SF.ConstructorInitializer ( SyntaxKind.BaseConstructorInitializer, SF.ArgumentList( SF.SeparatedList(new[] { SF.Argument( SF.ObjectCreationExpression( SF.Token(SyntaxKind.NewKeyword), SF.ParseTypeName("DeputyProps"), SF.ArgumentList(SF.SeparatedList( new[] { GetBaseArgument() } )), null ) ) }) ) ), SF.Block(), null )); } yield return(SF.ConstructorDeclaration ( SF.List <AttributeListSyntax>(), SF.TokenList(SF.Token(SyntaxKind.ProtectedKeyword)), typeName, SF.ParseParameterList("(ByRefValue reference)"), SF.ConstructorInitializer ( SyntaxKind.BaseConstructorInitializer, SF.ParseArgumentList("(reference)") ), SF.Block(), null )); // This constructor allows child classes to supply their own parameter lists. It is always protected. yield return(SF.ConstructorDeclaration ( SF.List <AttributeListSyntax>(), SF.TokenList(SF.Token(SyntaxKind.ProtectedKeyword)), typeName, SF.ParseParameterList("(DeputyProps props)"), SF.ConstructorInitializer ( SyntaxKind.BaseConstructorInitializer, SF.ParseArgumentList("(props)") ), SF.Block(), null )); ArgumentSyntax GetBaseArgument() { var deputyArguments = (Type.Initializer.Parameters ?? Enumerable.Empty <Parameter>()) .Select(p => Symbols.GetNameSyntaxToken(p)) .Select(i => SF.IdentifierName(i)); // In C#, arrays of reference types are covariant. Because of this, passing a string[] // to a method that takes `params object[] args` will interperet the string array *as* // args, rather than as args' first element. To workaround with, we remove the params // keyword from DeputyBase's constructor, and always explicitly create an array of // objects when calling it. return(SF.Argument( SF.ArrayCreationExpression( SF.Token(SyntaxKind.NewKeyword), SF.ArrayType(SF.ParseTypeName("object[]")), SF.InitializerExpression( SyntaxKind.ArrayInitializerExpression, SF.SeparatedList <ExpressionSyntax>(deputyArguments) ) ) )); } }
public ConstructorBuilder CallThis(IEnumerable <ExpressionBuilder> parameters) => new ConstructorBuilder(_modifiers, _name, _parameters, SF.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SF.ArgumentList(SF.SeparatedList(parameters.Select(p => SF.Argument(p.Build()))))), _expr, _block);
public ExpressionBuilder Call(string method, IEnumerable <string> typeParameters, IEnumerable <ExpressionBuilder> expressions) => new ExpressionBuilder(SF.InvocationExpression( SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, _expr, SF.GenericName(method).WithTypeArgumentList(SF.TypeArgumentList(SF.SeparatedList(typeParameters.Select(tp => ParseType(tp)))))), SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
public ExpressionBuilder Invoke(IEnumerable <ExpressionBuilder> expressions) => new ExpressionBuilder(SF.InvocationExpression(_expr, SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
public ExpressionBuilder Call(string method, IEnumerable <ExpressionBuilder> expressions) => new ExpressionBuilder(SF.InvocationExpression(SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, _expr, SF.IdentifierName(method)), SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
private async Task <Document> Handle(Diagnostic diagnostic, CodeFixContext context) { var root = await context.Document .GetSyntaxRootAsync(context.CancellationToken) .ConfigureAwait(false); if (root is null) { return(context.Document); } var semanticModel = await context.Document.GetSemanticModelAsync(); var targetNode = root.FindNode(diagnostic.Location.SourceSpan); var methodNode = targetNode.FirstAncestorOrSelf <MethodDeclarationSyntax>(); if (methodNode is null) { return(context.Document); } var maybeMethod = semanticModel.GetDeclaredSymbol(methodNode); if (!(maybeMethod is IMethodSymbol method) || method.Parameters.IsEmpty) { return(context.Document); } var inputParameter = method.Parameters.Last(); var outputType = method.ReturnType; var descendantNodes = targetNode .DescendantNodes() .ToArray(); var returnStatement = descendantNodes .OfType <ReturnStatementSyntax>() .LastOrDefault(); var allAssignments = descendantNodes .OfType <AssignmentExpressionSyntax>() .ToArray(); var outputProperties = outputType .GetAllPublicProperties() .ToDictionary(o => o.Name, o => o.Type); var assignmentProperties = allAssignments .Select(o => o.Left) .OfType <MemberAccessExpressionSyntax>() .Select(o => o.Name.Identifier.Text) .ToImmutableHashSet(); var missingProperties = outputProperties .Where(o => !assignmentProperties.Contains(o.Key)) .ToArray(); if (returnStatement == null) { return(FillMethod()); } return(AddMissingAssignments()); Document AddMissingAssignments() { var newAssignmentExpressions = missingProperties .Select(property => SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName("output"), SF.IdentifierName(property.Key)), SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(inputParameter.Name), SF.IdentifierName(property.Key))) )) .ToArray(); var newRoot = root.InsertNodesBefore(returnStatement, newAssignmentExpressions); var newDocument = context.Document .WithSyntaxRoot(newRoot); return(newDocument); } Document FillMethod() { var outputVariable = SF.LocalDeclarationStatement( SF.VariableDeclaration(SF.ParseTypeName("var"), SF.SeparatedList( new[] { SF.VariableDeclarator( SF.Identifier("output"), null, SF.EqualsValueClause( SF.ObjectCreationExpression( SF.ParseTypeName(outputType.ToGlobalName()), SF.ArgumentList(), null))) }))); var newAssignmentExpressions = missingProperties .Select(property => SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName("output"), SF.IdentifierName(property.Key)), SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(inputParameter.Name), SF.IdentifierName(property.Key))) )) .ToArray(); var returnOutputVariable = SF.ReturnStatement( SF.IdentifierName("output")); var statements = new StatementSyntax[] { outputVariable } .Concat(newAssignmentExpressions) .Concat(new[] { returnOutputVariable }); var newRoot = root.ReplaceNode(methodNode, methodNode.WithBody(SF.Block(statements))); var newDocument = context.Document .WithSyntaxRoot(newRoot); return(newDocument); } }
public static ArgumentListSyntax PrependArgument(this ArgumentListSyntax list, ArgumentSyntax argument) { return(SF.ArgumentList(SF.SingletonSeparatedList(argument)) .AddArguments(list.Arguments.ToArray())); }
private MemberDeclarationSyntax ExplicitInterfaceMember() { var mockedProperty = F.PropertyDeclaration(ValueWithReadonlyTypeSyntax, Symbol.Name) .WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol))); if (Symbol.IsReadOnly) { ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName)); if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly) { invocation = F.RefExpression(invocation); } mockedProperty = mockedProperty .WithExpressionBody(F.ArrowExpressionClause(invocation)) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)); } else { if (!Symbol.IsWriteOnly) { mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName)))) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)) ); } if (!Symbol.IsReadOnly) { mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName), F.ArgumentList(F.SeparatedList(new[] { F.Argument(F.IdentifierName("value")) }))))) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)) ); } } return(mockedProperty); }
public static ArgumentListSyntax Arguments(params IdentifierNameSyntax[] args) { return(SF.ArgumentList(new SeparatedSyntaxList <ArgumentSyntax>().AddRange(args.AsEnumerable().Select(arg => SF.Argument(arg))))); }
void Save(string packageOutputRoot, ISymbolMap symbols, Assembly assembly, string tarballFileName, string jsiiFileName) { if (assembly.Docs != null) { // TODO: Use Microsoft.Extensions.Logging instead of Console.Error. Console.Error.WriteLine($"Warning: Ignoring documentation comment on assembly {assembly.Name}. Assembly-level documentation comments are not supported for .NET"); } SaveProjectFile(); SaveAssemblyInfo(assembly.Name, assembly.Version, tarballFileName); SaveDependencyAnchorFile(); foreach (Type type in assembly.Types?.Values ?? Enumerable.Empty <Type>()) { SaveType(type); } void SaveProjectFile() { XElement project = new XElement("Project", new XAttribute("Sdk", "Microsoft.NET.Sdk"), new XElement("PropertyGroup", assembly.GetMsBuildProperties()), new XElement("ItemGroup", new XElement("EmbeddedResource", new XAttribute("Include", tarballFileName) ) ), new XElement("ItemGroup", new XElement("PackageReference", new XAttribute("Include", "Amazon.JSII.Runtime"), new XAttribute("Version", JsiiVersion.Version) ), GetDependencies() .Distinct() .Select(d => new { Package = symbols.GetAssemblyName(d.Key), Version = d.Value.GetDecoratedVersion() }) .Select(d => new XElement("PackageReference", new XAttribute("Include", d.Package), new XAttribute("Version", d.Version) ) ) ) ); if (!_fileSystem.Directory.Exists(packageOutputRoot)) { _fileSystem.Directory.CreateDirectory(packageOutputRoot); } // Save to StringBuilder instead of directly to path, so that we can // redirect the output through the filesystem shim. Project files are // small, so this shouldn't be a memory hog. StringBuilder builder = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings { // Visual Studio omits the XML declaration when creating project files, so we do too. OmitXmlDeclaration = true, // Visual Studio indents project files (they are often edited by hand), so we do too. Indent = true, }; using (XmlWriter writer = XmlWriter.Create(builder, settings)) { project.Save(writer); } string csProjPath = Path.Combine(packageOutputRoot, $"{assembly.GetNativePackageId()}.csproj"); _fileSystem.File.WriteAllText(csProjPath, builder.ToString()); IEnumerable <KeyValuePair <string, PackageVersion> > GetDependencies() { foreach (KeyValuePair <string, PackageVersion> dependency in GetDependenciesCore(assembly)) { yield return(dependency); } IEnumerable <KeyValuePair <string, PackageVersion> > GetDependenciesCore(DependencyRoot root) { if (root.Dependencies == null) { yield break; } foreach (var kvp in root.Dependencies) { yield return(kvp); foreach (KeyValuePair <string, PackageVersion> dependency in GetDependenciesCore(kvp.Value)) { yield return(dependency); } } } } } void SaveDependencyAnchorFile() { string anchorNamespace = $"{assembly.GetNativeNamespace()}.Internal.DependencyResolution"; var syntaxTree = SF.SyntaxTree( SF.CompilationUnit( SF.List <ExternAliasDirectiveSyntax>(), SF.List <UsingDirectiveSyntax>(), SF.List <AttributeListSyntax>(), SF.List <MemberDeclarationSyntax>(new[] { SF.NamespaceDeclaration( SF.IdentifierName(anchorNamespace), SF.List <ExternAliasDirectiveSyntax>(), SF.List <UsingDirectiveSyntax>(), SF.List(new MemberDeclarationSyntax[] { GenerateDependencyAnchor() }) ) }) ).NormalizeWhitespace(elasticTrivia: true) ); string directory = GetNamespaceDirectory(packageOutputRoot, @anchorNamespace); SaveSyntaxTree(directory, "Anchor.cs", syntaxTree); ClassDeclarationSyntax GenerateDependencyAnchor() { return(SF.ClassDeclaration( SF.List <AttributeListSyntax>(), SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)), SF.Identifier("Anchor"), null, null, SF.List <TypeParameterConstraintClauseSyntax>(), SF.List(new MemberDeclarationSyntax[] { SF.ConstructorDeclaration( SF.List <AttributeListSyntax>(), SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)), SF.Identifier("Anchor"), SF.ParameterList(SF.SeparatedList <ParameterSyntax>()), null, SF.Block(SF.List(GenerateAnchorReferences())), null ) }) )); IEnumerable <StatementSyntax> GenerateAnchorReferences() { return(assembly.Dependencies?.Keys .Select(k => assembly.GetNativeNamespace(k)) .Select(n => $"{n}.Internal.DependencyResolution.Anchor") .Select(t => SF.ExpressionStatement(SF.ObjectCreationExpression( SF.Token(SyntaxKind.NewKeyword), SF.ParseTypeName(t), SF.ArgumentList(SF.SeparatedList <ArgumentSyntax>()), null ))) ?? Enumerable.Empty <StatementSyntax>()); } } } void SaveAssemblyInfo(string name, string version, string tarball) { SyntaxTree assemblyInfo = SF.SyntaxTree( SF.CompilationUnit( SF.List <ExternAliasDirectiveSyntax>(), SF.List(new[] { SF.UsingDirective(SF.ParseName("Amazon.JSII.Runtime.Deputy")) }), SF.List(new[] { SF.AttributeList( SF.AttributeTargetSpecifier( SF.Identifier("assembly"), SF.Token(SyntaxKind.ColonToken) ), SF.SeparatedList(new[] { SF.Attribute( SF.ParseName("JsiiAssembly"), SF.ParseAttributeArgumentList($"({SF.Literal(name)}, {SF.Literal(version)}, {SF.Literal(tarball)})") ) }) ) }), SF.List <MemberDeclarationSyntax>() ).NormalizeWhitespace(elasticTrivia: true) ); string assemblyInfoPath = Path.Combine(packageOutputRoot, "AssemblyInfo.cs"); _fileSystem.File.WriteAllText(assemblyInfoPath, assemblyInfo.ToString()); } void SaveType(Type type) { string @namespace = symbols.GetNamespace(type); string directory = GetNamespaceDirectory(packageOutputRoot, @namespace); switch (type.Kind) { case TypeKind.Class: { var classType = (ClassType)type; if (classType.IsAbstract) { SaveTypeFile($"{symbols.GetAbstractClassProxyName(classType)}.cs", new AbstractClassProxyGenerator(assembly.Name, classType, symbols).CreateSyntaxTree()); } SaveTypeFile($"{symbols.GetName(type)}.cs", new ClassGenerator(assembly.Name, classType, symbols).CreateSyntaxTree()); return; } case TypeKind.Enum: { SaveTypeFile($"{symbols.GetName(type)}.cs", new EnumGenerator(assembly.Name, (EnumType)type, symbols).CreateSyntaxTree()); return; } case TypeKind.Interface: { InterfaceType interfaceType = (InterfaceType)type; SaveTypeFile($"{symbols.GetName(interfaceType)}.cs", new InterfaceGenerator(assembly.Name, interfaceType, symbols).CreateSyntaxTree()); SaveTypeFile($"{symbols.GetInterfaceProxyName(interfaceType)}.cs", new InterfaceProxyGenerator(assembly.Name, interfaceType, symbols).CreateSyntaxTree()); if (interfaceType.IsDataType) { SaveTypeFile($"{symbols.GetInterfaceDefaultName(interfaceType)}.cs", new InterfaceDefaultGenerator(assembly.Name, interfaceType, symbols) .CreateSyntaxTree()); } return; } default: { throw new ArgumentException($"Unkown type kind: {type.Kind}", nameof(type)); } } void SaveTypeFile(string filename, SyntaxTree syntaxTree) { SaveSyntaxTree(directory, filename, syntaxTree); } } void SaveSyntaxTree(string directory, string filename, SyntaxTree syntaxTree) { if (!_fileSystem.Directory.Exists(directory)) { _fileSystem.Directory.CreateDirectory(directory); } _fileSystem.File.WriteAllText( Path.Combine(directory, filename), syntaxTree.ToString() ); } }
public static ObjectCreationExpressionSyntax ObjectCreationWitoutArgs(INamedTypeSymbol sym) { return(SF.ObjectCreationExpression(SF.ParseTypeName(sym.ToString()), SF.ArgumentList(), default)); }
public ClassDeclarationSyntax GenerateHelper() { if (!HasImports) { return(null); } var xAttributeList = SyntaxFactory.FieldDeclaration( SyntaxFactory.List <AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.PrivateKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)), CommonConversions.CreateVariableDeclarationAndAssignment( "namespaceAttributes", SyntaxFactory.InitializerExpression( CSSyntaxKind.ArrayInitializerExpression, SyntaxFactory.SeparatedList <ExpressionSyntax>( from x in _xNamespaceFields let fieldIdentifierName = SyntaxFactory.IdentifierName(x.Declaration.Variables.Single().Identifier) let namespaceNameExpression = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, fieldIdentifierName, SyntaxFactory.IdentifierName("NamespaceName")) let attributeNameExpression = fieldIdentifierName.IsEquivalentTo(DefaultIdentifierName) ? CommonConversions.Literal("xmlns") : BuildXmlnsAttributeName(fieldIdentifierName) let arguments = SyntaxFactory.Argument(attributeNameExpression).Yield().Concat(SyntaxFactory.Argument(namespaceNameExpression)) select SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("XAttribute")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))))), SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName("XAttribute"), SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())))))); var boilerplate = SyntaxFactory.ParseStatement(@" TContainer Apply<TContainer>(TContainer x) where TContainer : XContainer { foreach (var d in x.Descendants()) { foreach (var n in namespaceAttributes) { var a = d.Attribute(n.Name); if (a != null && a.Value == n.Value) { a.Remove(); } } } x.Add(namespaceAttributes); return x; }") as LocalFunctionStatementSyntax; var applyMethod = SyntaxFactory.MethodDeclaration( SyntaxFactory.List <AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)), boilerplate.ReturnType, null, boilerplate.Identifier, boilerplate.TypeParameterList, boilerplate.ParameterList, boilerplate.ConstraintClauses, boilerplate.Body, boilerplate.ExpressionBody); return(SyntaxFactory.ClassDeclaration( SyntaxFactory.List <AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)), HelperClassUniqueIdentifierName.Identifier, null, null, SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(), SyntaxFactory.List(_xNamespaceFields.Concat <MemberDeclarationSyntax>(xAttributeList).Concat(applyMethod)) )); }
public static InvocationExpressionSyntax InvocationExpression(IdentifierNameSyntax source, IdentifierNameSyntax member, params ArgumentSyntax[] args) { return(SF.InvocationExpression(SimpleMemberAccess(source, member), SF.ArgumentList().AddArguments(args))); }
private void AddCtor(WebInfoGenerationData genData, List <WebInfoGenerationData> childrenGens) { var statements = new List <StatementSyntax>(); var infoInit = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(InfoClassName), SF.ObjectCreationExpression(SF.ParseTypeName($"{InfoStaticClassName}.{InfoClassName}")) .WithArgumentList(SF.ArgumentList()) ) ); statements.Add(infoInit); var locatorInit = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(LocatorClassName), SF.ObjectCreationExpression(SF.IdentifierName(nameof(WebLocatorInfo))) .WithArgumentList(SF.ArgumentList()) ) ); statements.Add(locatorInit); var locatorProps = new List <string> { nameof(WebLocatorInfo.LocatorType), nameof(WebLocatorInfo.LocatorValue), nameof(WebLocatorInfo.IsRelative) }; foreach (var locatorProp in locatorProps) { var st = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(LocatorClassName), SF.IdentifierName(locatorProp) ), SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(InfoStaticClassName), SF.IdentifierName(LocatorStaticClassName) ), SF.IdentifierName(locatorProp) ) ) ); statements.Add(st); } if (childrenGens?.Count > 0) { var elsInit = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(nameof(CombinedWebElementInfo.Elements)), SF.ObjectCreationExpression( SF.GenericName(SF.Identifier("List")) .WithTypeArgumentList(SF.TypeArgumentList(SF.SingletonSeparatedList <TypeSyntax>(SF.IdentifierName(nameof(WebElementInfo))))) ) .WithArgumentList(SF.ArgumentList()) ) ); statements.Add(elsInit); foreach (var childGen in childrenGens) { var propInit = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(childGen.PropertyName), SF.ObjectCreationExpression(SF.IdentifierName(childGen.ClassName)) .WithArgumentList(SF.ArgumentList()) ) ); statements.Add(propInit); var parentSt = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(childGen.PropertyName), SF.IdentifierName(nameof(WebElementInfo.Parent)) ), SF.ThisExpression() ) ); statements.Add(parentSt); var elsAddSt = SF.ExpressionStatement( SF.InvocationExpression( SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(nameof(CombinedWebElementInfo.Elements)), SF.IdentifierName("Add") ) ).WithArgumentList( SF.ArgumentList( SF.SingletonSeparatedList(SF.Argument(SF.IdentifierName(childGen.PropertyName))) ) ) ); statements.Add(elsAddSt); } } var summary = GetDocCommentWithText(genData.Element.Description); var ctor = SF.ConstructorDeclaration(SF.Identifier(genData.ClassName)) .WithBody(SF.Block(statements)) .WithModifiers(SF.TokenList(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(summary)))); var cd = genData.ClassSyntax.AddMembers(ctor); genData.ClassSyntax = cd; }
public static InvocationExpressionSyntax InvocationExpression0(IdentifierNameSyntax source, IdentifierNameSyntax member) { return(SF.InvocationExpression(SimpleMemberAccess(source, member), SF.ArgumentList())); }
private MemberDeclarationSyntax ExplicitInterfaceMember() { var mockedIndexer = F.IndexerDeclaration(ValueWithReadonlyTypeSyntax) .WithParameterList(F.BracketedParameterList(F.SeparatedList(Symbol.Parameters.Select(a => F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious())))))) .WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol))); if (Symbol.IsReadOnly) { ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName), F.ArgumentList(F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name)))))); if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly) { invocation = F.RefExpression(invocation); } mockedIndexer = mockedIndexer .WithExpressionBody(F.ArrowExpressionClause(invocation)) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)); } else { if (!Symbol.IsWriteOnly) { var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name)))); mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName)) .WithArgumentList(F.ArgumentList(argumentList)))) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)) ); } if (!Symbol.IsReadOnly) { var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name)))) .Add(F.Argument(F.IdentifierName("value"))); mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName), F.ArgumentList(argumentList)))) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)) ); } } return(mockedIndexer); }
private static ArgumentListSyntax CreateArgList(params ExpressionSyntax[] copyArgs) { return(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(copyArgs.Select(SyntaxFactory.Argument)))); }