private static NamingStylePreferences AsyncFunctionNamesEndWithAsyncOption() { var symbolSpecification = new SymbolSpecification( null, "Name", ImmutableArray.Create( new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary), new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)), ImmutableArray <Accessibility> .Empty, ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsAsync))); var namingStyle = new NamingStyle( Guid.NewGuid(), capitalizationScheme: Capitalization.PascalCase, name: "Name", prefix: "", suffix: "Async", wordSeparator: ""); var namingRule = new SerializableNamingRule() { SymbolSpecificationID = symbolSpecification.ID, NamingStyleID = namingStyle.ID, EnforcementLevel = DiagnosticSeverity.Error }; var info = new NamingStylePreferences( ImmutableArray.Create(symbolSpecification), ImmutableArray.Create(namingStyle), ImmutableArray.Create(namingRule)); return(info); }
private static NamingStylePreferences ConstantsAreUpperCaseOption() { var symbolSpecification = new SymbolSpecification( null, "Name", ImmutableArray.Create( new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field), new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), ImmutableArray <Accessibility> .Empty, ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst))); var namingStyle = new NamingStyle( Guid.NewGuid(), capitalizationScheme: Capitalization.AllUpper, name: "Name", prefix: "", suffix: "", wordSeparator: ""); var namingRule = new SerializableNamingRule() { SymbolSpecificationID = symbolSpecification.ID, NamingStyleID = namingStyle.ID, EnforcementLevel = DiagnosticSeverity.Error }; var info = new NamingStylePreferences( ImmutableArray.Create(symbolSpecification), ImmutableArray.Create(namingStyle), ImmutableArray.Create(namingRule)); return(info); }
public NamingStyleOptionPageViewModel(NamingStylePreferences info) { var viewModels = new List <NamingRuleViewModel>(); foreach (var namingRule in info.NamingRules) { var viewModel = new NamingRuleViewModel() { NamingStyles = new ObservableCollection <MutableNamingStyle>(info.NamingStyles.Select(n => new MutableNamingStyle(n))), Specifications = new ObservableCollection <SymbolSpecification>(info.SymbolSpecifications), NotificationPreferences = new List <NotificationOptionViewModel>(_notifications) }; viewModel.SelectedSpecification = viewModel.Specifications.Single(s => s.ID == namingRule.SymbolSpecificationID); viewModel.SelectedStyle = viewModel.NamingStyles.Single(s => s.ID == namingRule.NamingStyleID); viewModel.SelectedNotificationPreference = viewModel.NotificationPreferences.Single(n => n.Notification.Value == namingRule.EnforcementLevel); viewModels.Add(viewModel); } CodeStyleItems = new ObservableCollection <NamingRuleViewModel>(viewModels); Specifications = new ObservableCollection <SymbolSpecification>(info.SymbolSpecifications); NamingStyles = new ObservableCollection <MutableNamingStyle>(info.NamingStyles.Select(n => new MutableNamingStyle(n))); SetMoveArrowStatuses(); }
private NamingStylePreferences MethodNamesArePascalCaseOption() { var symbolSpecification = new SymbolSpecification( "Name", SpecializedCollections.SingletonEnumerable(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Method)).ToList(), SpecializedCollections.EmptyList <Accessibility>(), SpecializedCollections.EmptyList <SymbolSpecification.ModifierKind>()); var namingStyle = new NamingStyle() { CapitalizationScheme = Capitalization.PascalCase, Name = "Name", Prefix = "", Suffix = "", WordSeparator = "" }; var namingRule = new SerializableNamingRule() { SymbolSpecificationID = symbolSpecification.ID, NamingStyleID = namingStyle.ID, EnforcementLevel = DiagnosticSeverity.Error }; var info = new NamingStylePreferences(); info.SymbolSpecifications.Add(symbolSpecification); info.NamingStyles.Add(namingStyle); info.NamingRules.Add(namingRule); return(info); }
private static ImmutableDictionary <Guid, string> AssignNamesToNamingStyleElements( NamingStylePreferences namingStylePreferences ) { var symbolSpecificationNames = new HashSet <string>(); var builder = ImmutableDictionary.CreateBuilder <Guid, string>(); foreach (var symbolSpecification in namingStylePreferences.SymbolSpecifications) { var name = ToSnakeCaseName(symbolSpecification.Name); if (!symbolSpecificationNames.Add(name)) { name = symbolSpecification.ID.ToString("n"); } builder.Add(symbolSpecification.ID, name); } var namingStyleNames = new HashSet <string>(); foreach (var namingStyle in namingStylePreferences.NamingStyles) { var name = ToSnakeCaseName(namingStyle.Name); if (!namingStyleNames.Add(name)) { name = namingStyle.ID.ToString("n"); } builder.Add(namingStyle.ID, name); } return(builder.ToImmutable());
private NamingStylePreferences CreateCustomStaticFieldNamingStylePreference() { var symbolSpecification = new SymbolSpecification( null, "Name", ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field)), ImmutableArray <Accessibility> .Empty, ImmutableArray.Create(new ModifierKind(DeclarationModifiers.Static))); var namingStyle = new NamingStyle( Guid.NewGuid(), capitalizationScheme: Capitalization.PascalCase, name: "CustomStaticFieldTest", prefix: "staticfieldtest", suffix: "", wordSeparator: ""); var namingRule = new SerializableNamingRule() { SymbolSpecificationID = symbolSpecification.ID, NamingStyleID = namingStyle.ID, EnforcementLevel = ReportDiagnostic.Error }; var info = new NamingStylePreferences( ImmutableArray.Create(symbolSpecification), ImmutableArray.Create(namingStyle), ImmutableArray.Create(namingRule)); return(info); }
private NamingStylePreferences MethodNamesArePascalCaseOption() { var symbolSpecification = new SymbolSpecification( null, "Name", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Method)), ImmutableArray <Accessibility> .Empty, ImmutableArray <SymbolSpecification.ModifierKind> .Empty); var namingStyle = new NamingStyle( Guid.NewGuid(), capitalizationScheme: Capitalization.PascalCase, name: "Name", prefix: "", suffix: "", wordSeparator: ""); var namingRule = new SerializableNamingRule() { SymbolSpecificationID = symbolSpecification.ID, NamingStyleID = namingStyle.ID, EnforcementLevel = DiagnosticSeverity.Error }; var info = new NamingStylePreferences( ImmutableArray.Create(symbolSpecification), ImmutableArray.Create(namingStyle), ImmutableArray.Create(namingRule)); return(info); }
private static string ReserializePreferences(string serializedPreferences) { var preferences = NamingStylePreferences.FromXElement( XElement.Parse(serializedPreferences) ); return(preferences.CreateXElement().ToString()); }
public static NamingStylePreferences PrependNamingStylePreferences(this NamingStylePreferences original, NamingStylePreferences newPreferences) { var symbolSpecifications = original.SymbolSpecifications.InsertRange(0, newPreferences.SymbolSpecifications); var namingStyles = original.NamingStyles.InsertRange(0, newPreferences.NamingStyles); var namingRules = original.NamingRules.InsertRange(0, newPreferences.NamingRules); return(new NamingStylePreferences(symbolSpecifications, namingStyles, namingRules)); }
public static void AppendNamingStylePreferencesToEditorConfig(NamingStylePreferences namingStylePreferences, string language, StringBuilder editorconfig) { AppendNamingStylePreferencesToEditorConfig( namingStylePreferences.SymbolSpecifications, namingStylePreferences.NamingStyles, namingStylePreferences.NamingRules, language, editorconfig); }
public static void AppendNamingStylePreferencesToEditorConfig(NamingStylePreferences namingStylePreferences, string language, StringBuilder editorconfig) { editorconfig.AppendLine($"#### {CompilerExtensionsResources.Naming_styles} ####"); var serializedNameMap = AssignNamesToNamingStyleElements(namingStylePreferences); var ruleNameMap = AssignNamesToNamingStyleRules(namingStylePreferences, serializedNameMap); var referencedElements = new HashSet <Guid>(); editorconfig.AppendLine(); editorconfig.AppendLine($"# {CompilerExtensionsResources.Naming_rules}"); foreach (var namingRule in namingStylePreferences.NamingRules) { referencedElements.Add(namingRule.SymbolSpecificationID); referencedElements.Add(namingRule.NamingStyleID); editorconfig.AppendLine(); editorconfig.AppendLine($"dotnet_naming_rule.{ruleNameMap[namingRule]}.severity = {namingRule.EnforcementLevel.ToNotificationOption(defaultSeverity: DiagnosticSeverity.Hidden).ToEditorConfigString()}"); editorconfig.AppendLine($"dotnet_naming_rule.{ruleNameMap[namingRule]}.symbols = {serializedNameMap[namingRule.SymbolSpecificationID]}"); editorconfig.AppendLine($"dotnet_naming_rule.{ruleNameMap[namingRule]}.style = {serializedNameMap[namingRule.NamingStyleID]}"); } editorconfig.AppendLine(); editorconfig.AppendLine($"# {CompilerExtensionsResources.Symbol_specifications}"); foreach (var symbolSpecification in namingStylePreferences.SymbolSpecifications) { if (!referencedElements.Contains(symbolSpecification.ID)) { continue; } editorconfig.AppendLine(); editorconfig.AppendLine($"dotnet_naming_symbols.{serializedNameMap[symbolSpecification.ID]}.applicable_kinds = {symbolSpecification.ApplicableSymbolKindList.ToEditorConfigString()}"); editorconfig.AppendLine($"dotnet_naming_symbols.{serializedNameMap[symbolSpecification.ID]}.applicable_accessibilities = {symbolSpecification.ApplicableAccessibilityList.ToEditorConfigString(language)}"); editorconfig.AppendLine($"dotnet_naming_symbols.{serializedNameMap[symbolSpecification.ID]}.required_modifiers = {symbolSpecification.RequiredModifierList.ToEditorConfigString(language)}"); } editorconfig.AppendLine(); editorconfig.AppendLine($"# {CompilerExtensionsResources.Naming_styles}"); foreach (var namingStyle in namingStylePreferences.NamingStyles) { if (!referencedElements.Contains(namingStyle.ID)) { continue; } editorconfig.AppendLine(); editorconfig.AppendLine($"dotnet_naming_style.{serializedNameMap[namingStyle.ID]}.required_prefix = {namingStyle.Prefix}"); editorconfig.AppendLine($"dotnet_naming_style.{serializedNameMap[namingStyle.ID]}.required_suffix = {namingStyle.Suffix}"); editorconfig.AppendLine($"dotnet_naming_style.{serializedNameMap[namingStyle.ID]}.word_separator = {namingStyle.WordSeparator}"); editorconfig.AppendLine($"dotnet_naming_style.{serializedNameMap[namingStyle.ID]}.capitalization = {namingStyle.CapitalizationScheme.ToEditorConfigString()}"); } }
private static NamingStylePreferences LocalsAreCamelCaseConstantsAreUpperCaseOption() { var localsSymbolSpecification = new SymbolSpecification( null, "Locals", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), ImmutableArray <Accessibility> .Empty, ImmutableArray <SymbolSpecification.ModifierKind> .Empty); var constLocalsSymbolSpecification = new SymbolSpecification( null, "Const Locals", ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Local)), ImmutableArray <Accessibility> .Empty, ImmutableArray.Create(new SymbolSpecification.ModifierKind(SymbolSpecification.ModifierKindEnum.IsConst))); var camelCaseNamingStyle = new NamingStyle( Guid.NewGuid(), capitalizationScheme: Capitalization.CamelCase, name: "Camel Case", prefix: "", suffix: "", wordSeparator: ""); var allUpperNamingStyle = new NamingStyle( Guid.NewGuid(), capitalizationScheme: Capitalization.AllUpper, name: "All Upper", prefix: "", suffix: "", wordSeparator: ""); var localsCamelCaseNamingRule = new SerializableNamingRule() { SymbolSpecificationID = localsSymbolSpecification.ID, NamingStyleID = camelCaseNamingStyle.ID, EnforcementLevel = DiagnosticSeverity.Error }; var constLocalsUpperCaseNamingRule = new SerializableNamingRule() { SymbolSpecificationID = constLocalsSymbolSpecification.ID, NamingStyleID = allUpperNamingStyle.ID, EnforcementLevel = DiagnosticSeverity.Error }; var info = new NamingStylePreferences( ImmutableArray.Create(localsSymbolSpecification, constLocalsSymbolSpecification), ImmutableArray.Create(camelCaseNamingStyle, allUpperNamingStyle), ImmutableArray.Create(constLocalsUpperCaseNamingRule, localsCamelCaseNamingRule)); return(info); }
public void TestFetchPersistNamingStyle(StorageLocationKind kind) { var defaultValue = NamingStylePreferences.Default; var value1 = new NamingStylePreferences( defaultValue.SymbolSpecifications, defaultValue.NamingStyles.WhereAsArray(x => x.Prefix == "I"), defaultValue.NamingRules ); var value2 = new NamingStylePreferences( defaultValue.SymbolSpecifications, defaultValue.NamingStyles.WhereAsArray(x => x.Prefix != "I"), defaultValue.NamingRules ); TestFetchPersist(kind, value1, value2, defaultValue); }
private OptionSet ReadOptionFrom(OptionSet options, string language, PerLanguageOption <NamingStylePreferences> option, ObjectReader reader, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var xmlText = reader.ReadString(); try { var value = NamingStylePreferences.FromXElement(XElement.Parse(xmlText)); return(options.WithChangedOption(option, language, value)); } catch (System.Exception) { return(options); } }
public static void TestEmptyDictionaryDefaultNamingStylePreferencesObjectReturnsFalse() { var editorConfigStorageLocation = new NamingStylePreferenceEditorConfigStorageLocation(); var existingNamingStylePreferences = new NamingStylePreferences( ImmutableArray.Create <SymbolSpecification>(), ImmutableArray.Create <NamingStyle>(), ImmutableArray.Create <SerializableNamingRule>()); var result = editorConfigStorageLocation.TryGetOption( existingNamingStylePreferences, new Dictionary <string, object>(), typeof(NamingStylePreferences), out var @object); Assert.False(result, "Expected TryParseReadonlyDictionary to return 'false' for empty dictionary"); }
internal override void SaveSettings() { var symbolSpecifications = ArrayBuilder <SymbolSpecification> .GetInstance(); var namingRules = ArrayBuilder <SerializableNamingRule> .GetInstance(); var namingStyles = ArrayBuilder <NamingStyle> .GetInstance(); foreach (var item in _viewModel.CodeStyleItems) { if (!item.IsComplete()) { continue; } var rule = new SerializableNamingRule() { EnforcementLevel = item.SelectedNotificationPreference.Notification.Value, NamingStyleID = item.SelectedStyle.ID, SymbolSpecificationID = item.SelectedSpecification.ID }; namingRules.Add(rule); } foreach (var item in _viewModel.Specifications) { symbolSpecifications.Add(item); } foreach (var item in _viewModel.NamingStyles) { namingStyles.Add(item.NamingStyle); } var info = new NamingStylePreferences( symbolSpecifications.ToImmutableAndFree(), namingStyles.ToImmutableAndFree(), namingRules.ToImmutableAndFree()); var oldOptions = OptionService.GetOptions(); var newOptions = oldOptions.WithChangedOption(SimplificationOptions.NamingPreferences, _languageName, info); OptionService.SetOptions(newOptions); OptionLogger.Log(oldOptions, newOptions); }
internal override void OnSave() { var symbolSpecifications = ArrayBuilder <SymbolSpecification> .GetInstance(); var namingRules = ArrayBuilder <SerializableNamingRule> .GetInstance(); var namingStyles = ArrayBuilder <NamingStyle> .GetInstance(); foreach (var item in _viewModel.CodeStyleItems) { if (!item.IsComplete()) { continue; } var rule = new SerializableNamingRule() { EnforcementLevel = item.SelectedNotificationPreference.Notification.Severity, NamingStyleID = item.SelectedStyle.ID, SymbolSpecificationID = item.SelectedSpecification.ID }; namingRules.Add(rule); } foreach (var item in _viewModel.Specifications) { symbolSpecifications.Add(item); } foreach (var item in _viewModel.NamingStyles) { namingStyles.Add(item.NamingStyle); } var info = new NamingStylePreferences( symbolSpecifications.ToImmutableAndFree(), namingStyles.ToImmutableAndFree(), namingRules.ToImmutableAndFree() ); OptionStore.SetOption(NamingStyleOptions.NamingPreferences, _languageName, info); }
private void ValidateNamingStyles(Section section) { NamingStylePreferences namingStyle = EditorConfigNamingStyleParser.GetNamingStyles(section.Properties); IOrderedEnumerable <NamingRule> orderedRules = namingStyle.Rules.NamingRules .OrderBy(rule => rule, NamingRuleModifierListComparer.Instance) .ThenBy(rule => rule, NamingRuleAccessibilityListComparer.Instance) .ThenBy(rule => rule, NamingRuleSymbolListComparer.Instance) .ThenBy(rule => rule.Name, StringComparer.OrdinalIgnoreCase) .ThenBy(rule => rule.Name, StringComparer.Ordinal); var orderedRulePreferences = new NamingStylePreferences( namingStyle.SymbolSpecifications, namingStyle.NamingStyles, orderedRules.Select( rule => new SerializableNamingRule { Name = rule.Name, SymbolSpecificationID = rule.SymbolSpecification.ID, NamingStyleID = rule.NamingStyle.ID, EnforcementLevel = rule.EnforcementLevel, }).ToImmutableArray()); var reorderedOverlappingRules = new List <(string firstRule, string secondRule)>(); ImmutableArray <NamingRule> declaredNamingRules = namingStyle.Rules.NamingRules; ImmutableArray <NamingRule> orderedNamingRules = orderedRulePreferences.Rules.NamingRules; for (int i = 0; i < declaredNamingRules.Length; i++) { for (int j = 0; j < i; j++) { NamingRule firstRule = declaredNamingRules[j]; NamingRule secondRule = declaredNamingRules[i]; // If the reordered rules are in the same relative order, no need to check the overlap bool reordered = false; foreach (NamingRule rule in orderedNamingRules) { if (rule.Name == firstRule.Name) { break; } else if (rule.Name == secondRule.Name) { reordered = true; break; } } if (!reordered) { continue; } // If the rules don't overlap, reordering is not a problem if (!Overlaps(firstRule, secondRule)) { continue; } reorderedOverlappingRules.Add((firstRule.Name, secondRule.Name)); } } var reportedRules = new HashSet <string>(); foreach (Property property in section.Properties) { string name = property.Keyword.Text.Trim(); if (!name.StartsWith("dotnet_naming_rule.")) { continue; } string[] nameSplit = name.Split('.'); if (nameSplit.Length != 3) { continue; } string ruleName = nameSplit[1]; if (!reportedRules.Add(ruleName)) { continue; } foreach ((string firstRule, string secondRule) in reorderedOverlappingRules) { if (secondRule != ruleName) { continue; } ErrorCatalog.NamingRuleReordered.Run(property.Keyword, e => { e.Register(secondRule, firstRule); }); } } }
public bool TryFetch(OptionKey optionKey, out object value) { if (_settingManager == null) { Debug.Fail("Manager field is unexpectedly null."); value = null; return(false); } // Do we roam this at all? var roamingSerializations = optionKey.Option.StorageLocations.OfType <RoamingProfileStorageLocation>(); if (!roamingSerializations.Any()) { value = null; return(false); } value = GetFirstOrDefaultValue(optionKey, roamingSerializations); // VS's ISettingsManager has some quirks around storing enums. Specifically, // it *can* persist and retrieve enums, but only if you properly call // GetValueOrDefault<EnumType>. This is because it actually stores enums just // as ints and depends on the type parameter passed in to convert the integral // value back to an enum value. Unfortunately, we call GetValueOrDefault<object> // and so we get the value back as boxed integer. // // Because of that, manually convert the integer to an enum here so we don't // crash later trying to cast a boxed integer to an enum value. if (optionKey.Option.Type.IsEnum) { if (value != null) { value = Enum.ToObject(optionKey.Option.Type, value); } } else if (typeof(ICodeStyleOption).IsAssignableFrom(optionKey.Option.Type)) { return(DeserializeCodeStyleOption(ref value, optionKey.Option.Type)); } else if (optionKey.Option.Type == typeof(NamingStylePreferences)) { // We store these as strings, so deserialize if (value is string serializedValue) { try { value = NamingStylePreferences.FromXElement(XElement.Parse(serializedValue)); } catch (Exception) { value = null; return(false); } } else { value = null; return(false); } } else if (optionKey.Option.Type == typeof(bool) && value is int intValue) { // TypeScript used to store some booleans as integers. We now handle them properly for legacy sync scenarios. value = intValue != 0; return(true); } else if (optionKey.Option.Type == typeof(bool) && value is long longValue) { // TypeScript used to store some booleans as integers. We now handle them properly for legacy sync scenarios. value = longValue != 0; return(true); } else if (optionKey.Option.Type == typeof(bool?)) { // code uses object to hold onto any value which will use boxing on value types. // see boxing on nullable types - https://msdn.microsoft.com/en-us/library/ms228597.aspx return((value is bool) || (value == null)); } else if (value != null && optionKey.Option.Type != value.GetType()) { // We got something back different than we expected, so fail to deserialize value = null; return(false); } return(true); }
public bool TryFetch(OptionKey optionKey, out object value) { if (_settingManager == null) { Debug.Fail("Manager field is unexpectedly null."); value = null; return(false); } // Do we roam this at all? var roamingSerialization = optionKey.Option.StorageLocations.OfType <RoamingProfileStorageLocation>().SingleOrDefault(); if (roamingSerialization == null) { value = null; return(false); } var storageKey = roamingSerialization.GetKeyNameForLanguage(optionKey.Language); RecordObservedValueToWatchForChanges(optionKey, storageKey); value = _settingManager.GetValueOrDefault(storageKey, optionKey.Option.DefaultValue); // VS's ISettingsManager has some quirks around storing enums. Specifically, // it *can* persist and retrieve enums, but only if you properly call // GetValueOrDefault<EnumType>. This is because it actually stores enums just // as ints and depends on the type parameter passed in to convert the integral // value back to an enum value. Unfortunately, we call GetValueOrDefault<object> // and so we get the value back as boxed integer. // // Because of that, manually convert the integer to an enum here so we don't // crash later trying to cast a boxed integer to an enum value. if (optionKey.Option.Type.IsEnum) { if (value != null) { value = Enum.ToObject(optionKey.Option.Type, value); } } else if (optionKey.Option.Type == typeof(CodeStyleOption <bool>)) { // We store these as strings, so deserialize if (value is string serializedValue) { try { value = CodeStyleOption <bool> .FromXElement(XElement.Parse(serializedValue)); } catch (Exception) { value = null; return(false); } } else { value = null; return(false); } } else if (optionKey.Option.Type == typeof(NamingStylePreferences)) { // We store these as strings, so deserialize if (value is string serializedValue) { try { value = NamingStylePreferences.FromXElement(XElement.Parse(serializedValue)); } catch (Exception) { value = null; return(false); } } else { value = null; return(false); } } else if (optionKey.Option.Type == typeof(bool) && value is int intValue) { // TypeScript used to store some booleans as integers. We now handle them properly for legacy sync scenarios. value = intValue != 0; return(true); } else if (optionKey.Option.Type == typeof(bool) && value is long longValue) { // TypeScript used to store some booleans as integers. We now handle them properly for legacy sync scenarios. value = longValue != 0; return(true); } else if (value != null && optionKey.Option.Type != value.GetType()) { // We got something back different than we expected, so fail to deserialize value = null; return(false); } return(true); }