protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode baseNode) { Func <SyntaxNode, bool> match; if (baseNode.BaseNode is CompilationUnitSyntax) { match = FileMemberSyntaxNodeMatcher.Instance.Match; } else if (baseNode.BaseNode is NamespaceDeclarationSyntax) { match = NamespaceMemberSyntaxNodeMatcher.Instance.Match; } else if (baseNode.BaseNode is ClassDeclarationSyntax || baseNode.BaseNode is InterfaceDeclarationSyntax) { match = ClassMemberSyntaxNodeMatcher.Instance.Match; } else if (baseNode.BaseNode is StructDeclarationSyntax) { match = StructMemberSyntaxNodeMatcher.Instance.Match; } else { throw new ArgumentException("Unsupported node type", nameof(baseNode)); } CombinedSyntaxNode[] members = baseNode.BaseNode.ChildNodes() .Where(match) .GroupBy(x => x.Kind()) .Select(x => new CombinedSyntaxNode(x.First())) .ToArray(); return(members); }
public MethodBodyState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (!MethodBodySyntaxNodeMatcher.Instance.Match(contextNode.BaseNode)) { throw new ArgumentException("Unsupported node type.", nameof(contextNode)); } }
public MethodMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode) { if (!MethodMemberParentSyntaxNodeMatcher.Instance.Match(baseNode.BaseNode)) { throw new ArgumentException( "The provided base node is not a method body.", nameof(baseNode)); } }
public AutoPropertyDeclarationState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(AutoPropertyDeclarationSyntax)) { throw new ArgumentException( $"Unsupported base node type for {nameof(AutoPropertyDeclarationState)}"); } }
public bool Match(CombinedSyntaxNode node) { if (node.IsVirtual) { return(VirtualMethodMembers.Contains(node.MixedNode.GetType())); } return(this.Match(node.BaseNode)); }
public CatchClauseState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(CatchClauseSyntax)) { throw new ArgumentException( $"Unsupported context node for {nameof(CatchClauseState)}."); } }
protected MethodMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (!MethodMemberSyntaxNodeMatcher.Instance.Match(contextNode.BaseNode)) { throw new ArgumentException( "The provided context node is not a member of a method declaration.", nameof(contextNode)); } }
public TryMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode) { if (!(baseNode.BaseNode is TryStatementSyntax)) { throw new ArgumentException( "The provided base node is not supported by " + $"{nameof(TryMemberSiblingState)}", nameof(baseNode));;; } }
public IfMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode) { if (baseNode.MixedNode.GetType() != typeof(IfStatementSyntax)) { throw new ArgumentException( "The provided base node can not be used for " + $"{nameof(IfMemberSiblingState)}. " + $"The actual mixed node type is {baseNode.MixedNode.GetType()}.", nameof(baseNode)); } }
public ElseBodyState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(ElseBodySyntax)) { throw new ArgumentException( $"Unsupported context node for {nameof(ElseBodyState)}. " + $"Actual node type: {contextNode.MixedNode.GetType()}."); } targets = new[] { contextNode }; }
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root) { return(root.BaseNode ?.ChildNodes() .Where(x => !(x is TypeSyntax)) .QueryVirtualAndCombine(MethodBodyVirtualQuery.Instance) .Where(MethodMemberSyntaxNodeMatcher.Instance.Match) .GroupBy(x => x.MixedNode.GetType()) .Select(x => x.First()) .ToArray() ?? Array.Empty <CombinedSyntaxNode>()); }
protected LocalContextState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { // it was introduced as an optimization but caused // an error when TNode was set to the base SyntaxNode // for some states. //if (!(context.State is LocalContextState<TNode, T>)) //{ // this.SiblingState = this.InitSiblingState(); //} this.SiblingState = this.InitSiblingState(); }
public FinallyClauseState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(FinallyClauseSyntax)) { throw new ArgumentException( $"Unsupported context node for {nameof(FinallyClauseState)}."); } targetNodes = new[] { contextNode }; }
public ElseClauseState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(ElseClauseSyntax)) { throw new ArgumentException( $"The provided context node is not supported by {nameof(ElseClauseState)}.\"" + $"Actual: {contextNode.MixedNode.GetType()}.", nameof(contextNode)); } targets = new[] { contextNode }; }
public TryBodyState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(TryBodySyntax)) { throw new ArgumentException( $"The provided context node is not supported by {nameof(TryBodyState)}.", nameof(contextNode)); } // try statement can only have a single try block targets = new[] { contextNode }; }
public TryMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { Type mixedType = contextNode.MixedNode.GetType(); if (mixedType != typeof(TryBodySyntax) && mixedType != typeof(CatchClauseSyntax) && mixedType != typeof(FinallyClauseSyntax)) { throw new ArgumentException( $"Unsupported context node for {this.GetType()}."); } }
public ClassMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode) { Type baseNodeType = baseNode.BaseNode.GetType(); if (baseNodeType != typeof(ClassDeclarationSyntax) && baseNodeType != typeof(StructDeclarationSyntax) && baseNodeType != typeof(InterfaceDeclarationSyntax)) { throw new ArgumentException( "Only base nodes of type class, struct or interface " + "are supported by this state.", nameof(baseNode)); } }
public IfMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { Type mixedType = contextNode.MixedNode.GetType(); if (mixedType != typeof(IfConditionSyntax) && mixedType != typeof(IfBodySyntax) && mixedType != typeof(ElseClauseSyntax) && mixedType != typeof(ElseBodySyntax)) { throw new ArgumentException( $"Unsupported context node for {this.GetType()}."); } }
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode baseNode) { CombinedSyntaxNode[] members = baseNode.BaseNode.ChildNodes() .Where(x => x is BlockSyntax || x is FinallyClauseSyntax || x is CatchClauseSyntax) .GroupBy(x => x.Kind()) .Select(x => x.First()) .QueryVirtualAndCombine( TryBodyVirtualQuery.Instance) .ToArray(); return(members); }
protected PropOrEventClassMemberStateBase( LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { Type nodeType = contextNode.BaseNode.GetType(); if (nodeType != typeof(PropertyDeclarationSyntax) && nodeType != typeof(EventDeclarationSyntax) && nodeType != typeof(EventFieldDeclarationSyntax)) { throw new ArgumentException( "The provided node is not a base node " + $"for {nameof(PropOrEventClassMemberStateBase<T>)}"); } }
public NestedBlockState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { if (contextNode.MixedNode.GetType() != typeof(NestedBlockSyntax)) { throw new ArgumentException( $"The provided node is not of type {nameof(NestedBlockSyntax)}.", nameof(contextNode)); } if (!NestedBlockSyntaxNodeMatcher.Instance.Match(contextNode.BaseNode)) { throw new ArgumentException( "The provided base node is not a nested block", nameof(contextNode)); } }
private void PerformJumpAction(Action <CombinedSyntaxNode?> jumpAction) { _ = this.SiblingState ?? throw new NullReferenceException( "Sibling state should be initialized before jumping to a sibling."); this.SiblingState.QueryTargets(); if (!this.SiblingState.HasTargets) { return; } jumpAction(this.Context.State.ActiveNode); CombinedSyntaxNode target = this.SiblingState.Target; this.JumpToTarget(target, true); }
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root) { if (!(root.BaseNode is IfStatementSyntax ifRoot)) { throw new InvalidOperationException( $"The provided root is not {nameof(IfStatementSyntax)}."); } var members = new List <SyntaxNode>(); members.AddIfNotNull(ifRoot.Condition); members.AddIfNotNull(ifRoot.Statement); members.AddIfNotNull(ifRoot.Else); return(members.QueryVirtualAndCombine( IfConditionVirtualQuery.Instance, IfBodyVirtualQuery.Instance, ElseBodyVirtualQuery.Instance) .ToArray()); }
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root) { if (root.MixedNode is IfConditionSyntax condition) { return(new CombinedSyntaxNode[] { condition.Expression.QueryVirtualAndCombine( NestedBlockVirtualQuery.Instance) }); } return(root.BaseNode ?.ChildNodes() .QueryVirtualAndCombine(VirtualQueryExtensions.GetAllSupportedQueries()) .Where(MethodBodyMemberSyntaxNodeMatcher.Instance.Match) .GroupBy(x => x.MixedNode.GetType()) .Select(x => x.First()) .ToArray() ?? Array.Empty <CombinedSyntaxNode>()); }
public MethodBodyMemberSiblingState(CombinedSyntaxNode baseNode) : base(baseNode) { Type mixedNodeType = baseNode.MixedNode.GetType(); if (mixedNodeType != typeof(MethodBodyDeclarationSyntax) && mixedNodeType != typeof(NestedBlockSyntax) && mixedNodeType != typeof(IfConditionSyntax)) { throw new ArgumentException( "The provided node is not a method body nor a nested block. " + $"Actual node type is {mixedNodeType}."); } if (!MethodBodySyntaxNodeMatcher.Instance.Match(baseNode.BaseNode) && !baseNode.BaseNode.IsContainer()) { throw new ArgumentException( "The provided base node is not a method body.", nameof(baseNode)); } }
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode baseNode) { CombinedSyntaxNode[] members = baseNode.BaseNode.ChildNodes() .Where(ClassMemberSyntaxNodeMatcher.Instance.Match) .GroupBy(x => { SyntaxKind kind = x.Kind(); // "patch" event-field to treat it as a general event // it allows to treat them as the same sibling kind return(kind == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : kind); }) .Select(x => x.First()) .QueryVirtualAndCombine( AutoPropertyVirtualQuery.Instance, ReadOnlyPropertyVirtualQuery.Instance) .ToArray(); return(members); }
protected override CombinedSyntaxNode[] QueryTargetsProtected(CombinedSyntaxNode root) { return(Array.Empty <CombinedSyntaxNode>()); }
protected ClassMemberStateBase(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { }
public ClassDeclarationState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { }
public ForEachStatementState(LocalContext context, CombinedSyntaxNode contextNode) : base(context, contextNode) { }