#3786

pending completion

Build # #3786

Build Type

push

github actions

Committed by

web-flow

Commit Message

Merge pull request #4370 from Monits/rule-improvements

[java] Rule improvements

Run Details

5 of 5 new or added lines in 2 files covered. (100.0%)

67060 of 127680 relevant lines covered (52.52%)

0.53 hits per line

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

90.91

/pmd-core/src/main/java/net/sourceforge/pmd/lang/rule/internal/RuleApplicator.java

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

package net.sourceforge.pmd.lang.rule.internal;

import java.util.Collection;
import java.util.Iterator;

import org.apache.commons.lang3.exception.ExceptionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.sourceforge.pmd.Report.ProcessingError;
import net.sourceforge.pmd.Rule;
import net.sourceforge.pmd.RuleContext;
import net.sourceforge.pmd.RuleSet;
import net.sourceforge.pmd.benchmark.TimeTracker;
import net.sourceforge.pmd.benchmark.TimedOperation;
import net.sourceforge.pmd.benchmark.TimedOperationCategory;
import net.sourceforge.pmd.internal.SystemProps;
import net.sourceforge.pmd.lang.LanguageVersion;
import net.sourceforge.pmd.lang.ast.Node;
import net.sourceforge.pmd.lang.ast.RootNode;
import net.sourceforge.pmd.reporting.FileAnalysisListener;
import net.sourceforge.pmd.util.AssertionUtil;
import net.sourceforge.pmd.util.StringUtil;

/** Applies a set of rules to a set of ASTs. */
public class RuleApplicator {

    private static final Logger LOG = LoggerFactory.getLogger(RuleApplicator.class);
    // we reuse the type lattice from run to run, eventually it converges
    // towards the final topology (all node types have been encountered)
    // This has excellent performance! Indexing time is insignificant
    // compared to rule application for any non-trivial ruleset. Even
    // when you use a single rule, indexing time is insignificant compared
    // to eg type resolution.

    private final TreeIndex idx;
    private LanguageVersion currentLangVer;

    public RuleApplicator(TreeIndex index) {
        this.idx = index;
    }


    public void index(RootNode root) {
        idx.reset();
        indexTree(root, idx);
        currentLangVer = root.getLanguageVersion();
    }

    public void apply(Collection<? extends Rule> rules, FileAnalysisListener listener) {
        applyOnIndex(idx, rules, listener);
    }

    private void applyOnIndex(TreeIndex idx, Collection<? extends Rule> rules, FileAnalysisListener listener) {
        for (Rule rule : rules) {
            if (!RuleSet.applies(rule, currentLangVer)) {
                continue; // No point in even trying to apply the rule
            }
            
            RuleContext ctx = RuleContext.create(listener, rule);
            rule.start(ctx);
            try (TimedOperation rcto = TimeTracker.startOperation(TimedOperationCategory.RULE, rule.getName())) {

                int nodeCounter = 0;
                Iterator<? extends Node> targets = rule.getTargetSelector().getVisitedNodes(idx);
                while (targets.hasNext()) {
                    Node node = targets.next();

                    try {
                        nodeCounter++;
                        rule.apply(node, ctx);
                    } catch (RuntimeException e) {
                        reportOrRethrow(listener, rule, node, AssertionUtil.contexted(e), true);
                    } catch (StackOverflowError e) {
                        reportOrRethrow(listener, rule, node, AssertionUtil.contexted(e), SystemProps.isErrorRecoveryMode());
                    } catch (AssertionError e) {
                        reportOrRethrow(listener, rule, node, AssertionUtil.contexted(e), SystemProps.isErrorRecoveryMode());
                    }
                }
                
                rcto.close(nodeCounter);
            } finally {
                rule.end(ctx);
            }
        }
    }


    private <E extends Throwable> void reportOrRethrow(FileAnalysisListener listener, Rule rule, Node node, E e, boolean reportAndDontThrow) throws E {
        if (e instanceof ExceptionContext) {
            ((ExceptionContext) e).addContextValue("Rule applied on node", node);
        }

        if (reportAndDontThrow) {
            reportException(listener, rule, node, e);
        } else {
            throw e;
        }
    }


    private void reportException(FileAnalysisListener listener, Rule rule, Node node, Throwable e) {
        // The listener handles logging if needed,
        // it may also rethrow the error.
        listener.onError(new ProcessingError(e, node.getTextDocument().getDisplayName()));

        // fixme - maybe duplicated logging
        LOG.warn("Exception applying rule {} on file {}, continuing with next rule", rule.getName(), node.getTextDocument().getPathId(), e);
        String nodeToString = StringUtil.elide(node.toString(), 600, " ... (truncated)");
        LOG.warn("Exception occurred on node {}", nodeToString);
    }


    private void indexTree(Node top, TreeIndex idx) {
        idx.indexNode(top);
        for (Node child : top.children()) {
            indexTree(child, idx);
        }
    }

    public static RuleApplicator build(Iterable<? extends Rule> rules) {
        TargetSelectorInternal.ApplicatorBuilder builder = new TargetSelectorInternal.ApplicatorBuilder();
        for (Rule it : rules) {
            it.getTargetSelector().prepare(builder);
        }
        return builder.build();
    }

}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.rule.internal;
6
7	import java.util.Collection;
8	import java.util.Iterator;
9
10	import org.apache.commons.lang3.exception.ExceptionContext;
11	import org.slf4j.Logger;
12	import org.slf4j.LoggerFactory;
13
14	import net.sourceforge.pmd.Report.ProcessingError;
15	import net.sourceforge.pmd.Rule;
16	import net.sourceforge.pmd.RuleContext;
17	import net.sourceforge.pmd.RuleSet;
18	import net.sourceforge.pmd.benchmark.TimeTracker;
19	import net.sourceforge.pmd.benchmark.TimedOperation;
20	import net.sourceforge.pmd.benchmark.TimedOperationCategory;
21	import net.sourceforge.pmd.internal.SystemProps;
22	import net.sourceforge.pmd.lang.LanguageVersion;
23	import net.sourceforge.pmd.lang.ast.Node;
24	import net.sourceforge.pmd.lang.ast.RootNode;
25	import net.sourceforge.pmd.reporting.FileAnalysisListener;
26	import net.sourceforge.pmd.util.AssertionUtil;
27	import net.sourceforge.pmd.util.StringUtil;
28
29	/** Applies a set of rules to a set of ASTs. */
30	public class RuleApplicator {
31
32	private static final Logger LOG = LoggerFactory.getLogger(RuleApplicator.class);	1✔
33	// we reuse the type lattice from run to run, eventually it converges
34	// towards the final topology (all node types have been encountered)
35	// This has excellent performance! Indexing time is insignificant
36	// compared to rule application for any non-trivial ruleset. Even
37	// when you use a single rule, indexing time is insignificant compared
38	// to eg type resolution.
39
40	private final TreeIndex idx;
41	private LanguageVersion currentLangVer;
42
43	public RuleApplicator(TreeIndex index) {	1✔
44	this.idx = index;	1✔
45	}	1✔
46
47
48	public void index(RootNode root) {
49	idx.reset();	1✔
50	indexTree(root, idx);	1✔
51	currentLangVer = root.getLanguageVersion();	1✔
52	}	1✔
53
54	public void apply(Collection<? extends Rule> rules, FileAnalysisListener listener) {
55	applyOnIndex(idx, rules, listener);	1✔
56	}	1✔
57
58	private void applyOnIndex(TreeIndex idx, Collection<? extends Rule> rules, FileAnalysisListener listener) {
59	for (Rule rule : rules) {	1✔
60	if (!RuleSet.applies(rule, currentLangVer)) {	1✔
61	continue; // No point in even trying to apply the rule	×
62	}
63
64	RuleContext ctx = RuleContext.create(listener, rule);	1✔
65	rule.start(ctx);	1✔
66	try (TimedOperation rcto = TimeTracker.startOperation(TimedOperationCategory.RULE, rule.getName())) {	1✔
67
68	int nodeCounter = 0;	1✔
69	Iterator<? extends Node> targets = rule.getTargetSelector().getVisitedNodes(idx);	1✔
70	while (targets.hasNext()) {	1✔
71	Node node = targets.next();	1✔
72
73	try {
74	nodeCounter++;	1✔
75	rule.apply(node, ctx);	1✔
76	} catch (RuntimeException e) {	1✔
77	reportOrRethrow(listener, rule, node, AssertionUtil.contexted(e), true);	1✔
78	} catch (StackOverflowError e) {	×
79	reportOrRethrow(listener, rule, node, AssertionUtil.contexted(e), SystemProps.isErrorRecoveryMode());	×
80	} catch (AssertionError e) {	1✔
81	reportOrRethrow(listener, rule, node, AssertionUtil.contexted(e), SystemProps.isErrorRecoveryMode());	1✔
82	}	1✔
83	}	1✔
84
85	rcto.close(nodeCounter);	1✔
86	} finally {
87	rule.end(ctx);	1✔
88	}
89	}	1✔
90	}	1✔
91
92
93	private <E extends Throwable> void reportOrRethrow(FileAnalysisListener listener, Rule rule, Node node, E e, boolean reportAndDontThrow) throws E {
94	if (e instanceof ExceptionContext) {	1✔
95	((ExceptionContext) e).addContextValue("Rule applied on node", node);	1✔
96	}
97
98	if (reportAndDontThrow) {	1✔
99	reportException(listener, rule, node, e);	1✔
100	} else {
101	throw e;	1✔
102	}
103	}	1✔
104
105
106	private void reportException(FileAnalysisListener listener, Rule rule, Node node, Throwable e) {
107	// The listener handles logging if needed,
108	// it may also rethrow the error.
109	listener.onError(new ProcessingError(e, node.getTextDocument().getDisplayName()));	1✔
110
111	// fixme - maybe duplicated logging
112	LOG.warn("Exception applying rule {} on file {}, continuing with next rule", rule.getName(), node.getTextDocument().getPathId(), e);	1✔
113	String nodeToString = StringUtil.elide(node.toString(), 600, " ... (truncated)");	1✔
114	LOG.warn("Exception occurred on node {}", nodeToString);	1✔
115	}	1✔
116
117
118	private void indexTree(Node top, TreeIndex idx) {
119	idx.indexNode(top);	1✔
120	for (Node child : top.children()) {	1✔
121	indexTree(child, idx);	×
122	}	×
123	}	1✔
124
125	public static RuleApplicator build(Iterable<? extends Rule> rules) {
126	TargetSelectorInternal.ApplicatorBuilder builder = new TargetSelectorInternal.ApplicatorBuilder();	1✔
127	for (Rule it : rules) {	1✔
128	it.getTargetSelector().prepare(builder);	1✔
129	}	1✔
130	return builder.build();	1✔
131	}
132
133	}

pmd / pmd / #3786

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