public bool AppliesTo(
SymbolKindOrTypeKind kind,
DeclarationModifiers modifiers,
Accessibility?accessibility
)
{
if (!ApplicableSymbolKindList.Any(k => k.Equals(kind)))
{
return(false);
}
var collapsedModifiers = CollapseModifiers(RequiredModifierList);
if ((modifiers & collapsedModifiers) != collapsedModifiers)
{
return(false);
}
if (accessibility.HasValue && !ApplicableAccessibilityList.Any(k => k == accessibility))
{
return(false);
}
return(true);
}
private async Task <IEnumerable <(string, SymbolKind)> > GetRecommendedNamesAsync(
IEnumerable <IEnumerable <string> > baseNames,
NameDeclarationInfo declarationInfo,
CSharpSyntaxContext context,
Document document,
CancellationToken cancellationToken)
{
var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
var namingStyleOptions = options.GetOption(SimplificationOptions.NamingPreferences);
var rules = namingStyleOptions.CreateRules().NamingRules.Concat(s_BuiltInRules);
var result = new Dictionary <string, SymbolKind>();
foreach (var symbolKind in declarationInfo.PossibleSymbolKinds)
{
var kind = new SymbolKindOrTypeKind(symbolKind);
var modifiers = declarationInfo.Modifiers;
foreach (var rule in rules)
{
if (rule.SymbolSpecification.AppliesTo(kind, declarationInfo.Modifiers, declarationInfo.DeclaredAccessibility))
{
foreach (var baseName in baseNames)
{
var name = rule.NamingStyle.CreateName(baseName);
if (name.Length > 1 && !result.ContainsKey(name)) // Don't add multiple items for the same name
{
result.Add(name, symbolKind);
}
}
}
}
}
return(result.Select(kvp => (kvp.Key, kvp.Value)));
}
public static SymbolSpecification ReadFrom(ObjectReader reader)
{
return(new SymbolSpecification(
reader.ReadGuid(),
reader.ReadString(),
reader.ReadArray(r => SymbolKindOrTypeKind.ReadFrom(r)),
reader.ReadArray(r => (Accessibility)r.ReadInt32()),
reader.ReadArray(r => ModifierKind.ReadFrom(r))));
}
private void PopulateSymbolKindListFromXElement(XElement symbolKindListElement)
{
ApplicableSymbolKindList = new List <SymbolKindOrTypeKind>();
foreach (var symbolKindElement in symbolKindListElement.Elements(nameof(SymbolKind)))
{
ApplicableSymbolKindList.Add(SymbolKindOrTypeKind.AddSymbolKindFromXElement(symbolKindElement));
}
foreach (var typeKindElement in symbolKindListElement.Elements(nameof(TypeKind)))
{
ApplicableSymbolKindList.Add(SymbolKindOrTypeKind.AddTypeKindFromXElement(typeKindElement));
}
}
public static async Task <NamingRule> GetApplicableNamingRuleAsync(
this Document document, SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility?accessibility, NamingStylePreferencesProvider fallbackOptions, CancellationToken cancellationToken)
{
var rules = await document.GetNamingRulesAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
foreach (var rule in rules)
{
if (rule.SymbolSpecification.AppliesTo(kind, modifiers, accessibility))
{
return(rule);
}
}
throw ExceptionUtilities.Unreachable;
}
private static ImmutableArray <SymbolKindOrTypeKind> GetSymbolKindListFromXElement(XElement symbolKindListElement)
{
var applicableSymbolKindList = ArrayBuilder <SymbolKindOrTypeKind> .GetInstance();
foreach (var symbolKindElement in symbolKindListElement.Elements(nameof(SymbolKind)))
{
applicableSymbolKindList.Add(SymbolKindOrTypeKind.AddSymbolKindFromXElement(symbolKindElement));
}
foreach (var typeKindElement in symbolKindListElement.Elements(nameof(TypeKind)))
{
applicableSymbolKindList.Add(SymbolKindOrTypeKind.AddTypeKindFromXElement(typeKindElement));
}
return(applicableSymbolKindList.ToImmutableAndFree());
}
private static string ToEditorConfigString(this SymbolKindOrTypeKind symbol)
{
switch (symbol.MethodKind)
{
case MethodKind.Ordinary:
return("method");
case MethodKind.LocalFunction:
return("local_function");
case null:
break;
default:
throw ExceptionUtilities.UnexpectedValue(symbol);
}
switch (symbol.TypeKind)
{
case TypeKind.Class:
return("class");
case TypeKind.Struct:
return("struct");
case TypeKind.Interface:
return("interface");
case TypeKind.Enum:
return("enum");
case TypeKind.Delegate:
return("delegate");
case null:
break;
default:
throw ExceptionUtilities.UnexpectedValue(symbol);
}
switch (symbol.SymbolKind)
{
case SymbolKind.Namespace:
return("namespace");
case SymbolKind.Property:
return("property");
case SymbolKind.Field:
return("field");
case SymbolKind.Event:
return("event");
case SymbolKind.Parameter:
return("parameter");
case SymbolKind.TypeParameter:
return("type_parameter");
case SymbolKind.Local:
return("local");
case null:
break;
default:
throw ExceptionUtilities.UnexpectedValue(symbol);
}
throw ExceptionUtilities.UnexpectedValue(symbol);
}
public bool Equals(SymbolKindOrTypeKind other) => this.SymbolKind == other.SymbolKind && this.TypeKind == other.TypeKind && this.MethodKind == other.MethodKind;
public bool AppliesTo(SymbolKindOrTypeKind kind, DeclarationModifiers modifiers, Accessibility?accessibility)
{
if (!ApplicableSymbolKindList.Any(static (k, kind) => k.Equals(kind), kind))
