public override void VisitExpressionStatement(ExpressionStatementSyntax node)
 {
   // hack: Console.WriteLine
   var s = node.Expression.GetText().ToString().Trim();
   if (s.StartsWith("Console.WriteLine"))
   {
     var ise = node.Expression as InvocationExpressionSyntax;
     var args = ise.ArgumentList;
     cb.AppendWithIndent("cout << ")
       .Append(args.GetText().ToString().Trim('(', ')').Replace(" + ", " << ").Replace("+", " << "))
       .AppendLine(" << endl;");
   }
   else if (s.StartsWith("Environment.Exit"))
   {
     var ise = node.Expression as InvocationExpressionSyntax;
     var args = ise.ArgumentList;
     cb.AppendWithIndent("exit(")
       .Append(args.GetText().ToString().Trim('(', ')'))
       .AppendLine(");");
   }
   else
   {
     base.VisitExpressionStatement(node);
   }
 }

        /// <summary>
        /// Rewrites the statement with a raise statement.
        /// </summary>
        /// <param name="node">ExpressionStatementSyntax</param>
        /// <returns>SyntaxNode</returns>
        private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
        {
            var invocation = node.Expression as InvocationExpressionSyntax;

            var arguments = new List<ArgumentSyntax>();
            arguments.Add(invocation.ArgumentList.Arguments[0]);

            string payload = "";
            for (int i = 1; i < invocation.ArgumentList.Arguments.Count; i++)
            {
                if (i == invocation.ArgumentList.Arguments.Count - 1)
                {
                    payload += invocation.ArgumentList.Arguments[i].ToString();
                }
                else
                {
                    payload += invocation.ArgumentList.Arguments[i].ToString() + ", ";
                }
            }

            arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
                "new " + arguments[0].ToString() + "(" + payload + ")"));
            invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
                SyntaxFactory.SeparatedList(arguments)));

            var text = "{ " +
                node.WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Raise"))).ToString() +
                "return; }";
            var rewritten = SyntaxFactory.ParseStatement(text);
            rewritten = rewritten.WithTriviaFrom(node);

            return rewritten;
        }

        public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
        {
            var extension = null as SyntacticalExtension<SyntaxNode>;
            var expr = node.Expression;
            InvocationExpressionSyntax call = null;

            if (expr is InvocationExpressionSyntax)
                call = expr as InvocationExpressionSyntax;
            else if (expr is AssignmentExpressionSyntax)
            {
                var assignment = expr as AssignmentExpressionSyntax;
                call = assignment.Right as InvocationExpressionSyntax;
            }

            if (call != null)
                extension = codeExtension(call);

            if (extension != null)
            {

                if (extension.Kind != ExtensionKind.Code)
                {
                    //td: error, incorrect extension (i.e. a code extension being used inside a type)
                    return node;
                }

                _lookahead = CheckCodeExtension(node, extension);
                return null;
            }

            return node;
        }

		/// <summary>
		///     Normalizes the <paramref name="statement" /> if it is an invocation of a <c>SetInitialValues</c> method.
		/// </summary>
		public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
		{
			var invocationExpression = statement.Expression as InvocationExpressionSyntax;
			if (invocationExpression == null)
				return base.VisitExpressionStatement(statement);

			var methodSymbol = invocationExpression.GetReferencedSymbol(SemanticModel);
			if (methodSymbol.Name != "SetInitialValues" || !methodSymbol.IsStatic)
				return base.VisitExpressionStatement(statement);

			var isComponentMethod = methodSymbol.ContainingType.Equals(Compilation.GetComponentClassSymbol());
			var isFaultMethod = methodSymbol.ContainingType.Equals(Compilation.GetFaultClassSymbol());
			var isOccurrenceMethod = methodSymbol.ContainingType.Equals(Compilation.GetOccurrencePatternClassSymbol());

			if (!isComponentMethod && !isFaultMethod && !isOccurrenceMethod)
				return base.VisitExpressionStatement(statement);

			// MetadataBuilders.GetBuilder(this)
			var metadataBuilderSymbol = Syntax.TypeExpression(Compilation.GetTypeSymbol(typeof(MetadataBuilders)));
			var getBuilderMethod = Syntax.MemberAccessExpression(metadataBuilderSymbol, "GetBuilder");
			var builder = Syntax.InvocationExpression(getBuilderMethod, Syntax.ThisExpression());

			// ReflectionHelpers.GetField(typeof(...), typeof(...), "...")
			var fieldSymbol = invocationExpression.ArgumentList.Arguments[0].Expression.GetReferencedSymbol<IFieldSymbol>(SemanticModel);
			var fieldInfo = fieldSymbol.GetFieldInfoExpression(Syntax);

			// .WithInitialValues()
			var withInitialValues = Syntax.MemberAccessExpression(builder, Syntax.GenericName("WithInitialValues", fieldSymbol.Type));
			var arguments = new List<ArgumentSyntax>(invocationExpression.ArgumentList.Arguments.Skip(1));
			arguments.Insert(0, (ArgumentSyntax)Syntax.Argument(fieldInfo));
			return Syntax.ExpressionStatement(Syntax.InvocationExpression(withInitialValues, arguments)).EnsureLineCount(statement);
		}

		/// <summary>
		///     Normalizes the <paramref name="statement" /> if it is an invocation of a state machine method.
		/// </summary>
		public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
		{
			var invocationExpression = statement.Expression as InvocationExpressionSyntax;
			if (invocationExpression == null)
				return base.VisitExpressionStatement(statement);

			var methodSymbol = invocationExpression.GetReferencedSymbol(SemanticModel);
			if (!methodSymbol.IsStatic)
				return base.VisitExpressionStatement(statement);

			if (methodSymbol.Name != "InitialState" && methodSymbol.Name != "InitialStates" && methodSymbol.Name != "Transition")
				return base.VisitExpressionStatement(statement);

			var isComponentMethod = methodSymbol.ContainingType.Equals(Compilation.GetComponentClassSymbol());
			if (!isComponentMethod)
				return base.VisitExpressionStatement(statement);

			// MetadataBuilders.GetBuilder(this)
			var metadataBuilderSymbol = Syntax.TypeExpression(Compilation.GetTypeSymbol(typeof(MetadataBuilders)));
			var getBuilderMethod = Syntax.MemberAccessExpression(metadataBuilderSymbol, "GetBuilder");
			var builder = Syntax.InvocationExpression(getBuilderMethod, Syntax.ThisExpression());

			if (methodSymbol.Name == "Transition")
				return SyntaxFactory.Block(NormalizeTransitions(builder, invocationExpression)).NormalizeWhitespace().EnsureLineCount(statement);

			// .WithInitialStates(states)
			var withInitialStates = Syntax.MemberAccessExpression(builder, "WithInitialStates");
			var arguments = invocationExpression.ArgumentList.Arguments;
			return Syntax.ExpressionStatement(Syntax.InvocationExpression(withInitialStates, arguments)).EnsureLineCount(statement);
		}

		/// <summary>
		///   Normalizes the <paramref name="statement" />.
		/// </summary>
		public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
		{
			var transformed = TransformExpression(statement.Expression);
			if (transformed == null)
				return statement;

			return transformed.EnsureLineCount(statement);
		}

        /// <summary>
        /// Rewrites the raise statement.
        /// </summary>
        /// <param name="node">ExpressionStatementSyntax</param>
        /// <returns>SyntaxNode</returns>
        private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
        {
            var text = "{ " + node.ToString() + "return; }";
            var rewritten = SyntaxFactory.ParseStatement(text);
            rewritten = rewritten.WithTriviaFrom(node);

            return rewritten;
        }

 private static void CheckForCondition(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationNode,
   ExpressionStatementSyntax expressionStatementParent, DiagnosticDescriptor descriptor)
 {
   // Make sure the invocation's containing type is not the same as the class that contains it
   if ((invocationNode.DescendantNodesAndTokens().Any(_ => _.IsKind(SyntaxKind.DotToken)) &&
     !invocationNode.DescendantNodesAndTokens().Any(_ => _.IsKind(SyntaxKind.ThisExpression) || _.IsKind(SyntaxKind.BaseExpression))) &&
     (!expressionStatementParent?.DescendantNodesAndTokens()?.Any(_ => _.IsKind(SyntaxKind.EqualsToken)) ?? false) &&
     !(invocationNode.DescendantNodes()?.Any(_ => new ContainsInvocationExpressionWalker(_).HasIssue) ?? false) &&
     !FindSaveAssignmentIssueAnalyzer.IsReturnValue(invocationNode))
   {
     context.ReportDiagnostic(Diagnostic.Create(descriptor, invocationNode.GetLocation()));
   }
 }

 private static async Task<Document> UseExistenceOperatorAsyncWithAssignmentAsync(Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken, ExpressionStatementSyntax expressionIf)
 {
     var memberAccessAssignment = (AssignmentExpressionSyntax)expressionIf.Expression;
     var newMemberAccess = ((MemberAccessExpressionSyntax)memberAccessAssignment.Right).ToConditionalAccessExpression();
     var newExpressionStatement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, memberAccessAssignment.Left, newMemberAccess))
         .WithLeadingTrivia(ifStatement.GetLeadingTrivia())
         .WithTrailingTrivia(ifStatement.GetTrailingTrivia())
         .WithAdditionalAnnotations(Formatter.Annotation);
     var root = await document.GetSyntaxRootAsync(cancellationToken);
     var newRoot = root.ReplaceNode(ifStatement, newExpressionStatement);
     var newDocument = document.WithSyntaxRoot(newRoot);
     return newDocument;
 }

 private static SyntaxNode CreateRootAddingDisposeToEndOfMethod(SyntaxNode root, ExpressionStatementSyntax statement, ILocalSymbol identitySymbol)
 {
     var method = statement.FirstAncestorOrSelf<MethodDeclarationSyntax>();
     var newDispose = ImplementsDisposableExplicitly(identitySymbol.Type)
         ? SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(
             SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
             SyntaxFactory.ParenthesizedExpression(SyntaxFactory.CastExpression(SyntaxFactory.ParseName("System.IDisposable").WithAdditionalAnnotations(Simplifier.Annotation), SyntaxFactory.IdentifierName(identitySymbol.Name))),
             SyntaxFactory.IdentifierName("Dispose"))))
         : SyntaxFactory.ParseStatement($"{identitySymbol.Name}.Dispose();");
     newDispose = newDispose.WithAdditionalAnnotations(Formatter.Annotation);
     var last = method.Body.Statements.Last();
     var newRoot = root.InsertNodesAfter(method.Body.Statements.Last(), new[] { newDispose });
     return newRoot;
 }

        public override void VisitExpressionStatement(ExpressionStatementSyntax node)
        {
            if (node.DescendantNodes().OfType<IdentifierNameSyntax>().Any(a => "WaitAll".Equals(a.ToString()))
                && node.Parent.ChildNodes().Any(a => a.ToString().Contains("StartNew"))
                && !node.Parent.ChildNodes().Any(a => a is ForStatementSyntax)
                && !node.Parent.ChildNodes().Any(a => a is ForEachStatementSyntax))
            {
                if (Id.ToLower().Contains("test"))
                    Helper.WriteInstance(InvokeTestFile, Id, node.Parent.ToString());
                else
                    Helper.WriteInstance(InvokeFile, Id, node.Parent.ToString());
            }

            base.VisitExpressionStatement(node);
        }

        public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
        {
            SyntaxNode retVal = null;

            if (node.Expression.Kind() == SyntaxKind.AddAssignmentExpression ||
                node.Expression.Kind() == SyntaxKind.SubtractAssignmentExpression ||
                node.Expression.Kind() == SyntaxKind.MultiplyAssignmentExpression ||
                node.Expression.Kind() == SyntaxKind.DivideAssignmentExpression)
            {
                var add = node.Expression as BinaryExpressionSyntax;
                var printValueStmt = add.Left.GetText();

                retVal = base.VisitExpressionStatement(node);
            }

            return base.VisitExpressionStatement(node);
        }

        private async Task<Document> AssignMethodReturnToReceiverAsync(CodeFixContext context, Document document, ExpressionStatementSyntax statement, string receiverName, CancellationToken c)
        {
            var rValueExpr = statement.ToString();
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
            var memberAccess = root.FindNode(context.Span)?.FirstAncestorOrSelf<MemberAccessExpressionSyntax>();

            var declaration = SyntaxFactory
                .ParseStatement($"{receiverName} = {rValueExpr}");

            var formattedDeclaration = declaration.WithTriviaFrom(statement);
            // Replace the old statement with the block:
            var newRoot = root.ReplaceNode((SyntaxNode)statement, formattedDeclaration);

            var newDocument = document.WithSyntaxRoot(newRoot);
            return newDocument;

        }

		/// <summary>
		///   Normalizes the <paramref name="statement" />.
		/// </summary>
		public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
		{
			if (!statement.Expression.IsKind(SyntaxKind.InvocationExpression))
				return statement;

			var expression = (InvocationExpressionSyntax)statement.Expression;
			var methodSymbol = expression.GetReferencedSymbol<IMethodSymbol>(SemanticModel);
			if (!methodSymbol.IsBindMethod(SemanticModel))
				return statement;

			var requiredPortReferenceExpression = (InvocationExpressionSyntax)expression.ArgumentList.Arguments[0].Expression;
			var providedPortReferenceExpression = (InvocationExpressionSyntax)expression.ArgumentList.Arguments[1].Expression;

			var requiredPorts = requiredPortReferenceExpression.ResolvePortReferences(SemanticModel);
			var providedPorts = providedPortReferenceExpression.ResolvePortReferences(SemanticModel);

			requiredPorts.RemoveWhere(symbol => !symbol.IsRequiredPort(SemanticModel));
			providedPorts.RemoveWhere(symbol => symbol.IsRequiredPort(SemanticModel));

			if (methodSymbol.Arity == 1)
			{
				var delegateType = (INamedTypeSymbol)methodSymbol.TypeArguments[0];
				MethodSymbolFilter.Filter(requiredPorts, delegateType);
				MethodSymbolFilter.Filter(providedPorts, delegateType);
			}
			else
				MethodSymbolFilter.Filter(requiredPorts, providedPorts);

			// The analyzer guarantees that there is exactly one port in each set now, but just to be sure...
			Assert.That(requiredPorts.Count == 1, "Expected exactly one required port at this point.");
			Assert.That(providedPorts.Count == 1, "Expected exactly one provided port at this point.");

			var requiredPortExpression = requiredPortReferenceExpression.ArgumentList.Arguments[0].Expression;
			var providedPortExpression = providedPortReferenceExpression.ArgumentList.Arguments[0].Expression;

			var requiredPortReference = CreatePortReference(requiredPorts.Single(), requiredPortExpression);
			var providedPortReference = CreatePortReference(providedPorts.Single(), providedPortExpression);

			var binderType = Syntax.TypeExpression(SemanticModel.GetTypeSymbol(typeof(PortBinding)));
			var binderInstance = Syntax.ObjectCreationExpression(binderType, requiredPortReference, providedPortReference);
			var bindMemberAccess = Syntax.MemberAccessExpression(binderInstance, nameof(PortBinding.Bind));
			var invocation = (ExpressionSyntax)Syntax.InvocationExpression(bindMemberAccess);

			return statement.WithExpression(invocation).NormalizeWhitespace().WithTrivia(statement).PrependLineDirective(statement.GetLineNumber());
		}

        /// <summary>
        /// Rewrites the statement with a raise statement.
        /// </summary>
        /// <param name="node">ExpressionStatementSyntax</param>
        /// <returns>SyntaxNode</returns>
        private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
        {
            var invocation = node.Expression as InvocationExpressionSyntax;
            var arguments = new List<ArgumentSyntax>(invocation.ArgumentList.Arguments);

            arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
                "new " + arguments[0].ToString() + "()"));
            invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
                SyntaxFactory.SeparatedList(arguments)));
            
            var text = "{ " +
                node.WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Raise"))).ToString() +
                "return; }";
            var rewritten = SyntaxFactory.ParseStatement(text);
            rewritten = rewritten.WithTriviaFrom(node);

            return rewritten;
        }

		public override void VisitExpressionStatement(ExpressionStatementSyntax node)
		{
			if (this.InsideAutoIncludeMethodBlock)
			{
				var line = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
				var allchildren = node.DescendantNodesAndTokens(descendIntoTrivia: true);
				if (allchildren.Any(a => a.Kind() == SyntaxKind.MultiLineDocumentationCommentTrivia))
				{
					var walker = new CodeWithDocumentationWalker(ClassDepth, line);
					walker.Visit(node.WithAdditionalAnnotations());
					this.Blocks.AddRange(walker.Blocks);
					return;
				}
				base.VisitExpressionStatement(node);
				this.Blocks.Add(new CodeBlock(node.WithoutLeadingTrivia().ToFullString(), line));
			}
			else base.VisitExpressionStatement(node);

		}

 public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
 {
     var aes = node.Expression as AssignmentExpressionSyntax;
     if (aes != null)
     {
         if (aes.Left is IdentifierNameSyntax && ((IdentifierNameSyntax)aes.Left).Identifier.Text == DocumentWeaver.RESULTMARKER)
         {
             foundAssignment = aes.Right;
             //to delete this statement
             return null;
         }
     }
     var ies = node.Expression as InvocationExpressionSyntax;
     if (ies != null)
     {
         var newNode = VisitInvocationExpression(ies);
         if (newNode == null) return null;
     }
     return base.VisitExpressionStatement(node);
 }

        private static async Task<Document> MakeMock(Document document, ExpressionStatementSyntax creation,
            CancellationToken cancellationToken)
        {
            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            var creationExpressionSyntax = creation.Expression.ChildNodes().OfType<ObjectCreationExpressionSyntax>().First();

            var symbolInfo = semanticModel.GetSymbolInfo(creationExpressionSyntax);

            var invokedSymbol = (IMethodSymbol)symbolInfo.CandidateSymbols.FirstOrDefault(x => x is IMethodSymbol
                                                                                               /*&& ((IMethodSymbol)x).Parameters.All(y => y.Type.IsAbstract)*/);

            var constructorParameters = invokedSymbol.Parameters.Select(x => new ConstructorParameters
            {
                ArgumentName = x.Name,
                TypeName = GetTypeNameFromType((INamedTypeSymbol)x.Type)
            }).ToArray();

            var changes = constructorParameters.MakeConstructorInjections();

            var changedDocument = await ChangesMaker.ApplyConstuctorInjections(document, creation, cancellationToken, changes, creationExpressionSyntax);
            return changedDocument;
        }

 public BoundExpressionStatement BindExpressionStatement(ExpressionStatementSyntax node, DiagnosticBag diagnostics)
 {
     return BindExpressionStatement(node, node.Expression, node.AllowsAnyExpression, diagnostics);
 }

 public static void WriteStatement(OutputWriter writer, ExpressionStatementSyntax statement)
 {
     writer.WriteIndent();
     Write(writer, statement.Expression);
     writer.Write(";\r\n");
 }