public static MethodDeclarationSyntax Update(
this MethodDeclarationSyntax syntax,
SyntaxList <AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax returnType,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken identifier,
TypeParameterListSyntax typeParameterList,
ParameterListSyntax parameterList,
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses,
BlockSyntax block,
SyntaxToken semicolonToken)
{
return(syntax.Update(
attributeLists,
modifiers,
returnType,
explicitInterfaceSpecifier,
identifier,
typeParameterList,
parameterList,
constraintClauses,
block,
default(ArrowExpressionClauseSyntax),
semicolonToken));
}
public new void AddChildren()
{
base.AddChildren();
Kind = Node.Kind();
_arity = ((DelegateDeclarationSyntax)Node).Arity;
_arityIsChanged = false;
_attributeLists = ((DelegateDeclarationSyntax)Node).AttributeLists;
_attributeListsIsChanged = false;
_attributeListsCount = _attributeLists.Count;
_modifiers = ((DelegateDeclarationSyntax)Node).Modifiers;
_modifiersIsChanged = false;
_delegateKeyword = ((DelegateDeclarationSyntax)Node).DelegateKeyword;
_delegateKeywordIsChanged = false;
_returnType = ((DelegateDeclarationSyntax)Node).ReturnType;
_returnTypeIsChanged = false;
_identifier = ((DelegateDeclarationSyntax)Node).Identifier;
_identifierIsChanged = false;
_typeParameterList = ((DelegateDeclarationSyntax)Node).TypeParameterList;
_typeParameterListIsChanged = false;
_parameterList = ((DelegateDeclarationSyntax)Node).ParameterList;
_parameterListIsChanged = false;
_constraintClauses = ((DelegateDeclarationSyntax)Node).ConstraintClauses;
_constraintClausesIsChanged = false;
_constraintClausesCount = _constraintClauses.Count;
_semicolonToken = ((DelegateDeclarationSyntax)Node).SemicolonToken;
_semicolonTokenIsChanged = false;
}
private string GetTypeParameterSuffix(TypeParameterListSyntax typeParameterList)
{
if (typeParameterList == null)
{
return(null);
}
var pooledBuilder = PooledStringBuilder.GetInstance();
var builder = pooledBuilder.Builder;
builder.Append('<');
var first = true;
foreach (var parameter in typeParameterList.Parameters)
{
if (!first)
{
builder.Append(", ");
}
builder.Append(parameter.Identifier.Text);
first = false;
}
builder.Append('>');
return(pooledBuilder.ToStringAndFree());
}
public static ParametersInfo Create(DelegateDeclarationSyntax delegateDeclaration, bool allowMissing = false)
{
ParameterListSyntax parameterList = delegateDeclaration.ParameterList;
if (!Check(parameterList, allowMissing))
{
return(Default);
}
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
if (!CheckParameters(parameters, allowMissing))
{
return(Default);
}
TypeParameterListSyntax typeParameterList = delegateDeclaration.TypeParameterList;
SeparatedSyntaxList <TypeParameterSyntax> typeParameters = typeParameterList?.Parameters ?? default(SeparatedSyntaxList <TypeParameterSyntax>);
if (!CheckTypeParameters(typeParameters, allowMissing))
{
return(Default);
}
if (!parameters.Any() &&
!typeParameters.Any())
{
return(Default);
}
return(new ParametersInfo(typeParameterList, parameterList, default(CSharpSyntaxNode)));
}
public static void ComputeRefactoring(RefactoringContext context, InterfaceDeclarationSyntax interfaceDeclaration)
{
TypeParameterListSyntax typeParameterList = interfaceDeclaration.TypeParameterList;
if (typeParameterList != null)
{
if (context.Span.IsEmptyAndContainedInSpan(typeParameterList))
{
RegisterRefactoring(context, interfaceDeclaration);
}
}
else
{
TextSpan span = context.Span;
SyntaxToken identifier = interfaceDeclaration.Identifier;
if (!identifier.IsMissing &&
span.Start >= identifier.Span.End &&
CheckIdentifierAndSpan(identifier, span) &&
span.End <= identifier.GetNextToken().SpanStart)
{
RegisterRefactoring(context, interfaceDeclaration);
}
}
}
public ParameterInfo(BaseParameterListSyntax parameterList, TypeParameterListSyntax typeParameterList, CSharpSyntaxNode body)
{
ParameterList = parameterList;
Parameter = default(ParameterSyntax);
Body = body;
TypeParameterList = typeParameterList;
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveTypeParameter))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
TypeParameterSyntax typeParameter = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <TypeParameterSyntax>();
Debug.Assert(typeParameter != null, $"{nameof(typeParameter)} is null");
if (typeParameter == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.TypeParameterHasSameNameAsTypeParameterFromOuterType:
{
TypeParameterInfo info;
if (TypeParameterInfo.TryCreate(typeParameter, out info))
{
CodeAction codeAction = CodeAction.Create(
$"Remove type parameter '{info.Name}'",
cancellationToken =>
{
SeparatedSyntaxList <TypeParameterSyntax> parameters = info.TypeParameterList.Parameters;
TypeParameterListSyntax newTypeParameterList = (parameters.Count == 1)
? default(TypeParameterListSyntax)
: info.TypeParameterList.WithParameters(parameters.Remove(typeParameter));
SyntaxNode newNode = GenericDeclarationHelper.WithTypeParameterList(info.Declaration, newTypeParameterList);
TypeParameterConstraintClauseSyntax constraintClause = info.ConstraintClause;
if (constraintClause != null)
{
newNode = GenericDeclarationHelper.WithConstraintClauses(newNode, info.ConstraintClauses.Remove(constraintClause));
}
return(context.Document.ReplaceNodeAsync(info.Declaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
}
}
}
public static void ComputeRefactoring(RefactoringContext context, DelegateDeclarationSyntax delegateDeclaration)
{
TypeParameterListSyntax typeParameterList = delegateDeclaration.TypeParameterList;
if (typeParameterList != null)
{
if (context.Span.IsEmptyAndContainedInSpan(typeParameterList))
{
RegisterRefactoring(context, delegateDeclaration);
}
}
else
{
TextSpan span = context.Span;
SyntaxToken identifier = delegateDeclaration.Identifier;
if (!identifier.IsMissing &&
span.Start >= identifier.Span.End)
{
ParameterListSyntax parameterList = delegateDeclaration.ParameterList;
if (parameterList != null &&
span.End <= parameterList.Span.Start)
{
RegisterRefactoring(context, delegateDeclaration);
}
}
}
}
private TypeParameterInfo(
TypeParameterSyntax typeParameter,
TypeParameterListSyntax typeParameterList)
{
TypeParameter = typeParameter;
TypeParameterList = typeParameterList;
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ClassDeclarationSyntax classDeclaration)
{
SyntaxToken identifier = classDeclaration.Identifier;
if (identifier.IsMissing)
{
return;
}
TextSpan span = identifier.Span;
BaseListSyntax baseList = classDeclaration.BaseList;
if (baseList != null)
{
span = TextSpan.FromBounds(span.Start, baseList.Span.End);
}
TypeParameterListSyntax typeParameterList = classDeclaration.TypeParameterList;
if (typeParameterList != null)
{
span = TextSpan.FromBounds(span.Start, typeParameterList.Span.End);
}
if (!span.Contains(context.Span))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken);
if (classSymbol?.IsErrorType() != false)
{
return;
}
if (classSymbol.IsStatic)
{
return;
}
foreach (INamedTypeSymbol interfaceSymbol in classSymbol.AllInterfaces)
{
if (interfaceSymbol.HasMetadataName(MetadataNames.System_IEquatable_T) &&
interfaceSymbol.TypeArguments.Single().Equals(classSymbol))
{
return;
}
}
INamedTypeSymbol equatableSymbol = semanticModel.GetTypeByMetadataName("System.IEquatable`1").Construct(classSymbol);
context.RegisterRefactoring(
GetTitle(equatableSymbol, semanticModel, classDeclaration.SpanStart),
f => RefactorAsync(context.Document, classDeclaration, classSymbol, equatableSymbol, semanticModel, f),
RefactoringIdentifiers.ImplementIEquatableOfT);
}
/// <summary>
/// 构建泛型参数列表
/// </summary>
/// <returns></returns>
public TypeParameterListSyntax BuildTypeParameterListSyntax()
{
// syntax 写法太长
//List<SyntaxNodeOrToken> tokens = new List<SyntaxNodeOrToken>();
//var list = _generic.ToArray();
//for (int i = 0; i < list.Length; i++)
//{
// tokens.Add(SyntaxFactory.TypeParameter
// (
// SyntaxFactory.Identifier(list[i].Name)
// ));
// if (i < list.Length - 1)
// tokens.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
//}
//return
//SyntaxFactory.TypeParameterList
//(
// SyntaxFactory.SeparatedList<TypeParameterSyntax>
// (
// tokens.ToArray()
// )
//);
var syntaxNodes = CSharpSyntaxTree.ParseText(ToFullCode()).GetRoot().DescendantNodes();
TypeParameterListSyntax memberDeclaration = syntaxNodes
.OfType <TypeParameterListSyntax>()
.FirstOrDefault();
return(memberDeclaration);
}
private static SyntaxNode GetNewNode(
DelegateDeclarationSyntax delegateDeclaration,
TypeParameterConstraintSyntax constraint,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
TypeParameterListSyntax typeParameterList = delegateDeclaration.TypeParameterList;
INamedTypeSymbol delegateSymbol = semanticModel.GetDeclaredSymbol(delegateDeclaration, cancellationToken);
int position = (typeParameterList != null)
? typeParameterList.SpanStart
: delegateDeclaration.Identifier.SpanStart;
string name = GetTypeParameterName(position, semanticModel);
DelegateDeclarationSyntax newNode = delegateDeclaration.AddTypeParameterListParameters(TypeParameter(Identifier(name).WithRenameAnnotation()));
if (constraint != null)
{
newNode = newNode.AddConstraintClauses(TypeParameterConstraintClause(name, constraint));
}
return(newNode);
}
internal static void ComputeRefactoring(RefactoringContext context, LocalFunctionStatementSyntax localFunctionStatement)
{
TypeParameterListSyntax typeParameterList = localFunctionStatement.TypeParameterList;
if (typeParameterList != null)
{
if (context.Span.IsEmptyAndContainedInSpan(typeParameterList))
{
RegisterRefactoring(context, localFunctionStatement);
}
}
else
{
TextSpan span = context.Span;
SyntaxToken identifier = localFunctionStatement.Identifier;
if (!identifier.IsMissing &&
span.Start >= identifier.Span.End)
{
ParameterListSyntax parameterList = localFunctionStatement.ParameterList;
if (parameterList != null &&
span.End <= parameterList.Span.Start)
{
RegisterRefactoring(context, localFunctionStatement);
}
}
}
}
public static void ComputeRefactoring(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
TypeParameterListSyntax typeParameterList = methodDeclaration.TypeParameterList;
if (typeParameterList != null)
{
if (context.Span.IsEmptyAndContainedInSpan(typeParameterList))
{
RegisterRefactoring(context, methodDeclaration);
}
}
else
{
TextSpan span = context.Span;
SyntaxToken identifier = methodDeclaration.Identifier;
if (!identifier.IsMissing &&
span.Start >= identifier.Span.End)
{
ParameterListSyntax parameterList = methodDeclaration.ParameterList;
if (parameterList != null &&
span.End <= parameterList.Span.Start &&
methodDeclaration.BodyOrExpressionBody() != null)
{
RegisterRefactoring(context, methodDeclaration);
}
}
}
}
public GenericInfo WithTypeParameterList(TypeParameterListSyntax typeParameterList)
{
switch (Kind)
{
case SyntaxKind.ClassDeclaration:
return(new GenericInfo(((ClassDeclarationSyntax)Declaration).WithTypeParameterList(typeParameterList)));
case SyntaxKind.DelegateDeclaration:
return(new GenericInfo(((DelegateDeclarationSyntax)Declaration).WithTypeParameterList(typeParameterList)));
case SyntaxKind.InterfaceDeclaration:
return(new GenericInfo(((InterfaceDeclarationSyntax)Declaration).WithTypeParameterList(typeParameterList)));
case SyntaxKind.LocalFunctionStatement:
return(new GenericInfo(((LocalFunctionStatementSyntax)Declaration).WithTypeParameterList(typeParameterList)));
case SyntaxKind.MethodDeclaration:
return(new GenericInfo(((MethodDeclarationSyntax)Declaration).WithTypeParameterList(typeParameterList)));
case SyntaxKind.StructDeclaration:
return(new GenericInfo(((StructDeclarationSyntax)Declaration).WithTypeParameterList(typeParameterList)));
case SyntaxKind.None:
return(this);
}
Debug.Fail(Kind.ToString());
return(this);
}
private static bool CheckTypeParameters(
MemberDeclarationSyntax memberDeclaration,
INamedTypeSymbol interfaceSymbol)
{
if (!(memberDeclaration is MethodDeclarationSyntax methodDeclaration))
{
return(true);
}
TypeParameterListSyntax typeParameterList = methodDeclaration.TypeParameterList;
if (typeParameterList == null)
{
return(true);
}
SeparatedSyntaxList <TypeParameterSyntax> typeParameters = typeParameterList.Parameters;
if (typeParameters.Count == 0)
{
return(true);
}
return(typeParameters.Count == interfaceSymbol.TypeParameters.Length);
}
static ClassDeclarationSyntax MakeStaticClass(
SyntaxToken applyToIdentifier,
MethodDeclarationSyntax[] applyToMembers,
TypeParameterListSyntax applyToTypeParams,
SyntaxList <TypeParameterConstraintClauseSyntax> applyToConstraints,
MethodDeclarationSyntax pure,
bool mapIsStatic
)
{
var name = applyToIdentifier;
var @class = ClassDeclaration(name)
.WithModifiers(
TokenList(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.PartialKeyword) }));
var returnType = ParseTypeName($"{applyToIdentifier}{applyToTypeParams}");
var cases = applyToMembers
.Select(m => MakeCaseCtorFunction(applyToIdentifier, applyToTypeParams, applyToConstraints, returnType, m, pure))
.ToArray();
var bind = MakeBindFunction(applyToIdentifier, applyToConstraints, applyToMembers, applyToTypeParams, pure, mapIsStatic);
var map = mapIsStatic
? MakeMapExtension(applyToIdentifier, applyToConstraints, applyToMembers, applyToTypeParams)
: MakeMapFunction(applyToIdentifier, applyToConstraints, applyToMembers, applyToTypeParams, pure);
var monad = AddMonadDefaults(applyToIdentifier, applyToMembers, applyToTypeParams, applyToConstraints);
return(@class.WithMembers(List(cases).Add(bind).Add(map).AddRange(monad)));
}
public static MethodDeclarationSyntax MethodDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax returnType,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken identifier,
TypeParameterListSyntax typeParameterList,
ParameterListSyntax parameterList,
SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses,
BlockSyntax body,
SyntaxToken semicolonToken)
{
return SyntaxFactory.MethodDeclaration(
attributeLists,
modifiers,
default(SyntaxToken),
returnType,
explicitInterfaceSpecifier,
identifier,
typeParameterList,
parameterList,
constraintClauses,
body,
default(ArrowExpressionClauseSyntax),
semicolonToken);
}
// Preserved as shipped public API for binary compatibility
public LocalFunctionStatementSyntax Update(
SyntaxTokenList modifiers,
TypeSyntax returnType,
SyntaxToken identifier,
TypeParameterListSyntax typeParameterList,
ParameterListSyntax parameterList,
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses,
BlockSyntax body,
ArrowExpressionClauseSyntax expressionBody,
SyntaxToken semicolonToken
)
{
return(Update(
AttributeLists,
modifiers,
returnType,
identifier,
typeParameterList,
parameterList,
constraintClauses,
body,
expressionBody,
semicolonToken
));
}
public override SyntaxNode VisitTypeParameterList(TypeParameterListSyntax node)
{
node = (TypeParameterListSyntax)base.VisitTypeParameterList(node);
int i = 0;
foreach (TypeParameterSyntax parameter in node.Parameters)
{
if (RemoveTestAttributes(parameter.AttributeLists))
{
suppressedTypeParameters.Add(parameter.Identifier.Text);
node = node.Update(
node.LessThanToken,
node.Parameters.RemoveAt(i),
node.GreaterThanToken);
continue;
}
i++;
}
if (node.Parameters.Count == 0)
{
return(null);
}
return(node);
}
public FunctionBreakpointNameFactory(CSharpSyntaxNode member, SyntaxToken memberIdentifier, AccessorDeclarationSyntax accessor = null, TypeParameterListSyntax typeParameters = null)
{
this.member = member;
this.memberIdentifier = memberIdentifier;
this.accessor = accessor;
this.typeParameters = typeParameters;
}
/// <summary>
/// Creates a new <see cref="GenericInfo"/> with the type parameter list updated.
/// </summary>
/// <param name="typeParameterList"></param>
/// <returns></returns>
public GenericInfo WithTypeParameterList(TypeParameterListSyntax typeParameterList)
{
ThrowInvalidOperationIfNotInitialized();
switch (Node.Kind())
{
case SyntaxKind.ClassDeclaration:
return(new GenericInfo(((ClassDeclarationSyntax)Node).WithTypeParameterList(typeParameterList)));
case SyntaxKind.DelegateDeclaration:
return(new GenericInfo(((DelegateDeclarationSyntax)Node).WithTypeParameterList(typeParameterList)));
case SyntaxKind.InterfaceDeclaration:
return(new GenericInfo(((InterfaceDeclarationSyntax)Node).WithTypeParameterList(typeParameterList)));
case SyntaxKind.LocalFunctionStatement:
return(new GenericInfo(((LocalFunctionStatementSyntax)Node).WithTypeParameterList(typeParameterList)));
case SyntaxKind.MethodDeclaration:
return(new GenericInfo(((MethodDeclarationSyntax)Node).WithTypeParameterList(typeParameterList)));
case SyntaxKind.StructDeclaration:
return(new GenericInfo(((StructDeclarationSyntax)Node).WithTypeParameterList(typeParameterList)));
}
Debug.Fail(Node.Kind().ToString());
return(this);
}
/// <summary>
/// Visits a member.
/// </summary>
/// <typeparam name="T">The syntax node type to visit.</typeparam>
/// <param name="node">The node to visit.</param>
/// <param name="exctractName">Extract the node name.</param>
/// <param name="typeParameterList">The type parameter list.</param>
/// <param name="targetNode">Resolved the target node.</param>
/// <param name="visit">Visit sub nodes.</param>
private void Visit <T>(T node, Func <T, string> exctractName, TypeParameterListSyntax typeParameterList, Func <T, SyntaxNode> targetNode, Action <T> visit) where T : CSharpSyntaxNode
{
// Retrieve the accessor name
string name = exctractName(node);
// Compute suffix for representing generics
if (null != typeParameterList)
{
name = string.Format(
"{0}{{{1}}}",
name,
string.Join(",", typeParameterList.Parameters.Select(x => x.ToString())));
}
// Keep track of the initial node the restore the root after the visit
CSharpSyntaxMatchingNode initialNode = this.Root;
// Create and add the node
this.Root = this.Root.EnsureNode(name);
this.Root.AddSyntaxNode(targetNode(node));
// Trigger member visiting
visit(node);
// Copy the class sub tree to the Trie root
this.Root.CopyTo(this.internalInvariantRoot, name);
// Restore the initial root
this.Root = initialNode;
}
public ParametersInfo(TypeParameterListSyntax typeParameterList, BaseParameterListSyntax parameterList, CSharpSyntaxNode body)
{
TypeParameterList = typeParameterList;
Body = body;
Parameter = default(ParameterSyntax);
ParameterList = parameterList;
}
public static MethodDeclarationSyntax MethodDeclaration(
SyntaxList <AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax returnType,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken identifier,
TypeParameterListSyntax typeParameterList,
ParameterListSyntax parameterList,
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses,
BlockSyntax body,
SyntaxToken semicolonToken)
{
return(SyntaxFactory.MethodDeclaration(
attributeLists,
modifiers,
returnType,
explicitInterfaceSpecifier,
identifier,
typeParameterList,
parameterList,
constraintClauses,
body,
null,
semicolonToken));
}
public static SyntaxNode WithTypeParameterList(SyntaxNode node, TypeParameterListSyntax typeParameterList)
{
switch (node.Kind())
{
case SyntaxKind.ClassDeclaration:
return(((ClassDeclarationSyntax)node).WithTypeParameterList(typeParameterList));
case SyntaxKind.DelegateDeclaration:
return(((DelegateDeclarationSyntax)node).WithTypeParameterList(typeParameterList));
case SyntaxKind.InterfaceDeclaration:
return(((InterfaceDeclarationSyntax)node).WithTypeParameterList(typeParameterList));
case SyntaxKind.LocalFunctionStatement:
return(((LocalFunctionStatementSyntax)node).WithTypeParameterList(typeParameterList));
case SyntaxKind.MethodDeclaration:
return(((MethodDeclarationSyntax)node).WithTypeParameterList(typeParameterList));
case SyntaxKind.StructDeclaration:
return(((StructDeclarationSyntax)node).WithTypeParameterList(typeParameterList));
}
Debug.Fail(node.Kind().ToString());
return(node);
}
public static void ComputeRefactoring(RefactoringContext context, InterfaceDeclarationSyntax interfaceDeclaration)
{
TypeParameterListSyntax typeParameterList = interfaceDeclaration.TypeParameterList;
if (typeParameterList != null)
{
if (context.Span.IsEmptyAndContainedInSpan(typeParameterList))
{
RegisterRefactoring(context, interfaceDeclaration);
}
}
else
{
TextSpan span = context.Span;
SyntaxToken identifier = interfaceDeclaration.Identifier;
if (!identifier.IsMissing &&
span.Start >= identifier.Span.End)
{
SyntaxToken openBrace = interfaceDeclaration.OpenBraceToken;
if (!openBrace.IsMissing &&
span.End <= openBrace.Span.Start)
{
RegisterRefactoring(context, interfaceDeclaration);
}
}
}
}
private TypeParameterInfo(TypeParameterSyntax typeParameter, SyntaxNode declaration, TypeParameterListSyntax typeParameterList, SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses) : this()
{
TypeParameter = typeParameter;
Name = typeParameter.Identifier.ValueText;
Declaration = declaration;
TypeParameterList = typeParameterList;
ConstraintClauses = constraintClauses;
}
public override LuaSyntaxNode VisitTypeParameterList(TypeParameterListSyntax node) {
LuaParameterListSyntax parameterList = new LuaParameterListSyntax();
foreach (var typeParameter in node.Parameters) {
var typeIdentifier = (LuaIdentifierNameSyntax)typeParameter.Accept(this);
parameterList.Parameters.Add(new LuaParameterSyntax(typeIdentifier));
}
return parameterList;
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, StructDeclarationSyntax structDeclaration)
{
SyntaxToken identifier = structDeclaration.Identifier;
if (identifier.IsMissing)
{
return;
}
TextSpan span = identifier.Span;
BaseListSyntax baseList = structDeclaration.BaseList;
if (baseList != null)
{
span = TextSpan.FromBounds(span.Start, baseList.Span.End);
}
TypeParameterListSyntax typeParameterList = structDeclaration.TypeParameterList;
if (typeParameterList != null)
{
span = TextSpan.FromBounds(span.Start, typeParameterList.Span.End);
}
if (!span.Contains(context.Span))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol typeSymbol = semanticModel.GetDeclaredSymbol(structDeclaration, context.CancellationToken);
if (typeSymbol?.IsErrorType() != false)
{
return;
}
INamedTypeSymbol equatableSymbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_IEquatable_T);
if (equatableSymbol == null)
{
return;
}
equatableSymbol = equatableSymbol.Construct(typeSymbol);
if (typeSymbol.Implements(equatableSymbol, allInterfaces: true))
{
return;
}
context.RegisterRefactoring(
GetTitle(equatableSymbol, semanticModel, structDeclaration.SpanStart),
f => RefactorAsync(context.Document, structDeclaration, typeSymbol, equatableSymbol, semanticModel, f),
RefactoringIdentifiers.ImplementIEquatableOfT);
}
internal static SyntaxList <XmlNodeSyntax> BuildStandardTextSyntaxList(BaseTypeDeclarationSyntax typeDeclaration, string preText, string postText)
{
TypeParameterListSyntax typeParameterList = GetTypeParameterList(typeDeclaration);
return(XmlSyntaxFactory.List(
XmlSyntaxFactory.Text(preText),
BuildSeeElement(typeDeclaration.Identifier, typeParameterList),
XmlSyntaxFactory.Text(postText.EndsWith(".") ? postText : (postText + "."))));
}
public static DelegateDeclarationSyntax DelegateDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken delegateKeyword, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken semicolonToken)
{
return DelegateDeclaration(
attributeLists,
modifiers,
delegateKeyword,
refKeyword: default(SyntaxToken),
returnType: returnType,
identifier: identifier,
typeParameterList: typeParameterList,
parameterList: parameterList,
constraintClauses: constraintClauses,
semicolonToken: semicolonToken);
}
public static TypeDeclarationSyntax TypeDeclaration(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributes, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
{
switch (kind)
{
case SyntaxKind.ClassDeclaration:
return SyntaxFactory.ClassDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
case SyntaxKind.StructDeclaration:
return SyntaxFactory.StructDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
case SyntaxKind.InterfaceDeclaration:
return SyntaxFactory.InterfaceDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
default:
throw new ArgumentException("kind");
}
}
void AppendTypeParameter (StringBuilder sb, TypeParameterListSyntax parameters)
{
if (parameters == null || parameters.Parameters.Count == 0)
return;
sb.Append ("<");
bool first = true;
foreach (var param in parameters.Parameters) {
if (!first) {
sb.Append (", ");
} else {
first = false;
}
AppendEscaped (sb, param.ToString ());
}
sb.Append (">");
}
private static TypeArgumentListSyntax ParameterToArgumentListSyntax(TypeParameterListSyntax typeParameters)
{
var list = new SeparatedSyntaxList<TypeSyntax>();
list = list.AddRange(typeParameters.Parameters.Select(p => SyntaxFactory.ParseName(p.ToString()).WithTriviaFrom(p)));
for (int i = 0; i < list.SeparatorCount; i++)
{
// Make sure the parameter list looks nice
var separator = list.GetSeparator(i);
list = list.ReplaceSeparator(separator, separator.WithTrailingTrivia(SyntaxFactory.Space));
}
return SyntaxFactory.TypeArgumentList(list);
}
private static SyntaxList<XmlNodeSyntax> BuildStandardText(SyntaxToken identifier, TypeParameterListSyntax typeParameters, string newLineText, string preText, string postText)
{
TypeSyntax identifierName;
// Get a TypeSyntax representing the class name with its type parameters
if (typeParameters == null || !typeParameters.Parameters.Any())
{
identifierName = SyntaxFactory.IdentifierName(identifier.WithoutTrivia());
}
else
{
identifierName = SyntaxFactory.GenericName(identifier.WithoutTrivia(), ParameterToArgumentListSyntax(typeParameters));
}
return XmlSyntaxFactory.List(
XmlSyntaxFactory.NewLine(newLineText),
XmlSyntaxFactory.Text(preText),
XmlSyntaxFactory.SeeElement(SyntaxFactory.TypeCref(identifierName)),
XmlSyntaxFactory.Text(postText.EndsWith(".") ? postText : (postText + ".")));
}
public static bool Any(TypeParameterListSyntax listOpt)
{
return listOpt != null && listOpt.ChildNodesAndTokens().Count != 0;
}
public static TypeDeclarationSyntax WithTypeParameterList(
this TypeDeclarationSyntax node, TypeParameterListSyntax list)
{
switch (node.Kind())
{
case SyntaxKind.ClassDeclaration:
return ((ClassDeclarationSyntax)node).WithTypeParameterList(list);
case SyntaxKind.InterfaceDeclaration:
return ((InterfaceDeclarationSyntax)node).WithTypeParameterList(list);
case SyntaxKind.StructDeclaration:
return ((StructDeclarationSyntax)node).WithTypeParameterList(list);
}
throw new InvalidOperationException ();
}
private static void AppendTypeParameterList(StringBuilder builder, TypeParameterListSyntax typeParameterList)
{
if (typeParameterList != null && typeParameterList.Parameters.Count > 0)
{
builder.Append('<');
builder.Append(typeParameterList.Parameters[0].Identifier.ValueText);
for (int i = 1; i < typeParameterList.Parameters.Count; i++)
{
builder.Append(", ");
builder.Append(typeParameterList.Parameters[i].Identifier.ValueText);
}
builder.Append('>');
}
}
public static string TypeParameterList(TypeParameterListSyntax list)
{
return string.Join(", ", list.Parameters.Select(SyntaxNode));
}
/// <summary>Creates a new ClassDeclarationSyntax instance.</summary>
public static ClassDeclarationSyntax ClassDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
{
return SyntaxFactory.ClassDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
}
public TypeParameterListTranslation(TypeParameterListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Parameters = syntax.Parameters.Get<TypeParameterSyntax, TypeParameterTranslation>(this);
}
/// <summary>Creates a new StructDeclarationSyntax instance.</summary>
public static StructDeclarationSyntax StructDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<MemberDeclarationSyntax> members)
{
return SyntaxFactory.StructDeclaration(attributeLists, modifiers, identifier, typeParameterList, null, baseList, constraintClauses, members);
}
public override void VisitTypeParameterList(TypeParameterListSyntax node)
{
// skip
}
public static TypeDeclarationSyntax WithTypeParameterList(
this TypeDeclarationSyntax node, TypeParameterListSyntax list)
{
switch (node.CSharpKind())
{
case SyntaxKind.ClassDeclaration:
return ((ClassDeclarationSyntax)node).WithTypeParameterList(list);
case SyntaxKind.InterfaceDeclaration:
return ((InterfaceDeclarationSyntax)node).WithTypeParameterList(list);
case SyntaxKind.StructDeclaration:
return ((StructDeclarationSyntax)node).WithTypeParameterList(list);
}
throw Contract.Unreachable;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitTypeParameterList(TypeParameterListSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitTypeParameterList(node);
}
public MethodDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
{
return Update(attributeLists, modifiers, this.RefKeyword, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken);
}
private static string ExpandTypeParameterList(TypeParameterListSyntax typeParameterList)
{
if (typeParameterList != null && typeParameterList.Parameters.Count > 0)
{
var builder = new StringBuilder();
builder.Append('<');
builder.Append(typeParameterList.Parameters[0].Identifier.ValueText);
for (int i = 1; i < typeParameterList.Parameters.Count; i++)
{
builder.Append(',');
builder.Append(typeParameterList.Parameters[i].Identifier.ValueText);
}
builder.Append('>');
return builder.ToString();
}
else
{
return null;
}
}
public void VisitTypeParameterList(TypeParameterListSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
if (_writer.Configuration.Spaces.BeforeParentheses.BeforeTypeParameterListAngle)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.LessThan);
if (_writer.Configuration.Spaces.WithinParentheses.TypeParameterAngles)
_writer.WriteSpace();
bool hadOne = false;
foreach (var parameter in node.Parameters)
{
if (hadOne)
_writer.WriteListSeparator();
else
hadOne = true;
parameter.Accept(this);
}
if (_writer.Configuration.Spaces.WithinParentheses.TypeParameterAngles)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.GreaterThan);
}
// These (generic type params) should not be changed?
private TypeParameterListSyntax UpdateTypeParameterList(TypeParameterListSyntax typeParameterListSyntax)
{
return typeParameterListSyntax;
}
public static MethodDeclarationSyntax Update(
this MethodDeclarationSyntax syntax,
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
SyntaxToken refKeyword,
TypeSyntax returnType,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken identifier,
TypeParameterListSyntax typeParameterList,
ParameterListSyntax parameterList,
SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses,
BlockSyntax block,
SyntaxToken semicolonToken)
{
return syntax.Update(
attributeLists,
modifiers,
refKeyword,
returnType,
explicitInterfaceSpecifier,
identifier,
typeParameterList,
parameterList,
constraintClauses,
block,
default(ArrowExpressionClauseSyntax),
semicolonToken);
}
public StructDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
{
return this.Update(attributeLists, modifiers, keyword, identifier, typeParameterList, this.ParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitTypeParameterList(TypeParameterListSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitTypeParameterList(node);
}
public DelegateDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken delegateKeyword, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken semicolonToken)
{
return Update(attributeLists, modifiers, delegateKeyword, this.RefKeyword, returnType, identifier, typeParameterList, parameterList, constraintClauses, semicolonToken);
}
private static XmlEmptyElementSyntax BuildSeeElement(SyntaxToken identifier, TypeParameterListSyntax typeParameters)
{
TypeSyntax identifierName;
// Get a TypeSyntax representing the class name with its type parameters
if (typeParameters == null || !typeParameters.Parameters.Any())
{
identifierName = SyntaxFactory.IdentifierName(identifier.WithoutTrivia());
}
else
{
identifierName = SyntaxFactory.GenericName(identifier.WithoutTrivia(), ParameterToArgumentListSyntax(typeParameters));
}
return XmlSyntaxFactory.SeeElement(SyntaxFactory.TypeCref(identifierName));
}
private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context, SyntaxNode node, TypeParameterListSyntax typeParameterList)
{
if (typeParameterList == null)
{
// The member does not have a type parameter list
return;
}
var documentation = node.GetDocumentationCommentTriviaSyntax();
if (documentation == null)
{
// Don't report if the documentation is missing
return;
}
if (documentation.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag) != null)
{
// Ignore nodes with an <inheritdoc/> tag.
return;
}
var xmlParameterNames = documentation.Content.GetXmlElements(XmlCommentHelper.TypeParamXmlTag)
.Select(XmlCommentHelper.GetFirstAttributeOrDefault<XmlNameAttributeSyntax>)
.Where(x => x != null)
.ToImmutableArray();
foreach (var parameter in typeParameterList.Parameters)
{
if (!xmlParameterNames.Any(x => x.Identifier.Identifier.ValueText == parameter.Identifier.ValueText))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, parameter.Identifier.GetLocation(), parameter.Identifier.ValueText));
}
}
}
private static SyntaxList<XmlNodeSyntax> BuildStandardText(SyntaxToken identifier, TypeParameterListSyntax typeParameters, string newLineText, string preText, string postText)
{
return XmlSyntaxFactory.List(
XmlSyntaxFactory.NewLine(newLineText),
XmlSyntaxFactory.Text(preText),
BuildSeeElement(identifier, typeParameters),
XmlSyntaxFactory.Text(postText.EndsWith(".") ? postText : (postText + ".")));
}
