private Document IntroduceLocalDeclarationIntoLambda(
SemanticDocument document,
ExpressionSyntax expression,
IdentifierNameSyntax newLocalName,
LocalDeclarationStatementSyntax declarationStatement,
SyntaxNode oldLambda,
bool allOccurrences,
CancellationToken cancellationToken)
{
var oldBody = oldLambda is ParenthesizedLambdaExpressionSyntax
? (ExpressionSyntax)((ParenthesizedLambdaExpressionSyntax)oldLambda).Body
: (ExpressionSyntax)((SimpleLambdaExpressionSyntax)oldLambda).Body;
var rewrittenBody = Rewrite(
document, expression, newLocalName, document, oldBody, allOccurrences, cancellationToken);
var delegateType = document.SemanticModel.GetTypeInfo(oldLambda, cancellationToken).ConvertedType as INamedTypeSymbol;
var newBody = delegateType != null && delegateType.DelegateInvokeMethod != null && delegateType.DelegateInvokeMethod.ReturnsVoid
? SyntaxFactory.Block(declarationStatement)
: SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(rewrittenBody));
newBody = newBody.WithAdditionalAnnotations(Formatter.Annotation);
var newLambda = oldLambda is ParenthesizedLambdaExpressionSyntax
? ((ParenthesizedLambdaExpressionSyntax)oldLambda).WithBody(newBody)
: (SyntaxNode)((SimpleLambdaExpressionSyntax)oldLambda).WithBody(newBody);
var newRoot = document.Root.ReplaceNode(oldLambda, newLambda);
return document.Document.WithSyntaxRoot(newRoot);
}
protected override async Task<InsertionPoint> GetInsertionPointAsync(SemanticDocument document, int position, CancellationToken cancellationToken)
{
//Contract.ThrowIfFalse(position >= 0);
var root = await document.Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var basePosition = root.FindToken(position);
var memberNode = basePosition.GetAncestor<MemberDeclarationSyntax>();
// Contract.ThrowIfNull(memberNode);
// Contract.ThrowIfTrue(memberNode.Kind() == SyntaxKind.NamespaceDeclaration);
var globalStatement = memberNode as GlobalStatementSyntax;
if (globalStatement != null)
{
// check whether we are extracting whole global statement out
if (this.OriginalSelectionResult.FinalSpan.Contains(memberNode.Span))
{
return await InsertionPoint.CreateAsync(document, globalStatement.Parent, cancellationToken).ConfigureAwait(false);
}
return await InsertionPoint.CreateAsync(document, globalStatement.Statement, cancellationToken).ConfigureAwait(false);
}
return await InsertionPoint.CreateAsync(document, memberNode, cancellationToken).ConfigureAwait(false);
}
public CSharpSelectionValidator(
SemanticDocument document,
TextSpan textSpan,
OptionSet options) :
base(document, textSpan, options)
{
}
public static async Task<InsertionPoint> CreateAsync(SemanticDocument document, SyntaxNode node, CancellationToken cancellationToken)
{
var root = document.Root;
var annotation = new SyntaxAnnotation();
var newRoot = root.AddAnnotations(SpecializedCollections.SingletonEnumerable(Tuple.Create(node, annotation)));
return new InsertionPoint(await document.WithSyntaxRootAsync(newRoot, cancellationToken).ConfigureAwait(false), annotation);
}
public AnalyzerResult(
SemanticDocument document,
IEnumerable<ITypeParameterSymbol> typeParametersInDeclaration,
IEnumerable<ITypeParameterSymbol> typeParametersInConstraintList,
IList<VariableInfo> variables,
VariableInfo variableToUseAsReturnValue,
ITypeSymbol returnType,
bool awaitTaskReturn,
bool instanceMemberIsUsed,
bool endOfSelectionReachable,
OperationStatus status)
{
var semanticModel = document.SemanticModel;
this.UseInstanceMember = instanceMemberIsUsed;
this.EndOfSelectionReachable = endOfSelectionReachable;
this.AwaitTaskReturn = awaitTaskReturn;
this.SemanticDocument = document;
_typeParametersInDeclaration = typeParametersInDeclaration.Select(s => semanticModel.ResolveType(s)).ToList();
_typeParametersInConstraintList = typeParametersInConstraintList.Select(s => semanticModel.ResolveType(s)).ToList();
_variables = variables;
this.ReturnType = semanticModel.ResolveType(returnType);
_variableToUseAsReturnValue = variableToUseAsReturnValue;
this.Status = status;
}
public TriviaResult(SemanticDocument document, ITriviaSavedResult result, int endOfLineKind, int whitespaceKind)
{
this.SemanticDocument = document;
_result = result;
_endOfLineKind = endOfLineKind;
_whitespaceKind = whitespaceKind;
}
private InsertionPoint(SemanticDocument document, SyntaxAnnotation annotation)
{
//Contract.ThrowIfNull(document);
//Contract.ThrowIfNull(annotation);
this.SemanticDocument = document;
_annotation = annotation;
_context = CreateLazyContextNode();
}
public Rewriter(
LambdaSimplifierCodeRefactoringProvider codeIssueProvider,
SemanticDocument document,
Func<SyntaxNode, bool> predicate,
CancellationToken cancellationToken)
{
_codeIssueProvider = codeIssueProvider;
_document = document;
_predicate = predicate;
_cancellationToken = cancellationToken;
}
public ExpressionResult(
OperationStatus status,
TextSpan originalSpan,
TextSpan finalSpan,
OptionSet options,
bool selectionInExpression,
SemanticDocument document,
SyntaxAnnotation firstTokenAnnotation,
SyntaxAnnotation lastTokenAnnotation) :
base(status, originalSpan, finalSpan, options, selectionInExpression, document, firstTokenAnnotation, lastTokenAnnotation)
{
}
protected override Task<Document> IntroduceQueryLocalAsync(
SemanticDocument document, ExpressionSyntax expression, bool allOccurrences, CancellationToken cancellationToken)
{
var oldOutermostQuery = expression.GetAncestorsOrThis<QueryExpressionSyntax>().LastOrDefault();
var newLocalNameToken = GenerateUniqueLocalName(
document, expression, isConstant: false,
container: oldOutermostQuery, cancellationToken: cancellationToken);
var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken);
var letClause = SyntaxFactory.LetClause(
newLocalNameToken.WithAdditionalAnnotations(RenameAnnotation.Create()),
expression).WithAdditionalAnnotations(Formatter.Annotation);
var matches = FindMatches(document, expression, document, oldOutermostQuery, allOccurrences, cancellationToken);
var innermostClauses = new HashSet<SyntaxNode>(
matches.Select(expr => expr.GetAncestorsOrThis<SyntaxNode>().First(IsAnyQueryClause)));
if (innermostClauses.Count == 1)
{
// If there was only one match, or all the matches came from the same
// statement, then we want to place the declaration right above that
// statement. Note: we special case this because the statement we are going
// to go above might not be in a block and we may have to generate it
return Task.FromResult(IntroduceQueryLocalForSingleOccurrence(
document, expression, newLocalName, letClause, allOccurrences, cancellationToken));
}
var oldInnerMostCommonQuery = matches.FindInnermostCommonNode<QueryExpressionSyntax>();
var newInnerMostQuery = Rewrite(
document, expression, newLocalName, document, oldInnerMostCommonQuery, allOccurrences, cancellationToken);
var allAffectedClauses = new HashSet<SyntaxNode>(matches.SelectMany(expr => expr.GetAncestorsOrThis<SyntaxNode>().Where(IsAnyQueryClause)));
var oldClauses = oldInnerMostCommonQuery.GetAllClauses();
var newClauses = newInnerMostQuery.GetAllClauses();
var firstClauseAffectedInQuery = oldClauses.First(allAffectedClauses.Contains);
var firstClauseAffectedIndex = oldClauses.IndexOf(firstClauseAffectedInQuery);
var finalClauses = newClauses.Take(firstClauseAffectedIndex)
.Concat(letClause)
.Concat(newClauses.Skip(firstClauseAffectedIndex)).ToList();
var finalQuery = newInnerMostQuery.WithAllClauses(finalClauses);
var newRoot = document.Root.ReplaceNode(oldInnerMostCommonQuery, finalQuery);
return Task.FromResult(document.Document.WithSyntaxRoot(newRoot));
}
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();
}
private Document IntroduceQueryLocalForSingleOccurrence(
SemanticDocument document,
ExpressionSyntax expression,
NameSyntax newLocalName,
LetClauseSyntax letClause,
bool allOccurrences,
CancellationToken cancellationToken)
{
var oldClause = expression.GetAncestors<SyntaxNode>().First(IsAnyQueryClause);
var newClause = Rewrite(
document, expression, newLocalName, document, oldClause, allOccurrences, cancellationToken);
var oldQuery = (QueryBodySyntax)oldClause.Parent;
var newQuery = GetNewQuery(oldQuery, oldClause, newClause, letClause);
var newRoot = document.Root.ReplaceNode(oldQuery, newQuery);
return document.Document.WithSyntaxRoot(newRoot);
}
public GeneratedCode(
OperationStatus status,
SemanticDocument document,
SyntaxAnnotation methodNameAnnotation,
SyntaxAnnotation callsiteAnnotation,
SyntaxAnnotation methodDefinitionAnnotation)
{
//Contract.ThrowIfNull(document);
//Contract.ThrowIfNull(methodNameAnnotation);
//Contract.ThrowIfNull(callsiteAnnotation);
//Contract.ThrowIfNull(methodDefinitionAnnotation);
this.Status = status;
this.SemanticDocument = document;
this.MethodNameAnnotation = methodNameAnnotation;
this.CallSiteAnnotation = callsiteAnnotation;
this.MethodDefinitionAnnotation = methodDefinitionAnnotation;
}
public AnalyzerResult With(SemanticDocument document)
{
if (this.SemanticDocument == document)
{
return this;
}
return new AnalyzerResult(
document,
_typeParametersInDeclaration,
_typeParametersInConstraintList,
_variables,
_variableToUseAsReturnValue,
this.ReturnType,
this.AwaitTaskReturn,
this.UseInstanceMember,
this.EndOfSelectionReachable,
this.Status);
}
public static SyntaxNode GenerateThrowStatement(
ISyntaxFactoryService factory,
SemanticDocument document,
string exceptionMetadataName,
CancellationToken cancellationToken)
{
var compilation = document.SemanticModel.Compilation;
var exceptionType = compilation.GetTypeByMetadataName(exceptionMetadataName);
// If we can't find the Exception, we obviously can't generate anything.
if (exceptionType == null)
{
return null;
}
var exceptionCreationExpression = factory.CreateObjectCreationExpression(
exceptionType,
SpecializedCollections.EmptyList<SyntaxNode>());
return factory.CreateThrowStatement(exceptionCreationExpression);
}
private SyntaxNode GetContainerToGenerateInto(
SemanticDocument document, ExpressionSyntax expression, CancellationToken cancellationToken)
{
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 parentLambda;
}
else if (IsInExpressionBodiedMember(expression))
{
return expression.GetAncestorOrThis<ArrowExpressionClauseSyntax>();
}
else
{
return expression.GetAncestorsOrThis<BlockSyntax>().LastOrDefault();
}
}
public InsertionPoint With(SemanticDocument document)
{
return new InsertionPoint(document, _annotation);
}
public SyntaxToken GetIdentifierTokenAtDeclaration(SemanticDocument document)
{
return document.GetTokenWithAnnotaton(_variableSymbol.IdentifierTokenAnnotation);
}
private async Task<Tuple<bool, OperationStatus>> TryCheckVariableTypeAsync(
SemanticDocument document, SyntaxNode contextNode, IEnumerable<VariableInfo> variables,
OperationStatus status, CancellationToken cancellationToken)
{
if (status.FailedWithNoBestEffortSuggestion())
{
return Tuple.Create(false, status);
}
var location = contextNode.GetLocation();
foreach (var variable in variables)
{
var originalType = variable.GetVariableType(document);
var result = await CheckTypeAsync(document.Document, contextNode, location, originalType, cancellationToken).ConfigureAwait(false);
if (result.FailedWithNoBestEffortSuggestion())
{
status = status.With(result);
return Tuple.Create(false, status);
}
}
return Tuple.Create(true, status);
}
protected abstract Task<InsertionPoint> GetInsertionPointAsync(SemanticDocument document, int position, CancellationToken cancellationToken);
private CSharpTriviaResult(SemanticDocument document, ITriviaSavedResult result) :
base(document, result, (int)SyntaxKind.EndOfLineTrivia, (int)SyntaxKind.WhitespaceTrivia)
{
}
private ExtractMethodResult CreateExtractMethodResult(
OperationStatus status, SemanticDocument semanticDocument,
SyntaxAnnotation invocationAnnotation, SyntaxAnnotation methodAnnotation)
{
var newRoot = semanticDocument.Root;
var annotatedTokens = newRoot.GetAnnotatedNodesAndTokens(invocationAnnotation);
var methodDefinition = newRoot.GetAnnotatedNodesAndTokens(methodAnnotation).FirstOrDefault().AsNode();
return new SimpleExtractMethodResult(status, semanticDocument.Document, GetMethodNameAtInvocation(annotatedTokens), methodDefinition);
}
private async Task<Document> IntroduceLocalDeclarationIntoBlockAsync(
SemanticDocument document,
BlockSyntax block,
ExpressionSyntax expression,
NameSyntax newLocalName,
LocalDeclarationStatementSyntax declarationStatement,
bool allOccurrences,
CancellationToken cancellationToken)
{
declarationStatement = declarationStatement.WithAdditionalAnnotations(Formatter.Annotation);
var oldOutermostBlock = block;
var matches = FindMatches(document, expression, document, oldOutermostBlock, allOccurrences, cancellationToken);
Debug.Assert(matches.Contains(expression));
var complexified = await ComplexifyParentingStatements(document, matches, cancellationToken).ConfigureAwait(false);
document = complexified.Item1;
matches = complexified.Item2;
// Our original expression should have been one of the matches, which were tracked as part
// of complexification, so we can retrieve the latest version of the expression here.
expression = document.Root.GetCurrentNodes(expression).First();
var innermostStatements = new HashSet<StatementSyntax>(
matches.Select(expr => expr.GetAncestorOrThis<StatementSyntax>()));
if (innermostStatements.Count == 1)
{
// If there was only one match, or all the matches came from the same
// statement, then we want to place the declaration right above that
// statement. Note: we special case this because the statement we are going
// to go above might not be in a block and we may have to generate it
return IntroduceLocalForSingleOccurrenceIntoBlock(
document, expression, newLocalName, declarationStatement, allOccurrences, cancellationToken);
}
var oldInnerMostCommonBlock = matches.FindInnermostCommonBlock();
var allAffectedStatements = new HashSet<StatementSyntax>(matches.SelectMany(expr => expr.GetAncestorsOrThis<StatementSyntax>()));
var firstStatementAffectedInBlock = oldInnerMostCommonBlock.Statements.First(allAffectedStatements.Contains);
var firstStatementAffectedIndex = oldInnerMostCommonBlock.Statements.IndexOf(firstStatementAffectedInBlock);
var newInnerMostBlock = Rewrite(
document, expression, newLocalName, document, oldInnerMostCommonBlock, allOccurrences, cancellationToken);
var statements = new List<StatementSyntax>();
statements.AddRange(newInnerMostBlock.Statements.Take(firstStatementAffectedIndex));
statements.Add(declarationStatement);
statements.AddRange(newInnerMostBlock.Statements.Skip(firstStatementAffectedIndex));
var finalInnerMostBlock = newInnerMostBlock.WithStatements(
SyntaxFactory.List<StatementSyntax>(statements));
var newRoot = document.Root.ReplaceNode(oldInnerMostCommonBlock, finalInnerMostBlock);
return document.Document.WithSyntaxRoot(newRoot);
}
private Document IntroduceLocalForSingleOccurrenceIntoBlock(
SemanticDocument document,
ExpressionSyntax expression,
NameSyntax localName,
LocalDeclarationStatementSyntax localDeclaration,
bool allOccurrences,
CancellationToken cancellationToken)
{
var oldStatement = expression.GetAncestorOrThis<StatementSyntax>();
var newStatement = Rewrite(
document, expression, localName, document, oldStatement, allOccurrences, cancellationToken);
if (oldStatement.IsParentKind(SyntaxKind.Block))
{
var oldBlock = oldStatement.Parent as BlockSyntax;
var statementIndex = oldBlock.Statements.IndexOf(oldStatement);
var newBlock = oldBlock.WithStatements(CreateNewStatementList(
oldBlock.Statements, localDeclaration, newStatement, statementIndex));
var newRoot = document.Root.ReplaceNode(oldBlock, newBlock);
return document.Document.WithSyntaxRoot(newRoot);
}
else if (oldStatement.IsParentKind(SyntaxKind.SwitchSection))
{
var oldSwitchSection = oldStatement.Parent as SwitchSectionSyntax;
var statementIndex = oldSwitchSection.Statements.IndexOf(oldStatement);
var newSwitchSection = oldSwitchSection.WithStatements(CreateNewStatementList(
oldSwitchSection.Statements, localDeclaration, newStatement, statementIndex));
var newRoot = document.Root.ReplaceNode(oldSwitchSection, newSwitchSection);
return document.Document.WithSyntaxRoot(newRoot);
}
else
{
// we need to introduce a block to put the original statement, along with
// the statement we're generating
var newBlock = SyntaxFactory.Block(localDeclaration, newStatement).WithAdditionalAnnotations(Formatter.Annotation);
var newRoot = document.Root.ReplaceNode(oldStatement, newBlock);
return document.Document.WithSyntaxRoot(newRoot);
}
}
private TypeSyntax GetTypeSyntax(SemanticDocument document, ExpressionSyntax expression, bool isConstant, OptionSet options, CancellationToken cancellationToken)
{
var typeSymbol = GetTypeSymbol(document, expression, cancellationToken);
if (typeSymbol.ContainsAnonymousType())
{
return SyntaxFactory.IdentifierName("var");
}
if (!isConstant && true /*options.GetOption(CSharpCodeStyleOptions.UseVarWhenDeclaringLocals) */&& CanUseVar(typeSymbol))
{
return SyntaxFactory.IdentifierName("var");
}
return typeSymbol.GenerateTypeSyntax();
}
private Document RewriteExpressionBodiedMemberAndIntroduceLocalDeclaration(
SemanticDocument document,
ArrowExpressionClauseSyntax arrowExpression,
ExpressionSyntax expression,
NameSyntax newLocalName,
LocalDeclarationStatementSyntax declarationStatement,
bool allOccurrences,
CancellationToken cancellationToken)
{
var oldBody = arrowExpression;
var oldParentingNode = oldBody.Parent;
var leadingTrivia = oldBody.GetLeadingTrivia()
.AddRange(oldBody.ArrowToken.TrailingTrivia);
var newStatement = Rewrite(document, expression, newLocalName, document, oldBody.Expression, allOccurrences, cancellationToken);
var newBody = SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(newStatement))
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(oldBody.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newParentingNode = null;
if (oldParentingNode is BasePropertyDeclarationSyntax)
{
var getAccessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, newBody);
var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getAccessor }));
newParentingNode = ((BasePropertyDeclarationSyntax)oldParentingNode).RemoveNode(oldBody, SyntaxRemoveOptions.KeepNoTrivia);
if (newParentingNode.IsKind(SyntaxKind.PropertyDeclaration))
{
var propertyDeclaration = ((PropertyDeclarationSyntax)newParentingNode);
newParentingNode = propertyDeclaration
.WithAccessorList(accessorList)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(propertyDeclaration.SemicolonToken.TrailingTrivia);
}
else if (newParentingNode.IsKind(SyntaxKind.IndexerDeclaration))
{
var indexerDeclaration = ((IndexerDeclarationSyntax)newParentingNode);
newParentingNode = indexerDeclaration
.WithAccessorList(accessorList)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(indexerDeclaration.SemicolonToken.TrailingTrivia);
}
}
else if (oldParentingNode is BaseMethodDeclarationSyntax)
{
newParentingNode = ((BaseMethodDeclarationSyntax)oldParentingNode)
.RemoveNode(oldBody, SyntaxRemoveOptions.KeepNoTrivia)
.WithBody(newBody);
if (newParentingNode.IsKind(SyntaxKind.MethodDeclaration))
{
var methodDeclaration = ((MethodDeclarationSyntax)newParentingNode);
newParentingNode = methodDeclaration
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(methodDeclaration.SemicolonToken.TrailingTrivia);
}
else if (newParentingNode.IsKind(SyntaxKind.OperatorDeclaration))
{
var operatorDeclaration = ((OperatorDeclarationSyntax)newParentingNode);
newParentingNode = operatorDeclaration
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(operatorDeclaration.SemicolonToken.TrailingTrivia);
}
else if (newParentingNode.IsKind(SyntaxKind.ConversionOperatorDeclaration))
{
var conversionOperatorDeclaration = ((ConversionOperatorDeclarationSyntax)newParentingNode);
newParentingNode = conversionOperatorDeclaration
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(conversionOperatorDeclaration.SemicolonToken.TrailingTrivia);
}
}
var newRoot = document.Root.ReplaceNode(oldParentingNode, newParentingNode);
return document.Document.WithSyntaxRoot(newRoot);
}
private static async Task<Tuple<SemanticDocument, ISet<ExpressionSyntax>>> ComplexifyParentingStatements(
SemanticDocument semanticDocument,
ISet<ExpressionSyntax> matches,
CancellationToken cancellationToken)
{
// First, track the matches so that we can get back to them later.
var newRoot = semanticDocument.Root.TrackNodes(matches);
var newDocument = semanticDocument.Document.WithSyntaxRoot(newRoot);
var newSemanticDocument = await SemanticDocument.CreateAsync(newDocument, cancellationToken).ConfigureAwait(false);
var newMatches = newSemanticDocument.Root.GetCurrentNodes(matches.AsEnumerable()).ToSet();
// Next, expand the topmost parenting expression of each match, being careful
// not to expand the matches themselves.
var topMostExpressions = newMatches
.Select(m => m.AncestorsAndSelf().OfType<ExpressionSyntax>().Last())
.Distinct();
newRoot = await newSemanticDocument.Root
.ReplaceNodesAsync(
topMostExpressions,
computeReplacementAsync: async (oldNode, newNode, ct) =>
{
return await Simplifier
.ExpandAsync(
oldNode,
newSemanticDocument.Document,
expandInsideNode: node =>
{
var expression = node as ExpressionSyntax;
return expression == null
|| !newMatches.Contains(expression);
},
cancellationToken: ct)
.ConfigureAwait(false);
},
cancellationToken: cancellationToken)
.ConfigureAwait(false);
newDocument = newSemanticDocument.Document.WithSyntaxRoot(newRoot);
newSemanticDocument = await SemanticDocument.CreateAsync(newDocument, cancellationToken).ConfigureAwait(false);
newMatches = newSemanticDocument.Root.GetCurrentNodes(matches.AsEnumerable()).ToSet();
return Tuple.Create(newSemanticDocument, newMatches);
}
private TypeSyntax GetTypeSyntax(SemanticDocument document, DocumentOptionSet options, ExpressionSyntax expression, bool isConstant, CancellationToken cancellationToken)
{
var typeSymbol = GetTypeSymbol(document, expression, cancellationToken);
if (typeSymbol.ContainsAnonymousType())
{
return SyntaxFactory.IdentifierName("var");
}
if (!isConstant &&
CanUseVar(typeSymbol) &&
TypeStyleHelper.IsImplicitTypePreferred(expression, document.SemanticModel, options, cancellationToken))
{
return SyntaxFactory.IdentifierName("var");
}
return typeSymbol.GenerateTypeSyntax();
}
public ITypeSymbol GetVariableType(SemanticDocument document)
{
return document.SemanticModel.ResolveType(_variableSymbol.OriginalType);
}
