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); }