pmd / pmd / 43

Committed 20 Jun 2025 06:39PM UTC coverage: 78.375% (-0.002%) from 78.377%

Build # 43

Build Type

push

github

Committed by

adangel

Commit Message

Fix #1639 #5832: Use filtered comment text for UnnecessaryImport (#5833)

Merged pull request #5833 from adangel:java/issue-5832-unnecessaryimport

Run Details

17714 of 23438 branches covered (75.58%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

109 existing lines in 17 files now uncovered.

38908 of 48807 relevant lines covered (79.72%)

0.81 hits per line

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

0.0

/pmd-plsql/src/main/java/net/sourceforge/pmd/lang/plsql/symboltable/TypeSet.java

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

package net.sourceforge.pmd.lang.plsql.symboltable;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Keeps track of the types encountered in a ASTinput
 */
public class TypeSet {

    /**
     * TODO should Resolver provide a canResolve() and a resolve()? Requiring 2
     * calls seems clunky... but so does this throwing an exception for flow
     * control...
     */
    public interface Resolver {
        Class<?> resolve(String name) throws ClassNotFoundException;
    }

    public static class ExplicitImportResolver implements Resolver {
        private Set<String> importStmts;

        public ExplicitImportResolver(Set<String> importStmts) {
            this.importStmts = importStmts;
        }

        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            for (String importStmt : importStmts) {
                if (importStmt.endsWith(name)) {
                    return Class.forName(importStmt);
                }
            }
            throw new ClassNotFoundException("Type " + name + " not found");
        }
    }

    public static class CurrentPackageResolver implements Resolver {
        private String pkg;

        public CurrentPackageResolver(String pkg) {
            this.pkg = pkg;
        }

        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            return Class.forName(pkg + name);
        }
    }

    // TODO cite the JLS section on implicit imports
    public static class ImplicitImportResolver implements Resolver {
        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            return Class.forName("java.lang." + name);
        }
    }

    public static class ImportOnDemandResolver implements Resolver {
        private Set<String> importStmts;

        public ImportOnDemandResolver(Set<String> importStmts) {
            this.importStmts = importStmts;
        }

        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            for (String importStmt : importStmts) {
                if (importStmt.endsWith("*")) {
                    try {
                        String importPkg = importStmt.substring(0, importStmt.indexOf('*') - 1);
                        return Class.forName(importPkg + '.' + name);
                    } catch (ClassNotFoundException ignored) {
                        // Ignored, we'll throw a custom exception later, after all import possibilities have
                        // been checked
                    }
                }
            }
            throw new ClassNotFoundException("Type " + name + " not found");
        }
    }

    public static class PrimitiveTypeResolver implements Resolver {
        private Map<String, Class<?>> primitiveTypes = new HashMap<>();

        public PrimitiveTypeResolver() {
            primitiveTypes.put("int", int.class);
            primitiveTypes.put("float", float.class);
            primitiveTypes.put("double", double.class);
            primitiveTypes.put("long", long.class);
            primitiveTypes.put("boolean", boolean.class);
            primitiveTypes.put("byte", byte.class);
            primitiveTypes.put("short", short.class);
            primitiveTypes.put("char", char.class);
        }

        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            if (!primitiveTypes.containsKey(name)) {
                throw new ClassNotFoundException();
            }
            return primitiveTypes.get(name);
        }
    }

    public static class VoidResolver implements Resolver {
        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            if ("void".equals(name)) {
                return void.class;
            }
            throw new ClassNotFoundException();
        }
    }

    public static class FullyQualifiedNameResolver implements Resolver {
        @Override
        public Class<?> resolve(String name) throws ClassNotFoundException {
            return Class.forName(name);
        }
    }

    private String pkg;
    private Set<String> imports = new HashSet<>();
    private List<Resolver> resolvers = new ArrayList<>();

    public void setASTinputPackage(String pkg) {
        this.pkg = pkg;
    }

    public String getASTinputPackage() {
        return pkg;
    }

    public void addImport(String importString) {
        imports.add(importString);
    }

    public int getImportsCount() {
        return imports.size();
    }

    public Class<?> findClass(String name) throws ClassNotFoundException {
        // we don't build the resolvers until now since we first want to get all
        // the imports
        if (resolvers.isEmpty()) {
            buildResolvers();
        }

        for (Resolver resolver : resolvers) {
            try {
                return resolver.resolve(name);
            } catch (ClassNotFoundException ignored) {
                // Ignored, maybe another resolver might find the class
            }
        }

        throw new ClassNotFoundException("Type " + name + " not found");
    }

    private void buildResolvers() {
        resolvers.add(new PrimitiveTypeResolver());
        resolvers.add(new VoidResolver());
        resolvers.add(new ExplicitImportResolver(imports));
        resolvers.add(new CurrentPackageResolver(pkg));
        resolvers.add(new ImplicitImportResolver());
        resolvers.add(new ImportOnDemandResolver(imports));
        resolvers.add(new FullyQualifiedNameResolver());
    }

}

1	/**
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.plsql.symboltable;
6
7	import java.util.ArrayList;
8	import java.util.HashMap;
9	import java.util.HashSet;
10	import java.util.List;
11	import java.util.Map;
12	import java.util.Set;
13
14	/**
15	* Keeps track of the types encountered in a ASTinput
16	*/
17	public class TypeSet {	×
18
19	/**
20	* TODO should Resolver provide a canResolve() and a resolve()? Requiring 2
21	* calls seems clunky... but so does this throwing an exception for flow
22	* control...
23	*/
24	public interface Resolver {
25	Class<?> resolve(String name) throws ClassNotFoundException;
26	}
27
28	public static class ExplicitImportResolver implements Resolver {
29	private Set<String> importStmts;
30
31	public ExplicitImportResolver(Set<String> importStmts) {	×
32	this.importStmts = importStmts;	×
33	}	×
34
35	@Override
36	public Class<?> resolve(String name) throws ClassNotFoundException {
37	for (String importStmt : importStmts) {	×
38	if (importStmt.endsWith(name)) {	×
39	return Class.forName(importStmt);	×
40	}
41	}	×
42	throw new ClassNotFoundException("Type " + name + " not found");	×
43	}
44	}
45
46	public static class CurrentPackageResolver implements Resolver {
47	private String pkg;
48
49	public CurrentPackageResolver(String pkg) {	×
50	this.pkg = pkg;	×
51	}	×
52
53	@Override
54	public Class<?> resolve(String name) throws ClassNotFoundException {
55	return Class.forName(pkg + name);	×
56	}
57	}
58
59	// TODO cite the JLS section on implicit imports
60	public static class ImplicitImportResolver implements Resolver {	×
61	@Override
62	public Class<?> resolve(String name) throws ClassNotFoundException {
63	return Class.forName("java.lang." + name);	×
64	}
65	}
66
67	public static class ImportOnDemandResolver implements Resolver {
68	private Set<String> importStmts;
69
70	public ImportOnDemandResolver(Set<String> importStmts) {	×
71	this.importStmts = importStmts;	×
72	}	×
73
74	@Override
75	public Class<?> resolve(String name) throws ClassNotFoundException {
76	for (String importStmt : importStmts) {	×
77	if (importStmt.endsWith("*")) {	×
78	try {
79	String importPkg = importStmt.substring(0, importStmt.indexOf('*') - 1);	×
80	return Class.forName(importPkg + '.' + name);	×
81	} catch (ClassNotFoundException ignored) {	×
82	// Ignored, we'll throw a custom exception later, after all import possibilities have
83	// been checked
84	}
85	}
86	}	×
87	throw new ClassNotFoundException("Type " + name + " not found");	×
88	}
89	}
90
91	public static class PrimitiveTypeResolver implements Resolver {
92	private Map<String, Class<?>> primitiveTypes = new HashMap<>();	×
93
UNCOV 94	public PrimitiveTypeResolver() {	×
95	primitiveTypes.put("int", int.class);	×
96	primitiveTypes.put("float", float.class);	×
97	primitiveTypes.put("double", double.class);	×
98	primitiveTypes.put("long", long.class);	×
99	primitiveTypes.put("boolean", boolean.class);	×
100	primitiveTypes.put("byte", byte.class);	×
101	primitiveTypes.put("short", short.class);	×
102	primitiveTypes.put("char", char.class);	×
103	}	×
104
105	@Override
106	public Class<?> resolve(String name) throws ClassNotFoundException {
UNCOV 107	if (!primitiveTypes.containsKey(name)) {	×
108	throw new ClassNotFoundException();	×
109	}
UNCOV 110	return primitiveTypes.get(name);	×
111	}
112	}
113
UNCOV 114	public static class VoidResolver implements Resolver {	×
115	@Override
116	public Class<?> resolve(String name) throws ClassNotFoundException {
UNCOV 117	if ("void".equals(name)) {	×
118	return void.class;	×
119	}
UNCOV 120	throw new ClassNotFoundException();	×
121	}
122	}
123
UNCOV 124	public static class FullyQualifiedNameResolver implements Resolver {	×
125	@Override
126	public Class<?> resolve(String name) throws ClassNotFoundException {
UNCOV 127	return Class.forName(name);	×
128	}
129	}
130
131	private String pkg;
UNCOV 132	private Set<String> imports = new HashSet<>();	×
133	private List<Resolver> resolvers = new ArrayList<>();	×
134
135	public void setASTinputPackage(String pkg) {
UNCOV 136	this.pkg = pkg;	×
137	}	×
138
139	public String getASTinputPackage() {
UNCOV 140	return pkg;	×
141	}
142
143	public void addImport(String importString) {
UNCOV 144	imports.add(importString);	×
145	}	×
146
147	public int getImportsCount() {
UNCOV 148	return imports.size();	×
149	}
150
151	public Class<?> findClass(String name) throws ClassNotFoundException {
152	// we don't build the resolvers until now since we first want to get all
153	// the imports
UNCOV 154	if (resolvers.isEmpty()) {	×
155	buildResolvers();	×
156	}
157
UNCOV 158	for (Resolver resolver : resolvers) {	×
159	try {
UNCOV 160	return resolver.resolve(name);	×
161	} catch (ClassNotFoundException ignored) {	×
162	// Ignored, maybe another resolver might find the class
163	}
UNCOV 164	}	×
165
UNCOV 166	throw new ClassNotFoundException("Type " + name + " not found");	×
167	}
168
169	private void buildResolvers() {
UNCOV 170	resolvers.add(new PrimitiveTypeResolver());	×
171	resolvers.add(new VoidResolver());	×
172	resolvers.add(new ExplicitImportResolver(imports));	×
173	resolvers.add(new CurrentPackageResolver(pkg));	×
174	resolvers.add(new ImplicitImportResolver());	×
175	resolvers.add(new ImportOnDemandResolver(imports));	×
176	resolvers.add(new FullyQualifiedNameResolver());	×
177	}	×
178
179	}

pmd / pmd / 43

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