public static bool Applicable(SemanticModel semanticModel, ArgumentSyntax argument, IEnumerable<ParameterSyntax> parameters)
        {
            var symbolInfo = semanticModel.GetSymbolInfo(argument.Expression);
            var symbol = symbolInfo.Symbol;

            if (symbol == null)
            {
                return true;
            }

            if (symbol.Kind != SymbolKind.Field &&
                symbol.Kind != SymbolKind.Parameter &&
                symbol.Kind != SymbolKind.Local)
            {
                return false;
            }

            var field = symbol as IFieldSymbol;
            if (field != null)
            {
                return !field.IsReadOnly;
            }

            return true;
        }

        public override SyntaxNode VisitArgument(ArgumentSyntax node)
        {
            var invocationSyntax = node.Parent.Parent as InvocationExpressionSyntax;
            if(invocationSyntax == null)
                return base.VisitArgument(node);
            var memberAccessExpressionSyntax = invocationSyntax.Expression as MemberAccessExpressionSyntax;
            if(memberAccessExpressionSyntax == null)
                return base.VisitArgument(node);
            var methodNameSyntax = memberAccessExpressionSyntax.Name as SimpleNameSyntax;

            var method = model.GetSymbolInfo(methodNameSyntax).Symbol as IMethodSymbol;
            if(method == null)
                return base.VisitArgument(node);
            var argList = (ArgumentListSyntax)node.Parent;
            //TODO check that parameter name preserved if specified, otherwise order can be broken
            var argIndex = argList.Arguments.IndexOf(node);
            var parameterSymbol = method.Parameters[argIndex]; //TODO when there is params argument in method index may be well out of range

            var lambda = node.Expression as LambdaExpressionSyntax;
            if(parameterSymbol.HasAttribute<MetaRewriteLambdaParamAttribute>(model.Compilation) && lambda != null) {
                //TODO error if value is not lambda
                return node.WithExpression(VisitLambdaExpression(lambda));
            }
            if(parameterSymbol.HasAttribute<MetaRewriteParamAttribute>(model.Compilation))
                return node.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.Expression.ToFullString())));
            return base.VisitArgument(node);
        }

        public static bool TryGetParameterSymbol(ArgumentSyntax argument, ArgumentListSyntax argumentList,
            IMethodSymbol method, out IParameterSymbol parameter)
        {
            parameter = null;
            if (!argumentList.Arguments.Contains(argument) ||
                method == null ||
                method.IsVararg)
            {
                return false;
            }

            if (argument.NameColon != null)
            {
                parameter = method.Parameters
                    .FirstOrDefault(symbol => symbol.Name == argument.NameColon.Name.Identifier.ValueText);
                return parameter != null;
            }

            var argumentIndex = argumentList.Arguments.IndexOf(argument);
            var parameterIndex = argumentIndex;

            if (parameterIndex >= method.Parameters.Length)
            {
                var lastParameter = method.Parameters.Last();
                parameter = lastParameter.IsParams ? lastParameter : null;
                return parameter != null;
            }
            parameter = method.Parameters[parameterIndex];
            return true;
        }

		private async Task<Document> FormatXmlAsync(Document document, ArgumentSyntax argSntax, CancellationToken cancellationToken)
		{
			var root = await document.GetSyntaxRootAsync(cancellationToken);
			var tree = root.SyntaxTree;

			//Get the character position of the ArgumentSyntax
			FileLinePositionSpan position = tree.GetLineSpan(argSntax.Span);
			int cSpace = position.StartLinePosition.Character;

			//Get the parent VariableDeclaration to figure out the preceeding trivia since we can't 
			//get the column position from GetLineSpan (bug?)
			var parent = argSntax.Ancestors().Where(t => t.IsKind(SyntaxKind.VariableDeclaration)).FirstOrDefault();
			var parentTrivia = parent.GetLeadingTrivia().ToFullString();

			var xml = argSntax.Expression.GetFirstToken().ValueText;
			var newXml = FormatXml(xml);

			//Process each line of the formatted XML and prepend the parent trivia & spaces
			string[] xmlLines = newXml.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
			for (int i = 1; i < xmlLines.Length; i++)
			{
				xmlLines[i] = parentTrivia + new String(' ', (cSpace - 14)) + xmlLines[i];
			}

			newXml = String.Join("\r\n", xmlLines);
			newXml = "@\"" + newXml + "\"";

			var newNode = SyntaxFactory.Argument(null, SyntaxFactory.Token(SyntaxKind.None), SyntaxFactory.IdentifierName(newXml));
			var newRoot = root.ReplaceNode(argSntax, newNode);
			return document.WithSyntaxRoot(newRoot);
		}

        public static IParameterSymbol GetParameterSymbol(ArgumentSyntax argument, ArgumentListSyntax argumentList, IMethodSymbol method)
        {
            if (!argumentList.Arguments.Contains(argument) ||
                method == null)
            {
                return null;
            }

            if (argument.NameColon != null)
            {
                return method.Parameters
                    .FirstOrDefault(symbol => symbol.Name == argument.NameColon.Name.Identifier.ValueText);
            }

            var argumentIndex = argumentList.Arguments.IndexOf(argument);
            var parameterIndex = argumentIndex;

            if (parameterIndex >= method.Parameters.Length)
            {
                var p = method.Parameters.Last();
                return p.IsParams ? p : null;
            }
            var parameter = method.Parameters[parameterIndex];
            return parameter;
        }

        private async Task<Document> UseDeclarationExpression(Document document, ArgumentSyntax argument, VariableDeclaratorSyntax declarator,
              CancellationToken cancellationToken)
        {
            // get variable declaration
            var declaration = declarator.Parent;

            // get statement which contains both local declaration statement and method call with out argument
            var statement = DiagnosticAnalyzer.GetContainingStatement(declaration.Parent);

            // remove entire local declaration statement or just single variable declaration
            // depending on how many variables are declared within single local declaration statement
            var nodeToRemove = declaration.ChildNodes().OfType<VariableDeclaratorSyntax>().Count() > 1 ? declarator : declaration.Parent;
            var newStatement = statement.RemoveNode(nodeToRemove, SyntaxRemoveOptions.KeepEndOfLine);

            // get variable type
            var type = declaration.ChildNodes().First() as TypeSyntax;
            // create new Declaration Expression using variable type and declarator
            var newDeclarationExpression = SyntaxFactory.DeclarationExpression(type, declarator);
            // fix the trivia aroung Declaration Expression
            var firstToken = newDeclarationExpression.GetFirstToken();
            var leadingTrivia = firstToken.LeadingTrivia;
            var trimmedDeclarationExpression = newDeclarationExpression.ReplaceToken(firstToken, firstToken.WithLeadingTrivia(SyntaxTriviaList.Empty));
            // get ArgumentSyntax from newStatement which is equivalent to argument from original syntax tree
            var newArgument = newStatement.DescendantNodes()
                                          .FirstOrDefault(n => n.IsEquivalentTo(argument));
            // replace argument with new version, containing Declaration Expression
            newStatement = newStatement.ReplaceNode(newArgument.ChildNodes().First(), trimmedDeclarationExpression);

            // get root for current document and replace statement with new version
            var root = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = root.ReplaceNode(statement, newStatement);

            // return document with modified syntax
            return document.WithSyntaxRoot(newRoot);
        }

		static InvocationExpressionSyntax CheckThat(INamedTypeSymbol nfluentCheck, ArgumentSyntax argument)
	    {
		    return InvocationExpression(
			    MemberAccessExpression(
				    SyntaxKind.SimpleMemberAccessExpression,
				    nfluentCheck.ToNameSyntax(),
				    IdentifierName("That")),
			    ArgumentList(SingletonSeparatedList(argument)));
	    }

            private static bool IsOrdinalOrOrdinalIgnoreCase(ArgumentSyntax argumentSyntax, SemanticModel model)
            {
                var argumentSymbol = model.GetSymbolInfo(argumentSyntax.Expression).Symbol;
                if (argumentSymbol != null)
                {
                    return IsOrdinalOrOrdinalIgnoreCase(argumentSymbol.Name);
                }

                return false;
            }

        public static string Argument(ArgumentSyntax arg)
        {
            var output = SyntaxNode(arg.Expression);

            if (arg.NameColon != null)
            {
                output = SyntaxNode(arg.NameColon.Name) + ": " + output;
            }
            return output;
        }

 public AddOutOrRefCodeAction(
     Document document,
     SemanticModel semanticModel,
     ArgumentSyntax argument,
     IEnumerable<ParameterSyntax> parameters)
 {
     this.document = document;
     this.semanticModel = semanticModel;
     this.argument = argument;
     this.parameters = parameters;
 }

		protected ITypeSymbol GetArgumentType(ArgumentSyntax syntax)
		{
			var symbol = this.semanticModel.GetSpeculativeSymbolInfo(syntax.Expression.SpanStart + this.displacement, syntax.Expression, SpeculativeBindingOption.BindAsExpression).Symbol;

			var property = symbol?.GetType().GetProperty("Type");

			if (property != null)
			{
				return property.GetValue(symbol) as ITypeSymbol;
			}
			
			return this.semanticModel.GetSpeculativeTypeInfo(syntax.Expression.SpanStart + this.displacement, syntax.Expression, SpeculativeBindingOption.BindAsExpression).Type;
		}

		/// <summary>
		///     Lifts the expression represented by <paramref name="argument" />, if necessary.
		/// </summary>
		public override SyntaxNode VisitArgument(ArgumentSyntax argument)
		{
			if (argument.Parent.Parent is ElementAccessExpressionSyntax)
				return base.VisitArgument(argument);

			var requiresLifting = argument.HasAttribute<LiftExpressionAttribute>(SemanticModel);
			argument = (ArgumentSyntax)base.VisitArgument(argument);

			if (!requiresLifting)
				return argument;

			var expression = SyntaxBuilder.Lambda(Enumerable.Empty<ParameterSyntax>(), argument.Expression).WithTrivia(argument);
			return argument.WithExpression(expression);
		}

            private bool IsPassedToDelegateCreationExpression(ArgumentSyntax argument, ITypeSymbol type)
            {
                if (type.IsDelegateType() &&
                    argument.IsParentKind(SyntaxKind.ArgumentList) &&
                    argument.Parent.IsParentKind(SyntaxKind.ObjectCreationExpression))
                {
                    var objectCreationExpression = (ObjectCreationExpressionSyntax)argument.Parent.Parent;
                    var objectCreationType = _semanticModel.GetTypeInfo(objectCreationExpression).Type;
                    if (objectCreationType.Equals(type))
                    {
                        return true;
                    }
                }

                return false;
            }

		private Task<Document> ComputeRoot(
			Document document, SyntaxNode root,
			ArgumentSyntax argument, IMethodSymbol methodSymbol) {
			var providenArgumentsList = argument.Parent as ArgumentListSyntax;
			var providenArguments = providenArgumentsList.Arguments;
			var argumentIndex = providenArguments.IndexOf(argument);

			var newArguments = Enumerable.Concat(
				providenArguments.Take(argumentIndex),
				providenArguments.Skip(argumentIndex)
					.Select((arg, index) => {
						var parameterName = methodSymbol.Parameters[index].Name;
						return arg
							.WithNameColon(NameColon(IdentifierName(parameterName)))
							.WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);
					}));

			var newArgumentList = providenArgumentsList.WithArguments(SeparatedList(newArguments));

			var newRoot = root.ReplaceNode(providenArgumentsList, newArgumentList);
			return Task.FromResult(document.WithSyntaxRoot(newRoot));
		}

        private bool IsAccessed(
            SemanticModel semanticModel,
            ISymbol outSymbol, 
            BlockSyntax enclosingBlockOfLocalStatement,
            LocalDeclarationStatementSyntax localStatement, 
            ArgumentSyntax argumentNode,
            CancellationToken cancellationToken)
        {
            var localStatementStart = localStatement.Span.Start;
            var argumentNodeStart = argumentNode.Span.Start;
            var variableName = outSymbol.Name;

            // Walk the block that the local is declared in looking for accesses.
            // We can ignore anything prior to the actual local declaration point,
            // and we only need to check up until we reach the out-argument.
            foreach (var descendentNode in enclosingBlockOfLocalStatement.DescendantNodes())
            {
                var descendentStart = descendentNode.Span.Start;
                if (descendentStart <= localStatementStart)
                {
                    // This node is before the local declaration.  Can ignore it entirely as it could
                    // not be an access to the local.
                    continue;
                }

                if (descendentStart >= argumentNodeStart)
                {
                    // We reached the out-var.  We can stop searching entirely.
                    break;
                }

                if (descendentNode.IsKind(SyntaxKind.IdentifierName))
                {
                    // See if this looks like an accessor to the local variable syntactically.
                    var identifierName = (IdentifierNameSyntax)descendentNode;
                    if (identifierName.Identifier.ValueText == variableName)
                    {
                        // Confirm that it is a access of the local.
                        var symbol = semanticModel.GetSymbolInfo(identifierName, cancellationToken).Symbol;
                        if (outSymbol.Equals(symbol))
                        {
                            // We definitely accessed the local before the out-argument.  We 
                            // can't inline this local.
                            return true;
                        }
                    }
                }
            }

            // No accesses detected
            return false;
        }

 static SyntaxNode GetArgumentValue(ArgumentSyntax argument)
 {
     return argument.Expression;
 }

 static string GetArgumentName(ArgumentSyntax argument)
 {
     return argument.NameColon != null
                 ? argument.NameColon.Name.Identifier.ValueText
                 : "";
 }

 static string FormatArgument(ArgumentSyntax argument)
 {
     return string.Format(@"new Nake.TaskArgument(""{0}"", {1})",
                          GetArgumentName(argument), GetArgumentValue(argument));
 }

 private static InvocationExpressionSyntax GetIsInstanceOfTypeCall(InvocationExpressionSyntax invocation,
     ExpressionSyntax typeInstance, ArgumentSyntax getTypeCallInArgument)
 {
     return SyntaxFactory.InvocationExpression(
         SyntaxFactory.MemberAccessExpression(
             SyntaxKind.SimpleMemberAccessExpression,
             typeInstance,
             SyntaxFactory.IdentifierName("IsInstanceOfType")).WithTriviaFrom(invocation.Expression),
         SyntaxFactory.ArgumentList(
             SyntaxFactory.SeparatedList(new[]
             {
                 SyntaxFactory.Argument(
                     GetExpressionFromGetType(getTypeCallInArgument.Expression)).WithTriviaFrom(getTypeCallInArgument)
             }))
             .WithTriviaFrom(invocation.ArgumentList))
         .WithTriviaFrom(invocation);
 }

            internal static FieldDeclarationSyntax CreateEmptyRule(SyntaxGenerator generator, string idName="Change me to the name of the above constant", string titleDefault="Enter a title for this diagnostic", string messageDefault="Enter a message to be displayed with this diagnostic",
                                                                    string categoryDefault="Enter a category for this diagnostic (e.g. Formatting)", ExpressionSyntax severityDefault=null, ExpressionSyntax enabledDefault=null)
            {
                if (severityDefault == null)
                {
                    severityDefault = generator.DefaultExpression(SyntaxFactory.ParseTypeName("DiagnosticSeverity")) as ExpressionSyntax;
                }

                if (enabledDefault == null)
                {
                    enabledDefault = generator.DefaultExpression(generator.TypeExpression(SpecialType.System_Boolean)) as ExpressionSyntax;
                }

                var type = SyntaxFactory.ParseTypeName("DiagnosticDescriptor");

                var arguments = new ArgumentSyntax[6];
                var whitespace = "            ";

                var id = generator.LiteralExpression(idName);
                var idArg = generator.Argument("id", RefKind.None, id).WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
                arguments[0] = idArg;

                var title = generator.LiteralExpression(titleDefault);
                var titleArg = generator.Argument("title", RefKind.None, title).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
                arguments[1] = titleArg;

                var message = generator.LiteralExpression(messageDefault);
                var messageArg = generator.Argument("messageFormat", RefKind.None, message).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
                arguments[2] = messageArg;

                var category = generator.LiteralExpression(categoryDefault);
                var categoryArg = generator.Argument("category", RefKind.None, category).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
                arguments[3] = categoryArg;

                var defaultSeverityArg = generator.Argument("defaultSeverity", RefKind.None, severityDefault).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
                arguments[4] = defaultSeverityArg;

                var enabledArg = generator.Argument("isEnabledByDefault", RefKind.None, enabledDefault).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
                arguments[5] = enabledArg;
                
                var identifier = SyntaxFactory.ParseToken("spacingRule");

                var separators = new List<SyntaxToken>();
                var separator = SyntaxFactory.ParseToken(",").WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
                separators.Add(separator);
                separators.Add(separator);
                separators.Add(separator);
                separators.Add(separator);
                separators.Add(separator);

                var argumentsNewLines = SyntaxFactory.SeparatedList(arguments, separators);
                var argumentList = SyntaxFactory.ArgumentList(argumentsNewLines);
                var value = SyntaxFactory.ObjectCreationExpression(type, argumentList, null);
                var initializer = SyntaxFactory.EqualsValueClause(value);
                

                var variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>();
                var variable = SyntaxFactory.VariableDeclarator(identifier, null, initializer);
                variables = variables.Add(variable);

                var declaration = SyntaxFactory.VariableDeclaration(type.WithTrailingTrivia(SyntaxFactory.Whitespace(" ")), variables);
                var modifiers = SyntaxFactory.TokenList(SyntaxFactory.ParseToken("internal").WithTrailingTrivia(SyntaxFactory.Whitespace(" ")), SyntaxFactory.ParseToken("static").WithTrailingTrivia(SyntaxFactory.Whitespace(" ")));
                var rule = SyntaxFactory.FieldDeclaration(new SyntaxList<AttributeListSyntax>(), modifiers, declaration);
                return rule;
            }