private static async Task ChangeTypeAsync(
RefactoringContext context,
VariableDeclarationSyntax variableDeclaration)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeAnalysisFlags flags = CSharpAnalysis.AnalyzeType(variableDeclaration, semanticModel, context.CancellationToken);
if (flags.IsExplicit())
{
if (flags.SupportsImplicit() &&
flags.IsValidSymbol() &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
variableDeclaration.Type,
cancellationToken));
});
}
}
else if (flags.SupportsExplicit() &&
flags.IsValidSymbol() &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(variableDeclaration.Type, context.CancellationToken);
ChangeType(context, variableDeclaration, typeSymbol, semanticModel, context.CancellationToken);
}
}
private void AnalyzeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
var variableDeclaration = (VariableDeclarationSyntax)context.Node;
TypeAnalysisFlags flags = CSharpAnalysis.AnalyzeType(variableDeclaration, context.SemanticModel, context.CancellationToken);
if (flags.IsExplicit())
{
if (flags.SupportsImplicit() &&
flags.IsTypeObvious())
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseVarInsteadOfExplicitTypeWhenTypeIsObvious,
variableDeclaration.Type);
}
}
else if (flags.SupportsExplicit())
{
if (flags.IsTypeObvious())
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarWhenTypeIsObvious,
variableDeclaration.Type);
}
else if (flags.IsValidSymbol())
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarWhenTypeIsNotObvious,
variableDeclaration.Type);
}
}
}
private static void AnalyzeDeclarationExpression(SyntaxNodeAnalysisContext context)
{
var declarationExpression = (DeclarationExpressionSyntax)context.Node;
if (IsFixable(CSharpAnalysis.AnalyzeType(declarationExpression, context.SemanticModel, context.CancellationToken)))
{
context.ReportDiagnostic(DiagnosticDescriptors.UseVarInsteadOfExplicitTypeWhenTypeIsNotObvious, declarationExpression.Type);
}
}
public static async Task ComputeRefactoringsAsync(
RefactoringContext context,
DeclarationExpressionSyntax declarationExpression)
{
if (declarationExpression.Type?.Span.Contains(context.Span) == true &&
context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeExplicitTypeToVar,
RefactoringIdentifiers.ChangeVarToExplicitType))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
switch (CSharpAnalysis.AnalyzeType(
declarationExpression,
semanticModel,
context.CancellationToken))
{
case TypeAnalysisResult.Explicit:
case TypeAnalysisResult.ExplicitButShouldBeImplicit:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
declarationExpression.Type,
cancellationToken));
});
}
break;
}
case TypeAnalysisResult.Implicit:
case TypeAnalysisResult.ImplicitButShouldBeExplicit:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
TypeSyntax type = declarationExpression.Type;
var localSymbol = semanticModel.GetDeclaredSymbol(declarationExpression.Designation, context.CancellationToken) as ILocalSymbol;
ITypeSymbol typeSymbol = localSymbol.Type;
context.RegisterRefactoring(
$"Change type to '{SymbolDisplay.GetMinimalDisplayString(typeSymbol, type.Span.Start, semanticModel)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken));
}
break;
}
}
}
}
private static void AnalyzeForEachStatement(SyntaxNodeAnalysisContext context)
{
var forEachStatement = (ForEachStatementSyntax)context.Node;
TypeAnalysisFlags flags = CSharpAnalysis.AnalyzeType(forEachStatement, context.SemanticModel);
if (flags.IsExplicit() &&
flags.SupportsImplicit())
{
context.ReportDiagnostic(DiagnosticDescriptors.UseVarInsteadOfExplicitTypeInForEach, forEachStatement.Type);
}
}
private void AnalyzeForEachStatement(SyntaxNodeAnalysisContext context)
{
var forEachStatement = (ForEachStatementSyntax)context.Node;
TypeAnalysisResult result = CSharpAnalysis.AnalyzeType(forEachStatement, context.SemanticModel, context.CancellationToken);
if (result == TypeAnalysisResult.ImplicitButShouldBeExplicit)
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarInForEach,
forEachStatement.Type);
}
}
private void AnalyzeVariableDeclaration(SyntaxNodeAnalysisContext context)
{
var variableDeclaration = (VariableDeclarationSyntax)context.Node;
switch (CSharpAnalysis.AnalyzeType(variableDeclaration, context.SemanticModel, context.CancellationToken))
{
case TypeAnalysisResult.Explicit:
{
break;
}
case TypeAnalysisResult.ExplicitButShouldBeImplicit:
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseVarInsteadOfExplicitType,
variableDeclaration.Type.GetLocation());
break;
}
case TypeAnalysisResult.Implicit:
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVarEvenIfObvious,
variableDeclaration.Type.GetLocation());
break;
}
case TypeAnalysisResult.ImplicitButShouldBeExplicit:
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseExplicitTypeInsteadOfVar,
variableDeclaration.Type.GetLocation());
break;
}
}
}
internal static async Task ChangeTypeAsync(
RefactoringContext context,
ForEachStatementSyntax forEachStatement)
{
TypeSyntax type = forEachStatement.Type;
if (type?.Span.Contains(context.Span) != true)
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeAnalysisResult result = CSharpAnalysis.AnalyzeType(
forEachStatement,
semanticModel,
context.CancellationToken);
if (result == TypeAnalysisResult.Explicit)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeToVarAsync(context.Document, type, cancellationToken));
}
}
else if (result == TypeAnalysisResult.ImplicitButShouldBeExplicit)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
context.RegisterRefactoring(
$"Change type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, type.Span.Start)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken));
}
}
}
