An application to analyze a directory of Java code, reporting on all unneeded/redundant import statements. It detects imports that are not used, duplicate import statements, and also needless self-referencing star ('.*;') imports.
Source code: ReportBadImports.java.
This application does the same thing as PMD's rulesets/imports.xml ruleset, but has more specific error messages.
This application uses string analysis only, no reflection is involved. Specifically, it searches for the last word in each specific import statement ('AssertException' is the last word in 'import xbn.AssertException;'), to see that it exists elsewhere in the code (ignoring comments). It can tell the difference between 'MyAssertException' and 'AssertException'.
'.*;' import statements (star imports, the opposite of specific imports) are also analyzed for duplicates, and also that the package it is importing is one other than the package in which the containing class exists.
This application will only work (as expected!) on Java code that can be successfully compiled.
Although the compiler knows that // contained in a string is not the beginning of a comment, you must denote this with
'/' + '/'
and not
'//'
The same is true with the multi-line comment delimiter:
'/' + '*' and '*' + '/'
instead of
'/*' and '*/'
Why? Because I don't want to have to write complicated string parsing, which can tell the difference between true comment delimiters, and those existing inside strings. :' )
Key:
import java.what.Ever; is a sub-import of import java.what.*;. Import statements that are sub-imports should be deleted.Precedence: Duplicate state is always reported. Self-referencing trumps unneeded, and unneeded trumps sub-import. When one error type trumps another, the trumped error condition is not analyzed, and therefore unknown (denoted by a ?).
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||
Adding these import statements into VWChar (right below existing import statements), and then running this application (or PMD) against it, will result in every possible error. There is no need to compile the code.
//To test xbn.programs.ReportBadImports...START
import xbn.array.*;
import xbn.array.*;
import xbn.array.UNNEEDED_and_SUB_IMPORT_and_SELF_REFERENCE;
import xbn.array.UNNEEDED_and_SUB_IMPORT_and_SELF_REFERENCE_and_DUPLICATE;
import xbn.array.UNNEEDED_and_SUB_IMPORT_and_SELF_REFERENCE_and_DUPLICATE;
import java.util.UNNEEDED;
//Duplicate, because of the actual import statement above
//this testing section.
import java.util.Arrays;
import java.util.UNNEEDED_and_DUPLICATE;
import java.util.UNNEEDED_and_DUPLICATE;
//No errors.
import java.bla.*;
import java.bla.UNNEEDED_and_SUB_IMPORT;
import java.bla.UNNEEDED_and_SUB_IMPORT_and_DUPLICATE;
import java.bla.UNNEEDED_and_SUB_IMPORT_and_DUPLICATE;
//To test xbn.programs.ReportBadImports...END
Create a ReportBadImports. This constructor does nothing.
**/ public ReportBadImports() { } /**Run the application.
**/ public final static void main(String[] as_cmdLineParams) { sopl("ReportBadImports...START"); //Prepare for testing and get command line parameters...START opts.addOption(optDirToAnalyze); opts.addOption(optOutputFile); opts.addOption(optSubDirLvls); UtilCommandLine ucl = new UtilCommandLine(opts, 80, "xbn.programs.ReportBadImports", null, "\nFor documentation on the meaning of the reported error codes, see the JavaDoc for xbn.programs.ReportBadImports.", true); CommandLine cl = ucl.getCommandLine(as_cmdLineParams); Outputter optr = ucl.getOSDOOrOSDOAndFile("outfile", false); String sDir = cl.getOptionValue("dir2nlz"); int iSubDirLevels = ucl.getInt("subdirlvls", -1); //Prepare for testing and get command line parameters...END DirFile df = new DirFile(sDir, iSubDirLevels, (new FFJava()), optr); optr.write("------------------\nListing all files\n------------------"); optr.write(df.toString()); analyzeFiles(optr, df); optr.write("\n------------------\nSTART REPORT (" + iErrors + " errors, " + iValid + " valid)\n------------------\n" + sbErrors.toString() + "\n------------------\nEND REPORT (" + iErrors + " errors, " + iValid + " valid)\n------------------\n"); if(cl.hasOption("outfile")) { optr.write("\n\nOutput written to '" + ((OWFile)optr.getOWriter()).getPath() + "'"); } optr.write("(For the meanings of error codes, see the JavaDoc for xbn.programs.ReportBadImports)\n\nReportBadImports...END"); } private static void analyzeFiles(Outputter optr_dbg, DirFile df) { String sDebugPfx = " " + (new UtilString()).getDuped(" ", df.getLevelsBelowBaseDir()); for(int i = 0; i < df.getCountSubFiles(); i++) { File f = df.getSubFile(i).getFileObjectThis(); String sFilename = f.getName().substring(0, f.getName().length() - 5); optr_dbg.writeNoln(sDebugPfx + sFilename + " "); ssb.deleteAll(); util.appendFileText(ssb, f.getPath()); //Although the compiler knows that [slash][slash] //contained *in* a string is not the beginning of a //comment, I don't want to have to write code that //complicated, so make sure that [slash][slash] is //really only comments. util.stripSLCs(ssb, sSLASH + sSLASH); //Same with the multi-line comment delimiter. util.stripMLCs(ssb, sSLASH + sSTAR, sSTAR + sSLASH); //Trim all lines of tabs and spaces. This causes the //replaceUntil line to eliminate all empty *and* //whitespace only lines. tc.trimAllLines(ssb); //Eliminate all empty lines (except the very first and last) uSOB.replaceUntil(ssb, sLINE_SEP + sLINE_SEP, sLINE_SEP); //Eliminate empty lines at the very start and end. ssb.trim(); FLRString flrs = new FLRString(ssb.getStringBuffer()); AOSLCreator aoslc = new AOSLCreator(true, true); acjdfni.initializeVector(); JDFile jdfPackage = null; SOBStringBuffer ssbLine = null; while(flrs.hasMoreLines()) { ssbLine = new SOBStringBuffer(flrs.getNextLine()); if(ssbLine.startsWith("package")) { String sFQPackage = ssbLine.substring("package ".length(), ssbLine.length()); //Eliminate whitespace, and then the semicolon ("- 1"). sFQPackage = sFQPackage.trim(); sFQPackage = sFQPackage.substring(0, sFQPackage.length() - 1) + ".*"; jdfPackage = new JDFile(sFQPackage); //This is the first line in the file, and it is //a package statement. continue; } if(!ssbLine.startsWith("import")) { //All import statements have been retrieved. //This is the first line that does not start with //"import". break; } //This line is an import statement. //7 is the character *2* after the "t", because //there's expected to be a space or tab there. String sFQClass = ssbLine.substring(7, ssbLine.length()); //We don't know how many tabs or spaces there are //between import and the class. We are assuming //at least one, though. This also eliminates //the ending newline characters (and any other //whitespace). sFQClass = sFQClass.trim(); //Eliminate the ending semicolon sFQClass = sFQClass.substring(0, sFQClass.length() - 1); //Used exclusively so we can call //wasLastStringUnique(), below. aoslc.addString(sFQClass); JDFNImport jdfni = null; if(sFQClass.endsWith(sSTAR)) { jdfni = new JDFNIStar(sFQClass); } else { //This does not end in *, and is therefore //specific. jdfni = new JDFNISpecific(sFQClass); } if(aoslc.wasLastStringUnique()) { //This is a new import statement. acjdfni.add(jdfni); //Is this self-referencing (importing a class in //the same package as the class in which the //import statement exists)? if(jdfPackage != null && jdfPackage.isInSamePackageAs(jdfni.getJDFile())) { //It is. jdfni.declareSelfReference(); } } else { //This is a *duplicate* import statement. Find //the previous (existing) import, and mark it as //a duplicate. for(int j = 0; j < acjdfni.size(); j++) { if(acjdfni.getJDFNImport(j).getName().equals(sFQClass)) { acjdfni.getJDFNImport(j).declareDuplicate(); break; } } } } //All import statements have been retrieved. //Determine sub-imports. (Even though self-references //trump sub-imports [sub-imports are not reported when //it's a self-reference], were still analyzing if it is //a sub-import here, for diagnostic and debugging.) for(int j = 0; j < acjdfni.size(); j++) { if(acjdfni.getJDFNImport(j).isSpecific()) { //Only specific imports can be sub-import... for(int k = 0; k < acjdfni.size(); k++) { //...and they can only be sub-import with //star imports. if(acjdfni.getJDFNImport(k).isStar()) { //Okay, so is it sub-import? J is specific, K is star if(acjdfni.getJDFNISpecific(j).isInSamePackageAs(acjdfni.getJDFNIStar(k))) { //Yup. acjdfni.getJDFNISpecific(j).declareSubImport(); break; } } } } } //All sub-imports determined. //Now...determine which *specific* import statements //are actually being used in the code (below the import //statements). while(true) { //Note we're not getting the next line here, because //we still have it from the previous while. boolean bAllSpecificsFound = true; for(int j = 0; j < acjdfni.size(); j++) { if(acjdfni.getJDFNImport(j).isSpecific() && !acjdfni.getJDFNISpecific(j).wasFound()) { //This is a specific import statement, and it //was not yet found (used by the code). :' ( bAllSpecificsFound = false; //(Being found is moot for star imports.) } } if(bAllSpecificsFound) { //Every *specifically* imported class was found. //No need to analyze any more lines. break; } //At least one specific was not yet found was not yet found. for(int j = 0; j < acjdfni.size(); j++) { if(acjdfni.getJDFNImport(j).isSpecific() && !acjdfni.getJDFNISpecific(j).wasFound() && uSOB.indexOfWord(ssbLine, acjdfni.getJDFNISpecific(j).getJDFile().getFileName(), 0, ssbLine.length()) != -1) { acjdfni.getJDFNISpecific(j).declareFound(); } } if(!flrs.hasMoreLines()) { break; } //There is at least one more line. ssbLine = new SOBStringBuffer(flrs.getNextLine()); tc.trim(ssbLine); } //All potential errors have been analyzed for. /** //Debugging...START sopl(sES); int z = 0; for(; z < acjdfni.size(); z++) { sopl(acjdfni.getJDFNImport(z).getName() + " (isStar()=" + acjdfni.getJDFNImport(z).isStar() + ", isSpecific()=" + acjdfni.getJDFNImport(z).isSpecific() + ")"); sopl("\tisSelfReferencing()= " + acjdfni.getJDFNImport(z).isSelfReferencing()); sopl("\tisDuplicate()= " + acjdfni.getJDFNImport(z).isDuplicate()); if(acjdfni.getJDFNImport(z).isSpecific()) { sopl("\tisSubImport()= " + acjdfni.getJDFNISpecific(z).isSubImport()); sopl("\tisUnneeded()= " + acjdfni.getJDFNISpecific(z).isUnneeded()); } } sopl(sES + z + " total"); //Debugging...END **/ //Report on all errors, based on the state of each //JDFNImport. For error documentation and precedence, //see the main JavaDoc for this class. for(int j = 0; j < acjdfni.size(); j++) { char cErrorCode = ' '; //Is this import statement self-referencing? //(both star and specific) if(acjdfni.getJDFNImport(j).isSelfReferencing()) { //Self-referencing trumps everything but duplicate. if(acjdfni.getJDFNImport(j).isDuplicate()) { //Both self-referencing AND duplicate. cErrorCode = 'F'; } else { //Just self-referencing. cErrorCode = 'f'; } } //It is not self-referencing. //Check only specific imports for unneeded-ness, and //sub-import-ed-ness. if(cErrorCode == ' ' && acjdfni.getJDFNImport(j).isSpecific()) { if(acjdfni.getJDFNISpecific(j).isUnneeded()) { //Unneeded trumps sub-import (but not self- //referencing). if(acjdfni.getJDFNISpecific(j).isDuplicate()) { //Both self-referencing AND duplicate. cErrorCode = 'X'; } else { //Just self-referencing. cErrorCode = 'x'; } } //It is not unneeded. Is it a sub-import? if(cErrorCode == ' ' && acjdfni.getJDFNISpecific(j).isSubImport()) { //Unneeded trumps sub-import (but not self- //referencing). if(acjdfni.getJDFNISpecific(j).isDuplicate()) { //Both self-referencing AND duplicate. cErrorCode = 'I'; } else { //Just self-referencing. cErrorCode = 'i'; } } //It is not a sub-import. } //This import statement is definitely not self- //referencing, unneeded, nor is it a sub-import. Is //it a duplicate? if(cErrorCode == ' ' && acjdfni.getJDFNImport(j).isDuplicate()) { //Yup, it's duplicate. cErrorCode = 'd'; } //Done getting error codes for this import. Report. if(cErrorCode != ' ') { //This import statement is in error somehow, some way. iErrors++; optr_dbg.writeNoln(new Character(cErrorCode).toString()); sbClassErr.append(" " + cErrorCode + " " + acjdfni.getJDFNImport(j).getName() + sLINE_SEP); } else { iValid++; optr_dbg.writeNoln("."); } } if(sbClassErr.length() > 0) { //There is at least one error for this class. sbErrors.append(f.getPath() + sLINE_SEP + sbClassErr + sLINE_SEP); sbClassErr.setLength(0); } optr_dbg.newln(); } //Recursion. Only call again for sub-directories. for(int i = 0; i < df.getCountSubDirs(); i++) { optr_dbg.write(sDebugPfx + "[" + df.getSubDir(i).getFileObjectThis().getName() + "]"); analyzeFiles(optr_dbg, df.getSubDir(i)); } } } class FFJava implements FileFilter { public boolean accept(File f_ile) { if(f_ile.isDirectory() && !f_ile.getName().toLowerCase().startsWith("cvs") && !f_ile.getName().toLowerCase().endsWith("cvs")) { return true; } if(f_ile.getPath().toLowerCase().endsWith(".java")) { return true; } else { return false; } } } /** Represents an import statement. **/ class JDFNImport implements Named { private String sName = null; private boolean bDuplicate = false; private boolean bSelfReference = false; private JDFile jdf = null; public JDFNImport(String s_fqClassName) { jdf = new JDFile(s_fqClassName); sName = jdf.getList("."); } public final boolean isStar() { return getName().endsWith("*"); } public final boolean isSpecific() { return !isStar(); } public final String getName() { return sName; } public final JDFile getJDFile() { return jdf; } public final void declareDuplicate() { bDuplicate = true; } public final boolean isDuplicate() { return bDuplicate; } public final void declareSelfReference() { bSelfReference = true; } public final boolean isSelfReferencing() { return bSelfReference; } public final boolean isInSamePackageAs(JDFNImport jdfn_import) { return jdfn_import.getJDFile().isInSamePackageAs(getJDFile()); } } /** Represents a "specific" import statement. That is, an import statement that ends with anything other than ".*;" **/ class JDFNISpecific extends JDFNImport { private boolean bFound = false; private boolean bSubImport = false; public JDFNISpecific(String s_fqClassName) { super(s_fqClassName); } public final void declareFound() { bFound = true; } public final boolean wasFound() { return bFound; } public final boolean isUnneeded() { return !wasFound(); } public final void declareSubImport() { bSubImport = true; } public final boolean isSubImport() { return bSubImport; } } /** Represents a "star" import statement. That is, an import statement that ends with ".*;" This empty class is simply to make JDFNImport a "generic" name. The (way) above code is more clear because of it. **/ class JDFNIStar extends JDFNImport { public JDFNIStar(String s_fqClassName) { super(s_fqClassName); } } class ACjdfni extends VWObject { public final ACjdfni[] getAOACjdfn() { Object[] ao = getAOObject(); if(ao == null) { return null; } if(ao.length == 0) { return (new ACjdfni[0]); } //The array is at least one element in length. ACjdfni[] aACjdfn = new ACjdfni[ao.length]; for(int i = 0; i < aACjdfn.length; i++) { aACjdfn[i] = (ACjdfni)ao[i]; } return aACjdfn; } public final JDFNImport getJDFNImport(int i_dx) { return (JDFNImport)getObject(i_dx); } public final JDFNISpecific getJDFNISpecific(int i_dx) { return (JDFNISpecific)getJDFNImport(i_dx); } public final JDFNIStar getJDFNIStar(int i_dx) { return (JDFNIStar)getJDFNImport(i_dx); } }