示例#1
0
 private static bool IsScalarType(ITypeSymbol typeSymbol)
 {
     return(KnownSymbols.IsSystemString(typeSymbol) ||
            !typeSymbol.AllInterfaces.Select(i => i.ConstructedFrom).Any(KnownSymbols.IsSystemCollectionsGenericIEnumerable));
 }
示例#2
0
        private static void CheckCommandOptionProperties(
            SymbolAnalysisContext context,
            IReadOnlyList <IPropertySymbol> properties)
        {
            var options = properties
                          .Select(p =>
            {
                var attribute = p
                                .GetAttributes()
                                .First(a => KnownSymbols.IsCommandOptionAttribute(a.AttributeClass));

                var name = attribute
                           .ConstructorArguments
                           .Where(a => KnownSymbols.IsSystemString(a.Type))
                           .Select(a => a.Value)
                           .FirstOrDefault() as string;

                var shortName = attribute
                                .ConstructorArguments
                                .Where(a => KnownSymbols.IsSystemChar(a.Type))
                                .Select(a => a.Value)
                                .FirstOrDefault() as char?;

                return(new
                {
                    Property = p,
                    Name = name,
                    ShortName = shortName
                });
            })
                          .ToArray();

            // No name
            var noNameOptions = options
                                .Where(o => string.IsNullOrWhiteSpace(o.Name) && o.ShortName == null)
                                .ToArray();

            foreach (var option in noNameOptions)
            {
                context.ReportDiagnostic(
                    Diagnostic.Create(DiagnosticDescriptors.Typin0041, option.Property.Locations.First()));
            }

            // Too short name
            var invalidNameLengthOptions = options
                                           .Where(o => !string.IsNullOrWhiteSpace(o.Name) && o.Name.Length <= 1)
                                           .ToArray();

            foreach (var option in invalidNameLengthOptions)
            {
                context.ReportDiagnostic(
                    Diagnostic.Create(DiagnosticDescriptors.Typin0042, option.Property.Locations.First()));
            }

            // Duplicate name
            var duplicateNameOptions = options
                                       .Where(p => !string.IsNullOrWhiteSpace(p.Name))
                                       .GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
                                       .Where(g => g.Count() > 1)
                                       .SelectMany(g => g.AsEnumerable())
                                       .ToArray();

            foreach (var option in duplicateNameOptions)
            {
                context.ReportDiagnostic(
                    Diagnostic.Create(DiagnosticDescriptors.Typin0043, option.Property.Locations.First()));
            }

            // Duplicate name
            var duplicateShortNameOptions = options
                                            .Where(p => p.ShortName != null)
                                            .GroupBy(p => p.ShortName)
                                            .Where(g => g.Count() > 1)
                                            .SelectMany(g => g.AsEnumerable())
                                            .ToArray();

            foreach (var option in duplicateShortNameOptions)
            {
                context.ReportDiagnostic(
                    Diagnostic.Create(DiagnosticDescriptors.Typin0044, option.Property.Locations.First()));
            }
        }