private static SyntaxNode ToMultiLine(SyntaxNode node, SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses)
{
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken previousToken = node.FindToken(first.FullSpan.Start - 1);
node = node.ReplaceToken(previousToken, previousToken.WithTrailingTrivia(TriviaList(NewLine())));
SyntaxTriviaList leadingTrivia = node
.FindToken(node.SpanStart)
.LeadingTrivia;
SyntaxTriviaList trivia = IncreaseIndentation(leadingTrivia.LastOrDefault());
int count = constraintClauses.Count;
for (int i = 0; i < count; i++)
{
TypeParameterConstraintClauseSyntax newNode = constraintClauses[i].WithLeadingTrivia(trivia);
if (i < count - 1)
{
newNode = newNode.WithTrailingTrivia(NewLine());
}
constraintClauses = constraintClauses.ReplaceAt(i, newNode);
}
return(WithConstraintClauses(node, constraintClauses));
}
/// <inheritdoc/>
public override void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
foreach (TypeParameterConstraintSyntax constraint in node.Constraints)
{
base.Visit(constraint);
}
}
/// <summary>
/// Creates a new <see cref="GenericInfo"/> with the specified constraint clause removed.
/// </summary>
/// <param name="constraintClause"></param>
/// <returns></returns>
public GenericInfo RemoveConstraintClause(TypeParameterConstraintClauseSyntax constraintClause)
{
ThrowInvalidOperationIfNotInitialized();
switch (Node.Kind())
{
case SyntaxKind.ClassDeclaration:
return(new GenericInfo(((ClassDeclarationSyntax)Node).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.DelegateDeclaration:
return(new GenericInfo(((DelegateDeclarationSyntax)Node).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.InterfaceDeclaration:
return(new GenericInfo(((InterfaceDeclarationSyntax)Node).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.LocalFunctionStatement:
return(new GenericInfo(((LocalFunctionStatementSyntax)Node).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.MethodDeclaration:
return(new GenericInfo(((MethodDeclarationSyntax)Node).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.StructDeclaration:
return(new GenericInfo(((StructDeclarationSyntax)Node).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
}
Debug.Fail(Node.Kind().ToString());
return(this);
}
public static void ComputeRefactoring(RefactoringContext context, TypeParameterConstraintClauseSyntax constraintClause)
{
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = constraintClause.GetContainingList();
if (constraintClauses.IsSingleLine())
{
if (constraintClauses.Count > 1)
{
context.RegisterRefactoring(
"Format constraints on separate lines",
cancellationToken =>
{
SyntaxNode parent = constraintClause.Parent;
SyntaxNode newNode = ToMultiLine(parent, constraintClauses);
return(context.Document.ReplaceNodeAsync(parent, newNode, cancellationToken));
});
}
}
else
{
context.RegisterRefactoring(
"Format constraints on a single line",
cancellationToken =>
{
SyntaxNode parent = constraintClause.Parent;
SyntaxNode newNode = ToSingleLine(parent, constraintClauses);
return(context.Document.ReplaceNodeAsync(parent, newNode, cancellationToken));
});
}
}
/// <summary>
/// 将当前构建的泛型参数约束生成 Syntax
/// </summary>
/// <returns></returns>
public TypeParameterConstraintClauseSyntax ToConstraintSyntax()
{
if (_this is null)
{
throw new ArgumentNullException("当前没有正在构建的泛型参数约束");
}
const string Template = "where {Name} : {Constraints}";
if (_this.Constraints.Count == 0)
{
return(null);
}
var code = Template
.Replace("{Name}", _this.Name)
.Replace("{Constraints}", _this.Constraints.Join(","));
var syntaxNodes = CSharpSyntaxTree.ParseText(code).GetRoot().DescendantNodes();
TypeParameterConstraintClauseSyntax memberDeclaration = syntaxNodes
.OfType <TypeParameterConstraintClauseSyntax>()
.FirstOrDefault();
return(memberDeclaration);
}
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;
}
}
}
}
private static GenericInfo ToSingleLine(GenericInfo info)
{
SyntaxNode declaration = info.Node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = info.ConstraintClauses;
SyntaxToken previousToken = declaration.FindToken(constraintClauses.First().FullSpan.Start - 1);
declaration = declaration.ReplaceToken(previousToken, previousToken.WithTrailingTrivia(TriviaList(ElasticSpace)));
int count = constraintClauses.Count;
for (int i = 0; i < count; i++)
{
TypeParameterConstraintClauseSyntax constraintClause = constraintClauses[i];
TextSpan?span = null;
if (i == count - 1)
{
span = TextSpan.FromBounds(constraintClause.FullSpan.Start, constraintClause.Span.End);
}
TypeParameterConstraintClauseSyntax newNode = constraintClause
.RemoveWhitespace(span)
.WithFormatterAnnotation();
constraintClauses = constraintClauses.ReplaceAt(i, newNode);
}
return(SyntaxInfo.GenericInfo(declaration).WithConstraintClauses(constraintClauses));
}
private TypeParameterConstraintInfo(
TypeParameterConstraintSyntax constraint,
TypeParameterConstraintClauseSyntax constraintClause)
{
Constraint = constraint;
ConstraintClause = constraintClause;
}
public GenericInfo RemoveConstraintClause(TypeParameterConstraintClauseSyntax constraintClause)
{
switch (Kind)
{
case SyntaxKind.ClassDeclaration:
return(new GenericInfo(((ClassDeclarationSyntax)Declaration).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.DelegateDeclaration:
return(new GenericInfo(((DelegateDeclarationSyntax)Declaration).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.InterfaceDeclaration:
return(new GenericInfo(((InterfaceDeclarationSyntax)Declaration).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.LocalFunctionStatement:
return(new GenericInfo(((LocalFunctionStatementSyntax)Declaration).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.MethodDeclaration:
return(new GenericInfo(((MethodDeclarationSyntax)Declaration).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.StructDeclaration:
return(new GenericInfo(((StructDeclarationSyntax)Declaration).WithConstraintClauses(ConstraintClauses.Remove(constraintClause))));
case SyntaxKind.None:
return(this);
}
Debug.Fail(Kind.ToString());
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConstraintListDefinition" /> class.
/// </summary>
/// <param name="node">The node that defines the generic type constraints.</param>
/// <exception cref="ArgumentNullException">The <paramref name="node" /> parameter is <c>null</c>.</exception>
public ConstraintListDefinition(TypeParameterConstraintClauseSyntax node) : base(node)
{
node = node ?? throw new ArgumentNullException(nameof(node));
Name = node.Name.ToString();
Constraints = DetermineConstraints(node);
}
private static GenericInfo ToMultiLine(GenericInfo info)
{
SyntaxNode declaration = info.Node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = info.ConstraintClauses;
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken previousToken = declaration.FindToken(first.FullSpan.Start - 1);
declaration = declaration.ReplaceToken(previousToken, previousToken.WithTrailingTrivia(TriviaList(NewLine())));
SyntaxTriviaList leadingTrivia = declaration
.FindToken(declaration.SpanStart)
.LeadingTrivia;
SyntaxTriviaList trivia = IncreaseIndentation(leadingTrivia.LastOrDefault());
int count = constraintClauses.Count;
for (int i = 0; i < count; i++)
{
TypeParameterConstraintClauseSyntax newNode = constraintClauses[i].WithLeadingTrivia(trivia);
if (i < count - 1)
{
newNode = newNode.WithTrailingTrivia(NewLine());
}
constraintClauses = constraintClauses.ReplaceAt(i, newNode);
}
return(SyntaxInfo.GenericInfo(declaration).WithConstraintClauses(constraintClauses));
}
internal GenericParameterDeclarationSyntax(
TypeParameterSyntax typeParameter,
TypeParameterConstraintClauseSyntax constraintClause)
{
this.typeParameter = typeParameter;
this.constraintClause = constraintClause;
}
private void MoveConstraint(
CodeFixContext context,
Diagnostic diagnostic,
TypeParameterConstraintSyntax constraint,
SeparatedSyntaxList <TypeParameterConstraintSyntax> constraints,
int index)
{
CodeAction codeAction = CodeAction.Create(
$"Move constraint '{constraint}'",
cancellationToken =>
{
var constraintClause = (TypeParameterConstraintClauseSyntax)constraint.Parent;
SeparatedSyntaxList <TypeParameterConstraintSyntax> newConstraints = constraints.Remove(constraint).Insert(index, constraint);
TypeParameterConstraintClauseSyntax newNode = constraintClause
.WithConstraints(newConstraints)
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(constraintClause, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
private static SyntaxNode ToSingleLine(SyntaxNode node, SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses)
{
SyntaxToken previousToken = node.FindToken(constraintClauses.First().FullSpan.Start - 1);
node = node.ReplaceToken(previousToken, previousToken.WithTrailingTrivia(TriviaList(ElasticSpace)));
int count = constraintClauses.Count;
for (int i = 0; i < count; i++)
{
TypeParameterConstraintClauseSyntax constraintClause = constraintClauses[i];
TextSpan?span = null;
if (i == count - 1)
{
span = TextSpan.FromBounds(constraintClause.FullSpan.Start, constraintClause.Span.End);
}
TypeParameterConstraintClauseSyntax newNode = constraintClause
.RemoveWhitespaceOrEndOfLineTrivia(span)
.WithFormatterAnnotation();
constraintClauses = constraintClauses.ReplaceAt(i, newNode);
}
return(WithConstraintClauses(node, constraintClauses));
}
public static void ComputeRefactoring(RefactoringContext context, TypeParameterConstraintClauseSyntax constraintClause)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapConstraintClauses) &&
(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(constraintClause)))
{
WrapConstraintClausesRefactoring.ComputeRefactoring(context, constraintClause);
}
}
public override void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
if (IsAnyTypeParameter &&
node.IsParentKind(SyntaxKind.MethodDeclaration, SyntaxKind.LocalFunctionStatement))
{
base.VisitTypeParameterConstraintClause(node);
}
}
public override SyntaxNode VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
if (suppressedTypeParameters.Contains(node.Name.Identifier.Text))
{
return(null);
}
return(base.VisitTypeParameterConstraintClause(node));
}
private IEnumerable <string> GetConstraintNames(TypeParameterConstraintClauseSyntax constraintClause, SemanticModel semanticModel)
{
foreach (var constraint in constraintClause.Constraints)
{
yield return(constraint switch
{
TypeConstraintSyntax typeConstraint => semanticModel.GetTypeInfo(typeConstraint.Type).Type.ToString(),
_ => constraint.ToString()
});
public static Doc Print(TypeParameterConstraintClauseSyntax node)
{
return(Doc.Group(
Token.PrintWithSuffix(node.WhereKeyword, " "),
Node.Print(node.Name),
" ",
Token.PrintWithSuffix(node.ColonToken, " "),
Doc.Indent(SeparatedSyntaxList.Print(node.Constraints, Node.Print, Doc.Line))
));
}
public override void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
foreach (TypeParameterConstraintSyntax constraint in node.Constraints)
{
constraint.Accept(this);
}
node.Name?.Accept(this);
base.VisitTypeParameterConstraintClause(node);
}
public void RemoveAt(int index)
{
TypeParameterConstraintClauseSyntax constraintClause = GetConstraintClause(typeParameters[index]);
if (constraintClause != null)
{
constraintClauses.Remove(constraintClause);
}
typeParameters.RemoveAt(index);
}
private static IReadOnlyCollection <string> DetermineConstraints(TypeParameterConstraintClauseSyntax node)
{
var constraints = new List <string>();
foreach (var constraint in node.Constraints)
{
constraints.Add(constraint.ToString());
}
return(constraints.AsReadOnly());
}
public override Evaluation VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
foreach (TypeParameterConstraintSyntax constraint in node.Constraints)
{
constraint.Accept <Evaluation>(this);
}
node.Name?.Accept <Evaluation>(this);
return(base.VisitTypeParameterConstraintClause(node));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveTypeParameter))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out TypeParameterSyntax typeParameter))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.TypeParameterHasSameNameAsTypeParameterFromOuterType:
{
TypeParameterInfo typeParameterInfo = SyntaxInfo.TypeParameterInfo(typeParameter);
if (!typeParameterInfo.Success)
{
break;
}
CodeAction codeAction = CodeAction.Create(
$"Remove type parameter '{typeParameterInfo.Name}'",
cancellationToken =>
{
GenericInfo genericInfo = SyntaxInfo.GenericInfo(typeParameterInfo.Declaration);
GenericInfo newGenericInfo = genericInfo.RemoveTypeParameter(typeParameter);
TypeParameterConstraintClauseSyntax constraintClause = typeParameterInfo.ConstraintClause;
if (constraintClause != null)
{
newGenericInfo = newGenericInfo.RemoveConstraintClause(constraintClause);
}
return(context.Document.ReplaceNodeAsync(genericInfo.Declaration, newGenericInfo.Declaration, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
private TypeParameterConstraintInfo(
TypeParameterConstraintSyntax constraint,
TypeParameterConstraintClauseSyntax constraintClause,
SyntaxNode declaration,
TypeParameterListSyntax typeParameterList,
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses)
{
Constraint = constraint;
ConstraintClause = constraintClause;
Declaration = declaration;
TypeParameterList = typeParameterList;
ConstraintClauses = constraintClauses;
}
public static bool TryGetContainingList(TypeParameterConstraintClauseSyntax constraintClause, out SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses)
{
SyntaxNode parent = constraintClause.Parent;
switch (parent?.Kind())
{
case SyntaxKind.ClassDeclaration:
{
constraintClauses = ((ClassDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.DelegateDeclaration:
{
constraintClauses = ((DelegateDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.InterfaceDeclaration:
{
constraintClauses = ((InterfaceDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.LocalFunctionStatement:
{
constraintClauses = ((LocalFunctionStatementSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.MethodDeclaration:
{
constraintClauses = ((MethodDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.StructDeclaration:
{
constraintClauses = ((StructDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
}
constraintClauses = default(SyntaxList <TypeParameterConstraintClauseSyntax>);
return(false);
}
private Doc PrintTypeParameterConstraintClauseSyntax(
TypeParameterConstraintClauseSyntax node)
{
return(Group(
this.PrintSyntaxToken(node.WhereKeyword, " "),
this.Print(node.Name),
SpaceIfNoPreviousComment,
this.PrintSyntaxToken(node.ColonToken, " "),
Indent(
this.PrintSeparatedSyntaxList(
node.Constraints,
this.Print,
Line
)
)
));
}
private static TypeParameterConstraintInfo ConvertTypeParameterConstraints(
TypeParameterConstraintClauseSyntax x, LangParseContext context)
{
var info = context.RoslynModel.GetTypeInfo(x.Name);
if (info.Type == null)
{
throw new NullReferenceException("info.Type");
}
var ti = context.Roslyn_ResolveType(info.Type);
return(new TypeParameterConstraintInfo
{
Type = ti,
Constr = x.Constraints.Select(a => Convert2(a, context)).ToArray()
});
}
public GenericInfo RemoveConstraintClauses()
{
if (!ConstraintClauses.Any())
{
return(this);
}
TypeParameterConstraintClauseSyntax first = ConstraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(ConstraintClauses.Last().GetTrailingTrivia());
return(Create(Declaration.ReplaceToken(token, token.WithTrailingTrivia(trivia)))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
public override void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
if (!PreVisit(node))
{
return;
}
foreach (TypeParameterConstraintSyntax constraint in node.Constraints)
{
constraint.Accept(this);
}
node.Name?.Accept(this);
base.VisitTypeParameterConstraintClause(node);
PostVisit(node);
}
public void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
_writer.WriteKeyword(PrinterKeyword.Where);
_writer.WriteSpace();
node.Name.Accept(this);
if (_writer.Configuration.Spaces.Other.BeforeTypeParameterConstraintColon)
_writer.WriteSpace();
_writer.WriteSyntax(Syntax.Colon);
if (_writer.Configuration.Spaces.Other.AfterTypeParameterConstraintColon)
_writer.WriteSpace();
bool hadOne = false;
foreach (var constraint in node.Constraints)
{
if (hadOne)
_writer.WriteListSeparator();
else
hadOne = true;
constraint.Accept(this);
}
}
private static TypeParameterSymbol LookupTypeParameterFromConstraintClause(SemanticModel model, TypeParameterConstraintClauseSyntax constraintSyntax, string name)
{
var constraintStart = constraintSyntax.WhereKeyword.SpanStart;
var symbols = model.LookupSymbols(constraintStart, null, name: name);
Assert.Equal(1, symbols.Length);
var symbol = symbols[0] as TypeParameterSymbol;
Assert.NotNull(symbol);
return symbol;
}
public TypeParameterConstraintClauseTranslation(TypeParameterConstraintClauseSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Constraints = syntax.Constraints.Get<TypeParameterConstraintSyntax, TypeParameterConstraintTranslation>(this);
Name = syntax.Name.Get<IdentifierNameTranslation>(this);
}
private void ClassifyUpdate(TypeParameterConstraintClauseSyntax oldNode, TypeParameterConstraintClauseSyntax newNode)
{
if (!SyntaxFactory.AreEquivalent(oldNode.Name, newNode.Name))
{
ReportError(RudeEditKind.Renamed);
return;
}
Debug.Assert(!SyntaxFactory.AreEquivalent(oldNode.Constraints, newNode.Constraints));
ReportError(RudeEditKind.TypeUpdate);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitTypeParameterConstraintClause(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitTypeParameterConstraintClause(TypeParameterConstraintClauseSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitTypeParameterConstraintClause(node);
}
