C# Common.AnalyzerLanguage类代码示例

 private static int GetNumberOfCrossReferences(AnalyzerLanguage language)
 {
     return RuleDetailBuilder.GetParameterlessRuleDetails(language)
         .Select(rule => rule.Description)
         .Select(description => Regex.Matches(description, RuleImplementationMeta.CrosslinkPattern).Count)
         .Sum();
 }

 public IEnumerable<Type> GetParameterlessAnalyzerTypes(AnalyzerLanguage language)
 {
     return diagnosticAnalyzers
         .Where(analyzerType =>
             !analyzerType.GetProperties()
                 .Any(p => p.GetCustomAttributes<RuleParameterAttribute>().Any()))
         .Where(type => GetTargetLanguages(type).IsAlso(language));
 }

 public static Solution GetSolutionWithEmptyFile(AnalyzerLanguage language)
 {
     using (var workspace = new AdhocWorkspace())
     {
         var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic;
         return workspace.CurrentSolution.AddProject("foo", "foo.dll", lang)
             .AddMetadataReference(SystemMetadataReference)
             .AddDocument($"foo.{language.GetFileExtension()}", string.Empty)
             .Project
             .Solution;
     }
 }

        private static void WriteQualityProfileFile(string filePath, IEnumerable<RuleDetail> ruleDetails, AnalyzerLanguage language)
        {
            var root = new QualityProfileRoot(language);
            root.Rules.AddRange(ruleDetails
                .Where(descriptor => descriptor.IsActivatedByDefault)
                .Select(descriptor => new QualityProfileRuleDescriptor(language)
                {
                    Key = descriptor.Key
                }));

            SerializeObjectToFile(filePath, root);
        }

        private static void CheckRuleDescriptorsNotEmpty(AnalyzerLanguage language)
        {
            var ruleDetails = RuleDetailBuilder.GetAllRuleDetails(language).ToList();
            foreach (var ruleDetail in ruleDetails)
            {
                Assert.IsNotNull(ruleDetail);
                Assert.IsNotNull(ruleDetail.Description);
                Assert.IsNotNull(ruleDetail.Key);
                Assert.IsNotNull(ruleDetail.Title);
            }

            Assert.AreEqual(ruleDetails.Count,
                ruleDetails.Select(descriptor => descriptor.Key).Distinct().Count());
        }

 public static RuleImplementationMeta Convert(RuleDetail detail, string productVersion, AnalyzerLanguage language)
 {
     return new RuleImplementationMeta
     {
         Id = detail.Key,
         Language = language.GetFriendlyName(),
         Severity = detail.Severity,
         Title = detail.Title,
         Description = GetParameterDescription(detail.Parameters) +
             AddLinksBetweenRulesToDescription(detail.Description, productVersion) +
             GetCodeFixDescription(detail),
         Tags = detail.Tags
     };
 }

        public bool IsAlso(AnalyzerLanguage other)
        {
            if (other == null)
            {
                throw new ArgumentNullException(nameof(other));
            }

            if (other == None)
            {
                throw new NotSupportedException("IsAlso doesn't support AnalyzerLanguage.None.");
            }

            return this == other || this == Both;
        }

        public static Solution GetSolutionFromFiles(string filePath, AnalyzerLanguage language)
        {
            using (var workspace = new AdhocWorkspace())
            {
                var file = new FileInfo(filePath);
                var lang = language == AnalyzerLanguage.CSharp ? LanguageNames.CSharp : LanguageNames.VisualBasic;
                var project = workspace.CurrentSolution.AddProject("foo", "foo.dll", lang)
                    .AddMetadataReference(SystemMetadataReference);

                var document = project.AddDocument(file.Name, File.ReadAllText(file.FullName, Encoding.UTF8));
                project = document.Project;

                return project.Solution;
            }
        }

        public AnalyzerLanguage AddLanguage(AnalyzerLanguage other)
        {
            if (other == null)
            {
                throw new ArgumentNullException(nameof(other));
            }

            if (this == None ||
                this == other)
            {
                return other;
            }

            return Both;
        }

        public Configuration(string path, AnalyzerLanguage language)
        {
            if (!ParameterLoader.ConfigurationFilePathMatchesExpected(path))
            {
                throw new ArgumentException(
                    $"Input configuration doesn't match expected file name: '{ParameterLoader.ParameterConfigurationFileName}'",
                    nameof(path));
            }

            Path = path;
            analyzers = ImmutableArray.Create(GetAnalyzers(language).ToArray());

            var xml = XDocument.Load(path);
            var settings = ParseSettings(xml);
            IgnoreHeaderComments = "true".Equals(settings[$"sonar.{language}.ignoreHeaderComments"], StringComparison.OrdinalIgnoreCase);

            Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList();

            AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet();
        }

        private static RuleDetail GetRuleDetail(Type analyzerType, AnalyzerLanguage language)
        {
            var rule = analyzerType.GetCustomAttributes<RuleAttribute>().Single();

            var ruleDetail = new RuleDetail
            {
                Key = rule.Key,
                Title = rule.Title,
                Severity = rule.Severity.ToString(),
                IsActivatedByDefault = rule.IsActivatedByDefault,
                Description = GetResourceHtml(rule, language)
            };

            GetParameters(analyzerType, ruleDetail);
            GetTags(analyzerType, ruleDetail);
            GetSqale(analyzerType, ruleDetail);
            GetCodeFixNames(analyzerType, ruleDetail);

            return ruleDetail;
        }

 public static RuleDescription Convert(RuleDetail detail, string productVersion, AnalyzerLanguage language)
 {
     return new RuleDescription
     {
         Key = detail.Key,
         Data = new Dictionary<string, RuleMetaData>
         {
             {
                 language.ToString(),
                 new RuleMetaData
                 {
                     Title = detail.Title,
                     Description =
                         GetParameterDescription(detail.Parameters) +
                         AddLinksBetweenRulesToDescription(detail.Description, productVersion) +
                         GetCodeFixDescription(detail),
                     Tags = detail.Tags,
                     Severity = detail.Severity,
                     IdeSeverity = detail.IdeSeverity
                 }
             }
         }
     };
 }

        public Configuration(XContainer xml, AnalyzerLanguage language)
        {
            this.language = language;
            nonTemplateAnalyzers = ImmutableArray.Create(GetNonTemplateAnalyzers(language).ToArray());

            var settings = ParseSettings(xml);
            IgnoreHeaderComments = "true".Equals(settings["sonar.cs.ignoreHeaderComments"]);

            Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList();

            AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet();

            var builder = ImmutableList.CreateBuilder<RuleParameterValues>();
            foreach (var rule in xml.Descendants("Rule").Where(e => e.Elements("Parameters").Any()))
            {
                var analyzerId = rule.Elements("Key").Single().Value;

                var parameterValues = rule
                    .Elements("Parameters").Single()
                    .Elements("Parameter")
                    .Select(e => new RuleParameterValue
                    {
                        ParameterKey = e.Elements("Key").Single().Value,
                        ParameterValue = e.Elements("Value").Single().Value
                    });

                var pvs = new RuleParameterValues
                {
                    RuleId = analyzerId
                };
                pvs.ParameterValues.AddRange(parameterValues);

                builder.Add(pvs);
            }
            parameters = builder.ToImmutable();
        }

 private static int Lines(AnalyzerLanguage language, string text) => MetricsFor(language, text).LineCount;

 private static Distribution FunctionComplexityDistribution(AnalyzerLanguage language, string text) =>
     MetricsFor(language, text).FunctionComplexityDistribution;