private void lstOverrides_SelectedIndexChanged(object sender, EventArgs e)
{
if (lstOverrides.SelectedItem == null)
{
return;
}
OverrideInfo oi = (OverrideInfo)lstOverrides.SelectedItem;
Debug.Assert(oi != null);
if (!ActiveTheme.LineFormats.TryGetValue(oi.Index, out LineFormat format))
{
ActiveTheme.LineFormats[oi.Index] = format = ActiveTheme.DefaultLineFormat.Clone(ActiveTheme);
format.FormatIndex = oi.Index;
}
gridLineStyle.SelectedObject = format;
linePreview.ForeColor = format.LineColor;
linePreview.GlowColor = format.LineColor;
linePreview.Style = format.LineStyle;
linePreviewHighlight.ForeColor = format.HighlightStyle.HasFlag(LineStyle.Glow)
? format.LineColor
: format.HighlightColor;
linePreviewHighlight.GlowColor = format.HighlightColor;
linePreviewHighlight.Style = format.HighlightStyle;
}
private void lstOverrides_Format(object sender, ListControlConvertEventArgs e)
{
OverrideInfo oi = e.ListItem as OverrideInfo;
Debug.Assert(oi != null);
e.Value = oi.Text;
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeAccessibility))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(
root,
context.Span,
out SyntaxNode node,
predicate: f => OverrideInfo.CanCreate(f)))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotChangeAccessModifiersWhenOverridingInheritedMember:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
OverrideInfo overrideInfo = OverrideInfo.Create(node, semanticModel, context.CancellationToken);
if (!overrideInfo.Success)
{
break;
}
Accessibility newAccessibility = overrideInfo.OverriddenSymbol.DeclaredAccessibility;
CodeAction codeAction = CodeAction.Create(
$"Change accessibility to '{newAccessibility.GetName()}'",
cancellationToken =>
{
if (node.Kind() == SyntaxKind.VariableDeclarator)
{
node = node.Parent.Parent;
}
SyntaxNode newNode = node.WithAccessibility(newAccessibility, ModifierComparer.Instance);
return(context.Document.ReplaceNodeAsync(node, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.OverridingMemberCannotChangeAccessModifiers) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeMemberNonStatic) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
MemberDeclarationSyntax memberDeclaration = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <MemberDeclarationSyntax>();
Debug.Assert(memberDeclaration != null, $"{nameof(memberDeclaration)} is null");
if (memberDeclaration == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotChangeAccessModifiersWhenOverridingInheritedMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.OverridingMemberCannotChangeAccessModifiers))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
OverrideInfo overrideInfo = OverridingMemberCannotChangeAccessModifiersRefactoring.GetOverrideInfo(memberDeclaration, semanticModel, context.CancellationToken);
Accessibility newAccessibility = overrideInfo.OverriddenSymbol.DeclaredAccessibility;
string title = $"Change accessibility to '{AccessibilityHelper.GetAccessibilityName(newAccessibility)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => OverridingMemberCannotChangeAccessModifiersRefactoring.RefactorAsync(context.Document, memberDeclaration, newAccessibility, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MissingXmlCommentForPubliclyVisibleTypeOrMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add documentation comment",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, false, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
CodeAction codeAction2 = CodeAction.Create(
"Add documentation comment (copy from base if available)",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, true, cancellationToken),
GetEquivalenceKey(diagnostic, "CopyFromBaseIfAvailable"));
context.RegisterCodeFix(codeAction2, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MethodReturnTypeMustMatchOverriddenMethodReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = methodSymbol.OverriddenMethod.ReturnType;
if (typeSymbol?.IsErrorType() == false)
{
TypeSyntax newType = typeSymbol.ToMinimalTypeSyntax(semanticModel, memberDeclaration.SpanStart);
CodeAction codeAction = CodeAction.Create(
$"Change return type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, memberDeclaration.SpanStart)}'",
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.PartialMethodsMustHaveVoidReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;
MethodDeclarationSyntax otherPart = semanticModel.GetOtherPart(methodDeclaration, context.CancellationToken);
if (otherPart == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Change return type to 'void'",
cancellationToken =>
{
return(context.Document.Solution().ReplaceNodesAsync(
new MethodDeclarationSyntax[] { methodDeclaration, otherPart },
(node, rewrittenNode) => node.WithReturnType(CSharpFactory.VoidType().WithTriviaFrom(node.ReturnType)),
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MemberTypeMustMatchOverriddenMemberType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
{
var propertySymbol = (IPropertySymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = propertySymbol.OverriddenProperty.Type;
break;
}
case SyntaxKind.EventDeclaration:
{
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
case SyntaxKind.EventFieldDeclaration:
{
VariableDeclaratorSyntax declarator = ((EventFieldDeclarationSyntax)memberDeclaration).Declaration.Variables.First();
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
}
if (typeSymbol?.IsErrorType() == false)
{
string title = $"Change type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, memberDeclaration.SpanStart)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.MissingPartialModifier:
case CompilerDiagnosticIdentifiers.PartialMethodMustBeDeclaredWithinPartialClassOrPartialStruct:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add 'partial' modifier",
cancellationToken =>
{
if (memberDeclaration.IsKind(SyntaxKind.MethodDeclaration) &&
memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
return(context.Document.InsertModifierAsync(memberDeclaration.Parent, SyntaxKind.PartialKeyword, ModifierComparer.Instance, cancellationToken));
}
else if (memberDeclaration.IsKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration))
{
return(context.Document.InsertModifierAsync(memberDeclaration, SyntaxKind.PartialKeyword, ModifierComparer.Instance, cancellationToken));
}
return(Task.FromResult(context.Document));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MemberIsAbstractButItIsContainedInNonAbstractClass:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract))
{
break;
}
if (!memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Make containing class abstract",
cancellationToken => context.Document.InsertModifierAsync(memberDeclaration.Parent, SyntaxKind.AbstractKeyword, ModifierComparer.Instance, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ObjectReferenceIsRequiredForNonStaticMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeMemberNonStatic))
{
break;
}
SyntaxTokenList modifiers = memberDeclaration.GetModifiers();
Debug.Assert(modifiers.Contains(SyntaxKind.StaticKeyword), memberDeclaration.ToString());
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
break;
}
CodeAction codeAction = CodeAction.Create(
$"Make containing {memberDeclaration.GetTitle()} non-static",
cancellationToken => context.Document.RemoveModifierAsync(memberDeclaration, SyntaxKind.StaticKeyword, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.StaticConstructorMustBeParameterless:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor))
{
break;
}
var constructorDeclaration = (ConstructorDeclarationSyntax)memberDeclaration;
CodeAction codeAction = CodeAction.Create(
"Remove parameters",
cancellationToken =>
{
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
ParameterListSyntax newParameterList = parameterList
.WithParameters(default(SeparatedSyntaxList <ParameterSyntax>))
.WithOpenParenToken(parameterList.OpenParenToken.WithoutTrailingTrivia())
.WithCloseParenToken(parameterList.CloseParenToken.WithoutLeadingTrivia());
ConstructorDeclarationSyntax newNode = constructorDeclaration.WithParameterList(newParameterList);
return(context.Document.ReplaceNodeAsync(constructorDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public static extern IntPtr BizCreate(byte[] bios, byte[] data, int length, [In] OverrideInfo dbinfo, bool skipBios);
/// <summary>
/// Matches all methods that can be overriden (non-static, public or protected, abstract or virtual)
/// within this type sub-tree (this type, its base and interfaces)
/// with its override.
/// Methods without an override are either abstract or a ghost stup has to be synthesized.
/// </summary>
/// <param name="diagnostics"></param>
internal OverrideInfo[] ResolveOverrides(DiagnosticBag diagnostics)
{
if (_overrides != null)
{
// already resolved
return(_overrides);
}
// TODO: ignore System.Object ?
// inherit abstracts from base type
var overrides = new List <OverrideInfo>();
if (BaseType != null)
{
overrides.AddRange(BaseType.ResolveOverrides(diagnostics));
}
// collect this type declared methods including synthesized methods
var methods = this.GetMembers().OfType <MethodSymbol>();
var methodslookup = methods.Where(OverrideHelper.CanOverride).ToLookup(m => m.RoutineName);
// resolve overrides of inherited members
for (int i = 0; i < overrides.Count; i++)
{
var m = overrides[i];
if (m.HasOverride == false)
{
// update override info of the inherited member
overrides[i] = new OverrideInfo(m.Method, OverrideHelper.ResolveMethodImplementation(m.Method, methodslookup[m.RoutineName]));
}
else
{
// clear the interface flag of inherited override info
m.ImplementsInterface = false;
overrides[i] = m;
}
}
// resolve overrides of interface methods
foreach (var iface in this.Interfaces)
{
var iface_abstracts = iface.ResolveOverrides(diagnostics);
foreach (var m in iface_abstracts)
{
// add interface member,
// resolve its override
overrides.Add(new OverrideInfo(m.Method, OverrideHelper.ResolveMethodImplementation(m.Method, this))
{
ImplementsInterface = true
});
}
}
// add overrideable routines from this type
foreach (var m in methods)
{
if (m.IsOverrideable())
{
overrides.Add(new OverrideInfo(m));
}
}
// report unresolved abstracts
if (!this.IsInterface && !this.IsAbstract)
{
foreach (var m in overrides)
{
if (m.IsUnresolvedAbstract)
{
// TODO: diagnostics.Add()
}
}
}
// cache & return
return(_overrides = overrides.ToArray());
}
public static RichPresence CreateDiscordPresence(Title title, Timestamps time, string largeImageKey = "", string largeImageText = "", string smallImageKey = "", string state = "", bool useProvidedTime = true)
{
RichPresence presence = new RichPresence()
{
State = state
};
Assets assets = new Assets
{
SmallImageKey = smallImageKey
};
assets.LargeImageText = title.Name;
if (title.ProgramId != 0xffaadd23)
{
// assets.SmallImageText = "Nintendo Switch";
assets.SmallImageText = assets.SmallImageText;
if (!SwitchOverrides.ContainsKey($"0{title.ProgramId:x}"))
{
assets.LargeImageKey = $"0{title.ProgramId:x}";
presence.Details = $"Playing {title.Name}";
}
else
{
OverrideInfo pkgInfo = SwitchOverrides[$"0{title.ProgramId:x}"];
assets.LargeImageKey = pkgInfo.CustomKey ?? $"0{title.ProgramId:x}";
presence.Details = pkgInfo.CustomPrefix ?? "Playing";
presence.Details += $" {title.Name}";
}
}
else
{
assets.SmallImageText = "QuestPresence";
if (!QuestOverrides.ContainsKey(title.Name))
{
assets.LargeImageKey = title.Name.ToLower().Replace(" ", "");
presence.Details = $"Playing {title.Name}";
}
else
{
OverrideInfo pkgInfo = QuestOverrides[title.Name];
assets.LargeImageKey = pkgInfo.CustomKey ?? title.Name.ToLower().Replace(" ", "");
presence.Details = pkgInfo.CustomPrefix ?? "Playing";
presence.Details += $" {title.Name}";
}
}
if (!string.IsNullOrEmpty(largeImageKey))
{
assets.LargeImageKey = largeImageKey;
}
if (!string.IsNullOrEmpty(largeImageText))
{
assets.LargeImageText = largeImageText;
}
presence.Assets = assets;
if (useProvidedTime)
{
presence.Timestamps = time;
}
return(presence);
}
/// <summary>
/// Matches all methods that can be overriden (non-static, public or protected, abstract or virtual)
/// within this type sub-tree (this type, its base and interfaces)
/// with its override.
/// Methods without an override are either abstract or a ghost stup has to be synthesized.
/// </summary>
/// <param name="diagnostics"></param>
internal OverrideInfo[] ResolveOverrides(DiagnosticBag diagnostics)
{
if (_lazyOverrides != null)
{
// already resolved
return(_lazyOverrides);
}
// inherit abstracts from base type
// ignoring System.Object (we don't override its methods from PHP)
var overrides = new List <OverrideInfo>();
if (BaseType != null && BaseType.SpecialType != SpecialType.System_Object)
{
overrides.AddRange(BaseType.ResolveOverrides(diagnostics));
}
// collect this type declared methods including synthesized methods
var members = this.GetMembers();
// resolve overrides of inherited members
for (int i = 0; i < overrides.Count; i++)
{
var m = overrides[i];
if (m.HasOverride == false)
{
// update override info of the inherited member
overrides[i] = new OverrideInfo(m.Method, OverrideHelper.ResolveMethodImplementation(m.Method, members));
}
else
{
// clear the interface flag of inherited override info
m.ImplementsInterface = false;
overrides[i] = m;
}
}
// resolve overrides of interface methods
foreach (var iface in Interfaces)
{
// skip interfaces implemented by base type or other interfaces,
// we don't want to add redundant override entries:
if ((BaseType != null && BaseType.ImplementsInterface(iface)) ||
Interfaces.Any(x => x != iface && x.ImplementsInterface(iface)))
{
// iface is already handled within overrides => skip
// note: iface can be ignored in metadata at all actually
continue;
}
var iface_abstracts = iface.ResolveOverrides(diagnostics);
foreach (var m in iface_abstracts)
{
if (BaseType != null && m.Method.ContainingType != iface && BaseType.ImplementsInterface(m.Method.ContainingType))
{
// iface {m.Method.ContainingType} already handled within overrides => skip
continue;
}
// ignore interface method that is already implemented:
if (overrides.Any(o => OverrideHelper.SignaturesMatch(o.Method, m.Method)))
{
continue;
}
// add interface member,
// resolve its override
overrides.Add(new OverrideInfo(m.Method, this.IsInterface ? null : OverrideHelper.ResolveMethodImplementation(m.Method, this))
{
ImplementsInterface = true
});
}
}
// add overrideable routines from this type
foreach (var s in members)
{
if (s is MethodSymbol m && m.IsOverrideable())
{
overrides.Add(new OverrideInfo(m));
}
}
// handle unresolved abstracts
for (int i = 0; i < overrides.Count; i++)
{
var m = overrides[i];
if (m.IsUnresolvedAbstract && this is SourceTypeSymbol srct && !this.IsInterface)
{
if (!this.IsAbstract)
{
// Class '{0}' doesn't implement abstract method {1}::{2}()
diagnostics.Add(DiagnosticBagExtensions.ParserDiagnostic(srct.ContainingFile.SyntaxTree, srct.Syntax.HeadingSpan,
Devsense.PHP.Errors.Errors.AbstractMethodNotImplemented,
srct.FullName.ToString(), ((IPhpTypeSymbol)m.Method.ContainingType).FullName.ToString(), m.RoutineName));
}
else if (m.ImplementsInterface /*&& this.IsAbstract*/)
{
m.ImplementsInterface = false;
var method = m.Method;
Debug.Assert(!method.IsStatic);
Debug.Assert(method.DeclaredAccessibility != Accessibility.Private);
Debug.Assert(method.ContainingType.IsInterface);
// Template: abstract function {name}({parameters})
var ghost = new SynthesizedMethodSymbol(this, method.RoutineName,
isstatic: false, isvirtual: true, isabstract: true, isfinal: false,
returnType: method.ReturnType,
accessibility: method.DeclaredAccessibility);
ghost.SetParameters(SynthesizedParameterSymbol.Create(ghost, method.Parameters));
//module.SynthesizedManager.AddMethod(this, ghost); // will be added to synthesized manager by FinalizeMethodTable
m.Method = ghost; // replace the interface method with synthesized abstract method
// update overrides
overrides[i] = m;
}
}
}
// cache & return
return(_lazyOverrides = overrides.ToArray());
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
MemberDeclarationSyntax memberDeclaration = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf<MemberDeclarationSyntax>();
Debug.Assert(memberDeclaration != null, $"{nameof(memberDeclaration)} is null");
if (memberDeclaration == null)
return;
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.FormatDeclarationBraces:
{
CodeAction codeAction = CodeAction.Create(
"Format braces",
cancellationToken => FormatDeclarationBracesRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.MarkMemberAsStatic:
{
CodeAction codeAction = CodeAction.Create(
$"Mark {memberDeclaration.GetTitle()} as static",
cancellationToken => MarkMemberAsStaticRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AddDocumentationComment:
{
CodeAction codeAction = CodeAction.Create(
"Add documentation comment",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, false, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
CodeAction codeAction2 = CodeAction.Create(
"Add documentation comment (copy from base if available)",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, true, cancellationToken),
diagnostic.Id + "CopyFromBaseIfAvailable" + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction2, diagnostic);
break;
}
case DiagnosticIdentifiers.RemoveRedundantOverridingMember:
{
CodeAction codeAction = CodeAction.Create(
$"Remove redundant overridding {memberDeclaration.GetTitle()}",
cancellationToken => Remover.RemoveMemberAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.MarkContainingClassAsAbstract:
{
CodeAction codeAction = CodeAction.Create(
"Mark containing class as abstract",
cancellationToken => MarkContainingClassAsAbstractRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.MemberTypeMustMatchOverriddenMemberType:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.MethodDeclaration:
{
var methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = methodSymbol.OverriddenMethod.ReturnType;
break;
}
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
{
var propertySymbol = (IPropertySymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = propertySymbol.OverriddenProperty.Type;
break;
}
case SyntaxKind.EventDeclaration:
{
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
case SyntaxKind.EventFieldDeclaration:
{
VariableDeclaratorSyntax declarator = ((EventFieldDeclarationSyntax)memberDeclaration).Declaration.Variables.First();
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
}
int position = memberDeclaration.SpanStart;
TypeSyntax newType = typeSymbol.ToMinimalTypeSyntax(semanticModel, position);
string title = (memberDeclaration.IsKind(SyntaxKind.MethodDeclaration))
? "Change return type to "
: "Change type to ";
title += $"'{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, position)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, newType, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AddDefaultAccessModifier:
{
var accessibility = (Accessibility)Enum.Parse(
typeof(Accessibility),
context.Diagnostics[0].Properties[nameof(Accessibility)]);
CodeAction codeAction = CodeAction.Create(
"Add default access modifier",
cancellationToken => AddDefaultAccessModifierRefactoring.RefactorAsync(context.Document, memberDeclaration, accessibility, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AddEmptyLineBetweenDeclarations:
{
CodeAction codeAction = CodeAction.Create(
"Add empty line",
cancellationToken => AddEmptyLineBetweenDeclarationsRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.RemoveRedundantSealedModifier:
{
CodeAction codeAction = CodeAction.Create(
"Remove sealed modifier",
cancellationToken => RemoveRedundantSealedModifierRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AvoidSemicolonAtEndOfDeclaration:
{
CodeAction codeAction = CodeAction.Create(
"Remove unnecessary semicolon",
cancellationToken => AvoidSemicolonAtEndOfDeclarationRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ReorderModifiers:
{
CodeAction codeAction = CodeAction.Create(
"Reorder modifiers",
cancellationToken => ReorderModifiersRefactoring.RefactorAsync(context.Document, memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.OverridingMemberCannotChangeAccessModifiers:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
OverrideInfo overrideInfo = OverridingMemberCannotChangeAccessModifiersRefactoring.GetOverrideInfo(memberDeclaration, semanticModel, context.CancellationToken);
string title = $"Change accessibility to '{OverridingMemberCannotChangeAccessModifiersRefactoring.GetAccessibilityText(overrideInfo.OverridenSymbol.DeclaredAccessibility)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => OverridingMemberCannotChangeAccessModifiersRefactoring.RefactorAsync(context.Document, memberDeclaration, overrideInfo, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.MarkFieldAsReadOnly:
{
var fieldDeclaration = (FieldDeclarationSyntax)memberDeclaration;
SeparatedSyntaxList<VariableDeclaratorSyntax> declarators = fieldDeclaration.Declaration.Variables;
string title = (declarators.Count == 1)
? $"Mark '{declarators[0].Identifier.ValueText}' as read-only"
: "Mark fields as read-only";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => MarkFieldAsReadOnlyRefactoring.RefactorAsync(context.Document, fieldDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseReadOnlyAutoProperty:
{
CodeAction codeAction = CodeAction.Create(
"Use read-only auto-property",
cancellationToken => UseReadOnlyAutoPropertyRefactoring.RefactorAsync(context.Document, (PropertyDeclarationSyntax)memberDeclaration, cancellationToken),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
/// <summary>
/// Matches all methods that can be overriden (non-static, public or protected, abstract or virtual)
/// within this type sub-tree (this type, its base and interfaces)
/// with its override.
/// Methods without an override are either abstract or a ghost stup has to be synthesized.
/// </summary>
/// <param name="diagnostics"></param>
internal OverrideInfo[] ResolveOverrides(DiagnosticBag diagnostics)
{
if (_lazyOverrides != null)
{
// already resolved
return(_lazyOverrides);
}
// TODO: ignore System.Object ?
// inherit abstracts from base type
var overrides = new List <OverrideInfo>();
if (BaseType != null)
{
overrides.AddRange(BaseType.ResolveOverrides(diagnostics));
}
// collect this type declared methods including synthesized methods
var methods = this.GetMembers().OfType <MethodSymbol>();
var methodslookup = methods.Where(OverrideHelper.CanOverride).ToLookup(m => m.RoutineName);
// resolve overrides of inherited members
for (int i = 0; i < overrides.Count; i++)
{
var m = overrides[i];
if (m.HasOverride == false)
{
// update override info of the inherited member
overrides[i] = new OverrideInfo(m.Method, OverrideHelper.ResolveMethodImplementation(m.Method, methodslookup[m.RoutineName]));
}
else
{
// clear the interface flag of inherited override info
m.ImplementsInterface = false;
overrides[i] = m;
}
}
// resolve overrides of interface methods
foreach (var iface in Interfaces)
{
// skip interfaces implemented by base type or other interfaces,
// we don't want to add redundant override entries:
if ((BaseType != null && BaseType.ImplementsInterface(iface)) ||
Interfaces.Any(x => x != iface && x.ImplementsInterface(iface)))
{
// iface is already handled within overrides => skip
// note: iface can be ignored in metadata at all actually
continue;
}
var iface_abstracts = iface.ResolveOverrides(diagnostics);
foreach (var m in iface_abstracts)
{
if (BaseType != null && m.Method.ContainingType != iface && BaseType.ImplementsInterface(m.Method.ContainingType))
{
// iface {m.Method.ContainingType} already handled within overrides => skip
continue;
}
// add interface member,
// resolve its override
overrides.Add(new OverrideInfo(m.Method, this.IsInterface ? null : OverrideHelper.ResolveMethodImplementation(m.Method, this))
{
ImplementsInterface = true
});
}
}
// add overrideable routines from this type
foreach (var m in methods)
{
if (m.IsOverrideable())
{
overrides.Add(new OverrideInfo(m));
}
}
// report unresolved abstracts
if (!this.IsInterface && !this.IsAbstract)
{
foreach (var m in overrides)
{
if (m.IsUnresolvedAbstract)
{
// TODO: diagnostics.Add()
}
}
}
// cache & return
return(_lazyOverrides = overrides.ToArray());
}
public abstract IntPtr BizCreate(byte[] bios, byte[] data, int length, [In] OverrideInfo dbinfo, bool skipBios);
/// <summary>
/// Matches all methods that can be overriden (non-static, public or protected, abstract or virtual)
/// within this type sub-tree (this type, its base and interfaces)
/// with its override.
/// Methods without an override are either abstract or a ghost stup has to be synthesized.
/// </summary>
/// <param name="diagnostics"></param>
internal OverrideInfo[] ResolveOverrides(DiagnosticBag diagnostics)
{
if (_lazyOverrides != null)
{
// already resolved
return(_lazyOverrides);
}
// TODO: ignore System.Object ?
// inherit abstracts from base type
var overrides = new List <OverrideInfo>();
if (BaseType != null)
{
overrides.AddRange(BaseType.ResolveOverrides(diagnostics));
}
// collect this type declared methods including synthesized methods
var methods = this.GetMembers().OfType <MethodSymbol>();
var methodslookup = methods.Where(OverrideHelper.CanOverride).ToLookup(m => m.RoutineName, StringComparer.OrdinalIgnoreCase);
// resolve overrides of inherited members
for (int i = 0; i < overrides.Count; i++)
{
var m = overrides[i];
if (m.HasOverride == false)
{
// update override info of the inherited member
overrides[i] = new OverrideInfo(m.Method, OverrideHelper.ResolveMethodImplementation(m.Method, methodslookup[m.RoutineName]));
}
else
{
// clear the interface flag of inherited override info
m.ImplementsInterface = false;
overrides[i] = m;
}
}
// resolve overrides of interface methods
foreach (var iface in Interfaces)
{
// skip interfaces implemented by base type or other interfaces,
// we don't want to add redundant override entries:
if ((BaseType != null && BaseType.ImplementsInterface(iface)) ||
Interfaces.Any(x => x != iface && x.ImplementsInterface(iface)))
{
// iface is already handled within overrides => skip
// note: iface can be ignored in metadata at all actually
continue;
}
var iface_abstracts = iface.ResolveOverrides(diagnostics);
foreach (var m in iface_abstracts)
{
if (BaseType != null && m.Method.ContainingType != iface && BaseType.ImplementsInterface(m.Method.ContainingType))
{
// iface {m.Method.ContainingType} already handled within overrides => skip
continue;
}
// ignore interface method that is already implemented:
if (overrides.Any(o => OverrideHelper.SignaturesMatch(o.Method, m.Method)))
{
continue;
}
// add interface member,
// resolve its override
overrides.Add(new OverrideInfo(m.Method, this.IsInterface ? null : OverrideHelper.ResolveMethodImplementation(m.Method, this))
{
ImplementsInterface = true
});
}
}
// add overrideable routines from this type
foreach (var m in methods)
{
if (m.IsOverrideable())
{
overrides.Add(new OverrideInfo(m));
}
}
// report unresolved abstracts
if (!this.IsAbstract && !this.IsInterface && this is SourceTypeSymbol srct)
{
foreach (var m in overrides)
{
if (m.IsUnresolvedAbstract)
{
// Class '{0}' doesn't implement abstract method {1}::{2}()
diagnostics.Add(DiagnosticBagExtensions.ParserDiagnostic(srct.ContainingFile.SyntaxTree, srct.Syntax.HeadingSpan,
Devsense.PHP.Errors.Errors.AbstractMethodNotImplemented,
srct.FullName.ToString(), ((IPhpTypeSymbol)m.Method.ContainingType).FullName.ToString(), m.RoutineName));
}
}
}
// cache & return
return(_lazyOverrides = overrides.ToArray());
}
