private void updateAnalysisEnd(TypeAnalysisResult analysisResult) { var msg = string.Format("Analysis for {0}", typeFullName); if (analysisResult == null) { msg = string.Format("{0} aborted", msg); } else { var seconds = Math.Ceiling(analysisResult.TotalDuration.TotalSeconds); var statesCount = analysisResult.States.Count; var transitionsCount = analysisResult.Transitions.Count; msg = string.Format("{0} done in {1} seconds: {2} states, {3} transitions", msg, seconds, statesCount, transitionsCount); } dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationGeneral); dte.StatusBar.Text = msg; this.thread = null; this.graph = null; progressbar.Visible = false; cmdStopAnalysis.Enabled = false; }
private static void ChangeType( CodeRefactoringContext context, SemanticModel semanticModel, VariableDeclarationSyntax variableDeclaration) { TypeAnalysisResult result = VariableDeclarationAnalysis.AnalyzeType( variableDeclaration, semanticModel, context.CancellationToken); switch (result) { case TypeAnalysisResult.Explicit: case TypeAnalysisResult.ExplicitButShouldBeImplicit: { context.RegisterRefactoring( "Change type to 'var'", cancellationToken => TypeSyntaxRefactoring.ChangeTypeToImplicitAsync(context.Document, variableDeclaration.Type, cancellationToken)); break; } case TypeAnalysisResult.Implicit: case TypeAnalysisResult.ImplicitButShouldBeExplicit: { ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type, context.CancellationToken).Type; context.RegisterRefactoring( $"Change type to '{typeSymbol.ToDisplayString(TypeSyntaxRefactoring.SymbolDisplayFormat)}'", cancellationToken => TypeSyntaxRefactoring.ChangeTypeToExplicitAsync(context.Document, variableDeclaration.Type, typeSymbol, cancellationToken)); break; } } }
private void AnalyzeVariableDeclaration(SyntaxNodeAnalysisContext context) { if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true) { return; } var variableDeclaration = (VariableDeclarationSyntax)context.Node; if (variableDeclaration.Variables.Count != 1) { return; } TypeAnalysisResult result = VariableDeclarationAnalysis.AnalyzeType( variableDeclaration, context.SemanticModel, context.CancellationToken); switch (result) { case TypeAnalysisResult.Explicit: { break; } case TypeAnalysisResult.ExplicitButShouldBeImplicit: { context.ReportDiagnostic( DiagnosticDescriptors.DeclareImplicitType, variableDeclaration.Type.GetLocation()); break; } case TypeAnalysisResult.Implicit: { context.ReportDiagnostic( DiagnosticDescriptors.DeclareExplicitTypeEvenIfObvious, variableDeclaration.Type.GetLocation()); break; } case TypeAnalysisResult.ImplicitButShouldBeExplicit: { context.ReportDiagnostic( DiagnosticDescriptors.DeclareExplicitType, variableDeclaration.Type.GetLocation()); break; } } }
protected void ShowAnalysisResult(ITypeDefinition typeToAnalyze, TypeAnalysisResult analysisResult) { var totalTime = analysisResult.TotalTime; var statesCount = analysisResult.Epa.States.Count(); var transitionsCount = analysisResult.Epa.Transitions.Count(); UpdateStatus("Analysis for {0} done in {1:%m} minutes {1:%s} seconds ({2} states, {3} transitions)", typeToAnalyze.Name, totalTime, statesCount, transitionsCount); UpdateOutput(analysisResult.ToString()); }
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 AnalyzeForEachStatement(SyntaxNodeAnalysisContext context) { if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true) { return; } var forEachStatement = (ForEachStatementSyntax)context.Node; TypeAnalysisResult result = ForEachStatementAnalysis.AnalyzeType(forEachStatement, context.SemanticModel, context.CancellationToken); if (result == TypeAnalysisResult.ImplicitButShouldBeExplicit) { context.ReportDiagnostic( DiagnosticDescriptors.DeclareExplicitTypeInForEach, forEachStatement.Type.GetLocation()); } }
private static void ChangeType( CodeRefactoringContext context, SemanticModel semanticModel, ForEachStatementSyntax forEachStatement) { TypeSyntax type = forEachStatement.Type; if (type == null || !type.Span.Contains(context.Span)) { return; } TypeAnalysisResult result = ForEachStatementAnalysis.AnalyzeType( forEachStatement, semanticModel, context.CancellationToken); switch (result) { case TypeAnalysisResult.Explicit: { context.RegisterRefactoring( "Change type to 'var'", cancellationToken => TypeSyntaxRefactoring.ChangeTypeToImplicitAsync(context.Document, type, cancellationToken)); break; } case TypeAnalysisResult.ImplicitButShouldBeExplicit: { ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(type, context.CancellationToken).Type; context.RegisterRefactoring( $"Change type to '{typeSymbol.ToDisplayString(TypeSyntaxRefactoring.SymbolDisplayFormat)}'", cancellationToken => TypeSyntaxRefactoring.ChangeTypeToExplicitAsync(context.Document, type, typeSymbol, cancellationToken)); 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 = 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); } } }