| /* |
| * Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 6964768 6964461 6964469 6964487 6964460 6964481 6980021 |
| * @summary need test program to validate javac resource bundles |
| * @modules jdk.compiler/com.sun.tools.javac.code |
| * jdk.compiler/com.sun.tools.javac.resources:open |
| * jdk.jdeps/com.sun.tools.classfile |
| */ |
| |
| import java.io.*; |
| import java.lang.reflect.Layer; |
| import java.lang.reflect.Module; |
| import java.util.*; |
| import javax.tools.*; |
| import com.sun.tools.classfile.*; |
| import com.sun.tools.javac.code.Lint.LintCategory; |
| |
| /** |
| * Compare string constants in javac classes against keys in javac resource bundles. |
| */ |
| public class CheckResourceKeys { |
| /** |
| * Main program. |
| * Options: |
| * -finddeadkeys |
| * look for keys in resource bundles that are no longer required |
| * -findmissingkeys |
| * look for keys in resource bundles that are missing |
| * |
| * @throws Exception if invoked by jtreg and errors occur |
| */ |
| public static void main(String... args) throws Exception { |
| CheckResourceKeys c = new CheckResourceKeys(); |
| if (c.run(args)) |
| return; |
| |
| if (is_jtreg()) |
| throw new Exception(c.errors + " errors occurred"); |
| else |
| System.exit(1); |
| } |
| |
| static boolean is_jtreg() { |
| return (System.getProperty("test.src") != null); |
| } |
| |
| /** |
| * Main entry point. |
| */ |
| boolean run(String... args) throws Exception { |
| boolean findDeadKeys = false; |
| boolean findMissingKeys = false; |
| |
| if (args.length == 0) { |
| if (is_jtreg()) { |
| findDeadKeys = true; |
| findMissingKeys = true; |
| } else { |
| System.err.println("Usage: java CheckResourceKeys <options>"); |
| System.err.println("where options include"); |
| System.err.println(" -finddeadkeys find keys in resource bundles which are no longer required"); |
| System.err.println(" -findmissingkeys find keys in resource bundles that are required but missing"); |
| return true; |
| } |
| } else { |
| for (String arg: args) { |
| if (arg.equalsIgnoreCase("-finddeadkeys")) |
| findDeadKeys = true; |
| else if (arg.equalsIgnoreCase("-findmissingkeys")) |
| findMissingKeys = true; |
| else |
| error("bad option: " + arg); |
| } |
| } |
| |
| if (errors > 0) |
| return false; |
| |
| Set<String> codeStrings = getCodeStrings(); |
| Set<String> resourceKeys = getResourceKeys(); |
| |
| if (findDeadKeys) |
| findDeadKeys(codeStrings, resourceKeys); |
| |
| if (findMissingKeys) |
| findMissingKeys(codeStrings, resourceKeys); |
| |
| return (errors == 0); |
| } |
| |
| /** |
| * Find keys in resource bundles which are probably no longer required. |
| * A key is probably required if there is a string fragment in the code |
| * that is part of the resource key, or if the key is well-known |
| * according to various pragmatic rules. |
| */ |
| void findDeadKeys(Set<String> codeStrings, Set<String> resourceKeys) { |
| String[] prefixes = { |
| "compiler.err.", "compiler.warn.", "compiler.note.", "compiler.misc.", |
| "javac." |
| }; |
| for (String rk: resourceKeys) { |
| // some keys are used directly, without a prefix. |
| if (codeStrings.contains(rk)) |
| continue; |
| |
| // remove standard prefix |
| String s = null; |
| for (int i = 0; i < prefixes.length && s == null; i++) { |
| if (rk.startsWith(prefixes[i])) { |
| s = rk.substring(prefixes[i].length()); |
| } |
| } |
| if (s == null) { |
| error("Resource key does not start with a standard prefix: " + rk); |
| continue; |
| } |
| |
| if (codeStrings.contains(s)) |
| continue; |
| |
| // keys ending in .1 are often synthesized |
| if (s.endsWith(".1") && codeStrings.contains(s.substring(0, s.length() - 2))) |
| continue; |
| |
| // verbose keys are generated by ClassReader.printVerbose |
| if (s.startsWith("verbose.") && codeStrings.contains(s.substring(8))) |
| continue; |
| |
| // mandatory warning messages are synthesized with no characteristic substring |
| if (isMandatoryWarningString(s)) |
| continue; |
| |
| // check known (valid) exceptions |
| if (knownRequired.contains(rk)) |
| continue; |
| |
| // check known suspects |
| if (needToInvestigate.contains(rk)) |
| continue; |
| |
| //check lint description keys: |
| if (s.startsWith("opt.Xlint.desc.")) { |
| String option = s.substring(15); |
| boolean found = false; |
| |
| for (LintCategory lc : LintCategory.values()) { |
| if (option.equals(lc.option)) |
| found = true; |
| } |
| |
| if (found) |
| continue; |
| } |
| |
| error("Resource key not found in code: " + rk); |
| } |
| } |
| |
| /** |
| * The keys for mandatory warning messages are all synthesized and do not |
| * have a significant recognizable substring to look for. |
| */ |
| private boolean isMandatoryWarningString(String s) { |
| String[] bases = { "deprecated", "unchecked", "varargs" }; |
| String[] tails = { ".filename", ".filename.additional", ".plural", ".plural.additional", ".recompile" }; |
| for (String b: bases) { |
| if (s.startsWith(b)) { |
| String tail = s.substring(b.length()); |
| for (String t: tails) { |
| if (tail.equals(t)) |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| Set<String> knownRequired = new TreeSet<String>(Arrays.asList( |
| // See Resolve.getErrorKey |
| "compiler.err.cant.resolve.args", |
| "compiler.err.cant.resolve.args.params", |
| "compiler.err.cant.resolve.location.args", |
| "compiler.err.cant.resolve.location.args.params", |
| "compiler.misc.cant.resolve.location.args", |
| "compiler.misc.cant.resolve.location.args.params", |
| // JavaCompiler, reports #errors and #warnings |
| "compiler.misc.count.error", |
| "compiler.misc.count.error.plural", |
| "compiler.misc.count.warn", |
| "compiler.misc.count.warn.plural", |
| // Used for LintCategory |
| "compiler.warn.lintOption", |
| // Other |
| "compiler.misc.base.membership" // (sic) |
| )); |
| |
| |
| Set<String> needToInvestigate = new TreeSet<String>(Arrays.asList( |
| "compiler.misc.fatal.err.cant.close.loader", // Supressed by JSR308 |
| "compiler.err.cant.read.file", // UNUSED |
| "compiler.err.illegal.self.ref", // UNUSED |
| "compiler.err.io.exception", // UNUSED |
| "compiler.err.limit.pool.in.class", // UNUSED |
| "compiler.err.name.reserved.for.internal.use", // UNUSED |
| "compiler.err.no.match.entry", // UNUSED |
| "compiler.err.not.within.bounds.explain", // UNUSED |
| "compiler.err.signature.doesnt.match.intf", // UNUSED |
| "compiler.err.signature.doesnt.match.supertype", // UNUSED |
| "compiler.err.type.var.more.than.once", // UNUSED |
| "compiler.err.type.var.more.than.once.in.result", // UNUSED |
| "compiler.misc.non.denotable.type", // UNUSED |
| "compiler.misc.unnamed.package", // should be required, CR 6964147 |
| "compiler.warn.proc.type.already.exists", // TODO in JavacFiler |
| "javac.err.invalid.arg", // UNUSED ?? |
| "javac.opt.arg.class", // UNUSED ?? |
| "javac.opt.arg.pathname", // UNUSED ?? |
| "javac.opt.moreinfo", // option commented out |
| "javac.opt.nogj", // UNUSED |
| "javac.opt.printsearch", // option commented out |
| "javac.opt.prompt", // option commented out |
| "javac.opt.s" // option commented out |
| )); |
| |
| /** |
| * For all strings in the code that look like they might be fragments of |
| * a resource key, verify that a key exists. |
| */ |
| void findMissingKeys(Set<String> codeStrings, Set<String> resourceKeys) { |
| for (String cs: codeStrings) { |
| if (cs.matches("[A-Za-z][^.]*\\..*")) { |
| // ignore filenames (i.e. in SourceFile attribute |
| if (cs.matches(".*\\.java")) |
| continue; |
| // ignore package and class names |
| if (cs.matches("(com|java|javax|jdk|sun)\\.[A-Za-z.]+")) |
| continue; |
| if (cs.matches("(java|javax|sun)\\.")) |
| continue; |
| // ignore debug flag names |
| if (cs.startsWith("debug.")) |
| continue; |
| // ignore should-stop flag names |
| if (cs.startsWith("should-stop.")) |
| continue; |
| // ignore diagsformat flag names |
| if (cs.startsWith("diags.")) |
| continue; |
| // explicit known exceptions |
| if (noResourceRequired.contains(cs)) |
| continue; |
| // look for matching resource |
| if (hasMatch(resourceKeys, cs)) |
| continue; |
| error("no match for \"" + cs + "\""); |
| } |
| } |
| } |
| // where |
| private Set<String> noResourceRequired = new HashSet<String>(Arrays.asList( |
| // module names |
| "jdk.compiler", |
| "jdk.javadoc", |
| // system properties |
| "application.home", // in Paths.java |
| "env.class.path", |
| "line.separator", |
| "os.name", |
| "user.dir", |
| // file names |
| "ct.sym", |
| "rt.jar", |
| "jfxrt.jar", |
| "module-info.class", |
| "jrt-fs.jar", |
| // -XD option names |
| "process.packages", |
| "ignore.symbol.file", |
| "fileManager.deferClose", |
| // prefix/embedded strings |
| "compiler.", |
| "compiler.misc.", |
| "opt.Xlint.desc.", |
| "count.", |
| "illegal.", |
| "java.", |
| "javac.", |
| "verbose.", |
| "locn." |
| )); |
| |
| /** |
| * Look for a resource that ends in this string fragment. |
| */ |
| boolean hasMatch(Set<String> resourceKeys, String s) { |
| for (String rk: resourceKeys) { |
| if (rk.endsWith(s)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Get the set of strings from (most of) the javac classfiles. |
| */ |
| Set<String> getCodeStrings() throws IOException { |
| Set<String> results = new TreeSet<String>(); |
| JavaCompiler c = ToolProvider.getSystemJavaCompiler(); |
| try (JavaFileManager fm = c.getStandardFileManager(null, null, null)) { |
| JavaFileManager.Location javacLoc = findJavacLocation(fm); |
| String[] pkgs = { |
| "javax.annotation.processing", |
| "javax.lang.model", |
| "javax.tools", |
| "com.sun.source", |
| "com.sun.tools.javac" |
| }; |
| for (String pkg: pkgs) { |
| for (JavaFileObject fo: fm.list(javacLoc, |
| pkg, EnumSet.of(JavaFileObject.Kind.CLASS), true)) { |
| String name = fo.getName(); |
| // ignore resource files, and files which are not really part of javac |
| if (name.matches(".*resources.[A-Za-z_0-9]+\\.class.*") |
| || name.matches(".*CreateSymbols\\.class.*")) |
| continue; |
| scan(fo, results); |
| } |
| } |
| return results; |
| } |
| } |
| |
| // depending on how the test is run, javac may be on bootclasspath or classpath |
| JavaFileManager.Location findJavacLocation(JavaFileManager fm) { |
| JavaFileManager.Location[] locns = |
| { StandardLocation.PLATFORM_CLASS_PATH, StandardLocation.CLASS_PATH }; |
| try { |
| for (JavaFileManager.Location l: locns) { |
| JavaFileObject fo = fm.getJavaFileForInput(l, |
| "com.sun.tools.javac.Main", JavaFileObject.Kind.CLASS); |
| if (fo != null) |
| return l; |
| } |
| } catch (IOException e) { |
| throw new Error(e); |
| } |
| throw new IllegalStateException("Cannot find javac"); |
| } |
| |
| /** |
| * Get the set of strings from a class file. |
| * Only strings that look like they might be a resource key are returned. |
| */ |
| void scan(JavaFileObject fo, Set<String> results) throws IOException { |
| InputStream in = fo.openInputStream(); |
| try { |
| ClassFile cf = ClassFile.read(in); |
| for (ConstantPool.CPInfo cpinfo: cf.constant_pool.entries()) { |
| if (cpinfo.getTag() == ConstantPool.CONSTANT_Utf8) { |
| String v = ((ConstantPool.CONSTANT_Utf8_info) cpinfo).value; |
| if (v.matches("[A-Za-z0-9-_.]+")) |
| results.add(v); |
| } |
| } |
| } catch (ConstantPoolException ignore) { |
| } finally { |
| in.close(); |
| } |
| } |
| |
| /** |
| * Get the set of keys from the javac resource bundles. |
| */ |
| Set<String> getResourceKeys() { |
| Module jdk_compiler = Layer.boot().findModule("jdk.compiler").get(); |
| Set<String> results = new TreeSet<String>(); |
| for (String name : new String[]{"javac", "compiler"}) { |
| ResourceBundle b = |
| ResourceBundle.getBundle("com.sun.tools.javac.resources." + name, jdk_compiler); |
| results.addAll(b.keySet()); |
| } |
| return results; |
| } |
| |
| /** |
| * Report an error. |
| */ |
| void error(String msg) { |
| System.err.println("Error: " + msg); |
| errors++; |
| } |
| |
| int errors; |
| } |
