pmd / pmd / 486

Committed 23 Apr 2026 06:56PM UTC coverage: 79.035% (-0.01%) from 79.047%

Build # 486

Build Type

push

github

Committed by

adangel

Commit Message

[doc] basic.xml has been gone for a long time (#6607)

Coverage Stats

18603 of 24433 branches covered (76.14%)

Branch coverage included in aggregate %.

40592 of 50464 relevant lines covered (80.44%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/pmd-core/src/main/java/net/sourceforge/pmd/lang/ast/impl/antlr4/BaseAntlrInnerNode.java

/*
 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
 */

package net.sourceforge.pmd.lang.ast.impl.antlr4;

import java.util.List;

import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.RuleContext;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeListener;
import org.antlr.v4.runtime.tree.ParseTreeVisitor;
import org.antlr.v4.runtime.tree.RuleNode;
import org.antlr.v4.runtime.tree.TerminalNode;

import net.sourceforge.pmd.lang.ast.impl.antlr4.BaseAntlrInnerNode.PmdAsAntlrInnerNode;

/**
 * Base class for the inner nodes (corresponds to {@link ParserRuleContext}).
 * Use the {@code contextSuperClass} option to set this in the antlr g4 file,
 * eg {@code options { contextSuperClass = SwiftInnerNode; }}.
 */
public abstract class BaseAntlrInnerNode<N extends AntlrNode<N>> extends BaseAntlrNode<PmdAsAntlrInnerNode<N>, N> {

    public RecognitionException exception;

    private final PmdAsAntlrInnerNode<N> antlrNode;

    protected BaseAntlrInnerNode() {
        antlrNode = new PmdAsAntlrInnerNode<>(this);
    }

    protected BaseAntlrInnerNode(ParserRuleContext parent, int invokingStateNumber) {
        antlrNode = new PmdAsAntlrInnerNode<>(this, (PmdAsAntlrInnerNode<N>) parent, invokingStateNumber);
    }

    @Override
    @SuppressWarnings("unchecked")
    public N getChild(int index) {
        if (0 <= index && index < getNumChildren()) {
            N pmdNode = (N) antlrNode.getChild(index).getPmdNode();
            assert pmdNode.getIndexInParent() == index;
            return pmdNode;
        }
        throw new IndexOutOfBoundsException("Index " + index + ", numChildren " + getNumChildren());
    }

    @Override
    public int getNumChildren() {
        return antlrNode.getChildCount();
    }

    @Override
    protected PmdAsAntlrInnerNode<N> asAntlrNode() {
        return antlrNode;
    }

    protected abstract int getRuleIndex();


    @Override
    public Token getFirstAntlrToken() {
        return asAntlrNode().start;
    }

    @Override
    public Token getLastAntlrToken() {
        return asAntlrNode().stop;
    }

    protected <T extends BaseAntlrInnerNode<N>> T getRuleContext(Class<T> klass, int idx) {
        return children(klass).get(idx);
    }

    protected <T extends BaseAntlrInnerNode<N>> List<T> getRuleContexts(Class<T> klass) {
        return children(klass).toList();
    }

    protected TerminalNode getToken(int kind, int idx) {
        @SuppressWarnings("rawtypes")
        BaseAntlrTerminalNode pmdWrapper =
            children(BaseAntlrTerminalNode.class)
                .filter(it -> it.getTokenKind() == kind)
                .get(idx);
        return pmdWrapper != null ? pmdWrapper.asAntlrNode() : null;
    }

    protected List<TerminalNode> getTokens(int kind) {
        return children(BaseAntlrTerminalNode.class)
            .filter(it -> it.getTokenKind() == kind)
            .toList(BaseAntlrTerminalNode::asAntlrNode);
    }

    protected void copyFrom(BaseAntlrInnerNode<N> other) {
        asAntlrNode().copyFrom(other.asAntlrNode());
    }


    public void enterRule(ParseTreeListener listener) {
        // default does nothing
    }


    public void exitRule(ParseTreeListener listener) {
        // default does nothing
    }

    protected static class PmdAsAntlrInnerNode<N extends AntlrNode<N>> extends ParserRuleContext implements RuleNode, BaseAntlrNode.AntlrToPmdParseTreeAdapter<N> {

        private final BaseAntlrInnerNode<N> pmdNode;

        PmdAsAntlrInnerNode(BaseAntlrInnerNode<N> node) {
            this.pmdNode = node;
        }

        PmdAsAntlrInnerNode(BaseAntlrInnerNode<N> node, PmdAsAntlrInnerNode<N> parent, int invokingStateNumber) {
            super(parent, invokingStateNumber);
            this.pmdNode = node;
        }

        @Override
        public BaseAntlrInnerNode<N> getPmdNode() {
            return pmdNode;
        }

        @Override
        @SuppressWarnings("unchecked")
        public PmdAsAntlrInnerNode<N> getParent() {
            return (PmdAsAntlrInnerNode<N>) super.getParent();
        }

        @Override
        @SuppressWarnings("unchecked")
        public AntlrToPmdParseTreeAdapter<N> getChild(int i) {
            return (AntlrToPmdParseTreeAdapter<N>) super.getChild(i);
        }

        @Override
        public <T extends ParseTree> T addAnyChild(T t) {
            assert t instanceof AntlrToPmdParseTreeAdapter;
            BaseAntlrNode<?, ?> pmdNode = ((AntlrToPmdParseTreeAdapter<?>) t).getPmdNode();
            pmdNode.setIndexInParent(getChildCount());
            return super.addAnyChild(t);
        }

        @Override
        public void setParent(RuleContext parent) {
            assert parent instanceof PmdAsAntlrInnerNode;
            super.setParent(parent);
        }

        @Override
        public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
            throw new UnsupportedOperationException("Cannot visit the underlying antlr nodes");
        }

        @Override
        public String toString() {
            // ParserRuleContext#toString() prints a list of ATN state numbers like "[441 424 315]".
            // That is hard to interpret when this adapter leaks into logs/debug views.
            // Delegate to the PMD node's toString() which we can customize per language.
            return String.valueOf(pmdNode);
        }
    }
}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.ast.impl.antlr4;
6
7	import java.util.List;
8
9	import org.antlr.v4.runtime.ParserRuleContext;
10	import org.antlr.v4.runtime.RecognitionException;
11	import org.antlr.v4.runtime.RuleContext;
12	import org.antlr.v4.runtime.Token;
13	import org.antlr.v4.runtime.tree.ParseTree;
14	import org.antlr.v4.runtime.tree.ParseTreeListener;
15	import org.antlr.v4.runtime.tree.ParseTreeVisitor;
16	import org.antlr.v4.runtime.tree.RuleNode;
17	import org.antlr.v4.runtime.tree.TerminalNode;
18
19	import net.sourceforge.pmd.lang.ast.impl.antlr4.BaseAntlrInnerNode.PmdAsAntlrInnerNode;
20
21	/**
22	* Base class for the inner nodes (corresponds to {@link ParserRuleContext}).
23	* Use the {@code contextSuperClass} option to set this in the antlr g4 file,
24	* eg {@code options { contextSuperClass = SwiftInnerNode; }}.
25	*/
26	public abstract class BaseAntlrInnerNode<N extends AntlrNode<N>> extends BaseAntlrNode<PmdAsAntlrInnerNode<N>, N> {	×
27
28	public RecognitionException exception;
29
30	private final PmdAsAntlrInnerNode<N> antlrNode;
31
32	protected BaseAntlrInnerNode() {	×
33	antlrNode = new PmdAsAntlrInnerNode<>(this);	×
34	}	×
35
36	protected BaseAntlrInnerNode(ParserRuleContext parent, int invokingStateNumber) {	×
37	antlrNode = new PmdAsAntlrInnerNode<>(this, (PmdAsAntlrInnerNode<N>) parent, invokingStateNumber);	×
38	}	×
39
40	@Override
41	@SuppressWarnings("unchecked")
42	public N getChild(int index) {
43	if (0 <= index && index < getNumChildren()) {	×
44	N pmdNode = (N) antlrNode.getChild(index).getPmdNode();	×
45	assert pmdNode.getIndexInParent() == index;	×
46	return pmdNode;	×
47	}
48	throw new IndexOutOfBoundsException("Index " + index + ", numChildren " + getNumChildren());	×
49	}
50
51	@Override
52	public int getNumChildren() {
53	return antlrNode.getChildCount();	×
54	}
55
56	@Override
57	protected PmdAsAntlrInnerNode<N> asAntlrNode() {
58	return antlrNode;	×
59	}
60
61	protected abstract int getRuleIndex();
62
63
64	@Override
65	public Token getFirstAntlrToken() {
66	return asAntlrNode().start;	×
67	}
68
69	@Override
70	public Token getLastAntlrToken() {
71	return asAntlrNode().stop;	×
72	}
73
74	protected <T extends BaseAntlrInnerNode<N>> T getRuleContext(Class<T> klass, int idx) {
75	return children(klass).get(idx);	×
76	}
77
78	protected <T extends BaseAntlrInnerNode<N>> List<T> getRuleContexts(Class<T> klass) {
79	return children(klass).toList();	×
80	}
81
82	protected TerminalNode getToken(int kind, int idx) {
83	@SuppressWarnings("rawtypes")
84	BaseAntlrTerminalNode pmdWrapper =	×
85	children(BaseAntlrTerminalNode.class)	×
86	.filter(it -> it.getTokenKind() == kind)	×
87	.get(idx);	×
88	return pmdWrapper != null ? pmdWrapper.asAntlrNode() : null;	×
89	}
90
91	protected List<TerminalNode> getTokens(int kind) {
92	return children(BaseAntlrTerminalNode.class)	×
93	.filter(it -> it.getTokenKind() == kind)	×
94	.toList(BaseAntlrTerminalNode::asAntlrNode);	×
95	}
96
97	protected void copyFrom(BaseAntlrInnerNode<N> other) {
98	asAntlrNode().copyFrom(other.asAntlrNode());	×
99	}	×
100
101
102	public void enterRule(ParseTreeListener listener) {
103	// default does nothing
104	}	×
105
106
107	public void exitRule(ParseTreeListener listener) {
108	// default does nothing
109	}	×
110
111	protected static class PmdAsAntlrInnerNode<N extends AntlrNode<N>> extends ParserRuleContext implements RuleNode, BaseAntlrNode.AntlrToPmdParseTreeAdapter<N> {	×
112
113	private final BaseAntlrInnerNode<N> pmdNode;
114
115	PmdAsAntlrInnerNode(BaseAntlrInnerNode<N> node) {	×
116	this.pmdNode = node;	×
117	}	×
118
119	PmdAsAntlrInnerNode(BaseAntlrInnerNode<N> node, PmdAsAntlrInnerNode<N> parent, int invokingStateNumber) {
120	super(parent, invokingStateNumber);	×
121	this.pmdNode = node;	×
122	}	×
123
124	@Override
125	public BaseAntlrInnerNode<N> getPmdNode() {
126	return pmdNode;	×
127	}
128
129	@Override
130	@SuppressWarnings("unchecked")
131	public PmdAsAntlrInnerNode<N> getParent() {
132	return (PmdAsAntlrInnerNode<N>) super.getParent();	×
133	}
134
135	@Override
136	@SuppressWarnings("unchecked")
137	public AntlrToPmdParseTreeAdapter<N> getChild(int i) {
138	return (AntlrToPmdParseTreeAdapter<N>) super.getChild(i);	×
139	}
140
141	@Override
142	public <T extends ParseTree> T addAnyChild(T t) {
143	assert t instanceof AntlrToPmdParseTreeAdapter;	×
144	BaseAntlrNode<?, ?> pmdNode = ((AntlrToPmdParseTreeAdapter<?>) t).getPmdNode();	×
145	pmdNode.setIndexInParent(getChildCount());	×
146	return super.addAnyChild(t);	×
147	}
148
149	@Override
150	public void setParent(RuleContext parent) {
151	assert parent instanceof PmdAsAntlrInnerNode;	×
152	super.setParent(parent);	×
153	}	×
154
155	@Override
156	public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
157	throw new UnsupportedOperationException("Cannot visit the underlying antlr nodes");	×
158	}
159
160	@Override
161	public String toString() {
162	// ParserRuleContext#toString() prints a list of ATN state numbers like "[441 424 315]".
163	// That is hard to interpret when this adapter leaks into logs/debug views.
164	// Delegate to the PMD node's toString() which we can customize per language.
165	return String.valueOf(pmdNode);	×
166	}
167	}
168	}

pmd / pmd / 486

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous