public void TestSetBaseType_NoBaseOrInterface()
{
var code =
@"class C
{
}
class A
{
}";
var expected =
@"class C
: A
{
}
class A
{
}";
var solution = GetSolution(code);
var symbol = (INamedTypeSymbol)GetSymbols(solution, "C").First();
var editor = SymbolEditor.Create(solution);
// set base to A
var newSymbolC = editor.SetBaseTypeAsync(symbol, g => g.IdentifierName("A")).Result;
var actual = GetActual(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public async Task TestRemoveAllOfManyDeclarationsReturnsNull()
{
var code =
@"partial class C
{
}
partial class C
{
}";
var expected =
@"
";
var solution = GetSolution(code);
var symbol = (await GetSymbolsAsync(solution, "C")).First();
var editor = SymbolEditor.Create(solution);
var newSymbol = (INamedTypeSymbol)await editor.EditAllDeclarationsAsync(symbol, (e, d) => e.RemoveNode(d));
Assert.Null(newSymbol);
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
internal sealed override async Task <Document> GetUpdatedDocumentAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, Diagnostic diagnostic, CancellationToken cancellationToken)
{
ISymbol declaredSymbol = model.GetDeclaredSymbol(nodeToFix, cancellationToken);
Debug.Assert(declaredSymbol != null);
var editor = SymbolEditor.Create(document);
foreach (var customTag in diagnostic.Descriptor.CustomTags)
{
switch (customTag)
{
case CA1008DiagnosticAnalyzer.RuleRenameCustomTag:
return(await GetUpdatedDocumentForRuleNameRenameAsync(document, (IFieldSymbol)declaredSymbol, cancellationToken).ConfigureAwait(false));
case CA1008DiagnosticAnalyzer.RuleMultipleZeroCustomTag:
await ApplyRuleNameMultipleZeroAsync(editor, (INamedTypeSymbol)declaredSymbol, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
case CA1008DiagnosticAnalyzer.RuleNoZeroCustomTag:
await ApplyRuleNameNoZeroValueAsync(editor, (INamedTypeSymbol)declaredSymbol, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
}
}
return(document);
}
private async Task <Document> ChangeToPublicInterfaceImplementation(Document document, ISymbol symbolToChange, CancellationToken cancellationToken)
{
SymbolEditor editor = SymbolEditor.Create(document);
IEnumerable <ISymbol> explicitImplementations = GetExplicitImplementations(symbolToChange);
if (explicitImplementations == null)
{
return(document);
}
await editor.EditAllDeclarationsAsync(symbolToChange, (docEditor, declaration) =>
{
SyntaxNode newDeclaration = declaration;
foreach (ISymbol implementedMember in explicitImplementations)
{
SyntaxNode interfaceTypeNode = docEditor.Generator.TypeExpression(implementedMember.ContainingType);
newDeclaration = docEditor.Generator.AsPublicInterfaceImplementation(newDeclaration, interfaceTypeNode);
}
docEditor.ReplaceNode(declaration, newDeclaration);
}, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
}
public async Task TestSetBaseType_UnknownBase()
{
var code =
@"class C : X
{
}
class A
{
}";
var expected =
@"class C : A
{
}
class A
{
}";
var solution = GetSolution(code);
var symbol = (INamedTypeSymbol)(await GetSymbolsAsync(solution, "C")).First();
var editor = SymbolEditor.Create(solution);
// set base to A
var newSymbolC = editor.SetBaseTypeAsync(symbol, g => g.IdentifierName("A"));
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
protected async override Task <Solution> GetChangedSolutionAsync(CancellationToken cancellationToken)
{
var editor = SymbolEditor.Create(this.Solution);
await editor.EditAllDeclarationsAsync(this.Symbol, (e, d) => e.SetAccessibility(d, _newAccessibility), cancellationToken).ConfigureAwait(false);
return(editor.ChangedSolution);
}
public async Task TestEditAllDeclarations_SameFile()
{
var code =
@"public partial class C
{
}
public partial class C
{
}";
var expected =
@"internal partial class C
{
}
internal partial class C
{
}";
var solution = GetSolution(code);
var symbol = (await GetSymbolsAsync(solution, "C")).First();
var editor = SymbolEditor.Create(solution);
var newSymbol = (INamedTypeSymbol)await editor.EditAllDeclarationsAsync(symbol, (e, d) => e.SetAccessibility(d, Accessibility.Internal));
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public async Task TestSetBaseType_Null_ExistingBase()
{
var code =
@"class C : A
{
}
class A
{
}";
var expected =
@"class C
{
}
class A
{
}";
var solution = GetSolution(code);
var symbol = (INamedTypeSymbol)(await GetSymbolsAsync(solution, "C")).First();
var editor = SymbolEditor.Create(solution);
// set base to null
var newSymbolC = await editor.SetBaseTypeAsync(symbol, g => null);
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public void TestRemovedOneOfManyDeclarationsReturnsChangedSymbol()
{
var code =
@"partial class C
{
}
partial class C
{
}";
var expected =
@"
partial class C
{
}";
var solution = GetSolution(code);
var symbol = GetSymbols(solution, "C").First();
var editor = SymbolEditor.Create(solution);
var newSymbol = (INamedTypeSymbol)editor.EditOneDeclarationAsync(symbol, (e, d) => e.RemoveNode(d)).Result;
Assert.NotNull(newSymbol);
Assert.Equal("C", newSymbol.Name);
var actual = GetActual(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public async Task TestEditOneDeclaration()
{
var code =
@"class C
{
}";
var expected =
@"class C
{
void m()
{
}
}";
var solution = GetSolution(code);
var symbol = (await GetSymbolsAsync(solution, "C")).First();
var editor = SymbolEditor.Create(solution);
var newSymbol = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(symbol, (e, d) => e.AddMember(d, e.Generator.MethodDeclaration("m")));
Assert.Equal(1, newSymbol.GetMembers("m").Length);
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public async Task TestChangeLogicalIdentityReturnsCorrectSymbol_OneDeclaration()
{
// proves that APIs return the correct new symbol even after a change that changes the symbol's logical identity.
var code =
@"class C
{
}";
var expected =
@"class X
{
}";
var solution = GetSolution(code);
var symbol = (await GetSymbolsAsync(solution, "C")).First();
var editor = SymbolEditor.Create(solution);
var newSymbol = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(symbol, (e, d) => e.SetName(d, "X"));
Assert.Equal("X", newSymbol.Name);
// original symbols cannot be rebound after identity change.
var reboundSymbol = await editor.GetCurrentSymbolAsync(symbol);
Assert.Null(reboundSymbol);
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public void TestSetBaseType_Null_ExistingInterface()
{
var code =
@"class C : I
{
}
interface I
{
}";
var expected =
@"class C : I
{
}
interface I
{
}";
var solution = GetSolution(code);
var symbol = (INamedTypeSymbol)GetSymbols(solution, "C").First();
var editor = SymbolEditor.Create(solution);
// set base to null
var newSymbolC = editor.SetBaseTypeAsync(symbol, g => null).Result;
var actual = GetActual(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
public override async Task <CodeAction?> GetFixAsync(FixAllContext fixAllContext)
{
ImmutableArray <Diagnostic> diagnostics = await GetAllDiagnosticsInScope(fixAllContext).ConfigureAwait(false);
Dictionary <(INamedTypeSymbol marshallerType, ITypeSymbol managedType, bool isLinearCollectionMarshaller), HashSet <string> > uniqueMarshallersToFix = new();
// Organize all the diagnostics by marshaller, managed type, and whether or not it's a collection marshaller
foreach (Diagnostic diagnostic in diagnostics)
{
Document doc = fixAllContext.Solution.GetDocument(diagnostic.Location.SourceTree);
SemanticModel model = await doc.GetSemanticModelAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
var entryPointTypeSymbol = (INamedTypeSymbol)model.GetEnclosingSymbol(diagnostic.Location.SourceSpan.Start, fixAllContext.CancellationToken);
ITypeSymbol?managedType = GetManagedTypeInAttributeSyntax(diagnostic.Location, entryPointTypeSymbol);
SyntaxNode root = await diagnostic.Location.SourceTree.GetRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
SyntaxNode node = root.FindNode(diagnostic.Location.SourceSpan);
var marshallerType = (INamedTypeSymbol)model.GetSymbolInfo(node, fixAllContext.CancellationToken).Symbol;
var uniqueMarshallerFixKey = (marshallerType, managedType, ManualTypeMarshallingHelper.IsLinearCollectionEntryPoint(entryPointTypeSymbol));
if (!uniqueMarshallersToFix.TryGetValue(uniqueMarshallerFixKey, out HashSet <string> membersToAdd))
{
uniqueMarshallersToFix[uniqueMarshallerFixKey] = membersToAdd = new HashSet <string>();
}
membersToAdd.UnionWith(diagnostic.Properties[MissingMemberNames.Key].Split(MissingMemberNames.Delimiter));
}
Dictionary <INamedTypeSymbol, INamedTypeSymbol> partiallyUpdatedSymbols = new(SymbolEqualityComparer.Default);
SymbolEditor symbolEditor = SymbolEditor.Create(fixAllContext.Solution);
// Apply each fix
foreach (var marshallerInfo in uniqueMarshallersToFix)
{
var(marshallerType, managedType, isLinearCollectionMarshaller) = marshallerInfo.Key;
HashSet <string> missingMembers = marshallerInfo.Value;
if (!partiallyUpdatedSymbols.TryGetValue(marshallerType, out INamedTypeSymbol newMarshallerType))
{
newMarshallerType = marshallerType;
}
newMarshallerType = (INamedTypeSymbol)await symbolEditor.EditOneDeclarationAsync(
marshallerType,
(editor, decl) => AddMissingMembers(
editor,
decl,
marshallerType,
managedType,
missingMembers,
isLinearCollectionMarshaller),
fixAllContext.CancellationToken).ConfigureAwait(false);
partiallyUpdatedSymbols[marshallerType] = newMarshallerType;
}
return(CodeAction.Create(SR.AddMissingCustomTypeMarshallerMembers, ct => Task.FromResult(symbolEditor.ChangedSolution)));
}
public async Task TestSequentialEdits_SeparateSymbolsAndFiles()
{
var code1 =
@"class A
{
}";
var code2 =
@"class B
{
}";
var expected1 =
@"class A
{
void ma()
{
}
}";
var expected2 =
@"class B
{
void mb()
{
}
}";
var solution = GetSolution(code1, code2);
var comp = await solution.Projects.First().GetCompilationAsync();
var symbolA = comp.GlobalNamespace.GetMembers("A").First();
var symbolB = comp.GlobalNamespace.GetMembers("B").First();
var editor = SymbolEditor.Create(solution);
var newSymbolA = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(
symbolA,
(e, d) => e.AddMember(d, e.Generator.MethodDeclaration("ma"))
);
Assert.Equal(1, newSymbolA.GetMembers("ma").Length);
var newSymbolB = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(
symbolB,
(e, d) => e.AddMember(d, e.Generator.MethodDeclaration("mb"))
);
Assert.Equal(1, newSymbolB.GetMembers("mb").Length);
var docs = editor.GetChangedDocuments().ToList();
var actual1 = await GetActualAsync(docs[0]);
var actual2 = await GetActualAsync(docs[1]);
Assert.Equal(expected1, actual1);
Assert.Equal(expected2, actual2);
}
public static async Task <Solution> ChangeMemberAccessibility(Solution solution, ISymbol memberSymbol, Accessibility accessibility, CancellationToken cancellationToken)
{
var editor = SymbolEditor.Create(solution);
await editor.EditAllDeclarationsAsync(memberSymbol, (docEditor, syntaxNode) =>
{
docEditor.SetAccessibility(syntaxNode, accessibility);
}, cancellationToken).ConfigureAwait(false);
return(editor.ChangedSolution);
}
public async Task TestEditDeclarationWithLocation_SequentialEdits_NewLocation()
{
var code =
@"partial class C
{
}
partial class C
{
}";
var expected =
@"partial class C
{
}
partial class C
{
void m()
{
}
void m2()
{
}
}";
var solution = GetSolution(code);
var symbol = (await GetSymbolsAsync(solution, "C")).First();
var location = symbol.Locations.Last();
var editor = SymbolEditor.Create(solution);
var newSymbol = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(
symbol,
location,
(e, d) => e.AddMember(d, e.Generator.MethodDeclaration("m"))
);
Assert.Equal(1, newSymbol.GetMembers("m").Length);
// use location from new symbol
var newLocation = newSymbol.Locations.Last();
var newSymbol2 = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(
newSymbol,
newLocation,
(e, d) => e.AddMember(d, e.Generator.MethodDeclaration("m2"))
);
Assert.Equal(1, newSymbol2.GetMembers("m").Length);
Assert.Equal(1, newSymbol2.GetMembers("m2").Length);
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
}
private static async Task <Document> AddSerializableAttributeToType(Document document, ITypeSymbol type, CancellationToken cancellationToken)
{
SymbolEditor editor = SymbolEditor.Create(document);
await editor.EditOneDeclarationAsync(type, (docEditor, declaration) =>
{
SyntaxNode serializableAttr = docEditor.Generator.Attribute(docEditor.Generator.TypeExpression(WellKnownTypes.SerializableAttribute(docEditor.SemanticModel.Compilation)));
docEditor.AddAttribute(declaration, serializableAttr);
}, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
}
private async Task <Document> MakeProtected(Document document, ISymbol symbolToChange, CancellationToken cancellationToken)
{
SymbolEditor editor = SymbolEditor.Create(document);
await editor.EditAllDeclarationsAsync(symbolToChange, (docEditor, declaration) =>
{
docEditor.SetAccessibility(declaration, Accessibility.Protected);
}, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
}
private void DefaultSymbolButton_Click(object sender, RoutedEventArgs e)
{
var editor = new SymbolEditor();
editor.Symbol = Renderer.DefaultSymbol?.Clone() ?? new SimpleMarkerSymbol();
var result = MetroDialog.ShowDialog("Symbol Editor", editor, this);
if (result == true)
{
Renderer.DefaultSymbol = editor.Symbol;
}
}
private static async Task <Document> AddAccessor(Document document, SyntaxNode parameter, CancellationToken cancellationToken)
{
SymbolEditor symbolEditor = SymbolEditor.Create(document);
SemanticModel model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.GetDeclaredSymbol(parameter, cancellationToken) is not IParameterSymbol parameterSymbol)
{
return(document);
}
// Make the first character uppercase since we are generating a property.
string propName = char.ToUpper(parameterSymbol.Name[0], CultureInfo.InvariantCulture).ToString() + parameterSymbol.Name[1..];
private async Task <Document> MakeContainingTypeSealed(Document document, IMethodSymbol methodSymbol, CancellationToken cancellationToken)
{
SymbolEditor editor = SymbolEditor.Create(document);
await editor.EditAllDeclarationsAsync(methodSymbol.ContainingType, (docEditor, declaration) =>
{
DeclarationModifiers modifiers = docEditor.Generator.GetModifiers(declaration);
docEditor.SetModifiers(declaration, modifiers + DeclarationModifiers.Sealed);
}, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
}
public async Task TestRemoveFieldFromMultiFieldDeclaration()
{
var code =
@"class C
{
public int X, Y;
}";
var expected =
@"class C
{
public int Y;
}";
var expected2 =
@"class C
{
}";
var solution = GetSolution(code);
var symbol = (INamedTypeSymbol)(await GetSymbolsAsync(solution, "C")).First();
var symbolX = symbol.GetMembers("X").First();
var symbolY = symbol.GetMembers("Y").First();
var editor = SymbolEditor.Create(solution);
// remove X -- should remove only part of the field declaration.
var newSymbolX = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(
symbolX,
(e, d) => e.RemoveNode(d)
);
Assert.Null(newSymbolX);
var actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected, actual);
// now remove Y -- should remove entire remaining field declaration
var newSymbolY = (INamedTypeSymbol)await editor.EditOneDeclarationAsync(
symbolY,
(e, d) => e.RemoveNode(d)
);
Assert.Null(newSymbolY);
actual = await GetActualAsync(editor.GetChangedDocuments().First());
Assert.Equal(expected2, actual);
}
private static async Task <Document> SetAccessibilityAsync(Document document, IMethodSymbol methodSymbol, CancellationToken cancellationToken)
{
SymbolEditor editor = SymbolEditor.Create(document);
// This would be constructor and can have only one definition.
Debug.Assert(methodSymbol.IsConstructor() && methodSymbol.DeclaringSyntaxReferences.HasExactly(1));
await editor.EditOneDeclarationAsync(methodSymbol, (docEditor, declaration) =>
{
Accessibility newAccessibility = methodSymbol.ContainingType.IsSealed ? Accessibility.Private : Accessibility.Protected;
docEditor.SetAccessibility(declaration, newAccessibility);
}, cancellationToken).ConfigureAwait(false);
return(editor.GetChangedDocuments().First());
}
public static async Task <Solution> ChangeMemberStaticModifier(Solution solution, ISymbol memberSymbol, bool isStatic, CancellationToken cancellationToken)
{
var editor = SymbolEditor.Create(solution);
await editor.EditAllDeclarationsAsync(memberSymbol, (docEditor, syntaxNode) =>
{
var newMods = DeclarationModifiers.From(memberSymbol).WithIsStatic(isStatic);
if (memberSymbol is IPropertySymbol propertySymbol && propertySymbol.IsReadOnly)
{
// Looks like there's a bug in Roslyn where SetModifiers applies the 'readonly'
// keyword to a get-only property, producing illegal syntax.
newMods = newMods.WithIsReadOnly(false);
}
docEditor.SetModifiers(syntaxNode, newMods);
}, cancellationToken).ConfigureAwait(false);
private async Task ApplyRuleNameNoZeroValueAsync(SymbolEditor editor, INamedTypeSymbol enumType, CancellationToken cancellationToken)
{
// remove any non-zero member named 'None'
foreach (IFieldSymbol field in enumType.GetMembers().Where(m => m.Kind == SymbolKind.Field))
{
if (CA1008DiagnosticAnalyzer.IsMemberNamedNone(field))
{
await editor.EditOneDeclarationAsync(field, (e, d) => e.RemoveNode(d), cancellationToken).ConfigureAwait(false);
}
}
// insert zero-valued member 'None' to top
await editor.EditOneDeclarationAsync(enumType, (e, d) => e.InsertMembers(d, 0, new[] { e.Generator.EnumMember("None") }), cancellationToken).ConfigureAwait(false);
}
private async Task <Document> SetAccessibility(Document document, SyntaxNode node, ISymbol symbol, CancellationToken cancellationToken)
{
var editor = SymbolEditor.Create(document);
var methodSymbol = symbol as IMethodSymbol;
// This would be constructor and can have only one definition.
Debug.Assert(methodSymbol.IsConstructor() && methodSymbol.DeclaringSyntaxReferences.Count() == 1);
await editor.EditOneDeclarationAsync(methodSymbol, (docEditor, declaration) =>
{
var newAccessibility = methodSymbol.ContainingType.IsSealed ? Accessibility.Private : Accessibility.Protected;
docEditor.SetAccessibility(declaration, newAccessibility);
}, cancellationToken);
return(editor.GetChangedDocuments().First());
}
protected async override Task <Solution> GetChangedSolutionAsync(CancellationToken cancellationToken)
{
var editor = SymbolEditor.Create(this.Solution);
await editor.EditAllDeclarationsAsync(this.Symbol, (e, d) =>
{
e.SetModifiers(d, _newModifiers);
if (this.Symbol.IsAbstract && !_newModifiers.IsAbstract && this.Symbol.Kind == SymbolKind.Method)
{
e.ReplaceNode(d, (_d, g) => g.WithStatements(_d, new SyntaxNode[] { }));
}
}
, cancellationToken).ConfigureAwait(false);
return(editor.ChangedSolution);
}
private void OnTreeViewItemMouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
var item = (sender as FrameworkElement).DataContext as Esri.ArcGISRuntime.Toolkit.Preview.UI.TocItem;
if (item?.Content is LegendInfo legendInfo)
{
Symbol symbolReference = null;
Action <Symbol> symbolSetter = null;
// Find the symbol in the layer that matches the one in the legend
var layer = item.Layer;
if (layer is FeatureLayer fl)
{
var renderer = fl.Renderer;
if (renderer is SimpleRenderer sr)
{
symbolReference = sr.Symbol;
symbolSetter = (s) => sr.Symbol = s;
}
else if (renderer is UniqueValueRenderer uvr)
{
// TODO: Also handle uvr.DefaultSymbol
var uv = uvr.UniqueValues.Where(u => u.Label == legendInfo.Name);
if (uv.Count() > 1) // In case multiple symbols matches
{
uv = uv.Where(u => u.Symbol.ToJson() == legendInfo.Symbol.ToJson());
}
if (uv.Count() == 1)
{
var u = uv.First();
symbolReference = u.Symbol;
symbolSetter = (s) => u.Symbol = s;
}
}
else
{
// TODO
}
}
if (symbolReference != null && symbolSetter != null)
{
var editor = new SymbolEditor();
editor.Symbol = symbolReference?.Clone();
ShowSidePanelDialog(editor, () => { symbolSetter(editor.Symbol); item.Parent.RefreshLegend(); });
}
}
}
private async Task <Document> AddAccessor(Document document, SyntaxNode parameter, CancellationToken cancellationToken)
{
SymbolEditor symbolEditor = SymbolEditor.Create(document);
SemanticModel model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var parameterSymbol = model.GetDeclaredSymbol(parameter, cancellationToken) as IParameterSymbol;
if (parameterSymbol == null)
{
return(document);
}
// Make the first character uppercase since we are generating a property.
string propName = char.ToUpper(parameterSymbol.Name[0]).ToString() + parameterSymbol.Name.Substring(1);
INamedTypeSymbol typeSymbol = parameterSymbol.ContainingType;
ISymbol propertySymbol = typeSymbol.GetMembers(propName).Where(m => m.Kind == SymbolKind.Property).FirstOrDefault();
// Add a new property
if (propertySymbol == null)
{
await symbolEditor.EditOneDeclarationAsync(typeSymbol,
parameter.GetLocation(), // edit the partial declaration that has this parameter symbol.
(editor, typeDeclaration) =>
{
SyntaxNode newProperty = editor.Generator.PropertyDeclaration(propName,
editor.Generator.TypeExpression(parameterSymbol.Type),
Accessibility.Public,
DeclarationModifiers.ReadOnly);
newProperty = editor.Generator.WithGetAccessorStatements(newProperty, null);
editor.AddMember(typeDeclaration, newProperty);
},
cancellationToken).ConfigureAwait(false);
}
else
{
await symbolEditor.EditOneDeclarationAsync(propertySymbol,
(editor, propertyDeclaration) =>
{
editor.SetGetAccessorStatements(propertyDeclaration, null);
editor.SetModifiers(propertyDeclaration, editor.Generator.GetModifiers(propertyDeclaration) - DeclarationModifiers.WriteOnly);
},
cancellationToken).ConfigureAwait(false);
}
return(symbolEditor.GetChangedDocuments().First());
}
//シンボルのメニューを作成
private void CreateSymbolMenu()
{
//シンボル分メニュー作成
List <DefineSymbol> symbolList = SymbolEditor.SymbolList;
for (int i = 0; i < symbolList.Count; i++)
{
CreateSymbolMenuParts(symbolList [i], i);
GUILayout.Space(5);
}
//新規に追加できるよう、空白のメニューを追加
DefineSymbol newSymbol = new DefineSymbol("", false);
CreateSymbolMenuParts(newSymbol, symbolList.Count);
GUILayout.Space(10);
//保存されている状態に戻すボタン
if (GUILayout.Button("Reset"))
{
SymbolEditor.Init();
}
GUILayout.Space(10);
//全部無効にするボタン
if (GUILayout.Button("All Invalid"))
{
SymbolEditor.SetAllEnabled(false);
}
//全部有効にするボタン
if (GUILayout.Button("All Valid"))
{
SymbolEditor.SetAllEnabled(true);
}
GUILayout.Space(10);
//全部削除するボタン
if (GUILayout.Button("All Delete"))
{
SymbolEditor.AllDelete();
}
}
