C# ExpressionSyntax.WithoutTrailingTrivia方法代码示例

		protected override Task<Document> IntroduceLocalAsync(
			SemanticDocument document,
			ExpressionSyntax expression,
			bool allOccurrences,
			bool isConstant,
			CancellationToken cancellationToken)
		{
			var options = document.Project.Solution.Workspace.Options;

			var newLocalNameToken = (SyntaxToken)GenerateUniqueLocalName(document, expression, isConstant, cancellationToken);
			var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken);

			var modifiers = isConstant
				? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword))
			                   : default(SyntaxTokenList);

			var declarationStatement = SyntaxFactory.LocalDeclarationStatement(
				modifiers,
				SyntaxFactory.VariableDeclaration(
					this.GetTypeSyntax(document, expression, isConstant, options, cancellationToken),
					SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(
						newLocalNameToken.WithAdditionalAnnotations(RenameAnnotation.Create()),
						null,
						SyntaxFactory.EqualsValueClause(expression.WithoutTrailingTrivia().WithoutLeadingTrivia())))));

			var anonymousMethodParameters = GetAnonymousMethodParameters(document, expression, cancellationToken);
			var lambdas = anonymousMethodParameters.SelectMany(p => p.ContainingSymbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax(cancellationToken)).AsEnumerable())
			                                       .Where(n => n is ParenthesizedLambdaExpressionSyntax || n is SimpleLambdaExpressionSyntax)
			                                       .ToSet();

			var parentLambda = GetParentLambda(expression, lambdas);

			if (parentLambda != null)
			{
				return Task.FromResult(IntroduceLocalDeclarationIntoLambda(
					document, expression, newLocalName, declarationStatement, parentLambda, allOccurrences, cancellationToken));
			}
			else if (IsInExpressionBodiedMember(expression))
			{
				return Task.FromResult(RewriteExpressionBodiedMemberAndIntroduceLocalDeclaration(
					document, expression, newLocalName, declarationStatement, allOccurrences, cancellationToken));
			}
			else
			{
				return IntroduceLocalDeclarationIntoBlockAsync(
					document, expression, newLocalName, declarationStatement, allOccurrences, cancellationToken);
			}
		}

        protected override async Task<Document> IntroduceLocalAsync(
            SemanticDocument document,
            ExpressionSyntax expression,
            bool allOccurrences,
            bool isConstant,
            CancellationToken cancellationToken)
        {
            var containerToGenerateInto = GetContainerToGenerateInto(document, expression, cancellationToken);

            var newLocalNameToken = GenerateUniqueLocalName(
                document, expression, isConstant, containerToGenerateInto, cancellationToken);
            var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken);

            var modifiers = isConstant
                ? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword))
                : default(SyntaxTokenList);

            var options = await document.Document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);

            var declarationStatement = SyntaxFactory.LocalDeclarationStatement(
                modifiers,
                SyntaxFactory.VariableDeclaration(
                    this.GetTypeSyntax(document, options, expression, isConstant, cancellationToken),
                    SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(
                        newLocalNameToken.WithAdditionalAnnotations(RenameAnnotation.Create()),
                        null,
                        SyntaxFactory.EqualsValueClause(expression.WithoutTrailingTrivia().WithoutLeadingTrivia())))));

            switch (containerToGenerateInto)
            {
                case BlockSyntax block:
                    return await IntroduceLocalDeclarationIntoBlockAsync(
                        document, block, expression, newLocalName, declarationStatement, allOccurrences, cancellationToken).ConfigureAwait(false);

                case ArrowExpressionClauseSyntax arrowExpression:
                    return RewriteExpressionBodiedMemberAndIntroduceLocalDeclaration(
                        document, arrowExpression, expression, newLocalName,
                        declarationStatement, allOccurrences, cancellationToken);

                case LambdaExpressionSyntax lambda:
                    return IntroduceLocalDeclarationIntoLambda(
                        document, lambda, expression, newLocalName, declarationStatement, 
                        allOccurrences, cancellationToken);
            }

            throw new InvalidOperationException();
        }

 BinaryExpressionSyntax CreateIsNotNothingBinaryExpression(ExpressionSyntax identifier)
 {
     return SyntaxFactory.BinaryExpression(SyntaxKind.IsNotExpression, identifier.WithoutTrailingTrivia(), SyntaxFactory.Token(SyntaxKind.IsNotKeyword), SyntaxFactory.LiteralExpression(SyntaxKind.NothingLiteralExpression, SyntaxFactory.Token(SyntaxKind.NothingKeyword)));
 }