#3961

Committed 11 Mar 2024 01:52AM UTC coverage: 48.66% (+0.001%) from 48.659%

Build # #3961

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4834 from adangel/issue-4757-npe

[java] Fix intermittent NPE ClassSub.enclosingInfo is null

Run Details

32364 of 72818 branches covered (44.45%)

Branch coverage included in aggregate %.

3 of 4 new or added lines in 3 files covered. (75.0%)

1 existing line in 1 file now uncovered.

68096 of 133637 relevant lines covered (50.96%)

0.51 hits per line

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

81.67

/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/symbols/internal/asm/ParseLock.java

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

package net.sourceforge.pmd.lang.java.symbols.internal.asm;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A simple double-checked initializer, that parses something (a class,
 * or a type signature).
 */
@SuppressWarnings({"PMD.AvoidUsingVolatile", "PMD.AvoidCatchingThrowable"})
abstract class ParseLock {

    private static final Logger LOG = LoggerFactory.getLogger(ParseLock.class);

    private volatile ParseStatus status = ParseStatus.NOT_PARSED;

    public void ensureParsed() {
        getFinalStatus();
    }

    private ParseStatus getFinalStatus() {
        ParseStatus status = this.status;
        if (!status.isFinished) {
            synchronized (this) {
                status = this.status;
                if (status == ParseStatus.NOT_PARSED) {
                    this.status = ParseStatus.BEING_PARSED;
                    try {
                        boolean success = doParse();
                        status = success ? ParseStatus.FULL : ParseStatus.FAILED;
                        finishParse(!success);
                    } catch (Throwable t) {
                        status = ParseStatus.FAILED;
                        LOG.error("Parsing failed in ParseLock#doParse()", t);
                        finishParse(true);
                    }

                    // the status must be updated as last statement, so that
                    // other threads see the status FULL or FAILED only after finishParse()
                    // returns. Otherwise, some fields might not have been initialized.
                    //
                    // Note: the current thread might reenter the parsing logic through
                    // finishParse() -> ... -> ensureParsed(). In that case the status is still BEING_PARSED,
                    // and we don't call finishParse() again. See below for canReenter()
                    this.status = status;

                    assert status.isFinished : "Inconsistent status " + status;
                    assert postCondition() : "Post condition not satisfied after parsing sig " + this;
                } else if (status == ParseStatus.BEING_PARSED && !canReenter()) {
                    throw new IllegalStateException("Thread is reentering the parse lock");
                }
            }
        }
        return status;
    }

    protected boolean canReenter() {
        return false;
    }

    public boolean isFailed() {
        return getFinalStatus() == ParseStatus.FAILED;
    }

    public boolean isNotParsed() {
        return status == ParseStatus.NOT_PARSED;
    }

    // will be called in the critical section after parse is done
    protected void finishParse(boolean failed) {
        // by default do nothing
    }

    /** Returns true if parse is successful. */
    protected abstract boolean doParse() throws Throwable; // SUPPRESS CHECKSTYLE IllegalThrows

    /** Checked by an assert after parse. */
    protected boolean postCondition() {
        return true;
    }

    @Override
    public String toString() {
        return "ParseLock{status=" + status + '}';
    }

    private enum ParseStatus {
        NOT_PARSED(false),
        BEING_PARSED(false),
        FULL(true),
        FAILED(true);

        final boolean isFinished;

        ParseStatus(boolean finished) {
            this.isFinished = finished;
        }
    }
}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.java.symbols.internal.asm;
6
7	import org.slf4j.Logger;
8	import org.slf4j.LoggerFactory;
9
10	/**
11	* A simple double-checked initializer, that parses something (a class,
12	* or a type signature).
13	*/
14	@SuppressWarnings({"PMD.AvoidUsingVolatile", "PMD.AvoidCatchingThrowable"})
15	abstract class ParseLock {	1✔
16
17	private static final Logger LOG = LoggerFactory.getLogger(ParseLock.class);	1✔
18
19	private volatile ParseStatus status = ParseStatus.NOT_PARSED;	1✔
20
21	public void ensureParsed() {
22	getFinalStatus();	1✔
23	}	1✔
24
25	private ParseStatus getFinalStatus() {
26	ParseStatus status = this.status;	1✔
27	if (!status.isFinished) {	1✔
28	synchronized (this) {	1✔
29	status = this.status;	1✔
30	if (status == ParseStatus.NOT_PARSED) {	1✔
31	this.status = ParseStatus.BEING_PARSED;	1✔
32	try {
33	boolean success = doParse();	1✔
34	status = success ? ParseStatus.FULL : ParseStatus.FAILED;	1✔
35	finishParse(!success);	1✔
UNCOV 36	} catch (Throwable t) {	×
37	status = ParseStatus.FAILED;	×
NEW 38	LOG.error("Parsing failed in ParseLock#doParse()", t);	×
39	finishParse(true);	×
40	}	1✔
41
42	// the status must be updated as last statement, so that
43	// other threads see the status FULL or FAILED only after finishParse()
44	// returns. Otherwise, some fields might not have been initialized.
45	//
46	// Note: the current thread might reenter the parsing logic through
47	// finishParse() -> ... -> ensureParsed(). In that case the status is still BEING_PARSED,
48	// and we don't call finishParse() again. See below for canReenter()
49	this.status = status;	1✔
50
51	assert status.isFinished : "Inconsistent status " + status;	1!
52	assert postCondition() : "Post condition not satisfied after parsing sig " + this;	1!
53	} else if (status == ParseStatus.BEING_PARSED && !canReenter()) {	1!
54	throw new IllegalStateException("Thread is reentering the parse lock");	×
55	}
56	}	1✔
57	}
58	return status;	1✔
59	}
60
61	protected boolean canReenter() {
62	return false;	×
63	}
64
65	public boolean isFailed() {
66	return getFinalStatus() == ParseStatus.FAILED;	1✔
67	}
68
69	public boolean isNotParsed() {
70	return status == ParseStatus.NOT_PARSED;	1✔
71	}
72
73	// will be called in the critical section after parse is done
74	protected void finishParse(boolean failed) {
75	// by default do nothing
76	}	1✔
77
78	/** Returns true if parse is successful. */
79	protected abstract boolean doParse() throws Throwable; // SUPPRESS CHECKSTYLE IllegalThrows
80
81	/** Checked by an assert after parse. */
82	protected boolean postCondition() {
83	return true;	×
84	}
85
86	@Override
87	public String toString() {
88	return "ParseLock{status=" + status + '}';	×
89	}
90
91	private enum ParseStatus {	1✔
92	NOT_PARSED(false),	1✔
93	BEING_PARSED(false),	1✔
94	FULL(true),	1✔
95	FAILED(true);	1✔
96
97	final boolean isFinished;
98
99	ParseStatus(boolean finished) {	1✔
100	this.isFinished = finished;	1✔
101	}	1✔
102	}
103	}

pmd / pmd / #3961

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