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);
TypeAnalysis analysis = TypeAnalysis.AnalyzeType(forEachStatement, semanticModel);
if (analysis.IsExplicit)
{
if (analysis.SupportsImplicit &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeToVarAsync(context.Document, type, cancellationToken));
}
}
else if (analysis.SupportsExplicit &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
context.RegisterRefactoring(
$"Change type to '{SymbolDisplay.ToMinimalDisplayString(typeSymbol, semanticModel, type.SpanStart, SymbolDisplayFormats.Default)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken));
}
}
private static async Task ChangeTypeAsync(
RefactoringContext context,
VariableDeclarationSyntax variableDeclaration)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeAnalysis analysis = TypeAnalysis.AnalyzeType(variableDeclaration, semanticModel, context.CancellationToken);
if (analysis.IsExplicit)
{
if (analysis.SupportsImplicit &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
variableDeclaration.Type,
cancellationToken));
},
RefactoringIdentifiers.ChangeExplicitTypeToVar);
}
}
else if (analysis.SupportsExplicit &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(variableDeclaration.Type, context.CancellationToken);
ChangeType(context, variableDeclaration, typeSymbol, semanticModel, context.CancellationToken);
}
}
internal static async Task ChangeTypeAccordingToExpressionAsync(
RefactoringContext context,
ForEachStatementSyntax forEachStatement)
{
TypeSyntax type = forEachStatement.Type;
if (type?.IsVar == false &&
type.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol elementType = semanticModel.GetForEachStatementInfo(forEachStatement).ElementType;
if (elementType?.IsErrorType() == false)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(type).ConvertedType;
if (!elementType.Equals(typeSymbol))
{
if (elementType.SupportsExplicitDeclaration())
{
context.RegisterRefactoring(
$"Change type to '{SymbolDisplay.GetMinimalString(elementType, semanticModel, type.SpanStart)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, elementType, cancellationToken));
}
else
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeToVarAsync(context.Document, type, cancellationToken));
}
}
}
}
}
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;
}
}
}
}
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);
TypeAnalysis analysis = CSharpTypeAnalysis.AnalyzeType(declarationExpression, semanticModel, context.CancellationToken);
if (analysis.IsExplicit)
{
if (analysis.SupportsImplicit &&
context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
declarationExpression.Type,
cancellationToken));
},
RefactoringIdentifiers.ChangeExplicitTypeToVar);
}
}
else if (analysis.SupportsExplicit &&
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.ToMinimalDisplayString(typeSymbol, semanticModel, type.SpanStart, SymbolDisplayFormats.Default)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken),
RefactoringIdentifiers.ChangeVarToExplicitType);
}
}
}
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 = ForEachStatementAnalysis.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.GetTypeInfo(type, context.CancellationToken).Type;
context.RegisterRefactoring(
$"Change type to '{typeSymbol.ToMinimalDisplayString(semanticModel, type.Span.Start, SyntaxUtility.DefaultSymbolDisplayFormat)}'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, type, typeSymbol, cancellationToken));
}
}
}
private static async Task ChangeTypeAsync(
RefactoringContext context,
VariableDeclarationSyntax variableDeclaration)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeAnalysisResult result = VariableDeclarationAnalysis.AnalyzeType(
variableDeclaration,
semanticModel,
context.CancellationToken);
if (result == TypeAnalysisResult.Explicit || result == TypeAnalysisResult.ExplicitButShouldBeImplicit)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeExplicitTypeToVar))
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeToVarAsync(
context.Document,
variableDeclaration.Type,
cancellationToken));
});
}
}
else if (result == TypeAnalysisResult.Implicit || result == TypeAnalysisResult.ImplicitButShouldBeExplicit)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeVarToExplicitType))
{
ITypeSymbol typeSymbol = semanticModel
.GetTypeInfo(variableDeclaration.Type, context.CancellationToken)
.Type;
ChangeType(context, variableDeclaration, typeSymbol, semanticModel, context.CancellationToken);
}
}
}
private static async Task ChangeTypeAccordingToExpressionAsync(
RefactoringContext context,
VariableDeclarationSyntax variableDeclaration)
{
TypeSyntax type = variableDeclaration.Type;
if (type?.IsVar == false)
{
ExpressionSyntax initializerValue = variableDeclaration.Variables.SingleOrDefault(shouldthrow: false)?.Initializer?.Value;
if (initializerValue != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol initializerTypeSymbol = semanticModel.GetTypeSymbol(initializerValue);
if (initializerTypeSymbol?.IsErrorType() == false)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(type).ConvertedType;
if (!initializerTypeSymbol.Equals(typeSymbol))
{
if (initializerTypeSymbol.SupportsExplicitDeclaration())
{
ChangeType(context, variableDeclaration, initializerTypeSymbol, semanticModel, context.CancellationToken);
}
else
{
context.RegisterRefactoring(
"Change type to 'var'",
cancellationToken => ChangeTypeRefactoring.ChangeTypeToVarAsync(context.Document, type, cancellationToken));
}
}
}
}
}
}
