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 + "."))); }