public async Task <List <SourceFileAnalysisResult> > AnalyzeFileIncremental(string filePath, string fileContent, string projectFile, string solutionFilePath, List <string> preportReferences , List <string> currentReferences, RootNodes projectRules, ExternalReferences externalReferences, bool actionsOnly = false, bool compatibleOnly = false, string targetFramework = DEFAULT_TARGET) { try { List <SourceFileAnalysisResult> sourceFileAnalysisResults = new List <SourceFileAnalysisResult>(); var fileAnalysis = await AnalyzeProjectFiles(projectFile, fileContent, filePath, preportReferences, currentReferences); var fileActions = AnalyzeFileActionsIncremental(projectFile, projectRules, targetFramework, solutionFilePath, filePath, fileAnalysis); var sourceFileResult = fileAnalysis.RootNodes.FirstOrDefault(); Dictionary <string, List <CodeEntityDetails> > sourceFileToCodeEntityDetails = new Dictionary <string, List <CodeEntityDetails> >(); Dictionary <string, Task <RecommendationDetails> > recommendationResults = new Dictionary <string, Task <RecommendationDetails> >(); Dictionary <PackageVersionPair, Task <PackageDetails> > packageResults = new Dictionary <PackageVersionPair, Task <PackageDetails> >(); if (!actionsOnly) { var sourceFileToInvocations = new[] { SourceFileToCodeTokens(sourceFileResult) }.ToDictionary(result => result.Key, result => result.Value); sourceFileToCodeEntityDetails = CodeEntityModelToCodeEntities.Convert(sourceFileToInvocations, externalReferences); var namespaces = sourceFileToCodeEntityDetails.Aggregate(new HashSet <string>(), (agg, cur) => { agg.UnionWith(cur.Value.Select(i => i.Namespace).Where(i => i != null)); return(agg); }); var nugetPackages = externalReferences?.NugetReferences? .Select(r => CodeEntityModelToCodeEntities.ReferenceToPackageVersionPair(r))? .ToHashSet(); var subDependencies = externalReferences?.NugetDependencies? .Select(r => CodeEntityModelToCodeEntities.ReferenceToPackageVersionPair(r)) .ToHashSet(); var sdkPackages = namespaces.Select(n => new PackageVersionPair { PackageId = n, Version = "0.0.0", PackageSourceType = PackageSourceType.SDK }); var allPackages = nugetPackages .Union(subDependencies) .Union(sdkPackages) .ToList(); packageResults = _handler.GetNugetPackages(allPackages, solutionFilePath, isIncremental: true, incrementalRefresh: false); recommendationResults = _recommendationHandler.GetApiRecommendation(namespaces.ToList()); } var portingActionResults = new Dictionary <string, List <RecommendedAction> >(); var recommendedActions = fileActions.Select(f => new RecommendedAction() { Description = f.Description, RecommendedActionType = RecommendedActionType.ReplaceApi, TextSpan = new Model.TextSpan() { StartCharPosition = f.TextSpan.StartCharPosition, EndCharPosition = f.TextSpan.EndCharPosition, StartLinePosition = f.TextSpan.StartLinePosition, EndLinePosition = f.TextSpan.EndLinePosition }, TextChanges = f.TextChanges }).ToHashSet().ToList(); portingActionResults.Add(filePath, recommendedActions); var sourceFileAnalysisResult = CodeEntityModelToCodeEntities.AnalyzeResults( sourceFileToCodeEntityDetails, packageResults, recommendationResults, portingActionResults, targetFramework, compatibleOnly); //In case actions only, result will be empty, so we populate with actions if (actionsOnly) { sourceFileAnalysisResult.Add(new SourceFileAnalysisResult() { SourceFileName = Path.GetFileName(filePath), SourceFilePath = filePath, RecommendedActions = recommendedActions, ApiAnalysisResults = new List <ApiAnalysisResult>() }); } sourceFileAnalysisResults.AddRange(sourceFileAnalysisResult); return(sourceFileAnalysisResults); } finally { CommonUtils.RunGarbageCollection(_logger, "PortingAssistantAnalysisHandler.AnalyzeFileIncremental"); } }
private ProjectAnalysisResult AnalyzeProject( string project, List <AnalyzerResult> analyzers, Dictionary <string, ProjectActions> analysisActions, string targetFramework = "netcoreapp3.1") { try { using var analyzer = analyzers.Find((a) => a.ProjectResult?.ProjectFilePath != null && a.ProjectResult.ProjectFilePath.Equals(project)); var projectActions = new ProjectActions(); analysisActions.TryGetValue(project, out projectActions); if (analyzer == null || analyzer.ProjectResult == null) { _logger.LogError("Unable to build {0}.", project); return(null); } var sourceFileToInvocations = analyzer.ProjectResult.SourceFileResults.Select((sourceFile) => { var invocationsInSourceFile = sourceFile.AllInvocationExpressions(); _logger.LogInformation("API: SourceFile {0} has {1} invocations pre-filter", sourceFile.FileFullPath, invocationsInSourceFile.Count()); return(KeyValuePair.Create(sourceFile.FileFullPath, invocationsInSourceFile)); }).ToDictionary(p => p.Key, p => p.Value); var sourceFileToCodeEntityDetails = InvocationExpressionModelToInvocations.Convert(sourceFileToInvocations, analyzer); var namespaces = sourceFileToCodeEntityDetails.Aggregate(new HashSet <string>(), (agg, cur) => { agg.UnionWith(cur.Value.Select(i => i.Namespace).Where(i => i != null)); return(agg); }); var targetframeworks = analyzer.ProjectResult.TargetFrameworks.Count == 0 ? new List <string> { analyzer.ProjectResult.TargetFramework } : analyzer.ProjectResult.TargetFrameworks; var nugetPackages = analyzer.ProjectResult.ExternalReferences.NugetReferences .Select(r => InvocationExpressionModelToInvocations.ReferenceToPackageVersionPair(r)) .ToHashSet(); var subDependencies = analyzer.ProjectResult.ExternalReferences.NugetDependencies .Select(r => InvocationExpressionModelToInvocations.ReferenceToPackageVersionPair(r)) .ToHashSet(); var sdkPackages = namespaces.Select(n => new PackageVersionPair { PackageId = n, Version = "0.0.0", PackageSourceType = PackageSourceType.SDK }); var allPackages = nugetPackages .Union(subDependencies) .Union(sdkPackages) .ToList(); var packageResults = _handler.GetNugetPackages(allPackages, null); var recommendationResults = _recommendationHandler.GetApiRecommendation(namespaces.ToList()); var packageAnalysisResults = nugetPackages.Select(package => { var result = PackageCompatibility.IsCompatibleAsync(packageResults.GetValueOrDefault(package, null), package, _logger, targetFramework); var packageAnalysisResult = PackageCompatibility.GetPackageAnalysisResult(result, package, targetFramework); return(new Tuple <PackageVersionPair, Task <PackageAnalysisResult> >(package, packageAnalysisResult)); }).ToDictionary(t => t.Item1, t => t.Item2); var portingActionResults = ProjectActionsToRecommendedActions.Convert(projectActions); var SourceFileAnalysisResults = InvocationExpressionModelToInvocations.AnalyzeResults( sourceFileToCodeEntityDetails, packageResults, recommendationResults, portingActionResults, targetFramework); return(new ProjectAnalysisResult { ProjectName = analyzer.ProjectResult.ProjectName, ProjectFilePath = analyzer.ProjectResult.ProjectFilePath, TargetFrameworks = targetframeworks, PackageReferences = nugetPackages.ToList(), ProjectReferences = analyzer.ProjectResult.ExternalReferences.ProjectReferences.ConvertAll(p => new ProjectReference { ReferencePath = p.AssemblyLocation }), PackageAnalysisResults = packageAnalysisResults, IsBuildFailed = analyzer.ProjectResult.IsBuildFailed(), Errors = analyzer.ProjectResult.BuildErrors, ProjectGuid = analyzer.ProjectResult.ProjectGuid, ProjectType = analyzer.ProjectResult.ProjectType, SourceFileAnalysisResults = SourceFileAnalysisResults }); } catch (Exception ex) { _logger.LogError("Error while analyzing {0}, {1}", project, ex); return(new ProjectAnalysisResult { ProjectName = Path.GetFileNameWithoutExtension(project), ProjectFilePath = project, TargetFrameworks = new List <string>(), PackageReferences = new List <PackageVersionPair>(), ProjectReferences = new List <ProjectReference>(), PackageAnalysisResults = new Dictionary <PackageVersionPair, Task <PackageAnalysisResult> >(), IsBuildFailed = true, Errors = new List <string> { string.Format("Error while analyzing {0}, {1}", project, ex) }, ProjectGuid = null, ProjectType = null, SourceFileAnalysisResults = new List <SourceFileAnalysisResult>() }); } }