Beispiel #1
0
        private static ImmutableArray <(string analyzerId, SerializableDiagnosticMap diagnosticMap)> Dehydrate(
            ImmutableDictionary <DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder> builderMap,
            BidirectionalMap <string, DiagnosticAnalyzer> analyzerToIdMap
            )
        {
            using var _ =
                      ArrayBuilder <(string analyzerId, SerializableDiagnosticMap diagnosticMap)> .GetInstance(
                          out var diagnostics
                          );

            foreach (var(analyzer, analyzerResults) in builderMap)
            {
                var analyzerId = GetAnalyzerId(analyzerToIdMap, analyzer);

                diagnostics.Add(
                    (
                        analyzerId,
                        new SerializableDiagnosticMap(
                            analyzerResults.SyntaxLocals.SelectAsArray(
                                entry => (entry.Key, entry.Value)
                                ),
                            analyzerResults.SemanticLocals.SelectAsArray(
                                entry => (entry.Key, entry.Value)
                                ),
                            analyzerResults.NonLocals.SelectAsArray(
                                entry => (entry.Key, entry.Value)
                                ),
                            analyzerResults.Others
                            )
                    )
                    );
            }

            return(diagnostics.ToImmutable());
        }
Beispiel #2
0
            static ImmutableDictionary <string, AnalyzerTelemetryInfo> GetTelemetryInfo(
                AnalysisResult analysisResult,
                ImmutableArray <DiagnosticAnalyzer> analyzers,
                BidirectionalMap <string, DiagnosticAnalyzer> analyzerToIdMap)
            {
                Func <DiagnosticAnalyzer, bool> shouldInclude;

                if (analyzers.Length < analysisResult.AnalyzerTelemetryInfo.Count)
                {
                    // Filter the telemetry info to the executed analyzers.
                    using var _ = PooledHashSet <DiagnosticAnalyzer> .GetInstance(out var analyzersSet);

                    analyzersSet.AddRange(analyzers);

                    shouldInclude = analyzer => analyzersSet.Contains(analyzer);
                }
                else
                {
                    shouldInclude = _ => true;
                }

                var telemetryBuilder = ImmutableDictionary.CreateBuilder <string, AnalyzerTelemetryInfo>();

                foreach (var(analyzer, analyzerTelemetry) in analysisResult.AnalyzerTelemetryInfo)
                {
                    if (shouldInclude(analyzer))
                    {
                        var analyzerId = GetAnalyzerId(analyzerToIdMap, analyzer);
                        telemetryBuilder.Add(analyzerId, analyzerTelemetry);
                    }
                }

                return(telemetryBuilder.ToImmutable());
            }
Beispiel #3
0
        private static async Task <CompilationWithAnalyzersCacheEntry> CreateCompilationWithAnalyzersCacheEntryAsync(Project project, CancellationToken cancellationToken)
        {
            // We could consider creating a service so that we don't do this repeatedly if this shows up as perf cost
            using var pooledObject = SharedPools.Default <HashSet <object> >().GetPooledObject();
            using var pooledMap    = SharedPools.Default <Dictionary <string, DiagnosticAnalyzer> >().GetPooledObject();
            var referenceSet       = pooledObject.Object;
            var analyzerMapBuilder = pooledMap.Object;

            // This follows what we do in DiagnosticAnalyzerInfoCache.CheckAnalyzerReferenceIdentity
            using var _ = ArrayBuilder <DiagnosticAnalyzer> .GetInstance(out var analyzerBuilder);

            foreach (var reference in project.Solution.AnalyzerReferences.Concat(project.AnalyzerReferences))
            {
                if (!referenceSet.Add(reference.Id))
                {
                    continue;
                }

                var analyzers = reference.GetAnalyzers(project.Language);
                analyzerBuilder.AddRange(analyzers);
                analyzerMapBuilder.AppendAnalyzerMap(analyzers);
            }

            var compilationWithAnalyzers = await CreateCompilationWithAnalyzerAsync(
                project, analyzerBuilder.ToImmutable(), cancellationToken).ConfigureAwait(false);

            var analyzerToIdMap = new BidirectionalMap <string, DiagnosticAnalyzer>(analyzerMapBuilder);

            return(new CompilationWithAnalyzersCacheEntry(compilationWithAnalyzers, analyzerToIdMap));
    public static void Test()
    {
        //This line compiles
        var possiblyBad = new BidirectionalMap <string, string>();

        //This causes the compiler to fail with an ambiguous invocation
        possiblyBad.Remove("Something");
    }
 static LanguageServer()
 {
     VsCodeLanguageToLanguageNameMap = new BidirectionalMap <string, string>(new[]
     {
         new KeyValuePair <string, string>("hlsl", LanguageNames.Hlsl),
         new KeyValuePair <string, string>("shaderlab", LanguageNames.ShaderLab)
     });
 }
Beispiel #6
0
 public CompilationWithAnalyzersCacheEntry(
     CompilationWithAnalyzers compilationWithAnalyzers,
     BidirectionalMap <string, DiagnosticAnalyzer> analyzerToIdMap
     )
 {
     CompilationWithAnalyzers = compilationWithAnalyzers;
     AnalyzerToIdMap          = analyzerToIdMap;
 }
Beispiel #7
0
        private string GetAnalyzerId(BidirectionalMap <string, DiagnosticAnalyzer> analyzerMap, DiagnosticAnalyzer analyzer)
        {
            var analyzerId = analyzerMap.GetKeyOrDefault(analyzer);

            Contract.ThrowIfNull(analyzerId);

            return(analyzerId);
        }
Beispiel #8
0
        private async Task <DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> > AnalyzeAsync(
            BidirectionalMap <string, DiagnosticAnalyzer> analyzerMap,
            ImmutableArray <DiagnosticAnalyzer> analyzers,
            OptionSet options,
            bool reportSuppressedDiagnostics,
            bool logAnalyzerExecutionTime,
            CancellationToken cancellationToken)
        {
            // flag that controls concurrency
            var useConcurrent = true;

            // get original compilation
            var compilation = await _project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

            // fork compilation with concurrent build. this is okay since WithAnalyzers will fork compilation
            // anyway to attach event queue. this should make compiling compilation concurrent and make things
            // faster
            compilation = compilation.WithOptions(compilation.Options.WithConcurrentBuild(useConcurrent));

            // We need this to fork soluton, otherwise, option is cached at document.
            // all this can go away once we do this - https://github.com/dotnet/roslyn/issues/19284
            var temporaryWorksapce = new TemporaryWorkspace(_project.Solution);

            // TODO: can we support analyzerExceptionFilter in remote host?
            //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
            var analyzerOptions = new CompilationWithAnalyzersOptions(
                options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), temporaryWorksapce.CurrentSolution),
                onAnalyzerException: OnAnalyzerException,
                analyzerExceptionFilter: null,
                concurrentAnalysis: useConcurrent,
                logAnalyzerExecutionTime: logAnalyzerExecutionTime,
                reportSuppressedDiagnostics: reportSuppressedDiagnostics);

            var analyzerDriver = compilation.WithAnalyzers(analyzers, analyzerOptions);

            // PERF: Run all analyzers at once using the new GetAnalysisResultAsync API.
            var analysisResult = await analyzerDriver.GetAnalysisResultAsync(cancellationToken).ConfigureAwait(false);

            // REVIEW: the design of current analyzer engine is that, information/states in CompilationWithAnalyzer (more specifically AnalyzerManager singleton)
            //         will live forever until analyzer references (analyzers), which is given to CompilationWithAnalyzer, go away.
            //         that is not suitable for OOP since OOP will create new workspace
            //         for each analysis but share all resources including analyzer references.
            //         until, we address this issue, OOP will clear state every time analysis is done.
            //
            //         * NOTE * this only works for now since we don't run analysis on multiple threads.
            //
            //         best way to fix this is doing this - https://github.com/dotnet/roslyn/issues/2830
            //         host should control lifetime of all information related to analyzer reference explicitly
            CompilationWithAnalyzers.ClearAnalyzerState(analyzers);

            var builderMap = analysisResult.ToResultBuilderMap(_project, VersionStamp.Default, compilation, analysisResult.Analyzers, cancellationToken);

            return(DiagnosticAnalysisResultMap.Create(
                       builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                       analysisResult.AnalyzerTelemetryInfo.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                       _exceptions.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value.ToImmutableArray())));
        }
Beispiel #9
0
 /// <summary>
 /// Creates a data reader that reads from the underlying stream and returns only the columns specified in the transform.
 /// </summary>
 /// <param name="reader"></param>
 /// <param name="resultColumnsByColumnName"></param>
 public ProjectingDataReader(TDataReader reader, Dictionary <string, RowProjection <object> > resultColumnsByColumnName)
     : base(reader)
 {
     _columnsByName = resultColumnsByColumnName;
     //
     _columns    = resultColumnsByColumnName.Select(n => n.Value).ToArray();
     _fieldCount = _columns.Length;
     //
     _nameToOrdinalMapping = resultColumnsByColumnName.Select((o, i) => new { o, i }).ToBidirectionalMap(p => p.o.Key, p => p.i);
 }
Beispiel #10
0
 public ProjectingDataReader(TDataReader dataReader, RowProjection <object>[] resultColumns) : base(dataReader)
 {
     _columns = resultColumns;
     //
     _columnsByName =
         _columns.Select((i, o) => new { Index = i, Projection = o })
         .ToDictionary(p => "COLUMN" + p.Index, p => p.Index);
     _fieldCount = _columns.Length;
     //
     _nameToOrdinalMapping = _columnsByName.Select((o, i) => new { o, i }).ToBidirectionalMap(p => p.o.Key, p => p.i);
 }
Beispiel #11
0
        private async Task <DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> > AnalyzeAsync(
            BidirectionalMap <string, DiagnosticAnalyzer> analyzerMap,
            ImmutableArray <DiagnosticAnalyzer> analyzers,
            OptionSet options,
            bool reportSuppressedDiagnostics,
            bool logAnalyzerExecutionTime,
            CancellationToken cancellationToken)
        {
            // flag that controls concurrency
            var useConcurrent = true;

            // get original compilation
            var compilation = await _project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

            // fork compilation with concurrent build. this is okay since WithAnalyzers will fork compilation
            // anyway to attach event queue. this should make compiling compilation concurrent and make things
            // faster
            compilation = compilation.WithOptions(compilation.Options.WithConcurrentBuild(useConcurrent));

            // We need this to fork soluton, otherwise, option is cached at document.
            // all this can go away once we do this - https://github.com/dotnet/roslyn/issues/19284
            using (var temporaryWorksapce = new TemporaryWorkspace(_project.Solution))
            {
                // TODO: can we support analyzerExceptionFilter in remote host?
                //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
                var analyzerOptions = new CompilationWithAnalyzersOptions(
                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, MergeOptions(_project.Solution.Options, options), temporaryWorksapce.CurrentSolution),
                    onAnalyzerException: OnAnalyzerException,
                    analyzerExceptionFilter: null,
                    concurrentAnalysis: useConcurrent,
                    logAnalyzerExecutionTime: logAnalyzerExecutionTime,
                    reportSuppressedDiagnostics: reportSuppressedDiagnostics);

                var analyzerDriver = compilation.WithAnalyzers(analyzers, analyzerOptions);

                // PERF: Run all analyzers at once using the new GetAnalysisResultAsync API.
                var analysisResult = await analyzerDriver.GetAnalysisResultAsync(cancellationToken).ConfigureAwait(false);

                // record performance if tracker is available
                if (_performanceTracker != null)
                {
                    // +1 to include project itself
                    _performanceTracker.AddSnapshot(analysisResult.AnalyzerTelemetryInfo.ToAnalyzerPerformanceInfo(), _project.DocumentIds.Count + 1);
                }

                var builderMap = analysisResult.ToResultBuilderMap(_project, VersionStamp.Default, compilation, analysisResult.Analyzers, cancellationToken);

                return(DiagnosticAnalysisResultMap.Create(
                           builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                           analysisResult.AnalyzerTelemetryInfo.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                           _exceptions.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value.ToImmutableArray())));
            }
        }
        public void Test3()
        {
            var d = new BidirectionalMap <string, int>();

            d.Add(new Tuple <string, int>("Col1", 1));
            d.Add(new Tuple <string, int>("Col2", 2));
            d.Add(new Tuple <string, int>("Col3", 3));

            Assert.ThrowsException <ItemsNotOneToOneException>(() =>
            {
                d.Add(new Tuple <string, int>("Col3", 1));
            });
        }
        public void Test4()
        {
            var d = new BidirectionalMap <int, int>();

            d.Add(new Tuple <int, int>(1, 5));
            d.Add(new Tuple <int, int>(2, 6));
            d.Add(new Tuple <int, int>(3, 7));

            Assert.ThrowsException <ItemsNotOneToOneException>(() =>
            {
                d.Add(new Tuple <int, int>(4, 7));
            });
        }
Beispiel #14
0
    void UpdateRenderables <T>(
        List <T> renderables,
        GameObject newObject,
        List <GameObject> objectPool,
        BidirectionalMap <T, GameObject> renderableObjectMap,
        Transform uiContainer,
        System.Action <GameObject> onCreateCallback = null)
        where T : IRenderable
    {
        // Put all GameObjects in a set, and remove the objects that are still in used
        HashSet <GameObject> unusedObjects = new HashSet <GameObject>(renderableObjectMap.Values);

        foreach (T renderable in renderables)
        {
            GameObject uiObject;
            // Spawn new UI person
            if (!renderableObjectMap.ContainsKey(renderable))
            {
                if (objectPool.Count > 0)
                {
                    uiObject = objectPool[objectPool.Count - 1];
                    objectPool.RemoveAt(objectPool.Count - 1);
                    uiObject.SetActive(true);
                }
                else
                {
                    uiObject = Instantiate(newObject);
                }
                uiObject.transform.SetParent(uiContainer, false);
                renderableObjectMap.Add(renderable, uiObject);
                if (onCreateCallback != null)
                {
                    onCreateCallback(uiObject);
                }
            }
            else
            {
                uiObject = renderableObjectMap.GetValue(renderable);
                unusedObjects.Remove(uiObject);
            }
            renderable.RenderTo(uiObject);
        }
        foreach (GameObject uiObject in unusedObjects)
        {
            renderableObjectMap.RemoveValue(uiObject);
            objectPool.Add(uiObject);
            uiObject.SetActive(false);
            uiObject.transform.SetParent(null, false);
        }
    }
Beispiel #15
0
        private ImmutableArray <DiagnosticAnalyzer> GetAnalyzers(BidirectionalMap <string, DiagnosticAnalyzer> analyzerMap, IEnumerable <string> analyzerIds)
        {
            // TODO: this probably need to be cached as well in analyzer service?
            var builder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>();

            foreach (var analyzerId in analyzerIds)
            {
                if (analyzerMap.TryGetValue(analyzerId, out var analyzer))
                {
                    builder.Add(analyzer);
                }
            }

            return(builder.ToImmutable());
        }
        private async Task <DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> > AnalyzeAsync(
            BidirectionalMap <string, DiagnosticAnalyzer> analyzerMap,
            ImmutableArray <DiagnosticAnalyzer> analyzers,
            SkippedHostAnalyzersInfo skippedAnalyzersInfo,
            bool reportSuppressedDiagnostics,
            bool logAnalyzerExecutionTime,
            CancellationToken cancellationToken)
        {
            // flag that controls concurrency
            var useConcurrent = true;

            // get original compilation
            var compilation = await _project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

            // fork compilation with concurrent build. this is okay since WithAnalyzers will fork compilation
            // anyway to attach event queue. this should make compiling compilation concurrent and make things
            // faster
            compilation = compilation.WithOptions(compilation.Options.WithConcurrentBuild(useConcurrent));

            // TODO: can we support analyzerExceptionFilter in remote host?
            //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
            var analyzerOptions = new CompilationWithAnalyzersOptions(
                options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, _project.Solution),
                onAnalyzerException: null,
                analyzerExceptionFilter: null,
                concurrentAnalysis: useConcurrent,
                logAnalyzerExecutionTime: logAnalyzerExecutionTime,
                reportSuppressedDiagnostics: reportSuppressedDiagnostics);

            var analyzerDriver = compilation.WithAnalyzers(analyzers, analyzerOptions);

            // PERF: Run all analyzers at once using the new GetAnalysisResultAsync API.
            var(analysisResult, additionalPragmaSuppressionDiagnostics) = await analyzerDriver.GetAnalysisResultAsync(_project, _analyzerInfoCache, cancellationToken).ConfigureAwait(false);

            // record performance if tracker is available
            if (_performanceTracker != null)
            {
                // +1 to include project itself
                _performanceTracker.AddSnapshot(analysisResult.AnalyzerTelemetryInfo.ToAnalyzerPerformanceInfo(_analyzerInfoCache), _project.DocumentIds.Count + 1);
            }

            var builderMap = analysisResult.ToResultBuilderMap(additionalPragmaSuppressionDiagnostics, _project, VersionStamp.Default, compilation, analysisResult.Analyzers, skippedAnalyzersInfo, cancellationToken);

            return(DiagnosticAnalysisResultMap.Create(
                       builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                       analysisResult.AnalyzerTelemetryInfo.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value)));
        }
Beispiel #17
0
        private async Task<DiagnosticAnalysisResultMap<string, DiagnosticAnalysisResultBuilder>> AnalyzeAsync(
            BidirectionalMap<string, DiagnosticAnalyzer> analyzerMap,
            ImmutableArray<DiagnosticAnalyzer> analyzers,
            bool reportSuppressedDiagnostics,
            bool logAnalyzerExecutionTime,
            CancellationToken cancellationToken)
        {
            var compilation = await _project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

            // TODO: can we support analyzerExceptionFilter in remote host? 
            //       right now, host doesn't support watson, we might try to use new NonFatal watson API?
            var analyzerOptions = new CompilationWithAnalyzersOptions(
                    options: new WorkspaceAnalyzerOptions(_project.AnalyzerOptions, _project.Solution.Workspace),
                    onAnalyzerException: OnAnalyzerException,
                    analyzerExceptionFilter: null,
                    concurrentAnalysis: true,
                    logAnalyzerExecutionTime: logAnalyzerExecutionTime,
                    reportSuppressedDiagnostics: reportSuppressedDiagnostics);

            var analyzerDriver = compilation.WithAnalyzers(analyzers, analyzerOptions);

            // PERF: Run all analyzers at once using the new GetAnalysisResultAsync API.
            var analysisResult = await analyzerDriver.GetAnalysisResultAsync(cancellationToken).ConfigureAwait(false);

            // REVIEW: the design of current analyzer engine is that, information/states in CompilationWithAnalyzer (more specifically AnalyzerManager singleton)
            //         will live forever until analyzer references (analyzers), which is given to CompilationWithAnalyzer, go away.
            //         that is not suitable for OOP since OOP will create new workspace
            //         for each analysis but share all resources including analyzer references.
            //         until, we address this issue, OOP will clear state every time analysis is done.
            //
            //         * NOTE * this only works for now since we don't run analysis on multiple threads.
            //
            //         best way to fix this is doing this - https://github.com/dotnet/roslyn/issues/2830
            //         host should control lifetime of all information related to analyzer reference explicitly
            CompilationWithAnalyzers.ClearAnalyzerState(analyzers);

            var builderMap = analysisResult.ToResultBuilderMap(_project, VersionStamp.Default, compilation, analysisResult.Analyzers, cancellationToken);

            return DiagnosticAnalysisResultMap.Create(
                builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                analysisResult.AnalyzerTelemetryInfo.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value),
                _exceptions.ToImmutableDictionary(kv => GetAnalyzerId(analyzerMap, kv.Key), kv => kv.Value.ToImmutableArray()));
        }
        public void Test6()
        {
            var d = new BidirectionalMap <string, int>(new Dictionary <string, int>()
            {
                { "Col1", 1 },
                { "Col2", 2 },
                { "Col3", 3 }
            });

            Assert.AreEqual(d.Count, 3);

            Assert.AreEqual(d.GetLeft(1), "Col1");
            Assert.AreEqual(d.GetRight("Col3"), 3);

            Assert.ThrowsException <ItemsNotOneToOneException>(() =>
            {
                d.Add(new Tuple <string, int>("Col1", 3));
            });
        }
        public void Test5()
        {
            var d = new BidirectionalMap <int, int>();

            d.Add(new Tuple <int, int>(1, 5));
            d.Add(new Tuple <int, int>(2, 6));
            d.Add(new Tuple <int, int>(3, 7));

            Assert.AreEqual(d.Count, 3);

            Assert.AreEqual(d.GetLeft(7), 3);
            Assert.AreEqual(d.GetRight(3), 7);

            Assert.ThrowsException <Exception>(() =>
            {
                var e = d.GetLeft(11);
            });

            Assert.ThrowsException <Exception>(() =>
            {
                var e = d.GetRight(11);
            });
        }
Beispiel #20
0
        private async Task <DiagnosticAnalysisResultMap <string, DiagnosticAnalysisResultBuilder> > AnalyzeAsync(
            CompilationWithAnalyzers compilationWithAnalyzers,
            BidirectionalMap <string, DiagnosticAnalyzer> analyzerToIdMap,
            ImmutableArray <DiagnosticAnalyzer> analyzers,
            SkippedHostAnalyzersInfo skippedAnalyzersInfo,
            bool reportSuppressedDiagnostics,
            bool logPerformanceInfo,
            bool getTelemetryInfo,
            CancellationToken cancellationToken)
        {
            var documentAnalysisScope = _document != null
                ? new DocumentAnalysisScope(_document, _span, analyzers, _analysisKind !.Value)
                : null;

            var(analysisResult, additionalPragmaSuppressionDiagnostics) = await compilationWithAnalyzers.GetAnalysisResultAsync(
                documentAnalysisScope, _project, _analyzerInfoCache, cancellationToken).ConfigureAwait(false);

            // Record performance if tracker is available
            if (logPerformanceInfo && _performanceTracker != null)
            {
                // +1 to include project itself
                var unitCount = documentAnalysisScope != null ? 1 : _project.DocumentIds.Count + 1;
                _performanceTracker.AddSnapshot(analysisResult.AnalyzerTelemetryInfo.ToAnalyzerPerformanceInfo(_analyzerInfoCache), unitCount);
            }

            var builderMap = await analysisResult.ToResultBuilderMapAsync(
                additionalPragmaSuppressionDiagnostics, documentAnalysisScope,
                _project, VersionStamp.Default, compilationWithAnalyzers.Compilation,
                analyzers, skippedAnalyzersInfo, reportSuppressedDiagnostics, cancellationToken).ConfigureAwait(false);

            var result    = builderMap.ToImmutableDictionary(kv => GetAnalyzerId(analyzerToIdMap, kv.Key), kv => kv.Value);
            var telemetry = getTelemetryInfo
                ? GetTelemetryInfo(analysisResult, analyzers, analyzerToIdMap)
                : ImmutableDictionary <string, AnalyzerTelemetryInfo> .Empty;

            return(DiagnosticAnalysisResultMap.Create(result, telemetry));
        public HeaderDataReader(IDataReader dataReader, HeaderReaderConfiguration configuration) : base(dataReader)
        {
            this._configuration = configuration;

            //build col info
            _columnsLazy = new Lazy <SimpleColumnInfo[]>(() =>
            {
                var d = HeaderInformation();

                return(d);
            });

            //build col names index
            _columnNamesToIndex = new Lazy <BidirectionalMap <string, int> >(() =>
            {
                var cols = _columnsLazy.Value
                           .Select(c => new KeyValuePair <string, int>(c.ColumnName, c.Index))
                           .ToArray();

                var r = new BidirectionalMap <string, int>(cols);

                return(r);
            });
        }
 /*************************/
 // Constructor
 /*************************/
 // Basic constructor
 public LinearRepresentativeList()
 {
     _map = new BidirectionalMap<BitSet, BitSet>();
 }
 /*************************/
 // Constructor
 /*************************/
 // Basic constructor
 public RepresentativeList()
 {
     Map = new BidirectionalMap<BitSet, dNeighborhood>();
 }
Beispiel #24
0
        private string GetAnalyzerId(BidirectionalMap<string, DiagnosticAnalyzer> analyzerMap, DiagnosticAnalyzer analyzer)
        {
            var analyzerId = analyzerMap.GetKeyOrDefault(analyzer);
            Contract.ThrowIfNull(analyzerId);

            return analyzerId;
        }
 public void Setup()
 {
     map = new BidirectionalMap <int, string>();
 }
Beispiel #26
0
        private ImmutableArray<DiagnosticAnalyzer> GetAnalyzers(BidirectionalMap<string, DiagnosticAnalyzer> analyzerMap, IEnumerable<string> analyzerIds)
        {
            // TODO: this probably need to be cached as well in analyzer service?
            var builder = ImmutableArray.CreateBuilder<DiagnosticAnalyzer>();

            foreach (var analyzerId in analyzerIds)
            {
                DiagnosticAnalyzer analyzer;
                if (analyzerMap.TryGetValue(analyzerId, out analyzer))
                {
                    builder.Add(analyzer);
                }
            }

            return builder.ToImmutable();
        }